@floless/app 0.32.0 → 0.33.0

package/dist/floless-server.cjs

@@ -52835,7 +52835,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.32.0" : void 0,
+    define: true ? "0.33.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -52845,7 +52845,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.32.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.33.0" : void 0 });
 }
 
 // oauth-presets.ts
@@ -53838,6 +53838,18 @@ function bakeSceneIntoApp(sourcePath, scene, agent = "viewer-3d") {
   doc2.setIn(["nodes", idx, "config", "scene"], scene);
   (0, import_node_fs18.writeFileSync)(sourcePath, doc2.toString());
 }
+function bakeNodeConfigById(sourcePath, nodeId, patch) {
+  const doc2 = (0, import_yaml5.parseDocument)((0, import_node_fs18.readFileSync)(sourcePath, "utf8"));
+  if (doc2.errors.length > 0) {
+    throw new Error(`node bake: source is not valid YAML: ${doc2.errors[0]?.message ?? "parse error"}`);
+  }
+  const seq = doc2.get("nodes");
+  const items = (0, import_yaml5.isSeq)(seq) ? seq.items : [];
+  const idx = items.findIndex((it) => ((0, import_yaml5.isMap)(it) ? it.toJSON() : null)?.id === nodeId);
+  if (idx < 0) throw new Error(`no node with id "${nodeId}"`);
+  for (const [key, value] of Object.entries(patch)) doc2.setIn(["nodes", idx, "config", key], value);
+  (0, import_node_fs18.writeFileSync)(sourcePath, doc2.toString());
+}
 function writeViewer3dApp(dir, appId, scene) {
   (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
   const flo = (0, import_node_path15.join)(dir, `${appId}.flo`);
@@ -53861,6 +53873,140 @@ function writeViewer3dApp(dir, appId, scene) {
   bakeSceneIntoApp(flo, scene);
   return flo;
 }
+function writeIfcApp(dir, appId, scene, outputPath) {
+  (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
+  const flo = (0, import_node_path15.join)(dir, `${appId}.flo`);
+  (0, import_node_fs18.writeFileSync)(flo, [
+    `app: ${appId}`,
+    "version: 0.1.0",
+    "display-name: Steel IFC",
+    "description: IFC file written from an approved steel.takeoff/v1 contract (a companion export; the contract is the source of truth).",
+    "exposes-as-agent: false",
+    "requires:",
+    "  - ifc@0.1.x",
+    "layout: linear",
+    "nodes:",
+    "  - id: bake-ifc",
+    "    agent: ifc",
+    "    command: write",
+    "    config:",
+    `      output-path: ${JSON.stringify(outputPath)}`,
+    // the ifc agent's input key is hyphenated
+    "      scene: {}",
+    ""
+  ].join("\n"));
+  bakeSceneIntoApp(flo, scene, "ifc");
+  return flo;
+}
+function writeTeklaApp(dir, appId, scene, teklaVersion = "2026.0") {
+  (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
+  const flo = (0, import_node_path15.join)(dir, `${appId}.flo`);
+  (0, import_node_fs18.writeFileSync)(flo, [
+    `app: ${appId}`,
+    "version: 0.1.0",
+    "display-name: Steel to Tekla",
+    "description: Native Tekla parts created from an approved steel.takeoff/v1 contract (a companion bake; the contract is the source of truth). Needs Tekla open with a model.",
+    "exposes-as-agent: false",
+    "requires:",
+    "  - tekla@0.1.x",
+    "layout: linear",
+    "nodes:",
+    "  - id: bake-tekla",
+    "    agent: tekla",
+    "    command: bake-scene",
+    "    mode: write",
+    "    safety:",
+    "      snapshot: true",
+    // one Tekla Undo reverts the whole bake (required: write-mode needs a safety block)
+    "    config:",
+    `      version: ${JSON.stringify(teklaVersion)}`,
+    "      scene: {}",
+    ""
+  ].join("\n"));
+  bakeSceneIntoApp(flo, scene, "tekla");
+  return flo;
+}
+
+// bom-format.ts
+var round1 = (n) => Math.round(n * 10) / 10;
+function contractToBom(contractInput) {
+  const c = contractInput ?? {};
+  const weights = c.weights ?? {};
+  const agg = /* @__PURE__ */ new Map();
+  for (const plan of c.plans ?? []) {
+    const ptPerFt = typeof plan.pt_per_ft === "number" && plan.pt_per_ft > 0 ? plan.pt_per_ft : 12;
+    for (const m of plan.members ?? []) {
+      const profile = m.profile;
+      if (!profile) continue;
+      const plf = weights[profile];
+      if (plf == null) continue;
+      let lenFt;
+      if (m.role === "column") {
+        const tos = m.col?.tos;
+        const bos = m.col?.bos;
+        if (tos == null || bos == null) continue;
+        lenFt = Math.abs(tos - bos) / 12;
+      } else {
+        const wp = m.wp;
+        if (!Array.isArray(wp) || wp.length < 2) continue;
+        const a = wp[0];
+        const b = wp[1];
+        if (!a || !b) continue;
+        lenFt = Math.hypot(a[0] - b[0], a[1] - b[1]) / ptPerFt;
+      }
+      const g = agg.get(profile) ?? { qty: 0, lenFt: 0, plf };
+      g.qty += 1;
+      g.lenFt += lenFt;
+      agg.set(profile, g);
+    }
+  }
+  const rows = [...agg.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([profile, g]) => ({
+    Profile: profile,
+    Qty: g.qty,
+    "Length (ft)": round1(g.lenFt),
+    "lb/ft": g.plf,
+    "Weight (lb)": Math.round(g.lenFt * g.plf)
+  }));
+  const totalLb = rows.reduce((t, r) => t + r["Weight (lb)"], 0);
+  const totalQty = rows.reduce((t, r) => t + r.Qty, 0);
+  const totalLenFt = round1(rows.reduce((t, r) => t + r["Length (ft)"], 0));
+  const totalTons = round1(totalLb / 2e3);
+  rows.push({
+    Profile: "TOTAL",
+    Qty: totalQty,
+    "Length (ft)": totalLenFt,
+    "lb/ft": "",
+    "Weight (lb)": totalLb
+  });
+  return {
+    title: `Bill of Materials \u2014 ${totalTons} tons (${totalLb.toLocaleString("en-US")} lb)`,
+    columns: ["Profile", "Qty", "Length (ft)", "lb/ft", "Weight (lb)"],
+    rows,
+    totalLb,
+    totalTons
+  };
+}
+
+// downstream-bake.ts
+function bakeDownstream(sourcePath, contract) {
+  const { scene } = contractToScene(contract);
+  let sceneElements = 0;
+  try {
+    bakeSceneIntoApp(sourcePath, scene);
+    sceneElements = scene.elements.length;
+  } catch (e) {
+    if (!(e instanceof Error && /no viewer-3d render node/.test(e.message))) throw e;
+  }
+  const bom = contractToBom(contract);
+  let bomRows = 0;
+  try {
+    bakeNodeConfigById(sourcePath, "bom", { data: bom.rows, title: bom.title, columns: bom.columns });
+    bomRows = bom.rows.length;
+  } catch (e) {
+    if (!(e instanceof Error && /no node with id "bom"/.test(e.message))) throw e;
+  }
+  return { sceneElements, bomRows };
+}
 
 // app-lifecycle.ts
 var import_node_fs21 = require("node:fs");
@@ -54781,7 +54927,7 @@ function isGatedAwareRoute(url, method) {
   if (path === "/api/trigger-run") return m === "POST";
   if (path.startsWith("/api/app/")) return m === "PATCH" || m === "POST" || m === "DELETE";
   if (path.startsWith("/api/contract/")) {
-    return m === "POST" && (path.endsWith("/approve") || path.endsWith("/export-3d"));
+    return m === "POST" && (path.endsWith("/approve") || path.endsWith("/export-3d") || path.endsWith("/export-ifc") || path.endsWith("/export-tekla"));
   }
   return AWARE_ROUTES.some((p) => path.startsWith(p));
 }
@@ -58194,6 +58340,7 @@ async function startServer() {
     const sourcePath = readApp(req.params.appId).source.path;
     try {
       bakeContractIntoApp(sourcePath, doc2);
+      bakeDownstream(sourcePath, doc2);
     } catch (e) {
       return reply.status(422).send({ ok: false, error: e instanceof Error ? e.message : "bake failed" });
     }
@@ -58255,6 +58402,102 @@ async function startServer() {
     broadcast({ type: "apps-changed" });
     return { ok: true, report: { ...extracted, interactive: true }, skipped };
   });
+  app.post("/api/contract/:appId/export-ifc", async (req, reply) => {
+    const doc2 = readContract(req.params.appId);
+    if (doc2 == null) return reply.status(404).send({ ok: false, error: "no contract to export" });
+    const v = validateSteelTakeoff(doc2);
+    if (!v.valid) return reply.status(400).send({ ok: false, error: "stored contract is invalid \u2014 re-save it in the editor" });
+    const { scene, skipped } = contractToScene(doc2);
+    if (scene.elements.length === 0) {
+      return reply.status(422).send({ ok: false, error: "no resolvable members to export \u2014 every member is an RFI (no AISC size yet)", skipped });
+    }
+    const companionId = `${req.params.appId}-ifc`;
+    const filename = `${req.params.appId}.ifc`;
+    const outPath = (0, import_node_path26.join)(appPath(companionId), filename);
+    let flo;
+    try {
+      flo = writeIfcApp(appPath(companionId), companionId, scene, outPath);
+    } catch (e) {
+      app.log.error({ companionId, err: e instanceof Error ? e.message : e }, "export-ifc: companion app write failed");
+      return reply.status(500).send({ ok: false, error: `could not write the IFC companion app: ${e instanceof Error ? e.message : "write error"}` });
+    }
+    try {
+      await aware.compile(flo);
+    } catch (e) {
+      app.log.warn({ companionId, detail: e instanceof AwareError ? e.detail : void 0 }, "IFC compile failed");
+      return reply.status(422).send({ ok: false, error: `IFC compile failed: ${e instanceof Error ? e.message : "compile error"}`, reason: awareStderr(e) });
+    }
+    try {
+      await aware.run(companionId, {});
+    } catch (e) {
+      if (e instanceof AwareError) {
+        app.log.warn({ companionId, detail: e.detail }, "IFC write failed");
+        return reply.send({ ok: false, error: e.message, reason: awareStderr(e) });
+      }
+      throw e;
+    }
+    if (!(0, import_node_fs28.existsSync)(outPath)) return reply.send({ ok: false, error: "the IFC export produced no file" });
+    const content = (0, import_node_fs28.readFileSync)(outPath, "utf8");
+    broadcast({ type: "apps-changed" });
+    return { ok: true, filename, content, bytes: Buffer.byteLength(content), skipped };
+  });
+  app.post("/api/contract/:appId/export-tekla", async (req, reply) => {
+    const doc2 = readContract(req.params.appId);
+    if (doc2 == null) return reply.status(404).send({ ok: false, error: "no contract to bake" });
+    const v = validateSteelTakeoff(doc2);
+    if (!v.valid) return reply.status(400).send({ ok: false, error: "stored contract is invalid \u2014 re-save it in the editor" });
+    const { scene, skipped } = contractToScene(doc2);
+    if (scene.elements.length === 0) {
+      return reply.status(422).send({ ok: false, error: "no resolvable members to bake \u2014 every member is an RFI (no AISC size yet)", skipped });
+    }
+    const companionId = `${req.params.appId}-tekla`;
+    let flo;
+    try {
+      flo = writeTeklaApp(appPath(companionId), companionId, scene);
+    } catch (e) {
+      app.log.error({ companionId, err: e instanceof Error ? e.message : e }, "export-tekla: companion app write failed");
+      return reply.status(500).send({ ok: false, error: `could not write the Tekla companion app: ${e instanceof Error ? e.message : "write error"}` });
+    }
+    try {
+      await aware.compile(flo);
+    } catch (e) {
+      app.log.warn({ companionId, detail: e instanceof AwareError ? e.detail : void 0 }, "Tekla compile failed");
+      return reply.status(422).send({ ok: false, error: `Tekla compile failed: ${e instanceof Error ? e.message : "compile error"}`, reason: awareStderr(e) });
+    }
+    let result;
+    try {
+      result = await aware.run(companionId, {});
+    } catch (e) {
+      if (e instanceof AwareError) {
+        const reason = awareStderr(e);
+        const needsTekla = /tekla|connect|model|open api/i.test(`${e.message} ${reason ?? ""}`);
+        app.log.warn({ companionId, detail: e.detail }, "Tekla bake failed");
+        return reply.send({
+          ok: false,
+          needsTekla,
+          error: needsTekla ? "Tekla must be open with a model to bake into it." : e.message,
+          reason
+        });
+      }
+      throw e;
+    }
+    const events = result.traceText ? parseTrace(result.traceText) : [];
+    const outEv = [...events].reverse().find((e) => e.kind === "node-output" && e.node === "bake-tekla");
+    const inner = outEv && outEv.data && typeof outEv.data === "object" ? outEv.data.result : void 0;
+    if (!inner || inner.ok !== true) {
+      const msg = inner?.error || "the Tekla bake produced no confirmation that parts were created";
+      const needsTekla = /tekla|connect|model|open api/i.test(msg);
+      app.log.warn({ companionId, error: msg }, "Tekla bake reported failure in the node output");
+      return reply.send({
+        ok: false,
+        needsTekla,
+        error: needsTekla ? "Tekla must be open with a model to bake into it." : msg,
+        reason: msg
+      });
+    }
+    broadcast({ type: "apps-changed" });
+    return { ok: true, message: `Created ${scene.elements.length} native part(s) in the open Tekla model.`, elements: scene.elements.length, skipped };
+  });
   async function stopForegroundSession(id) {
     try {
       const sid = foregroundSessionId(id);

package/dist/web/app.css

@@ -2487,6 +2487,11 @@ body {
   background: color-mix(in srgb, var(--accent) 22%, transparent);
   border-color: var(--accent); color: var(--text);
 }
+/* Hairline separator between node-action groups (view/edit vs export/write). */
+.agent-card .node-action-sep {
+  height: 0; margin: 8px 2px 0;
+  border-top: 1px solid var(--border-strong);
+}
 /* Input node: current values at a glance ("phase = 2"), so the user knows what
    the next run uses without opening the dialog. */
 .agent-card .node-inputs { display: flex; flex-wrap: wrap; gap: 5px; margin-top: 8px; }

package/dist/web/aware.js

@@ -982,6 +982,15 @@
       onClick();
     });
     card.appendChild(btn);
+    return btn;
+  }
+
+  // A hairline separator between groups of node actions (e.g. view/edit vs export),
+  // so the export/write actions read as a distinct group without a submenu.
+  function addNodeActionDivider(card) {
+    const sep = document.createElement('div');
+    sep.className = 'node-action-sep';
+    card.appendChild(sep);
   }
 
   // Show the input node's current values inline ("phase = 2"), so the user sees
@@ -1052,6 +1061,11 @@
       if (contractType && window.CONTRACT_RENDERERS && window.CONTRACT_RENDERERS[contractType]) {
         addNodeAction(card, 'Edit contract ▸', () => openContractEditor(currentId, contractType));
         addNodeAction(card, 'View 3D ▸', () => exportContract3d(currentId));
+        // Export/write group — visually separated from the look-and-read actions above.
+        addNodeActionDivider(card);
+        addNodeAction(card, 'Export IFC ▸', () => exportContractIfc(currentId));
+        const teklaBtn = addNodeAction(card, 'Send to Tekla ▸', () => exportContractTekla(currentId));
+        teklaBtn.dataset.tip = 'Tekla must be open with a model loaded. Click to create native parts in it.';
         card.dataset.tip = 'Double-click to open the contract editor';
       }
     });
@@ -1466,6 +1480,41 @@
     }
   }
 
+  // Export IFC ▸ — write the approved takeoff OUT to a universal .ifc and download it. The server
+  // builds a model-free ifc companion, runs it, and returns the .ifc text (res.content); the browser
+  // turns it into a download. api() throws on any failure (no contract, all-RFI, compile/write error).
+  async function exportContractIfc(appId) {
+    showToast('Generating IFC…', 'info');
+    try {
+      const res = await api('/api/contract/' + encodeURIComponent(appId) + '/export-ifc', { method: 'POST' });
+      const blob = new Blob([res.content || ''], { type: 'application/x-step' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url; a.download = res.filename || (appId + '.ifc');
+      document.body.appendChild(a); a.click(); a.remove();
+      setTimeout(() => URL.revokeObjectURL(url), 4000);
+      const dropped = Array.isArray(res.skipped) ? res.skipped.length : 0;
+      showToast(`IFC downloaded — ${res.filename || appId + '.ifc'}${dropped ? ` · ${dropped} RFI member(s) skipped` : ''}`, 'ok');
+    } catch (e) {
+      showToast('IFC export failed: ' + (e && e.message ? e.message : String(e)), 'warn');
+    }
+  }
+
+  // Send to Tekla ▸ — create native parts in the OPEN Tekla model from the approved takeoff. Needs
+  // Tekla running with a model; when it's not, the server returns a clear needsTekla state (api()
+  // throws with err.body.needsTekla) — surfaced as an informational nudge, not a hard error.
+  async function exportContractTekla(appId) {
+    showToast('Baking into Tekla…', 'info');
+    try {
+      const res = await api('/api/contract/' + encodeURIComponent(appId) + '/export-tekla', { method: 'POST' });
+      const dropped = Array.isArray(res.skipped) ? res.skipped.length : 0;
+      showToast((res.message || 'Baked into the Tekla model.') + (dropped ? ` · ${dropped} RFI member(s) skipped` : ''), 'ok');
+    } catch (e) {
+      const needsTekla = e && e.body && e.body.needsTekla;
+      showToast(e && e.message ? e.message : String(e), needsTekla ? 'info' : 'warn');
+    }
+  }
+
   // ── Right-click Freeze / Unfreeze a node (aware-aeco#261) ─────────────────────
   // A general per-node toggle: right-click a canvas node → Freeze output (Run then
   // REPLAYS the node's last result instead of re-running its agent — so e.g. a

package/package.json

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