@nodegx/mcp 0.2.2 → 0.2.4

package/dist/cloud-bundle.cjs

@@ -14407,7 +14407,7 @@ var require_common2 = __commonJS({
     exports2.setopts = setopts;
     exports2.ownProp = ownProp;
     exports2.makeAbs = makeAbs;
-    exports2.finish = finish2;
+    exports2.finish = finish3;
     exports2.mark = mark;
     exports2.isIgnored = isIgnored;
     exports2.childrenIgnored = childrenIgnored;
@@ -14497,7 +14497,7 @@ var require_common2 = __commonJS({
       self2.minimatch = new Minimatch(pattern, options);
       self2.options = self2.minimatch.options;
     }
-    function finish2(self2) {
+    function finish3(self2) {
       var nou = self2.nounique;
       var all = nou ? [] : /* @__PURE__ */ Object.create(null);
       for (var i = 0, l = self2.matches.length; i < l; i++) {
@@ -55335,6 +55335,18 @@ var init_node_catalog = __esm({
               isSignal: false,
               description: "Object path inside the bucket, such as avatars/me.png. Supabase only. Leave blank to use the file's own name"
             },
+            {
+              name: "photoQuality",
+              displayName: "Photo Quality",
+              group: "Shrink Photos",
+              plug: "input",
+              type: {
+                name: "number"
+              },
+              isSignal: false,
+              default: 80,
+              description: "How much detail a shrunk JPEG or WebP keeps, from 1 to 100; PNG keeps every pixel and its transparency, GIF and SVG are never shrunk"
+            },
             {
               name: "private",
               displayName: "Private",
@@ -55347,6 +55359,17 @@ var init_node_catalog = __esm({
               default: false,
               description: "Restricts the stored file to whoever uploaded it, so reading it later needs a Sign File URL node"
             },
+            {
+              name: "readers",
+              displayName: "Readers",
+              group: "General",
+              plug: "input",
+              type: {
+                name: "string"
+              },
+              isSignal: false,
+              description: "Roles that may read the file as well as whoever uploaded it, such as role:member, separated by commas; setting it makes the file private. NodeGX backends only"
+            },
             {
               name: "recordId",
               displayName: "Record ID (PocketBase)",
@@ -55358,6 +55381,18 @@ var init_node_catalog = __esm({
               isSignal: false,
               description: "Existing record to attach the file to. PocketBase only. Leave blank to create a new record as part of the upload"
             },
+            {
+              name: "shrinkTo",
+              displayName: "Shrink To",
+              group: "Shrink Photos",
+              plug: "input",
+              type: {
+                name: "number"
+              },
+              isSignal: false,
+              default: 0,
+              description: "Makes a photo smaller in the browser before sending it, so its longer side is at most this many pixels; 0 sends every file as picked"
+            },
             {
               name: "upload",
               displayName: "Upload",
@@ -55500,6 +55535,15 @@ var init_node_catalog = __esm({
             private: [
               "always: held as handed; read when the next Upload goes"
             ],
+            readers: [
+              "always: held as handed; read when the next Upload goes \u2014 set, those roles may read the file as well as whoever uploaded it, and the file is private"
+            ],
+            shrinkTo: [
+              "always: held as handed; read when the next Upload goes \u2014 above 0, a photo (not a GIF or an SVG) is drawn smaller in the browser first, its longer side at most this many pixels, and the smaller file is what goes; it goes as picked when it is already that small, when the smaller one would weigh more, or when the browser cannot read it"
+            ],
+            photoQuality: [
+              "always: held as handed; read when the next Upload goes, and only when a photo is shrunk \u2014 1 to 100 for a JPEG or WebP, anything else is 80; a PNG keeps every pixel"
+            ],
             bucket: [
               "always: held as handed; read when the next Upload goes \u2014 set, the file goes to this bucket at Path (or under the file's own name)"
             ],
@@ -55516,7 +55560,7 @@ var init_node_catalog = __esm({
               "always: held as handed; read when the next Upload goes, and only with Collection \u2014 a half-filled group is no location at all"
             ],
             upload: [
-              "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure"
+              "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private, Readers and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure"
             ]
           }
         },
@@ -89210,8 +89254,8 @@ var init_nodegx = __esm({
         // The header works. What it cannot do is make a file private on behalf of
         // nobody, and an author reading "supported" would not expect that.
         "files.private": degraded(
-          "A private upload is locked to the person who made it, so a file uploaded by anything other than a signed-in user \u2014 an admin tool, a cloud function \u2014 ends up private with no owner, and stays readable by everyone.",
-          "BCN-007 live, security enforced: uploaded as a signed-in user, the plain URL is 403 for anonymous AND for a second signed-in user. Uploaded with the master key, the identical request with X-NodeGX-File-Private: true serves 200 to anonymous \u2014 files.ts::upload sets owner=null for a non-user principal"
+          "A private upload is locked to the person who made it, so a file uploaded by anything other than a signed-in user \u2014 an admin tool, a cloud function \u2014 ends up private with no owner, and stays readable by everyone. Upload File's Readers names roles that may read it too, such as role:member; a file with Readers is never readable by everyone.",
+          "BCN-007 live, security enforced: uploaded as a signed-in user, the plain URL is 403 for anonymous AND for a second signed-in user. Uploaded with the master key, the identical request with X-NodeGX-File-Private: true serves 200 to anonymous \u2014 files.ts::upload sets owner=null for a non-user principal. P121-TWO001-MEMBERSPHOTO: X-NodeGX-File-Readers adds read-only role entries to the file's ACL; uploaded with the master key and role:crew, anonymous and a user without the role are 403 (files-http.test.ts)"
         ),
         "files.progress": supported("XHR upload path reports progress"),
         "auth.password": supported("nodegx-backend/src/server/users.ts"),
@@ -102712,6 +102756,13 @@ var init_store = __esm({
   }
 });
 
+// ../nodegx-project-contract/format/run-on-change-pins.ts
+var init_run_on_change_pins = __esm({
+  "../nodegx-project-contract/format/run-on-change-pins.ts"() {
+    "use strict";
+  }
+});
+
 // ../nodegx-project-contract/format.ts
 var init_format = __esm({
   "../nodegx-project-contract/format.ts"() {
@@ -102720,6 +102771,7 @@ var init_format = __esm({
     init_validator();
     init_files();
     init_store();
+    init_run_on_change_pins();
   }
 });
 
@@ -111739,13 +111791,13 @@ function readMessagesAnswer(payload) {
 function readChatAnswer(payload) {
   const choice = payload && Array.isArray(payload.choices) ? payload.choices[0] : void 0;
   if (!choice) return void 0;
-  const finish2 = choice.finish_reason ? String(choice.finish_reason) : "";
-  const declined = choice.message && typeof choice.message.refusal === "string" && choice.message.refusal.length > 0 || finish2 === "content_filter";
+  const finish3 = choice.finish_reason ? String(choice.finish_reason) : "";
+  const declined = choice.message && typeof choice.message.refusal === "string" && choice.message.refusal.length > 0 || finish3 === "content_filter";
   return {
     usage: chatUsageOf(payload.usage),
     text: chatTextOf(choice.message),
-    stopReason: declined ? "refusal" : CHAT_STOP_REASONS[finish2] || finish2,
-    refusal: declined ? `Model Request: the model declined this request (${finish2 === "content_filter" ? "content_filter" : "refusal"})` : void 0
+    stopReason: declined ? "refusal" : CHAT_STOP_REASONS[finish3] || finish3,
+    refusal: declined ? `Model Request: the model declined this request (${finish3 === "content_filter" ? "content_filter" : "refusal"})` : void 0
   };
 }
 function errorIdentifiers(raw) {
@@ -133511,13 +133563,25 @@ var init_upload_file = __esm({
       // Error always a sentence; v1 read `code || status || 0` and put a message-less envelope on Error.
       // v3 (P109 ISL-030, row C52 ruled "Keep the real name"): the Cloud File keeps the name it was uploaded as (the backend's
       // `filename`, else the sent file's name); v2's dropped `filename` and knew only the stored name.
-      version: 3,
+      // v4 (P121 TWO-001 / TWO-008): three inputs, Readers (roles that may read a private file), Shrink To and Photo Quality.
+      version: 4,
+      changes: [
+        {
+          version: 4,
+          says: "Three new inputs: Readers names the roles that may read a private file as well as whoever uploaded it, and Shrink To and Photo Quality make a photo smaller in the browser before it is sent. Left empty, each sends the file as v3 did",
+          row: "P121-TWO001-MEMBERSPHOTO, P121-TWO008-UPLOADSHRINK",
+          migration: { none: "Each new input is empty in an app built on v3, and an empty one changes nothing: the upload is the same request" }
+        }
+      ],
       source: "packages/noodl-viewer-react/src/nodes/std-library/uploadfile.ts; noodl-runtime api/cloudstore.js, api/cloudfile.ts",
       needs: ["backend"],
       worldPool: { backends: [...pool2("uploadFile", FILE_REFS[0]), ...pool2("uploadFile", FILE_REFS[1]).slice(0, 1), ...pool2("uploadFile", FILE_REFS[2]).slice(2, 3)] },
       state: {
         file: void 0,
         private: void 0,
+        readers: void 0,
+        shrinkTo: void 0,
+        photoQuality: void 0,
         bucket: void 0,
         path: void 0,
         collection: void 0,
@@ -133549,6 +133613,35 @@ var init_upload_file = __esm({
           description: "Restricts the stored file to whoever uploaded it, so reading it later needs a Sign File URL node",
           examples: [true, false]
         },
+        // P121-TWO001-MEMBERSPHOTO — handed to the store with Private; the backend reads it (files.ts)
+        readers: {
+          type: "string",
+          coerce: "none",
+          displayName: "Readers",
+          group: "General",
+          description: "Roles that may read the file as well as whoever uploaded it, such as role:member, separated by commas; setting it makes the file private. NodeGX backends only",
+          examples: ["role:member, role:admin", ""]
+        },
+        // P121-TWO008-UPLOADSHRINK — the Shrink Photos group. The canvas step (shrinkphoto.ts) is the browser's: this world
+        // has no decoder, so a photo goes as it was picked, which is what the runtime does when the browser cannot read it.
+        shrinkTo: {
+          type: "number",
+          coerce: "none",
+          default: 0,
+          displayName: "Shrink To",
+          group: "Shrink Photos",
+          description: "Makes a photo smaller in the browser before sending it, so its longer side is at most this many pixels; 0 sends every file as picked",
+          examples: [0, 1600]
+        },
+        photoQuality: {
+          type: "number",
+          coerce: "none",
+          default: 80,
+          displayName: "Photo Quality",
+          group: "Shrink Photos",
+          description: "How much detail a shrunk JPEG or WebP keeps, from 1 to 100; PNG keeps every pixel and its transparency, GIF and SVG are never shrunk",
+          examples: [80, 50]
+        },
         // :111-158
         bucket: {
           ...stringInput("Bucket (Supabase)", "Supabase Storage bucket to upload into. Supabase only; there is no default, and a bucket that does not exist fails with an error that does not say so", ["avatars", ""]),
@@ -133588,6 +133681,21 @@ var init_upload_file = __esm({
       {
         file: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes \u2014 an upload already running keeps the file it was sent with", set: { file: v }, send: [] }),
         private: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes", set: { private: v }, send: [] }),
+        readers: (_s, v) => ({
+          says: "always: held as handed; read when the next Upload goes \u2014 set, those roles may read the file as well as whoever uploaded it, and the file is private",
+          set: { readers: v },
+          send: []
+        }),
+        shrinkTo: (_s, v) => ({
+          says: "always: held as handed; read when the next Upload goes \u2014 above 0, a photo (not a GIF or an SVG) is drawn smaller in the browser first, its longer side at most this many pixels, and the smaller file is what goes; it goes as picked when it is already that small, when the smaller one would weigh more, or when the browser cannot read it",
+          set: { shrinkTo: v },
+          send: []
+        }),
+        photoQuality: (_s, v) => ({
+          says: "always: held as handed; read when the next Upload goes, and only when a photo is shrunk \u2014 1 to 100 for a JPEG or WebP, anything else is 80; a PNG keeps every pixel",
+          set: { photoQuality: v },
+          send: []
+        }),
         bucket: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes \u2014 set, the file goes to this bucket at Path (or under the file's own name)", set: { bucket: v }, send: [] }),
         path: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes, and only with a Bucket", set: { path: v }, send: [] }),
         collection: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes \u2014 with Field set and no Bucket, the file attaches to a record of this collection", set: { collection: v }, send: [] }),
@@ -133595,7 +133703,7 @@ var init_upload_file = __esm({
         field: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes, and only with Collection \u2014 a half-filled group is no location at all", set: { field: v }, send: [] }),
         // :170-172 — a token now, the work at the frame end
         upload: (s) => ({
-          says: "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure",
+          says: "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private, Readers and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure",
           set: { presses: s.presses + 1 },
           send: [],
           outcome: "pending"
@@ -133612,7 +133720,7 @@ var init_upload_file = __esm({
         },
         // :172-216
         afterInputs: (s, _i, w) => {
-          const r = frame(s, w, !!s.file, "uploadFile", () => ({ file: s.file, private: s.private, target: fileTarget(s) }), UPLOAD_ERROR_CODE, "upload");
+          const r = frame(s, w, !!s.file, "uploadFile", () => ({ file: s.file, private: s.private, readers: s.readers, target: fileTarget(s) }), UPLOAD_ERROR_CODE, "upload");
           if (!("backend" in r) || !r.backend) return r;
           const f = s.file;
           const sent2 = f && typeof f.name === "string" ? f.name : void 0;
@@ -138626,16 +138734,743 @@ var init_runner = __esm({
 });
 
 // ../nodegx-node-spec/src/layout.ts
+function edges(e) {
+  return { ...ZERO, ...e ?? {} };
+}
+function resolveLength(length, reference) {
+  if (length.percent !== void 0 && length.percent !== 0) {
+    if (reference === void 0) return void 0;
+    return length.percent / 100 * reference + (length.px ?? 0);
+  }
+  return length.px ?? 0;
+}
+function clamp3(value, min2, max2) {
+  let v = value;
+  if (max2 !== void 0 && v > max2) v = max2;
+  if (min2 !== void 0 && v < min2) v = min2;
+  return v;
+}
+function minOf(child, dim, reference) {
+  const l = dim === "width" ? child.minWidth : child.minHeight;
+  return l ? resolveLength(l, reference) : void 0;
+}
+function maxOf(child, dim, reference) {
+  const l = dim === "width" ? child.maxWidth : child.maxHeight;
+  return l ? resolveLength(l, reference) : void 0;
+}
+function crossSize(child, dim, reference, marginSum, stretch) {
+  const rule = child[dim];
+  let size2;
+  if (rule.kind === "length") {
+    size2 = resolveLength(rule.length, reference) ?? child.content[dim];
+  } else if (rule.kind === "fill" || stretch) {
+    size2 = reference === void 0 ? child.content[dim] : Math.max(0, reference - marginSum);
+  } else {
+    size2 = child.content[dim];
+  }
+  return clamp3(size2, minOf(child, dim, reference), maxOf(child, dim, reference));
+}
+function basisOf(child, dim, reference) {
+  const rule = child[dim];
+  if (rule.kind === "hug") return child.content[dim];
+  if (rule.kind === "length") return resolveLength(rule.length, reference) ?? child.content[dim];
+  const basis = rule.basis ?? { px: 0 };
+  if (basis === "hug") return child.content[dim];
+  if (reference === void 0) {
+    const resolved = resolveLength(basis, void 0);
+    return resolved === void 0 || rule.basis === void 0 ? child.content[dim] : resolved;
+  }
+  return resolveLength(basis, reference) ?? child.content[dim];
+}
+function resolveMain(children, dim, available, reference, outerExtra, scroll = false) {
+  const n = children.length;
+  const base = children.map((c) => basisOf(c, dim, reference));
+  const floorOf = (c) => scroll ? Math.max(c.floor ?? 0, c.content[dim]) : c.floor ?? 0;
+  const min2 = children.map((c) => minOf(c, dim, reference) ?? (c[dim].kind === "fill" ? floorOf(c) : void 0));
+  const max2 = children.map((c) => maxOf(c, dim, reference));
+  const hyp = base.map((b, i) => clamp3(b, min2[i], max2[i]));
+  const weight = children.map((c) => {
+    const r = c[dim];
+    return r.kind === "fill" ? Math.max(0, r.weight) : 0;
+  });
+  if (available === void 0) return hyp;
+  const sumHyp = hyp.reduce((a, b) => a + b, 0) + outerExtra;
+  const growing = sumHyp < available;
+  const target = hyp.slice();
+  const frozen = children.map((_3, i) => {
+    if (growing) return weight[i] === 0 || base[i] > hyp[i];
+    return weight[i] === 0 || base[i] < hyp[i];
+  });
+  const initialFree = available - outerExtra - children.reduce((a, _3, i) => a + (frozen[i] ? hyp[i] : base[i]), 0);
+  for (let guard = 0; guard <= n; guard++) {
+    if (frozen.every(Boolean)) break;
+    let free = available - outerExtra - children.reduce((a, _3, i) => a + (frozen[i] ? target[i] : base[i]), 0);
+    const open2 = [...Array(n).keys()].filter((i) => !frozen[i]);
+    if (growing) {
+      const sumW = open2.reduce((a, i) => a + weight[i], 0);
+      if (sumW < 1 && Math.abs(initialFree * sumW) < Math.abs(free)) free = initialFree * sumW;
+      for (const i of open2) target[i] = sumW > 0 ? base[i] + free * weight[i] / sumW : base[i];
+    } else {
+      const scaled = open2.map((i) => base[i]);
+      const sumS = scaled.reduce((a, b) => a + b, 0);
+      open2.forEach((i, k) => {
+        target[i] = sumS > 0 ? base[i] + free * scaled[k] / sumS : base[i];
+      });
+    }
+    let total = 0;
+    const adjust = /* @__PURE__ */ new Map();
+    for (const i of open2) {
+      const clamped = clamp3(target[i], min2[i] ?? 0, max2[i]);
+      adjust.set(i, clamped - target[i]);
+      total += clamped - target[i];
+      target[i] = clamped;
+    }
+    if (total === 0) break;
+    for (const i of open2) {
+      const a = adjust.get(i) ?? 0;
+      if (total > 0 && a > 0 || total < 0 && a < 0) frozen[i] = true;
+    }
+    for (const i of open2) if (!frozen[i]) target[i] = base[i];
+  }
+  return target;
+}
+function transformBox(box, t) {
+  if (!t) return box;
+  const tx = resolveLength(t.x ?? {}, box.width) ?? 0;
+  const ty = resolveLength(t.y ?? {}, box.height) ?? 0;
+  const ox = box.x + (resolveLength(t.originX ?? { percent: 50 }, box.width) ?? 0);
+  const oy = box.y + (resolveLength(t.originY ?? { percent: 50 }, box.height) ?? 0);
+  const s = t.scale ?? 1;
+  const rad = (t.rotation ?? 0) * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  const corners = [
+    [box.x, box.y],
+    [box.x + box.width, box.y],
+    [box.x, box.y + box.height],
+    [box.x + box.width, box.y + box.height]
+  ].map(([px2, py]) => {
+    const dx = (px2 - ox) * s;
+    const dy = (py - oy) * s;
+    return [ox + tx + dx * cos - dy * sin, oy + ty + dx * sin + dy * cos];
+  });
+  const xs = corners.map((c) => c[0]);
+  const ys = corners.map((c) => c[1]);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+}
+function intersect(a, b) {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const r = Math.min(a.x + a.width, b.x + b.width);
+  const bt = Math.min(a.y + a.height, b.y + b.height);
+  if (r <= x || bt <= y) return null;
+  return { x, y, width: r - x, height: bt - y };
+}
+function placeOverlay(child, pad) {
+  const m = edges(child.margin);
+  const width = crossSize(child, "width", pad.width, m.left + m.right, false);
+  const height = crossSize(child, "height", pad.height, m.top + m.bottom, false);
+  const ax = child.overlayAlign?.x ?? "start";
+  const ay = child.overlayAlign?.y ?? "start";
+  const x = ax === "start" ? pad.x + m.left : ax === "end" ? pad.x + pad.width - width - m.right : pad.x + pad.width / 2 + m.left - width / 2;
+  const y = ay === "start" ? pad.y + m.top : ay === "end" ? pad.y + pad.height - height - m.bottom : pad.y + pad.height / 2 + m.top - height / 2;
+  return { x, y, width, height };
+}
+function layoutChildren(parent, children) {
+  const p = edges(parent.padding);
+  const b = edges(parent.border);
+  const padBox = {
+    x: b.left,
+    y: b.top,
+    width: Math.max(0, parent.width - b.left - b.right),
+    height: Math.max(0, parent.height - b.top - b.bottom)
+  };
+  const contentBox = {
+    x: padBox.x + p.left,
+    y: padBox.y + p.top,
+    width: Math.max(0, padBox.width - p.left - p.right),
+    height: Math.max(0, padBox.height - p.top - p.bottom)
+  };
+  const boxes = new Array(children.length);
+  const flow = children.map((c, i) => ({ c, i })).filter(({ c }) => parent.axis !== "overlay" && (c.place ?? "flow") === "flow");
+  for (const { c, i } of children.map((c2, i2) => ({ c: c2, i: i2 }))) {
+    if (parent.axis === "overlay" || c.place === "overlay") boxes[i] = placeOverlay(c, padBox);
+  }
+  let extentMain = 0;
+  let extentCross = 0;
+  let overflows = false;
+  if (parent.axis !== "overlay") {
+    const v = parent.axis === "column" ? COLUMN : ROW;
+    const mainRef = contentBox[v.main];
+    const crossRef = contentBox[v.cross];
+    const kids = flow.map(({ c }) => c);
+    const margins = kids.map((c) => edges(c.margin));
+    const gap = parent.gap ?? 0;
+    const marginMain = margins.reduce((a, m) => a + m[v.mainEdges[0]] + m[v.mainEdges[1]], 0);
+    const gaps = kids.length > 1 ? gap * (kids.length - 1) : 0;
+    const main2 = resolveMain(kids, v.main, mainRef, mainRef, marginMain + gaps, parent.scroll);
+    const used = main2.reduce((a, s) => a + s, 0) + marginMain + gaps;
+    const free = parent.scroll ? Math.max(0, mainRef - used) : mainRef - used;
+    const spacers = kids.reduce((a, c) => a + (c.spacer?.before ? 1 : 0) + (c.spacer?.after ? 1 : 0), 0);
+    let lead = 0;
+    let between = 0;
+    let spacer = 0;
+    const align = parent.mainAlign ?? "start";
+    if (spacers > 0 && free > 0) {
+      spacer = free / spacers;
+    } else if (kids.length > 0) {
+      const n = kids.length;
+      if (align === "center") lead = free / 2;
+      else if (align === "end") lead = free;
+      else if (align === "space-between") {
+        if (free > 0 && n > 1) between = free / (n - 1);
+      } else if (align === "space-around") {
+        if (free > 0 && n > 1) {
+          between = free / n;
+          lead = between / 2;
+        } else lead = free / 2;
+      } else if (align === "space-evenly") {
+        if (free > 0) {
+          between = free / (n + 1);
+          lead = between;
+        } else lead = free / 2;
+      }
+    }
+    let cursor = contentBox[v.main === "height" ? "y" : "x"] + lead;
+    const crossStart = contentBox[v.cross === "width" ? "x" : "y"];
+    kids.forEach((c, k) => {
+      const m = margins[k];
+      const marginCross = m[v.crossEdges[0]] + m[v.crossEdges[1]];
+      const selfAlign = c.alignSelf ?? parent.crossAlign ?? "start";
+      const cross = crossSize(c, v.cross, crossRef, marginCross, selfAlign === "stretch" && c[v.cross].kind === "hug");
+      if (c.spacer?.before && spacer > 0) cursor += spacer;
+      cursor += m[v.mainEdges[0]];
+      const at = cursor;
+      cursor += main2[k] + m[v.mainEdges[1]];
+      if (c.spacer?.after && spacer > 0) cursor += spacer;
+      cursor += k < kids.length - 1 ? gap + between : 0;
+      const room = crossRef - cross - marginCross;
+      const crossAt = crossStart + m[v.crossEdges[0]] + (selfAlign === "center" ? room / 2 : selfAlign === "end" ? room : 0);
+      extentCross = Math.max(extentCross, crossAt + cross + m[v.crossEdges[1]]);
+      boxes[flow[k].i] = v.main === "height" ? { x: crossAt, y: at, width: cross, height: main2[k] } : { x: at, y: crossAt, width: main2[k], height: cross };
+    });
+    extentMain = cursor;
+    overflows = used > mainRef + 1e-9;
+    const endMain = v.main === "height" ? p.bottom + b.bottom : p.right + b.right;
+    const endCross = v.cross === "width" ? p.right + b.right : p.bottom + b.bottom;
+    extentMain += endMain;
+    extentCross += endCross;
+    const extent = v.main === "height" ? { width: extentCross, height: extentMain } : { width: extentMain, height: extentCross };
+    return finish2(parent, children, boxes, padBox, extent, overflows);
+  }
+  return finish2(parent, children, boxes, padBox, { width: parent.width, height: parent.height }, false);
+}
+function finish2(parent, children, boxes, padBox, extent, overflows) {
+  const clips = Boolean(parent.clip || parent.scroll);
+  const out = boxes.map((box, i) => {
+    const drawn3 = transformBox(box, children[i].transform);
+    return { ...box, drawn: drawn3, visible: clips ? intersect(drawn3, padBox) : drawn3 };
+  });
+  const paintOrder = children.map((c, i) => ({ z: c.z ?? 0, i })).sort((a, b) => a.z - b.z || a.i - b.i).map((e) => e.i);
+  return { children: out, paintOrder, extent, overflows };
+}
+function hugSize(parent, children, given = {}) {
+  const p = edges(parent.padding);
+  const b = edges(parent.border);
+  const insetW = p.left + p.right + b.left + b.right;
+  const insetH = p.top + p.bottom + b.top + b.bottom;
+  const refW = given.width === void 0 ? void 0 : Math.max(0, given.width - insetW);
+  const refH = given.height === void 0 ? void 0 : Math.max(0, given.height - insetH);
+  const outer = (c, dim, ref) => {
+    const m = edges(c.margin);
+    const ms = dim === "width" ? m.left + m.right : m.top + m.bottom;
+    const rule = c[dim];
+    const size2 = rule.kind === "length" ? resolveLength(rule.length, ref) ?? c.content[dim] : rule.kind === "fill" && ref !== void 0 ? Math.max(0, ref - ms) : c.content[dim];
+    return clamp3(size2, minOf(c, dim, ref), maxOf(c, dim, ref)) + ms;
+  };
+  let w = 0;
+  let h = 0;
+  const gap = parent.gap ?? 0;
+  const flow = children.filter((c) => parent.axis !== "overlay" && (c.place ?? "flow") === "flow");
+  if (parent.axis === "overlay") {
+    for (const c of children) {
+      w = Math.max(w, outer(c, "width", refW));
+      h = Math.max(h, outer(c, "height", refH));
+    }
+  } else {
+    const v = parent.axis === "column" ? COLUMN : ROW;
+    const refMain = v.main === "width" ? refW : refH;
+    const refCross = v.cross === "width" ? refW : refH;
+    const m = flow.map((c) => {
+      const marg = edges(c.margin);
+      return basisOf(c, v.main, refMain) + marg[v.mainEdges[0]] + marg[v.mainEdges[1]];
+    });
+    const mainSum = m.reduce((a, x) => a + x, 0) + (flow.length > 1 ? gap * (flow.length - 1) : 0);
+    const crossMax = flow.reduce((a, c) => Math.max(a, outer(c, v.cross, refCross)), 0);
+    if (v.main === "height") [w, h] = [crossMax, mainSum];
+    else [w, h] = [mainSum, crossMax];
+  }
+  return {
+    width: given.width ?? w + insetW,
+    height: given.height ?? h + insetH
+  };
+}
+var ZERO, COLUMN, ROW;
 var init_layout = __esm({
   "../nodegx-node-spec/src/layout.ts"() {
     "use strict";
+    ZERO = { top: 0, right: 0, bottom: 0, left: 0 };
+    COLUMN = { main: "height", cross: "width", mainEdges: ["top", "bottom"], crossEdges: ["left", "right"] };
+    ROW = { main: "width", cross: "height", mainEdges: ["left", "right"], crossEdges: ["top", "bottom"] };
   }
 });
 
 // ../nodegx-node-spec/src/layout-map.ts
+function readLength(raw, defaultUnit, options, why) {
+  let value;
+  let unit;
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  if (typeof raw === "number") {
+    value = raw;
+    unit = defaultUnit;
+  } else if (typeof raw === "object" && raw !== null && "value" in raw) {
+    const o = raw;
+    value = Number(o.value);
+    unit = typeof o.unit === "string" && o.unit !== "" ? o.unit : defaultUnit;
+  } else if (typeof raw === "string") {
+    const token = /^var\(\s*(--[\w-]+)\s*(?:,\s*([^)]*))?\)$/.exec(raw.trim());
+    if (token) {
+      const px2 = options.token?.(token[1]);
+      if (px2 !== void 0) return { px: px2 };
+      if (token[2] !== void 0) return readLength(token[2].trim(), defaultUnit, options, why);
+      why(`the token ${token[1]} has no value here`);
+      return void 0;
+    }
+    const m = /^(-?\d*\.?\d+)\s*([a-z%]*)$/i.exec(raw.trim());
+    if (!m) {
+      why(`"${raw}" is not a length`);
+      return void 0;
+    }
+    value = Number(m[1]);
+    unit = m[2] === "" ? defaultUnit : m[2].toLowerCase();
+  } else {
+    why(`${JSON.stringify(raw)} is not a length`);
+    return void 0;
+  }
+  if (!Number.isFinite(value)) {
+    why(`${JSON.stringify(raw)} is not a number`);
+    return void 0;
+  }
+  if (unit === "px") return { px: value };
+  if (unit === "%") return { percent: value };
+  if ((unit === "vw" || unit === "vh") && options.viewport) {
+    return { px: value / 100 * (unit === "vw" ? options.viewport.width : options.viewport.height) };
+  }
+  why(`the unit "${unit}" is not in the model${unit === "vw" || unit === "vh" ? " without a viewport" : ""}`);
+  return void 0;
+}
+function pxOf(length, name, why) {
+  if (!length) return 0;
+  if (length.percent) {
+    why(`${name} in percent is not in the model`);
+    return 0;
+  }
+  return length.px ?? 0;
+}
+function numberOf(raw) {
+  const v = typeof raw === "object" && raw !== null && "value" in raw ? raw.value : raw;
+  if (v === void 0 || v === null || v === "") return void 0;
+  const n = typeof v === "number" ? v : parseFloat(String(v));
+  return Number.isFinite(n) ? n : void 0;
+}
+function layoutOf(spec, params, options = {}) {
+  const outside = [];
+  const byRole = /* @__PURE__ */ new Map();
+  for (const [name, decl] of Object.entries(spec.inputs)) {
+    const role = decl.layout;
+    if (role) byRole.set(role, name);
+    const cls = decl.portability;
+    const set = params[name] !== void 0 && params[name] !== decl.default;
+    if (set && cls && !role && !(name in BOX_NEUTRAL) && (UNMAPPED_CLASSES.includes(cls) || cls === "layout-expressible")) {
+      outside.push(`${name} (${cls}) is set`);
+    }
+  }
+  const has4 = (role) => byRole.has(role);
+  const value = (role) => {
+    const name = byRole.get(role);
+    if (name === void 0) return void 0;
+    return params[name] !== void 0 ? params[name] : spec.inputs[name].default;
+  };
+  const length = (role, unit) => readLength(value(role), unit, options, (r) => outside.push(`${byRole.get(role)}: ${r}`));
+  const px2 = (role) => pxOf(length(role, "px"), byRole.get(role) ?? role, (r) => outside.push(r));
+  const present = value("present") !== false;
+  const position = value("place");
+  if (position === "fixed" || position === "sticky") outside.push(`position is ${position}`);
+  const parentAxis = options.parentAxis;
+  const overlay = parentAxis === "overlay" || position === "absolute" || position === "fixed";
+  const margin = {
+    top: px2("margin-top"),
+    right: px2("margin-right"),
+    bottom: px2("margin-bottom"),
+    left: px2("margin-left")
+  };
+  const mode = has4("size-mode") ? String(value("size-mode")) : "explicit";
+  const assigns = {
+    width: mode === "explicit" || mode === "contentHeight",
+    height: mode === "explicit" || mode === "contentWidth"
+  };
+  const sizeRule = (dim) => {
+    if (has4("diameter")) {
+      const d = length("diameter", "px");
+      return d ? { kind: "length", length: d } : { kind: "hug" };
+    }
+    if (!has4(dim) || !assigns[dim]) return { kind: "hug" };
+    const l = length(dim, "%");
+    if (!l) return { kind: "hug" };
+    if (!l.percent) return { kind: "length", length: l };
+    const fixed = Boolean(params[byRole.get(dim) ?? ""]?.isFixed);
+    const along = parentAxis === "row" && dim === "width" || parentAxis === "column" && dim === "height";
+    const lessMargins = dim === "width" ? margin.left + margin.right : margin.top + margin.bottom;
+    if (!overlay && along && !fixed) return { kind: "fill", weight: l.percent, basis: { percent: l.percent } };
+    if (parentAxis === void 0 && !overlay) return { kind: "length", length: l };
+    return { kind: "length", length: lessMargins ? { percent: l.percent, px: -lessMargins } : { percent: l.percent } };
+  };
+  const child = { width: sizeRule("width"), height: sizeRule("height"), margin };
+  for (const [role, key] of [
+    ["min-width", "minWidth"],
+    ["max-width", "maxWidth"],
+    ["min-height", "minHeight"],
+    ["max-height", "maxHeight"]
+  ]) {
+    const l = has4(role) ? length(role, "%") : void 0;
+    if (l) child[key] = l;
+  }
+  const alignX = value("align-x");
+  const alignY = value("align-y");
+  if (overlay) {
+    child.place = "overlay";
+    child.overlayAlign = { x: OVERLAY_ALIGN[alignX ?? "left"] ?? "start", y: OVERLAY_ALIGN[alignY ?? "top"] ?? "start" };
+  } else if (parentAxis !== void 0) {
+    const [mainAlign, crossAlign, before2, after3] = parentAxis === "row" ? [alignX, alignY, margin.left, margin.right] : [alignY, alignX, margin.top, margin.bottom];
+    const startish = parentAxis === "row" ? "left" : "top";
+    const endish = parentAxis === "row" ? "right" : "bottom";
+    if (mainAlign === startish && !after3) child.spacer = { after: true };
+    else if (mainAlign === "center") child.spacer = { before: !before2, after: !after3 };
+    else if (mainAlign === endish && !before2) child.spacer = { before: true };
+    if (crossAlign && SELF_ALIGN[crossAlign]) child.alignSelf = SELF_ALIGN[crossAlign];
+  }
+  const transform = {};
+  const tx = has4("translate-x") ? length("translate-x", "px") : void 0;
+  const ty = has4("translate-y") ? length("translate-y", "px") : void 0;
+  if (tx && (tx.px || tx.percent)) transform.x = tx;
+  if (ty && (ty.px || ty.percent)) transform.y = ty;
+  const rotation = has4("rotation") ? numberOf(value("rotation")) : void 0;
+  if (rotation) transform.rotation = rotation;
+  const scale = has4("scale") ? numberOf(value("scale")) : void 0;
+  if (scale !== void 0 && scale !== 1) transform.scale = scale;
+  if (Object.keys(transform).length > 0) {
+    const ox = has4("origin-x") ? length("origin-x", "%") : void 0;
+    const oy = has4("origin-y") ? length("origin-y", "%") : void 0;
+    if (ox) transform.originX = ox;
+    if (oy) transform.originY = oy;
+    child.transform = transform;
+  }
+  let parent;
+  if (has4("axis")) {
+    const dir = value("axis");
+    const axis = dir === "row" ? "row" : dir === "none" ? "overlay" : "column";
+    const borderSide = (side) => {
+      const style = (has4(`border-${side}-style`) ? value(`border-${side}-style`) : void 0) ?? value("border-style");
+      if (style === void 0 || style === "none") return 0;
+      const w = has4(`border-${side}-width`) && value(`border-${side}-width`) !== void 0 ? px2(`border-${side}-width`) : px2("border-width");
+      return w;
+    };
+    const gap = axis === "row" ? has4("gap-column") ? px2("gap-column") : 0 : axis === "column" ? has4("gap-row") ? px2("gap-row") : 0 : 0;
+    parent = {
+      axis,
+      mainAlign: MAIN_ALIGN[String(value("main-align") ?? "flex-start")] ?? "start",
+      crossAlign: CROSS_ALIGN[String(value("cross-align") ?? "flex-start")] ?? "start",
+      gap,
+      padding: { top: px2("padding-top"), right: px2("padding-right"), bottom: px2("padding-bottom"), left: px2("padding-left") },
+      border: { top: borderSide("top"), right: borderSide("right"), bottom: borderSide("bottom"), left: borderSide("left") },
+      clip: value("clip") === true,
+      scroll: value("scroll") === true
+    };
+  }
+  return { present, child, parent, outside };
+}
+var UNMAPPED_CLASSES, BOX_NEUTRAL, MAIN_ALIGN, CROSS_ALIGN, SELF_ALIGN, OVERLAY_ALIGN;
 var init_layout_map = __esm({
   "../nodegx-node-spec/src/layout-map.ts"() {
     "use strict";
+    UNMAPPED_CLASSES = ["layout-not-shared", "web-only"];
+    BOX_NEUTRAL = {
+      as: "the Tag: the runtime's sheet resets a Text's margins (`.ndl-visual-text { margin: 0 }`), and a Group's section, nav or span lays out as its div does; an h1\u2013h6 changes only the browser font, the Text content (layout-fixtures/measured/tags.json, s71)"
+    };
+    MAIN_ALIGN = {
+      "flex-start": "start",
+      "flex-end": "end",
+      center: "center",
+      "space-between": "space-between",
+      "space-around": "space-around",
+      "space-evenly": "space-evenly"
+    };
+    CROSS_ALIGN = { "flex-start": "start", "flex-end": "end", center: "center", stretch: "stretch" };
+    SELF_ALIGN = { left: "start", top: "start", center: "center", right: "end", bottom: "end" };
+    OVERLAY_ALIGN = { left: "start", top: "start", center: "center", right: "end", bottom: "end" };
+  }
+});
+
+// ../nodegx-node-spec/src/draw.ts
+function createDrawer(specs2) {
+  const isVisualType = (type) => {
+    const spec = specs2[type];
+    return !!spec && Object.values(spec.inputs).some((d) => d.layout !== void 0);
+  };
+  function draw(input) {
+    const { viewport } = input;
+    const components = input.components ?? {};
+    const componentOf = (path5) => components[path5] ?? components[path5.replace(/^\/+/, "")] ?? components["/" + path5.replace(/^\/+/, "")];
+    const isInstance = (type) => componentOf(type) !== void 0 || type.startsWith("/") && !specs2[type];
+    const rootComp = Array.isArray(input.nodes) ? { nodes: input.nodes } : input.nodes;
+    const needs = /* @__PURE__ */ new Map();
+    const limits = /* @__PURE__ */ new Map();
+    const add = (m, path5, what) => {
+      const list2 = m.get(path5) ?? m.set(path5, []).get(path5);
+      if (!list2.includes(what)) list2.push(what);
+    };
+    const need = (path5, what) => add(needs, path5, what);
+    const limit = (path5, what) => add(limits, path5, what);
+    const inTree = (n) => isVisualType(n.type) || n.type === PAGE || isInstance(n.type) || n.type === REPEATER;
+    const fileChildren = (comp, node) => {
+      const byId = new Map(comp.nodes.map((n) => [n.id, n]));
+      const listed = (node.children ?? []).map((id) => byId.get(id)).filter((n) => !!n && inTree(n));
+      const byParent = comp.nodes.filter((n) => n.parent === node.id && inTree(n) && !listed.includes(n));
+      return [...listed, ...byParent];
+    };
+    const fileRoots = (comp) => {
+      const byId = new Map(comp.nodes.map((n) => [n.id, n]));
+      if (comp.visualRoots && comp.visualRoots.length > 0) return comp.visualRoots.map((id) => byId.get(id)).filter((n) => !!n && inTree(n));
+      return comp.nodes.filter((n) => inTree(n) && (!n.parent || !byId.has(n.parent)));
+    };
+    const expand = (nodes, comp, prefix) => {
+      const out2 = [];
+      for (const n of nodes) {
+        const path5 = prefix ? `${prefix}/${n.id}` : n.id;
+        if (n.type === REPEATER) {
+          need(path5, ROWS_NEED);
+          continue;
+        }
+        if (isInstance(n.type)) {
+          const placed = componentOf(n.type);
+          if (!placed) {
+            need(path5, `the component ${n.type} is not among the files given, so nothing is drawn in its place`);
+            continue;
+          }
+          out2.push(...expand(fileRoots(placed), placed, path5));
+          continue;
+        }
+        if (n.type === PAGE) {
+          need(path5, PAGE_NEED);
+          out2.push({ node: n, path: path5, prefix, comp, kind: "page" });
+          continue;
+        }
+        if (n.type === ROUTER) {
+          need(path5, ROUTER_NEED);
+          out2.push({ node: n, path: path5, prefix, comp, kind: "router" });
+          continue;
+        }
+        out2.push({ node: n, path: path5, prefix, comp, kind: "visual" });
+      }
+      return out2;
+    };
+    const childItems = (item) => {
+      if (item.kind === "router") {
+        const pages = item.node.parameters?.pages;
+        const wanted = input.pageOf?.(item.node, item.path) ?? pages?.startPage ?? pages?.routes?.[0];
+        if (!wanted) {
+          need(item.path, "the Router lists no page, so nothing is drawn in it");
+          return [];
+        }
+        const page = componentOf(wanted);
+        if (!page) {
+          need(item.path, `the Router's page ${wanted} is not among the files given, so nothing is drawn in it`);
+          return [];
+        }
+        return expand(fileRoots(page), page, item.path);
+      }
+      return expand(fileChildren(item.comp, item.node), item.comp, item.prefix);
+    };
+    const params = (item) => ({ ...item.node.parameters ?? {}, ...input.values?.[item.node.id] ?? {}, ...input.values?.[item.path] ?? {} });
+    const read2 = (item) => (port5) => {
+      const p = params(item);
+      return p[port5] !== void 0 ? p[port5] : specs2[item.node.type]?.inputs[port5]?.default;
+    };
+    const opts = (parentAxis) => ({ parentAxis, viewport, token: input.token });
+    const lay = (item, parentAxis) => {
+      if (item.kind === "visual") return layoutOf(specs2[item.node.type], params(item), opts(parentAxis));
+      const base = item.kind === "router" ? layoutOf(specs2[ROUTER], params(item), opts(parentAxis)) : void 0;
+      const clip = item.kind === "router" ? read2(item)("clip") : void 0;
+      return {
+        present: base ? base.present : true,
+        child: { width: { kind: "fill", weight: 1 }, height: { kind: "fill", weight: 1 }, margin: { top: 0, right: 0, bottom: 0, left: 0 } },
+        parent: {
+          axis: "column",
+          mainAlign: "start",
+          crossAlign: item.kind === "page" ? "start" : "stretch",
+          gap: 0,
+          padding: { top: 0, right: 0, bottom: 0, left: 0 },
+          border: { top: 0, right: 0, bottom: 0, left: 0 },
+          clip: clip === "clip",
+          scroll: clip === "scroll"
+        },
+        outside: base ? base.outside : []
+      };
+    };
+    const contents = /* @__PURE__ */ new Map();
+    const kidsCache = /* @__PURE__ */ new Map();
+    const kidsOf = (item) => kidsCache.get(item.path) ?? kidsCache.set(item.path, childItems(item)).get(item.path);
+    const contentOf = (item, parentAxis) => {
+      const self2 = lay(item, parentAxis);
+      const kids = kidsOf(item).filter((c) => lay(c, void 0).present);
+      if (kids.length > 0 && self2.parent) {
+        const axis = self2.parent.axis;
+        return hugSize(self2.parent, kids.map((c) => ({ ...lay(c, axis).child, content: contentOf(c, axis) })));
+      }
+      if (!usesContent(self2.child)) return { width: 0, height: 0 };
+      if (item.kind !== "visual") return { width: 0, height: 0 };
+      const measured = input.measure?.(item.node, read2(item), { path: item.path });
+      if (!measured) {
+        need(item.path, "its content size (nobody measured it)");
+        return { width: 0, height: 0 };
+      }
+      for (const w of measured.needs ?? []) need(item.path, w);
+      for (const w of measured.limits ?? []) limit(item.path, w);
+      contents.set(item.path, measured.size);
+      return measured.size;
+    };
+    const out = [];
+    const place = (item, at, drawnAt, parentAxis, parentPath, underTransform) => {
+      const self2 = lay(item, parentAxis);
+      const content = contents.get(item.path);
+      if (content && content.width > at.width + 0.5 && self2.child.height.kind === "hug") {
+        limit(item.path, `its content is wider than its box (${round(content.width)} px in ${round(at.width)} px): in a browser the text wraps and the box grows down; the model takes one content size per leaf`);
+      }
+      if (underTransform) limit(item.path, "an ancestor is transformed: its drawn box moves with it, and the model compounds no transforms");
+      out.push({
+        id: item.node.id,
+        path: item.path,
+        type: item.node.type,
+        label: item.node.label,
+        parent: parentPath,
+        x: at.x,
+        y: at.y,
+        width: at.width,
+        height: at.height,
+        ...drawnAt ? { drawn: drawnAt } : {},
+        present: true,
+        outside: self2.outside,
+        needs: needs.get(item.path) ?? [],
+        limits: limits.get(item.path) ?? []
+      });
+      const kids = kidsOf(item);
+      if (kids.length === 0 || !self2.parent) return;
+      const axis = self2.parent.axis;
+      const placed = kids.map((c) => ({ c, l: lay(c, axis) }));
+      const shown = placed.filter((p) => p.l.present);
+      const children = shown.map((p) => ({ ...p.l.child, content: contentOf(p.c, axis) }));
+      const result2 = layoutChildren({ ...self2.parent, width: at.width, height: at.height }, children);
+      shown.forEach((p, i) => {
+        const b = result2.children[i];
+        const box = { x: at.x + b.x, y: at.y + b.y, width: b.width, height: b.height };
+        const own = p.l.child.transform !== void 0;
+        const drawn3 = own ? { x: at.x + b.drawn.x, y: at.y + b.drawn.y, width: b.drawn.width, height: b.drawn.height } : void 0;
+        place(p.c, box, drawn3, axis, item.path, underTransform || own);
+      });
+      for (const p of placed) {
+        if (p.l.present) continue;
+        out.push({ id: p.c.node.id, path: p.c.path, type: p.c.node.type, label: p.c.node.label, parent: item.path, x: 0, y: 0, width: 0, height: 0, present: false, outside: [], needs: needs.get(p.c.path) ?? [], limits: [] });
+      }
+    };
+    const ROOT_AXIS = "column";
+    const roots = expand(fileRoots(rootComp), rootComp, "");
+    const rootKids = roots.map((r) => ({ r, l: lay(r, ROOT_AXIS) })).filter((p) => p.l.present);
+    const rootChild = (child) => {
+      if (!input.bodyScroll) return child;
+      const h = child.height;
+      const unreferenced = h.kind === "fill" || h.kind === "length" && h.length.percent !== void 0;
+      return unreferenced ? { ...child, height: { kind: "hug" } } : child;
+    };
+    const topChildren = rootKids.map((p) => ({ ...rootChild(p.l.child), content: contentOf(p.r, ROOT_AXIS) }));
+    const rootHeight = input.bodyScroll ? Math.max(viewport.height, hugSize({ axis: ROOT_AXIS }, topChildren).height) : viewport.height;
+    const top = layoutChildren({ axis: ROOT_AXIS, width: viewport.width, height: rootHeight }, topChildren);
+    rootKids.forEach((p, i) => {
+      const b = top.children[i];
+      const own = p.l.child.transform !== void 0;
+      place(p.r, { x: b.x, y: b.y, width: b.width, height: b.height }, own ? { x: b.drawn.x, y: b.drawn.y, width: b.drawn.width, height: b.drawn.height } : void 0, ROOT_AXIS, void 0, own);
+    });
+    for (const p of roots) if (!rootKids.some((k) => k.r === p)) out.push({ id: p.node.id, path: p.path, type: p.node.type, label: p.node.label, x: 0, y: 0, width: 0, height: 0, present: false, outside: [], needs: needs.get(p.path) ?? [], limits: [] });
+    for (const [path5, list2] of needs) if (!out.some((b) => b.path === path5)) out.push({ id: path5.slice(path5.lastIndexOf("/") + 1), path: path5, type: typeAt(path5), x: 0, y: 0, width: 0, height: 0, present: false, outside: [], needs: list2, limits: limits.get(path5) ?? [] });
+    return { boxes: out, roots: roots.map((r) => r.path), needs: [input.bodyScroll ? BODY_SCROLL_NEED : ROOT_NEED, VALUES_NEED] };
+    function typeAt(path5) {
+      const ids = path5.split("/");
+      let comp = rootComp;
+      let node;
+      for (const id of ids) {
+        node = comp?.nodes.find((n) => n.id === id);
+        if (!node) return "?";
+        if (isInstance(node.type)) comp = componentOf(node.type);
+        else if (node.type === ROUTER) {
+          const pages = node.parameters?.pages;
+          const wanted = input.pageOf?.(node, path5) ?? pages?.startPage ?? pages?.routes?.[0];
+          comp = wanted ? componentOf(wanted) : void 0;
+        }
+      }
+      return node?.type ?? "?";
+    }
+  }
+  return { draw, isVisualType };
+}
+function usesContent(child) {
+  const on = (r) => r.kind === "hug" || r.kind === "fill" && r.basis === "hug";
+  return on(child.width) || on(child.height);
+}
+var REPEATER, PAGE, ROUTER, ROOT_NEED, BODY_SCROLL_NEED, VALUES_NEED, ROUTER_NEED, PAGE_NEED, ROWS_NEED, round;
+var init_draw = __esm({
+  "../nodegx-node-spec/src/draw.ts"() {
+    "use strict";
+    init_layout();
+    init_layout_map();
+    REPEATER = "For Each";
+    PAGE = "Page";
+    ROUTER = "Router";
+    ROOT_NEED = "the root's parent: the app's root element, the viewport's size, stacked down (no node, no spec says so)";
+    BODY_SCROLL_NEED = "the root's parent with Body Scroll on (the project's settings): the app's root element is as tall as its content, at least the viewport, and the document scrolls \u2014 a visual root's percent or share height is its content (no node says so; the project file does)";
+    VALUES_NEED = "the values on the wires: a trace or a graph runner (a drawn screen cannot run the graph)";
+    ROUTER_NEED = "the Router's box: its spec has no size or axis role; drawn as a column that fills its parent and stretches across it, its page the start page unless told (the runtime's element, read once \u2014 not a description)";
+    PAGE_NEED = "the Page has no spec yet: drawn as a column that fills its parent, its children starting at the left (the runtime's element, read once \u2014 not a description)";
+    ROWS_NEED = "a For Each draws one row per item: no items were given, so no row is drawn (a trace or a graph runner has them)";
+    round = (n) => Math.round(n * 10) / 10;
+  }
+});
+
+// ../nodegx-node-spec/src/draw-full.ts
+var drawer;
+var init_draw_full = __esm({
+  "../nodegx-node-spec/src/draw-full.ts"() {
+    "use strict";
+    init_draw();
+    init_nodes();
+    drawer = createDrawer(specs);
+  }
+});
+
+// ../nodegx-node-spec/src/draw-canvas.ts
+var init_draw_canvas = __esm({
+  "../nodegx-node-spec/src/draw-canvas.ts"() {
+    "use strict";
   }
 });
 
@@ -138646,6 +139481,44 @@ var init_settings_diagnostics = __esm({
   }
 });
 
+// ../nodegx-node-spec/src/honesty.ts
+var SCRIPT_TYPES, EXEMPT_TYPES, GRAPH_GRADED_TYPES, SCRIPT_TEXT_PARAMETER;
+var init_honesty = __esm({
+  "../nodegx-node-spec/src/honesty.ts"() {
+    "use strict";
+    SCRIPT_TYPES = Object.freeze(["Expression", "JavaScriptFunction", "Javascript2", "Logic Builder"]);
+    EXEMPT_TYPES = Object.freeze(["CSS Definition", "Component Children"]);
+    GRAPH_GRADED_TYPES = Object.freeze([
+      "Component Inputs",
+      "Component Outputs",
+      "Event Receiver",
+      "Event Sender",
+      "For Each Actions",
+      "On App Error",
+      "RunTasks",
+      "net.noodl.ActionDispatcher",
+      "net.noodl.ActionHandler",
+      "net.noodl.ComponentObject",
+      "net.noodl.GlobalStore",
+      "net.noodl.GlobalStore.Set",
+      "net.noodl.GlobalStore.Subscribe",
+      "net.noodl.OptimisticUpdate",
+      "net.noodl.ParentComponentObject",
+      "net.noodl.SetComponentObjectProperties",
+      "net.noodl.SetParentComponentObjectProperties",
+      "net.noodl.StateHistory",
+      "net.noodl.StateHistory.Undo",
+      "net.noodl.StateSnapshot"
+    ]);
+    SCRIPT_TEXT_PARAMETER = Object.freeze({
+      JavaScriptFunction: "functionScript",
+      Expression: "expression",
+      Javascript2: "code",
+      "Logic Builder": "generatedCode"
+    });
+  }
+});
+
 // ../nodegx-node-spec/src/browser.ts
 var init_browser = __esm({
   "../nodegx-node-spec/src/browser.ts"() {
@@ -138666,7 +139539,11 @@ var init_browser = __esm({
     init_runner();
     init_layout();
     init_layout_map();
+    init_draw();
+    init_draw_full();
+    init_draw_canvas();
     init_settings_diagnostics();
+    init_honesty();
   }
 });
 
@@ -139325,7 +140202,10 @@ function exportNode(node) {
     id: node.id,
     type: node.type.name,
     version: node.version,
-    variant: node.variant ? node.variant.name : void 0,
+    // P123-S2-VARIANTLOST: `node.variant` is a lookup through the node library's registered modules, and a project
+    // that is not `ProjectModel.instance` (the kit's in-page preview, the headless render) is not one — the name the
+    // node wears is on the node itself, and the runtime looks the variant up by name.
+    variant: node.variant ? node.variant.name : node.variantName || void 0,
     parameters: clone(node.parameters),
     stateParameters: node.stateParameters ? clone(node.stateParameters) : void 0,
     stateTransitions: node.stateTransitions ? clone(node.stateTransitions) : void 0,
@@ -139437,7 +140317,7 @@ function referencesByComponent(components) {
     byFullName.set(component.name, component.name);
     byFullName.set(component.name.substring(CLOUD_COMPONENT_PREFIX.length), component.name);
   }
-  const edges = /* @__PURE__ */ new Map();
+  const edges2 = /* @__PURE__ */ new Map();
   for (const component of components) {
     const targets = /* @__PURE__ */ new Set();
     const note = (value) => {
@@ -139449,19 +140329,19 @@ function referencesByComponent(components) {
       note(node.typename);
       Object.values(node.parameters || {}).forEach(note);
     }
-    edges.set(component.name, targets);
+    edges2.set(component.name, targets);
   }
-  return edges;
+  return edges2;
 }
 function classifyCloudComponents(project) {
   const components = getCloudFunctionComponents(project);
   const endpoints = components.filter(declaresCloudEndpoint);
-  const edges = referencesByComponent(components);
+  const edges2 = referencesByComponent(components);
   const reachable = /* @__PURE__ */ new Set();
   const queue = endpoints.map((c) => c.name);
   while (queue.length > 0) {
     const current = queue.shift();
-    for (const target of edges.get(current) || []) {
+    for (const target of edges2.get(current) || []) {
       if (reachable.has(target)) continue;
       reachable.add(target);
       queue.push(target);