# si-001 read the first product: a drawing where every line says how it is known. one page — `index.html` — opens a folder and draws it. a folder is the reference as it arrived and a log of what was said; the drawing is the reference with the log replayed. nothing else. ``` product/ index.html the app. ?src= opens it; ?turn=N replays its log to message N; &play goes on from there by itself, once it is on screen app.js the page: the thread, the drawing, the sheet; the ask at a point; the hand, the voice, the pen log.js the log: replay(n), a message as html, and the quotation — any [data-log] element quotes a moment, mounted when the page is read and drawn as it comes near, data-show="ask" the drawing with that moment's question standing on its member renderer.js the drawing. every line an entity: kind, layer, and how it is known. it never sets state ../design/sheet.js the marks, and words landing. drawn once for the site, the deck and the product ../design/styles.css one stylesheet. the thread, the citation, the checker's list are sheet vocabulary floor-73/ a folder the app opens model.json the reference, as it arrived: the slab measured off a published drawing, the core, four facts. 1 kB core.json the owner's core linework, 4,072 paths, fetched once, after the framing is on screen log.json the session: sixteen messages in order. a message that changed the drawing carries the change build.py the demo session. writes model.json, core.json and log.json from source/ source/ the package as it arrived SOURCES.md what the package is right about, wrong about, and whose it is brooklyn-bridge/ a second folder, and the opposite case: an elevation of a bridge that was measured, so the drawing is ink and the blue is only what the measured sheet leaves out. ?src=brooklyn-bridge build.py writes model.json and log.json from ../design/brooklyn-bridge/geometry.py. twelve messages SOURCES.md what is ink, what is blue and why, and where the redline's two numbers come from joint/ a third folder and the third scale: a braced-frame connection detail, in inches. the members are ink, every plate and bolt is blue. geometry imported from ../design/joint/draw.py. eleven messages. ?src=joint ``` the site and the deck quote this folder instead of describing it: `
` is message 8 as it landed, `data-show="drawing"` the floor as it was after it, drawn by the same renderer, and `data-show="ask" data-ask="9"` that floor with message 9 standing on the member it is about, on a leader — the slide that says the engineer asks inside the drawing shows it instead of describing it. `site/product.html` and deck slides 021, 055 and 155–161 are made of these. the single member, the ask at a point, one of the two citations and the signature quote the bridge, the seven weights and the redline quote the joint, the rest the floor: the product opens a folder, and one folder everywhere said it opens a floor. there are no pictures of the product anywhere; there is the product, at a moment. ## the page three panes on a sheet. the thread on the left: what was asked, what the machine said, its reasoning with the drawing it read, the redline, the signature. the ask is one box in two positions: at the foot of the thread with nothing chosen, and on the drawing, a leader down to a work point on the member, the moment there is one. the drawing in the middle, the whole height, pan and zoom, click a member. the sheet on the right: the answer to what you clicked, the layers, the checker's list, what was learned. a folder with a `log.json` opens as it arrived, before anything was said. next lets the following message in the way it was made: the engineer's line is typed into the ask, letter by letter, and sent; the machine's words land whole, one after another — subtitles, not typing — and what it drew is drawn under them at pen speed, one member after the other, the way a pen would. play walks the whole log with a beat between messages; back jumps; `?turn=N` is a link to a moment. the ask box holds the engineer's next line, not yet sent. a folder without a log is the drawing alone — the same page with nothing else on. a member is anything with an id: a line answers along its length, and a ring — a tower, a cable's parabola — along its edge. ## the log the log is the truth and the drawing is derived. `model.json` is only what arrived. every message is `{ kind: ask | said | redline | signed, who, at, text: [..] }` and may carry: ``` adds: { grid, support, slab, entities: [..] } what this message drew changes: [ { id, section, picked, .. } ] what it changed, by member member, mark a redline: the member it points at, and the words on the drawing signs: "D. Ruiz, PE" every assumed member becomes drawn, signed by done, learned, held, cite, log, label, after what it said about the work: steps that hold, a rule kept, what it could not resolve, the reasoning with the drawing it read ``` the model at message n is the reference plus messages 1..n applied in order — `replay(n)` in `log.js`, thirty lines. between two messages the drawing on screen is the last one plus what the next drew, part way: an entity carries `p`, how much of it the pen has covered, and the renderer draws that much of a line, a ring, a circle. a pen has one speed — 700 feet a second here — and lines draw linear, never eased. when it stops, `p` is gone and the drawing is `replay(n)` again. a `cite` is drawn from the same replay, still, with only the layers the claim is about. there is no `state`, no `only`, no `select` in any file the app reads: what you see is what happened, and what you click is yours. this is what makes it an app rather than a storyboard. the demo is a log `build.py` wrote; the product is the same log a machine appends to. the ask box appends a message; a redline is a message; signing is a message. the app cannot tell the difference, and there is nothing to switch on later except who writes the next line. ## the decisions **one page, folders it opens.** the first draft was seven html files, each hardcoding one state of the same drawing, and a separate viewer for the floor alone. the second was one page performing a `task.json` of director's notes — show these layers, select this, mark that. now there are no notes: the log is the content, the drawing is replayed from it, and the viewer is the app with no log. one renderer, one shell, one grammar. **the drawing is the product.** `renderer.js` lives here, not in `design/`, because a drawing that says how it is known is what *read* is. the site reaches into `../product/renderer.js` to draw with it; that is the right direction — the site shows the product, not pictures of it. **the three states are the product.** `drawn` in ink, `reference` in grey, `assumed` in blue. that is `design/COLOR.md`, and it is exactly the promise: what the machine drew is blue until an engineer signs it. the renderer draws a member's `marked` and `picked` and never sets them; a redline message marks, a pick-up message changes, a signed message signs. the renderer has no verbs. **colour is the interface.** the five pens of `../design/COLOR.md`, no sixth: red only the engineer writes, yellow is the mark for done. no green: in a structural program green already means under capacity. **the ask stands at the point.** a question about a beam is not typed in a box across the room from it; a checker writes it on the sheet, at the member, on a leader. so there is one ask, and it goes where the question is — click a member and the box moves onto the drawing above it, `esc` and it falls back to the foot of the thread. the leader is the engineer's line: ink, and red only when the engineer is writing red. it hangs off `at(member)` in the renderer and the renderer's `view` event, so pan and zoom carry it. the renderer still has no verbs. **citation is not a feature.** a reasoning card is two columns: the drawing on the left in the state it was read, the claim on the right. the machine cannot say something without showing where it read it. **pre-flight.** turn 2 does not exist in the working product and it is the highest-value turn here. before three minutes of work the machine says what is published on this floor (two numbers) and that everything else will be assumed. **what it could not resolve is shown while it works.** b1-040 spans 52'-3" against a published maximum of 47'. it is held when the framing is done at message 8, explained at 12, still held after the pick-up at 14, and settled by the engineer at 15. one thread, never buried. **learning is the redline.** no settings screen, no onboarding form. read everything the office has signed, then read the red. message 13 marks one beam and 14 picks up the 34 others that match, thirty-five in all; the rule joins the office standard. **the signature is the only irreversible act,** and the only place the seal appears. a message with `signs` turns every assumed member to drawn, blue to ink, and the title block says who and when. the seal is the one thing that arrives from off the sheet: it scales down and lands hard, once, in a quarter second. **the marks do their own jobs.** bubbles in the title block say the company. a bubble numbers a turn the way a bubble numbers a detail. the work point sits on a checked line. the seal signs. nothing is said twice. ## honest about the floor the members are a reconstruction; the sizes are demonstration sizes; the owner withheld the real ones. the title block says *reconstruction, not for construction* because the drawing says so about itself, and the product's whole claim is that a drawing should. the core linework is © the durst organization, kept as reference and credited. see `floor-73/SOURCES.md`. ## open - the name. `read` is a placeholder that matches the first of the three questions the brand asks. - the ask box shows the next line and does not yet send one. anchored, it is where a redline would be written, and sending one is the same message with a `member` on it. sending is appending a message to the log; answering is a machine appending the next. the page is finished for both. - the app asks a logless folder for `log.json` and gets a 404. honest, and the only noise in the console.