lineadraw 0.8.0 → 0.9.0

package/dist/sdk.d.ts

@@ -1,17 +1,18 @@
 import { z } from 'zod';
+export { BridgeError, BridgeOptions, BridgeStatus, DEFAULT_BRIDGE_PORT, EditorHandle, EditorInfo, LineaBridge, bridgeFilePath, connectEditors, createBridge } from './bridge.js';
 
-interface Vec2 {
+interface Vec2$1 {
     x: number;
     y: number;
 }
 
 interface Segment {
-    a: Vec2;
-    b: Vec2;
+    a: Vec2$1;
+    b: Vec2$1;
 }
 
 interface ArcGeom {
-    center: Vec2;
+    center: Vec2$1;
     radius: number;
     /** Start angle, radians CCW from +X. */
     startAngle: number;
@@ -20,8 +21,8 @@ interface ArcGeom {
 }
 
 interface EllipseGeom {
-    center: Vec2;
-    majorAxis: Vec2;
+    center: Vec2$1;
+    majorAxis: Vec2$1;
     /** minor/major in (0, 1]. */
     ratio: number;
     startAngle: number;
@@ -59,7 +60,7 @@ declare const TextStyleSchema: z.ZodObject<{
     }>>;
     arrowSize: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
-type TextStyle = z.infer<typeof TextStyleSchema>;
+type TextStyle$1 = z.infer<typeof TextStyleSchema>;
 /** A named document dimension style; documents carry an ARRAY of these and
  * dimensions reference one by `styleId` (absent/dangling = the first). */
 declare const DimStyleSchema: z.ZodObject<{
@@ -87,7 +88,7 @@ declare const DimStyleSchema: z.ZodObject<{
     extensionOvershoot: z.ZodDefault<z.ZodNumber>;
     precision: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
-type DimStyle = z.infer<typeof DimStyleSchema>;
+type DimStyle$1 = z.infer<typeof DimStyleSchema>;
 /**
  * A LINKED file drawn in place (an xref): the document holds this record,
  * never the file. The file's model space lands with its origin at
@@ -118,6 +119,9 @@ declare const ReferenceSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"url">;
         url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"asset">;
+        assetId: z.ZodString;
     }, z.core.$strip>], "kind">;
     position: z.ZodPreprocess<z.ZodObject<{
         x: z.ZodNumber;
@@ -147,7 +151,7 @@ declare const ReferenceSchema: z.ZodObject<{
         maxY: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type ReferenceObject = z.infer<typeof ReferenceSchema>;
+type Reference = z.infer<typeof ReferenceSchema>;
 declare const ModelObjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     layerId: z.ZodString;
@@ -436,23 +440,6 @@ declare const ModelObjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
     }, z.core.$strip>, unknown>, z.ZodString]>>>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    layerId: z.ZodString;
-    color: z.ZodOptional<z.ZodString>;
-    lineType: z.ZodOptional<z.ZodString>;
-    lineTypeScale: z.ZodOptional<z.ZodNumber>;
-    lineWidth: z.ZodOptional<z.ZodNumber>;
-    opacity: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodLiteral<"image">;
-    assetId: z.ZodString;
-    origin: z.ZodPreprocess<z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strip>, unknown>;
-    width: z.ZodNumber;
-    height: z.ZodNumber;
-    rotation: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     id: z.ZodString;
     layerId: z.ZodString;
@@ -606,6 +593,9 @@ declare const ModelObjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"url">;
         url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"asset">;
+        assetId: z.ZodString;
     }, z.core.$strip>], "kind">;
     position: z.ZodPreprocess<z.ZodObject<{
         x: z.ZodNumber;
@@ -676,7 +666,7 @@ type Layer = z.infer<typeof LayerSchema>;
 declare const LineaDocumentSchema: z.ZodPreprocess<z.ZodObject<{
     id: z.ZodDefault<z.ZodString>;
     type: z.ZodDefault<z.ZodLiteral<"lineadraw">>;
-    version: z.ZodLiteral<22>;
+    version: z.ZodLiteral<23>;
     settings: z.ZodDefault<z.ZodObject<{
         units: z.ZodDefault<z.ZodEnum<{
             in: "in";
@@ -983,23 +973,6 @@ declare const LineaDocumentSchema: z.ZodPreprocess<z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
         }, z.core.$strip>, unknown>, z.ZodString]>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        layerId: z.ZodString;
-        color: z.ZodOptional<z.ZodString>;
-        lineType: z.ZodOptional<z.ZodString>;
-        lineTypeScale: z.ZodOptional<z.ZodNumber>;
-        lineWidth: z.ZodOptional<z.ZodNumber>;
-        opacity: z.ZodOptional<z.ZodNumber>;
-        type: z.ZodLiteral<"image">;
-        assetId: z.ZodString;
-        origin: z.ZodPreprocess<z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strip>, unknown>;
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-        rotation: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         id: z.ZodString;
         layerId: z.ZodString;
@@ -1153,6 +1126,9 @@ declare const LineaDocumentSchema: z.ZodPreprocess<z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"url">;
             url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"asset">;
+            assetId: z.ZodString;
         }, z.core.$strip>], "kind">;
         position: z.ZodPreprocess<z.ZodObject<{
             x: z.ZodNumber;
@@ -1482,23 +1458,6 @@ declare const LineaDocumentSchema: z.ZodPreprocess<z.ZodObject<{
                 x: z.ZodNumber;
                 y: z.ZodNumber;
             }, z.core.$strip>, unknown>, z.ZodString]>>>;
-        }, z.core.$strip>, z.ZodObject<{
-            id: z.ZodString;
-            layerId: z.ZodString;
-            color: z.ZodOptional<z.ZodString>;
-            lineType: z.ZodOptional<z.ZodString>;
-            lineTypeScale: z.ZodOptional<z.ZodNumber>;
-            lineWidth: z.ZodOptional<z.ZodNumber>;
-            opacity: z.ZodOptional<z.ZodNumber>;
-            type: z.ZodLiteral<"image">;
-            assetId: z.ZodString;
-            origin: z.ZodPreprocess<z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strip>, unknown>;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            rotation: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
             id: z.ZodString;
             layerId: z.ZodString;
@@ -1652,6 +1611,9 @@ declare const LineaDocumentSchema: z.ZodPreprocess<z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"url">;
                 url: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"asset">;
+                assetId: z.ZodString;
             }, z.core.$strip>], "kind">;
             position: z.ZodPreprocess<z.ZodObject<{
                 x: z.ZodNumber;
@@ -1749,7 +1711,7 @@ declare const LineaDocumentSchema: z.ZodPreprocess<z.ZodObject<{
 }, z.core.$strip>, unknown>;
 type LineaDocument = z.infer<typeof LineaDocumentSchema>;
 
-declare const BlockParamSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+declare const ParamDefSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     name: z.ZodString;
     label: z.ZodOptional<z.ZodString>;
     hint: z.ZodOptional<z.ZodString>;
@@ -1947,7 +1909,7 @@ declare const BlockParamSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         default: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>], "type">>;
 }, z.core.$strip>], "type">;
-type BlockParameter = z.infer<typeof BlockParamSchema>;
+type ParamDef = z.infer<typeof ParamDefSchema>;
 
 /** ISO A-series portrait sizes in mm [width, height]. */
 declare const SHEET_PRESETS: {
@@ -2286,23 +2248,6 @@ declare const PaperLayoutSchema: z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
         }, z.core.$strip>, unknown>, z.ZodString]>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        layerId: z.ZodString;
-        color: z.ZodOptional<z.ZodString>;
-        lineType: z.ZodOptional<z.ZodString>;
-        lineTypeScale: z.ZodOptional<z.ZodNumber>;
-        lineWidth: z.ZodOptional<z.ZodNumber>;
-        opacity: z.ZodOptional<z.ZodNumber>;
-        type: z.ZodLiteral<"image">;
-        assetId: z.ZodString;
-        origin: z.ZodPreprocess<z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strip>, unknown>;
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-        rotation: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         id: z.ZodString;
         layerId: z.ZodString;
@@ -2456,6 +2401,9 @@ declare const PaperLayoutSchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"url">;
             url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"asset">;
+            assetId: z.ZodString;
         }, z.core.$strip>], "kind">;
         position: z.ZodPreprocess<z.ZodObject<{
             x: z.ZodNumber;
@@ -2506,7 +2454,7 @@ declare const ensureScriptTranspiler: () => Promise<ModuleExecutor>;
 interface BlockMeta {
     id: string;
     name: string;
-    params: BlockParameter[];
+    params: ParamDef[];
     description?: string;
     version?: string;
     authors?: string[];
@@ -2735,7 +2683,7 @@ interface CommandMeta {
     /** Declared parameters (the blocks' ParamDef table): prompted in the
      * editor before `run`, or passed by a headless caller; arrive as
      * `ctx.params`. Absent when the command declares none. */
-    params?: BlockParameter[];
+    params?: ParamDef[];
 }
 /** Non-throwing meta lookup for list UIs. */
 type CommandMetaResult = {
@@ -2759,7 +2707,7 @@ interface TextMeasurer {
 
 type SnapPointType = "endpoint" | "midpoint" | "center" | "quadrant";
 interface SnapPoint {
-    p: Vec2;
+    p: Vec2$1;
     type: SnapPointType;
 }
 /** A cached segment; tessellation chords of curves are marked as such. */
@@ -2794,13 +2742,13 @@ interface SnapCacheEntry {
      */
     ellipses?: EllipseGeom[];
     /** Closed tessellated rings (hatch interiors, for inside hit-testing). */
-    rings?: Vec2[][];
+    rings?: Vec2$1[][];
     /**
      * Filled regions of NESTED content — a block's hatch children — each its
      * own even-odd ring set (so two overlapping fills don't cancel). An
      * inside hit on one ranks like a hatch hit: below geometry drawn over it.
      */
-    regions?: Vec2[][][];
+    regions?: Vec2$1[][][];
     /**
      * Huge entries (a referenced site plan: 10⁵+ segments) answer "what is in
      * this box" from a spatial index, so snapping and picking near the cursor
@@ -2822,9 +2770,9 @@ interface DocumentPaintResources {
      * it (its color still follows the instance unless it sets one). */
     layers: readonly Layer[];
     /** Document dimension styles — dimensions pick theirs by styleId. */
-    dimStyles: readonly DimStyle[];
+    dimStyles: readonly DimStyle$1[];
     /** Document text styles — texts pick theirs by styleId. */
-    textStyles: readonly TextStyle[];
+    textStyles: readonly TextStyle$1[];
     /** Document-defined line types / hatch patterns, resolved by NAME ahead
      * of the built-in catalogue (block children and hatch fills). */
     lineTypes: readonly LineType[];
@@ -2842,9 +2790,8 @@ interface DocumentPaintResources {
      */
     resolveObject?: (id: string) => ModelObject | undefined;
     /**
-     * The document's embedded assets (hash → data URL) — the image painter
-     * resolves `assetId` against these. Optional: consumers that can't show
-     * images (or documents without any) paint a crossed placeholder frame.
+     * The document's embedded assets (hash → data URL) — the bytes behind
+     * `asset`-source references, which a host's `resolveReference` reads.
      */
     assets?: Readonly<Record<string, string>>;
     /**
@@ -2852,7 +2799,7 @@ interface DocumentPaintResources {
      * loading and caching. Absent, or null for a file not loaded (yet), → the
      * reference paints as a dashed frame.
      */
-    resolveReference?: (ref: ReferenceObject) => ReferenceContent | null;
+    resolveReference?: (ref: Reference) => ReferenceContent | null;
 }
 
 /**
@@ -2871,6 +2818,8 @@ interface ReferenceContent extends LayoutModelContext {
     bounds: AABB;
     /** PDF: how many pages the file has (the page field's range). */
     pageCount?: number;
+    /** A bitmap drawn under `objects` (PNG/JPEG, raster PDF page). */
+    raster?: ReferenceRaster;
     /**
      * Snap geometry precomputed in FILE coordinates (off the main thread —
      * see `referenceSnapOf`); absent → derived from `objects`. A raster PDF
@@ -2883,13 +2832,13 @@ interface ReferenceContent extends LayoutModelContext {
  * reference's hidden layers still filter them). */
 interface ReferenceSnap {
     points: {
-        p: Vec2;
+        p: Vec2$1;
         type: SnapPointType;
         layer: string;
     }[];
     segments: {
-        a: Vec2;
-        b: Vec2;
+        a: Vec2$1;
+        b: Vec2$1;
         chord?: boolean;
         layer: string;
     }[];
@@ -2900,6 +2849,14 @@ interface ReferenceSnap {
         layer: string;
     })[];
 }
+/** Raster content: one bitmap, bottom-left at the file origin, `width` ×
+ * `height` mm — a PNG/JPEG reference or a raster PDF page. */
+interface ReferenceRaster {
+    /** The bitmap as a data URL (what the sink's `image()` op draws). */
+    data: string;
+    width: number;
+    height: number;
+}
 
 /**
  * Where a reorder places the moved objects: the top/bottom of the space's
@@ -3204,23 +3161,6 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
         }, z.core.$strip>, unknown>, z.ZodString]>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        layerId: z.ZodString;
-        color: z.ZodOptional<z.ZodString>;
-        lineType: z.ZodOptional<z.ZodString>;
-        lineTypeScale: z.ZodOptional<z.ZodNumber>;
-        lineWidth: z.ZodOptional<z.ZodNumber>;
-        opacity: z.ZodOptional<z.ZodNumber>;
-        type: z.ZodLiteral<"image">;
-        assetId: z.ZodString;
-        origin: z.ZodPreprocess<z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strip>, unknown>;
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-        rotation: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         id: z.ZodString;
         layerId: z.ZodString;
@@ -3374,6 +3314,9 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"url">;
             url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"asset">;
+            assetId: z.ZodString;
         }, z.core.$strip>], "kind">;
         position: z.ZodPreprocess<z.ZodObject<{
             x: z.ZodNumber;
@@ -3697,23 +3640,6 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
         }, z.core.$strip>, unknown>, z.ZodString]>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        id: z.ZodString;
-        layerId: z.ZodString;
-        color: z.ZodOptional<z.ZodString>;
-        lineType: z.ZodOptional<z.ZodString>;
-        lineTypeScale: z.ZodOptional<z.ZodNumber>;
-        lineWidth: z.ZodOptional<z.ZodNumber>;
-        opacity: z.ZodOptional<z.ZodNumber>;
-        type: z.ZodLiteral<"image">;
-        assetId: z.ZodString;
-        origin: z.ZodPreprocess<z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strip>, unknown>;
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-        rotation: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         id: z.ZodString;
         layerId: z.ZodString;
@@ -3867,6 +3793,9 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"url">;
             url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"asset">;
+            assetId: z.ZodString;
         }, z.core.$strip>], "kind">;
         position: z.ZodPreprocess<z.ZodObject<{
             x: z.ZodNumber;
@@ -4272,23 +4201,6 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 x: z.ZodNumber;
                 y: z.ZodNumber;
             }, z.core.$strip>, unknown>, z.ZodString]>>>;
-        }, z.core.$strip>, z.ZodObject<{
-            id: z.ZodString;
-            layerId: z.ZodString;
-            color: z.ZodOptional<z.ZodString>;
-            lineType: z.ZodOptional<z.ZodString>;
-            lineTypeScale: z.ZodOptional<z.ZodNumber>;
-            lineWidth: z.ZodOptional<z.ZodNumber>;
-            opacity: z.ZodOptional<z.ZodNumber>;
-            type: z.ZodLiteral<"image">;
-            assetId: z.ZodString;
-            origin: z.ZodPreprocess<z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strip>, unknown>;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            rotation: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
             id: z.ZodString;
             layerId: z.ZodString;
@@ -4442,6 +4354,9 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"url">;
                 url: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"asset">;
+                assetId: z.ZodString;
             }, z.core.$strip>], "kind">;
             position: z.ZodPreprocess<z.ZodObject<{
                 x: z.ZodNumber;
@@ -4794,23 +4709,6 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 x: z.ZodNumber;
                 y: z.ZodNumber;
             }, z.core.$strip>, unknown>, z.ZodString]>>>;
-        }, z.core.$strip>, z.ZodObject<{
-            id: z.ZodString;
-            layerId: z.ZodString;
-            color: z.ZodOptional<z.ZodString>;
-            lineType: z.ZodOptional<z.ZodString>;
-            lineTypeScale: z.ZodOptional<z.ZodNumber>;
-            lineWidth: z.ZodOptional<z.ZodNumber>;
-            opacity: z.ZodOptional<z.ZodNumber>;
-            type: z.ZodLiteral<"image">;
-            assetId: z.ZodString;
-            origin: z.ZodPreprocess<z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strip>, unknown>;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            rotation: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
             id: z.ZodString;
             layerId: z.ZodString;
@@ -4964,6 +4862,9 @@ declare const OperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"url">;
                 url: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"asset">;
+                assetId: z.ZodString;
             }, z.core.$strip>], "kind">;
             position: z.ZodPreprocess<z.ZodObject<{
                 x: z.ZodNumber;
@@ -5278,9 +5179,10 @@ interface PdfImportReport {
     objectIds: string[];
 }
 interface PdfImportOptions {
-    /** "vectors" (default): lines and text runs. "image": every page
-     * rasterized and placed as an image at true page scale — a host
-     * capability (`rasterizePdf`), refused where it is missing. */
+    /** "vectors" (default): lines and text runs. "image": the PDF embedded
+     * and every page placed as a raster reference at true page scale — a host
+     * capability (`rasterizePdf`, for the page sizes), refused where it is
+     * missing. */
     as?: "vectors" | "image";
     /** Bottom-left corner of the first page (image mode; default 0,0). Pages
      * line up to the right. */
@@ -5299,7 +5201,7 @@ interface AssetInfo {
     mimeType: string;
     /** Decoded size in bytes. */
     bytes: number;
-    /** Image objects (every space) that show it. */
+    /** References (every space) that embed it. */
     users: number;
 }
 /**
@@ -5328,7 +5230,7 @@ interface DrawingHooks {
     /** Document-wide object lookup for block reference inputs. */
     resolveObject?: (id: string) => ModelObject | undefined;
     /** Loaded reference content (default: the drawing's referenceContent). */
-    resolveReference?: (ref: ReferenceObject) => ReferenceContent | null;
+    resolveReference?: (ref: Reference) => ReferenceContent | null;
     /** Snap/hit-test geometry, e.g. from a cache (default: built per call). */
     snapEntry?: (obj: ModelObject) => SnapCacheEntry;
     /** Where the host keeps its marketplace list and how it reaches them
@@ -5413,11 +5315,12 @@ declare class LocalDrawing implements Drawing$1 {
     setCurrentLayer(nameOrId: string): void;
     updateSettings(patch: Partial<LineaDocument["settings"]>): void;
     /**
-     * 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: string): string;
-    /** Remove an asset (the kernel refuses while an image references it). */
+    /** Remove an asset (the kernel refuses while a reference embeds it). */
     removeAsset(id: string): void;
     listAssets(): AssetInfo[];
     /** Merge DXF text into the document (new layers, objects, layouts). */
@@ -5425,7 +5328,8 @@ declare class LocalDrawing implements Drawing$1 {
     /** Merge DWG bytes into the document (wasm transcode → the DXF path). */
     importDwgData(data: Uint8Array, opts?: DxfImportOptions): Promise<DxfImportReport>;
     /** 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. */
     importPdfData(data: ArrayBuffer | Uint8Array, opts?: PdfImportOptions): Promise<PdfImportReport>;
     /** Host capability: every PDF page rasterized. Absent → PDF-as-image
      * import is refused (headless Node, until it has a rasterizer). */
@@ -5443,14 +5347,14 @@ declare class LocalDrawing implements Drawing$1 {
      * unknown value is refused rather than stored dangling — a dangling
      * reference renders with the first style and nothing says why. */
     private styleRef;
-    listTextStyles(): TextStyle[];
-    listDimStyles(): DimStyle[];
+    listTextStyles(): TextStyle$1[];
+    listDimStyles(): DimStyle$1[];
     /** Create a text style (unique name; unset fields take the defaults);
      * returns its id. */
     addTextStyle(props: {
         name: string;
-    } & Partial<Omit<TextStyle, "id">>): string;
-    updateTextStyle(nameOrId: string, patch: Partial<Omit<TextStyle, "id">>): void;
+    } & Partial<Omit<TextStyle$1, "id">>): string;
+    updateTextStyle(nameOrId: string, patch: Partial<Omit<TextStyle$1, "id">>): void;
     listLineTypes(): LineType[];
     addLineTypes(lineTypes: readonly LineType[]): void;
     updateLineType(name: string, patch: Partial<LineType>): void;
@@ -5465,21 +5369,17 @@ declare class LocalDrawing implements Drawing$1 {
      * defaults); returns its id. */
     addDimStyle(props: {
         name: string;
-    } & Partial<Omit<DimStyle, "id">>): string;
-    updateDimStyle(nameOrId: string, patch: Partial<Omit<DimStyle, "id">>): void;
+    } & Partial<Omit<DimStyle$1, "id">>): string;
+    updateDimStyle(nameOrId: string, patch: Partial<Omit<DimStyle$1, "id">>): void;
     /** Remove a dimension style no dimension uses (the kernel refuses
      * otherwise). */
     removeDimStyle(nameOrId: string): void;
-    /** @deprecated Use updateDimStyle (default here: the first style). */
-    setDimStyle(patch: Partial<DimStyle>, styleId?: string): void;
     /** Replace the document's dimension styles (min 1; objects reference by
      * id). Diffed into granular per-style ops. */
-    setDimStyles(styles: DimStyle[]): void;
-    /** @deprecated Use updateTextStyle (default here: the first style). */
-    setTextStyle(patch: Partial<TextStyle>, styleId?: string): void;
+    setDimStyles(styles: DimStyle$1[]): void;
     /** Replace the document's text styles (min 1; objects reference by id).
      * Diffed into granular per-style ops. */
-    setTextStyles(styles: TextStyle[]): void;
+    setTextStyles(styles: TextStyle$1[]): void;
     private assertModuleSources;
     /**
      * Replace the block library (raw module sources — each exports its own
@@ -5538,7 +5438,7 @@ declare class LocalDrawing implements Drawing$1 {
      * Add objects (points may be `[x, y]`; `layer` resolves by name) to model
      * space, or to a paper layout's sheet via `{ layout }`. Returns ids.
      */
-    add(objects: readonly ObjectInput[], opts?: AddOptions): string[];
+    add(objects: readonly ModelObjectInput[], opts?: AddOptions): string[];
     private patched;
     /** Apply one patch to several ids. */
     update(ids: readonly string[], patch: Record<string, unknown>): void;
@@ -5591,12 +5491,12 @@ declare class LocalDrawing implements Drawing$1 {
     private distanceTo;
     /** Query model-space objects — or one paper layout's sheet objects
      * (viewports, annotations) via `filter.layout`. */
-    listObjects(filter?: QueryFilter): ModelObject[];
+    listObjects(filter?: ObjectQuery): ModelObject[];
     summary(): DocumentSummary;
     protected paintContext(): {
         layers: readonly Layer[];
-        dimStyles: readonly DimStyle[];
-        textStyles: readonly TextStyle[];
+        dimStyles: readonly DimStyle$1[];
+        textStyles: readonly TextStyle$1[];
         lineTypes: readonly LineType[];
         hatchPatterns: readonly DocumentHatchPattern[];
         blockDefinitions: readonly string[];
@@ -5845,23 +5745,6 @@ declare class LocalDrawing implements Drawing$1 {
                 x: number;
                 y: number;
             })[];
-        } | {
-            id: string;
-            layerId: string;
-            color?: string | undefined;
-            lineType?: string | undefined;
-            lineTypeScale?: number | undefined;
-            lineWidth?: number | undefined;
-            opacity?: number | undefined;
-            type: "image";
-            assetId: string;
-            origin: {
-                x: number;
-                y: number;
-            };
-            width: number;
-            height: number;
-            rotation: number;
         } | {
             id: string;
             layerId: string;
@@ -5980,6 +5863,9 @@ declare class LocalDrawing implements Drawing$1 {
             } | {
                 kind: "url";
                 url: string;
+            } | {
+                kind: "asset";
+                assetId: string;
             };
             position: {
                 x: number;
@@ -6007,7 +5893,7 @@ declare class LocalDrawing implements Drawing$1 {
             } | undefined;
         })[];
         resolveObject: (id: string) => ModelObject | undefined;
-        resolveReference: (ref: ReferenceObject) => ReferenceContent | null;
+        resolveReference: (ref: Reference) => ReferenceContent | null;
     };
     protected resolveLayout(nameOrId: string): PaperLayout;
     /** Render model space (or a paper layout via `layout`) to an SVG string. */
@@ -6016,23 +5902,374 @@ declare class LocalDrawing implements Drawing$1 {
     toDxf(): Promise<string>;
     /** 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). */
     toDwg(opts?: {
         version?: DwgVersion;
     }): Promise<Uint8Array>;
     toLinea(): string;
 }
 
+/** A 2D point (mm, y-up). Point-valued fields also accept [x, y]. */
+type Vec2 = {
+    x: number;
+    y: number;
+};
+type Vec2Like = Vec2 | readonly [number, number];
+/** An axis-aligned box (mm). */
+type Box = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+/** Arrowhead styles (leaders, dimensions). */
+type ArrowType = "filled" | "open" | "tick" | "dot" | "none";
+/** Polyline vertex; bulge = tan(sweep/4), 0 = straight. Accepts [x, y, bulge?]. */
+type PolylineVertexInput = {
+    x: number;
+    y: number;
+    bulge?: number;
+} | readonly [number, number, number?];
+/** The fields every object input may carry: its layer and the style
+ * overrides (otherwise by layer — or, for a block child, by the instance). */
+type ObjectInputBase = {
+    /** The layer, by NAME or id. Absent: `document.add` uses the current
+     * layer, a block child the instance's (the portable default; an unknown
+     * name falls back to it too). A child on another layer hides with that
+     * layer, while its color / line type / width still follow the instance
+     * unless it sets its own (ByBlock, as in CAD). */
+    layer?: string;
+    /** The layer by id only — prefer `layer`. */
+    layerId?: string;
+    /** #rrggbb; absent = by layer. */
+    color?: string;
+    /** Line type; absent = by layer. */
+    lineType?: string;
+    /** Dash-pattern length multiplier; absent = 1. */
+    lineTypeScale?: number;
+    /** Line weight in mm; absent = by layer. */
+    lineWidth?: number;
+    /** Paint opacity 0..1; absent = by layer (opaque unless the layer says). */
+    opacity?: number;
+};
+/**
+ * T plus the shared input fields, FLATTENED (the homomorphic map forces the
+ * intersection to resolve): hovers then list every member inline instead of
+ * the opaque `ObjectInputBase & { … }` — the block editor has no
+ * expand-type affordance, so the alias display is all a script author gets.
+ */
+type ObjectInputShape<T> = {
+    [K in keyof (T & ObjectInputBase)]: (T & ObjectInputBase)[K];
+} & {};
+type LineInput = ObjectInputShape<{
+    type: "line";
+    a: Vec2Like;
+    b: Vec2Like;
+}>;
+/** A point: paints as a round dot whose diameter is the lineWidth. */
+type PointInput$1 = ObjectInputShape<{
+    type: "point";
+    p: Vec2Like;
+}>;
+type PolylineInput = ObjectInputShape<{
+    type: "polyline";
+    /** At least 2 vertices. */
+    points: readonly PolylineVertexInput[];
+    closed?: boolean;
+}>;
+type CircleInput = ObjectInputShape<{
+    type: "circle";
+    center: Vec2Like;
+    radius: number;
+}>;
+/** Runs CCW from startAngle to endAngle (radians; DXF ARC convention). */
+type ArcInput = ObjectInputShape<{
+    type: "arc";
+    center: Vec2Like;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+}>;
+/** majorAxis = endpoint vector from center; ratio = minor/major in (0, 1]. */
+type EllipseInput = ObjectInputShape<{
+    type: "ellipse";
+    center: Vec2Like;
+    majorAxis: Vec2Like;
+    ratio: number;
+    startAngle?: number;
+    endAngle?: number;
+}>;
+type HatchInput = ObjectInputShape<{
+    type: "hatch";
+    /** loops[0] = outer boundary, the rest are holes (even-odd). */
+    loops: readonly {
+        points: readonly PolylineVertexInput[];
+    }[];
+    fill?: {
+        kind: "solid";
+    }
+    /** A named pattern: the built-in catalogue (ANSI31, AR-CONC, …) or one of
+     * the document's own hatch patterns, by name. `angle` radians, `scale`
+     * multiplies the definition's mm; `origin` anchors the pattern frame
+     * (block-local mm; absent = the block origin). */
+     | {
+        kind: "pattern";
+        name: string;
+        angle: number;
+        scale: number;
+        origin?: Vec2Like;
+    } | {
+        kind: "lines";
+        angle: number;
+        spacing: number;
+    } | {
+        kind: "gradient";
+        shape?: "linear" | "radial";
+        color1?: string;
+        color2?: string;
+        angle?: number;
+    };
+    /** Pattern spacing multiplier. */
+    scale?: number;
+}>;
+/** Character formatting over [start, end) of a text's `content` (JS string
+ * indices). Absent attributes inherit the text's style; `height` is a ratio
+ * of its cap height. Setting `content` without `spans` drops old spans. */
+type TextSpan = {
+    start: number;
+    end: number;
+    font?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    /** "#rrggbb". */
+    color?: string;
+    height?: number;
+    script?: "sub" | "super";
+};
+type TextInput = ObjectInputShape<{
+    type: "text";
+    position: Vec2Like;
+    content: string;
+    spans?: readonly TextSpan[];
+    rotation?: number;
+    /** Justification, as in AutoCAD / DXF: which edge sits on the point —
+     * "left" = the text runs right of it, "right" = left of it; vAlign
+     * "bottom" = the text sits above the point, "top" = below it. */
+    hAlign?: "left" | "center" | "right";
+    vAlign?: "bottom" | "center" | "top";
+    /** Word-wrap / frame width in mm (before `scale`); absent = no wrapping. */
+    width?: number;
+    frame?: "none" | "rectangle" | "circle" | "slot" | "bottom" | "firstLine";
+    /** MLEADER-style arrow polylines pointing at the text (arrowhead at [0]). */
+    leaderLines?: readonly (readonly Vec2Like[])[];
+    /** The document text style to follow (name or id); absent = the first. */
+    styleId?: string;
+    /** Style overrides; absent keys inherit the document text style. */
+    styleOverride?: TextStyleOverride;
+    /** Size multiplier for height + arrow size. */
+    scale?: number;
+}>;
+type DimensionInput = ObjectInputShape<{
+    type: "dimension";
+    kind?: "linear" | "angular" | "radial" | "diameter";
+    /** linear: 2+ chained points (measured point to point); angular: [vertex, a, b]; radial: [center, p]; diameter: [p1, p2]. */
+    points: readonly Vec2Like[];
+    /** linear only: the measuring direction, radians CCW from +X. Unset =
+     * aligned to the points. */
+    rotation?: number;
+    /** linear: signed distance of the dimension line from points[0], positive
+     * to the LEFT of the measuring direction; angular: signed arc radius
+     * (negative = the complementary arc). Not for radial/diameter. */
+    offset?: number;
+    /** One per measured segment (linear chain: points.length − 1, others: 1).
+     * `along` (mm along the line from the segment origin — radial/diameter:
+     * from the center) and `across` (mm off the line) place the text, unset =
+     * automatic; `content` is the text, `{value}` = the measurement. */
+    labels?: readonly {
+        along?: number;
+        across?: number;
+        content?: string;
+        /** Formatting over `content` (spans covering `{value}` format it). */
+        spans?: readonly TextSpan[];
+    }[];
+    /** The document dimension style to follow (name or id); absent = the first. */
+    styleId?: string;
+    /** Style overrides; absent keys inherit the document dimension style. */
+    styleOverride?: DimStyleOverride;
+    /** Annotation size multiplier (text/arrows/offsets). */
+    scale?: number;
+}>;
+/** Nested block instance (inputs may hold points, never object references). */
+type BlockInput = ObjectInputShape<{
+    type: "block";
+    definitionId: string;
+    /** Applied last, about the pivot (the first input point). */
+    rotation?: number;
+    scale?: number;
+    params?: Record<string, number | string | boolean | readonly number[] | readonly string[]>;
+    /** Input points in the PARENT's local coords; the first is the pivot. */
+    inputs?: readonly Vec2Like[];
+}>;
+/** A table cell: plain text, or text with merge / alignment / style. */
+type TableCellInput = string | {
+    content?: string;
+    /** Character formatting over `content`. */
+    spans?: readonly TextSpan[];
+    /** Merge from this (top-left) cell; covered cells are ignored. */
+    span?: {
+        cols: number;
+        rows: number;
+    };
+    hAlign?: "left" | "center" | "right";
+    vAlign?: "top" | "center" | "bottom";
+    styleId?: string;
+    styleOverride?: TextStyleOverride;
+    color?: string;
+};
+/** Grid of text cells hanging right/down from `position` (top-left);
+ * rows grow to fit their wrapped text. */
+type TableInput = ObjectInputShape<{
+    type: "table";
+    position: Vec2Like;
+    /** Column widths (mm, before `scale`). */
+    columns: readonly number[];
+    /** Row count, or per-row settings (`minHeight` mm floor). */
+    rows: number | readonly {
+        minHeight?: number;
+    }[];
+    /** Row-major `cells[row][column]`, exactly rows × columns. */
+    cells: readonly (readonly TableCellInput[])[];
+    rotation?: number;
+    scale?: number;
+    /** Rows above the heavier header rule. */
+    headerRows?: number;
+    /** Text inset from the cell edges (mm). */
+    cellMargin?: number;
+    borders?: "all" | "outer" | "rows" | "none";
+    styleId?: string;
+    styleOverride?: TextStyleOverride;
+}>;
+/** Where a reference's file lives: a path (relative to the drawing's
+ * folder), a url, or EMBEDDED — an asset of the document holding it (add the
+ * file's bytes first with `document.addAsset`). */
+type ReferenceSource = {
+    kind: "path";
+    path: string;
+    cacheKey?: string;
+} | {
+    kind: "url";
+    url: string;
+} | {
+    kind: "asset";
+    assetId: string;
+};
+/** A file drawn in place — a .linea, DXF, DWG, PDF page or picture (PNG /
+ * JPEG). The file's origin lands at `position`; a picture draws at its
+ * natural size (96 dpi) times `scale`. */
+type ReferenceInput = ObjectInputShape<{
+    type: "reference";
+    format: "linea" | "dxf" | "dwg" | "pdf" | "png" | "jpg";
+    name: string;
+    source: ReferenceSource;
+    position: Vec2Like;
+    /** Radians CCW about `position`. */
+    rotation?: number;
+    scale?: number;
+    /** Flipped left-right (x → −x) before the rotation. */
+    mirrored?: boolean;
+    /** PDF: the 1-based page, drawn as vectors or rasterized. */
+    pdfPage?: number;
+    pdfMode?: "vector" | "raster";
+    /** The file's layers not drawn, by name. */
+    hiddenLayers?: readonly string[];
+    hidden?: boolean;
+    locked?: boolean;
+    /** Crop rectangle in file coordinates. */
+    clip?: Box;
+    /** Content bounds in file coordinates (the frame drawn before it loads). */
+    extent?: Box;
+}>;
+/** Paper-space window into model space; only in a layout (`document.add`
+ * with `layout`). */
+type ViewportInput = ObjectInputShape<{
+    type: "viewport";
+    /** The frame on the sheet (mm): bottom-left corner + size. */
+    rect: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** The model point shown at the frame's centre. */
+    modelCenter?: Vec2Like;
+    /** Drawing-scale denominator (model mm per paper mm); 1:50 => 50. */
+    scale?: number;
+    /** Pinned: no pan/zoom-through, no move/resize grips. */
+    locked?: boolean;
+    /** Layer ids hidden in this viewport only. */
+    hiddenLayerIds?: readonly string[];
+}>;
+/** Review note pinned to a point; the editor shows a screen-fixed marker. */
+type CommentInput = ObjectInputShape<{
+    type: "comment";
+    /** Tail tip of the bubble (world/sheet mm). */
+    position: Vec2Like;
+    text?: string;
+    tags?: readonly string[];
+}>;
+/** What a script WRITES — the union of the authoring DTOs above (what
+ * `document.add` takes). Reads return `ModelObject`. */
+type ModelObjectInput$1 = LineInput | PointInput$1 | PolylineInput | CircleInput | ArcInput | EllipseInput | HatchInput | TextInput | DimensionInput | BlockInput | TableInput | ViewportInput | CommentInput | ReferenceInput;
+/** Text style keys a text, table or table cell may override. */
+type TextStyleOverride = Partial<Omit<TextStyle, "id" | "name">>;
+/** Dimension style keys a dimension may override. */
+type DimStyleOverride = Partial<Omit<DimStyle, "id" | "name">>;
+/** A document text style (`styles.text(id)` in `draw`,
+ * `document.listTextStyles()`). Heights and arrow sizes are mm before an
+ * object's `scale`. */
+type TextStyle = {
+    readonly id: string;
+    readonly name: string;
+    readonly font: string;
+    readonly widthFactor: number;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly textHeight: number;
+    readonly arrowType: ArrowType;
+    readonly arrowSize: number;
+};
+/** A document dimension style (`styles.dim(id)`,
+ * `document.listDimStyles()`). */
+type DimStyle = {
+    readonly id: string;
+    readonly name: string;
+    readonly font: string;
+    readonly widthFactor: number;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly textHeight: number;
+    readonly textOffset: number;
+    readonly arrowType: ArrowType;
+    readonly arrowSize: number;
+    /** "short" = a 2×overshoot tick across the dimension line. */
+    readonly extensionType: "long" | "short";
+    readonly extensionOffset: number;
+    readonly extensionOvershoot: number;
+    readonly precision: number;
+};
+
 /** A world point in mm, as `[x, y]` or `{x, y}`. */
-type PointInput = Vec2 | readonly [number, number];
-/** Loose object input: model fields + `layer` (name) / `layerId` / `id`. */
-type ObjectInput = {
-    type: ModelObjectType;
-} & Record<string, unknown>;
+type PointInput = Vec2$1 | readonly [number, number];
+/** Object input: the typed authoring DTOs (per-type fields, so editors
+ * autocomplete them; `layer` by name or id) + an optional own `id`. */
+type ModelObjectInput = ModelObjectInput$1 & {
+    id?: string;
+};
 /** Semantic, filtered read over one space's objects (all filters AND). */
-interface QueryFilter {
+interface ObjectQuery {
     ids?: readonly string[];
     type?: ModelObjectType;
     /** Layer name or id. */
@@ -6162,7 +6399,7 @@ interface Drawing$1 {
     readonly document: LineaDocument;
     summary(): DocumentSummary;
     /** Filtered objects — model space, or one layout via `filter.layout`. */
-    listObjects(filter?: QueryFilter): ModelObject[];
+    listObjects(filter?: ObjectQuery): ModelObject[];
     /** Look up an object in ANY space. */
     getObject(id: string): ModelObject | undefined;
     /** bbox / curve length / enclosed area of one object (any space). */
@@ -6190,7 +6427,7 @@ interface Drawing$1 {
     toLinea(): string;
     /** Add objects (points may be `[x, y]`; `layer` resolves by name);
      * returns the created ids. */
-    add(objects: readonly ObjectInput[], opts?: AddOptions): string[];
+    add(objects: readonly ModelObjectInput[], opts?: AddOptions): string[];
     /** Apply per-object patches (`{id, ...fields}`) in one undo step. */
     update(entries: readonly ({
         id: string;
@@ -6228,25 +6465,21 @@ interface Drawing$1 {
     /** Document-wide settings, merged over the current record (`units` is
      * declarative for now: everything is stored in mm). */
     updateSettings(patch: Partial<LineaDocument["settings"]>): void;
-    listTextStyles(): TextStyle[];
-    listDimStyles(): DimStyle[];
+    listTextStyles(): TextStyle$1[];
+    listDimStyles(): DimStyle$1[];
     /** Create a style (name unique, case-insensitive; unset fields take the
      * defaults); returns its id. Styles are addressed by name or id. */
     addTextStyle(props: {
         name: string;
-    } & Partial<Omit<TextStyle, "id">>): string;
-    updateTextStyle(nameOrId: string, patch: Partial<Omit<TextStyle, "id">>): void;
+    } & Partial<Omit<TextStyle$1, "id">>): string;
+    updateTextStyle(nameOrId: string, patch: Partial<Omit<TextStyle$1, "id">>): void;
     /** Remove a style no object resolves to (else refused, with a count). */
     removeTextStyle(nameOrId: string): void;
     addDimStyle(props: {
         name: string;
-    } & Partial<Omit<DimStyle, "id">>): string;
-    updateDimStyle(nameOrId: string, patch: Partial<Omit<DimStyle, "id">>): void;
+    } & Partial<Omit<DimStyle$1, "id">>): string;
+    updateDimStyle(nameOrId: string, patch: Partial<Omit<DimStyle$1, "id">>): void;
     removeDimStyle(nameOrId: string): void;
-    /** @deprecated Use updateDimStyle (default here: the first style). */
-    setDimStyle(patch: Partial<DimStyle>, styleId?: string): void;
-    /** @deprecated Use updateTextStyle (default here: the first style). */
-    setTextStyle(patch: Partial<TextStyle>, styleId?: string): void;
     /** The document's own line type definitions (name-keyed; objects and
      * layers reference line types by NAME, these ahead of the built-in
      * catalogue). */
@@ -6265,18 +6498,19 @@ interface Drawing$1 {
     addHatchPatterns(patterns: readonly DocumentHatchPattern[]): void;
     updateHatchPattern(name: string, patch: Partial<DocumentHatchPattern>): void;
     removeHatchPattern(name: string): void;
-    /** Embed image pixels (a data URL); returns the content-keyed assetId. */
+    /** Embed a file (a data URL); returns the content-keyed assetId an
+     * embedded reference's `source: { kind: "asset", assetId }` names. */
     addAsset(dataUrl: string): string;
-    /** Remove an asset (refused while an image references it). */
+    /** Remove an asset (refused while a reference embeds it). */
     removeAsset(id: string): void;
-    /** Embedded image assets: id, mime type, bytes, how many images use it. */
+    /** Embedded files: id, mime type, bytes, how many references embed it. */
     listAssets(): AssetInfo[];
     /** DXF text → new layers, objects, layouts. */
     importDxfText(text: string, opts?: DxfImportOptions): DxfImportReport;
     /** DWG bytes (wasm transcode → the DXF path). */
     importDwgData(data: Uint8Array, opts?: DxfImportOptions): Promise<DxfImportReport>;
     /** PDF vectors/text onto the current layer, or (`as: "image"`, a host
-     * capability) every page as an image at true scale. */
+     * capability) embedded, every page a raster reference at true scale. */
     importPdfData(data: ArrayBuffer | Uint8Array, opts?: PdfImportOptions): Promise<PdfImportReport>;
     /** Merge block module sources into the document library (verbatim →
      * skip, same id → replace in place, name clash → suffix). Async: awaits
@@ -6324,7 +6558,7 @@ interface EditorSurface {
     setSelection(ids: readonly string[]): void;
     zoom(to: ZoomTarget): void;
     /** Await one snapped world point; rejects when the user cancels. */
-    pickPoint(opts?: PickPointOptions): Promise<Vec2>;
+    pickPoint(opts?: PickPointOptions): Promise<Vec2$1>;
     /** Await one object click; resolves the object's id. */
     pickObject(opts?: {
         label?: string;
@@ -6390,8 +6624,9 @@ declare class Drawing extends LocalDrawing {
      * that can't be read stays a frame. */
     ready(): Promise<void>;
     /** 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). */
+     * 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). */
     private loadReference;
     private readSource;
     /** Rasterize model space (or a paper layout via `layout`) to PNG bytes
@@ -6433,4 +6668,4 @@ declare function drawingFromJson(text: string): Drawing;
 /** Open a `.linea` file (parse + migrate) into an in-process kernel. */
 declare function openDrawing(path: string, options?: DrawingOptions): Promise<Drawing>;
 
-export { type AABB, type AddOptions, type BlockMeta, type CommandMeta, type DimStyle, type DocumentSummary, Drawing, type Drawing$1 as DrawingApi, type DrawingOptions, type DxfImportOptions, type DxfImportReport, type EditorSurface, type Layer, type LayerInfo, type LayoutOptions, type LayoutPatch, type LineaDocument, type MarketplaceConfig, type MarketplaceHit, type MarketplaceInfo, type MarketplaceQuery, type Measurement, type MergeReport, type ModelObject, type ModelObjectType, type ObjectInput, type Operation, type PaperLayout, type PdfImportReport, type RenderPdfOptions as PdfOptions, type RenderPngOptions as PngOptions, type PointInput, type PrintPalette, type QueryFilter, type SheetName, type RenderSvgOptions as SvgOptions, type TextMeasurer, type TextStyle, type Vec2, type ViewportOptions, drawingFromJson, ensureScriptTranspiler, getBlockMetaResult, getCommandMetaResult, newDrawing, openDrawing, parseScale, renderBlockThumbnailSvg, testBlockDefinition };
+export { type AABB, type AddOptions, type BlockMeta, type CommandMeta, type DimStyle$1 as DimStyle, type DocumentSummary, Drawing, type Drawing$1 as DrawingApi, type DrawingOptions, type DxfImportOptions, type DxfImportReport, type EditorSurface, type Layer, type LayerInfo, type LayoutOptions, type LayoutPatch, type LineaDocument, type MarketplaceConfig, type MarketplaceHit, type MarketplaceInfo, type MarketplaceQuery, type Measurement, type MergeReport, type ModelObject, type ModelObjectInput, type ModelObjectType, type ObjectQuery, type Operation, type PaperLayout, type PdfImportReport, type RenderPdfOptions as PdfOptions, type RenderPngOptions as PngOptions, type PointInput, type PrintPalette, type SheetName, type RenderSvgOptions as SvgOptions, type TextMeasurer, type TextStyle$1 as TextStyle, type Vec2$1 as Vec2, type ViewportOptions, drawingFromJson, ensureScriptTranspiler, getBlockMetaResult, getCommandMetaResult, newDrawing, openDrawing, parseScale, renderBlockThumbnailSvg, testBlockDefinition };