@floless/app 0.62.0 → 0.64.0

package/dist/floless-server.cjs

@@ -53022,7 +53022,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.62.0" : void 0,
+    define: true ? "0.64.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -53032,7 +53032,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.62.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.64.0" : void 0 });
 }
 
 // workflow-update.ts
@@ -64076,7 +64076,7 @@ async function startServer() {
     { bodyLimit: 25 * 1024 * 1024 },
     // contracts embed rasters (matches PUT /api/contract) — the editor POSTs the live contract on every 3D rebuild
     async (req, reply) => {
-      const doc = req.body && "contract" in req.body ? req.body.contract : readContract(req.params.appId);
+      const doc = req.body && "contract" in req.body ? req.body.contract : readContractForApp(req.params.appId);
       if (doc == null) return reply.status(404).send({ ok: false, error: "no contract to render" });
       if (doc && typeof doc === "object" && doc.type === "drawing.vector/v1") {
         const cleaned = postProcess(doc);

package/dist/schemas/steel.takeoff.v1.schema.json

@@ -43,6 +43,24 @@
     "dims3d": { "type": "array", "items": { "$ref": "#/$defs/dim3" }, "description": "Draft-only 3D dimensions (editor annotations, model-global). World-scene mm. NOT baked into the lock / 3D scene / IFC / BOM." }
   },
   "$defs": {
+    "grid": {
+      "type": ["object", "null"],
+      "required": ["origin"],
+      "additionalProperties": true,
+      "description": "Structural grid: X/Y are RELATIVE spacing strings (Tekla syntax — \"0 3*25' 20'-6\\\"\", n*d repeats a bay; tokens accept ft-in / inches / m / bare mm), Z is ABSOLUTE elevations. X entries space lines along +X (lines vertical on the plan, auto-labels 1,2,3…); Y entries march UP the sheet (lines horizontal, auto-labels A,B,C…). web/grid-core.js is the parser/geometry source of truth.",
+      "properties": {
+        "on": { "type": "boolean", "description": "Grid visible (2D + 3D). Default true." },
+        "origin": { "$ref": "#/$defs/point2", "description": "The [1,A] corner, display space (same space as member wp)." },
+        "x": { "type": "string", "description": "Relative spacings along +X, e.g. \"0 3*25'\"." },
+        "y": { "type": "string", "description": "Relative spacings up the sheet, e.g. \"0 4*30'\"." },
+        "z": { "type": "string", "description": "Absolute level elevations, e.g. \"0 16'-6\\\"\"." },
+        "labels_x": { "type": "string", "description": "Whitespace-separated label overrides for X lines; blank = auto 1,2,3…" },
+        "labels_y": { "type": "string", "description": "Whitespace-separated label overrides for Y lines; blank = auto A,B,C…" },
+        "ext": { "type": "number", "description": "How far lines run past the outermost line, in mm. Default 5'." },
+        "ends_x": { "type": "object", "description": "Per-line extent overrides for X lines: { \"<line index>\": [lo, hi] } display px along the line (a partial line like a 5.1 insert covering one wing). null / absent element = the auto full span. Set by dragging a bubble along its line." },
+        "ends_y": { "type": "object", "description": "Per-line extent overrides for Y lines — same shape as ends_x." }
+      }
+    },
     "filter": {
       "type": "object",
       "additionalProperties": true,
@@ -111,18 +129,21 @@
         },
         "elements": {
           "type": "array",
-          "description": "Every drawing element: lines (with an SVG path `d`) and text spans (with `text`+`bbox`), each tagged layer/thickness/colour.",
+          "description": "Every drawing element: lines (with an SVG path `d`), text spans (with `text`+`bbox`) and circles (`cx`/`cy`/`r` — grid bubbles, callout balloons), each tagged layer/thickness/colour.",
           "items": {
             "type": "object",
             "additionalProperties": true,
             "properties": {
-              "kind": { "enum": ["line", "text"] },
+              "kind": { "enum": ["line", "text", "circle"] },
               "layer": { "type": "string" },
               "w": { "type": "number" },
               "color": { "type": "string" },
               "d": { "type": "string", "description": "SVG path (line elements)." },
               "text": { "type": "string", "description": "Label text (text elements)." },
               "bbox": { "type": "array", "items": { "type": "number" }, "description": "[x0,y0,x1,y1] (text elements)." },
+              "cx": { "type": "number", "description": "Circle centre X (circle elements)." },
+              "cy": { "type": "number", "description": "Circle centre Y (circle elements)." },
+              "r": { "type": "number", "description": "Circle radius (circle elements)." },
               "dashed": { "type": "boolean" }
             }
           }
@@ -150,18 +171,21 @@
         "steelBbox": { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] of this sheet's steel linework, for Zoom-to-steel." },
         "elements": {
           "type": "array",
-          "description": "This sheet's drawing elements: lines (SVG path `d`) and text spans (`text`+`bbox`), each tagged layer/thickness/colour.",
+          "description": "This sheet's drawing elements: lines (SVG path `d`), text spans (`text`+`bbox`) and circles (`cx`/`cy`/`r` — grid bubbles feed the editor's grid-from-drawing detector), each tagged layer/thickness/colour.",
           "items": {
             "type": "object",
             "additionalProperties": true,
             "properties": {
-              "kind": { "enum": ["line", "text"] },
+              "kind": { "enum": ["line", "text", "circle"] },
               "layer": { "type": "string" },
               "w": { "type": "number" },
               "color": { "type": "string" },
               "d": { "type": "string" },
               "text": { "type": "string" },
               "bbox": { "type": "array", "items": { "type": "number" } },
+              "cx": { "type": "number" },
+              "cy": { "type": "number" },
+              "r": { "type": "number" },
               "dashed": { "type": "boolean" }
             }
           }
@@ -236,7 +260,8 @@
         "tos_callouts": { "type": "array", "items": { "$ref": "#/$defs/tos_callout" } },
         "members": { "type": "array", "items": { "$ref": "#/$defs/member" } },
         "dims": { "type": "array", "items": { "$ref": "#/$defs/dim" }, "description": "Draft-only on-drawing dimensions (editor annotations). NOT baked into the lock / 3D / IFC / BOM." },
-        "frame": { "$ref": "#/$defs/frame" }
+        "frame": { "$ref": "#/$defs/frame" },
+        "grid": { "$ref": "#/$defs/grid", "description": "Structural grid lines (Tekla-style). PER-PLAN — its origin/spacings live in this sheet's display space (like frame/dims). A plan REFERENCE the editor renders in 2D + 3D and snaps to — it never constrains members and is NOT baked into the lock / IFC / BOM." }
       }
     },
     "segment": {

package/dist/skills/floless-app-steel-takeoff/SKILL.md

@@ -2,7 +2,7 @@
 name: floless-app-steel-takeoff
 description: Read a structural steel drawing into an editable steel.takeoff/v1 contract in floless.app — the "Steel Takeoff" reader. Triggers on a pending floless `rebake` request for the `steel-model` app (queued from its "Re-read & re-bake ▸" button), or asks like "read this framing plan into a takeoff", "turn this structural drawing into a takeoff", "bake my drawing into steel-model", "extract members from this PDF". Teaches the host AI to READ a steel drawing (PDF/image) with its own vision at COMPOSE time, build a steel.takeoff/v1 contract (members + profiles + elevations + weights from AISC lookup), write it to the contract store, and hand control to the editor — no model in the run path, no API key.
 metadata:
-  version: 0.3.0
+  version: 0.4.0
 ---
 
 # Steel Takeoff — read a drawing into a steel.takeoff/v1 contract
@@ -80,6 +80,11 @@ native/display coords):
    pt>, color:<#rrggbb stroke>, d:<SVG path>, dashed:<bool> }`.
 2. **Text** — `page.get_text("dict")`: per span keep `{ kind:"text", layer:<OCG>, w:0, color:<#hex>,
    text:<string>, bbox:[x0,y0,x1,y1] }`.
+2b. **Circles** — a closed bezier path whose bbox is round (width ≈ height, ≥ ~8 pt across) becomes
+   `{ kind:"circle", cx:<centre x>, cy:<centre y>, r:<radius> }` in display space. These are the grid
+   bubbles and callout balloons; the editor's **grid-from-drawing** detector (`web/grid-core.js`
+   `gridFromDrawing`) anchors grid lines to them, so skipping circles silently disables the Grid
+   panel's "From drawing" button.
 3. **Per-sheet entry** — push `{ sheet:<number>, title:<name?>, page:{ w, h, bg_b64, rect }, steelBbox,
    elements:[…] }` onto `filter.sheets`. `bg_b64` is a dimmed raster of THIS sheet's framing area
    (**title block excluded** — CONFIDENTIAL, machine-local, never committed). **`page.rect` = the exact
@@ -96,6 +101,29 @@ native/display coords):
 5. Set `filter.mode: "layer"`, `filter.active: 0`. **PUT** the contract
    (`PUT /api/contract/steel-model`). On a re-read, preserve any existing per-facet `on` flags.
 
+### 1c. Grid lines — read the printed grid (quick, per sheet)
+
+With the filter elements in hand, populate each plan's **`plan.grid`** (Tekla-style grid lines the
+editor renders in 2D + 3D and snaps to). The geometry is deterministic — the editor's Grid panel has
+a "From drawing" button running the same detector (`web/grid-core.js` `gridFromDrawing`: grid lines
+are the long dash-dot line fields that AIM at a bubble circle's centre and STOP at its edge; bubbles
+line up in a row along one sheet edge and columns along the sides). What the detector usually can't
+get is the **labels** — CAD sets outline their text, so bubble marks like `5.1` / `K.1` aren't in the
+text layer. You CAN read them: you already have vision on the sheet. So:
+
+1. Derive the line positions (or let the user press "From drawing" later — same result).
+2. **Vision-read each bubble's mark** from the sheet render, in line order.
+3. Write `plan.grid = { on:true, origin:[x,y], x:"0 3*25' …", y:"…", z:"0", labels_x:"K J H …",
+   labels_y:"0.5 1 1.1 …", ext:<mm> }` — origin = the left-most × bottom-most line crossing,
+   spacings are RELATIVE ft-in tokens (`n*d` repeats a bay), labels are whitespace-separated
+   overrides in line order (X: left→right; Y: bottom→up). Sanity-check a bay or two against the
+   printed dimension strings between grid lines — a mismatch means the sheet scale (`pt_per_ft`) is
+   wrong, which corrupts the whole takeoff, not just the grid. **Then PUT the contract again** —
+   the 1b PUT already happened, and the user's next Filter-node Save writes back the contract *it
+   loaded*; an un-PUT grid (and its vision-read labels) would be silently dropped.
+
+Skip silently only when the sheet genuinely has no grid bubbles (rare for framing plans); say so.
+
 **Then STOP and hand off — checkpoint before the member read.** Tell the user to open the **Filter**
 node, flip through the sheets, narrow to the steel, and **Save**. The saved `on` flags + `mode` are
 what step 2 reads — **per sheet** (each sheet's elements passing `mode` + the global `on` flags). Only

package/dist/skills/floless-app-vectorize/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: floless-app-vectorize
-description: Vectorize a drawing into an editable drawing.vector/v1 contract in floless.app — the "Vectorize" reader. Triggers on a pending floless `rebake` request for the `vectorize` app (queued from its "Re-read & re-bake ▸" button), or asks like "vectorize this PDF", "turn my sketch into clean CAD linework", "read this detail into vectors", "trace this photo". Teaches the host AI to read a drawing at COMPOSE time — a vector PDF via ONE deterministic PyMuPDF pass (no LLM), a scan/photo/hand sketch via AWARE's fenced vision.extract (schema-bound, cached) — emit the drawing.vector/v1 contract, PUT it to the contract store, and hand the 2D vector editor to the user.
+description: Vectorize a drawing into an editable drawing.vector/v1 contract in floless.app — the "Vectorize" reader. Triggers on a pending floless `rebake` request for the `vectorize` app (queued from its "Re-read & re-bake ▸" button), or asks like "vectorize this PDF", "turn my sketch into clean CAD linework", "read this detail into vectors", "trace this photo", "make this drawing 3D". Teaches the host AI to read a drawing at COMPOSE time — a vector PDF via ONE deterministic PyMuPDF pass (no LLM), a scan/photo/hand sketch via AWARE's fenced vision.extract (schema-bound, cached) — emit the drawing.vector/v1 contract, PUT it to the contract store, and hand the 2D vector editor to the user; and, for a multi-view set (plan + elevation), to classify views, read datums, and declare entities so the server reconstructs a viewable 3D model.
 metadata:
-  version: 0.3.0
+  version: 0.4.0
 ---
 
 # Vectorize — read a drawing into a drawing.vector/v1 contract
@@ -26,8 +26,14 @@ The drawing is read **at compose time**, by one of two paths:
 There is **no model in the run path** either way. The app ships with a tiny hard-coded
 example; this skill is how the user's OWN drawing replaces it.
 
-**Later slices (mention as "next", do not attempt here):** multi-view 3D reconstruction,
-DXF export.
+A **multi-view set** (a plan plus an elevation/section of the same object) can additionally be
+**reconstructed in 3D**: the skill's multi-view pass (step 3c) adds view classification, datums
+and entity declarations to the contract, and the server's deterministic reconstruction renders
+it in the **View 3D** viewer — members and extruded bodies, with everything unplaceable listed
+honestly with a reason.
+
+**Later slices (mention as "next", do not attempt here):** DXF export, placing details into a
+live model.
 
 > **Pasted a request?** If the user pastes a message beginning with a `[floless-request
 > type=rebake id=…]` marker, that's a request copied from the FloLess Dashboard — resolve it
@@ -119,6 +125,50 @@ For each raster image (or rasterized PDF page exported to an image):
    the vision output matches what the drawing actually says. A wildly wrong trace usually means
    the image is too low-contrast — say so rather than shipping garbage.
 
+### 3c. Multi-view pass — make a plan + elevation set 3D (optional)
+
+Run this ONLY when the set contains **multiple views of one object** and the user wants 3D.
+Prerequisite discipline: `reading-structural-drawings` — **massing + coordinate frame FIRST**,
+entities last, cross-validate every view. All fields below are additive on the contract the
+2D pass (3a/3b) already produced; the server's reconstruction (`views-to-scene`) is
+deterministic and **refuses to guess** — anything you leave unresolved lands in the 3D view's
+"Not shown in 3D" list with a reason, never at a made-up position.
+
+1. **Classify every sheet** — set `sheets[].view`:
+   `{ kind: 'plan'|'elevation'|'section'|'detail', dir, datum }`. `dir` is the observer look
+   direction in world axes (a plan looks `-z`; a south elevation looks `+y`; a west-looking
+   section `+x`). **Cross-validate the scale of each axis pair with one known dimension**
+   (a labeled length that appears in both views) before trusting it — a wrong `dir` or scale
+   silently mirrors or misplaces the model. **Show the user the classification and get an OK**
+   ("s1 = plan at 1:50, s2 = south elevation — reconstruct from these?") before writing 3D
+   fields — this is the same confirm gate the steel reader uses before its heavy pass.
+2. **One world frame.** Give every sheet a `transform` (`scale` = world units per display unit,
+   `origin` = the display point that is world [0,0], `rotation` if the frame is turned) chosen
+   so the views AGREE: pick one shared reference (a grid intersection, a corner that appears in
+   both views) as the common origin. World units are the contract's `units` (mm canonical).
+3. **Datums** — read the height ladder off the elevation (level lines + labels) into the
+   top-level `datums: [{ id:'lv1', kind:'level', axis:'z', value:<world units>, label, sheet }]`.
+   Grid lines go in the same array with `axis:'x'|'y'`. Only `z` datums can drive heights.
+4. **Entities** — group the linework into `sheets[].groups`:
+   - a **member** (beam/bar/stud seen along its axis): `axis: [[x0,y0],[x1,y1]]` (this sheet's
+     display coords) + `section: { w, d }` in WORLD units — from a callout or a dimension, never
+     eyeballed;
+   - an **extruded body** (plate/wall/slab footprint): `footprint: [[x,y]…]` +
+     `extrude: { from, to }` where each end is a **z-datum id** or a world number. A present
+     extrude that doesn't resolve is an ERROR (surfaced, not guessed) — omit `extrude` entirely
+     if the height must come from the elevation instead;
+   - annotation groups (labels, dims) get neither — they simply don't build.
+5. **Links** — where a section mark or the drawing itself says two groups are the same object in
+   two views, add `links: [{ kind:'same-entity', a:{sheet,id}, b:{sheet,id} }]` (ids are only
+   sheet-unique — always the composite). A linked elevation entity gives its plan twin the
+   Z extent directly; unlinked entities are matched by their shared horizontal span, and
+   **anything ambiguous (two elevation entities over the same span) is skipped until you link it**.
+6. **PUT** the contract (step 4) and **open View 3D ▸** on the read node. Work the
+   "Not shown in 3D" panel like a worklist: each row says exactly what is missing (a datum, a
+   link, an extrude); fix the contract, re-PUT, reopen. Reconstructed members export through the
+   existing 3D/IFC path later; extruded bodies render in FloLess's own viewer only for now —
+   say so if the user asks about IFC.
+
 ### 4. Write to the contract store
 
 ```
@@ -147,6 +197,9 @@ Tell the user:
 - **Approve & bake lock**: when satisfied, the user clicks Approve in the editor header — it
   bakes the (edited) contract into the `read` node's `config.takeoff` and recompiles, arming
   the Run gate. Never auto-approve on their behalf.
+- **View 3D ▸** (after a multi-view pass, step 3c): the node action opens the read-only
+  reconstruction viewer — orbit/pan/zoom, solid/wire/x-ray, per-group toggles, and the
+  "Not shown in 3D" panel listing every entity that couldn't be placed, with the reason.
 
 ### 6. Clear the request
 

package/dist/web/aware.js

@@ -1360,6 +1360,11 @@
       // openContractEditor() returns false and the click would silently do nothing.
       if (contractType && window.CONTRACT_RENDERERS && window.CONTRACT_RENDERERS[contractType]) {
         addNodeAction(card, 'Edit contract ▸', () => openContractEditor(currentId, contractType));
+        // A renderer with a LOCAL 3D viewer (the drawing.vector reconstruction) gets View 3D via
+        // that page — distinct from the steel `scene` chain below (AWARE exporter companions).
+        if (window.CONTRACT_RENDERERS[contractType].viewerUrl) {
+          addNodeAction(card, 'View 3D ▸', () => openLocalViewer(currentId, contractType));
+        }
         // The 3D/IFC/BOM/Tekla chain derives a scene from the contract — only contract types that
         // declare `scene` support it (a drawing.vector node would 4xx on these endpoints).
         if (window.CONTRACT_RENDERERS[contractType].scene) {
@@ -1770,6 +1775,21 @@
     $contractEditor.hidden = false;
     return true;
   }
+  // A renderer-declared LOCAL viewer page (e.g. the drawing.vector 3D reconstruction) — reuses the
+  // contract-editor overlay/iframe. Read-only: no Approve (the editor owns that gate).
+  function openLocalViewer(appId, type) {
+    const r = window.CONTRACT_RENDERERS && window.CONTRACT_RENDERERS[type];
+    if (!r || !r.viewerUrl) return false;
+    const ap = document.getElementById('contract-editor-approve'); if (ap) ap.hidden = true;
+    $contractEditorTitle.replaceChildren(
+      Object.assign(document.createElement('span'), { textContent: appId, style: 'color:var(--text);font-weight:600' }),
+      Object.assign(document.createElement('span'), { textContent: ' · 3D view', style: 'color:var(--text-muted)' }),
+    );
+    $contractEditorFrame.onload = () => { try { $contractEditorFrame.contentWindow.focus(); } catch (_) {} };
+    $contractEditorFrame.src = r.viewerUrl(appId);
+    $contractEditor.hidden = false;
+    return true;
+  }
   // The steel filter pre-stage view — reuses the contract-editor overlay/iframe to load the served
   // steel-filter.html (layer/thickness/colour facets + eyedropper). Same seam as the editor: the
   // iframe talks to /api/contract directly and Save writes contract.filter.