@floless/app 0.61.0 → 0.63.0

package/dist/floless-server.cjs

@@ -53022,7 +53022,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.61.0" : void 0,
+    define: true ? "0.63.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -53032,7 +53032,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.61.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.63.0" : void 0 });
 }
 
 // workflow-update.ts
@@ -54017,7 +54017,219 @@ function postProcess(contract, opts = {}) {
     const groups = sheet.groups ? assignIds(sheet.groups, "g") : void 0;
     return { ...sheet, id, elements, layers, ...groups ? { groups } : {} };
   });
-  return { ...contract, type: "drawing.vector/v1", sheets };
+  const datums = contract.datums ? assignIds(contract.datums, "dt") : void 0;
+  const links = contract.links ? assignIds(contract.links, "lk") : void 0;
+  return {
+    ...contract,
+    type: "drawing.vector/v1",
+    sheets,
+    ...datums ? { datums } : {},
+    ...links ? { links } : {}
+  };
+}
+
+// views-to-scene.ts
+function mapper(sheet) {
+  const t = sheet.transform;
+  if (!t || typeof t.scale !== "number" || !(t.scale > 0)) return null;
+  const s = t.scale;
+  const [ox, oy] = t.origin ?? [0, 0];
+  const rot = (t.rotation ?? 0) * Math.PI / 180;
+  const cos = Math.cos(rot);
+  const sin = Math.sin(rot);
+  return (p) => {
+    const dx = p[0] - ox;
+    const dy = p[1] - oy;
+    const rx = dx * cos - dy * sin;
+    const ry = dx * sin + dy * cos;
+    return [rx * s + 0, -ry * s + 0];
+  };
+}
+function uprightHorizontal(sheet) {
+  const dir = sheet.view?.dir ?? "+y";
+  if (dir === "+y") return { axis: "x", sign: 1 };
+  if (dir === "-y") return { axis: "x", sign: -1 };
+  if (dir === "+x") return { axis: "y", sign: -1 };
+  if (dir === "-x") return { axis: "y", sign: 1 };
+  return null;
+}
+function elevationZExtent(sheet, g) {
+  const map = mapper(sheet);
+  if (!map) return null;
+  const pts = collectDisplayPoints(g, sheet);
+  if (pts.length === 0) return null;
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const p of pts) {
+    const z = map(p)[1];
+    if (z < lo) lo = z;
+    if (z > hi) hi = z;
+  }
+  return lo <= hi ? [lo, hi] : null;
+}
+function worldInterval(sheet, g, component, sign = 1) {
+  const map = mapper(sheet);
+  if (!map) return null;
+  const pts = collectDisplayPoints(g, sheet);
+  if (pts.length === 0) return null;
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const p of pts) {
+    const v = map(p)[component] * sign;
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  return lo <= hi ? [lo, hi] : null;
+}
+function collectDisplayPoints(g, sheet) {
+  if (g.footprint && g.footprint.length) return g.footprint;
+  if (g.axis && g.axis.length === 2) return g.axis;
+  const ids = new Set(g.elementIds ?? []);
+  const pts = [];
+  for (const el of sheet.elements ?? []) {
+    if (!el.id || !ids.has(el.id)) continue;
+    if (el.pts) pts.push(...el.pts);
+    else if (el.bbox && el.bbox.length === 4) {
+      pts.push([el.bbox[0], el.bbox[1]], [el.bbox[2], el.bbox[3]]);
+    }
+  }
+  return pts;
+}
+function resolveDatum(v, datums, axis) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const d = datums.find((x) => x.id === v);
+    return d && (d.axis ?? "z") === axis ? d.value : null;
+  }
+  return null;
+}
+var PALETTE = ["#3b82f6", "#f59e0b", "#10b981", "#8b5cf6", "#ef4444", "#14b8a6", "#eab308", "#64748b"];
+function overlapRatio(a, b) {
+  const lo = Math.max(a[0], b[0]);
+  const hi = Math.min(a[1], b[1]);
+  if (hi <= lo) return 0;
+  const shorter = Math.max(1e-9, Math.min(a[1] - a[0], b[1] - b[0]));
+  return (hi - lo) / shorter;
+}
+function viewsToScene(contractInput) {
+  const contract = contractInput ?? {};
+  const sheets = contract.sheets ?? [];
+  const datums = contract.datums ?? [];
+  const links = contract.links ?? [];
+  const elements = [];
+  const skipped = [];
+  const groupKeys = [];
+  const seenKey = /* @__PURE__ */ new Set();
+  const plans = sheets.filter((s) => s.view?.kind === "plan");
+  const uprights = sheets.filter((s) => s.view?.kind === "elevation" || s.view?.kind === "section");
+  const uprightEntities = [];
+  for (const sh of uprights) {
+    const hz = uprightHorizontal(sh);
+    if (!hz) continue;
+    for (const g of sh.groups ?? []) {
+      const z = elevationZExtent(sh, g);
+      const h = worldInterval(sh, g, 0, hz.sign);
+      if (z && h) uprightEntities.push({ sheet: sh, g, z, h, axis: hz.axis });
+    }
+  }
+  const linkedAway = /* @__PURE__ */ new Set();
+  for (const l of links) {
+    if (l.kind !== "same-entity") continue;
+    linkedAway.add(`${l.a.sheet}/${l.a.id ?? ""}`);
+    linkedAway.add(`${l.b.sheet}/${l.b.id ?? ""}`);
+  }
+  function resolveZ(planSheet, g) {
+    if (g.extrude && (g.extrude.from !== void 0 || g.extrude.to !== void 0)) {
+      const exFrom = resolveDatum(g.extrude.from, datums, "z");
+      const exTo = resolveDatum(g.extrude.to, datums, "z");
+      if (exFrom != null && exTo != null) return { z: [exFrom, exTo], how: "extrude" };
+      return { error: "extrude reference unresolved \u2014 each end must be a number or the id of a z-axis datum" };
+    }
+    const key = { sheet: planSheet.id, id: g.id };
+    for (const l of links) {
+      if (l.kind !== "same-entity") continue;
+      const other = l.a.sheet === key.sheet && l.a.id === key.id ? l.b : l.b.sheet === key.sheet && l.b.id === key.id ? l.a : null;
+      if (!other) continue;
+      const hit = uprightEntities.find((u) => u.sheet.id === other.sheet && u.g.id === other.id);
+      if (hit) return { z: hit.z, how: "link" };
+    }
+    const mineX = worldInterval(planSheet, g, 0);
+    const mineY = worldInterval(planSheet, g, 1);
+    if (mineX || mineY) {
+      const candidates = uprightEntities.filter((u) => !linkedAway.has(`${u.sheet.id}/${u.g.id ?? ""}`)).map((u) => {
+        const mine = u.axis === "x" ? mineX : mineY;
+        return { u, r: mine ? overlapRatio(mine, u.h) : 0 };
+      }).filter((x) => x.r >= 0.8);
+      if (candidates.length === 1) return { z: candidates[0].u.z, how: "match" };
+      if (candidates.length > 1) return { ambiguous: candidates.length };
+    }
+    return null;
+  }
+  for (const plan of plans) {
+    const map = mapper(plan);
+    const sheetId = plan.id ?? "?";
+    if (!map) {
+      for (const g of plan.groups ?? []) skipped.push({ id: `${sheetId}/${g.id ?? "?"}`, reason: "sheet has no world transform (transform.scale required)" });
+      continue;
+    }
+    for (const g of plan.groups ?? []) {
+      const gid = `${sheetId}/${g.id ?? "?"}`;
+      const isMember = !!(g.axis && g.section);
+      const isFootprint = !!(g.footprint && g.footprint.length >= 3);
+      if (!isMember && !isFootprint) continue;
+      if (isMember && !(g.section.w > 0 && g.section.d > 0)) {
+        skipped.push({ id: gid, reason: "invalid section \u2014 w and d must be positive world units" });
+        continue;
+      }
+      const zr0 = resolveZ(plan, g);
+      if (!zr0) {
+        skipped.push({ id: gid, reason: "no Z extent \u2014 add extrude datums/values, a same-entity link, or a matching elevation entity" });
+        continue;
+      }
+      if ("ambiguous" in zr0) {
+        skipped.push({ id: gid, reason: `ambiguous Z \u2014 ${zr0.ambiguous} elevation entities share this span; add a same-entity link to pick one` });
+        continue;
+      }
+      if ("error" in zr0) {
+        skipped.push({ id: gid, reason: zr0.error });
+        continue;
+      }
+      const zr = zr0;
+      const key = g.kind || (isMember ? "member" : "footprint");
+      if (!seenKey.has(key)) {
+        seenKey.add(key);
+        groupKeys.push(key);
+      }
+      if (isMember) {
+        const [ax, ay] = map(g.axis[0]);
+        const [bx, by] = map(g.axis[1]);
+        const zFrom = zr.how === "extrude" ? zr.z[0] : (zr.z[0] + zr.z[1]) / 2;
+        const zTo = zr.how === "extrude" ? zr.z[1] : zFrom;
+        elements.push({
+          id: g.id ?? gid,
+          group: key,
+          kind: "box",
+          from: [ax, ay, zFrom],
+          to: [bx, by, zTo],
+          section: { w: g.section.w, d: g.section.d },
+          meta: { sheet: sheetId, ...g.label ? { label: g.label } : {} }
+        });
+      } else {
+        elements.push({
+          id: g.id ?? gid,
+          group: key,
+          kind: "extrusion",
+          footprint: g.footprint.map((p) => map(p)),
+          from: Math.min(zr.z[0], zr.z[1]),
+          to: Math.max(zr.z[0], zr.z[1]),
+          meta: { sheet: sheetId, ...g.label ? { label: g.label } : {} }
+        });
+      }
+    }
+  }
+  const groups = groupKeys.map((key, i) => ({ key, label: key, color: PALETTE[i % PALETTE.length] }));
+  const name = contract.source && typeof contract.source.name === "string" ? String(contract.source.name) : "Reconstructed drawing";
+  return { scene: { meta: { name, units: "mm", up: "z" }, groups, elements }, skipped };
 }
 
 // steel-joints.ts
@@ -54516,12 +54728,13 @@ function contractToScene(contractInput) {
     const ptPerFt = plan.pt_per_ft && plan.pt_per_ft > 0 ? plan.pt_per_ft : 1;
     const defaultTosMm = (plan.default_tos ?? 0) * IN_TO_MM;
     for (const m of plan.members ?? []) {
-      const dims = profileDims(m.profile);
+      const explicit = m.section && typeof m.section.w === "number" && m.section.w > 0 && typeof m.section.d === "number" && m.section.d > 0 ? { w: m.section.w, d: m.section.d, approx: false } : null;
+      const dims = explicit ?? profileDims(m.profile);
       if (!dims || !Array.isArray(m.wp) || m.wp.length < 2) {
         skipped.push(m.id);
         continue;
       }
-      const profile = (m.profile ?? "").trim().toUpperCase();
+      const profile = (m.profile ?? "").trim().toUpperCase() || (explicit ? "CUSTOM" : "");
       if (!seenProfile.has(profile)) {
         seenProfile.add(profile);
         profileOrder.push(profile);
@@ -63865,6 +64078,15 @@ async function startServer() {
     async (req, reply) => {
       const doc = req.body && "contract" in req.body ? req.body.contract : readContract(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);
+        const v2 = validateContract(cleaned);
+        if (!v2.valid) {
+          const first = v2.errors[0];
+          return reply.status(400).send({ ok: false, error: `contract failed schema validation \u2014 ${first ? `${first.path}: ${first.message}` : "invalid"}` });
+        }
+        return { ok: true, ...viewsToScene(cleaned) };
+      }
       const v = validateSteelTakeoff(doc);
       if (!v.valid) {
         const first = v.errors[0];

package/dist/schemas/drawing.vector.v1.schema.json

@@ -27,6 +27,16 @@
       "type": "array",
       "items": { "$ref": "#/$defs/sheet" },
       "description": "One entry per page/view. Multi-page PDFs and image sets each become a sheet."
+    },
+    "datums": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/datum" },
+      "description": "READER-EMITTED world reference values (levels, grid lines) harvested from elevations/sections — the Z-ladder (or X/Y grid) that places 2D views in 3D. Top-level because a datum is a WORLD fact shared by every sheet; `sheet` records provenance. Multi-view reconstruction (views-to-scene) resolves groups[].extrude datum refs against these."
+    },
+    "links": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/link" },
+      "description": "READER-EMITTED cross-view correspondence hints: which entities in two sheets are the same object, which mark is a section cut of which region (the steel callouts[] analog). Keys are {sheet,id} composites — element/group ids are only sheet-unique."
     }
   },
   "$defs": {
@@ -57,7 +67,19 @@
             "scale":    { "type": "number", "description": "World units per display unit (e.g. mm per pt). Uniform." },
             "origin":   { "$ref": "#/$defs/point2", "description": "Display-space point mapped to world [0,0]." },
             "units":    { "type": "string", "description": "World units this maps into (overrides the top-level default for this sheet)." },
-            "rotation": { "type": "number", "description": "Degrees the display frame is rotated relative to world (page orientation)." }
+            "rotation": { "type": "number", "description": "Degrees to realign a rotated display frame with world axes. Applied by the reconstruction mapper as the standard math-positive matrix [cos -sin; sin cos] on display deltas about `origin` (display coords, Y-down), BEFORE scale and the Y-flip — i.e. content drawn rotated by R(-θ) is recovered with rotation: θ (locked by the views-to-scene rotation test)." }
+          },
+          "additionalProperties": true
+        },
+        "view": {
+          "type": "object",
+          "description": "READER-EMITTED view classification + third-axis binding — `transform` maps display->world in TWO axes but never says WHICH world axes; this does (a plan maps to X,Y at some Z; a south elevation maps to X,Z at some Y). Required for multi-view 3D reconstruction (views-to-scene); a sheet without it stays 2D-only. A wrong `dir`/`datum` silently mirrors or misplaces the model — the reader must cross-validate one known dimension per axis pair before emitting.",
+          "required": ["kind"],
+          "properties": {
+            "kind":  { "enum": ["plan", "elevation", "section", "detail"], "description": "What this sheet IS. Only plan/elevation/section participate in reconstruction." },
+            "dir":   { "enum": ["+z", "-z", "+x", "-x", "+y", "-y"], "description": "Observer look direction in world axes (a plan looks -z; a south elevation looks +y). Defaults: plan -z." },
+            "datum": { "type": "number", "description": "World offset (units) of the view plane along `dir`'s axis — plan: the projection Z; elevation/section: the plane's X or Y. Default 0." },
+            "depth": { "type": ["number", "null"], "description": "Section only: how far past the cut plane the view shows. null/absent = projection (shows everything)." }
           },
           "additionalProperties": true
         },
@@ -115,13 +137,79 @@
       "type": "object",
       "required": ["id"],
       "additionalProperties": true,
-      "description": "A named, ID-BEARING set of elements (a detected entity or a user grouping) — the unit an insert/modify Request can target.",
+      "description": "A named, ID-BEARING set of elements (a detected entity or a user grouping) — the unit an insert/modify Request can target, and the unit multi-view reconstruction lifts to 3D (via `section`/`axis` for member-like entities, `footprint`+`extrude` for extruded ones).",
       "properties": {
         "id":    { "type": "string", "description": "Stable, sheet-unique group id." },
-        "kind":  { "type": "string", "description": "Free-form entity kind (vocabulary-free; e.g. 'detail', 'wall', 'annotation'). The generic core does not enforce a taxonomy." },
+        "kind":  { "type": "string", "description": "Free-form entity kind (vocabulary-free; e.g. 'detail', 'wall', 'annotation', 'member', 'footprint'). The generic core does not enforce a taxonomy; views-to-scene keys on `section`/`axis`/`footprint`/`extrude` being present, not on kind." },
         "label": { "type": "string" },
         "elementIds": { "type": "array", "items": { "type": "string" }, "description": "The `elements[].id`s in this group." },
-        "confidence": { "type": "number", "minimum": 0, "maximum": 1, "description": "Reader-emitted grouping confidence 0..1." }
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1, "description": "Reader-emitted grouping confidence 0..1." },
+        "section": {
+          "type": "object",
+          "required": ["w", "d"],
+          "description": "READER-EMITTED rectangular cross-section in WORLD units for a member-like entity — the vocabulary-free replacement for steel's AISC lookup; feeds the scene `section` as-is.",
+          "properties": { "w": { "type": "number", "exclusiveMinimum": 0 }, "d": { "type": "number", "exclusiveMinimum": 0 } },
+          "additionalProperties": true
+        },
+        "axis": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/point2" },
+          "minItems": 2,
+          "maxItems": 2,
+          "description": "Member work-line [[x0,y0],[x1,y1]] in THIS SHEET's display coords (mapped to world via transform+view). Paired with `section`."
+        },
+        "footprint": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/point2" },
+          "minItems": 3,
+          "description": "Closed outline (display coords, this sheet) of an extruded entity — a plate, wall, slab. Paired with `extrude`."
+        },
+        "extrude": {
+          "type": "object",
+          "description": "How far the entity extends along the sheet's missing axis (a plan's Z). Meaningful ONLY on PLAN-sheet groups — reconstruction builds geometry from plans; on elevation/section groups this field is ignored (those groups contribute extents, not bodies). Ends are datum ids (resolved against the top-level `datums`, z-axis only) or numbers (world units). views-to-scene can also INFER this by fold-line matching against a linked elevation when absent — but a PRESENT extrude that fails to resolve is an error, never silently replaced by inference.",
+          "properties": {
+            "from": { "type": ["string", "number"], "description": "Datum id or world value — the lower/near end." },
+            "to":   { "type": ["string", "number"], "description": "Datum id or world value — the upper/far end." }
+          },
+          "additionalProperties": true
+        }
+      }
+    },
+    "datum": {
+      "type": "object",
+      "required": ["id", "axis", "value"],
+      "additionalProperties": true,
+      "description": "One world reference value read off a drawing (a level line, a grid line). `value` is WORLD units on `axis`.",
+      "properties": {
+        "id":    { "type": "string", "description": "Document-unique datum id (e.g. 'lv1') — groups[].extrude references it." },
+        "kind":  { "enum": ["level", "grid"], "description": "level = a horizontal datum (Z); grid = a plan grid line (X or Y)." },
+        "label": { "type": "string", "description": "The as-drawn label (e.g. 'T.O.S. 16\\u2032-6\\u2033')." },
+        "axis":  { "enum": ["x", "y", "z"], "description": "Which world axis the value is on." },
+        "value": { "type": "number", "description": "World units (the contract's canonical units)." },
+        "sheet": { "type": "string", "description": "Provenance: the sheet id this datum was read from." },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    },
+    "link": {
+      "type": "object",
+      "required": ["kind", "a", "b"],
+      "additionalProperties": true,
+      "description": "A cross-view correspondence hint between two {sheet,id} targets (ids are only sheet-unique — always composite keys).",
+      "properties": {
+        "kind": { "enum": ["same-entity", "cut-line", "datum-ref"], "description": "same-entity = the two targets are one object seen in two views; cut-line = a section mark and the sheet it cuts; datum-ref = an entity bound to a datum." },
+        "a": { "$ref": "#/$defs/linkEnd" },
+        "b": { "$ref": "#/$defs/linkEnd" },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    },
+    "linkEnd": {
+      "type": "object",
+      "required": ["sheet"],
+      "additionalProperties": true,
+      "description": "One side of a link: a sheet and (usually) a group/element id on it.",
+      "properties": {
+        "sheet": { "type": "string" },
+        "id":    { "type": "string", "description": "A groups[].id or elements[].id on that sheet; absent = the whole sheet. NOTE: v1 reconstruction resolves same-entity links between GROUP ids only — an element-level link is kept as data but does not drive Z resolution yet." }
       }
     },
     "point2": {

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