@floless/app 0.59.1 → 0.60.0

package/dist/floless-server.cjs

@@ -53022,7 +53022,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.59.1" : void 0,
+    define: true ? "0.60.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -53032,7 +53032,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.59.1" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.60.0" : void 0 });
 }
 
 // workflow-update.ts
@@ -53783,30 +53783,45 @@ function walk(value, node, root, path, errors) {
     }
   }
 }
-var _cached = null;
-function loadSteelTakeoffSchema() {
-  if (_cached) return _cached;
+var _cache = /* @__PURE__ */ new Map();
+function loadContractSchema(file) {
+  const hit = _cache.get(file);
+  if (hit) return hit;
   const here2 = (0, import_node_path14.dirname)((0, import_node_url2.fileURLToPath)(__import_meta_url));
   const candidates = [
-    (0, import_node_path14.join)(here2, "..", "schemas", "steel.takeoff.v1.schema.json"),
+    (0, import_node_path14.join)(here2, "..", "schemas", file),
     // dev: server/ next to schemas/
-    (0, import_node_path14.join)(here2, "schemas", "steel.takeoff.v1.schema.json")
+    (0, import_node_path14.join)(here2, "schemas", file)
     // bundled: dist/ holds ./schemas
   ];
   for (const p of candidates) {
     try {
-      const text = (0, import_node_fs16.readFileSync)(p, "utf8");
-      _cached = JSON.parse(text);
-      return _cached;
+      const parsed = JSON.parse((0, import_node_fs16.readFileSync)(p, "utf8"));
+      _cache.set(file, parsed);
+      return parsed;
     } catch (err2) {
       if (err2.code !== "ENOENT") throw err2;
     }
   }
-  throw new Error("steel.takeoff/v1 schema file not found");
+  throw new Error(`contract schema file not found: ${file}`);
+}
+function loadSteelTakeoffSchema() {
+  return loadContractSchema("steel.takeoff.v1.schema.json");
+}
+function loadDrawingVectorSchema() {
+  return loadContractSchema("drawing.vector.v1.schema.json");
 }
 function validateSteelTakeoff(doc) {
   return validate(doc, loadSteelTakeoffSchema());
 }
+function validateDrawingVector(doc) {
+  return validate(doc, loadDrawingVectorSchema());
+}
+function validateContract(doc) {
+  const type = doc && typeof doc === "object" ? doc.type : void 0;
+  if (type === "drawing.vector/v1") return validateDrawingVector(doc);
+  return validateSteelTakeoff(doc);
+}
 
 // contract-store.ts
 var ContractError = class extends Error {
@@ -53832,7 +53847,7 @@ function readContract(appId) {
 }
 function writeContract(appId, doc) {
   const p = contractPath(appId);
-  const res = validateSteelTakeoff(doc);
+  const res = validateContract(doc);
   if (!res.valid) {
     const first = res.errors.slice(0, 5).map((e) => `${e.path}: ${e.message}`).join("; ");
     throw new ContractError(`contract failed schema validation \u2014 ${first}`);
@@ -53851,11 +53866,12 @@ function readContractForApp(appId, readAppFn = readApp) {
   } catch {
     return null;
   }
-  const node = app.nodes.find((n) => n.config["contract"] === "steel.takeoff/v1");
+  const isBaked = (v) => v != null && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length > 0;
+  const node = app.nodes.find(
+    (n) => typeof n.config["contract"] === "string" && n.config["contract"] !== "" && isBaked(n.config["takeoff"])
+  );
   const t = node?.config["takeoff"];
-  if (t == null || typeof t !== "object" || Array.isArray(t) || Object.keys(t).length === 0) {
-    return null;
-  }
+  if (!isBaked(t)) return null;
   return t;
 }
 
@@ -53886,29 +53902,124 @@ function bakeContractIntoApp(sourcePath, contract) {
       return p;
     });
   }
+  const stripPageRaster = (p) => {
+    if (p && typeof p === "object") {
+      const page = { ...p };
+      delete page.bg_b64;
+      return page;
+    }
+    return p;
+  };
   const filter = baked.filter;
   if (filter && typeof filter === "object") {
-    const stripPage = (p) => {
-      if (p && typeof p === "object") {
-        const page = { ...p };
-        delete page.bg_b64;
-        return page;
-      }
-      return p;
-    };
     const next = { ...filter };
-    if (filter.page) next.page = stripPage(filter.page);
+    if (filter.page) next.page = stripPageRaster(filter.page);
     if (Array.isArray(filter.sheets)) {
       next.sheets = filter.sheets.map(
-        (s) => s && typeof s === "object" ? { ...s, page: stripPage(s.page) } : s
+        (s) => s && typeof s === "object" ? { ...s, page: stripPageRaster(s.page) } : s
       );
     }
     baked.filter = next;
   }
+  if (Array.isArray(baked.sheets)) {
+    baked.sheets = baked.sheets.map(
+      (s) => s && typeof s === "object" ? { ...s, page: stripPageRaster(s.page) } : s
+    );
+  }
   doc.setIn(["nodes", idx, "config", "takeoff"], baked);
   (0, import_node_fs18.writeFileSync)(sourcePath, doc.toString());
 }
 
+// vectorize.ts
+function assignIds(items, prefix) {
+  const used = /* @__PURE__ */ new Set();
+  const keep = items.map((it) => {
+    if (it.id && !used.has(it.id)) {
+      used.add(it.id);
+      return true;
+    }
+    return false;
+  });
+  let counter = 0;
+  const nextId = () => {
+    let id;
+    do {
+      counter += 1;
+      id = `${prefix}${counter}`;
+    } while (used.has(id));
+    used.add(id);
+    return id;
+  };
+  return items.map((it, i) => keep[i] ? it : { ...it, id: nextId() });
+}
+function geomKey(el, index) {
+  const layer = el.layer ?? "";
+  if (el.kind === "text") {
+    const pos2 = el.origin ? el.origin.join(",") : (el.bbox ?? []).join(",");
+    return `text|${layer}|${el.text ?? ""}|${pos2}`;
+  }
+  if (el.d) return `${el.kind}|${layer}|${el.d}`;
+  if (el.pts) return `${el.kind}|${layer}|${el.pts.map((p) => p.join(",")).join(" ")}`;
+  return `nogeom|${index}`;
+}
+function dedupeElements(elements) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  elements.forEach((el, i) => {
+    const key = geomKey(el, i);
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(el);
+  });
+  return out;
+}
+function snapEndpoints(elements, tol = 1) {
+  const reps = [];
+  const tol2 = tol * tol;
+  const snap = (p) => {
+    for (const r of reps) {
+      const dx = p[0] - r[0];
+      const dy = p[1] - r[1];
+      if (dx * dx + dy * dy <= tol2) return r;
+    }
+    const rep = [p[0], p[1]];
+    reps.push(rep);
+    return rep;
+  };
+  return elements.map((el) => {
+    if (!el.pts || el.pts.length === 0) return el;
+    const pts = el.pts.map((p) => {
+      const s = snap(p);
+      return [s[0], s[1]];
+    });
+    return { ...el, pts };
+  });
+}
+function deriveLayers(elements, existing) {
+  const onByName = /* @__PURE__ */ new Map();
+  for (const l of existing ?? []) if (l && l.name && l.on != null) onByName.set(l.name, l.on);
+  const counts = /* @__PURE__ */ new Map();
+  for (const el of elements) {
+    if (!el.layer) continue;
+    counts.set(el.layer, (counts.get(el.layer) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([name, count]) => onByName.has(name) ? { name, count, on: onByName.get(name) } : { name, count }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+function postProcess(contract, opts = {}) {
+  const snapTol = opts.snapTol ?? 1;
+  const sheets = contract.sheets.map((sheet, i) => {
+    let elements = sheet.elements ?? [];
+    elements = snapEndpoints(elements, snapTol);
+    elements = dedupeElements(elements);
+    elements = assignIds(elements, "e");
+    const layers = deriveLayers(elements, sheet.layers);
+    const id = sheet.id ?? `s${i + 1}`;
+    const groups = sheet.groups ? assignIds(sheet.groups, "g") : void 0;
+    return { ...sheet, id, elements, layers, ...groups ? { groups } : {} };
+  });
+  return { ...contract, type: "drawing.vector/v1", sheets };
+}
+
 // steel-joints.ts
 var GROUPS = {
   "base-plate": { key: "base-plate", label: "Base plates", color: "#6b7a8d" },
@@ -61279,6 +61390,8 @@ var PRODUCT_SKILLS = [
   // handle a tweak-contract request from the Steel Model contract editor (Slice 2 AI round-trip)
   "floless-app-ui",
   //            compose Custom Panels (~/.floless/ui/extensions.json) for the Dashboard
+  "floless-app-vectorize",
+  //     read a vector PDF into an editable drawing.vector/v1 contract (the Vectorize reader)
   "floless-app-workflows",
   //     author/run .flo workflows
   "reading-structural-drawings",
@@ -63537,7 +63650,7 @@ async function startServer() {
       return reply.status(409).send({ ok: false, error: `"${id}"'s saved data is unreadable \u2014 open it in the editor and re-save before updating`, code: "contract-corrupt" });
     }
     if (contract != null) {
-      const v = validateSteelTakeoff(contract);
+      const v = validateContract(contract);
       if (!v.valid) return reply.status(409).send({ ok: false, error: `"${id}"'s saved data is invalid \u2014 re-save it in the editor before updating`, code: "contract-invalid" });
     }
     _wfUpdating.add(id);
@@ -63670,6 +63783,9 @@ async function startServer() {
   app.get("/api/contract/:appId", async (req, reply) => {
     const doc = readContractForApp(req.params.appId);
     if (doc == null) return reply.status(404).send({ ok: false, error: "no contract for this app yet" });
+    if (doc && typeof doc === "object" && doc.type === "drawing.vector/v1") {
+      return postProcess(doc);
+    }
     return doc;
   });
   app.put(
@@ -63690,7 +63806,7 @@ async function startServer() {
   app.post("/api/contract/:appId/approve", async (req, reply) => {
     const doc = readContract(req.params.appId);
     if (doc == null) return reply.status(404).send({ ok: false, error: "no contract to approve" });
-    const v = validateSteelTakeoff(doc);
+    const v = validateContract(doc);
     if (!v.valid) return reply.status(400).send({ ok: false, error: "stored contract is invalid \u2014 re-save it in the editor" });
     const sourcePath = readApp(req.params.appId).source.path;
     try {
@@ -64001,7 +64117,7 @@ async function startServer() {
       return reply.status(409).send({ ok: false, error: `"${id}"'s saved data is unreadable \u2014 open it in the editor and re-save before restoring`, code: "contract-corrupt" });
     }
     if (contract != null) {
-      const v = validateSteelTakeoff(contract);
+      const v = validateContract(contract);
       if (!v.valid) return reply.status(409).send({ ok: false, error: `"${id}"'s saved data is invalid \u2014 re-save it in the editor before restoring`, code: "contract-invalid" });
     }
     _wfUpdating.add(id);

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

@@ -0,0 +1,135 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://floless.app/schemas/drawing.vector/v1",
+  "title": "drawing.vector/v1",
+  "description": "Vocabulary-free vectorized-drawing contract: clean 2D linework + text extracted from any sketch / PDF / photo, the general 'draw CAD from anything' core. Mirrors the (steel-agnostic) steel.takeoff/v1 `filter` block but makes every element and group ID-BEARING (so a placed/edited detail can be targeted) and first-class. The contract is the single source of truth; the 2D vectorize editor is its view; server/vectorize.ts is the pure post-processor; exporters (SVG now; viewer-3d/ifc via a generalized scene later) consume it; Approve bakes the .lock. Coordinates are DISPLAY space (the drawing's own frame); `sheets[].transform` carries the reader-emitted display->world mapping a renderer cannot reconstruct. Confidential rasters ride inside as base64 and are NEVER committed (stripped at bake, like steel's page.bg_b64). Design: docs/superpowers/specs/2026-07-01-vectorize-draw-from-anything-design.md.",
+  "type": "object",
+  "required": ["type", "sheets"],
+  "additionalProperties": true,
+  "properties": {
+    "type": { "const": "drawing.vector/v1", "description": "Renderer-registry discriminator (web/renderers.js contractTypeOf)." },
+    "active": { "type": "integer", "description": "Index into `sheets` of the active sheet (mirrors steel's plans/active)." },
+    "units": { "type": "string", "description": "World units the `transform` maps into (default 'mm'). The scene/3D reuse is mm, Z-up." },
+    "source": {
+      "type": "object",
+      "description": "Provenance: where this drawing was read from.",
+      "properties": {
+        "name":    { "type": "string" },
+        "path":    { "type": "string" },
+        "kind":    { "enum": ["pdf", "image"], "description": "Input modality the extractor read." },
+        "sha256":  { "type": "string" },
+        "read_at": { "type": "string" },
+        "extractor": { "type": "string", "description": "How it was read (e.g. 'pymupdf@compose-time', later 'vectorize.extract@<ver>'). Determinism/audit trail." }
+      },
+      "additionalProperties": true
+    },
+    "sheets": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/sheet" },
+      "description": "One entry per page/view. Multi-page PDFs and image sets each become a sheet."
+    }
+  },
+  "$defs": {
+    "sheet": {
+      "type": "object",
+      "required": ["id", "elements"],
+      "additionalProperties": true,
+      "description": "One drawing page/view: its raster backdrop, the display->world transform, and the vectorized elements + optional detected groups. Lines render as SVG paths over a dimmed page raster; text spans stay pickable.",
+      "properties": {
+        "id": { "type": "string", "description": "Stable, document-unique sheet id (e.g. 's1'). Targets are keyed {sheet,id} (member ids can collide across sheets — task_d1db821f)." },
+        "label": { "type": "string", "description": "Human sheet name (page title / detail name)." },
+        "page": {
+          "type": "object",
+          "required": ["w", "h"],
+          "description": "Page geometry in DISPLAY space. w/h are required and positive.",
+          "properties": {
+            "w": { "type": "number", "minimum": 1 },
+            "h": { "type": "number", "minimum": 1 },
+            "bg_b64": { "type": "string", "description": "Base64 JPEG of the page for the dimmed backdrop. CONFIDENTIAL — machine-local, stripped from the baked .flo (contract-bake.ts), never committed." },
+            "rect": { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] display-coords the raster was clipped to, so the viewer registers 1:1 with the linework." }
+          },
+          "additionalProperties": true
+        },
+        "transform": {
+          "type": "object",
+          "description": "READER-EMITTED display->world mapping a renderer cannot reconstruct: pixel/point -> `units`. AWARE-owned on graduation (§Graduation). Absent = display space treated as world 1:1.",
+          "properties": {
+            "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)." }
+          },
+          "additionalProperties": true
+        },
+        "layers": {
+          "type": "array",
+          "description": "Distinct layers observed (name + count), for the editor's layer toggles. Vocabulary-free: no steel 'is this a beam' flags.",
+          "items": {
+            "type": "object",
+            "required": ["name"],
+            "additionalProperties": true,
+            "properties": {
+              "name":  { "type": "string" },
+              "count": { "type": "number" },
+              "on":    { "type": "boolean", "description": "Persisted visibility state." }
+            }
+          }
+        },
+        "elements": {
+          "type": "array",
+          "description": "Every vectorized element, each with a STABLE id. Geometry elements carry an SVG path `d`; text elements carry `text`+`bbox`.",
+          "items": { "$ref": "#/$defs/element" }
+        },
+        "groups": {
+          "type": "array",
+          "description": "Optional detected entities (the AEC-on-top layer, or user groupings): a named set of element ids. Each group is ID-BEARING so it can be targeted for insert/modify.",
+          "items": { "$ref": "#/$defs/group" }
+        }
+      }
+    },
+    "element": {
+      "type": "object",
+      "required": ["id", "kind"],
+      "additionalProperties": true,
+      "description": "One drawing element. STABLE, sheet-unique `id` (assigned by the post-processor if the extractor omitted it) so it can be selected, exported, and targeted for modification.",
+      "properties": {
+        "id":    { "type": "string", "description": "Stable, sheet-unique element id (e.g. 'e12')." },
+        "kind":  { "enum": ["line", "arc", "polyline", "spline", "text"], "description": "Geometry class (broader than steel's line/text)." },
+        "d":     { "type": "string", "description": "SVG path in DISPLAY coords (geometry elements). The SVG export is near-free — this IS the path." },
+        "pts":   { "type": "array", "items": { "$ref": "#/$defs/point2" }, "description": "Optional explicit vertices (display coords) for line/polyline; a convenience alongside/instead of `d` for snap/edit." },
+        "text":  { "type": "string", "description": "Label text (text elements)." },
+        "bbox":  { "type": "array", "items": { "type": "number" }, "minItems": 4, "maxItems": 4, "description": "[x0,y0,x1,y1] display coords (text + geometry bounds)." },
+        "size":  { "type": "number", "description": "Text font size in display units (text elements) — reader-emitted; the renderer needs it (a fixed size renders wrong)." },
+        "origin": { "$ref": "#/$defs/point2", "description": "Text BASELINE start [x,y] (text elements) — where the glyphs actually sit. The bbox top is NOT the baseline; reader-emitted." },
+        "angle": { "type": "number", "description": "Text rotation in degrees from the writing direction (text elements); 0 = horizontal. Reader-emitted." },
+        "font":  { "type": "string", "description": "Text font family (text elements)." },
+        "layer": { "type": "string" },
+        "color": { "type": "string", "description": "Stroke colour (#hex or name), reader-emitted." },
+        "w":     { "type": "number", "description": "Stroke width (display units)." },
+        "dashed": { "type": "boolean" },
+        "confidence": { "type": "number", "minimum": 0, "maximum": 1, "description": "READER-EMITTED trace confidence 0..1. The editor flags weak traces (.chip.weak) below a threshold; absent = trusted (1)." },
+        "group": { "type": "string", "description": "Optional back-reference to a `groups[].id` this element belongs to." }
+      }
+    },
+    "group": {
+      "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.",
+      "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." },
+        "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." }
+      }
+    },
+    "point2": {
+      "type": "array",
+      "items": { "type": "number" },
+      "minItems": 2,
+      "maxItems": 2,
+      "description": "[x, y] in display space."
+    }
+  }
+}

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

@@ -0,0 +1,130 @@
+---
+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 drawing into clean CAD linework", "read this detail into vectors", "trace this sheet". Teaches the host AI to run ONE deterministic PyMuPDF pass at COMPOSE time (no LLM, no API key) over a vector PDF, emit the drawing.vector/v1 contract, PUT it to the contract store, and hand the 2D vector editor to the user.
+metadata:
+  version: 0.1.0
+---
+
+# Vectorize — read a drawing into a drawing.vector/v1 contract
+
+## What this is
+
+`vectorize` is a FloLess app that turns a drawing (PDF today; scans/photos are a later
+slice) into clean, editable **2D vector linework** — a `drawing.vector/v1` contract
+(vocabulary-free; every element has a stable id) rendered in the 2D vector editor, where the
+user pans/zooms, toggles Lines/Curves/Text and layers, inspects weak traces, and exports SVG.
+
+The drawing is read **at compose time** with one deterministic PyMuPDF pass. There is **no
+model in the run path and no API key** — and for a vector PDF no vision either: the geometry
+is exact, extracted, never guessed. 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):** raster/photo input via AWARE
+`vision.extract`, editor Save/edit, multi-view 3D reconstruction, DXF export.
+
+> **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
+> via `GET /api/requests` (match the id), don't run the pasted line verbatim, and `DELETE` it
+> when done.
+
+## The loop
+
+### 1. Find the drawing(s)
+
+From a `rebake` request: `GET http://localhost:<port>/api/requests` → the entry with
+`type:"rebake"` and `appId:"vectorize"` carries `snapshots: ["<abs path>", …]` and optionally
+`sourceName` (use it for `source.name` provenance). **`snapshots` may hold multiple files —
+read every one**, each page becoming a sheet. If the user just attaches or names a file in
+prose, skip the lookup and proceed from that path. Resolve the port from the running
+floless.app (check `~/.floless/port` or the active server port), as the other floless-app
+skills do.
+
+### 2. Gate — is it a VECTOR PDF?
+
+This skill's deterministic path reads **vector** PDFs only. If `page.get_drawings()` returns
+nothing on every page (a scan, a photo, a hand sketch), **stop and say so honestly** — the
+raster/vision path is a later slice and is not shipped. Never trace pixels by eye into
+made-up coordinates; fabricated geometry is worse than no geometry.
+
+### 3. Extract — one deterministic PyMuPDF pass
+
+Run the bundled extractor (it lives beside this file):
+
+```
+python <skill dir>/scripts/extract_pdf.py <drawing.pdf> [more.pdf …] --out contract.json
+```
+
+Requires PyMuPDF (`pip install pymupdf`). The script forces UTF-8 on its own output; but any
+OTHER ad-hoc Python that prints extracted drawing text must set UTF-8 first — drawings carry
+glyphs (Ø, —) that crash a cp1250 Windows console (PowerShell
+`$env:PYTHONIOENCODING='utf-8'`; bash `PYTHONIOENCODING=utf-8 python …`). What it does, per
+page:
+
+- **Geometry** — each `page.get_drawings()` path becomes one element in DISPLAY coords:
+  a continuous straight-line chain emits `pts` (explicit vertices — the server snaps shared
+  corners through them); everything else emits an SVG `d` (`c` items become cubic béziers,
+  `re`/`qu` closed 4-corner polygons). Never both — renderers prefer `d`, which would shadow
+  snapped `pts`. Plus stroke `color` (falling back to fill), `w`, `dashed`, and the OCG
+  `layer` when the PDF carries one. Kind is `line` (single segment), `polyline`, or `spline`
+  (any bézier).
+- **Text** — each `page.get_text("dict")` span becomes `{kind:'text', text, origin (baseline),
+  size, angle, color, font, bbox}`. The baseline `origin` and real `size`/`angle` matter — a
+  fixed size or bbox-top placement renders wrong.
+- **Rotated pages** — every point is mapped through `page.rotation_matrix` into display space
+  (`page.rect` is already display). Never mix native/display coords.
+- **Ids** — the PUT schema **requires** per-element ids; the script assigns `e1…` per sheet
+  and `s1…` sheets in document order.
+
+If the script needs adapting (odd PDF, extra filtering), patch a local copy — the mapping
+above is the contract. Hard schema requirements the server enforces on PUT: `type`,
+`sheets[].id`, and `sheets[].elements[].{id,kind}` (a missing element id is rejected). Do NOT
+dedupe, snap, or derive layers yourself — the server post-processes every read of this
+contract type.
+
+### 4. Write to the contract store
+
+```
+PUT http://localhost:<port>/api/contract/vectorize
+Content-Type: application/json
+
+<contract JSON body>
+```
+
+The server schema-validates the body; on `400` read the error, fix the offending fields, and
+re-PUT. The stored draft **wins over the baked example immediately** — no compile needed for
+the editor to show it. Read back with `GET /api/contract/vectorize` (served through the pure
+post-processor, so ids/layers come back cleaned).
+
+### 5. Hand off to the user
+
+Tell the user:
+
+- **What was read** — e.g. "2 sheets, 214 lines, 12 curves, 96 text spans from `detail.pdf`".
+- **Open the editor**: double-click the `read` node on the Vectorize canvas. It renders their
+  drawing — pan/zoom + Fit, Lines/Curves/Text toggles, per-layer toggles, weak-trace isolation
+  (deterministic reads have none), and **Export SVG**.
+- The editor is **view-only for now** — no Save/Approve path yet (a later slice); corrections
+  mean re-running this read with a better source.
+
+### 6. Clear the request
+
+If the trigger came from a `rebake` request:
+
+```
+DELETE http://localhost:<port>/api/requests/<id>
+```
+
+## Guardrails
+
+- **Compose-time only.** The drawing is read HERE, by the terminal AI, then PUT to the store.
+  Never add a runtime node that reads the drawing — `aware app validate` rejects it, and it
+  breaks determinism.
+- **Deterministic or nothing.** Vector geometry is extracted exactly; a raster with no vector
+  paths is out of scope until the vision slice ships. No eyeballed coordinates, ever.
+- **Thin-UI contract.** The browser recorded intent and the file path; the brain is the
+  terminal AI. The UI never reads the drawing and never writes the contract itself.
+- **Stay in scope.** Producing and handing off the contract is the whole job — do not wire
+  editor Save/edit, 3D, or DXF here.
+- **Confidentiality.** The contract carries `source.path` and the drawing's content; it is
+  machine-local (`~/.floless/contracts/vectorize.json`) and never committed. Don't echo client
+  or project identifiers into files or commits.

package/dist/skills/floless-app-vectorize/scripts/extract_pdf.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Deterministic vector-PDF -> drawing.vector/v1 extractor (compose-time, no LLM).
+
+One PyMuPDF pass per page: every page.get_drawings() path becomes a geometry element
+(SVG `d` in DISPLAY coords) and every page.get_text("dict") span becomes a text element
+(baseline origin, real size, rotation). Emits a RAW drawing.vector/v1 contract ready to
+PUT to /api/contract/vectorize — the server's postProcess handles endpoint-snap, dedupe
+and layer derivation, but per-element ids are REQUIRED by the PUT schema, so this script
+assigns them (e1.. per sheet, s1.. sheets).
+
+Usage:
+
+  python extract_pdf.py drawing.pdf [more.pdf ...] [--out contract.json]
+
+The script forces UTF-8 on its own stdout/stderr (drawings contain glyphs like a diameter
+sign that crash Windows cp1250 consoles), so no shell-specific env setup is needed.
+
+Requires PyMuPDF (pip install pymupdf). A raster-only page (scan / photo / hand sketch)
+yields no geometry — that is the Slice-2 vision path, NOT this script's job; the caller
+must tell the user honestly instead of tracing pixels.
+"""
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+from datetime import datetime, timezone
+
+import fitz  # PyMuPDF
+
+
+def fmt(v):
+    """Compact numeric formatting for SVG path data."""
+    return f"{round(v, 2):g}"
+
+
+def rgb_hex(c):
+    """PyMuPDF float RGB tuple -> #rrggbb, or None."""
+    if c is None:
+        return None
+    r, g, b = (max(0, min(255, round(v * 255))) for v in c)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def int_hex(c):
+    """get_text span colour int (sRGB) -> #rrggbb."""
+    return f"#{(c or 0) & 0xFFFFFF:06x}"
+
+
+def path_to_element(pth, m):
+    """One get_drawings() path -> a geometry element dict (or None if it draws nothing).
+
+    Item -> SVG mapping: 'l' segments chain into M/L, 'c' cubic beziers into C,
+    're' rects and 'qu' quads into closed 4-corner polygons. Every point is mapped
+    through the page's rotation_matrix so a rotated page lands in display space.
+    """
+    d, pts, kinds = [], [], set()
+    cur = None
+    breaks = 0  # subpath breaks after the first M (disqualifies pts[])
+
+    def moveto(p):
+        nonlocal cur, breaks
+        if cur is not None:
+            breaks += 1
+        d.append(f"M{fmt(p.x)} {fmt(p.y)}")
+        pts.append([round(p.x, 2), round(p.y, 2)])
+        cur = p
+
+    def cont(p):
+        return cur is not None and abs(cur.x - p.x) < 1e-4 and abs(cur.y - p.y) < 1e-4
+
+    for item in pth["items"]:
+        op = item[0]
+        if op == "l":
+            p1, p2 = item[1] * m, item[2] * m
+            if abs(p1.x - p2.x) < 1e-6 and abs(p1.y - p2.y) < 1e-6:
+                continue  # zero-length
+            if not cont(p1):
+                moveto(p1)
+            d.append(f"L{fmt(p2.x)} {fmt(p2.y)}")
+            pts.append([round(p2.x, 2), round(p2.y, 2)])
+            cur = p2
+            kinds.add("l")
+        elif op == "c":
+            p1, c1, c2, p2 = (item[i] * m for i in (1, 2, 3, 4))
+            if not cont(p1):
+                moveto(p1)
+            d.append(f"C{fmt(c1.x)} {fmt(c1.y)} {fmt(c2.x)} {fmt(c2.y)} {fmt(p2.x)} {fmt(p2.y)}")
+            cur = p2
+            kinds.add("c")
+        elif op in ("re", "qu"):
+            q = item[1].quad if op == "re" else item[1]
+            ul, ur, lr, ll = (p * m for p in (q.ul, q.ur, q.lr, q.ll))
+            if cur is not None:
+                breaks += 1
+            d.append(
+                f"M{fmt(ul.x)} {fmt(ul.y)} L{fmt(ur.x)} {fmt(ur.y)} "
+                f"L{fmt(lr.x)} {fmt(lr.y)} L{fmt(ll.x)} {fmt(ll.y)} Z"
+            )
+            cur = None
+            kinds.add(op)
+
+    if not d:
+        return None
+    closed = bool(pth.get("closePath"))
+    if closed and not d[-1].endswith("Z"):
+        d.append("Z")
+
+    kind = "spline" if "c" in kinds else ("line" if kinds == {"l"} and len(pts) == 2 else "polyline")
+    el = {"kind": kind}
+    if kinds == {"l"} and breaks == 0 and len(pts) >= 2:
+        # Continuous straight-line chain: emit VERTICES ONLY (no `d`). Renderers rebuild the path
+        # from pts, and the server's endpoint-snap edits pts — a `d` alongside would shadow the
+        # snapped geometry (renderers prefer `d` when both are present).
+        if closed and pts[0] != pts[-1]:
+            pts.append(list(pts[0]))  # make the closing edge explicit — pts paths carry no Z
+        el["pts"] = pts
+        if len(pts) > 2:
+            el["kind"] = "polyline"
+    else:
+        el["d"] = " ".join(d)
+    color = rgb_hex(pth.get("color")) or rgb_hex(pth.get("fill"))
+    if color is None:
+        return None  # neither stroked nor filled -> draws nothing
+    el["color"] = color
+    if pth.get("width"):
+        el["w"] = round(pth["width"], 3)
+    dashes = (pth.get("dashes") or "").strip()
+    if dashes and dashes not in ("[] 0", "[]"):
+        el["dashed"] = True
+    if pth.get("layer"):
+        el["layer"] = pth["layer"]
+    return el
+
+
+def text_elements(page, m):
+    """get_text('dict') spans -> text elements with baseline origin, size, rotation, colour."""
+    rot = fitz.Matrix(m.a, m.b, m.c, m.d, 0, 0)  # rotation part only (for direction vectors)
+    out = []
+    for block in page.get_text("dict")["blocks"]:
+        if block.get("type") != 0:
+            continue
+        for line in block["lines"]:
+            dv = fitz.Point(line["dir"]) * rot
+            angle = round(math.degrees(math.atan2(dv.y, dv.x)), 2)
+            for span in line["spans"]:
+                if not span["text"].strip():
+                    continue
+                origin = fitz.Point(span["origin"]) * m
+                bbox = fitz.Rect(span["bbox"]) * m
+                bbox.normalize()
+                el = {
+                    "kind": "text",
+                    "text": span["text"],
+                    "origin": [round(origin.x, 2), round(origin.y, 2)],
+                    "bbox": [round(v, 2) for v in (bbox.x0, bbox.y0, bbox.x1, bbox.y1)],
+                    "size": round(span["size"], 2),
+                    "color": int_hex(span.get("color")),
+                }
+                if span.get("font"):
+                    el["font"] = span["font"]
+                if abs(angle) > 0.01:
+                    el["angle"] = angle
+                out.append(el)
+    return out
+
+
+def extract(paths):
+    sheets = []
+    for path in paths:
+        doc = fitz.open(path)
+        stem = os.path.splitext(os.path.basename(path))[0]
+        for pno in range(doc.page_count):
+            page = doc[pno]
+            m = page.rotation_matrix  # unrotated -> display space; page.rect is already display
+            elements = []
+            for pth in page.get_drawings():
+                el = path_to_element(pth, m)
+                if el:
+                    elements.append(el)
+            elements.extend(text_elements(page, m))
+            for i, el in enumerate(elements):
+                el["id"] = f"e{i + 1}"  # PUT schema requires ids; stable in document order
+            sheets.append({
+                "id": f"s{len(sheets) + 1}",
+                "label": f"{stem} p{pno + 1}",
+                "page": {"w": round(page.rect.width, 2), "h": round(page.rect.height, 2)},
+                "elements": elements,
+            })
+        doc.close()
+
+    first = paths[0]
+    name = os.path.basename(first) + (f" (+{len(paths) - 1} more)" if len(paths) > 1 else "")
+    return {
+        "type": "drawing.vector/v1",
+        "units": "pt",  # no transform emitted -> display space (PDF points) is world 1:1
+        "source": {
+            "name": name,
+            "path": os.path.abspath(first),
+            "kind": "pdf",
+            "sha256": hashlib.sha256(open(first, "rb").read()).hexdigest(),
+            "read_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+            "extractor": f"pymupdf@compose-time ({getattr(fitz, 'VersionBind', '?')})",
+        },
+        "sheets": sheets,
+    }
+
+
+def main():
+    # Self-sufficient UTF-8 output regardless of console codepage (Windows cp1250 crashes on Ø/—).
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except AttributeError:
+            pass
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("pdfs", nargs="+", help="vector PDF file(s) to extract")
+    ap.add_argument("--out", help="write the contract JSON here instead of stdout")
+    args = ap.parse_args()
+
+    contract = extract(args.pdfs)
+    total = sum(len(s["elements"]) for s in contract["sheets"])
+    if total == 0:
+        print(
+            "WARNING: no vector geometry or text found — this looks like a raster-only PDF "
+            "(scan/photo). The deterministic path cannot read it; do not fabricate linework.",
+            file=sys.stderr,
+        )
+    if args.out:
+        with open(args.out, "w", encoding="utf-8") as f:
+            json.dump(contract, f, ensure_ascii=False)
+        print(f"{args.out}: {len(contract['sheets'])} sheet(s), {total} element(s)", file=sys.stderr)
+    else:
+        json.dump(contract, sys.stdout, ensure_ascii=False)
+
+
+if __name__ == "__main__":
+    main()

package/dist/templates/vectorize.flo

@@ -0,0 +1,61 @@
+app:           vectorize
+version:       0.1.0
+display-name:  Vectorize
+publisher:     floless
+description: |
+  Turn any drawing — a sketch, a PDF, a photo — into clean, editable 2D vectors. Your terminal AI
+  reads the drawing ONCE at compose time (a deterministic PyMuPDF pass — no LLM) and bakes it into a
+  drawing.vector contract; double-click the node to open the 2D vector editor, where you pan and zoom,
+  toggle what's shown, flag weak traces, and export SVG. Attach a drawing and use "Re-read & re-bake ▸"
+  (or ask your terminal AI) to vectorize your own; the deterministic run just re-renders a short summary
+  of what was read. Ships with a tiny example so it works out of the box.
+exposes-as-agent: false
+# Workflow changelog (FloLess-published). Newest first; the app shows entries newer than the installed
+# version when offering an update. Plain-English — it surfaces to the user.
+changelog:
+  - version: 0.1.0
+    summary: Vectorize a drawing into clean 2D linework you can edit and export
+inputs:
+  drawing:
+    type: image
+    widget: file
+    accept: [pdf, png, jpg]
+    read-strategy: bake
+    description: A drawing to vectorize — read by your terminal AI into clean 2D vectors; swap to re-read & re-bake.
+requires:
+  - html-report@0.2.x
+layout: linear
+nodes:
+  # ── node 1: read — vectorize the drawing into clean 2D linework ───────────────
+  # This is where your drawing becomes editable vectors. Your terminal AI reads the
+  # attached drawing once (a deterministic PyMuPDF pass — no LLM) and bakes every line,
+  # curve and label into the contract. Double-click this node to open the 2D vector
+  # editor: pan and zoom the drawing, toggle Lines / Curves / Text, flag any weak traces,
+  # and Export SVG. `contract` tells FloLess which editor to open; `takeoff` is the single
+  # source the editor, Approve and the run all read. It ships with a tiny EXAMPLE so it
+  # renders out of the box — "Re-read & re-bake ▸" replaces it with your own drawing. The
+  # deterministic run re-renders the short summary below.
+  - id: read
+    agent: html-report
+    command: render
+    config:
+      contract: drawing.vector/v1
+      takeoff:
+        type: drawing.vector/v1
+        units: mm
+        source: { name: "Example — sample detail (not your drawing)" }
+        sheets:
+          - id: s1
+            label: "Sample detail"
+            page: { w: 300, h: 200 }
+            elements:
+              - { id: e1, kind: polyline, d: "M60 50 H240 V150 H60 Z", color: "#334155", w: 1.4 }
+              - { id: e2, kind: line, d: "M150 30 L150 170", color: "#94a3b8", w: 0.8, dashed: true }
+              - { id: e3, kind: line, d: "M60 100 H240", color: "#94a3b8", w: 0.8 }
+              - { id: t1, kind: text, text: "SAMPLE DETAIL", size: 11, origin: [66, 44], color: "#334155" }
+              - { id: t2, kind: text, text: "PL 13mm", size: 9, origin: [98, 96], color: "#334155" }
+      title: "Vectorized drawing"
+      data:
+        - { Kind: Lines, Count: 3 }
+        - { Kind: Text, Count: 2 }
+connections: []

package/dist/web/aware.js

@@ -1752,9 +1752,9 @@
   function openContractEditor(appId, type) {
     const r = window.CONTRACT_RENDERERS && window.CONTRACT_RENDERERS[type];
     if (!r) return false;
-    // The editor bakes the .lock on Approve — that control belongs to the contract editor, not the
-    // filter view (which has its own Save). Make sure it's visible here (openFilterView hides it).
-    const ap0 = document.getElementById('contract-editor-approve'); if (ap0) ap0.hidden = false;
+    // The editor bakes the .lock on Approve — that control belongs to an editable contract editor, not
+    // the filter view (own Save) nor a view-only renderer. Show it unless the renderer is viewOnly.
+    const ap0 = document.getElementById('contract-editor-approve'); if (ap0) ap0.hidden = !!r.viewOnly;
     $contractEditorTitle.replaceChildren(
       Object.assign(document.createElement('span'), { textContent: appId, style: 'color:var(--text);font-weight:600' }),
       Object.assign(document.createElement('span'), { textContent: ' · ' + type, style: 'color:var(--text-muted)' }),

package/dist/web/renderers.js

@@ -13,6 +13,12 @@ window.CONTRACT_RENDERERS = {
   'steel.takeoff/v1': {
     editorUrl: (appId) => '/steel-editor.html?app=' + encodeURIComponent(appId),
   },
+  'drawing.vector/v1': {
+    editorUrl: (appId) => '/vector-editor.html?app=' + encodeURIComponent(appId),
+    // View-only for now: the vector editor renders + exports SVG but has no Save/edit path yet (the
+    // edit/re-bake flow is a later slice), so the shell hides its Approve button (see openContractEditor).
+    viewOnly: true,
+  },
 };
 
 // Return the contract type string declared on a node, or null when none.

package/dist/web/vector-editor.html

@@ -0,0 +1,289 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Vectorize — 2D editor</title>
+<style>
+  /* Locked baseline: shadcn dark slate-blue (identical tokens + scrollbar theming as steel-editor.html). */
+  :root{--bg:#0f172a;--panel:#1e293b;--line:#334155;--text:#e2e8f0;--mut:#94a3b8;--brand:#3b82f6;--paper:#f8fafc}
+  *{scrollbar-width:thin;scrollbar-color:#475569 transparent}
+  *::-webkit-scrollbar{width:10px;height:10px}
+  *::-webkit-scrollbar-track{background:transparent}
+  *::-webkit-scrollbar-thumb{background:#475569;border-radius:6px;border:2px solid transparent;background-clip:content-box}
+  *::-webkit-scrollbar-thumb:hover{background:#5b6b85;background-clip:content-box}
+  *::-webkit-scrollbar-corner{background:transparent}
+  *{box-sizing:border-box}
+  body{margin:0;background:var(--bg);color:var(--text);font:13px system-ui;height:100vh;display:flex;flex-direction:column;overflow:hidden}
+  header{display:flex;align-items:center;gap:14px;padding:8px 14px;background:var(--panel);border-bottom:1px solid var(--line);flex:none}
+  header b{font-size:14px}
+  header .spacer{flex:1}
+  .stat{color:var(--mut)} .stat b{color:var(--text);font-variant-numeric:tabular-nums}
+  button{height:28px;padding:0 12px;background:var(--line);color:var(--text);border:1px solid var(--line);border-radius:6px;cursor:pointer;font:inherit}
+  button:hover{background:#475569}
+  button.primary{background:var(--brand);border-color:var(--brand);color:#fff}
+  button.primary:hover{filter:brightness(1.08)}
+  #wrap{flex:1;display:flex;min-height:0}
+  #stage{flex:1;position:relative;background:var(--paper);overflow:hidden;min-width:0}
+  #svg{position:absolute;inset:0;width:100%;height:100%;touch-action:none;cursor:grab}
+  #svg.panning{cursor:grabbing}
+  #svg path{stroke-linecap:round;stroke-linejoin:round}
+  #svg .weak{stroke:#f59e0b!important} #svg text.weak{fill:#f59e0b!important}
+  #svg .hidden{display:none}
+  #state{position:absolute;inset:0;display:none;align-items:center;justify-content:center;flex-direction:column;gap:10px;background:var(--bg);color:var(--mut);text-align:center;padding:24px}
+  #state.show{display:flex}
+  #state .spin{width:26px;height:26px;border:3px solid var(--line);border-top-color:var(--brand);border-radius:50%;animation:spin .8s linear infinite}
+  @keyframes spin{to{transform:rotate(360deg)}}
+  aside{width:244px;flex:none;background:var(--panel);border-left:1px solid var(--line);padding:12px;overflow:auto;display:flex;flex-direction:column;gap:14px}
+  aside h3{margin:0;font-size:10px;color:var(--mut);text-transform:uppercase;letter-spacing:.06em}
+  .ck{display:flex;align-items:center;gap:8px;padding:5px 6px;border-radius:6px;cursor:pointer;color:var(--text)}
+  .ck:hover{background:var(--line)}
+  .ck input{accent-color:var(--brand);cursor:pointer;margin:0}
+  .ck .ct{margin-left:auto;color:var(--mut);font-variant-numeric:tabular-nums;font-size:11px}
+  .muted{color:var(--mut);font-size:12px;line-height:1.5}
+  hr{border:0;border-top:1px solid var(--line);margin:0}
+  #zoombar{position:absolute;left:12px;bottom:12px;display:flex;align-items:center;gap:8px;background:var(--panel);border:1px solid var(--line);border-radius:8px;padding:6px 10px;box-shadow:0 4px 14px rgba(0,0,0,.45);z-index:5}
+  #zoombar input[type=range]{width:120px;padding:0;accent-color:var(--brand)}
+  #zoombar #zpct{min-width:42px;text-align:right;color:var(--mut);font-variant-numeric:tabular-nums}
+  #zoombar .ghost{height:24px;padding:0 8px;background:transparent;border:1px solid var(--line);color:var(--mut);border-radius:5px;font-size:11px}
+  #zoombar .ghost:hover{color:var(--text);border-color:var(--brand)}
+</style>
+</head>
+<body>
+  <header>
+    <b>Vectorize</b>
+    <span class="stat" id="title">—</span>
+    <span class="spacer"></span>
+    <span class="stat"><b id="nEl">0</b> elements · <b id="nTx">0</b> text</span>
+    <button class="primary" id="exportBtn" disabled>Export SVG</button>
+  </header>
+  <div id="wrap">
+    <div id="stage">
+      <svg id="svg" xmlns="http://www.w3.org/2000/svg"></svg>
+      <div id="state" class="show"><div class="spin"></div><div id="stateMsg">Loading drawing…</div></div>
+      <div id="zoombar">
+        <button class="ghost" id="fitBtn" title="Fit to view">Fit</button>
+        <input type="range" id="zoom" min="10" max="800" value="100" aria-label="Zoom">
+        <span id="zpct">100%</span>
+      </div>
+    </div>
+    <aside>
+      <div>
+        <h3>Show</h3>
+        <label class="ck"><input type="checkbox" id="kLines" checked><span>Lines</span><span class="ct" id="cLines">0</span></label>
+        <label class="ck"><input type="checkbox" id="kCurves" checked><span>Curves</span><span class="ct" id="cCurves">0</span></label>
+        <label class="ck"><input type="checkbox" id="kText" checked><span>Text</span><span class="ct" id="cText">0</span></label>
+      </div>
+      <hr>
+      <div>
+        <h3>Layers</h3>
+        <div id="layers"><div class="muted">No layers in this drawing.</div></div>
+      </div>
+      <hr>
+      <div>
+        <h3>Confidence</h3>
+        <label class="ck" id="weakRow" hidden><input type="checkbox" id="weakOnly"><span>Isolate weak traces</span><span class="ct" id="cWeak">0</span></label>
+        <div class="muted" id="weakNote">No weak traces — read deterministically.</div>
+      </div>
+    </aside>
+  </div>
+<script>
+(function () {
+  'use strict';
+  const $ = (id) => document.getElementById(id);
+  const SVGNS = 'http://www.w3.org/2000/svg';
+  const svg = $('svg');
+  const params = new URLSearchParams(location.search);
+  const app = params.get('app');
+  const src = params.get('src') || (app ? ('/api/contract/' + encodeURIComponent(app)) : '/vector-example.json');
+  const WEAK = 0.5;
+
+  let sheet = null;
+  let view = { x: 0, y: 0, w: 100, h: 100 };
+
+  function showState(msg) { $('stateMsg').textContent = msg; $('state').classList.add('show'); $('state').querySelector('.spin').style.display = msg ? 'none' : ''; }
+  function hideState() { $('state').classList.remove('show'); }
+
+  // Build an SVG polyline path from explicit points (a line/polyline carrying pts but no d).
+  function ptsPath(pts) {
+    if (!pts || pts.length < 2) return '';
+    return pts.map((p, i) => (i === 0 ? 'M' : 'L') + (+p[0] || 0) + ' ' + (+p[1] || 0)).join(' ');
+  }
+  // Build one element as a real SVG DOM node (safe — setAttribute / textContent, no innerHTML).
+  function makeNode(el) {
+    const weak = (el.confidence != null && el.confidence < WEAK);
+    if (el.kind === 'text') {
+      if (!el.text) return null;
+      const ox = (el.origin && el.origin[0] != null) ? el.origin[0] : (el.bbox ? el.bbox[0] : 0);
+      const oy = (el.origin && el.origin[1] != null) ? el.origin[1] : (el.bbox ? (el.bbox[3] != null ? el.bbox[3] : el.bbox[1]) : 0);
+      const t = document.createElementNS(SVGNS, 'text');
+      t.setAttribute('x', ox); t.setAttribute('y', oy);
+      t.setAttribute('font-size', el.size != null ? el.size : 4);
+      t.setAttribute('fill', el.color || '#334155');
+      if (el.angle) t.setAttribute('transform', 'rotate(' + el.angle + ' ' + ox + ' ' + oy + ')');
+      t.textContent = el.text;
+      tag(t, el, 'text', weak);
+      return t;
+    }
+    const d = el.d || ptsPath(el.pts);
+    if (!d) return null;
+    const p = document.createElementNS(SVGNS, 'path');
+    p.setAttribute('d', d);
+    p.setAttribute('fill', 'none');
+    p.setAttribute('stroke', el.color || '#334155');
+    p.setAttribute('stroke-width', el.w || 1);
+    p.setAttribute('vector-effect', 'non-scaling-stroke');
+    if (el.dashed) p.setAttribute('stroke-dasharray', '3 2');
+    tag(p, el, (el.kind === 'line' || el.kind === 'polyline') ? 'lines' : 'curves', weak);
+    return p;
+  }
+  function tag(node, el, group, weak) {
+    node.setAttribute('class', 'el' + (weak ? ' weak' : ''));
+    node.dataset.kind = el.kind;
+    node.dataset.group = group;
+    node.dataset.layer = el.layer || '';
+    node.dataset.id = el.id || '';
+  }
+
+  function render() {
+    while (svg.firstChild) svg.removeChild(svg.firstChild);
+    const frag = document.createDocumentFragment();
+    for (const el of sheet.elements) { const n = makeNode(el); if (n) frag.appendChild(n); }
+    svg.appendChild(frag);
+    applyVisibility();
+  }
+
+  function counts() {
+    let lines = 0, curves = 0, text = 0, weak = 0;
+    for (const el of sheet.elements) {
+      if (el.kind === 'text') text++;
+      else if (el.kind === 'line' || el.kind === 'polyline') lines++;
+      else curves++;
+      if (el.confidence != null && el.confidence < WEAK) weak++;
+    }
+    return { lines, curves, text, weak };
+  }
+
+  function applyVisibility() {
+    const showLines = $('kLines').checked, showCurves = $('kCurves').checked, showText = $('kText').checked;
+    const off = new Set([...document.querySelectorAll('#layers input:not(:checked)')].map((i) => i.dataset.layer));
+    const weakOnly = $('weakOnly').checked;
+    for (const node of svg.children) {
+      const g = node.dataset.group;
+      let vis = g === 'text' ? showText : g === 'lines' ? showLines : showCurves;
+      if (vis && node.dataset.layer && off.has(node.dataset.layer)) vis = false;
+      if (vis && weakOnly) vis = node.classList.contains('weak');
+      node.classList.toggle('hidden', !vis);
+    }
+  }
+
+  function pageW() { return (sheet.page && sheet.page.w) || 100; }
+  function pageH() { return (sheet.page && sheet.page.h) || 100; }
+  function setViewBox() { svg.setAttribute('viewBox', view.x + ' ' + view.y + ' ' + view.w + ' ' + view.h); }
+  function baseScale() { const r = svg.getBoundingClientRect(); return Math.min(r.width / (pageW() * 1.08), r.height / (pageH() * 1.08)) || 1; }
+  function curScale() { const r = svg.getBoundingClientRect(); return (r.width / view.w) || 1; }
+  function syncZoom() { const pct = Math.round((curScale() / baseScale()) * 100); $('zoom').value = Math.max(10, Math.min(800, pct)); $('zpct').textContent = pct + '%'; }
+  function fit() { const m = Math.max(pageW(), pageH()) * 0.04; view = { x: -m, y: -m, w: pageW() + 2 * m, h: pageH() + 2 * m }; setViewBox(); syncZoom(); }
+
+  svg.addEventListener('wheel', (e) => {
+    e.preventDefault();
+    const r = svg.getBoundingClientRect();
+    const px = view.x + ((e.clientX - r.left) / r.width) * view.w;
+    const py = view.y + ((e.clientY - r.top) / r.height) * view.h;
+    const f = e.deltaY < 0 ? 0.9 : 1.1;
+    view.w *= f; view.h *= f;
+    view.x = px - ((e.clientX - r.left) / r.width) * view.w;
+    view.y = py - ((e.clientY - r.top) / r.height) * view.h;
+    setViewBox(); syncZoom();
+  }, { passive: false });
+
+  let pan = null;
+  svg.addEventListener('pointerdown', (e) => { pan = { x: e.clientX, y: e.clientY, vx: view.x, vy: view.y }; svg.setPointerCapture(e.pointerId); svg.classList.add('panning'); });
+  svg.addEventListener('pointermove', (e) => {
+    if (!pan) return;
+    const r = svg.getBoundingClientRect();
+    view.x = pan.vx - (e.clientX - pan.x) * (view.w / r.width);
+    view.y = pan.vy - (e.clientY - pan.y) * (view.h / r.height);
+    setViewBox();
+  });
+  const endPan = () => { pan = null; svg.classList.remove('panning'); };
+  svg.addEventListener('pointerup', endPan); svg.addEventListener('pointercancel', endPan);
+
+  $('zoom').addEventListener('input', (e) => {
+    const pct = +e.target.value, target = baseScale() * (pct / 100), r = svg.getBoundingClientRect();
+    const cx = view.x + view.w / 2, cy = view.y + view.h / 2;
+    view.w = r.width / target; view.h = r.height / target; view.x = cx - view.w / 2; view.y = cy - view.h / 2;
+    setViewBox(); $('zpct').textContent = pct + '%';
+  });
+  $('fitBtn').addEventListener('click', fit);
+  ['kLines', 'kCurves', 'kText', 'weakOnly'].forEach((id) => $(id).addEventListener('change', applyVisibility));
+
+  // Export the visible drawing as a standalone SVG — clone the live nodes and serialize (no string HTML).
+  $('exportBtn').addEventListener('click', () => {
+    if (!sheet) return; // nothing loaded yet — guard against a null-sheet deref
+    const out = document.createElementNS(SVGNS, 'svg');
+    out.setAttribute('xmlns', SVGNS);
+    out.setAttribute('viewBox', '0 0 ' + pageW() + ' ' + pageH());
+    out.setAttribute('width', pageW()); out.setAttribute('height', pageH());
+    for (const node of svg.children) {
+      if (node.classList.contains('hidden')) continue;
+      const c = node.cloneNode(true);
+      c.removeAttribute('class');
+      out.appendChild(c);
+    }
+    const doc = new XMLSerializer().serializeToString(out);
+    const blob = new Blob([doc], { type: 'image/svg+xml' });
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = String((sheet.label || 'drawing')).replace(/[^a-z0-9._-]+/gi, '-') + '.svg';
+    document.body.appendChild(a); a.click(); a.remove();
+    URL.revokeObjectURL(a.href);
+  });
+
+  function buildLayers() {
+    const box = $('layers');
+    while (box.firstChild) box.removeChild(box.firstChild);
+    const layers = (sheet.layers || []).filter((l) => l && l.name);
+    if (!layers.length) {
+      const d = document.createElement('div'); d.className = 'muted'; d.textContent = 'No layers in this drawing.'; box.appendChild(d); return;
+    }
+    for (const l of layers) {
+      const lab = document.createElement('label'); lab.className = 'ck';
+      const inp = document.createElement('input'); inp.type = 'checkbox'; inp.checked = true; inp.dataset.layer = l.name;
+      inp.addEventListener('change', applyVisibility);
+      const nm = document.createElement('span'); nm.textContent = l.name;
+      const ct = document.createElement('span'); ct.className = 'ct'; ct.textContent = String(l.count || 0);
+      lab.append(inp, nm, ct); box.appendChild(lab);
+    }
+  }
+
+  function load(contract) {
+    if (!contract || !Array.isArray(contract.sheets) || !contract.sheets.length) { showState('This app has no vectorized drawing yet. Drop a PDF and re-bake to read one.'); return; }
+    sheet = contract.sheets[contract.active || 0] || contract.sheets[0];
+    if (!sheet || !Array.isArray(sheet.elements)) { showState('The drawing has no elements.'); return; }
+    const c = counts();
+    const name = (contract.source && contract.source.name) ? contract.source.name : (sheet.label || 'drawing');
+    $('title').textContent = name;
+    document.title = 'Vectorize — ' + name;
+    $('nEl').textContent = sheet.elements.length; $('nTx').textContent = c.text;
+    $('cLines').textContent = c.lines; $('cCurves').textContent = c.curves; $('cText').textContent = c.text;
+    $('cWeak').textContent = c.weak;
+    $('weakNote').textContent = c.weak ? (c.weak + ' trace' + (c.weak === 1 ? '' : 's') + ' below ' + WEAK + ' confidence.') : 'No weak traces — read deterministically.';
+    $('weakRow').hidden = c.weak === 0; // hide the filter when there's nothing to filter (not disabled)
+    buildLayers();
+    render(); fit(); $('exportBtn').disabled = false; hideState();
+  }
+
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 15000);
+  fetch(src, { headers: { accept: 'application/json' }, signal: ctrl.signal })
+    .then((r) => { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
+    .then(load)
+    .catch((e) => showState(e.name === 'AbortError' ? 'Loading timed out — is the server reachable?' : ('Could not load the drawing (' + e.message + ').')))
+    .finally(() => clearTimeout(timer));
+
+  window.addEventListener('resize', () => { if (sheet) syncZoom(); });
+})();
+</script>
+</body>
+</html>

package/dist/web/vector-example.json

@@ -0,0 +1,107 @@
+{
+  "type": "drawing.vector/v1",
+  "units": "mm",
+  "source": {
+    "name": "vectorize-detail.pdf",
+    "kind": "pdf",
+    "extractor": "pymupdf@compose-time"
+  },
+  "sheets": [
+    {
+      "id": "s1",
+      "label": "page 1",
+      "page": {
+        "w": 300,
+        "h": 220
+      },
+      "elements": [
+        {
+          "kind": "polyline",
+          "d": "M90.0 70.0 H210.0 V170.0 H90.0 Z",
+          "color": "#000000",
+          "w": 1.4,
+          "id": "e1"
+        },
+        {
+          "kind": "polyline",
+          "d": "M120.0 100.0 H180.0 V140.0 H120.0 Z",
+          "color": "#667084",
+          "w": 1,
+          "id": "e2"
+        },
+        {
+          "kind": "spline",
+          "d": "M100.0 85.0 C100.0 87.8 102.2 90.0 105.0 90.0 M105.0 90.0 C107.8 90.0 110.0 87.8 110.0 85.0 M110.0 85.0 C110.0 82.2 107.8 80.0 105.0 80.0 M105.0 80.0 C102.2 80.0 100.0 82.2 100.0 85.0",
+          "color": "#db2626",
+          "w": 1,
+          "id": "e3"
+        },
+        {
+          "kind": "spline",
+          "d": "M190.0 85.0 C190.0 87.8 192.2 90.0 195.0 90.0 M195.0 90.0 C197.8 90.0 200.0 87.8 200.0 85.0 M200.0 85.0 C200.0 82.2 197.8 80.0 195.0 80.0 M195.0 80.0 C192.2 80.0 190.0 82.2 190.0 85.0",
+          "color": "#db2626",
+          "w": 1,
+          "id": "e4"
+        },
+        {
+          "kind": "spline",
+          "d": "M100.0 155.0 C100.0 157.8 102.2 160.0 105.0 160.0 M105.0 160.0 C107.8 160.0 110.0 157.8 110.0 155.0 M110.0 155.0 C110.0 152.2 107.8 150.0 105.0 150.0 M105.0 150.0 C102.2 150.0 100.0 152.2 100.0 155.0",
+          "color": "#db2626",
+          "w": 1,
+          "id": "e5"
+        },
+        {
+          "kind": "spline",
+          "d": "M190.0 155.0 C190.0 157.8 192.2 160.0 195.0 160.0 M195.0 160.0 C197.8 160.0 200.0 157.8 200.0 155.0 M200.0 155.0 C200.0 152.2 197.8 150.0 195.0 150.0 M195.0 150.0 C192.2 150.0 190.0 152.2 190.0 155.0",
+          "color": "#db2626",
+          "w": 1,
+          "id": "e6"
+        },
+        {
+          "kind": "line",
+          "d": "M210.0 70.0 L250.0 55.0",
+          "color": "#667084",
+          "w": 0.8,
+          "id": "e7"
+        },
+        {
+          "kind": "text",
+          "text": "BASE PLATE PL1/2",
+          "bbox": [
+            96,
+            50.3,
+            177,
+            62.7
+          ],
+          "origin": [
+            96,
+            60
+          ],
+          "size": 9,
+          "color": "#000000",
+          "font": "Helvetica",
+          "id": "e8"
+        },
+        {
+          "kind": "text",
+          "text": "4x Ø22",
+          "bbox": [
+            214,
+            43.4,
+            239.8,
+            54.4
+          ],
+          "origin": [
+            214,
+            52
+          ],
+          "size": 8,
+          "color": "#db2626",
+          "font": "Helvetica",
+          "id": "e9"
+        }
+      ],
+      "layers": []
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floless/app",
-  "version": "0.59.1",
+  "version": "0.60.0",
   "type": "module",
   "description": "Thin localhost host for floless.app — serves web/ and shells the aware CLI. No engine, no LLM.",
   "bin": {