# floor 73, and what the renderer opens

a floor the product opens. `../index.html?src=floor-73` is the app on it; `../renderer.js` is the drawing. `model.json` is only what arrived; `log.json` is what happened to it, message by message, and every member the machine drew is in the message that drew it. drawn the way a set is drawn:
ink for the drawing, grey for what is already there, and blue the moment you ask what the
machine assumed. nothing on the screen is a picture of a plan. every line is an entity, and
clicking it gets the answer: what it is, what it spans, what layer it sits on, and how it is
known.

three states, and only three, because a drawing that cannot say which of the three a line is
cannot be checked:

| state | what it means | how it is drawn |
|---|---|---|
| `drawn` | published, or measured off a published drawing | ink |
| `reference` | lifted from someone else's sheet, kept as context, not ours | grey, halftone |
| `assumed` | the machine put it there. no engineer has signed it | blue, and only when asked |

`build.py` writes three files from `source/`. run `python3 build.py`.

- `model.json`, 1 kB: the reference. the slab octagon, the core, the four published facts.
- `log.json`, 42 kB: the session. sixteen messages; the datums, the core envelope and the 131
  members are in the messages that drew them. small enough to open and read.
- `core.json`, 255 kB: the owner's core linework, 4,072 paths. someone else's drawing, so it
  is its own file, and the renderer fetches it after the framing is already on screen.

both are in feet. the core is written relative, in hundredths of a foot — an eighth of an
inch, finer than the brochure it was scaled off — and the pen is carried as the integer it
just wrote, so the rounding never walks down the path. worst error anywhere: 0.06 in.

## what is in source/

a floor 73 framing package, revision 02, produced by an engineer prompting gpt astra,
september 7 2026. it arrives in three coordinate spaces — entities in feet, the plotted sheet
in points, the core linework in the pixels of the page it was lifted from — and `build.py`
puts all three in feet, y up, origin at the centre of the floor plate. the 42 x 30 in sheet
plots at 9 points to the foot; the core pixels are fitted to it by the seventeen corners of
the three clip masks the package already agrees on. the fit is one scale and one offset per
axis, and it lands on the support envelope to the foot.

| file | what |
|---|---|
| `framing-model.json` | 131 entities in feet: 99 beams and girders in four families, 32 perimeter columns |
| `core-reference-paths.json.gz` | 4,072 vector paths of the core, clipped out of the owner's leasing plan, in page pixels |
| `S-073-floor-framing.svg.gz` | the plotted sheet, 42 x 30 in, layered `S-BEAM` `S-GIRDER` `S-COL` `S-GRID` `S-SLAB` `S-WALL` `S-ANNO` `A-CORE-REFERENCE` |
| `S-073-floor-framing.pdf` | the same sheet, printable |
| `README-R02.md`, `WEBSITE-PROMPT.md`, `VALIDATION.json` | its own account of itself, and its checks |
| `S-073-preview.png`, `framing-plan-detail.png` | previews |

the two big text files are kept gzipped, and `build.py` reads them that way. this is not
housekeeping: bike draws a card for every file it can render, and a 1.5 mb sheet of 56,000
elements is a card that never finishes. a folder is only as fast as the heaviest thing in it
that something will try to draw.

the 10 mb dxf that came with it is not here. the geometry is in the json; the dxf is on the
desktop if a cad check ever needs it.

## what the package is right about

it carries the thing almost no generated drawing carries: **every member says how it is known.**
a section is not a string, it is a string plus `synthetic_demo_size_unverified`. the core
linework is not merged into the structure, it is a separate layer named `A-CORE-REFERENCE`
with the instruction not to classify its doors and shafts as structural walls. it ships a
`VALIDATION.json` that says what was checked and, in one field, what was not: *"drafting,
geometry and file checks only. no capacity analysis or as-built verification."*

that is the whole discipline of a check print, in a json file. the renderer takes it and makes
it visible instead of legible-in-metadata.

## what it is wrong about

the sizes. `W24x68`, `W18x40`, `W30x116`, `W24x84` are invented. the beam layout is invented:
56 orthogonal beams where the owner's plan shows none. the column spacing is inferred from a
leasing plan drawn for a broker.

one world trade center's member data is withheld. the trade press that covered the structure
printed an editor's note that the grade, size and type of the steel were left out on the
owner's instruction (metals in construction, spring 2015). a sheet that fills that silence
with plausible w-shapes is not a drawing of this building. it is a drawing of a building
shaped like it.

so the sizes are not deleted here and they are not promoted. they are drawn, and they are
`assumed`, and the moment anyone asks, 131 of 131 members go blue. that is the honest reading
of this package, and it is also the product: the machine drew it, no engineer signed it, and
the drawing says so itself.

the two things that are not blue are the two things somebody published: 13'-4" slab to slab,
and the 47 ft maximum span from core face to perimeter. see `../../design/one-wtc/SOURCES.md`.

## rights

the core reference linework is © the durst organization, from the owner's floor 73 leasing
brochure, and is kept as reference, credited, not represented as ours. the framing is a
reconstruction. neither is for construction.