lineadraw 0.8.0 → 0.10.0

package/dist/sdk.js

@@ -1,3 +1,10 @@
+import {
+  BridgeError,
+  DEFAULT_BRIDGE_PORT,
+  bridgeFilePath,
+  connectEditors,
+  createBridge
+} from "./chunk-L2CWZAKW.js";
 import {
   ADVANCE_TABLES,
   ANSI31_BASE_SPACING,
@@ -10,16 +17,17 @@ import {
   EXTRACTED_EXTRAS,
   EXTRACTED_RANGES,
   FONTS,
-  HEX_COLOR,
   HatchPatternSchema,
   LineTypeSchema,
   MAX_HATCH_SEGMENTS,
   ModelObjectSchema,
+  PX_TO_MM,
   REAL_FACES,
   REFERENCE_FORMATS,
   TextStyleSchema,
   Vec2Schema,
   aciToHex,
+  acquireInputTable,
   add,
   angle,
   approximateTextMeasurer,
@@ -28,11 +36,14 @@ import {
   blockDefinitionExists,
   blockPivot,
   blockScriptId,
+  bytesToDataUrl,
+  checkNamedInputs,
   cleanRichText,
   cleanText,
   closestPointOnSegment,
   computeHatchLines,
   computePatternGeometry,
+  dataUrlBytes,
   decodeTextEscapes,
   dimFontFace,
   dimStyleFor,
@@ -40,12 +51,14 @@ import {
   dimensionRawToLabels,
   dimensionRawToOffset,
   dist,
+  documentBlocks,
   documentObjectResolver,
   dot,
-  dryRunBlockInputs,
+  dryRunBlockPlacement,
   dryRunObjectResolver,
   effectiveTextFont,
   ellipseArcToBeziers,
+  embeddedAssetId,
   ensureScriptTranspiler,
   estimatePatternSegments,
   executeScriptModule,
@@ -59,17 +72,23 @@ import {
   getEvaluatedWorldChildren,
   getHatchPattern,
   getLineType,
+  hashAsset,
   hatchPatternKey,
   hexToRgb,
-  imageCenter,
-  imageCorners,
+  hostedClosure,
+  imagePixelSize,
+  inputLabel,
+  inputPoints,
+  inputRefs,
   invalidateBlockCache,
+  isRequiredInput,
   len,
   lineSegments,
   lineTypeKey,
   lineWeightToMm,
   linearAxis,
   listBlockMeta,
+  mapInputValues,
   matApply,
   matIdentity,
   matMultiply,
@@ -81,7 +100,9 @@ import {
   norm,
   normAngle,
   normalizeSpans,
+  paramMismatch,
   parseFontFace,
+  parseInputTable,
   parseParamsExport,
   perp,
   realFace,
@@ -96,7 +117,9 @@ import {
   rotateObject,
   scale,
   scaleObjectUniform,
+  scanScriptId,
   scriptTranspilerReady,
+  selectionFits,
   signedArcSweep,
   sub,
   tableLayout,
@@ -110,8 +133,9 @@ import {
   textStyleFor,
   textWidth,
   translateObject,
-  valueParams
-} from "./chunk-VWED6V6F.js";
+  valueParams,
+  withEmptyLists
+} from "./chunk-YYJAXJOY.js";
 import {
   embeddedPdfFonts
 } from "./chunk-L4FNH35X.js";
@@ -446,9 +470,10 @@ var LineaDocumentSchema = z2.preprocess(
     /** Document-defined hatch patterns (model/hatchPatterns.ts), same model. */
     hatchPatterns: z2.array(HatchPatternSchema).default([]),
     /**
-     * Embedded binary assets for image objects: content hash → data URL.
-     * Kept IN the document so the .linea file stays self-contained (the
-     * cost is base64 in the JSON). Entries orphaned by deleted images just
+     * Embedded files (the bytes of `asset`-source references — PNG, JPEG,
+     * PDF, DXF, DWG, .linea): content hash → data URL. Kept IN the document
+     * so the .linea file stays self-contained (the cost is base64 in the
+     * JSON). Entries orphaned by deleted references just
      * ride along (no GC — deletion is undoable, so eager sweeps would break
      * redo).
      */
@@ -513,14 +538,6 @@ function emptyDocument() {
   });
 }
 
-// ../core/src/model/assets.ts
-var hashAsset = (data) => {
-  let h = 5381;
-  for (let i = 0; i < data.length; i++)
-    h = (h << 5) + h + data.charCodeAt(i) | 0;
-  return `${(h >>> 0).toString(16)}-${data.length.toString(16)}`;
-};
-
 // ../core/src/serialize.ts
 var documentToJson = (doc) => JSON.stringify(doc, null, 2);
 var documentFromJson = (text) => LineaDocumentSchema.parse(JSON.parse(text));
@@ -1240,7 +1257,9 @@ var paintChildren = (children, sink, env, parentLayerId) => {
         hatchPatterns: env.hatchPatterns,
         blockDefinitions: env.blockDefinitions,
         resolveObject: env.resolveObject,
-        assets: env.assets
+        assets: env.assets,
+        // A reference child (linked / embedded file) loads like any other.
+        resolveReference: env.resolveReference
       }
     );
   }
@@ -1258,36 +1277,6 @@ var paintViewport = (obj, sink, env) => {
   sink.stroke({ color: env.style.color, widthMm: env.style.widthMm });
 };
 
-// ../core/src/paint/painters/image.ts
-var paintImage = (obj, sink, env) => {
-  const data = env.assets?.[obj.assetId];
-  if (data !== void 0 && !env.forceStyle) {
-    sink.image({
-      data,
-      origin: obj.origin,
-      widthMm: obj.width,
-      heightMm: obj.height,
-      rotation: obj.rotation,
-      opacity: env.style.opacity ?? 1
-    });
-    return;
-  }
-  const [a, b, c, d] = imageCorners(obj);
-  sink.beginPath();
-  sink.moveTo(a);
-  sink.lineTo(b);
-  sink.lineTo(c);
-  sink.lineTo(d);
-  sink.closePath();
-  if (data === void 0) {
-    sink.moveTo(a);
-    sink.lineTo(c);
-    sink.moveTo(b);
-    sink.lineTo(d);
-  }
-  sink.stroke(env.style);
-};
-
 // ../core/src/paint/painters/table.ts
 var paintTable = (obj, sink, env) => paintChildren(tableLayout(obj, env.textStyles).children, sink, env);
 
@@ -1706,10 +1695,8 @@ var buildEntry = (obj, ctx) => {
       };
     }
     case "block": {
-      const inputPoints = obj.inputs.filter(
-        (v) => typeof v !== "string"
-      );
-      const points = (inputPoints.length > 0 ? inputPoints : [blockPivot(obj)]).map((p) => ({ p, type: "endpoint" }));
+      const pts = inputPoints(obj.inputs);
+      const points = (pts.length > 0 ? pts : inputRefs(obj.inputs).length > 0 ? [] : [blockPivot(obj)]).map((p) => ({ p, type: "endpoint" }));
       const segments = [];
       const arcs = [];
       const ellipses = [];
@@ -1757,26 +1744,6 @@ var buildEntry = (obj, ctx) => {
         rings: [outline]
       };
     }
-    case "image": {
-      const corners = imageCorners(obj);
-      const segments = corners.map((c, i) => ({
-        a: c,
-        b: corners[(i + 1) % corners.length]
-      }));
-      const points = corners.map((p) => ({
-        p,
-        type: "endpoint"
-      }));
-      for (const s of segments)
-        points.push({ p: mid(s.a, s.b), type: "midpoint" });
-      points.push({ p: imageCenter(obj), type: "center" });
-      return {
-        bounds: boundsOfPoints(corners),
-        points,
-        segments,
-        arcs: []
-      };
-    }
     case "comment": {
       const bounds = emptyBounds();
       addPointToBounds(bounds, obj.position);
@@ -4300,10 +4267,9 @@ var convertAcadTable = (e, ctx) => {
       const cell = cells[r * cols + c];
       const raw = cell.text || cell.display || "";
       const a = cell.alignment;
-      const rich = cleanRichText(
-        raw,
-        cell.height && cell.height > 0 ? cell.height : 2.5
-      );
+      const inlineHeight = Number(/\\H(\d+(?:\.\d+)?);/.exec(raw)?.[1]);
+      const height = cell.height && cell.height > 0 ? cell.height : inlineHeight > 0 ? inlineHeight : void 0;
+      const rich = cleanRichText(raw, height ?? 2.5);
       const text = rich.content.replace(/\s+$/, "");
       const spans = normalizeSpans(rich.spans, text).filter(
         (s) => s.start > 0 || s.end < text.length
@@ -4317,7 +4283,7 @@ var convertAcadTable = (e, ctx) => {
           vAlign: a <= 3 ? "top" : a <= 6 ? "center" : "bottom"
         } : {},
         styleOverride: {
-          ...cell.height && cell.height > 0 ? { textHeight: cell.height * f } : {},
+          ...height !== void 0 ? { textHeight: height * f } : {},
           ...mtextFontFlags(raw)
         }
       };
@@ -4985,7 +4951,7 @@ var dxfToModel = (text, input) => {
 
 // ../core/src/reference/reference.ts
 var rebaseReferenceSource = (child, parent) => {
-  if (child.kind === "url" || parent.kind === "url") return child;
+  if (child.kind !== "path" || parent.kind !== "path") return child;
   if (/^([A-Za-z]:[\\/]|[\\/])/.test(child.path)) return child;
   const folder = parent.path.replace(/\\/g, "/").replace(/\/?[^/]*$/, "");
   return { ...child, path: folder ? `${folder}/${child.path}` : child.path };
@@ -5028,7 +4994,10 @@ var contentFromDocument = (doc, refId, bounds = emptyBounds()) => {
     (o) => o.type === "block" ? {
       ...o,
       id: prefix + o.id,
-      inputs: o.inputs.map((v) => typeof v === "string" ? prefix + v : v)
+      inputs: mapInputValues(
+        o.inputs,
+        (v) => typeof v === "string" ? prefix + v : v
+      )
     } : { ...o, id: prefix + o.id }
   );
   const byId = new Map(objects.map((o) => [o.id, o]));
@@ -5090,39 +5059,43 @@ var documentFromDxf = (text) => documentWithObjects((doc) => {
     ]
   };
 });
-var documentFromImage = (dataUrl, widthMm, heightMm) => {
-  const doc = emptyDocument();
-  const assetId = hashAsset(dataUrl);
-  doc.assets = { [assetId]: dataUrl };
-  doc.objects = [
-    {
-      id: "image",
-      type: "image",
-      layerId: doc.layers[0].id,
-      assetId,
-      origin: { x: 0, y: 0 },
-      width: widthMm,
-      height: heightMm,
-      rotation: 0
-    }
+var rasterSnap = (w, h, layer) => {
+  const corners = [
+    { x: 0, y: 0 },
+    { x: w, y: 0 },
+    { x: w, y: h },
+    { x: 0, y: h }
   ];
-  return doc;
+  return {
+    points: [
+      ...corners.map((p) => ({ p, type: "endpoint", layer })),
+      ...corners.map((p, i) => {
+        const q = corners[(i + 1) % 4];
+        return {
+          p: { x: (p.x + q.x) / 2, y: (p.y + q.y) / 2 },
+          type: "midpoint",
+          layer
+        };
+      }),
+      { p: { x: w / 2, y: h / 2 }, type: "center", layer }
+    ],
+    segments: corners.map((a, i) => ({ a, b: corners[(i + 1) % 4], layer })),
+    arcs: [],
+    ellipses: []
+  };
 };
-var imagePixelSize = (b) => {
-  const u32 = (i) => (b[i] << 24 | b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
-  const u16 = (i) => b[i] << 8 | b[i + 1];
-  if (b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71)
-    return { width: u32(16), height: u32(20) };
-  if (b[0] !== 255 || b[1] !== 216) return null;
-  for (let i = 2; i + 9 < b.length; ) {
-    if (b[i] !== 255) return null;
-    const marker = b[i + 1];
-    const len2 = u16(i + 2);
-    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204)
-      return { width: u16(i + 7), height: u16(i + 5) };
-    i += 2 + len2;
-  }
-  return null;
+var contentFromRaster = (refId, data, width, height) => {
+  const content = contentFromDocument(emptyDocument(), refId, {
+    minX: 0,
+    minY: 0,
+    maxX: width,
+    maxY: height
+  });
+  return {
+    ...content,
+    raster: { data, width, height },
+    snap: rasterSnap(width, height, content.layers[0].id)
+  };
 };
 var measureContentBounds = (content, measure) => {
   const ctx = {
@@ -5266,6 +5239,26 @@ var paintReference = (obj, sink, env) => {
       w: clip.maxX - clip.minX,
       h: clip.maxY - clip.minY
     });
+  const raster = content.raster;
+  if (raster) {
+    if (env.forceStyle) {
+      out.beginPath();
+      out.moveTo({ x: 0, y: 0 });
+      out.lineTo({ x: raster.width, y: 0 });
+      out.lineTo({ x: raster.width, y: raster.height });
+      out.lineTo({ x: 0, y: raster.height });
+      out.closePath();
+      out.stroke(env.style);
+    } else
+      out.image({
+        data: raster.data,
+        origin: { x: 0, y: 0 },
+        widthMm: raster.width,
+        heightMm: raster.height,
+        rotation: 0,
+        opacity: fade
+      });
+  }
   for (const child of content.objects) {
     if (shown.get(child.layerId) === false) continue;
     const own = resolveStyle(
@@ -5345,7 +5338,6 @@ var painters = {
   dimension: paintDimension,
   block: paintBlockInstance,
   viewport: paintViewport,
-  image: paintImage,
   table: paintTable,
   reference: paintReference,
   // Screen-fixed editor chrome — painted by the editor's canvas renderer
@@ -5366,7 +5358,7 @@ var renderBlockThumbnailSvg = async (script, {
 } = {}) => {
   await ensureScriptTranspiler();
   const defId = getBlockMeta(script).id;
-  const inputs = await dryRunBlockInputs(script);
+  const { inputs, params } = await dryRunBlockPlacement(script);
   const defs = [script];
   const present = /* @__PURE__ */ new Set([defId]);
   for (const extra of definitions) {
@@ -5382,7 +5374,7 @@ var renderBlockThumbnailSvg = async (script, {
     definitionId: defId,
     rotation: 0,
     scale: 1,
-    params: {},
+    params,
     inputs
   };
   const env = {
@@ -5548,8 +5540,23 @@ var OptionalMetaSchema = z3.object({
   version: z3.string().optional(),
   authors: z3.array(z3.string()).optional(),
   tags: z3.array(z3.string()).optional(),
-  inputs: z3.array(z3.string().min(1)).optional()
+  requiresEditor: z3.boolean().optional()
 });
+var isInputTable = (inputs) => inputs !== void 0 && inputs.length > 0 && typeof inputs[0] !== "string";
+var parseCommandInputs = (raw, params) => {
+  if (raw === void 0) return void 0;
+  if (Array.isArray(raw) && raw.every((l) => typeof l === "string")) {
+    if (raw.some((l) => l === ""))
+      throw new Error("Invalid command metadata \u2014 inputs: empty label");
+    return raw;
+  }
+  const table = parseInputTable(raw, params);
+  if (table?.some((d) => d.type === "host"))
+    throw new Error(
+      "Invalid command metadata \u2014 inputs: `host` is a block input (a command has no frame to live in)"
+    );
+  return table;
+};
 var extractCommandMeta = (mod) => {
   if (typeof mod.id !== "string" || mod.id.trim() === "")
     throw new Error("Command script must export a non-empty string `id`");
@@ -5563,10 +5570,12 @@ var extractCommandMeta = (mod) => {
     );
   }
   const params = parseParamsExport(mod.params);
+  const inputs = parseCommandInputs(mod.inputs, params);
   return {
     id: mod.id,
     name: mod.name,
     ...parsed.data,
+    ...inputs ? { inputs } : {},
     ...params.length > 0 ? { params } : {}
   };
 };
@@ -5605,16 +5614,11 @@ var getCommandMetaResult = (script) => {
 };
 var listCommandMeta = (scripts) => scripts.map(getCommandMetaResult);
 var getCommandRun = (script) => compileCommand(script).run;
-var ID_EXPORT_RE = /export\s+const\s+id\s*=\s*["']([^"']+)["']/;
 var commandScriptId = (script) => {
   try {
     return compileCommand(script).meta.id;
   } catch {
-    const named = ID_EXPORT_RE.exec(script);
-    if (named) return named[1];
-    const call = script.search(/defineCommand\s*\(|export\s+default\s*\{/);
-    if (call === -1) return void 0;
-    return /\bid\s*:\s*["']([^"']+)["']/.exec(script.slice(call))?.[1];
+    return scanScriptId(script, /defineCommand\s*\(|export\s+default\s*\{/);
   }
 };
 var mergeCommandModules = (existing, incoming) => mergeScriptModules(existing, incoming, {
@@ -8012,7 +8016,7 @@ var applySetAsset = (doc, op) => {
   };
 };
 var assetInUse = (doc, id) => {
-  const used = (objs) => objs.some((o) => o.type === "image" && o.assetId === id);
+  const used = (objs) => objs.some((o) => embeddedAssetId(o) === id);
   return used(doc.objects) || doc.layouts.some((l) => used(l.objects));
 };
 var applyRemoveAsset = (doc, op) => {
@@ -8193,7 +8197,9 @@ var invalidationIds = (op) => {
   switch (op.type) {
     case "add-objects":
     case "update-objects":
-      return op.objects.map((o) => o.id);
+      return op.objects.flatMap(
+        (o) => o.type === "block" ? [o.id, ...inputRefs(o.inputs)] : [o.id]
+      );
     case "remove-objects":
       return op.ids;
     case "set-current-layer":
@@ -8688,8 +8694,9 @@ var LocalDrawing = class {
   }
   // --- document meta / assets ------------------------------------------------
   /**
-   * Embed image pixels (a data URL) and return the assetId that `image`
-   * objects reference. Content-keyed: the same data reuses one entry.
+   * Embed a file (a data URL — PNG, JPEG, PDF…) and return the assetId an
+   * embedded reference's `source: { kind: "asset", assetId }` names.
+   * Content-keyed: the same data reuses one entry.
    */
   addAsset(dataUrl) {
     const id = hashAsset(dataUrl);
@@ -8697,7 +8704,7 @@ var LocalDrawing = class {
       this.applyForward({ type: "set-asset", id, dataUrl });
     return id;
   }
-  /** Remove an asset (the kernel refuses while an image references it). */
+  /** Remove an asset (the kernel refuses while a reference embeds it). */
   removeAsset(id) {
     this.applyForward({ type: "remove-asset", id });
   }
@@ -8707,9 +8714,10 @@ var LocalDrawing = class {
       this.state.objects,
       ...this.state.layouts.map((l) => l.objects)
     ])
-      for (const o of objs)
-        if (o.type === "image")
-          users.set(o.assetId, (users.get(o.assetId) ?? 0) + 1);
+      for (const o of objs) {
+        const id = embeddedAssetId(o);
+        if (id !== void 0) users.set(id, (users.get(id) ?? 0) + 1);
+      }
     return Object.entries(this.state.assets).map(([id, dataUrl]) => {
       const comma = dataUrl.indexOf(",");
       const base64 = dataUrl.slice(comma + 1);
@@ -8748,7 +8756,8 @@ var LocalDrawing = class {
     return this.importDxfText(await dwgToDxf(data), opts);
   }
   /** Merge a PDF: its vector/text content onto the current layer, or
-   * (`as: "image"`) every page as an image at true page scale. */
+   * (`as: "image"`) embedded, every page a raster reference at true page
+   * scale. */
   async importPdfData(data, opts = {}) {
     if (opts.as === "image") {
       if (!this.rasterizePdf)
@@ -8758,15 +8767,20 @@ var LocalDrawing = class {
       const pages = await this.rasterizePdf(data);
       const at = toVec(opts.origin ?? [0, 0]);
       const layerId2 = this.state.currentLayerId;
+      const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+      const assetId = this.addAsset(bytesToDataUrl(bytes, "application/pdf"));
       let x = at.x;
-      const placed = pages.map((p) => {
+      const placed = pages.map((p, i) => {
         const object = {
-          type: "image",
+          type: "reference",
           layerId: layerId2,
-          assetId: this.addAsset(p.dataUrl),
-          origin: { x, y: at.y },
-          width: p.widthMm,
-          height: p.heightMm
+          format: "pdf",
+          name: pages.length > 1 ? `PDF page ${i + 1}` : "PDF",
+          source: { kind: "asset", assetId },
+          pdfPage: i + 1,
+          pdfMode: "raster",
+          position: { x, y: at.y },
+          extent: { minX: 0, minY: 0, maxX: p.widthMm, maxY: p.heightMm }
         };
         x += p.widthMm + PDF_PAGE_GAP_MM;
         return object;
@@ -8952,10 +8966,6 @@ var LocalDrawing = class {
       id: this.resolveStyle(this.state.dimStyles, nameOrId, "dim style").id
     });
   }
-  /** @deprecated Use updateDimStyle (default here: the first style). */
-  setDimStyle(patch, styleId) {
-    this.updateDimStyle(styleId ?? this.state.dimStyles[0].id, patch);
-  }
   /** Replace the document's dimension styles (min 1; objects reference by
    * id). Diffed into granular per-style ops. */
   setDimStyles(styles) {
@@ -8963,10 +8973,6 @@ var LocalDrawing = class {
     assertUniqueIds(parsed, "setDimStyles()");
     this.applyForwardAll(diffDimStyleOps(this.state.dimStyles, parsed));
   }
-  /** @deprecated Use updateTextStyle (default here: the first style). */
-  setTextStyle(patch, styleId) {
-    this.updateTextStyle(styleId ?? this.state.textStyles[0].id, patch);
-  }
   /** Replace the document's text styles (min 1; objects reference by id).
    * Diffed into granular per-style ops. */
   setTextStyles(styles) {
@@ -9334,7 +9340,12 @@ var LocalDrawing = class {
   /** Delete objects by id (unknown ids are skipped); returns how many went. */
   remove(ids) {
     const entries = [];
-    for (const id of ids) {
+    const all = hostedClosure(
+      ids,
+      this.state.blockDefinitions,
+      documentBlocks(this.state)
+    );
+    for (const id of all) {
       try {
         entries.push({ space: this.findObject(id).space, item: id });
       } catch {
@@ -9469,6 +9480,7 @@ var LocalDrawing = class {
     return {
       dimStyles: this.state.dimStyles,
       textStyles: this.state.textStyles,
+      layers: this.state.layers,
       blockDefinitions: this.state.blockDefinitions,
       resolveObject: this.resolveObject(),
       resolveReference: this.resolveReference,
@@ -9635,19 +9647,17 @@ var LocalDrawing = class {
   }
   /** Export the document to a DXF string. */
   async toDxf() {
-    const { buildDxf } = await import("./exportDxf-2VU5475O.js");
+    const { buildDxf } = await import("./exportDxf-C4CLQCC3.js");
     return buildDxf(this.state, this.measurer).content;
   }
   /** Export the document to DWG bytes (the DXF content, wasm-transcoded).
    * Defaults to AC1027 (AutoCAD 2013) — readable by every current CAD tool.
-   * Dimensions transcode as real DIMENSION objects; leaders are exploded to
-   * plain geometry (acadrust's MULTILEADER DWG output is unproven in real
-   * CADs — exploded geometry always displays). */
+   * Dimensions transcode as real DIMENSION objects; leaders and tables are
+   * exploded to plain geometry (DWG_DXF_OPTIONS — the transcoder's DWG
+   * output for them is not accepted by AutoCAD). */
   async toDwg(opts) {
-    const { buildDxf } = await import("./exportDxf-2VU5475O.js");
-    const dxf = buildDxf(this.state, this.measurer, {
-      explodeLeaders: true
-    }).content;
+    const { buildDxf, DWG_DXF_OPTIONS } = await import("./exportDxf-C4CLQCC3.js");
+    const dxf = buildDxf(this.state, this.measurer, DWG_DXF_OPTIONS).content;
     return dxfToDwg(dxf, opts?.version ?? "AC1027");
   }
   toLinea() {
@@ -9656,66 +9666,15 @@ var LocalDrawing = class {
 };
 
 // ../core/src/drawing/runCommand.ts
-var needsEditor = (what) => () => {
-  throw new Error(`${what} needs an editor (this command runs headlessly)`);
-};
 var makeContext = (opts, inputs, params) => {
   const { document, editor } = opts;
   return {
     document,
     editor,
     inputs,
-    params,
-    // Deprecated shorthands (pre-`editor` wire form) — one release.
-    pickPoint: editor ? (label) => editor.pickPoint({ label }) : needsEditor("pickPoint"),
-    pickObject: editor ? (label) => editor.pickObject({ label }) : needsEditor("pickObject"),
-    selection: editor ? () => editor.state().selectedIds : needsEditor("selection"),
-    setSelection: editor ? (ids) => editor.setSelection(ids) : needsEditor("setSelection"),
-    prompt: editor ? (message, o) => editor.prompt(message, o) : needsEditor("prompt"),
-    showToast: editor ? (message, kind) => editor.toast(message, kind) : () => {
-    }
+    params
   };
 };
-var paramMismatch = (def, value) => {
-  switch (def.type) {
-    case "number":
-      if (typeof value !== "number" || !Number.isFinite(value))
-        return "expected a number";
-      if (def.integer && !Number.isInteger(value))
-        return "expected a whole number";
-      if (def.min !== void 0 && value < def.min)
-        return `below the minimum ${def.min}`;
-      if (def.max !== void 0 && value > def.max)
-        return `above the maximum ${def.max}`;
-      return null;
-    case "string":
-    case "textStyle":
-    case "dimStyle":
-    case "font":
-    case "lineType":
-    case "hatchPattern":
-      return typeof value === "string" ? null : "expected a string";
-    case "boolean":
-      return typeof value === "boolean" ? null : "expected true or false";
-    case "numberList": {
-      if (!Array.isArray(value) || !value.every((v) => typeof v === "number" && Number.isFinite(v)))
-        return "expected an array of numbers";
-      const low = value.find((v) => def.min !== void 0 && v < def.min);
-      if (low !== void 0) return `${low} is below the minimum ${def.min}`;
-      const high = value.find((v) => def.max !== void 0 && v > def.max);
-      if (high !== void 0) return `${high} is above the maximum ${def.max}`;
-      return null;
-    }
-    case "color":
-      return typeof value === "string" && HEX_COLOR.test(value) ? null : 'expected a "#rrggbb" color';
-    case "stringList":
-      return Array.isArray(value) && value.every((v) => typeof v === "string") ? null : "expected an array of strings";
-    case "enum":
-      return def.options.some((o) => o.value === value) ? null : `expected one of ${def.options.map((o) => JSON.stringify(o.value)).join(", ")}`;
-    default:
-      return "a label carries no value";
-  }
-};
 var resolveCommandParams = (meta, given = {}) => {
   const defs = valueParams(meta.params ?? []);
   const params = /* @__PURE__ */ Object.create(null);
@@ -9733,8 +9692,57 @@ var resolveCommandParams = (meta, given = {}) => {
   }
   return params;
 };
+var surfacePickers = (editor, document) => {
+  let selectionUsed = false;
+  const fromSelection = (def) => {
+    if (selectionUsed) return null;
+    const selected = editor.state().selectedIds.map((id) => document.getObject(id)).filter((o) => o !== void 0);
+    if (!selectionFits(def, selected)) return null;
+    selectionUsed = true;
+    return selected.map((o) => o.id);
+  };
+  return {
+    point: (def, ref) => editor.pickPoint({ label: inputLabel(def), referencePoint: ref }),
+    points: (def, ref) => editor.pickPoints({ ...def, referencePoint: ref }),
+    object: async (def) => fromSelection({ types: def.types, min: 1, max: 1 })?.[0] ?? editor.pickObject({ label: inputLabel(def), types: def.types }),
+    objects: async (def) => fromSelection(def) ?? editor.pickObjects(def)
+  };
+};
+var acquireNamedCommandInputs = async (meta, table, opts) => {
+  const { inputs, missing } = checkNamedInputs(
+    meta.name,
+    table,
+    opts.inputs,
+    (id) => opts.document.getObject(id)
+  );
+  if (!opts.editor) {
+    const required = missing.filter(isRequiredInput);
+    if (required.length > 0)
+      throw new Error(
+        `${meta.name} needs an editor for: ${required.map((d) => d.name).join(", ")} \u2014 supply inputs`
+      );
+    return withEmptyLists(table, inputs);
+  }
+  if (missing.length === 0) return inputs;
+  const picked = await acquireInputTable(
+    missing,
+    surfacePickers(opts.editor, opts.document)
+  );
+  const out = {};
+  for (const def of table) {
+    const v = inputs[def.name] ?? picked[def.name];
+    if (v !== void 0) out[def.name] = v;
+  }
+  return out;
+};
 var acquireCommandInputs = async (meta, opts) => {
+  if (isInputTable(meta.inputs))
+    return acquireNamedCommandInputs(meta, meta.inputs, opts);
   const labels = meta.inputs ?? [];
+  if (opts.inputs !== void 0 && !Array.isArray(opts.inputs))
+    throw new Error(
+      `${meta.name}: inputs are positional (${labels.join(", ") || "none declared"}) \u2014 pass an array`
+    );
   const given = (opts.inputs ?? []).map((p, i) => {
     try {
       return Vec2Schema.parse(p);
@@ -9766,11 +9774,29 @@ var runCommandModule = async (source, opts) => {
   const result = getCommandMetaResult(source);
   if (!result.ok) throw new Error(`Command failed to compile: ${result.error}`);
   const run = getCommandRun(source);
+  if (result.meta.requiresEditor && !opts.editor)
+    throw new Error(
+      `${result.meta.name} needs the editor (it asks during the run) \u2014 run it from Linea`
+    );
   const params = resolveCommandParams(result.meta, opts.params);
   const inputs = await acquireCommandInputs(result.meta, opts);
-  return opts.document.transaction(
-    () => run(makeContext(opts, inputs, params)),
-    result.meta.name
+  try {
+    return await opts.document.transaction(
+      () => run(makeContext(opts, inputs, params)),
+      result.meta.name
+    );
+  } catch (e) {
+    throw opts.editor ? e : namedEditorError(result.meta.name, e);
+  }
+};
+var namedEditorError = (name, e) => {
+  const m = e instanceof TypeError ? /reading '(pickPoint|pickPoints|pickObject|pickObjects|prompt|ask|toast|state|setSelection|setActiveSpace|zoom|listCommands|runCommand)'/.exec(
+    e.message
+  ) : null;
+  if (!m) return e;
+  return new Error(
+    `${name} used editor.${m[1]} but runs without an editor here \u2014 check \`editor\` before using it, or declare \`requiresEditor: true\``,
+    { cause: e }
   );
 };
 var runDocumentCommand = async (id, opts) => {
@@ -9824,18 +9850,30 @@ var referenceDocument = async (ref, bytes) => {
       }));
     }
     case "png":
-    case "jpg": {
-      const size = imagePixelSize(bytes);
-      if (!size) throw new Error(`${ref.name}: not a PNG/JPEG`);
-      const mime = ref.format === "png" ? "image/png" : "image/jpeg";
-      const px = 25.4 / 96;
-      return documentFromImage(
-        `data:${mime};base64,${Buffer.from(bytes).toString("base64")}`,
-        size.width * px,
-        size.height * px
-      );
-    }
+    case "jpg":
+      throw new Error("pictures load as raster content");
+  }
+};
+var referenceContent = async (ref, bytes) => {
+  if (ref.format === "png" || ref.format === "jpg") {
+    const size = imagePixelSize(bytes);
+    if (!size) throw new Error(`${ref.name}: not a PNG/JPEG`);
+    const mime = ref.format === "png" ? "image/png" : "image/jpeg";
+    return contentFromRaster(
+      ref.id,
+      `data:${mime};base64,${Buffer.from(bytes).toString("base64")}`,
+      size.width * PX_TO_MM,
+      size.height * PX_TO_MM
+    );
   }
+  const content = contentFromDocument(
+    await referenceDocument(ref, bytes),
+    ref.id
+  );
+  return {
+    ...content,
+    bounds: measureContentBounds(content, approximateTextMeasurer)
+  };
 };
 var Drawing = class extends LocalDrawing {
   path;
@@ -9873,22 +9911,31 @@ var Drawing = class extends LocalDrawing {
       ...this.layouts.flatMap((l) => l.objects)
     ].filter((o) => o.type === "reference");
     for (const ref of refs) {
-      const content = await this.loadReference(ref, ref.source, 0, /* @__PURE__ */ new Set());
+      const content = await this.loadReference(
+        ref,
+        ref.source,
+        this.state.assets,
+        0,
+        /* @__PURE__ */ new Set()
+      );
       if (content) this.referenceContent.set(ref.id, content);
       else this.referenceContent.delete(ref.id);
     }
   }
   /** One reference's content (null when unreadable); a .linea's own
-   * references load relative to it — depth-limited, never re-entering a
-   * file above in the chain (the editor's rules). */
-  async loadReference(ref, source, depth, seen) {
-    let doc;
+   * references load relative to it — and its embedded ones from ITS assets —
+   * depth-limited, never re-entering a file above in the chain (the
+   * editor's rules). */
+  async loadReference(ref, source, assets, depth, seen) {
+    let content;
     try {
-      doc = await referenceDocument(ref, await this.readSource(source));
+      content = await referenceContent(
+        ref,
+        await this.readSource(source, assets)
+      );
     } catch {
       return null;
     }
-    const content = contentFromDocument(doc, ref.id);
     if (ref.format === "linea" && depth + 1 < 4) {
       const above = new Set(seen).add(JSON.stringify(source));
       const nested = /* @__PURE__ */ new Map();
@@ -9899,19 +9946,23 @@ var Drawing = class extends LocalDrawing {
         const c = await this.loadReference(
           child,
           childSource,
+          content.assets ?? {},
           depth + 1,
           above
         );
         if (c) nested.set(child.id, c);
       }
       content.resolveReference = (r) => nested.get(r.id) ?? null;
+      content.bounds = measureContentBounds(content, approximateTextMeasurer);
     }
-    return {
-      ...content,
-      bounds: measureContentBounds(content, approximateTextMeasurer)
-    };
+    return content;
   }
-  async readSource(source) {
+  async readSource(source, assets) {
+    if (source.kind === "asset") {
+      const data = assets[source.assetId];
+      if (data === void 0) throw new Error("embedded file missing");
+      return dataUrlBytes(data);
+    }
     if (source.kind === "url") {
       const res = await fetch(source.url);
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
@@ -9991,7 +10042,8 @@ var Drawing = class extends LocalDrawing {
   }
   // --- scripts ---------------------------------------------------------------
   /** Run a command module source (`defineCommand`) against this drawing as
-   * ONE undo step, headlessly: declared `inputs` must be supplied; declared
+   * ONE undo step, headlessly: declared `inputs` must be supplied (points
+   * in label order, or a record by name for an inputs table); declared
    * `params` take their defaults unless given by name (unknown names and
    * wrong types throw). Resolves with the script's return value. */
   runScript(source, inputs, params) {
@@ -10032,7 +10084,12 @@ async function openDrawing(path, options = {}) {
   return doc;
 }
 export {
+  BridgeError,
+  DEFAULT_BRIDGE_PORT,
   Drawing,
+  bridgeFilePath,
+  connectEditors,
+  createBridge,
   drawingFromJson,
   ensureScriptTranspiler,
   getBlockMetaResult,