lineadraw 0.7.0 → 0.9.0

package/dist/{chunk-NCNZ7A6M.js → chunk-BQCSFVAF.js}

@@ -2,21 +2,7 @@ import {
   __export
 } from "./chunk-PZ5AY32C.js";
 
-// ../core/src/export/dxf/exportDxf.ts
-import {
-  DxfWriter,
-  Units,
-  LayerFlags,
-  LWPolylineFlags,
-  TextHorizontalAlignment,
-  TextVerticalAlignment,
-  HatchBoundaryPaths,
-  HatchPolylineBoundary,
-  HatchPredefinedPatterns,
-  pattern
-} from "@tarikjabiri/dxf";
-
-// ../core/src/model/objects.ts
+// ../core/src/model/hatchPatterns.ts
 import { z as z2 } from "zod";
 
 // ../core/src/model/common.ts
@@ -40,6 +26,716 @@ var ObjectBaseSchema = z.object({
   opacity: z.number().min(0).max(1).optional()
 });
 
+// ../core/src/paint/sink.ts
+var matIdentity = [1, 0, 0, 1, 0, 0];
+var matMultiply = (m, n) => [
+  m[0] * n[0] + m[2] * n[1],
+  m[1] * n[0] + m[3] * n[1],
+  m[0] * n[2] + m[2] * n[3],
+  m[1] * n[2] + m[3] * n[3],
+  m[0] * n[4] + m[2] * n[5] + m[4],
+  m[1] * n[4] + m[3] * n[5] + m[5]
+];
+var matApply = (m, p) => ({
+  x: m[0] * p.x + m[2] * p.y + m[4],
+  y: m[1] * p.x + m[3] * p.y + m[5]
+});
+var signedArcSweep = (startAngle, endAngle, ccw) => {
+  const TAU = Math.PI * 2;
+  let sweep = ccw ? ((endAngle - startAngle) % TAU + TAU) % TAU : -(((startAngle - endAngle) % TAU + TAU) % TAU);
+  if (sweep === 0) sweep = ccw ? TAU : -TAU;
+  return sweep;
+};
+var arcToBeziers = (center, r, startAngle, sweep) => {
+  const n = Math.max(1, Math.ceil(Math.abs(sweep) / (Math.PI / 2)));
+  const step = sweep / n;
+  const k = 4 / 3 * Math.tan(step / 4);
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const a0 = startAngle + step * i;
+    const a1 = a0 + step;
+    const p0 = {
+      x: center.x + r * Math.cos(a0),
+      y: center.y + r * Math.sin(a0)
+    };
+    const p1 = {
+      x: center.x + r * Math.cos(a1),
+      y: center.y + r * Math.sin(a1)
+    };
+    result.push({
+      start: p0,
+      c1: { x: p0.x - r * k * Math.sin(a0), y: p0.y + r * k * Math.cos(a0) },
+      c2: { x: p1.x + r * k * Math.sin(a1), y: p1.y - r * k * Math.cos(a1) },
+      end: p1
+    });
+  }
+  return result;
+};
+var vExtent = (rings, v) => {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const ring of rings) {
+    for (const p of ring) {
+      const dv = p.x * v.x + p.y * v.y;
+      if (dv < min) min = dv;
+      if (dv > max) max = dv;
+    }
+  }
+  return Number.isFinite(min) ? { min, max } : null;
+};
+var scanlineCrossings = (rings, u, v, off) => {
+  const crossings = [];
+  for (const ring of rings) {
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+      const a = ring[j];
+      const b = ring[i];
+      const va = a.x * v.x + a.y * v.y;
+      const vb = b.x * v.x + b.y * v.y;
+      if (va < off === vb < off) continue;
+      const t = (off - va) / (vb - va);
+      const px = a.x + (b.x - a.x) * t;
+      const py = a.y + (b.y - a.y) * t;
+      crossings.push(px * u.x + py * u.y);
+    }
+  }
+  crossings.sort((x, y) => x - y);
+  return crossings;
+};
+var computeHatchLines = (rings, angle2, spacing) => spacing <= 0 ? [] : computeHatchFamily(rings, {
+  angle: angle2,
+  origin: { x: 0, y: 0 },
+  deltaAlong: 0,
+  deltaPerp: spacing
+});
+var DOT_LENGTH_MM = 0.35;
+var splitByDashes = (a, b, u, dashes, along0, out) => {
+  const len3 = (b.x - a.x) * u.x + (b.y - a.y) * u.y;
+  if (len3 <= 1e-9) return;
+  const cycle = dashes.reduce((s, d) => s + Math.abs(d), 0);
+  if (cycle <= 1e-9) {
+    out.push({ a, b });
+    return;
+  }
+  const pt = (d) => ({ x: a.x + u.x * d, y: a.y + u.y * d });
+  const base = a.x * u.x + a.y * u.y - along0;
+  let phase = (base % cycle + cycle) % cycle;
+  let idx = 0;
+  for (; idx < dashes.length; idx++) {
+    const w = Math.abs(dashes[idx]);
+    if (phase < w || w <= 1e-9) break;
+    phase -= w;
+  }
+  if (idx >= dashes.length) {
+    idx = 0;
+    phase = 0;
+  }
+  let remaining = Math.max(0, Math.abs(dashes[idx]) - phase);
+  let pos = 0;
+  let guard = 0;
+  while (pos < len3 - 1e-9 && guard++ < 1e5) {
+    const w = Math.abs(dashes[idx]);
+    const draw = dashes[idx] >= 0;
+    if (w <= 1e-9) {
+      if (draw) {
+        const s0 = Math.max(0, pos - DOT_LENGTH_MM / 2);
+        const s1 = Math.min(len3, pos + DOT_LENGTH_MM / 2);
+        if (s1 > s0) out.push({ a: pt(s0), b: pt(s1) });
+      }
+      idx = (idx + 1) % dashes.length;
+      remaining = Math.abs(dashes[idx]);
+      continue;
+    }
+    const step = Math.min(remaining, len3 - pos);
+    if (draw) out.push({ a: pt(pos), b: pt(pos + step) });
+    pos += step;
+    remaining -= step;
+    if (remaining <= 1e-9) {
+      idx = (idx + 1) % dashes.length;
+      remaining = Math.abs(dashes[idx]);
+    }
+  }
+};
+var computeHatchFamily = (rings, family) => {
+  const { deltaPerp } = family;
+  if (rings.length === 0 || Math.abs(deltaPerp) <= 1e-9) return [];
+  const u = { x: Math.cos(family.angle), y: Math.sin(family.angle) };
+  const v = { x: -u.y, y: u.x };
+  const ext = vExtent(rings, v);
+  if (!ext) return [];
+  const oV = family.origin.x * v.x + family.origin.y * v.y;
+  const oU = family.origin.x * u.x + family.origin.y * u.y;
+  const iA = (ext.min - oV) / deltaPerp;
+  const iB = (ext.max - oV) / deltaPerp;
+  const iLo = Math.ceil(Math.min(iA, iB));
+  const iHi = Math.floor(Math.max(iA, iB));
+  const dashes = family.dashesMm && family.dashesMm.length ? family.dashesMm : null;
+  const out = [];
+  for (let i = iLo; i <= iHi; i++) {
+    const off = oV + i * deltaPerp;
+    const along0 = oU + i * family.deltaAlong;
+    const crossings = scanlineCrossings(rings, u, v, off);
+    for (let k = 0; k + 1 < crossings.length; k += 2) {
+      const c0 = crossings[k];
+      const c1 = crossings[k + 1];
+      if (c1 - c0 < 1e-9) continue;
+      const a = { x: u.x * c0 + v.x * off, y: u.y * c0 + v.y * off };
+      const b = { x: u.x * c1 + v.x * off, y: u.y * c1 + v.y * off };
+      if (dashes) splitByDashes(a, b, u, dashes, along0, out);
+      else out.push({ a, b });
+    }
+  }
+  return out;
+};
+var ellipseArcToBeziers = (center, rx, ry, rotation, startAngle, sweep) => {
+  const cosR = Math.cos(rotation);
+  const sinR = Math.sin(rotation);
+  const map = (p) => ({
+    x: center.x + p.x * cosR - p.y * sinR,
+    y: center.y + p.x * sinR + p.y * cosR
+  });
+  return arcToBeziers({ x: 0, y: 0 }, 1, startAngle, sweep).map((b) => ({
+    start: map({ x: b.start.x * rx, y: b.start.y * ry }),
+    c1: map({ x: b.c1.x * rx, y: b.c1.y * ry }),
+    c2: map({ x: b.c2.x * rx, y: b.c2.y * ry }),
+    end: map({ x: b.end.x * rx, y: b.end.y * ry })
+  }));
+};
+
+// ../core/src/model/builtinPat.ts
+var BUILTIN_PAT = `;;  Linea built-in hatch pattern library.
+;;
+;;  Format: .pat syntax - a \`*NAME,description\` header followed by one line
+;;  family per row: \`angle, x-origin, y-origin, delta-x, delta-y [, dash...]\`
+;;  (angle in degrees CCW; delta-x shifts successive lines along their own
+;;  direction - dash phase - and delta-y is the perpendicular spacing;
+;;  dashes: >0 pen-down, <0 gap, 0 dot). All lengths are millimeters (ISO
+;;  scaling).
+;;
+;;  The pattern geometry is functional interchange data, kept name- and
+;;  value-compatible with the predefined DXF HATCH patterns other CAD
+;;  applications resolve - ANSI/ISO/JIS/GOST section conventions plus common
+;;  architectural textures. Descriptions and organization are Linea's
+;;  own. There is no SOLID entry: solid fill is its own fill kind, not a
+;;  line-family pattern.
+;;
+;;  After editing, regenerate the embedded TS mirror:
+;;    npm run gen:patterns -w @lineadraw/core
+;;
+
+;;  Material and texture patterns.
+
+*ANGLE,Steel angle framing
+0, 0, 0, 0, 6.985, 5.08, -1.905
+90, 0, 0, 0, 6.985, 5.08, -1.905
+*ANSI31,Cast iron; general section (ANSI)
+45, 0, 0, 0, 3.175
+*ANSI32,Steel (ANSI)
+45, 0, 0, 0, 9.525
+45, 4.49013, 0, 0, 9.525
+*ANSI33,Bronze, brass, copper (ANSI)
+45, 0, 0, 0, 6.35
+45, 4.49013, 0, 0, 6.35, 3.175, -1.5875
+*ANSI34,Plastic, rubber (ANSI)
+45, 0, 0, 0, 19.05
+45, 4.49013, 0, 0, 19.05
+45, 8.98026, 0, 0, 19.05
+45, 13.4704, 0, 0, 19.05
+*ANSI35,Fire brick, refractory (ANSI)
+45, 0, 0, 0, 6.35
+45, 4.49013, 0, 0, 6.35, 7.9375, -1.5875, 0, -1.5875
+*ANSI36,Marble, slate, glass (ANSI)
+45, 0, 0, 5.55625, 3.175, 7.9375, -1.5875, 0, -1.5875
+*ANSI37,Lead, zinc, insulation (ANSI)
+45, 0, 0, 0, 3.175
+135, 0, 0, 0, 3.175
+*ANSI38,Aluminum (ANSI)
+45, 0, 0, 0, 3.175
+135, 0, 0, 6.35, 3.175, 7.9375, -4.7625
+*AR-B816,Block wall 8x16, running bond
+0, 0, 0, 0, 203.2
+90, 0, 0, 203.2, 203.2, 203.2, -203.2
+*AR-B816C,Block wall 8x16 with mortar joints
+0, 0, 0, 203.2, 203.2, 396.875, -9.525
+0, -203.2, 9.525, 203.2, 203.2, 396.875, -9.525
+90, 0, 0, 203.2, 203.2, -212.725, 193.675
+90, -9.525, 0, 203.2, 203.2, -212.725, 193.675
+*AR-B88,Block wall 8x8, running bond
+0, 0, 0, 0, 203.2
+90, 0, 0, 203.2, 101.6, 203.2, -203.2
+*AR-BRELM,Brick wall, English bond, mortar joints
+0, 0, 0, 0, 135.484, 193.675, -9.525
+0, 0, 57.15, 0, 135.484, 193.675, -9.525
+0, 50.8, 67.7418, 0, 135.484, 92.075, -9.525
+0, 50.8, 124.892, 0, 135.484, 92.075, -9.525
+90, 0, 0, 0, 203.2, 57.15, -78.334
+90, -9.525, 0, 0, 203.2, 57.15, -78.334
+90, 50.8, 67.7418, 0, 101.6, 57.15, -78.334
+90, 41.275, 67.7418, 0, 101.6, 57.15, -78.334
+*AR-BRSTD,Brick wall, running bond
+0, 0, 0, 0, 67.7418
+90, 0, 0, 67.7418, 101.6, 67.7418, -67.7418
+*AR-CONC,Concrete, random aggregate
+50, 0, 0, 104.896, -149.807, 19.05, -209.55
+355, 0, 0, -51.76101082,187.25814969, 15.24, -167.64058417
+100.4514447,15.182007,-1.3282535,145.5569059,-176.270089,16.1900088,-178.0902446
+46.1842, 0, 50.8, 157.343, -224.71, 28.575, -314.325
+96.63555761,22.5899,47.2965,218.33577212,-264.40480444,24.28502314,-267.13560816
+351.18415117,0,50.8,196.67912063,280.88740361,22.85996707,-251.45973192
+21, 25.4, 38.1, 104.89565868, -149.80652586, 19.05, -209.55
+326, 25.4, 38.1, -51.7604, 187.258, 15.24, -167.64
+71.451445,38.0345326,29.5779001,145.5567546,-176.2700748,16.1900088,-178.0899376
+37.5, 0, 0, 53.9242, 65.2018, 0,        -165.608, 0, -170.18, 0, -168.275
+7.5, 0, 0, 79.3242, 90.6018, 0, -97.028, 0, -161.798, 0, -64.135
+-32.5, -56.642, 0, 117.434, 68.0212, 0, -63.5, 0, -198.12, 0, -262.89
+-42.5, -82.042, 0, 92.0344, 118.821, 0, -82.55, 0, -131.572, 0, -186.69
+*AR-HBONE,Brick paving, herringbone at 45 deg
+45, 0, 0, 101.6, 101.6, 304.8, -101.6
+135, 71.842, 71.842, 101.6, -101.6, 304.8, -101.6
+*AR-PARQ1,Parquet flooring, basket weave
+90, 0, 0, 304.8, 304.8, 304.8, -304.8
+90, 50.8, 0, 304.8, 304.8, 304.8, -304.8
+90, 101.6, 0, 304.8, 304.8, 304.8, -304.8
+90, 152.4, 0, 304.8, 304.8, 304.8, -304.8
+90, 203.2, 0, 304.8, 304.8, 304.8, -304.8
+90, 254, 0, 304.8, 304.8, 304.8, -304.8
+90, 304.8, 0, 304.8, 304.8, 304.8, -304.8
+0, 0, 304.8, 304.8, -304.8, 304.8, -304.8
+0, 0, 355.6, 304.8, -304.8, 304.8, -304.8
+0, 0, 406.4, 304.8, -304.8, 304.8, -304.8
+0, 0, 457.2, 304.8, -304.8, 304.8, -304.8
+0, 0, 508, 304.8, -304.8, 304.8, -304.8
+0, 0, 558.8, 304.8, -304.8, 304.8, -304.8
+0, 0, 609.6, 304.8, -304.8, 304.8, -304.8
+*AR-RROOF,Roof shingles
+0, 0, 0, 55.88, 25.4, 381, -50.8, 127, -25.4
+0, 33.782, 12.7, -25.4, 33.782, 76.2, -8.382, 152.4, -19.05
+0, 12.7, 21.59, 132.08, 17.018, 203.2, -35.56, 101.6, -25.4
+*AR-RSHKE,Roof wood shakes
+0, 0, 0, 647.7, 304.8, 152.4,   -127, 177.8, -76.2, 228.6, -101.6
+0, 152.4, 12.7, 647.7, 304.8, 127, -482.6, 101.6, -152.4
+0, 457.2, -19.05, 647.7, 304.8, 76.2, -787.4
+90, 0, 0, 304.8, 215.9, 292.1, -927.1
+90, 152.4, 0, 304.8, 215.9, 285.75, -933.45
+90, 279.4, 0, 304.8, 215.9, 266.7, -952.5
+90, 457.2, -19.05, 304.8, 215.9, 292.1, -927.1
+90, 533.4, -19.05, 304.8, 215.9, 292.1, -927.1
+90, 762, 0, 304.8, 215.9, 279.4, -939.8
+*AR-SAND,Sand stipple
+37.5, 0, 0, 28.5242, 39.8018, 0,        -38.608, 0, -43.18, 0, -41.275
+7.5, 0, 0, 53.9242, 65.2018, 0, -20.828, 0, -34.798, 0, -13.335
+-32.5, -31.242, 0, 66.6344, 42.6212, 0, -12.7, 0, -45.72, 0, -59.69
+-42.5, -31.242, 0, 41.2344, 68.0212, 0, -6.35, 0, -29.972, 0, -34.29
+*BOX,Interlocking box weave
+90, 0, 0, 0, 25.4
+90, 6.35, 0, 0, 25.4
+0, 0, 0, 0, 25.4, -6.35, 6.35
+0, 0, 6.35, 0, 25.4, -6.35, 6.35
+0, 0, 12.7, 0, 25.4, 6.35, -6.35
+0, 0, 19.05, 0, 25.4, 6.35, -6.35
+90, 12.7, 0, 0, 25.4, 6.35, -6.35
+90, 19.05, 0, 0, 25.4, 6.35, -6.35
+*BRASS,Brass
+0, 0, 0, 0, 6.35
+0, 0, 3.175, 0, 6.35, 3.175, -1.5875
+*BRICK,Brick coursing
+0, 0, 0, 0, 6.35
+90, 0, 0, 0, 12.7, 6.35, -6.35
+90, 6.35, 0, 0, 12.7, -6.35, 6.35
+*BRSTONE,Brick and stone mix
+0, 0, 0, 0, 8.382
+90, 22.86, 0, 8.382, 12.7, 8.382, -8.382
+90, 20.32, 0, 8.382, 12.7, 8.382, -8.382
+0, 22.86, 1.397, 12.7, 8.382, -22.86, 2.54
+0, 22.86, 2.794, 12.7, 8.382, -22.86, 2.54
+0, 22.86, 4.191, 12.7, 8.382, -22.86, 2.54
+0, 22.86, 5.588, 12.7, 8.382, -22.86, 2.54
+0, 22.86, 6.985, 12.7, 8.382, -22.86, 2.54
+*CLAY,Clay
+0, 0, 0, 0, 4.7625
+0, 0, 0.79375, 0, 4.7625
+0, 0, 1.5875, 0, 4.7625
+0, 0, 3.175, 0, 4.7625, 4.7625, -3.175
+*CORK,Cork
+0, 0, 0, 0, 3.175
+135, 1.5875, -1.5875, 0, 8.98026, 4.49013, -4.49013
+135, 2.38125, -1.5875, 0, 8.98026, 4.49013, -4.49013
+135, 3.175, -1.5875, 0, 8.98026, 4.49013, -4.49013
+*CROSS,Cross tiling
+0, 0, 0, 6.35, 6.35, 3.175, -9.525
+90, 1.5875, -1.5875, 6.35, 6.35, 3.175, -9.525
+*DASH,Staggered dashes
+0, 0, 0, 3.175, 3.175, 3.175, -3.175
+*DOLMIT,Layered rock (dolomite)
+0, 0, 0, 0, 6.35
+45, 0, 0, 0, 17.9605,8.98025612106915355989072339,-17.9605122421383071197814467
+*DOTS,Dot screen
+0, 0, 0, 0.79375, 1.5875, 0, -1.5875
+*EARTH,Earth (section)
+0, 0, 0, 6.35, 6.35, 6.35, -6.35
+0, 0, 2.38125, 6.35, 6.35, 6.35, -6.35
+0, 0, 4.7625, 6.35, 6.35, 6.35, -6.35
+90, 0.79375, 5.55625, 6.35, 6.35, 6.35, -6.35
+90, 3.175, 5.55625, 6.35, 6.35, 6.35, -6.35
+90, 5.55625, 5.55625, 6.35, 6.35, 6.35, -6.35
+*ESCHER,Isometric cube tiling
+60, 0, 0, -15.24, 26.3964542936, 27.94, -2.54
+180, 0, 0, -15.24, 26.3964542936, 27.94, -2.54
+300, 0, 0, 15.24, 26.3964542936, 27.94, -2.54
+60, 2.54, 0, -15.24, 26.3964542936, 5.08, -25.4
+300, 2.54, 0, 15.24, 26.3964542936, 5.08, -25.4
+60, -1.27, 2.199704516, -15.24, 26.3964542936, 5.08, -25.4
+180, -1.27, 2.199704516, -15.24, 26.3964542936, 5.08, -25.4
+300, -1.27, -2.199704516, 15.24, 26.3964542936, 5.08, -25.4
+180, -1.27, -2.199704516, -15.24, 26.3964542936, 5.08, -25.4
+60, -10.16, 0, -15.24, 26.3964542936, 5.08, -25.4
+300, -10.16, 0, 15.24, 26.3964542936, 5.08, -25.4
+60, 5.08, -8.7988180894, -15.24, 26.3964542936, 5.08, -25.4
+180, 5.08, -8.7988180894, -15.24, 26.3964542936, 5.08, -25.4
+300, 5.08, 8.7988180894, 15.24, 26.3964542936, 5.08, -25.4
+180, 5.08, 8.7988180894, -15.24, 26.3964542936, 5.08, -25.4
+0, 5.08, 4.3994090574, -15.24, 26.3964542936, 17.78, -12.7
+0, 5.08, -4.3994090574, -15.24, 26.3964542936, 17.78, -12.7
+120, 1.27, 6.5991135734, 15.24, 26.3964542936, 17.78, -12.7
+120, -6.35, 2.199704516, 15.24, 26.3964542936, 17.78, -12.7
+240, -6.35, -2.199704516, 15.24, 26.3964542936, 17.78, -12.7
+240, 1.27, -6.5991135734, 15.24, 26.3964542936, 17.78, -12.7
+*FLEX,Flexible material
+0, 0, 0, 0, 6.35, 6.35, -6.35
+45,6.35,0,4.490128053,4.490128053,1.5875,-5.8052561314,1.5875,-8.9802561314
+*GOST_GLASS,Glass (GOST)
+45, 0, 0, 6, -6, 5, -7
+45, 2.121320, 0, 6, -6, 2, -10
+45, 0, 2.121320, 6, -6, 2, -10
+*GOST_GROUND,Ground (GOST)
+45, 0, 0, 10, -10, 20
+45, 3, 0, 10, -10, 20
+45, 6, 0, 10, -10, 20
+*GOST_WOOD,Wood (GOST)
+90, 0, 0, 0, -6, 10, -2
+90, 2, -2, 0, -6, 6, -1.5, 3, -1.5
+90, 4, -5, 0, -6, 10, -2
+*GRASS,Grass
+90, 0, 0, 17.96051224, 17.96051224, 4.7625, -31.15852448
+45, 0, 0, 0, 25.4, 4.7625, -20.6375
+135, 0, 0, 0, 25.4, 4.7625, -20.6375
+*GRATE,Grating
+0, 0, 0, 0, 0.79375
+90, 0, 0, 0, 3.175
+*GRAVEL,Gravel, random cobbles
+228.0127875,18.288,25.4,305.85067529778,1.88796713245,3.4172144,-338.30483639565
+184.969741,16.002,22.86,-305.8545235377,1.10019612724,5.8640472,-580.54048893524
+132.5104471,10.16,22.352,-377.59492241548,1.56030959675,4.1348152,-409.347227941
+267.273689,.254,16.002,-508.63316875916,1.20815479432,5.3400452,-528.66437425738
+292.83365418,0.0,10.668,-330.19770134945,1.23208097566,5.236337,-518.39807745344
+357.273689,2.032,5.842,-508.63316875916,1.20815479432,5.3400452,-528.66437425738
+37.69424047,7.366,5.588,-416.58997273292,.91357450169,7.0619366,-699.13115314247
+72.25532837,12.954,9.906,586.40373773403,.96766293399,6.6671952,-660.05256601905
+121.42956562,14.986,16.256,387.71230339293,1.2040754753,5.35813,-530.45545698712
+175.2363583,12.192,20.828,-280.5442400419,2.10935518695,6.1171328,-299.7393695
+222.3974378,6.096,21.336,413.48123885686,.81554484621,7.9107792,-783.16772512177
+138.81407483,25.4,15.748,234.164238558,2.38943100688,2.7000454,-267.30565824344
+171.4692344,23.368,17.526,-334.082478726,1.25594916784,5.1368198,-508.5463899704
+225.00000,18.288,18.288,17.96051224214,17.96051224214,3.5920934,-32.32893108428
+203.19859051,16.51,21.336,-136.74251918,3.33518339548,1.9344132,-191.50622368894
+291.80140949,14.732,20.574,-80.18324702488,4.71666158921,2.7356562,-134.0475299
+30.96375653,15.748,18.034,91.47734531502,4.35606406258,4.4431966,-143.6629815291
+161.56505118,19.558,20.32,-56.2252967978,8.03218525675,3.2128714,-77.10898116828
+16.389540334,0.0,20.574,265.17991128726,1.43340492604,4.50088,-445.58826672539
+70.34617594,4.318,21.844,-297.29446803469,1.70858889651,3.7759894,-373.822156782
+293.19859051,19.558,25.4,-136.7425191801,3.33518339548,3.868801,-189.57183588894
+343.61045967,21.082,21.844,-265.17991128725,1.433404926,4.50088,-445.5882667254
+339.44395478,0.0,4.826,-136.75087638398,2.97284513779,4.340352,-212.67734313106
+294.7751406,4.064,3.302,-306.90424056705,1.77401295215,3.6367212,-360.0359338072
+66.80140949,19.812,0.0,136.74251918012,3.33518339452,3.868801,-189.57183588894
+17.35402464,21.336,3.556,-345.47402804977,1.51523696536,4.2578274,-421.523759802
+69.44395478,7.366,0.0,-136.75087638396,2.97284513874,2.170176,-214.84751913106
+101.309932474,18.288,0.0,104.60834648271,4.98134983255,1.295146,-128.21994964526
+165.963756532,18.034,1.27,-80.085263387,6.16040487582,5.236337,-99.49054589069
+186.00900596,12.954,2.54,-255.26337856879,1.32949676118,4.85267,-480.41364863337
+303.69006753,15.748,15.748,-56.35753993648,7.0446924921,3.6632388,-87.9177635968
+353.15722659,17.78,12.7,434.77679606606,1.0087628707,6.3955676,-633.16009065031
+60.9453959,24.13,11.938,-204.76648550216,2.46706609031,2.6150824,-258.8939231811
+90.0000000,25.4,14.224,25.4,25.4,1.524,-23.876
+120.25643716,12.446,3.302,-204.77318477297,1.8283320086,3.5286696,-349.339407732
+48.01278750,10.668,6.35,305.85067529778,1.88796713138,6.8344288,-334.88762199565
+0.000000000,15.24,11.43,25.4,25.4,6.604,-18.796
+325.3048465,21.844,11.43,310.04235091354,-1.6064370526,4.0160956,-397.5931672414
+254.0546041,25.146,9.144,104.6687497289,3.48895832444,3.6982908,-181.21650038772
+207.64597536,24.13,5.588,545.36007557253,1.07143433066,6.021451,-596.12464422938
+175.42607874,18.796,2.794,331.1739336186,1.01276432357,6.3702946,-630.6584645624
+*HEX,Hexagonal mesh
+0, 0, 0, 0, 5.4992613154, 3.175, -6.35
+120, 0, 0, 0, 5.4992613154, 3.175, -6.35
+60, 3.175, 0, 0, 5.4992613154, 3.175, -6.35
+*HONEY,Honeycomb
+0, 0, 0, 4.7625, 2.749630645, 3.175, -6.35
+120, 0, 0, 4.7625, 2.749630645, 3.175, -6.35
+60, 0, 0, 4.7625, 2.749630645, -6.35, 3.175
+*HOUND,Houndstooth
+0, 0, 0, 6.35, 1.5875, 25.4, -12.7
+90, 0, 0, -6.35, 1.5875, 25.4, -12.7
+*INSUL,Insulation batt
+0, 0, 0, 0, 9.525
+0, 0, 3.175, 0, 9.525, 3.175, -3.175
+0, 0, 6.35, 0, 9.525, 3.175, -3.175
+*LINE,Horizontal lines
+0, 0, 0, 0, 3.175
+*MUDST,Mud / sand (geological)
+0, 0, 0, 12.7, 6.35, 6.35,      -6.35, 0, -6.35, 0, -6.35
+*NET,Square grid
+0, 0, 0, 0, 3.175
+90, 0, 0, 0, 3.175
+*NET3,Triangular grid
+0, 0, 0, 0, 3.175
+60, 0, 0, 0, 3.175
+120, 0, 0, 0, 3.175
+*PLAST,Plastic
+0, 0, 0, 0, 6.35
+0, 0, 0.79375, 0, 6.35
+0, 0, 1.5875, 0, 6.35
+*PLASTI,Plastic, dense
+0, 0, 0, 0, 6.35
+0, 0, 0.79375, 0, 6.35
+0, 0, 1.5875, 0, 6.35
+0, 0, 3.96875, 0, 6.35
+*SACNCR,Concrete, dotted diagonal
+45, 0, 0, 0, 2.38125
+45, 1.6838, 0, 0, 2.38125, 0, -2.38125
+*SQUARE,Dashed square lattice
+0, 0, 0, 0, 3.175, 3.175, -3.175
+90, 0, 0, 0, 3.175, 3.175, -3.175
+*STARS,Six-pointed star lattice
+0, 0, 0, 0, 5.4992613154, 3.175, -3.175
+60, 0, 0, 0, 5.4992613154, 3.175, -3.175
+120, 1.5875, 2.7496306704, 0, 5.4992613154, 3.175, -3.175
+*STEEL,Steel, paired lines
+45, 0, 0, 0, 3.175
+45, 0, 1.5875, 0, 3.175
+*SWAMP,Swamp / marsh
+0, 0, 0, 12.7, 21.9970452362, 3.175, -22.225
+90, 1.5875, 0, 21.9970452362, 12.7, 1.5875, -42.4065904724
+90, 1.984375, 0, 21.9970452362, 12.7, 1.27, -42.7240904724
+90, 1.190625, 0, 21.9970452362, 12.7, 1.27, -42.7240904724
+60, 2.38125, 0, 12.7, 21.9970452362, 1.016, -24.384
+120, 0.79375, 0, 12.7, 21.9970452362, 1.016, -24.384
+*TRANS,Heat-transfer surface
+0, 0, 0, 0, 6.35
+0, 0, 3.175, 0, 6.35, 3.175, -3.175
+*TRIANG,Triangle tiling
+60, 0, 0, 4.7625, 8.2488919604, 4.7625, -4.7625
+120, 0, 0, 4.7625, 8.2488919604, 4.7625, -4.7625
+0, -2.38125, 4.1244459802, 4.7625, 8.2488919604, 4.7625, -4.7625
+*ZIGZAG,Stair-step zigzag
+0, 0, 0, 3.175, 3.175, 3.175, -3.175
+90, 3.175, 0, 3.175, 3.175, 3.175, -3.175
+
+;;  Hatch companions to the ISO 128 line types (1 mm pen base).
+
+*ACAD_ISO02W100,ISO dashed
+0, 0,0, 0,5, 12,-3
+*ACAD_ISO03W100,ISO dashed, wide gaps
+0, 0,0, 0,5, 12,-18
+*ACAD_ISO04W100,ISO long-dash dot
+0, 0,0, 0,5, 24,-3,.5,-3
+*ACAD_ISO05W100,ISO long-dash double-dot
+0, 0,0, 0,5, 24,-3,.5,-3,.5,-3
+*ACAD_ISO06W100,ISO long-dash triple-dot
+0, 0,0, 0,5, 24,-3,.5,-3,.5,-6.5
+0, 0,0, 0,5, -34,.5,-3
+*ACAD_ISO07W100,ISO dotted
+0, 0,0, 0,5, .5,-3
+*ACAD_ISO08W100,ISO long-dash short-dash
+0, 0,0, 0,5, 24,-3,6,-3
+*ACAD_ISO09W100,ISO long-dash double short-dash
+0, 0,0, 0,5, 24,-3,6,-3,6,-3
+*ACAD_ISO10W100,ISO dash dot
+0, 0,0, 0,5, 12,-3,.5,-3
+*ACAD_ISO11W100,ISO double-dash dot
+0, 0,0, 0,5, 12,-3,12,-3,.5,-3
+*ACAD_ISO12W100,ISO dash double-dot
+0, 0,0, 0,5, 12,-3,.5,-3,.5,-3
+*ACAD_ISO13W100,ISO double-dash double-dot
+0, 0,0, 0,5, 12,-3,12,-3,.5,-6.5
+0, 0,0, 0,5, -33.5,.5,-3
+*ACAD_ISO14W100,ISO dash triple-dot
+0, 0,0, 0,5, 12,-3,.5,-3,.5,-6.5
+0, 0,0, 0,5, -22,.5,-3
+*ACAD_ISO15W100,ISO double-dash triple-dot
+0, 0,0, 0,5, 12,-3,12,-3,.5,-10
+0, 0,0, 0,5, -33.5,.5,-3,.5,-3
+
+;;  JIS A 0150 section patterns.
+
+*JIS_LC_20,Lightweight concrete, 20 mm (JIS)
+45,0,0,0,20
+45,.4,0,0,20
+*JIS_LC_20A,Lightweight concrete, 20 mm wide (JIS)
+45,0,0,0,20
+45,1,0,0,20
+*JIS_LC_8,Lightweight concrete, 8 mm (JIS)
+45,0,0,0,7.8
+45,.4,0,0,7.8
+*JIS_LC_8A,Lightweight concrete, 8 mm wide (JIS)
+45,0,0,0,7.8
+45,1,0,0,7.8
+*JIS_RC_10,Reinforced concrete, 10 mm (JIS)
+45,0,0,0,10
+45,.725,0,0,10
+45,1.45,0,0,10
+*JIS_RC_15,Reinforced concrete, 15 mm (JIS)
+45,0,0,0,15
+45,.725,0,0,15
+45,1.45,0,0,15
+*JIS_RC_18,Reinforced concrete, 18 mm (JIS)
+45,0,0,0,18
+45,1,0,0,18
+45,2,0,0,18
+*JIS_RC_30,Reinforced concrete, 30 mm (JIS)
+45,0,0,0,30
+45,1,0,0,30
+45,2,0,0,30
+*JIS_STN_1E,Stone, 1 mm (JIS)
+45, 0, 0, 0, 1
+45, .705, 0, 0,1, 1, -.5
+*JIS_STN_2.5,Stone, 2.5 mm (JIS)
+45, 0, 0, 0, 2.5
+45, 1.765, 0, 0,2.5, 1.2, -.5
+*JIS_WOOD,Wood (JIS)
+45,0,0,0,.70710678
+`;
+
+// ../core/src/model/hatchPatterns.ts
+var parsePatternDefinitions = (text, unitScale = 25.4) => {
+  const DEG2RAD = Math.PI / 180;
+  const patterns = [];
+  let current = null;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith(";")) continue;
+    if (line.startsWith("*")) {
+      const [name, ...desc] = line.slice(1).split(",");
+      current = { name: name.trim(), lines: [] };
+      const d = desc.join(",").trim();
+      if (d) current.description = d;
+      patterns.push(current);
+      continue;
+    }
+    if (!current) continue;
+    const n = line.split(",").map((s) => Number(s.trim()));
+    if (n.length < 5 || n.some((v) => Number.isNaN(v))) continue;
+    const [angle2, x, y, dx, dy, ...dashes] = n;
+    current.lines.push({
+      angle: angle2 * DEG2RAD,
+      origin: { x: x * unitScale, y: y * unitScale },
+      deltaX: dx * unitScale,
+      deltaY: dy * unitScale,
+      dashesMm: dashes.length ? dashes.map((v) => v * unitScale) : void 0
+    });
+  }
+  return patterns.filter((p) => p.lines.length > 0);
+};
+var BUILT_IN_PATTERNS = parsePatternDefinitions(
+  BUILTIN_PAT,
+  1
+).filter((p) => p.name.toUpperCase() !== "SOLID");
+var normalizeName = (name) => name.trim().toUpperCase().replace(/[\s.-]+/g, "_");
+var BUILT_IN_BY_NAME = new Map(
+  BUILT_IN_PATTERNS.map((p) => [normalizeName(p.name), p])
+);
+var HATCH_PATTERN_NAMES = BUILT_IN_PATTERNS.map(
+  (p) => p.name
+);
+var getHatchPattern = (name) => BUILT_IN_BY_NAME.get(normalizeName(name));
+var MAX_HATCH_SEGMENTS = 1e5;
+var estimatePatternSegments = (rings, pattern2, scale3) => {
+  if (scale3 <= 0) return 0;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const ring of rings)
+    for (const p of ring) {
+      if (p.x < minX) minX = p.x;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.y > maxY) maxY = p.y;
+    }
+  if (minX > maxX) return 0;
+  const diag = Math.hypot(maxX - minX, maxY - minY);
+  let count = 0;
+  for (const fam of pattern2.lines) {
+    const perp2 = Math.abs(fam.deltaY) * scale3;
+    if (perp2 <= 1e-9) continue;
+    const lines = diag / perp2 + 1;
+    const period = (fam.dashesMm?.reduce((a, b) => a + Math.abs(b), 0) ?? 0) * scale3;
+    const perLine = period > 1e-9 ? diag / period + 1 : 1;
+    count += lines * perLine;
+  }
+  return count;
+};
+var computePatternGeometry = (rings, pattern2, angle2, scale3, origin = { x: 0, y: 0 }) => {
+  const out = [];
+  if (scale3 <= 0) return out;
+  const c = Math.cos(angle2);
+  const s = Math.sin(angle2);
+  for (const fam of pattern2.lines) {
+    if (Math.abs(fam.deltaY) * scale3 <= 1e-9) continue;
+    const ox = fam.origin.x * scale3;
+    const oy = fam.origin.y * scale3;
+    const segs = computeHatchFamily(rings, {
+      angle: angle2 + fam.angle,
+      origin: { x: ox * c - oy * s + origin.x, y: ox * s + oy * c + origin.y },
+      deltaAlong: fam.deltaX * scale3,
+      deltaPerp: fam.deltaY * scale3,
+      dashesMm: fam.dashesMm?.map((d) => d * scale3)
+    });
+    for (const seg of segs) out.push(seg);
+  }
+  return out;
+};
+var PatternLineSchema = z2.object({
+  /** Radians CCW, in the pattern's own frame. */
+  angle: z2.number(),
+  /** Base point, mm. */
+  origin: Vec2Schema,
+  /** Shift ALONG the line between successive lines (dash phase), mm. */
+  deltaX: z2.number(),
+  /** Perpendicular spacing between successive lines, mm. */
+  deltaY: z2.number().positive(),
+  /** Dash cycle along the line: >0 dash, <0 gap, 0 dot; absent = solid. */
+  dashesMm: z2.array(z2.number()).optional()
+});
+var HatchPatternSchema = z2.object({
+  /** Stored on fills as `fill.name`; case-insensitive, unique per document. */
+  name: z2.string().min(1),
+  description: z2.string().optional(),
+  lines: z2.array(PatternLineSchema).min(1)
+});
+var hatchPatternKey = (name) => normalizeName(name);
+var resolveHatchPattern = (name, hatchPatterns) => {
+  if (!name) return void 0;
+  if (hatchPatterns && hatchPatterns.length > 0) {
+    const key = normalizeName(name);
+    const own = hatchPatterns.find((p) => normalizeName(p.name) === key);
+    if (own) return own;
+  }
+  return getHatchPattern(name);
+};
+
+// ../core/src/export/dxf/exportDxf.ts
+import {
+  DxfWriter,
+  Units,
+  LayerFlags,
+  LWPolylineFlags,
+  TextHorizontalAlignment,
+  TextVerticalAlignment,
+  HatchBoundaryPaths,
+  HatchPolylineBoundary,
+  HatchPredefinedPatterns,
+  pattern
+} from "@tarikjabiri/dxf";
+
+// ../core/src/model/objects.ts
+import { z as z3 } from "zod";
+
 // ../core/src/model/fonts.ts
 var DEFAULT_FONT = "arial";
 var FONTS = {
@@ -172,102 +868,185 @@ var fontTypeface = (def) => def.cssStack.split(",")[0].replace(/["']/g, "").trim
 var FONT_OPTIONS = Object.values(
   FONTS
 ).filter((f) => f.id !== "osifont-italic").map((f) => ({ value: f.id, label: f.label }));
+var SHX_STEMS = /* @__PURE__ */ new Set([
+  "txt",
+  "monotxt",
+  "simplex",
+  "complex",
+  "romans",
+  "romand",
+  "romanc",
+  "romant",
+  "italic",
+  "italicc",
+  "italict",
+  "scripts",
+  "scriptc",
+  "gothice",
+  "gothicg",
+  "gothici",
+  "greeks",
+  "greekc",
+  "isocp",
+  "isocp2",
+  "isocp3",
+  "isoct",
+  "isoct2",
+  "isoct3",
+  "iso",
+  "amgdt",
+  "gdt",
+  "symap",
+  "syastro",
+  "symath",
+  "symeteo",
+  "symusic",
+  "bigfont",
+  "ltypeshp",
+  "swiss",
+  "swissb",
+  "swissi",
+  "swissbi",
+  "sansserif",
+  "sanss",
+  "sansserifb",
+  "sanssb",
+  "arc",
+  "ic-romans",
+  "ic-simplex",
+  "txtalt"
+]);
+var fontFromDxfStyle = (fontFile, typeface) => {
+  const file = (fontFile ?? "").trim();
+  const stem = file.replace(/\.[a-z0-9]+$/i, "").toLowerCase();
+  const family = (typeface ?? "").trim();
+  const familyLower = family.toLowerCase();
+  for (const def of Object.values(FONTS)) {
+    if (file && def.dxfFontFile.toLowerCase() === file.toLowerCase() || familyLower && fontTypeface(def).toLowerCase() === familyLower)
+      return def.id === "osifont-italic" ? { font: "osifont", italic: true } : { font: def.id };
+  }
+  const arialFace = /^arial(bd|bi|i)$/.exec(stem);
+  if (arialFace)
+    return {
+      font: "arial",
+      ...arialFace[1].includes("b") ? { bold: true } : {},
+      ...arialFace[1].includes("i") ? { italic: true } : {}
+    };
+  const key = `${familyLower} ${stem}`;
+  if (/narrow|condensed|arialn/.test(key)) return { font: "roboto-condensed" };
+  if (/mono|courier|\bcour\b|consola|lucon|menlo/.test(key))
+    return { font: "jetbrains-mono" };
+  if (/times|georgia|cambria|garamond|serif|\bbook/.test(key))
+    return { font: "source-serif" };
+  if (/comic/.test(key)) return { font: "comic-neue" };
+  if (/\.shx$/i.test(file) || !file && !family || SHX_STEMS.has(stem))
+    return {
+      font: "osifont",
+      .../italic/.test(stem) ? { italic: true } : {}
+    };
+  return { font: family || stem };
+};
 
 // ../core/src/model/objects.ts
 var PointSchema = ObjectBaseSchema.extend({
-  type: z2.literal("point"),
+  type: z3.literal("point"),
   p: Vec2Schema
 });
 var LineSchema = ObjectBaseSchema.extend({
-  type: z2.literal("line"),
+  type: z3.literal("line"),
   a: Vec2Schema,
   b: Vec2Schema
 });
-var PolylineVertexSchema = z2.preprocess(
+var PolylineVertexSchema = z3.preprocess(
   (v) => Array.isArray(v) && v.length >= 2 ? { x: v[0], y: v[1], bulge: v[2] ?? 0 } : v,
-  z2.object({ x: z2.number(), y: z2.number(), bulge: z2.number().default(0) })
+  z3.object({ x: z3.number(), y: z3.number(), bulge: z3.number().default(0) })
 );
 var PolylineSchema = ObjectBaseSchema.extend({
-  type: z2.literal("polyline"),
-  points: z2.array(PolylineVertexSchema).min(2),
-  closed: z2.boolean().default(false)
+  type: z3.literal("polyline"),
+  points: z3.array(PolylineVertexSchema).min(2),
+  closed: z3.boolean().default(false)
 });
 var CircleSchema = ObjectBaseSchema.extend({
-  type: z2.literal("circle"),
+  type: z3.literal("circle"),
   center: Vec2Schema,
-  radius: z2.number().positive()
+  radius: z3.number().positive()
 });
 var ArcSchema = ObjectBaseSchema.extend({
-  type: z2.literal("arc"),
+  type: z3.literal("arc"),
   center: Vec2Schema,
-  radius: z2.number().positive(),
-  startAngle: z2.number(),
-  endAngle: z2.number()
+  radius: z3.number().positive(),
+  startAngle: z3.number(),
+  endAngle: z3.number()
 });
 var EllipseSchema = ObjectBaseSchema.extend({
-  type: z2.literal("ellipse"),
+  type: z3.literal("ellipse"),
   center: Vec2Schema,
   majorAxis: Vec2Schema,
-  ratio: z2.number().gt(0).max(1),
-  startAngle: z2.number().default(0),
-  endAngle: z2.number().default(Math.PI * 2)
+  ratio: z3.number().gt(0).max(1),
+  startAngle: z3.number().default(0),
+  endAngle: z3.number().default(Math.PI * 2)
 });
-var HatchLoopSchema = z2.object({
-  points: z2.array(PolylineVertexSchema).min(3)
+var HatchLoopSchema = z3.object({
+  points: z3.array(PolylineVertexSchema).min(3)
 });
-var HatchFillSchema = z2.discriminatedUnion("kind", [
-  z2.object({ kind: z2.literal("solid") }),
-  z2.object({
-    kind: z2.literal("pattern"),
-    name: z2.string(),
-    angle: z2.number(),
-    scale: z2.number().positive()
+var HatchFillSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("solid") }),
+  z3.object({
+    kind: z3.literal("pattern"),
+    name: z3.string(),
+    angle: z3.number(),
+    scale: z3.number().positive(),
+    /** Where the pattern frame is anchored, world mm (absent = the drawing
+     * origin, like a hatch drawn here). Set by import for hatches that came
+     * out of blocks — AutoCAD anchors a block's hatch to the block, so the
+     * pattern phase follows the insertion — and carried by the transforms. */
+    origin: Vec2Schema.optional()
   }),
-  z2.object({
-    kind: z2.literal("lines"),
-    angle: z2.number(),
-    spacing: z2.number().positive()
+  z3.object({
+    kind: z3.literal("lines"),
+    angle: z3.number(),
+    spacing: z3.number().positive()
   }),
-  z2.object({
-    kind: z2.literal("gradient"),
+  z3.object({
+    kind: z3.literal("gradient"),
     /** linear = color1→color2 along `angle`; radial = color1 at the
      * boundary's center fading to color2 at its edge. */
-    shape: z2.enum(["linear", "radial"]).default("linear"),
-    color1: z2.string().default("#808080"),
-    color2: z2.string().default("#2d2d2d"),
+    shape: z3.enum(["linear", "radial"]).default("linear"),
+    color1: z3.string().default("#808080"),
+    color2: z3.string().default("#2d2d2d"),
     /** Direction, radians CCW: 0 = color1 on the left (linear only). */
-    angle: z2.number().default(0)
+    angle: z3.number().default(0)
   })
 ]);
 var HatchSchema = ObjectBaseSchema.extend({
-  type: z2.literal("hatch"),
-  loops: z2.array(HatchLoopSchema).min(1),
+  type: z3.literal("hatch"),
+  loops: z3.array(HatchLoopSchema).min(1),
   fill: HatchFillSchema.default({
     kind: "lines",
     angle: Math.PI / 4,
     spacing: 5
   }),
   /** Pattern spacing multiplier (same idea as DimStyle.scale). */
-  scale: z2.number().positive().default(1)
+  scale: z3.number().positive().default(1)
 });
-var ArrowTypeSchema = z2.enum(["filled", "open", "tick", "dot", "none"]);
-var TextStyleSchema = z2.object({
-  id: z2.string().default(() => crypto.randomUUID()),
-  name: z2.string().default("Standard"),
+var ArrowTypeSchema = z3.enum(["filled", "open", "tick", "dot", "none"]);
+var TextStyleSchema = z3.object({
+  id: z3.string().default(() => crypto.randomUUID()),
+  name: z3.string().default("Standard"),
   /** Font id (model/fonts.ts). */
-  font: z2.string().default("arial"),
+  font: z3.string().default("arial"),
   /** AutoCAD-style width factor: horizontal glyph scale. */
-  widthFactor: z2.number().positive().default(1),
+  widthFactor: z3.number().positive().default(1),
   /** Bold / italic face (bundled outlines where the font has them, else
    * synthesized — model/fonts.ts `fontFace`). Absent = regular. */
-  bold: z2.boolean().optional(),
-  italic: z2.boolean().optional(),
+  bold: z3.boolean().optional(),
+  italic: z3.boolean().optional(),
   /** Cap height in mm (world), before the object's `scale`. */
-  textHeight: z2.number().positive().default(2.5),
+  textHeight: z3.number().positive().default(2.5),
   /** Leader arrowhead style. */
   arrowType: ArrowTypeSchema.default("filled"),
   /** Leader arrowhead size (mm), before the object's `scale`. */
-  arrowSize: z2.number().positive().default(2.5)
+  arrowSize: z3.number().positive().default(2.5)
 });
 var DEFAULT_TEXT_STYLE = {
   id: "standard",
@@ -278,14 +1057,14 @@ var DEFAULT_TEXT_STYLE = {
   arrowType: "filled",
   arrowSize: 2.5
 };
-var TextStyleOverrideSchema = z2.object({
-  font: z2.string().optional(),
-  widthFactor: z2.number().positive().optional(),
-  bold: z2.boolean().optional(),
-  italic: z2.boolean().optional(),
-  textHeight: z2.number().positive().optional(),
+var TextStyleOverrideSchema = z3.object({
+  font: z3.string().optional(),
+  widthFactor: z3.number().positive().optional(),
+  bold: z3.boolean().optional(),
+  italic: z3.boolean().optional(),
+  textHeight: z3.number().positive().optional(),
   arrowType: ArrowTypeSchema.optional(),
-  arrowSize: z2.number().positive().optional()
+  arrowSize: z3.number().positive().optional()
 });
 var textStyleFor = (obj, styles) => styles.find((s) => s.id === obj.styleId) ?? styles[0] ?? DEFAULT_TEXT_STYLE;
 var resolveTextStyle = (obj, styles) => ({ ...textStyleFor(obj, styles), ...obj.styleOverride });
@@ -301,62 +1080,79 @@ var effectiveTextFont = (obj, styles) => {
     widthFactor: o?.widthFactor ?? base.widthFactor
   };
 };
+var TextSpanSchema = z3.object({
+  start: z3.number().int().min(0),
+  end: z3.number().int().min(0),
+  /** Font id (model/fonts.ts). */
+  font: z3.string().optional(),
+  bold: z3.boolean().optional(),
+  italic: z3.boolean().optional(),
+  underline: z3.boolean().optional(),
+  /** Literal colour; absent = the text's own (possibly ByLayer) colour. */
+  color: ColorSchema.optional(),
+  /** × the text's cap height. */
+  height: z3.number().positive().optional(),
+  script: z3.enum(["sub", "super"]).optional()
+});
 var TextSchema = ObjectBaseSchema.extend({
-  type: z2.literal("text"),
+  type: z3.literal("text"),
   position: Vec2Schema,
-  content: z2.string(),
+  content: z3.string(),
+  /** Character formatting over `content`; absent = all plain. Replacing
+   * `content` without new spans drops them (offsets would be stale). */
+  spans: z3.array(TextSpanSchema).optional(),
   /** Arrow polylines pointing at this text (arrowhead at [0]). */
-  leaderLines: z2.array(z2.array(Vec2Schema).min(2)).default([]),
+  leaderLines: z3.array(z3.array(Vec2Schema).min(2)).default([]),
   /**
    * Max text box width in mm (before `scale`) — the word-wrap boundary and the
    * frame width. Undefined = no wrapping (lines break only on explicit
    * newlines). Maps to the DXF MTEXT reference rectangle width.
    */
-  width: z2.number().positive().optional(),
-  hAlign: z2.enum(["left", "center", "right"]).default("center"),
-  vAlign: z2.enum(["bottom", "center", "top"]).default("center"),
+  width: z3.number().positive().optional(),
+  hAlign: z3.enum(["left", "center", "right"]).default("center"),
+  vAlign: z3.enum(["bottom", "center", "top"]).default("center"),
   /** Border drawn around the text: a rectangle, a circle, a slot (rounded
    * ends), a line under the text or under its first line. */
-  frame: z2.enum(["none", "rectangle", "circle", "slot", "bottom", "firstLine"]).optional(),
+  frame: z3.enum(["none", "rectangle", "circle", "slot", "bottom", "firstLine"]).optional(),
   /** The document text style this text follows (absent/dangling = the
    * document's first style). */
-  styleId: z2.string().optional(),
+  styleId: z3.string().optional(),
   /** Style keys the user set on THIS text (font, height, arrows, …);
    * absent = inherit the referenced style. */
   styleOverride: TextStyleOverrideSchema.optional(),
-  rotation: z2.number().default(0),
+  rotation: z3.number().default(0),
   /** Size multiplier for height + arrow size (same idea as
    * Dimension.scale). */
-  scale: z2.number().positive().default(1)
+  scale: z3.number().positive().default(1)
 });
-var DimensionKindSchema = z2.enum([
+var DimensionKindSchema = z3.enum([
   "linear",
   "angular",
   "radial",
   "diameter"
 ]);
-var DimStyleSchema = z2.object({
-  id: z2.string().default(() => crypto.randomUUID()),
-  name: z2.string().default("Standard"),
+var DimStyleSchema = z3.object({
+  id: z3.string().default(() => crypto.randomUUID()),
+  name: z3.string().default("Standard"),
   /** Font id for dimension text (model/fonts.ts). */
-  font: z2.string().default("arial"),
+  font: z3.string().default("arial"),
   /** Horizontal glyph scale for dimension text. */
-  widthFactor: z2.number().positive().default(1),
+  widthFactor: z3.number().positive().default(1),
   /** Bold / italic dimension text (same faces as TextStyle). */
-  bold: z2.boolean().optional(),
-  italic: z2.boolean().optional(),
-  textHeight: z2.number().positive().default(2.5),
+  bold: z3.boolean().optional(),
+  italic: z3.boolean().optional(),
+  textHeight: z3.number().positive().default(2.5),
   /** Dimension line → text center distance (mm, × scale; DXF DIMGAP-ish). */
-  textOffset: z2.number().default(1.8),
+  textOffset: z3.number().default(1.8),
   arrowType: ArrowTypeSchema.default("tick"),
-  arrowSize: z2.number().positive().default(2.5),
+  arrowSize: z3.number().positive().default(2.5),
   /** "long" runs each extension line from the measured point to the
    * dimension line; "short" draws only a 2×overshoot tick across it. */
-  extensionType: z2.enum(["long", "short"]).default("long"),
-  extensionOffset: z2.number().default(1),
-  extensionOvershoot: z2.number().default(1.25),
+  extensionType: z3.enum(["long", "short"]).default("long"),
+  extensionOffset: z3.number().default(1),
+  extensionOvershoot: z3.number().default(1.25),
   /** Decimal places for the measurement text. */
-  precision: z2.number().int().min(0).max(6).default(1)
+  precision: z3.number().int().min(0).max(6).default(1)
 });
 var DEFAULT_DIM_STYLE = {
   id: "standard",
@@ -372,19 +1168,19 @@ var DEFAULT_DIM_STYLE = {
   extensionOvershoot: 1,
   precision: 1
 };
-var DimStyleOverrideSchema = z2.object({
-  font: z2.string().optional(),
-  widthFactor: z2.number().positive().optional(),
-  bold: z2.boolean().optional(),
-  italic: z2.boolean().optional(),
-  textHeight: z2.number().positive().optional(),
-  textOffset: z2.number().optional(),
+var DimStyleOverrideSchema = z3.object({
+  font: z3.string().optional(),
+  widthFactor: z3.number().positive().optional(),
+  bold: z3.boolean().optional(),
+  italic: z3.boolean().optional(),
+  textHeight: z3.number().positive().optional(),
+  textOffset: z3.number().optional(),
   arrowType: ArrowTypeSchema.optional(),
-  arrowSize: z2.number().positive().optional(),
-  extensionType: z2.enum(["long", "short"]).optional(),
-  extensionOffset: z2.number().optional(),
-  extensionOvershoot: z2.number().optional(),
-  precision: z2.number().int().min(0).max(6).optional()
+  arrowSize: z3.number().positive().optional(),
+  extensionType: z3.enum(["long", "short"]).optional(),
+  extensionOffset: z3.number().optional(),
+  extensionOvershoot: z3.number().optional(),
+  precision: z3.number().int().min(0).max(6).optional()
 });
 var unknownStyleOverrideKeys = (input) => {
   const so = input.styleOverride;
@@ -403,48 +1199,114 @@ var assertKnownStyleOverrideKeys = (input, where) => {
 };
 var dimStyleFor = (obj, styles) => styles.find((s) => s.id === obj.styleId) ?? styles[0] ?? DEFAULT_DIM_STYLE;
 var dimFontFace = (style) => fontFace(style.font, style.bold, style.italic);
-var DimensionSchema = ObjectBaseSchema.extend({
-  type: z2.literal("dimension"),
+var DIM_VALUE_TOKEN = "{value}";
+var DimLabelSchema = z3.object({
+  /** mm along the dimension line from the segment's origin (linear: the
+   * foot of the segment's first point; angular: where ray a meets the arc,
+   * as arc length; radial/diameter: the center). Undefined = automatic
+   * placement: centered when the text fits, else outside. */
+  along: z3.number().optional(),
+  /** mm perpendicular to the dimension line, positive on the side the
+   * dimension line is on (linear/angular) or to the left of `along`
+   * (radial/diameter). Undefined or 0 = on the line; otherwise the text
+   * floats, with a leader when it no longer overlaps its segment. */
+  across: z3.number().optional(),
+  /** Text; `{value}` is replaced by the formatted measurement. Undefined =
+   * the kind's default template ("{value}", "{value}°", "R{value}",
+   * "Ø{value}"). */
+  content: z3.string().optional(),
+  /** Character formatting over `content` (the TEMPLATE: a span covering
+   * `{value}` formats the measurement). Needs `content` set. */
+  spans: z3.array(TextSpanSchema).optional()
+});
+var DimensionShapeSchema = ObjectBaseSchema.extend({
+  type: z3.literal("dimension"),
   kind: DimensionKindSchema.default("linear"),
   /**
-   * Measured points. Linear dims with MORE than two points render as a
-   * CHAIN: one measurement per consecutive pair, sharing the dimension
-   * line (text placement is derived — see `offset`, not a text anchor).
+   * Measured points. linear: 2+ (more than two render as a CHAIN — one
+   * measurement per consecutive pair sharing the dimension line);
+   * angular: [vertex, a, b]; radial: [center, curve point]; diameter:
+   * [p1, p2] opposite on the curve.
+   */
+  points: z3.array(Vec2Schema).min(2),
+  /**
+   * linear only: the measuring direction, radians CCW from +X (DXF's
+   * "rotated" dimension, code 50). Undefined = aligned to
+   * points[0] → points[last] (DXF "aligned"), so dragging a point turns the
+   * dimension; set, the direction is locked and a point drag only changes
+   * the measurement.
    */
-  points: z2.array(Vec2Schema).min(1),
+  rotation: z3.number().optional(),
   /**
-   * Dimension line placement, anchored at the kind's base point (points[0];
-   * diameter: the points' midpoint): anchor + offset lies on the dimension
-   * line (angular: on the arc — its length is the arc radius; radial /
-   * diameter: at the text). The DIRECTION is set at creation and preserved
-   * afterwards — the offset grip only rescales the length.
+   * linear: signed distance of the dimension line from points[0] along the
+   * LEFT perpendicular of the measuring direction. angular: the arc radius,
+   * positive for the arc running CCW from a to b, negative for the
+   * complementary arc. radial/diameter: absent — the line's direction comes
+   * from the points and the text position is labels[0].along.
    */
-  offset: Vec2Schema,
-  textOverride: z2.string().optional(),
+  offset: z3.number().optional(),
+  /** One label per measured segment (linear chain: points.length − 1,
+   * every other kind: 1). Missing or short = automatic. */
+  labels: z3.array(DimLabelSchema).default([]),
   /** The document dimension style this dimension follows (absent/dangling =
    * the document's first style). */
-  styleId: z2.string().optional(),
+  styleId: z3.string().optional(),
   styleOverride: DimStyleOverrideSchema.optional(),
   /** Annotation size multiplier (text/arrows/offsets — same idea as
    * Text.scale; rides as DIMSCALE in DXF). */
-  scale: z2.number().positive().default(1)
+  scale: z3.number().positive().default(1)
 });
+var dimensionRefinement = (d, ctx) => {
+  const need = d.kind === "angular" ? 3 : 2;
+  if (d.points.length < need)
+    ctx.addIssue({
+      code: "custom",
+      path: ["points"],
+      message: `a ${d.kind} dimension needs at least ${need} points`
+    });
+  if (d.kind !== "linear" && d.kind !== "angular") {
+    if (d.offset !== void 0)
+      ctx.addIssue({
+        code: "custom",
+        path: ["offset"],
+        message: `offset does not apply to a ${d.kind} dimension (the text position is labels[0].along)`
+      });
+  } else if (d.offset === void 0)
+    ctx.addIssue({
+      code: "custom",
+      path: ["offset"],
+      message: `a ${d.kind} dimension needs offset`
+    });
+  if (d.kind !== "linear" && d.rotation !== void 0)
+    ctx.addIssue({
+      code: "custom",
+      path: ["rotation"],
+      message: "rotation applies to linear dimensions only"
+    });
+};
+var DimensionSchema = DimensionShapeSchema.superRefine(dimensionRefinement);
+var DIM_DEFAULT_CONTENT = {
+  linear: DIM_VALUE_TOKEN,
+  angular: `${DIM_VALUE_TOKEN}\xB0`,
+  radial: `R${DIM_VALUE_TOKEN}`,
+  diameter: `\xD8${DIM_VALUE_TOKEN}`
+};
 var BlockSchema = ObjectBaseSchema.extend({
-  type: z2.literal("block"),
-  definitionId: z2.string(),
+  type: z3.literal("block"),
+  definitionId: z3.string(),
   /** Applied LAST, about the pivot (the first point input). */
-  rotation: z2.number().default(0),
-  scale: z2.number().positive().default(1),
+  rotation: z3.number().default(0),
+  scale: z3.number().positive().default(1),
   /** Per-instance parameter values (merged over the definition defaults). */
-  params: z2.record(
-    z2.string(),
-    z2.union([
-      z2.number(),
-      z2.string(),
-      z2.boolean(),
+  params: z3.record(
+    z3.string(),
+    z3.union([
+      z3.number(),
+      z3.string(),
+      z3.boolean(),
       // numberList / stringList parameters.
-      z2.array(z2.number()),
-      z2.array(z2.string())
+      z3.array(z3.number()),
+      z3.array(z3.string())
     ])
   ).default({}),
   /**
@@ -456,63 +1318,73 @@ var BlockSchema = ObjectBaseSchema.extend({
    * Transforms map the points and the script recomputes, which is what
    * makes mirror correct for script-derived geometry.
    */
-  inputs: z2.array(z2.union([Vec2Schema, z2.string()])).default([])
+  inputs: z3.array(z3.union([Vec2Schema, z3.string()])).default([])
 });
 var CommentSchema = ObjectBaseSchema.extend({
-  type: z2.literal("comment"),
+  type: z3.literal("comment"),
   /** Tail tip of the bubble (world/sheet mm). */
   position: Vec2Schema,
-  text: z2.string().default(""),
-  tags: z2.array(z2.string()).default([])
+  text: z3.string().default(""),
+  tags: z3.array(z3.string()).default([])
 });
-var TableCellSchema = z2.object({
-  /** Plain text; "\n" = line break. Long lines wrap at the cell width. */
-  text: z2.string().default(""),
+var cellInput = (v) => {
+  if (typeof v === "string") return { content: v };
+  if (v && typeof v === "object" && "text" in v && !("content" in v)) {
+    const { text, ...rest } = v;
+    return { ...rest, content: text };
+  }
+  return v;
+};
+var TableCellSchema = z3.object({
+  /** Plain text; "\n" = line break. Long lines wrap at the cell width.
+   * (Named `text` before document v22 — still read, see `cellInput`.) */
+  content: z3.string().default(""),
+  /** Character formatting over `content` (core/table.ts `cellWithContent`
+   * keeps it consistent when the content changes). */
+  spans: z3.array(TextSpanSchema).optional(),
   /** Merge, set on the ANCHOR (top-left) cell. Covered cells stay in the
    * grid with their content ignored — AutoCAD's model. */
-  span: z2.object({
-    cols: z2.number().int().min(1),
-    rows: z2.number().int().min(1)
+  span: z3.object({
+    cols: z3.number().int().min(1),
+    rows: z3.number().int().min(1)
   }).optional(),
   /** Where the text sits in the cell; absent = left / center. */
-  hAlign: z2.enum(["left", "center", "right"]).optional(),
-  vAlign: z2.enum(["top", "center", "bottom"]).optional(),
-  styleId: z2.string().optional(),
+  hAlign: z3.enum(["left", "center", "right"]).optional(),
+  vAlign: z3.enum(["top", "center", "bottom"]).optional(),
+  styleId: z3.string().optional(),
   styleOverride: TextStyleOverrideSchema.optional(),
   /** Text color; absent = the table's. */
   color: ColorSchema.optional()
 });
-var TableSchema = ObjectBaseSchema.extend({
-  type: z2.literal("table"),
+var TableShapeSchema = ObjectBaseSchema.extend({
+  type: z3.literal("table"),
   position: Vec2Schema,
-  rotation: z2.number().default(0),
-  scale: z2.number().positive().default(1),
+  rotation: z3.number().default(0),
+  scale: z3.number().positive().default(1),
   /** Column widths (mm). */
-  columns: z2.array(z2.number().positive()).min(1),
+  columns: z3.array(z3.number().positive()).min(1),
   /** Per-row settings. Input may give a row COUNT (all auto-height). */
-  rows: z2.preprocess(
+  rows: z3.preprocess(
     (v) => typeof v === "number" ? Array.from({ length: v }, () => ({})) : v,
-    z2.array(z2.object({ minHeight: z2.number().positive().optional() })).min(1)
+    z3.array(z3.object({ minHeight: z3.number().positive().optional() })).min(1)
   ),
   /** Row-major: `cells[row][column]`, exactly rows × columns. Input may
    * give a cell as a plain string (= `{ text }`). */
-  cells: z2.array(
-    z2.array(
-      z2.preprocess(
-        (v) => typeof v === "string" ? { text: v } : v,
-        TableCellSchema
-      )
+  cells: z3.array(
+    z3.array(
+      z3.preprocess(cellInput, TableCellSchema)
     )
   ),
   /** Rows above the heavier header rule. */
-  headerRows: z2.number().int().min(0).default(0),
+  headerRows: z3.number().int().min(0).default(0),
   /** Text inset from the cell edges (mm). */
-  cellMargin: z2.number().min(0).default(1),
-  borders: z2.enum(["all", "outer", "rows", "none"]).default("all"),
+  cellMargin: z3.number().min(0).default(1),
+  borders: z3.enum(["all", "outer", "rows", "none"]).default("all"),
   /** Document text style for every cell (cells may override). */
-  styleId: z2.string().optional(),
+  styleId: z3.string().optional(),
   styleOverride: TextStyleOverrideSchema.optional()
-}).superRefine((t, ctx) => {
+});
+var tableRefinement = (t, ctx) => {
   const issue = (message) => ctx.addIssue({ code: "custom", message });
   const nr = t.rows.length;
   const nc = t.columns.length;
@@ -536,40 +1408,28 @@ var TableSchema = ObjectBaseSchema.extend({
         }
     })
   );
-});
+};
+var TableSchema = TableShapeSchema.superRefine(tableRefinement);
 var blockPivot = (b) => {
   for (const v of b.inputs) if (typeof v !== "string") return v;
   return { x: 0, y: 0 };
 };
 var ViewportSchema = ObjectBaseSchema.extend({
-  type: z2.literal("viewport"),
+  type: z3.literal("viewport"),
   /** Placement on the sheet, mm, origin bottom-left of sheet. */
-  rect: z2.object({
-    x: z2.number(),
-    y: z2.number(),
-    w: z2.number().positive(),
-    h: z2.number().positive()
+  rect: z3.object({
+    x: z3.number(),
+    y: z3.number(),
+    w: z3.number().positive(),
+    h: z3.number().positive()
   }),
   /** World point shown at the center of the rect. */
   modelCenter: Vec2Schema.default({ x: 0, y: 0 }),
   /** Drawing-scale denominator (model mm per paper mm); 1:50 => 50. */
-  scale: z2.number().positive().default(1),
+  scale: z3.number().positive().default(1),
   /** Pinned: no pan/zoom-through, no move/resize grips. */
-  locked: z2.boolean().default(false),
-  hiddenLayerIds: z2.array(z2.string()).default([])
-});
-var ImageSchema = ObjectBaseSchema.extend({
-  type: z2.literal("image"),
-  /** Key into `document.assets`. */
-  assetId: z2.string(),
-  /** Bottom-left corner (world/sheet mm) — rotation pivots here. */
-  origin: Vec2Schema,
-  width: z2.number().positive(),
-  height: z2.number().positive(),
-  /** Radians CCW about `origin`. */
-  rotation: z2.number().default(0)
-  // (opacity moved to ObjectBaseSchema — every object paints with it now;
-  // documents that stored it per-image parse unchanged.)
+  locked: z3.boolean().default(false),
+  hiddenLayerIds: z3.array(z3.string()).default([])
 });
 var REFERENCE_FORMATS = [
   "linea",
@@ -579,54 +1439,55 @@ var REFERENCE_FORMATS = [
   "png",
   "jpg"
 ];
-var ReferenceSourceSchema = z2.discriminatedUnion("kind", [
-  z2.object({
-    kind: z2.literal("path"),
-    path: z2.string().min(1),
-    cacheKey: z2.string().min(1).optional()
+var ReferenceSourceSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("path"),
+    path: z3.string().min(1),
+    cacheKey: z3.string().min(1).optional()
   }),
-  z2.object({ kind: z2.literal("url"), url: z2.string().url() })
+  z3.object({ kind: z3.literal("url"), url: z3.string().url() }),
+  z3.object({ kind: z3.literal("asset"), assetId: z3.string().min(1) })
 ]);
 var ReferenceSchema = ObjectBaseSchema.extend({
-  type: z2.literal("reference"),
-  format: z2.enum(REFERENCE_FORMATS),
-  name: z2.string().min(1),
+  type: z3.literal("reference"),
+  format: z3.enum(REFERENCE_FORMATS),
+  name: z3.string().min(1),
   source: ReferenceSourceSchema,
   position: Vec2Schema,
   /** Radians CCW about `position`. */
-  rotation: z2.number().default(0),
-  scale: z2.number().positive().default(1),
-  mirrored: z2.boolean().optional(),
+  rotation: z3.number().default(0),
+  scale: z3.number().positive().default(1),
+  mirrored: z3.boolean().optional(),
   /** PDF: the 1-based page drawn, and how (vector lines + text / raster). */
-  pdfPage: z2.number().int().positive().optional(),
-  pdfMode: z2.enum(["vector", "raster"]).optional(),
+  pdfPage: z3.number().int().positive().optional(),
+  pdfMode: z3.enum(["vector", "raster"]).optional(),
   /** The FILE's layers not drawn, by name (stable across reloads). */
-  hiddenLayers: z2.array(z2.string()).default([]),
+  hiddenLayers: z3.array(z3.string()).default([]),
   /** Switched off in the References panel: not drawn, picked or snapped. */
-  hidden: z2.boolean().optional(),
+  hidden: z3.boolean().optional(),
   /** Locked in the References panel: drawn and snapped, but never hovered
    * or picked on the canvas — select it from the panel instead. */
-  locked: z2.boolean().optional(),
+  locked: z3.boolean().optional(),
   /** Crop rectangle in FILE coordinates: only content inside is drawn and
    * snapped (AutoCAD's XCLIP, rectangular). */
-  clip: z2.object({
-    minX: z2.number(),
-    minY: z2.number(),
-    maxX: z2.number(),
-    maxY: z2.number()
+  clip: z3.object({
+    minX: z3.number(),
+    minY: z3.number(),
+    maxX: z3.number(),
+    maxY: z3.number()
   }).optional(),
   /**
    * The content's bounds in file coordinates, recorded on each successful
    * load: a missing file still has a frame to draw, pick and snap to.
    */
-  extent: z2.object({
-    minX: z2.number(),
-    minY: z2.number(),
-    maxX: z2.number(),
-    maxY: z2.number()
+  extent: z3.object({
+    minX: z3.number(),
+    minY: z3.number(),
+    maxX: z3.number(),
+    maxY: z3.number()
   }).optional()
 });
-var ModelObjectSchema = z2.discriminatedUnion("type", [
+var ModelObjectSchema = z3.discriminatedUnion("type", [
   PointSchema,
   LineSchema,
   PolylineSchema,
@@ -637,13 +1498,15 @@ var ModelObjectSchema = z2.discriminatedUnion("type", [
   TextSchema,
   DimensionSchema,
   BlockSchema,
-  ImageSchema,
   ViewportSchema,
   CommentSchema,
   TableSchema,
   ReferenceSchema
 ]);
 
+// ../core/src/model/lineTypes.ts
+import { z as z4 } from "zod";
+
 // ../core/src/model/builtinLin.ts
 var BUILTIN_LIN = `;;  Linea built-in line type library.
 ;;
@@ -799,7 +1662,7 @@ var CURATED = [
     dxfName: "DIVIDE"
   }
 ];
-var normalizeName = (name) => name.trim().toUpperCase().replace(/[\s.-]+/g, "_");
+var normalizeName2 = (name) => name.trim().toUpperCase().replace(/[\s.-]+/g, "_");
 var asciiPreview = (dashesMm) => {
   const WIDTH = 15;
   if (!dashesMm.length) return "_".repeat(WIDTH * 0.8);
@@ -820,9 +1683,9 @@ var withPreview = (p) => {
   return { ...p, label: `${p.label}  ${asciiPreview(p.dashesMm)}` };
 };
 var BUILT_IN = CURATED.map(withPreview);
-var BY_NAME = new Map(BUILT_IN.map((p) => [normalizeName(p.name), p]));
+var BY_NAME = new Map(BUILT_IN.map((p) => [normalizeName2(p.name), p]));
 for (const p of parseLinDefinitions(BUILTIN_LIN)) {
-  const key = normalizeName(p.name);
+  const key = normalizeName2(p.name);
   if (BY_NAME.has(key)) continue;
   const pattern2 = withPreview({
     name: p.name,
@@ -840,15 +1703,40 @@ var scaleVariantBase = (name) => {
 };
 for (const p of BUILT_IN) {
   const base = scaleVariantBase(p.name);
-  const target = base ? BY_NAME.get(normalizeName(base)) : void 0;
+  const target = base ? BY_NAME.get(normalizeName2(base)) : void 0;
   if (target && target !== p) p.hidden = true;
 }
 var LINE_TYPE_NAMES = BUILT_IN.filter((p) => !p.hidden).map(
   (p) => p.name
 );
 var LINE_TYPE_DEFS = BUILT_IN;
-var getLineType = (name) => BY_NAME.get(normalizeName(name));
+var getLineType = (name) => BY_NAME.get(normalizeName2(name));
 var renderDashes = (pattern2) => pattern2.dashesMm.length ? pattern2.dashesMm.map((v) => v === 0 ? 0.1 : Math.abs(v)) : void 0;
+var LineTypeSchema = z4.object({
+  /** Stored on objects/layers as `lineType`; case-insensitive, unique per
+   * document. */
+  name: z4.string().min(1),
+  description: z4.string().optional(),
+  /** Signed dash cycle, mm per 1 mm of line width: >0 dash, <0 gap, 0 dot.
+   * Empty = continuous. */
+  dashesMm: z4.array(z4.number())
+});
+var lineTypeKey = (name) => normalizeName2(name);
+var lineTypeAsPattern = (t) => ({
+  name: t.name,
+  label: t.description ?? t.name,
+  dashesMm: t.dashesMm,
+  dxfName: t.name.toUpperCase()
+});
+var resolveLineType = (name, lineTypes) => {
+  if (!name) return void 0;
+  if (lineTypes && lineTypes.length > 0) {
+    const key = normalizeName2(name);
+    const own = lineTypes.find((t) => normalizeName2(t.name) === key);
+    if (own) return lineTypeAsPattern(own);
+  }
+  return getLineType(name);
+};
 
 // ../core/src/geometry/vec2.ts
 var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
@@ -939,105 +1827,105 @@ var readListParam = (type, value) => {
 };
 
 // ../core/src/model/blockDefinition.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var paramBase = {
-  name: z3.string().regex(/^[a-zA-Z_]\w*$/),
-  label: z3.string().optional(),
+  name: z5.string().regex(/^[a-zA-Z_]\w*$/),
+  label: z5.string().optional(),
   /** What the parameter means: the label's tooltip in the panel. */
-  hint: z3.string().optional()
+  hint: z5.string().optional()
 };
 var HEX_COLOR = /^#[0-9a-f]{6}$/i;
-var EnumOptionSchema = z3.preprocess(
+var EnumOptionSchema = z5.preprocess(
   (raw) => typeof raw === "string" ? { value: raw } : raw,
-  z3.object({
-    value: z3.string(),
-    label: z3.string().optional(),
+  z5.object({
+    value: z5.string(),
+    label: z5.string().optional(),
     /** A `#rrggbb` color square before the option's label. */
-    swatch: z3.string().regex(HEX_COLOR).optional()
+    swatch: z5.string().regex(HEX_COLOR).optional()
   })
 );
-var NumberParam = z3.object({
+var NumberParam = z5.object({
   ...paramBase,
-  type: z3.literal("number"),
-  default: z3.number(),
-  min: z3.number().optional(),
-  max: z3.number().optional(),
+  type: z5.literal("number"),
+  default: z5.number(),
+  min: z5.number().optional(),
+  max: z5.number().optional(),
   /** Whole numbers only. */
-  integer: z3.boolean().optional(),
+  integer: z5.boolean().optional(),
   /** ArrowUp / ArrowDown increment in the panel (default 1). */
-  step: z3.number().positive().optional(),
+  step: z5.number().positive().optional(),
   /** Shown inside the field before / after the value ("1:", "mm"). */
-  prefix: z3.string().optional(),
-  suffix: z3.string().optional(),
+  prefix: z5.string().optional(),
+  suffix: z5.string().optional(),
   /** Standard values offered in the field's dropdown; typing stays free. */
-  presets: z3.array(z3.number()).optional()
+  presets: z5.array(z5.number()).optional()
 });
-var StringParam = z3.object({
+var StringParam = z5.object({
   ...paramBase,
-  type: z3.literal("string"),
-  default: z3.string(),
-  placeholder: z3.string().optional(),
+  type: z5.literal("string"),
+  default: z5.string(),
+  placeholder: z5.string().optional(),
   /** A textarea; Shift+Enter starts a new line. */
-  multiline: z3.boolean().optional(),
-  presets: z3.array(z3.string()).optional()
+  multiline: z5.boolean().optional(),
+  presets: z5.array(z5.string()).optional()
 });
-var BooleanParam = z3.object({
+var BooleanParam = z5.object({
   ...paramBase,
-  type: z3.literal("boolean"),
-  default: z3.boolean(),
+  type: z5.literal("boolean"),
+  default: z5.boolean(),
   /** "toggle": a toggle button showing the label (compact, e.g. in a row
    * beside a picker) instead of a switch. */
-  display: z3.enum(["switch", "toggle"]).optional()
+  display: z5.enum(["switch", "toggle"]).optional()
 });
-var NumberListParam = z3.object({
+var NumberListParam = z5.object({
   ...paramBase,
-  type: z3.literal("numberList"),
-  default: z3.array(z3.number()),
+  type: z5.literal("numberList"),
+  default: z5.array(z5.number()),
   /** Shown while the list is empty. */
-  placeholder: z3.string().optional(),
-  min: z3.number().optional(),
-  max: z3.number().optional(),
-  presets: z3.array(z3.array(z3.number())).optional()
+  placeholder: z5.string().optional(),
+  min: z5.number().optional(),
+  max: z5.number().optional(),
+  presets: z5.array(z5.array(z5.number())).optional()
 });
-var StringListParam = z3.object({
+var StringListParam = z5.object({
   ...paramBase,
-  type: z3.literal("stringList"),
-  default: z3.array(z3.string()),
+  type: z5.literal("stringList"),
+  default: z5.array(z5.string()),
   /** Shown while the list is empty. */
-  placeholder: z3.string().optional(),
-  presets: z3.array(z3.array(z3.string())).optional()
+  placeholder: z5.string().optional(),
+  presets: z5.array(z5.array(z5.string())).optional()
 });
-var ColorParam = z3.object({
+var ColorParam = z5.object({
   ...paramBase,
-  type: z3.literal("color"),
-  default: z3.string().regex(HEX_COLOR),
-  presets: z3.array(z3.string().regex(HEX_COLOR)).optional()
+  type: z5.literal("color"),
+  default: z5.string().regex(HEX_COLOR),
+  presets: z5.array(z5.string().regex(HEX_COLOR)).optional()
 });
-var EnumParam = z3.object({
+var EnumParam = z5.object({
   ...paramBase,
-  type: z3.literal("enum"),
-  default: z3.string(),
-  options: z3.array(EnumOptionSchema).min(1),
+  type: z5.literal("enum"),
+  default: z5.string(),
+  options: z5.array(EnumOptionSchema).min(1),
   /** "buttons": a segmented toggle group of the options (short choices);
    * the panel falls back to the dropdown when they don't fit. */
-  display: z3.enum(["dropdown", "buttons"]).optional()
+  display: z5.enum(["dropdown", "buttons"]).optional()
 });
-var resourceParam = (type, fallback) => z3.object({
+var resourceParam = (type, fallback) => z5.object({
   ...paramBase,
-  type: z3.literal(type),
-  default: z3.string().default(fallback)
+  type: z5.literal(type),
+  default: z5.string().default(fallback)
 });
 var TextStyleParam = resourceParam("textStyle", "");
 var DimStyleParam = resourceParam("dimStyle", "");
 var FontParam = resourceParam("font", "arial");
 var LineTypeParam = resourceParam("lineType", "continuous");
 var HatchPatternParam = resourceParam("hatchPattern", "ANSI31");
-var LabelParam = z3.object({ ...paramBase, type: z3.literal("label") });
+var LabelParam = z5.object({ ...paramBase, type: z5.literal("label") });
 var enumDefaultIsAnOption = (p) => p.type !== "enum" || p.options.some(
   (o) => o.value === p.default
 );
 var ENUM_DEFAULT = { message: "enum default must be one of its options" };
-var RowItemSchema = z3.discriminatedUnion("type", [
+var RowItemSchema = z5.discriminatedUnion("type", [
   NumberParam,
   StringParam,
   BooleanParam,
@@ -1049,12 +1937,12 @@ var RowItemSchema = z3.discriminatedUnion("type", [
   LineTypeParam,
   HatchPatternParam
 ]).refine(enumDefaultIsAnOption, ENUM_DEFAULT);
-var RowParam = z3.object({
+var RowParam = z5.object({
   ...paramBase,
-  type: z3.literal("row"),
-  items: z3.array(RowItemSchema).min(2).max(3)
+  type: z5.literal("row"),
+  items: z5.array(RowItemSchema).min(2).max(3)
 });
-var BlockParamSchema = z3.discriminatedUnion("type", [
+var ParamDefSchema = z5.discriminatedUnion("type", [
   NumberParam,
   StringParam,
   BooleanParam,
@@ -1075,7 +1963,7 @@ var valueParams = (defs) => defs.flatMap(
 );
 
 // ../core/src/extensions/evalBlock.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // ../core/src/geometry/line.ts
 var projectParam = (p, a, b) => {
@@ -1108,16 +1996,6 @@ var remapBlockInputRefs = (obj, idMap) => {
 };
 var mapInputPoints = (obj, fn) => obj.inputs.map((value) => typeof value === "string" ? value : fn(value));
 var pointsCarryPose = (obj) => obj.inputs.some((v) => typeof v === "string") || obj.inputs.filter((v) => typeof v !== "string").length >= 2;
-var imageCenter = (obj) => add(obj.origin, rot({ x: obj.width / 2, y: obj.height / 2 }, obj.rotation));
-var imageCorners = (obj) => {
-  const c = (x, y) => add(obj.origin, rot({ x, y }, obj.rotation));
-  return [
-    obj.origin,
-    c(obj.width, 0),
-    c(obj.width, obj.height),
-    c(0, obj.height)
-  ];
-};
 var mapObjectPoints = (obj, fn) => {
   switch (obj.type) {
     case "line":
@@ -1133,6 +2011,10 @@ var mapObjectPoints = (obj, fn) => {
     case "hatch":
       return {
         ...obj,
+        // The pattern frame moves with its region, as in AutoCAD — an
+        // unanchored fill's frame is the drawing origin, which moves along
+        // too (else the pattern would swim inside a moved hatch).
+        fill: obj.fill.kind === "pattern" ? { ...obj.fill, origin: fn(obj.fill.origin ?? { x: 0, y: 0 }) } : obj.fill,
         loops: obj.loops.map((loop) => ({
           points: loop.points.map((v) => ({ ...v, ...fn(v) }))
         }))
@@ -1149,8 +2031,6 @@ var mapObjectPoints = (obj, fn) => {
       return { ...obj, inputs: mapInputPoints(obj, fn) };
     case "viewport":
       return obj;
-    case "image":
-      return { ...obj, origin: fn(obj.origin) };
     case "comment":
       return { ...obj, position: fn(obj.position) };
     case "table":
@@ -1178,6 +2058,7 @@ var moveViewportCenter = (obj, map) => {
   const nc = map(c);
   return translateObject(obj, sub(nc, c));
 };
+var turnFill = (fill, f) => fill.kind === "pattern" || fill.kind === "lines" ? { ...fill, angle: f(fill.angle) } : fill;
 var rotateObject = (obj, center, ang) => {
   const r = (p) => rotAround(p, center, ang);
   const mapped = mapObjectPoints(obj, r);
@@ -1194,19 +2075,19 @@ var rotateObject = (obj, center, ang) => {
     case "table":
       return { ...mapped, rotation: mapped.rotation + ang };
     case "dimension":
-      return { ...mapped, offset: rot(mapped.offset, ang) };
+      return mapped.rotation === void 0 ? mapped : { ...mapped, rotation: mapped.rotation + ang };
     case "block":
       return pointsCarryPose(mapped) ? mapped : { ...mapped, rotation: mapped.rotation + ang };
     case "viewport":
       return moveViewportCenter(mapped, r);
-    case "image":
     case "reference":
       return { ...mapped, rotation: normAngle(mapped.rotation + ang) };
+    case "hatch":
+      return { ...mapped, fill: turnFill(mapped.fill, (a) => a + ang) };
     case "line":
     case "point":
     case "polyline":
     case "circle":
-    case "hatch":
     case "comment":
       return mapped;
     default:
@@ -1231,7 +2112,16 @@ var scaleObjectUniform = (obj, s) => {
     case "table":
       return { ...mapped, scale: mapped.scale * s };
     case "dimension":
-      return { ...mapped, offset: m(mapped.offset), scale: mapped.scale * s };
+      return {
+        ...mapped,
+        ...mapped.offset === void 0 ? {} : { offset: mapped.offset * s },
+        labels: mapped.labels.map((l) => ({
+          ...l,
+          ...l.along === void 0 ? {} : { along: l.along * s },
+          ...l.across === void 0 ? {} : { across: l.across * s }
+        })),
+        scale: mapped.scale * s
+      };
     case "block":
       return pointsCarryPose(mapped) ? mapped : { ...mapped, scale: mapped.scale * s };
     case "viewport":
@@ -1247,8 +2137,6 @@ var scaleObjectUniform = (obj, s) => {
         // mm per paper mm) shrinks as the frame grows.
         scale: mapped.scale / s
       };
-    case "image":
-      return { ...mapped, width: mapped.width * s, height: mapped.height * s };
     case "reference":
       return { ...mapped, scale: mapped.scale * s };
     case "point":
@@ -1284,12 +2172,6 @@ var mirrorObject = (obj, a, b) => {
       mirrored: !obj.mirrored
     };
   }
-  if (obj.type === "image") {
-    const c = imageCenter(obj);
-    const rotation = mirrorAngle(obj.rotation);
-    const moved = { ...obj, rotation };
-    return translateObject(moved, sub(m(c), imageCenter(moved)));
-  }
   if (obj.type === "table") {
     const width = obj.columns.reduce((a2, w) => a2 + w, 0) * obj.scale;
     const topRight = add(obj.position, scale(fromAngle(obj.rotation), width));
@@ -1317,6 +2199,7 @@ var mirrorObject = (obj, a, b) => {
     case "hatch":
       return {
         ...mapped,
+        fill: turnFill(mapped.fill, mirrorAngle),
         loops: mapped.loops.map((loop) => ({
           points: loop.points.map((v) => ({ ...v, bulge: -v.bulge }))
         }))
@@ -1331,8 +2214,17 @@ var mirrorObject = (obj, a, b) => {
         hAlign: readable ? mapped.hAlign : swap[mapped.hAlign]
       };
     }
-    case "dimension":
-      return { ...mapped, offset: sub(m(add(a, mapped.offset)), a) };
+    case "dimension": {
+      const handed = mapped.kind === "radial" || mapped.kind === "diameter";
+      return {
+        ...mapped,
+        ...mapped.rotation === void 0 ? {} : { rotation: mirrorAngle(mapped.rotation) },
+        ...mapped.offset === void 0 ? {} : { offset: -mapped.offset },
+        labels: handed ? mapped.labels.map(
+          (l) => l.across === void 0 ? l : { ...l, across: -l.across }
+        ) : mapped.labels
+      };
+    }
     case "block":
       return pointsCarryPose(mapped) ? mapped : { ...mapped, rotation: mirrorAngle(mapped.rotation) };
     case "viewport":
@@ -1345,7 +2237,6 @@ var mirrorObject = (obj, a, b) => {
     // Mirrored above, before the point map.
     case "ellipse":
     case "reference":
-    case "image":
     case "table":
       return mapped;
     default:
@@ -1354,7 +2245,7 @@ var mirrorObject = (obj, a, b) => {
 };
 
 // ../core/src/extensions/blockDtos.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // ../core/src/extensions/jsLiteral.ts
 var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
@@ -1385,8 +2276,51 @@ ${indent}}`;
   return "undefined";
 };
 
+// ../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)}`;
+};
+var dataUrlMime = (dataUrl) => /^data:([^;,]*)/.exec(dataUrl)?.[1] ?? "";
+var dataUrlBytes = (dataUrl) => {
+  const comma = dataUrl.indexOf(",");
+  const payload = dataUrl.slice(comma + 1);
+  if (!/;base64$/.test(dataUrl.slice(0, comma)))
+    return new TextEncoder().encode(decodeURIComponent(payload));
+  const bin = atob(payload);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+};
+var bytesToDataUrl = (bytes, mime) => {
+  let bin = "";
+  for (let i = 0; i < bytes.length; i += 32768)
+    bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return `data:${mime};base64,${btoa(bin)}`;
+};
+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 len3 = 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 + len3;
+  }
+  return null;
+};
+var PX_TO_MM = 25.4 / 96;
+var embeddedAssetId = (o) => o.type === "reference" && o.source?.kind === "asset" ? o.source.assetId : void 0;
+
 // ../core/src/model/migrations.ts
-var CURRENT_DOCUMENT_VERSION = 20;
+var CURRENT_DOCUMENT_VERSION = 23;
 var leaderRawToText = (raw) => {
   const points = Array.isArray(raw.points) ? raw.points : [];
   const extraLines = Array.isArray(raw.extraLines) ? raw.extraLines : [];
@@ -1888,6 +2822,134 @@ var migrateV18toV19 = (doc) => {
   };
 };
 var migrateV19toV20 = (doc) => ({ ...swapTextAlignments(doc), version: 20 });
+var dimensionPointCount = (kind) => kind === "angular" ? 3 : 2;
+var wrapAngle = (a) => {
+  const twoPi = 2 * Math.PI;
+  const r = a % twoPi;
+  return r < 0 ? r + twoPi : r;
+};
+var dimensionRawToLabels = (raw) => {
+  if (raw.type !== "dimension") return raw;
+  const legacyOffset = Array.isArray(raw.offset) ? { x: Number(raw.offset[0]), y: Number(raw.offset[1]) } : raw.offset !== null && typeof raw.offset === "object" ? raw.offset : null;
+  if (legacyOffset === null && !("textOverride" in raw)) return raw;
+  const kind = typeof raw.kind === "string" ? raw.kind : "linear";
+  const points = Array.isArray(raw.points) ? raw.points : [];
+  const tooFew = points.length < dimensionPointCount(kind);
+  const out = { ...raw };
+  delete out.textOverride;
+  const labels = Array.isArray(raw.labels) ? raw.labels.map((l) => ({ ...l })) : [];
+  const label = (i) => labels[i] ??= {};
+  if (legacyOffset) {
+    const v = legacyOffset;
+    const vLen = Math.hypot(v.x, v.y);
+    if (kind === "linear") {
+      delete out.rotation;
+      if (vLen < 1e-9 || tooFew) out.offset = 0;
+      else {
+        let ux = -v.y / vLen;
+        let uy = v.x / vLen;
+        if (ux < 0 || ux === 0 && uy < 0) {
+          ux = -ux;
+          uy = -uy;
+        }
+        out.rotation = Math.atan2(uy, ux);
+        out.offset = v.x * -uy + v.y * ux;
+      }
+    } else if (kind === "angular") {
+      if (tooFew) out.offset = vLen;
+      else {
+        const [vertex, a, b] = points;
+        const angA = Math.atan2(a.y - vertex.y, a.x - vertex.x);
+        const angB = Math.atan2(b.y - vertex.y, b.x - vertex.x);
+        const angL = Math.atan2(v.y, v.x);
+        const inAB = wrapAngle(angL - angA) <= wrapAngle(angB - angA);
+        out.offset = inAB ? vLen : -vLen;
+      }
+    } else {
+      delete out.offset;
+      const [p0, p1] = points;
+      const d = tooFew ? 0 : Math.hypot(p1.x - p0.x, p1.y - p0.y);
+      if (d > 1e-9) {
+        const ux = (p1.x - p0.x) / d;
+        const uy = (p1.y - p0.y) / d;
+        label(0).along = v.x * ux + v.y * uy;
+      }
+    }
+  }
+  if (typeof raw.textOverride === "string") {
+    const template = {
+      linear: "{value}",
+      angular: "{value}\xB0",
+      radial: "R{value}",
+      diameter: "\xD8{value}"
+    };
+    const content = raw.textOverride.replaceAll(
+      "<>",
+      template[kind] ?? "{value}"
+    );
+    const segments = kind === "linear" ? Math.max(1, points.length - 1) : 1;
+    for (let i = 0; i < segments; i++) label(i).content = content;
+  }
+  if (labels.length > 0) out.labels = labels;
+  return out;
+};
+var migrateV20toV21 = (doc) => {
+  const degenerate = (raw) => raw.type === "dimension" && (Array.isArray(raw.points) ? raw.points.length : 0) < dimensionPointCount(typeof raw.kind === "string" ? raw.kind : "linear");
+  const mapObjects = (list) => Array.isArray(list) ? list.filter(
+    (raw) => raw === null || typeof raw !== "object" || !degenerate(raw)
+  ).map(
+    (raw) => raw !== null && typeof raw === "object" ? dimensionRawToLabels(raw) : raw
+  ) : list;
+  const layouts = Array.isArray(doc.layouts) ? doc.layouts.map((raw) => {
+    if (raw === null || typeof raw !== "object") return raw;
+    const layout = raw;
+    return { ...layout, objects: mapObjects(layout.objects) };
+  }) : doc.layouts;
+  return { ...doc, objects: mapObjects(doc.objects), layouts, version: 21 };
+};
+var migrateV21toV22 = (doc) => ({ ...doc, version: 22 });
+var imageRawToReference = (raw, assets) => {
+  const rest = { ...raw };
+  delete rest.assetId;
+  delete rest.origin;
+  delete rest.width;
+  delete rest.height;
+  const assetId = typeof raw.assetId === "string" ? raw.assetId : "";
+  const data = assets[assetId];
+  const width = typeof raw.width === "number" && raw.width > 0 ? raw.width : 1;
+  const height = typeof raw.height === "number" && raw.height > 0 ? raw.height : 1;
+  let px;
+  try {
+    px = typeof data === "string" ? imagePixelSize(dataUrlBytes(data)) : null;
+  } catch {
+    px = null;
+  }
+  const w = px ? px.width * PX_TO_MM : width;
+  const h = px ? px.height * PX_TO_MM : height;
+  return {
+    ...rest,
+    type: "reference",
+    format: typeof data === "string" && dataUrlMime(data) === "image/jpeg" ? "jpg" : "png",
+    name: "Image",
+    source: { kind: "asset", assetId: assetId || "missing" },
+    position: raw.origin ?? { x: 0, y: 0 },
+    rotation: typeof raw.rotation === "number" ? raw.rotation : 0,
+    scale: width / w,
+    extent: { minX: 0, minY: 0, maxX: w, maxY: h }
+  };
+};
+var migrateV22toV23 = (doc) => {
+  const assets = doc.assets !== null && typeof doc.assets === "object" ? doc.assets : {};
+  const mapObjects = (list) => Array.isArray(list) ? list.map(
+    (raw) => raw !== null && typeof raw === "object" && raw.type === "image" ? imageRawToReference(raw, assets) : raw
+  ) : list;
+  const layouts = Array.isArray(doc.layouts) ? doc.layouts.map((raw) => {
+    if (raw === null || typeof raw !== "object") return raw;
+    const layout = raw;
+    return { ...layout, objects: mapObjects(layout.objects) };
+  }) : doc.layouts;
+  return { ...doc, objects: mapObjects(doc.objects), layouts, version: 23 };
+};
 var MIGRATION_STEPS = [
   migrateV1toV2,
   migrateV2toV3,
@@ -1907,7 +2969,10 @@ var MIGRATION_STEPS = [
   migrateV16toV17,
   migrateV17toV18,
   migrateV18toV19,
-  migrateV19toV20
+  migrateV19toV20,
+  migrateV20toV21,
+  migrateV21toV22,
+  migrateV22toV23
 ];
 function migrateDocument(raw) {
   if (raw === null || typeof raw !== "object") return raw;
@@ -1926,7 +2991,11 @@ function migrateDocument(raw) {
 
 // ../core/src/extensions/blockDtos.ts
 var CHILD_OMIT = { id: true, layerId: true };
-var BlockChildSchema = z4.preprocess(
+var CHILD_LAYER = {
+  layerId: z6.string().optional(),
+  layer: z6.string().optional()
+};
+var BlockChildSchema = z6.preprocess(
   // Back-compat: scripts written before document v6 may still emit "leader"
   // children (→ text with leaderLines), pre-v9 scripts may emit dimensions
   // in the linePoint/rotation shape (→ offset), pre-v17 scripts may put
@@ -1939,27 +3008,30 @@ var BlockChildSchema = z4.preprocess(
     let obj = raw;
     if (obj.type === "leader") obj = leaderRawToText(obj);
     if (obj.type === "dimension")
-      return dimRawScaleToField(dimensionRawToOffset(obj));
+      return dimensionRawToLabels(
+        dimRawScaleToField(dimensionRawToOffset(obj))
+      );
     if (obj.type === "text") return textRawStyleToOverride(obj);
     return obj;
   },
-  z4.discriminatedUnion("type", [
-    LineSchema.omit(CHILD_OMIT),
-    PointSchema.omit(CHILD_OMIT),
-    PolylineSchema.omit(CHILD_OMIT),
-    CircleSchema.omit(CHILD_OMIT),
-    ArcSchema.omit(CHILD_OMIT),
-    EllipseSchema.omit(CHILD_OMIT),
-    HatchSchema.omit(CHILD_OMIT),
-    TextSchema.omit(CHILD_OMIT),
-    DimensionSchema.omit(CHILD_OMIT),
-    BlockSchema.omit(CHILD_OMIT).refine(
-      (b) => b.inputs.every((v) => typeof v !== "string"),
-      { message: "nested block instances may not carry object references" }
-    )
+  z6.discriminatedUnion("type", [
+    LineSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    PointSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    PolylineSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    CircleSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    ArcSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    EllipseSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    HatchSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    TextSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    TableShapeSchema.omit(CHILD_OMIT).extend(CHILD_LAYER).superRefine(tableRefinement),
+    DimensionShapeSchema.omit(CHILD_OMIT).extend(CHILD_LAYER).superRefine(dimensionRefinement),
+    ReferenceSchema.omit(CHILD_OMIT).extend(CHILD_LAYER),
+    BlockSchema.omit(CHILD_OMIT).extend(CHILD_LAYER).refine((b) => b.inputs.every((v) => typeof v !== "string"), {
+      message: "nested block instances may not carry object references"
+    })
   ])
 );
-var BlockScriptResultSchema = z4.array(BlockChildSchema);
+var BlockScriptResultSchema = z6.array(BlockChildSchema);
 
 // ../core/src/extensions/scriptHelpers.ts
 var scriptHelpers_exports = {};
@@ -1967,7 +3039,6 @@ __export(scriptHelpers_exports, {
   add: () => add2,
   dist: () => dist2,
   dot: () => dot2,
-  helpers: () => helpers,
   len: () => len2,
   norm: () => norm2,
   polar: () => polar,
@@ -2011,22 +3082,9 @@ var rotate = (p, angle2) => {
   const sin = Math.sin(angle2);
   return { x: p.x * cos - p.y * sin, y: p.x * sin + p.y * cos };
 };
-var helpers = Object.freeze({
-  range,
-  polar,
-  toDeg,
-  toRad,
-  len: len2,
-  dist: dist2,
-  add: add2,
-  sub: sub2,
-  scale: scale2,
-  norm: norm2,
-  dot: dot2,
-  rotate
-});
 
 // ../core/src/extensions/scriptRuntime.ts
+var helpers = Object.freeze({ ...scriptHelpers_exports });
 var onTranspilerReady = null;
 var transpiler = null;
 var transpilerLoading = null;
@@ -2146,13 +3204,13 @@ var toBlockModule = (mod) => {
     );
   return { ...mod, draw, place };
 };
-var ParamsExportSchema = z5.array(BlockParamSchema);
-var OptionalBlockMetaSchema = z5.object({
-  description: z5.string().optional(),
-  version: z5.string().optional(),
-  authors: z5.array(z5.string()).optional(),
-  tags: z5.array(z5.string()).optional(),
-  dependencies: z5.array(z5.string()).optional()
+var ParamsExportSchema = z7.array(ParamDefSchema);
+var OptionalBlockMetaSchema = z7.object({
+  description: z7.string().optional(),
+  version: z7.string().optional(),
+  authors: z7.array(z7.string()).optional(),
+  tags: z7.array(z7.string()).optional(),
+  dependencies: z7.array(z7.string()).optional()
 });
 var parseParamsExport = (paramsExport) => {
   if (typeof paramsExport === "function") {
@@ -2288,7 +3346,7 @@ var stylesSig = (s) => {
   };
   return `${sig(s.textStyles)}.${sig(s.dimStyles)}`;
 };
-var ParamVisibilityResultSchema = z5.record(z5.string(), z5.boolean());
+var ParamVisibilityResultSchema = z7.record(z7.string(), z7.boolean());
 var paramsKey = (params) => JSON.stringify(Object.entries(params).sort(([a], [b]) => a.localeCompare(b)));
 var r6 = (v) => Math.round(v * 1e6) / 1e6;
 var sigOf = (v) => typeof v === "string" ? `#${v}` : `${r6(v.x)},${r6(v.y)}`;
@@ -2314,7 +3372,7 @@ var resolveInputs = (inputs, pivot, resolve) => {
     return obj ? translateObject(obj, neg) : null;
   });
 };
-var BlockInputsSchema = z5.array(z5.union([Vec2Schema, z5.string()]));
+var BlockInputsSchema = z7.array(z7.union([Vec2Schema, z7.string()]));
 var acquireBlockInputs = async (script, pickers) => {
   const { mod, meta } = compileBlock(script);
   if (!mod.place) return [await pickers.pickPoint("Insertion point")];
@@ -2410,15 +3468,17 @@ var testBlockDefinition = async (script) => {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
 };
-var childToObject = (child, instance, index) => {
+var childToObject = (child, instance, index, layers) => {
+  const { layer, ...rest } = child;
+  const named = layer === void 0 ? void 0 : (layers?.find((l) => l.id === layer) ?? layers?.find((l) => l.name === layer))?.id;
   return {
     color: instance.color,
     lineType: instance.lineType,
     lineTypeScale: instance.lineTypeScale,
     lineWidth: instance.lineWidth,
-    ...child,
+    ...rest,
     id: `${instance.id}:${index}`,
-    layerId: instance.layerId
+    layerId: named ?? child.layerId ?? instance.layerId
   };
 };
 var evaluating = /* @__PURE__ */ new Set();
@@ -2486,7 +3546,7 @@ var getEvaluatedWorldChildren = (instance, scripts, resolveObject, styles = DEFA
     evalErrors.delete(instance.id);
     const pivot = blockPivot(instance);
     return children.map((child, i) => {
-      let obj = childToObject(child, instance, i);
+      let obj = childToObject(child, instance, i, styles.layers);
       if (instance.scale !== 1) obj = scaleObjectUniform(obj, instance.scale);
       if (instance.rotation !== 0)
         obj = rotateObject(obj, { x: 0, y: 0 }, instance.rotation);
@@ -2516,246 +3576,29 @@ var indexOf = (doc) => {
 var resolveDocumentObject = (doc, id) => indexOf(doc).get(id);
 var documentObjectResolver = (doc) => (id) => resolveDocumentObject(doc, id);
 
-// ../core/src/paint/dimensionGeometry.ts
-var RAD2DEG = 180 / Math.PI;
-var formatDimValue = (value, precision) => {
-  const fixed = value.toFixed(precision);
-  return fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
+// ../core/src/paint/textMetrics.ts
+var LINE_HEIGHT_FACTOR = 1.66;
+var TAB_SIZE_FACTOR = 4;
+var boundMeasurer = (measure, font, widthFactor) => font === void 0 && widthFactor === void 0 ? measure : {
+  measureTextWidth: (text, heightMm) => measure.measureTextWidth(text, heightMm, font, widthFactor)
 };
-var resolveDimStyle = (obj, styles) => ({
-  ...dimStyleFor(obj, styles),
-  ...obj.styleOverride,
-  scale: obj.scale
-});
-var readableRotation = (u) => {
-  const raw = normAngle(angle(u));
-  const flipped = raw > Math.PI / 2 + 1e-9 && raw <= 3 * Math.PI / 2 + 1e-9;
-  return flipped ? raw - Math.PI : raw;
+var lineSegments = (line, heightMm, measure) => {
+  if (!line.includes("	")) return [{ text: line, x: 0 }];
+  const tab = heightMm * TAB_SIZE_FACTOR;
+  const out = [];
+  let x = 0;
+  const parts = line.split("	");
+  for (let i = 0; i < parts.length; i++) {
+    if (i > 0) x = (Math.floor(x / tab + 1e-9) + 1) * tab;
+    out.push({ text: parts[i], x });
+    x += measure.measureTextWidth(parts[i], heightMm);
+  }
+  return out;
 };
-var textFor = (content, at, along, style) => {
-  const rotation = readableRotation(along);
-  const textUp = perp(fromAngle(rotation));
-  return {
-    content,
-    anchor: add(at, scale(textUp, style.textOffset * style.scale)),
-    rotation,
-    height: style.textHeight * style.scale,
-    font: dimFontFace(style),
-    widthFactor: style.widthFactor
-  };
-};
-var linearGeometry = (obj, style) => {
-  if (obj.points.length < 2) return null;
-  const s = style.scale;
-  const points = obj.points;
-  const first = points[0];
-  const last = points[points.length - 1];
-  const upLen = len(obj.offset);
-  const u = upLen > 1e-9 ? perp(scale(obj.offset, 1 / upLen)) : dist(first, last) > 1e-9 ? norm(sub(last, first)) : { x: 1, y: 0 };
-  const v = perp(u);
-  const h = dot(obj.offset, v);
-  const feet = points.map((p) => add(p, scale(v, h - dot(sub(p, first), v))));
-  const extensionLines = [];
-  points.forEach((p, i) => {
-    const f = feet[i];
-    const gap = dist(p, f);
-    if (gap < 1e-9) return;
-    const w = norm(sub(f, p));
-    extensionLines.push({
-      a: style.extensionType === "short" ? sub(f, scale(w, style.extensionOvershoot * s)) : add(p, scale(w, Math.min(style.extensionOffset * s, gap))),
-      b: add(f, scale(w, style.extensionOvershoot * s))
-    });
-  });
-  const dimLines = [];
-  const arrows = [];
-  const texts = [];
-  for (let i = 0; i + 1 < feet.length; i++) {
-    const a = feet[i];
-    const b = feet[i + 1];
-    const value = dist(a, b);
-    if (value < 1e-9) continue;
-    dimLines.push({ a, b });
-    arrows.push(
-      { tip: a, toward: b, size: style.arrowSize * s },
-      { tip: b, toward: a, size: style.arrowSize * s }
-    );
-    texts.push(
-      textFor(
-        obj.textOverride ?? formatDimValue(value, style.precision),
-        mid(a, b),
-        u,
-        style
-      )
-    );
-  }
-  if (dimLines.length === 0) return null;
-  return {
-    extensionLines,
-    dimLines,
-    dimArc: null,
-    arrows,
-    arrowType: style.arrowType,
-    texts,
-    value: dist(feet[0], feet[feet.length - 1])
-  };
-};
-var angularGeometry = (obj, style) => {
-  if (obj.points.length < 3) return null;
-  const s = style.scale;
-  const [vertex, a, b] = obj.points;
-  const radius = len(obj.offset);
-  const da = dist(vertex, a);
-  const db = dist(vertex, b);
-  if (radius < 1e-9 || da < 1e-9 || db < 1e-9) return null;
-  const angA = angle(sub(a, vertex));
-  const angB = angle(sub(b, vertex));
-  const angL = angle(obj.offset);
-  const sweepAB = normAngle(angB - angA);
-  const inAB = normAngle(angL - angA) <= sweepAB;
-  const start = inAB ? angA : angB;
-  const sweep = inAB ? sweepAB : normAngle(angA - angB);
-  if (sweep < 1e-9) return null;
-  const at = (t) => add(vertex, scale(fromAngle(start + t), radius));
-  const extensionLines = [];
-  for (const [p, d] of [
-    [a, da],
-    [b, db]
-  ]) {
-    const w = norm(sub(p, vertex));
-    const inner = style.extensionType === "short" ? radius - style.extensionOvershoot * s : Math.min(d + style.extensionOffset * s, radius);
-    const outer = radius + style.extensionOvershoot * s;
-    if (outer - inner > 1e-9)
-      extensionLines.push({
-        a: add(vertex, scale(w, inner)),
-        b: add(vertex, scale(w, outer))
-      });
-  }
-  const tangentStep = Math.min(sweep / 3, style.arrowSize * s * 2 / radius);
-  const valueDeg = sweep * RAD2DEG;
-  const midPoint = at(sweep / 2);
-  const midTangent = perp(norm(sub(midPoint, vertex)));
-  return {
-    extensionLines,
-    dimLines: [],
-    dimArc: {
-      center: vertex,
-      radius,
-      startAngle: start,
-      endAngle: start + sweep
-    },
-    arrows: [
-      { tip: at(0), toward: at(tangentStep), size: style.arrowSize * s },
-      {
-        tip: at(sweep),
-        toward: at(sweep - tangentStep),
-        size: style.arrowSize * s
-      }
-    ],
-    arrowType: style.arrowType,
-    texts: [
-      textFor(
-        obj.textOverride ?? `${formatDimValue(valueDeg, style.precision)}\xB0`,
-        midPoint,
-        midTangent,
-        style
-      )
-    ],
-    value: sweep
-  };
-};
-var radialGeometry = (obj, style) => {
-  if (obj.points.length < 2) return null;
-  const s = style.scale;
-  const [center, p] = obj.points;
-  const r = dist(center, p);
-  if (r < 1e-9) return null;
-  const u = norm(sub(p, center));
-  const t = Math.max(dot(obj.offset, u), r * 0.2);
-  const textAt = add(center, scale(u, t));
-  return {
-    extensionLines: [],
-    // The line runs center → text position (through the curve point).
-    dimLines: [{ a: center, b: t > r ? textAt : p }],
-    dimArc: null,
-    arrows: [{ tip: p, toward: center, size: style.arrowSize * s }],
-    arrowType: style.arrowType,
-    texts: [
-      textFor(
-        obj.textOverride ?? `R${formatDimValue(r, style.precision)}`,
-        textAt,
-        u,
-        style
-      )
-    ],
-    value: r
-  };
-};
-var diameterGeometry = (obj, style) => {
-  if (obj.points.length < 2) return null;
-  const s = style.scale;
-  const [p1, p2] = obj.points;
-  const d = dist(p1, p2);
-  if (d < 1e-9) return null;
-  const u = norm(sub(p2, p1));
-  const t = dot(sub(add(mid(p1, p2), obj.offset), p1), u);
-  const textAt = add(p1, scale(u, Math.min(Math.max(t, d * 0.15), d * 0.85)));
-  return {
-    extensionLines: [],
-    dimLines: [{ a: p1, b: p2 }],
-    dimArc: null,
-    arrows: [
-      { tip: p1, toward: p2, size: style.arrowSize * s },
-      { tip: p2, toward: p1, size: style.arrowSize * s }
-    ],
-    arrowType: style.arrowType,
-    texts: [
-      textFor(
-        obj.textOverride ?? `\xD8${formatDimValue(d, style.precision)}`,
-        textAt,
-        u,
-        style
-      )
-    ],
-    value: d
-  };
-};
-var dimensionGeometry = (obj, styles) => {
-  const style = resolveDimStyle(obj, styles);
-  switch (obj.kind) {
-    case "angular":
-      return angularGeometry(obj, style);
-    case "radial":
-      return radialGeometry(obj, style);
-    case "diameter":
-      return diameterGeometry(obj, style);
-    case "linear":
-      return linearGeometry(obj, style);
-  }
-};
-
-// ../core/src/paint/textMetrics.ts
-var LINE_HEIGHT_FACTOR = 1.66;
-var TAB_SIZE_FACTOR = 4;
-var boundMeasurer = (measure, font, widthFactor) => font === void 0 && widthFactor === void 0 ? measure : {
-  measureTextWidth: (text, heightMm) => measure.measureTextWidth(text, heightMm, font, widthFactor)
-};
-var lineSegments = (line, heightMm, measure) => {
-  if (!line.includes("	")) return [{ text: line, x: 0 }];
-  const tab = heightMm * TAB_SIZE_FACTOR;
-  const out = [];
-  let x = 0;
-  const parts = line.split("	");
-  for (let i = 0; i < parts.length; i++) {
-    if (i > 0) x = (Math.floor(x / tab + 1e-9) + 1) * tab;
-    out.push({ text: parts[i], x });
-    x += measure.measureTextWidth(parts[i], heightMm);
-  }
-  return out;
-};
-var lineWidthWithTabs = (line, heightMm, measure) => {
-  const segs = lineSegments(line, heightMm, measure);
-  const last = segs[segs.length - 1];
-  return last.x + measure.measureTextWidth(last.text, heightMm);
+var lineWidthWithTabs = (line, heightMm, measure) => {
+  const segs = lineSegments(line, heightMm, measure);
+  const last = segs[segs.length - 1];
+  return last.x + measure.measureTextWidth(last.text, heightMm);
 };
 var wrapWords = (line, heightMm, measure, maxWidthMm) => {
   const words = line.split(" ");
@@ -2802,6 +3645,203 @@ var textBlock = (content, heightMm, measure, maxWidthMm) => {
   };
 };
 
+// ../core/src/paint/richText.ts
+var ATTR_KEYS = [
+  "font",
+  "bold",
+  "italic",
+  "underline",
+  "color",
+  "height",
+  "script"
+];
+var SCRIPT_SCALE = 0.6;
+var SUPER_RISE = 0.45;
+var SUB_DROP = 0.2;
+var attrsOf = (s) => {
+  const out = {};
+  for (const k of ATTR_KEYS) if (s[k] !== void 0) out[k] = s[k];
+  return out;
+};
+var sameAttrs = (a, b) => ATTR_KEYS.every((k) => a[k] === b[k]);
+var isEmpty = (a) => ATTR_KEYS.every((k) => a[k] === void 0);
+var snap = (i, content) => {
+  const c = Math.max(0, Math.min(content.length, Math.round(i)));
+  const code = content.charCodeAt(c);
+  return c > 0 && code >= 56320 && code <= 57343 ? c - 1 : c;
+};
+var toIntervals = (spans, content, extra = []) => {
+  const cuts = /* @__PURE__ */ new Set([0, content.length]);
+  for (const s of spans ?? []) {
+    cuts.add(snap(s.start, content));
+    cuts.add(snap(s.end, content));
+  }
+  for (const c of extra) cuts.add(snap(c, content));
+  const sorted = [...cuts].sort((a, b) => a - b);
+  const out = [];
+  for (let i = 0; i + 1 < sorted.length; i++) {
+    const start = sorted[i];
+    const end = sorted[i + 1];
+    let attrs = {};
+    for (const s of spans ?? [])
+      if (snap(s.start, content) <= start && snap(s.end, content) >= end)
+        attrs = { ...attrs, ...attrsOf(s) };
+    out.push({ start, end, attrs });
+  }
+  return out;
+};
+var fromIntervals = (intervals) => {
+  const out = [];
+  for (const iv of intervals) {
+    if (iv.end <= iv.start || isEmpty(iv.attrs)) continue;
+    const last = out[out.length - 1];
+    if (last && last.end === iv.start && sameAttrs(attrsOf(last), iv.attrs))
+      last.end = iv.end;
+    else out.push({ start: iv.start, end: iv.end, ...iv.attrs });
+  }
+  return out;
+};
+var normalizeSpans = (spans, content) => fromIntervals(toIntervals(spans, content));
+var sliceSpans = (spans, start, end, to = 0) => (spans ?? []).filter((s) => s.end > start && s.start < end).map((s) => ({
+  ...s,
+  start: Math.max(s.start, start) - start + to,
+  end: Math.min(s.end, end) - start + to
+}));
+var richTextBlock = (content, spans, base, measure, tabMeasure, maxWidthMm) => {
+  const h = base.heightMm;
+  const baseFace = parseFontFace(base.face);
+  const runs = toIntervals(spans, content).map((iv) => {
+    const a = iv.attrs;
+    const cap = h * (a.height ?? 1);
+    return {
+      ...iv,
+      face: fontFace(
+        a.font ?? baseFace.font,
+        a.bold ?? baseFace.bold,
+        a.italic ?? baseFace.italic
+      ),
+      cap,
+      glyph: a.script ? cap * SCRIPT_SCALE : cap,
+      dy: a.script === "super" ? cap * SUPER_RISE : a.script === "sub" ? -cap * SUB_DROP : 0
+    };
+  });
+  const runsIn = (a, b) => runs.filter((r) => r.end > a && r.start < b);
+  const widthOf = (a, b, m) => runsIn(a, b).reduce(
+    (w, r) => w + m.measureTextWidth(
+      content.slice(Math.max(a, r.start), Math.min(b, r.end)),
+      r.glyph,
+      r.face,
+      base.widthFactor
+    ),
+    0
+  );
+  const tab = h * TAB_SIZE_FACTOR;
+  const nextStop = (x) => (Math.floor(x / tab + 1e-9) + 1) * tab;
+  const segments = (a, b) => {
+    const out = [];
+    let x = 0;
+    let s = a;
+    for (let i = a; i <= b; i++) {
+      if (i < b && content[i] !== "	") continue;
+      out.push({ start: s, end: i, x });
+      x = nextStop(x + widthOf(s, i, tabMeasure));
+      s = i + 1;
+    }
+    return out;
+  };
+  const wrapWords2 = (a, b, max) => {
+    const out = [];
+    let lineStart = a;
+    let cur = -1;
+    for (let i = a; i <= b; i++) {
+      if (i < b && content[i] !== " ") continue;
+      if (cur >= 0 && widthOf(lineStart, i, measure) > max) {
+        out.push([lineStart, cur]);
+        lineStart = cur + 1;
+      }
+      cur = i;
+    }
+    out.push([lineStart, b]);
+    return out;
+  };
+  const raw = [];
+  let p0 = 0;
+  for (const para of content.split("\n")) {
+    const p1 = p0 + para.length;
+    const tabbed = para.includes("	");
+    const wrap = maxWidthMm !== void 0 && maxWidthMm > 0;
+    if (!wrap) raw.push({ start: p0, end: p1, tabbed });
+    else if (!tabbed)
+      for (const [s, e] of wrapWords2(p0, p1, maxWidthMm))
+        raw.push({ start: s, end: e, tabbed });
+    else {
+      const segs = segments(p0, p1);
+      const last = segs[segs.length - 1];
+      const width = last.x + widthOf(last.start, last.end, measure);
+      if (width <= maxWidthMm || maxWidthMm - last.x <= h)
+        raw.push({ start: p0, end: p1, tabbed });
+      else
+        wrapWords2(last.start, p1, maxWidthMm - last.x).forEach(
+          ([s, e], i) => raw.push(
+            i === 0 ? { start: p0, end: e, tabbed } : { start: s, end: e, hang: last.x, tabbed }
+          )
+        );
+    }
+    p0 = p1 + 1;
+  }
+  const lines = [];
+  let baseline = 0;
+  let prevCap = 0;
+  for (const r of raw) {
+    const segs = r.hang !== void 0 ? [{ start: r.start, end: r.end, x: r.hang }] : segments(r.start, r.end);
+    const pieces = [];
+    for (const seg of segs) {
+      let x = seg.x;
+      for (const run of runsIn(seg.start, seg.end)) {
+        const text = content.slice(
+          Math.max(seg.start, run.start),
+          Math.min(seg.end, run.end)
+        );
+        const width = measure.measureTextWidth(
+          text,
+          run.glyph,
+          run.face,
+          base.widthFactor
+        );
+        pieces.push({
+          text,
+          x,
+          width,
+          dy: run.dy,
+          heightMm: run.glyph,
+          face: run.face,
+          ...run.attrs.color ? { color: run.attrs.color } : {},
+          ...run.attrs.underline ? { underline: true } : {}
+        });
+        x += width;
+      }
+    }
+    const at = runsIn(r.start, Math.max(r.end, r.start + 1));
+    const cap = Math.max(...at.map((run) => run.cap), at.length ? 0 : h);
+    baseline += lines.length === 0 ? cap : LINE_HEIGHT_FACTOR * (prevCap + cap) / 2;
+    prevCap = cap;
+    const last = pieces[pieces.length - 1];
+    lines.push({
+      start: r.start,
+      end: r.end,
+      pieces,
+      width: last ? last.x + last.width : 0,
+      fromBlockEdge: r.tabbed,
+      baseline
+    });
+  }
+  return {
+    lines,
+    width: maxWidthMm !== void 0 && maxWidthMm > 0 ? maxWidthMm : Math.max(...lines.map((l) => l.width), 0),
+    height: baseline
+  };
+};
+
 // ../core/src/paint/advanceTables.ts
 var EXTRACTED_RANGES = [
   [32, 126],
@@ -6284,6 +7324,473 @@ var approximateTextMeasurer = {
   }
 };
 
+// ../core/src/paint/dimensionGeometry.ts
+var RAD2DEG = 180 / Math.PI;
+var formatDimValue = (value, precision) => {
+  const fixed = value.toFixed(precision);
+  return fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
+};
+var dimLabelContent = (kind, label, formatted) => {
+  const parts = (label?.content ?? DIM_DEFAULT_CONTENT[kind]).split(
+    DIM_VALUE_TOKEN
+  );
+  const content = parts.join(formatted);
+  if (!label?.spans?.length || label.content === void 0) return { content };
+  const T = DIM_VALUE_TOKEN.length;
+  const map = (p, end) => {
+    let t = 0;
+    let c = 0;
+    for (let i = 0; i < parts.length; i++) {
+      if (p <= t + parts[i].length) return c + (p - t);
+      t += parts[i].length;
+      c += parts[i].length;
+      if (i === parts.length - 1) break;
+      if (p < t + T) return end ? c + formatted.length : c;
+      t += T;
+      c += formatted.length;
+    }
+    return content.length;
+  };
+  const spans = normalizeSpans(
+    label.spans.map((s) => ({
+      ...s,
+      start: map(s.start, false),
+      end: map(s.end, true)
+    })),
+    content
+  );
+  return spans.length ? { content, spans } : { content };
+};
+var labelWidth = (label, h, font, widthFactor) => label.spans?.length ? richTextBlock(
+  label.content,
+  label.spans,
+  { face: font, heightMm: h, widthFactor },
+  approximateTextMeasurer,
+  approximateTextMeasurer
+).width : approximateTextMeasurer.measureTextWidth(
+  label.content,
+  h,
+  font,
+  widthFactor
+);
+var resolveDimStyle = (obj, styles) => ({
+  ...dimStyleFor(obj, styles),
+  ...obj.styleOverride,
+  scale: obj.scale
+});
+var readableRotation = (u) => {
+  const raw = normAngle(angle(u));
+  const flipped = raw > Math.PI / 2 + 1e-9 && raw <= 3 * Math.PI / 2 + 1e-9;
+  return flipped ? raw - Math.PI : raw;
+};
+var straightFrame = (origin, u, n, s0, s1) => ({
+  s0,
+  s1,
+  toWorld: (along, across) => add(origin, add(scale(u, along), scale(n, across))),
+  fromWorld: (p) => {
+    const d = sub(p, origin);
+    return { along: dot(d, u), across: dot(d, n) };
+  },
+  tangent: () => u
+});
+var linearAxis = (obj) => {
+  const first = obj.points[0];
+  const last = obj.points[obj.points.length - 1];
+  const u = obj.rotation !== void 0 ? fromAngle(obj.rotation) : dist(first, last) > 1e-9 ? norm(sub(last, first)) : { x: 1, y: 0 };
+  return { u, n: perp(u) };
+};
+var linearFeet = (obj) => {
+  const { u, n } = linearAxis(obj);
+  const first = obj.points[0];
+  const h = obj.offset ?? 0;
+  const feet = obj.points.map(
+    (p) => add(p, scale(n, h - dot(sub(p, first), n)))
+  );
+  return { feet, u, n };
+};
+var dimensionLabelFrames = (obj) => {
+  switch (obj.kind) {
+    case "linear": {
+      if (obj.points.length < 2) return [];
+      const { feet, u, n } = linearFeet(obj);
+      const across = (obj.offset ?? 0) >= 0 ? n : scale(n, -1);
+      const frames = [];
+      for (let i = 0; i + 1 < feet.length; i++) {
+        const L = dot(sub(feet[i + 1], feet[i]), u);
+        if (Math.abs(L) < 1e-9) continue;
+        const dir = L > 0 ? u : scale(u, -1);
+        frames.push(straightFrame(feet[i], dir, across, 0, Math.abs(L)));
+      }
+      return frames;
+    }
+    case "angular": {
+      const polar2 = angularFrame(obj);
+      return polar2 ? [polar2.frame] : [];
+    }
+    case "radial": {
+      if (obj.points.length < 2) return [];
+      const [center, p] = obj.points;
+      const r = dist(center, p);
+      if (r < 1e-9) return [];
+      const u = norm(sub(p, center));
+      return [straightFrame(center, u, perp(u), 0, r)];
+    }
+    case "diameter": {
+      if (obj.points.length < 2) return [];
+      const [p1, p2] = obj.points;
+      const d = dist(p1, p2);
+      if (d < 1e-9) return [];
+      const u = norm(sub(p2, p1));
+      const center = add(p1, scale(u, d / 2));
+      return [straightFrame(center, u, perp(u), -d / 2, d / 2)];
+    }
+  }
+};
+var angularFrame = (obj) => {
+  if (obj.points.length < 3) return null;
+  const [vertex, a, b] = obj.points;
+  const signed = obj.offset ?? 0;
+  const radius = Math.abs(signed);
+  if (radius < 1e-9 || dist(vertex, a) < 1e-9 || dist(vertex, b) < 1e-9)
+    return null;
+  const angA = angle(sub(a, vertex));
+  const angB = angle(sub(b, vertex));
+  const start = signed >= 0 ? angA : angB;
+  const sweep = signed >= 0 ? normAngle(angB - angA) : normAngle(angA - angB);
+  if (sweep < 1e-9) return null;
+  const frame = {
+    s0: 0,
+    s1: radius * sweep,
+    toWorld: (along, across) => add(vertex, scale(fromAngle(start + along / radius), radius + across)),
+    fromWorld: (p) => {
+      const d = sub(p, vertex);
+      let w = normAngle(angle(d) - start);
+      if (w > Math.PI) w -= 2 * Math.PI;
+      return { along: w * radius, across: len(d) - radius };
+    },
+    tangent: (along) => perp(fromAngle(start + along / radius))
+  };
+  return { vertex, radius, start, sweep, frame };
+};
+var overlaps = (a, b) => a[0] < b[1] - 1e-9 && b[0] < a[1] - 1e-9;
+var placeLabel = (frame, spec, index, label, style, arrowCount, mode, stack) => {
+  const s = style.scale;
+  const h = style.textHeight * s;
+  const gap = style.textOffset * s;
+  const A = style.arrowSize * s;
+  const font = dimFontFace(style);
+  const width = labelWidth(label, h, font, style.widthFactor);
+  const L = frame.s1 - frame.s0;
+  const arrowsInside = L >= arrowCount * A - 1e-9;
+  let along = spec?.along;
+  let across = spec?.across ?? 0;
+  let row = 0;
+  if (along === void 0) {
+    const fits = L >= width + 2 * gap + arrowCount * A - 1e-9;
+    const push = (arrowsInside ? 0 : A) + gap + width / 2;
+    if (fits) along = (frame.s0 + frame.s1) / 2;
+    else if (mode === "end") along = frame.s1 + push;
+    else if (mode === "start") along = frame.s0 - push;
+    else {
+      along = (frame.s0 + frame.s1) / 2;
+      row = 1;
+      const interval2 = [along - width / 2, along + width / 2];
+      if (stack && stack.row >= 1 && overlaps(interval2, stack.interval))
+        row = stack.row + 1;
+      across = row * (h + gap);
+    }
+  }
+  const interval = [along - width / 2, along + width / 2];
+  let cover = null;
+  if (across === 0 && (interval[1] > frame.s1 || interval[0] < frame.s0))
+    cover = [
+      Math.min(frame.s0, interval[0] - gap),
+      Math.max(frame.s1, interval[1] + gap)
+    ];
+  const leaders = [];
+  if (spec?.across !== void 0 && spec.across !== 0) {
+    const landingA = frame.toWorld(interval[0], across);
+    const landingB = frame.toWorld(interval[1], across);
+    const from = frame.toWorld((frame.s0 + frame.s1) / 2, 0);
+    const to = dist(from, landingA) <= dist(from, landingB) ? landingA : landingB;
+    leaders.push({ a: from, b: to }, { a: landingA, b: landingB });
+  }
+  const tangent = frame.tangent(along);
+  const rotation = readableRotation(tangent);
+  const textUp = perp(fromAngle(rotation));
+  const text = {
+    content: label.content,
+    ...label.spans ? { spans: label.spans } : {},
+    anchor: add(frame.toWorld(along, across), scale(textUp, gap)),
+    rotation,
+    height: h,
+    width,
+    font,
+    widthFactor: style.widthFactor,
+    segment: index,
+    along,
+    across
+  };
+  return { text, cover, leaders, row };
+};
+var linearGeometry = (obj, style) => {
+  if (obj.points.length < 2) return null;
+  const s = style.scale;
+  const A = style.arrowSize * s;
+  const { feet, u } = linearFeet(obj);
+  const frames = dimensionLabelFrames(obj);
+  if (frames.length === 0) return null;
+  const extensionLines = [];
+  obj.points.forEach((p, i) => {
+    const f = feet[i];
+    const gap = dist(p, f);
+    if (gap < 1e-9) return;
+    const w = norm(sub(f, p));
+    extensionLines.push({
+      a: style.extensionType === "short" ? sub(f, scale(w, style.extensionOvershoot * s)) : add(p, scale(w, Math.min(style.extensionOffset * s, gap))),
+      b: add(f, scale(w, style.extensionOvershoot * s))
+    });
+  });
+  const dimLines = [];
+  const arrows = [];
+  const labels = [];
+  const leaders = [];
+  let stack = null;
+  frames.forEach((frame, i) => {
+    const L = frame.s1 - frame.s0;
+    const value = L;
+    const mode = frames.length === 1 || i === frames.length - 1 ? "end" : i === 0 ? "start" : "raise";
+    const placed = placeLabel(
+      frame,
+      obj.labels[i],
+      i,
+      dimLabelContent(
+        obj.kind,
+        obj.labels[i],
+        formatDimValue(value, style.precision)
+      ),
+      style,
+      2,
+      mode,
+      stack
+    );
+    stack = placed.row > 0 ? {
+      row: placed.row,
+      interval: [
+        placed.text.along - placed.text.width / 2,
+        placed.text.along + placed.text.width / 2
+      ]
+    } : null;
+    labels.push(placed.text);
+    leaders.push(...placed.leaders);
+    const a = frame.toWorld(frame.s0, 0);
+    const b = frame.toWorld(frame.s1, 0);
+    const arrowsInside = L >= 2 * A - 1e-9;
+    let from = frame.s0;
+    let to = frame.s1;
+    if (!arrowsInside) {
+      from -= 2 * A;
+      to += 2 * A;
+    }
+    if (placed.cover) {
+      from = Math.min(from, placed.cover[0]);
+      to = Math.max(to, placed.cover[1]);
+    }
+    dimLines.push({ a: frame.toWorld(from, 0), b: frame.toWorld(to, 0) });
+    arrows.push(
+      arrowsInside ? { tip: a, toward: b, size: A } : { tip: a, toward: frame.toWorld(from, 0), size: A },
+      arrowsInside ? { tip: b, toward: a, size: A } : { tip: b, toward: frame.toWorld(to, 0), size: A }
+    );
+  });
+  return {
+    extensionLines,
+    dimLines,
+    dimArc: null,
+    leaders,
+    arrows,
+    arrowType: style.arrowType,
+    labels,
+    value: Math.abs(dot(sub(feet[feet.length - 1], feet[0]), u))
+  };
+};
+var angularGeometry = (obj, style) => {
+  const polar2 = angularFrame(obj);
+  if (!polar2) return null;
+  const { vertex, radius, start, sweep, frame } = polar2;
+  const s = style.scale;
+  const A = style.arrowSize * s;
+  const [, a, b] = obj.points;
+  const extensionLines = [];
+  for (const p of [a, b]) {
+    const d = dist(vertex, p);
+    const w = norm(sub(p, vertex));
+    const inner = style.extensionType === "short" ? radius - style.extensionOvershoot * s : Math.min(d + style.extensionOffset * s, radius);
+    const outer = radius + style.extensionOvershoot * s;
+    if (outer - inner > 1e-9)
+      extensionLines.push({
+        a: add(vertex, scale(w, inner)),
+        b: add(vertex, scale(w, outer))
+      });
+  }
+  const placed = placeLabel(
+    frame,
+    obj.labels[0],
+    0,
+    dimLabelContent(
+      obj.kind,
+      obj.labels[0],
+      formatDimValue(sweep * RAD2DEG, style.precision)
+    ),
+    style,
+    2,
+    "end",
+    null
+  );
+  const L = frame.s1;
+  const arrowsInside = L >= 2 * A - 1e-9;
+  let from = 0;
+  let to = L;
+  if (!arrowsInside) {
+    from -= 2 * A;
+    to += 2 * A;
+  }
+  if (placed.cover) {
+    from = Math.min(from, placed.cover[0]);
+    to = Math.max(to, placed.cover[1]);
+  }
+  const step = Math.min(sweep / 3, A * 2 / radius) * radius;
+  const at = (along) => frame.toWorld(along, 0);
+  return {
+    extensionLines,
+    dimLines: [],
+    dimArc: {
+      center: vertex,
+      radius,
+      startAngle: start + from / radius,
+      endAngle: start + to / radius
+    },
+    leaders: placed.leaders,
+    arrows: [
+      { tip: at(0), toward: at(arrowsInside ? step : -step), size: A },
+      { tip: at(L), toward: at(arrowsInside ? L - step : L + step), size: A }
+    ],
+    arrowType: style.arrowType,
+    labels: [placed.text],
+    value: sweep
+  };
+};
+var radialGeometry = (obj, style) => {
+  const [frame] = dimensionLabelFrames(obj);
+  if (!frame) return null;
+  const s = style.scale;
+  const A = style.arrowSize * s;
+  const [center, p] = obj.points;
+  const r = frame.s1;
+  const spec = obj.labels[0];
+  const content = dimLabelContent(
+    obj.kind,
+    spec,
+    formatDimValue(r, style.precision)
+  );
+  const width = labelWidth(
+    content,
+    style.textHeight * s,
+    dimFontFace(style),
+    style.widthFactor
+  );
+  const gap = style.textOffset * s;
+  const autoInside = spec?.along === void 0 && r >= width + 2 * gap + A - 1e-9 ? { ...spec, along: r - A - gap - width / 2 } : spec;
+  const placed = placeLabel(
+    frame,
+    autoInside,
+    0,
+    content,
+    style,
+    1,
+    "end",
+    null
+  );
+  const outside = placed.text.along > r + 1e-9;
+  let to = r;
+  if (placed.cover) to = Math.max(to, placed.cover[1]);
+  return {
+    extensionLines: [],
+    dimLines: [{ a: center, b: frame.toWorld(to, 0) }],
+    dimArc: null,
+    leaders: placed.leaders,
+    // Head at the curve: pointing outward with the text inside, inward
+    // (body on the outside) with the text outside.
+    arrows: [
+      { tip: p, toward: outside ? frame.toWorld(r + A, 0) : center, size: A }
+    ],
+    arrowType: style.arrowType,
+    labels: [placed.text],
+    value: r
+  };
+};
+var diameterGeometry = (obj, style) => {
+  const [frame] = dimensionLabelFrames(obj);
+  if (!frame) return null;
+  const s = style.scale;
+  const A = style.arrowSize * s;
+  const [p1, p2] = obj.points;
+  const d = frame.s1 - frame.s0;
+  const placed = placeLabel(
+    frame,
+    obj.labels[0],
+    0,
+    dimLabelContent(
+      obj.kind,
+      obj.labels[0],
+      formatDimValue(d, style.precision)
+    ),
+    style,
+    2,
+    "end",
+    null
+  );
+  const arrowsInside = d >= 2 * A - 1e-9;
+  let from = frame.s0;
+  let to = frame.s1;
+  if (!arrowsInside) {
+    from -= 2 * A;
+    to += 2 * A;
+  }
+  if (placed.cover) {
+    from = Math.min(from, placed.cover[0]);
+    to = Math.max(to, placed.cover[1]);
+  }
+  return {
+    extensionLines: [],
+    dimLines: [{ a: frame.toWorld(from, 0), b: frame.toWorld(to, 0) }],
+    dimArc: null,
+    leaders: placed.leaders,
+    arrows: arrowsInside ? [
+      { tip: p1, toward: p2, size: A },
+      { tip: p2, toward: p1, size: A }
+    ] : [
+      { tip: p1, toward: frame.toWorld(from, 0), size: A },
+      { tip: p2, toward: frame.toWorld(to, 0), size: A }
+    ],
+    arrowType: style.arrowType,
+    labels: [placed.text],
+    value: d
+  };
+};
+var dimensionGeometry = (obj, styles) => {
+  const style = resolveDimStyle(obj, styles);
+  switch (obj.kind) {
+    case "linear":
+      return linearGeometry(obj, style);
+    case "angular":
+      return angularGeometry(obj, style);
+    case "radial":
+      return radialGeometry(obj, style);
+    case "diameter":
+      return diameterGeometry(obj, style);
+  }
+};
+
 // ../core/src/paint/textGeometry.ts
 var textHeight = (obj, textStyles) => (obj.styleOverride?.textHeight ?? textStyleFor(obj, textStyles).textHeight) * obj.scale;
 var textArrowSize = (obj, textStyles) => (obj.styleOverride?.arrowSize ?? textStyleFor(obj, textStyles).arrowSize) * obj.scale;
@@ -6292,11 +7799,24 @@ var textWidth = (obj) => obj.width === void 0 ? void 0 : obj.width * obj.scale;
 var FRAME_MARGIN_FACTOR = 0.35;
 var textBoxLocal = (obj, measure, textStyles) => {
   const { font, widthFactor } = effectiveTextFont(obj, textStyles);
-  const m = boundMeasurer(measure, font, widthFactor);
-  const block = textBlock(
+  const block = obj.spans?.length ? (
+    // Formatted: per-run fonts, so the measurer stays unbound.
+    richTextBlock(
+      obj.content,
+      obj.spans,
+      {
+        face: font,
+        heightMm: textHeight(obj, textStyles),
+        widthFactor
+      },
+      measure,
+      approximateTextMeasurer,
+      textWidth(obj)
+    )
+  ) : textBlock(
     obj.content,
     textHeight(obj, textStyles),
-    m,
+    boundMeasurer(measure, font, widthFactor),
     textWidth(obj)
   );
   const u = fromAngle(obj.rotation);
@@ -6397,7 +7917,7 @@ var cellText = (t, row, col) => {
     id: `${t.id}:${row}:${col}`,
     layerId: t.layerId,
     position: { x: 0, y: 0 },
-    content: cell.text,
+    content: cell.content,
     leaderLines: [],
     hAlign: "center",
     vAlign: "center",
@@ -6441,6 +7961,18 @@ var cellAnchor = (t, colX, rowY, a) => {
     vAlign: v
   };
 };
+var tableCellFrame = (t, textStyles, row, col) => {
+  const { colX, rowY, anchors } = tableLayout(t, textStyles);
+  const a = anchors.find(
+    (a2) => row >= a2.row && row < a2.row + a2.rows && col >= a2.col && col < a2.col + a2.cols
+  ) ?? { row, col, rows: 1, cols: 1 };
+  return {
+    row: a.row,
+    col: a.col,
+    text: { ...cellText(t, a.row, a.col), ...cellAnchor(t, colX, rowY, a) },
+    innerWidth: colX[a.col + a.cols] - colX[a.col] - 2 * t.cellMargin * t.scale
+  };
+};
 var cache = /* @__PURE__ */ new WeakMap();
 var tableLayout = (t, textStyles) => {
   const hit = cache.get(t);
@@ -6462,9 +7994,32 @@ var tableLayout = (t, textStyles) => {
       const h = textHeight(text, textStyles);
       const { font, widthFactor } = effectiveTextFont(text, textStyles);
       const inner2 = colX[c + cols] - colX[c] - 2 * margin;
+      if (cell.spans?.length) {
+        const rich = richTextBlock(
+          cell.content,
+          cell.spans,
+          { face: font, heightMm: h, widthFactor },
+          approximateTextMeasurer,
+          approximateTextMeasurer,
+          inner2 > 0 ? inner2 : void 0
+        );
+        let content = "";
+        const spans = [];
+        rich.lines.forEach((l, k) => {
+          if (k > 0) content += "\n";
+          spans.push(...sliceSpans(cell.spans, l.start, l.end, content.length));
+          content += cell.content.slice(l.start, l.end);
+        });
+        wrapped.push({
+          text: { ...text, spans },
+          lines: [content],
+          height: rich.height + 2 * margin
+        });
+        return;
+      }
       const measure = boundMeasurer(approximateTextMeasurer, font, widthFactor);
       const block = textBlock(
-        cell.text,
+        cell.content,
         h,
         measure,
         inner2 > 0 ? inner2 : void 0
@@ -6474,7 +8029,7 @@ var tableLayout = (t, textStyles) => {
         text,
         lines,
         // An empty cell still reserves one line of its text height.
-        height: (cell.text ? h + (lines.length - 1) * block.lineHeight : h) + 2 * margin
+        height: (cell.content ? h + (lines.length - 1) * block.lineHeight : h) + 2 * margin
       });
     })
   );
@@ -6553,7 +8108,7 @@ var tableLayout = (t, textStyles) => {
   }));
   anchors.forEach((a, i) => {
     const { text, lines } = wrapped[i];
-    if (!t.cells[a.row][a.col].text) return;
+    if (!t.cells[a.row][a.col].content) return;
     children.push({
       ...text,
       ...cellAnchor(t, colX, rowY, a),
@@ -6869,6 +8424,303 @@ var hexToTrueColor = (hex) => {
   return rgb ? rgb[0] << 16 | rgb[1] << 8 | rgb[2] : null;
 };
 
+// ../core/src/export/dxf/codecs.ts
+var LINE_WEIGHTS = [
+  0,
+  5,
+  9,
+  13,
+  15,
+  18,
+  20,
+  25,
+  30,
+  35,
+  40,
+  50,
+  53,
+  60,
+  70,
+  80,
+  90,
+  100,
+  106,
+  120,
+  140,
+  158,
+  200,
+  211
+];
+var lineWeightToMm = (lineWeight) => lineWeight === void 0 || lineWeight < 0 ? void 0 : Math.max(lineWeight, 5) / 100;
+var mmToLineWeight = (mm) => LINE_WEIGHTS.reduce(
+  (best, w) => Math.abs(w - mm * 100) < Math.abs(best - mm * 100) ? w : best
+);
+var encodeMtext = (s) => s.replace(/\r\n/g, "\n").replace(/\r/g, "").replace(/\\/g, "\\\\").replace(/\{/g, "\\{").replace(/\}/g, "\\}").replace(/\^/g, "^ ").replace(/\n/g, "\\P").replace(/\t/g, "^I");
+var decodeTextEscapes = (text) => text.replace(/%%([dpcuo%])/gi, (_, ch) => {
+  switch (ch.toLowerCase()) {
+    case "d":
+      return "\xB0";
+    case "p":
+      return "\xB1";
+    case "c":
+      return "\xD8";
+    case "u":
+    case "o":
+      return "";
+    default:
+      return "%";
+  }
+});
+var SUPERSCRIPT = {
+  "0": "\u2070",
+  "1": "\xB9",
+  "2": "\xB2",
+  "3": "\xB3",
+  "4": "\u2074",
+  "5": "\u2075",
+  "6": "\u2076",
+  "7": "\u2077",
+  "8": "\u2078",
+  "9": "\u2079",
+  "+": "\u207A",
+  "-": "\u207B",
+  "=": "\u207C",
+  "(": "\u207D",
+  ")": "\u207E",
+  n: "\u207F",
+  i: "\u2071"
+};
+var SUBSCRIPT = {
+  "0": "\u2080",
+  "1": "\u2081",
+  "2": "\u2082",
+  "3": "\u2083",
+  "4": "\u2084",
+  "5": "\u2085",
+  "6": "\u2086",
+  "7": "\u2087",
+  "8": "\u2088",
+  "9": "\u2089",
+  "+": "\u208A",
+  "-": "\u208B",
+  "=": "\u208C",
+  "(": "\u208D",
+  ")": "\u208E"
+};
+var toScript = (s, map) => [...s].every((c) => map[c]) ? [...s].map((c) => map[c]).join("") : s;
+var stackText = (body) => {
+  const m = /^(.*?)([\^#/])(.*)$/s.exec(body);
+  if (!m) return body;
+  const top = m[1].trim();
+  const bottom = m[3].trim();
+  if (top && !bottom) return toScript(top, SUPERSCRIPT);
+  if (!top && bottom) return toScript(bottom, SUBSCRIPT);
+  return `${top}/${bottom}`;
+};
+var SYMBOL_FONT = {
+  a: "\u03B1",
+  b: "\u03B2",
+  c: "\u03C7",
+  d: "\u03B4",
+  e: "\u03B5",
+  f: "\u03C6",
+  g: "\u03B3",
+  h: "\u03B7",
+  i: "\u03B9",
+  k: "\u03BA",
+  l: "\u03BB",
+  m: "\u03BC",
+  n: "\u03BD",
+  p: "\u03C0",
+  q: "\u03B8",
+  r: "\u03C1",
+  s: "\u03C3",
+  t: "\u03C4",
+  u: "\u03C5",
+  w: "\u03C9",
+  x: "\u03BE",
+  y: "\u03C8",
+  z: "\u03B6",
+  D: "\u0394",
+  F: "\u03A6",
+  G: "\u0393",
+  L: "\u039B",
+  P: "\u03A0",
+  Q: "\u0398",
+  S: "\u03A3",
+  W: "\u03A9",
+  X: "\u039E",
+  Y: "\u03A8",
+  "\xA3": "\u2264",
+  "\xB3": "\u2265",
+  "\xB9": "\u2260",
+  "\xBB": "\u2248",
+  "\xA5": "\u221E",
+  "\xB4": "\xD7",
+  "\xB8": "\xF7",
+  \u00D6: "\u221A",
+  "\xAE": "\u2192",
+  "\xAC": "\u2190",
+  \u00C6: "\u2205",
+  \u00CE: "\u2208",
+  "\xB6": "\u2202"
+};
+var isSymbolFont = (fontCode) => /^symbol(\.ttf)?$/i.test(fontCode.split("|")[0].trim());
+var scanMtext = (text, opts) => {
+  const chunks = [];
+  let st = { symbol: false };
+  const stack = [];
+  const attrs = (extra) => opts ? {
+    ...st.font !== void 0 ? { font: st.font } : {},
+    ...st.bold !== void 0 ? { bold: st.bold } : {},
+    ...st.italic !== void 0 ? { italic: st.italic } : {},
+    ...st.height !== void 0 ? { height: st.height } : {},
+    ...st.color !== void 0 ? { color: st.color } : {},
+    ...st.underline ? { underline: true } : {},
+    ...extra
+  } : {};
+  const emit = (t, extra) => {
+    if (!t) return;
+    const a = attrs(extra);
+    const last = chunks[chunks.length - 1];
+    if (!extra && last && JSON.stringify(last.attrs) === JSON.stringify(a))
+      last.text += t;
+    else chunks.push({ text: t, attrs: a });
+  };
+  const codeBody = (i2) => {
+    const end = text.indexOf(";", i2);
+    return end === -1 ? ["", i2] : [text.slice(i2, end), end + 1];
+  };
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "{") {
+      stack.push(st);
+      st = { ...st };
+      i++;
+    } else if (ch === "}") {
+      st = stack.pop() ?? st;
+      i++;
+    } else if (ch !== "\\") {
+      emit(st.symbol ? SYMBOL_FONT[ch] ?? ch : ch);
+      i++;
+    } else {
+      const next = text[i + 1] ?? "";
+      if (next === "\\" || next === "{" || next === "}") {
+        emit(next);
+        i += 2;
+      } else if (next === "P") {
+        emit("\n");
+        i += 2;
+      } else if (next === "~") {
+        emit(" ");
+        i += 2;
+      } else if (next === "L" || next === "l") {
+        st = { ...st, underline: next === "L" };
+        i += 2;
+      } else if ("OoKk".includes(next)) {
+        i += 2;
+      } else if (next === "S") {
+        const [body, at] = codeBody(i + 2);
+        const m = /^(.*?)([\^#/])(.*)$/s.exec(body);
+        const top = m?.[1].trim() ?? "";
+        const bottom = m?.[3].trim() ?? "";
+        if (opts && m && m[2] === "^" && top && !bottom)
+          emit(top, { script: "super" });
+        else if (opts && m && m[2] === "^" && !top && bottom)
+          emit(bottom, { script: "sub" });
+        else emit(stackText(body));
+        i = at === i + 2 ? i + 2 : at;
+      } else if ((next === "U" || next === "u") && /^\+[0-9a-fA-F]{4}/.test(text.slice(i + 2, i + 7))) {
+        emit(String.fromCodePoint(parseInt(text.slice(i + 3, i + 7), 16)));
+        i += 7;
+      } else if (next === "f" || next === "F") {
+        const [body, at] = codeBody(i + 2);
+        st = { ...st, symbol: isSymbolFont(body) };
+        if (opts && !st.symbol && body) {
+          const [name, ...flags] = body.split("|");
+          const file = name.includes(".");
+          const face = fontFromDxfStyle(
+            file ? name : void 0,
+            file ? void 0 : name
+          );
+          const flag = (k) => flags.find((f) => f[0] === k)?.slice(1);
+          st.font = face.font;
+          st.bold = flag("b") !== void 0 ? flag("b") === "1" : face.bold;
+          st.italic = flag("i") !== void 0 ? flag("i") === "1" : face.italic;
+        }
+        i = at === i + 2 ? i + 2 : at;
+      } else if (opts && next === "H") {
+        const [body, at] = codeBody(i + 2);
+        const v = Number.parseFloat(body);
+        if (Number.isFinite(v) && v > 0)
+          st = {
+            ...st,
+            height: /x$/i.test(body) ? (st.height ?? 1) * v : v / (opts.heightMm > 0 ? opts.heightMm : v)
+          };
+        i = at === i + 2 ? i + 2 : at;
+      } else if (opts && next === "C") {
+        const [body, at] = codeBody(i + 2);
+        st = { ...st, color: aciToHex(Number.parseInt(body, 10)) };
+        i = at === i + 2 ? i + 2 : at;
+      } else {
+        const end = text.indexOf(";", i + 1);
+        i = end === -1 ? i + 2 : end + 1;
+      }
+    }
+  }
+  return chunks;
+};
+var stripMtextCodes = (text) => scanMtext(text).map((c) => c.text).join("");
+var mtextWidthFactor = (text) => {
+  const m = /\\W([0-9.]+);/.exec(text);
+  const v = m ? Number(m[1]) : NaN;
+  return Number.isFinite(v) && v > 0 && v !== 1 ? v : void 0;
+};
+var mtextFontFlags = (text) => {
+  const m = /\\f[^|;]*((?:\|[a-z]\d+)*)/.exec(text);
+  if (!m) return {};
+  return {
+    .../\|b1/.test(m[1]) ? { bold: true } : {},
+    .../\|i1/.test(m[1]) ? { italic: true } : {}
+  };
+};
+var decodeControlCodes = (text) => text.replace(
+  /\^M\^J|\^[IJM ]|\r\n?/g,
+  (m) => m === "^I" ? "	" : m === "^ " ? "^" : "\n"
+);
+var cleanText = (raw, mtext) => decodeControlCodes(decodeTextEscapes(mtext ? stripMtextCodes(raw) : raw));
+var cleanRichText = (raw, heightMm) => {
+  let content = "";
+  const spans = [];
+  for (const c of scanMtext(raw, { heightMm })) {
+    const text = decodeControlCodes(decodeTextEscapes(c.text));
+    spans.push({
+      start: content.length,
+      end: content.length + text.length,
+      ...c.attrs
+    });
+    content += text;
+  }
+  return { content, spans: normalizeSpans(spans, content) };
+};
+var encodeStack = (s) => encodeMtext(s).replace(/[#/;]/g, (c) => `\\${c}`);
+var encodeRichMtext = (content, spans, face) => {
+  const base = parseFontFace(face);
+  let out = "";
+  let at = 0;
+  for (const s of normalizeSpans(spans, content)) {
+    out += encodeMtext(content.slice(at, s.start));
+    const fontCode = s.font !== void 0 || s.bold !== void 0 || s.italic !== void 0 ? `\\f${fontTypeface(resolveFont(s.font ?? base.font))}|b${s.bold ?? base.bold ? 1 : 0}|i${s.italic ?? base.italic ? 1 : 0};` : "";
+    const codes = fontCode + (s.height !== void 0 ? `\\H${s.height}x;` : "") + (s.color ? `\\C${nearestAci(s.color)};` : "") + (s.underline ? "\\L" : "");
+    const body = content.slice(s.start, s.end);
+    const text = s.script && !/[\n\t]/.test(body) ? s.script === "super" ? `\\S${encodeStack(body)}^;` : `\\S^${encodeStack(body)};` : encodeMtext(body);
+    out += codes || s.script ? `{${codes}${text}}` : text;
+    at = s.end;
+  }
+  return out + encodeMtext(content.slice(at));
+};
+
 // ../core/src/export/dxf/dxfExtras.ts
 import { Point, DxfObject } from "@tarikjabiri/dxf";
 var RAW_COLOR_BY_BLOCK = -1056964608;
@@ -7030,7 +8882,7 @@ var MultiLeaderEntity = class extends Point {
     dx.push(45, 1);
     dx.push(170, 1);
     dx.push(90, RAW_COLOR_BY_BLOCK);
-    dx.push(171, 1);
+    dx.push(171, a.attachment);
     dx.push(172, 1);
     dx.push(91, RAW_COLOR_NONE);
     dx.push(141, 1.5);
@@ -7167,6 +9019,130 @@ var MLeaderStyleObject = class extends DxfObject {
     dx.push(273, 9);
   }
 };
+var AcadTableEntity = class extends Point {
+  args;
+  constructor(args) {
+    super(args.position.x, args.position.y, 0);
+    this.args = args;
+    this.type = "ACAD_TABLE";
+    this.subclassMarker = "AcDbBlockReference";
+  }
+  dxfyChild(dx) {
+    const a = this.args;
+    dx.push(2, a.blockName);
+    dx.push(10, a.position.x);
+    dx.push(20, a.position.y);
+    dx.push(30, 0);
+    dx.push(100, "AcDbTable");
+    dx.push(280, 0);
+    dx.push(342, a.tableStyleHandle);
+    dx.push(343, a.blockRecordHandle);
+    dx.push(11, a.direction.x);
+    dx.push(21, a.direction.y);
+    dx.push(31, 0);
+    dx.push(90, 22);
+    dx.push(91, a.rowHeights.length);
+    dx.push(92, a.colWidths.length);
+    dx.push(93, 2);
+    dx.push(94, 0);
+    dx.push(95, 0);
+    dx.push(96, 0);
+    dx.push(281, 1);
+    for (const h of a.rowHeights) dx.push(141, h);
+    for (const w of a.colWidths) dx.push(142, w);
+    for (const c of a.cells) {
+      dx.push(171, 1);
+      dx.push(172, 0);
+      dx.push(173, c.merged ? 1 : 0);
+      dx.push(174, 0);
+      dx.push(175, c.cols);
+      dx.push(176, c.rows);
+      dx.push(91, 1);
+      dx.push(178, 0);
+      dx.push(145, 0);
+      dx.push(170, c.alignment);
+      dx.push(92, 0);
+      dx.push(301, "CELL_VALUE");
+      if (c.text === "") {
+        dx.push(93, 3);
+        dx.push(90, 0);
+      } else {
+        dx.push(93, 6);
+        dx.push(90, 4);
+        dx.push(1, c.text);
+      }
+      dx.push(94, 0);
+      dx.push(300, "");
+      dx.push(302, c.text);
+      dx.push(304, "ACVALUE_END");
+    }
+  }
+};
+var TableStyleObject = class extends DxfObject {
+  args;
+  constructor(args) {
+    super("TABLESTYLE");
+    this.args = args;
+  }
+  dxfy(dx) {
+    const a = this.args;
+    dx.push(0, "TABLESTYLE");
+    dx.push(5, this.handle);
+    dx.push(102, "{ACAD_REACTORS");
+    dx.push(330, a.dictionaryHandle);
+    dx.push(102, "}");
+    dx.push(330, a.dictionaryHandle);
+    dx.push(100, "AcDbTableStyle");
+    dx.push(280, 0);
+    dx.push(3, a.name);
+    dx.push(70, 0);
+    dx.push(71, 0);
+    dx.push(40, a.margin);
+    dx.push(41, a.margin);
+    dx.push(280, 0);
+    dx.push(281, 0);
+    for (const [height, alignment] of [
+      [a.textHeight, 2],
+      [a.textHeight, 5],
+      [a.textHeight, 5]
+    ]) {
+      dx.push(7, a.textStyleName);
+      dx.push(140, height);
+      dx.push(170, alignment);
+      dx.push(62, 0);
+      dx.push(63, 7);
+      dx.push(283, 0);
+      dx.push(90, 4);
+      dx.push(91, 0);
+      dx.push(1, "");
+      for (const [lw, vis, color] of [
+        [274, 284, 64],
+        [275, 285, 65],
+        [276, 286, 66],
+        [277, 287, 67],
+        [278, 288, 68],
+        [279, 289, 69]
+      ]) {
+        dx.push(lw, -2);
+        dx.push(vis, 1);
+        dx.push(color, 0);
+      }
+    }
+  }
+};
+var DXF_CLASSES = [
+  ["ACAD_TABLE", "AcDbTable", "ObjectDBX Classes", 1025, 1],
+  ["TABLESTYLE", "AcDbTableStyle", "ObjectDBX Classes", 4095, 0],
+  ["MULTILEADER", "AcDbMLeader", "ACDB_MLEADER_CLASS", 1025, 1],
+  ["MLEADERSTYLE", "AcDbMLeaderStyle", "ACDB_MLEADERSTYLE_CLASS", 4095, 0]
+];
+var classesSection = (content) => DXF_CLASSES.filter(([name]) => content.includes(`
+0
+${name}
+`)).map(
+  ([name, cpp, app, proxy, isEntity]) => [0, "CLASS", 1, name, 2, cpp, 3, app, 90, proxy, 91, 0, 280, 0, 281, isEntity].map((v) => `${v}
+`).join("")
+).join("");
 
 // ../core/src/export/dxf/hatchPattern.ts
 var ANSI31_BASE_SPACING = 3.175;
@@ -7187,17 +9163,35 @@ var mtextAttachment = (hAlign, vAlign) => {
   const col = hAlign === "left" ? 1 : hAlign === "center" ? 2 : 3;
   return row + col;
 };
-var escapeMtext = (s) => s.replace(/\\/g, "\\\\").replace(/\{/g, "\\{").replace(/\}/g, "\\}").replace(/\n/g, "\\P").replace(/\t/g, "^I");
-var dxfLineTypeName = (lineType) => {
+var dxfLineTypeName = (lineType, lineTypes) => {
   if (!lineType) return void 0;
-  const p = getLineType(lineType);
+  const p = resolveLineType(lineType, lineTypes);
   if (!p || p.dashesMm.length === 0) return void 0;
   return p.dxfName ?? p.name.toUpperCase();
 };
-var DIM_STYLE_NAME = "LINEA";
+var setLineWeight = (target, weight) => {
+  const emit = target.dxfy.bind(target);
+  target.dxfy = (dx) => {
+    const start = dx.lines.length;
+    emit(dx);
+    const lines = dx.lines;
+    for (let i = start; i < lines.length; i += 2)
+      if (lines[i] === 370) {
+        lines[i + 1] = weight;
+        return;
+      }
+    let markers = 0;
+    for (let i = start; i < lines.length; i += 2)
+      if (lines[i] === 100 && ++markers === 2) {
+        lines.splice(i, 0, 370, weight);
+        return;
+      }
+    lines.push(370, weight);
+  };
+};
 var optionsFor = (obj, ctx) => {
   const layer = ctx.doc.layers.find((l) => l.id === obj.layerId);
-  const dashed = (getLineType(obj.lineType ?? layer?.lineType ?? "")?.dashesMm.length ?? 0) > 0;
+  const dashed = (resolveLineType(obj.lineType ?? layer?.lineType ?? "", ctx.doc.lineTypes)?.dashesMm.length ?? 0) > 0;
   const lineTypeScale = (obj.lineTypeScale ?? 1) * (obj.lineWidth ?? layer?.lineWidth ?? 0.25);
   const trueColor = obj.color ? hexToTrueColor(obj.color) : null;
   return {
@@ -7206,7 +9200,7 @@ var optionsFor = (obj, ctx) => {
     // color (420) which wins wherever it is supported.
     ...obj.color ? { colorNumber: nearestAci(obj.color) } : {},
     ...trueColor !== null ? { trueColor: String(trueColor) } : {},
-    ...dxfLineTypeName(obj.lineType) ? { lineType: dxfLineTypeName(obj.lineType) } : {},
+    ...dxfLineTypeName(obj.lineType, ctx.doc.lineTypes) ? { lineType: dxfLineTypeName(obj.lineType, ctx.doc.lineTypes) } : {},
     ...dashed && lineTypeScale !== 1 ? { lineTypeScale } : {}
   };
 };
@@ -7251,28 +9245,87 @@ var addArrowhead = (space, tip, toward, size, type, opts) => {
       break;
   }
 };
-var textStyleFor2 = (ctx, font) => {
+var uniqueTableName = (taken, base) => {
+  let name = base;
+  for (let i = 2; taken.has(name.toUpperCase()); i++) name = `${base}_${i}`;
+  taken.add(name.toUpperCase());
+  return name;
+};
+var writableFace = (font) => {
   const def = resolveFont(font);
-  const { bold, italic } = parseFontFace(font);
-  const suffix = (bold ? "B" : "") + (italic ? "I" : "");
-  const key = fontFace(def.id, bold, italic);
-  let rec = ctx.textStyles.get(key);
-  if (!rec) {
-    const style = ctx.writer.document.tables.styleTable.addStyle(
-      `LINEA_${def.id.toUpperCase()}${suffix ? `_${suffix}` : ""}`
-    );
-    style.fontFileName = def.dxfFontFile;
-    rec = { name: style.name, handle: style.handle };
-    ctx.textStyles.set(key, rec);
-  }
+  const { font: bare, bold, italic } = parseFontFace(font);
+  const foreign = bare !== void 0 && bare !== "" && bare !== def.id;
+  const fontId = foreign ? bare : def.id;
+  return {
+    face: fontFace(fontId, bold, italic),
+    fontFile: foreign ? `${fontId}.ttf` : def.dxfFontFile,
+    fontId,
+    foreign
+  };
+};
+var addStyleRecord = (ctx, key, name, font, widthFactor = 1, fixedHeight = 0) => {
+  const { face, fontFile } = writableFace(font);
+  const table = ctx.writer.document.tables.styleTable;
+  const predefined = name.toUpperCase() === "STANDARD" && !ctx.styleNames.has("STANDARD") ? table.records.find((r) => r.name.toUpperCase() === "STANDARD") : void 0;
+  const style = predefined ?? table.addStyle(uniqueTableName(ctx.styleNames, name));
+  if (predefined) ctx.styleNames.add("STANDARD");
+  style.fontFileName = fontFile;
+  style.widthFactor = widthFactor;
+  style.fixedTextHeight = fixedHeight;
+  const rec = { name: style.name, handle: style.handle, face };
+  ctx.textStyles.set(key, rec);
   return rec;
 };
+var createDocTextStyles = (ctx) => {
+  for (const s of ctx.doc.textStyles)
+    addStyleRecord(
+      ctx,
+      `doc:${s.id}`,
+      sanitizeLayerName(s.name),
+      fontFace(s.font, s.bold, s.italic),
+      s.widthFactor,
+      s.textHeight
+    );
+};
+var dimTextStyleFor = (ctx, face, widthFactor) => {
+  const want = writableFace(face).face;
+  const own = ctx.doc.textStyles.find(
+    (s) => writableFace(fontFace(s.font, s.bold, s.italic)).face === want && Math.abs(s.widthFactor - widthFactor) < 1e-9
+  );
+  const ownRec = own && ctx.textStyles.get(`doc:${own.id}`);
+  if (ownRec) return ownRec;
+  if (Math.abs(widthFactor - 1) < 1e-9) return textStyleFor2(ctx, face);
+  const key = `${want}|w${widthFactor}`;
+  return ctx.textStyles.get(key) ?? addStyleRecord(
+    ctx,
+    key,
+    `${textStyleFor2(ctx, face).name}_W${Math.round(widthFactor * 100)}`,
+    face,
+    widthFactor
+  );
+};
+var textStyleFor2 = (ctx, font) => {
+  const { face, fontId, foreign } = writableFace(font);
+  const { bold, italic } = parseFontFace(face);
+  const suffix = (bold ? "B" : "") + (italic ? "I" : "");
+  return ctx.textStyles.get(face) ?? addStyleRecord(
+    ctx,
+    face,
+    `LINEA_${(foreign ? fontId.replace(/[^A-Za-z0-9_-]/g, "_") : fontId).toUpperCase()}${suffix ? `_${suffix}` : ""}`,
+    face
+  );
+};
+var textRecordFor = (ctx, obj, face) => {
+  const base = textStyleFor(obj, ctx.doc.textStyles);
+  const own = ctx.textStyles.get(`doc:${base.id}`);
+  return own && writableFace(fontFace(base.font, base.bold, base.italic)).face === writableFace(face).face ? own : textStyleFor2(ctx, face);
+};
 var addTextLines = (space, content, position, height, rotation, hAlign, vAlign, opts, measure, mtextWidth, fontOpts = {}) => {
-  const { styleName, font, widthFactor = 1 } = fontOpts;
+  const { styleName, font, widthFactor = 1, spans } = fontOpts;
   const m = boundMeasurer(measure, font, widthFactor);
   const block = textBlock(content, height, m, mtextWidth);
-  if (block.lines.length > 1 || mtextWidth !== void 0 && mtextWidth > 0 || content.includes("	")) {
-    const value = (widthFactor !== 1 ? `\\W${widthFactor};` : "") + escapeMtext(content);
+  if (block.lines.length > 1 || mtextWidth !== void 0 && mtextWidth > 0 || content.includes("	") || !!spans?.length) {
+    const value = (widthFactor !== 1 ? `\\W${widthFactor};` : "") + (spans?.length ? encodeRichMtext(content, spans, font) : encodeMtext(content));
     const mtext = space.addMText(v3(position), height, value, {
       rotation: rotation * RAD2DEG2,
       attachmentPoint: mtextAttachment(hAlign, vAlign),
@@ -7283,7 +9336,8 @@ var addTextLines = (space, content, position, height, rotation, hAlign, vAlign,
     return;
   }
   const down = scale(perp(fromAngle(rotation)), -1);
-  block.lines.forEach((line, i) => {
+  block.lines.forEach((raw, i) => {
+    const line = raw.replace(/\r/g, "");
     if (!line) return;
     const anchor = add(position, scale(down, i * block.lineHeight));
     const text = space.addText(v3(anchor), height, line, {
@@ -7298,11 +9352,94 @@ var addTextLines = (space, content, position, height, rotation, hAlign, vAlign,
     if (styleName) text.textStyle = styleName;
   });
 };
+var documentPattern = (ctx, name) => ctx.doc.hatchPatterns.find(
+  (p) => hatchPatternKey(p.name) === hatchPatternKey(name)
+);
+var injectHatchPatternLines = (content, ctx) => {
+  if (!content.includes("\n0\nHATCH\n")) return content;
+  const out = [];
+  let pos = 0;
+  for (; ; ) {
+    const start = content.indexOf("\n0\nHATCH\n", pos);
+    if (start === -1) break;
+    const rest = content.slice(start + 8);
+    const m = /\n0\n(?=[A-Z][A-Z0-9_]*\n)/.exec(rest);
+    const end = m ? start + 8 + m.index : content.length;
+    let record = content.slice(start, end);
+    const handle = /\n5\n([0-9A-Fa-f]+)\n/.exec(record)?.[1];
+    const bodyAt = record.indexOf("\nAcDbHatch\n");
+    const body = bodyAt === -1 ? record : record.slice(bodyAt);
+    const name = /\n2\n([^\n]*)\n/.exec(body)?.[1];
+    const anchor = handle ? ctx.hatchOrigins.get(handle) : void 0;
+    const own = name ? documentPattern(ctx, name) : void 0;
+    const pat = own ?? (name ? resolveHatchPattern(name, []) : void 0);
+    const m77 = pat ? /\n77\n[^\n]*\n/.exec(body) : null;
+    if (pat && m77 && bodyAt !== -1) {
+      const angle2 = Number(/\n52\n([^\n]*)\n/.exec(body)?.[1] ?? 0) * Math.PI / 180;
+      const scale3 = Number(/\n41\n([^\n]*)\n/.exec(body)?.[1] ?? 1) || 1;
+      const cos = Math.cos(angle2);
+      const sin = Math.sin(angle2);
+      const bake = (x, y) => [
+        (cos * x - sin * y) * scale3,
+        (sin * x + cos * y) * scale3
+      ];
+      const lines = pat.lines.map((l) => {
+        const [bx, by] = bake(l.origin.x, l.origin.y);
+        const ox = bx + (anchor?.x ?? 0);
+        const oy = by + (anchor?.y ?? 0);
+        const bakedAngle = l.angle + angle2;
+        const dx = (Math.cos(bakedAngle) * l.deltaX - Math.sin(bakedAngle) * l.deltaY) * scale3;
+        const dy = (Math.sin(bakedAngle) * l.deltaX + Math.cos(bakedAngle) * l.deltaY) * scale3;
+        const dashes = l.dashesMm ?? [];
+        return `53
+${(l.angle * 180 / Math.PI + angle2 * 180 / Math.PI).toFixed(6)}
+43
+${ox.toFixed(6)}
+44
+${oy.toFixed(6)}
+45
+${dx.toFixed(6)}
+46
+${dy.toFixed(6)}
+79
+${dashes.length}
+` + dashes.map((d) => `49
+${(d * scale3).toFixed(6)}
+`).join("");
+      }).join("");
+      const at = bodyAt + m77.index + m77[0].length;
+      const tail = record.slice(at);
+      const writerBlock = tail.startsWith("78\n") ? (() => {
+        const stop = /\n(?:47|98)\n/.exec(tail);
+        return stop ? stop.index + 1 : tail.length;
+      })() : 0;
+      record = record.slice(0, at) + `78
+${pat.lines.length}
+` + lines + tail.slice(writerBlock);
+      if (own) record = record.replace(/\n76\n1\n/, "\n76\n2\n");
+      else if (name && name !== pat.name.toUpperCase()) {
+        const nameAt = record.indexOf(`
+2
+${name}
+`, bodyAt);
+        if (nameAt !== -1)
+          record = record.slice(0, nameAt) + `
+2
+${pat.name.toUpperCase()}
+` + record.slice(nameAt + name.length + 4);
+      }
+    }
+    out.push(content.slice(pos, start), record);
+    pos = end;
+  }
+  out.push(content.slice(pos));
+  return out.join("");
+};
 var dxfPatternName = (name) => {
   const key = name.toUpperCase().replace(/-/g, "_").replace(/\./g, "_");
   return HatchPredefinedPatterns[key] ?? HatchPredefinedPatterns.ANSI31;
 };
-var writeHatch = (space, obj, opts) => {
+var writeHatch = (space, obj, opts, ctx) => {
   if (obj.type !== "hatch") return;
   if (obj.fill.kind === "gradient") {
     opts = {
@@ -7326,9 +9463,11 @@ var writeHatch = (space, obj, opts) => {
     obj.fill.kind === "solid" || obj.fill.kind === "gradient" ? pattern({ name: HatchPredefinedPatterns.SOLID }) : obj.fill.kind === "pattern" ? (
       // The curated library names are the standard predefined patterns, so
       // this is a direct mapping; fill.angle/scale ARE the DXF rotation
-      // (code 52) and scale (code 41).
+      // (code 52) and scale (code 41). A DOCUMENT pattern goes out under
+      // its own name; its definition lines are spliced in afterwards
+      // (injectHatchPatternLines — the writer has no custom patterns).
       pattern({
-        name: dxfPatternName(obj.fill.name),
+        name: documentPattern(ctx, obj.fill.name) ? obj.fill.name.toUpperCase() : dxfPatternName(obj.fill.name),
         angle: obj.fill.angle * RAD2DEG2,
         scale: obj.fill.scale * obj.scale
       })
@@ -7339,10 +9478,12 @@ var writeHatch = (space, obj, opts) => {
       scale: obj.fill.spacing * obj.scale / ANSI31_BASE_SPACING
     })
   );
-  space.addHatch(boundary, fill, opts);
+  const written = space.addHatch(boundary, fill, opts);
+  if (obj.fill.kind === "pattern" && obj.fill.origin)
+    ctx.hatchOrigins.set(written.handle, obj.fill.origin);
 };
 var writeDimensionGeometry = (target, geom, opts, ctx) => {
-  for (const seg of [...geom.extensionLines, ...geom.dimLines])
+  for (const seg of [...geom.extensionLines, ...geom.dimLines, ...geom.leaders])
     target.addLine(v3(seg.a), v3(seg.b), opts);
   if (geom.dimArc)
     target.addArc(
@@ -7361,7 +9502,7 @@ var writeDimensionGeometry = (target, geom, opts, ctx) => {
       geom.arrowType,
       opts
     );
-  for (const text of geom.texts)
+  for (const text of geom.labels)
     addTextLines(
       target,
       text.content,
@@ -7376,13 +9517,43 @@ var writeDimensionGeometry = (target, geom, opts, ctx) => {
       {
         styleName: textStyleFor2(ctx, text.font).name,
         font: text.font,
-        widthFactor: text.widthFactor
+        widthFactor: text.widthFactor,
+        spans: text.spans
       }
     );
 };
-var dimStyleFor2 = (ctx, style) => {
+var addDimStyleRecord = (ctx, name, style) => {
+  const table = ctx.writer.document.tables.dimStyleTable;
+  const predefined = name.toUpperCase() === "STANDARD" && !ctx.dimStyleNames.has("STANDARD") ? table.records.find((r) => r.name.toUpperCase() === "STANDARD") : void 0;
+  const rec = predefined ?? ctx.writer.addDimStyle(uniqueTableName(ctx.dimStyleNames, name));
+  if (predefined) ctx.dimStyleNames.add("STANDARD");
   const scale3 = style.scale ?? 1;
+  rec.DIMASZ = style.arrowSize;
+  rec.DIMEXO = style.extensionOffset;
+  rec.DIMEXE = style.extensionOvershoot;
+  rec.DIMTXT = style.textHeight;
+  rec.DIMGAP = style.textOffset;
+  rec.DIMDEC = style.precision;
+  if (scale3 !== 1) rec.DIMSCALE = scale3;
+  if (style.arrowType !== "filled") rec.DIMBLK = DIMBLK_NAMES[style.arrowType];
+  rec.DIMTXSTY = dimTextStyleFor(
+    ctx,
+    dimFontFace(style),
+    style.widthFactor
+  ).handle;
+  return rec.name;
+};
+var createDocDimStyles = (ctx) => {
+  for (const s of ctx.doc.dimStyles)
+    ctx.dimStyleRecords.set(
+      s.id,
+      addDimStyleRecord(ctx, sanitizeLayerName(s.name), s)
+    );
+};
+var dimOverrideStyleFor = (ctx, base, style) => {
+  const baseName = ctx.dimStyleRecords.get(base.id) ?? ctx.dimStyleRecords.values().next().value ?? "Standard";
   const key = JSON.stringify([
+    baseName,
     style.arrowSize,
     style.arrowType,
     style.extensionOffset,
@@ -7391,21 +9562,13 @@ var dimStyleFor2 = (ctx, style) => {
     style.textOffset,
     style.precision,
     dimFontFace(style),
-    scale3
+    style.scale ?? 1
   ]);
-  let name = ctx.dimStyles.get(key);
-  if (name) return name;
-  name = ctx.dimStyles.size === 0 ? DIM_STYLE_NAME : `${DIM_STYLE_NAME}_${ctx.dimStyles.size}`;
-  const rec = ctx.writer.addDimStyle(name);
-  rec.DIMASZ = style.arrowSize;
-  rec.DIMEXO = style.extensionOffset;
-  rec.DIMEXE = style.extensionOvershoot;
-  rec.DIMTXT = style.textHeight;
-  rec.DIMGAP = style.textOffset;
-  rec.DIMDEC = style.precision;
-  if (scale3 !== 1) rec.DIMSCALE = scale3;
-  if (style.arrowType !== "filled") rec.DIMBLK = DIMBLK_NAMES[style.arrowType];
-  rec.DIMTXSTY = textStyleFor2(ctx, dimFontFace(style)).handle;
+  const cached = ctx.dimStyles.get(key);
+  if (cached) return cached;
+  const n = (ctx.dimOverrideCounts.get(baseName) ?? 0) + 1;
+  ctx.dimOverrideCounts.set(baseName, n);
+  const name = addDimStyleRecord(ctx, `${baseName}_${n}`, style);
   ctx.dimStyles.set(key, name);
   return name;
 };
@@ -7431,26 +9594,38 @@ var writeDimension = (space, obj, opts, ctx) => {
   const blockName = `LINEA_DIM_${ctx.dimBlockCount++}`;
   const block = ctx.writer.addBlock(blockName);
   writeDimensionGeometry(block, geom, opts, ctx);
-  const styleName = obj.styleId || obj.styleOverride || obj.scale !== 1 ? dimStyleFor2(ctx, {
-    ...dimStyleFor(obj, ctx.doc.dimStyles),
+  const baseStyle = dimStyleFor(obj, ctx.doc.dimStyles);
+  const hasOverride = obj.styleOverride !== void 0 && Object.values(obj.styleOverride).some((v) => v !== void 0);
+  const styleName = hasOverride || obj.scale !== 1 ? dimOverrideStyleFor(ctx, baseStyle, {
+    ...baseStyle,
     ...obj.styleOverride,
     scale: obj.scale
-  }) : DIM_STYLE_NAME;
+  }) : ctx.dimStyleRecords.get(baseStyle.id) ?? dimOverrideStyleFor(ctx, baseStyle, baseStyle);
+  const content = obj.labels[0]?.content;
+  const precision = {
+    ...dimStyleFor(obj, ctx.doc.dimStyles),
+    ...obj.styleOverride
+  }.precision;
+  const text = content === void 0 ? void 0 : content.split(DIM_DEFAULT_CONTENT[obj.kind]).join("<>").split(DIM_VALUE_TOKEN).join(
+    obj.kind === "radial" || obj.kind === "diameter" ? formatDimValue(geom.value, precision) : "<>"
+  );
   const dimOpts = {
     blockName,
-    text: geom.texts[0]?.content,
+    ...text === void 0 ? {} : { text },
     styleName,
     // Text middle point (group 11) — without it a regenerating CAD places
     // the value at the style default instead of where the user saw it.
-    ...geom.texts[0] ? { middlePoint: v3(geom.texts[0].anchor) } : {},
+    ...geom.labels[0] ? { middlePoint: v3(geom.labels[0].anchor) } : {},
     ...opts
   };
   switch (obj.kind) {
     case "angular": {
       const [vertex, a, b] = obj.points;
+      const [frame] = dimensionLabelFrames(obj);
       space.addAngularPointsDim(v3(vertex), v3(a), v3(b), {
         ...dimOpts,
-        definitionPoint: v3(add(vertex, obj.offset))
+        // A point on the arc (its middle): the radius and which arc.
+        definitionPoint: v3(frame.toWorld((frame.s0 + frame.s1) / 2, 0))
       });
       break;
     }
@@ -7466,8 +9641,7 @@ var writeDimension = (space, obj, opts, ctx) => {
     }
     case "linear": {
       const [p1, p2] = obj.points;
-      const upLen = Math.hypot(obj.offset.x, obj.offset.y);
-      const u = upLen > 1e-9 ? perp(scale(obj.offset, 1 / upLen)) : norm(sub(p2, p1));
+      const { u } = linearAxis(obj);
       space.addLinearDim(v3(p1), v3(p2), {
         ...dimOpts,
         definitionPoint: v3(geom.dimLines[0].b),
@@ -7478,7 +9652,90 @@ var writeDimension = (space, obj, opts, ctx) => {
   }
   return true;
 };
+var tableCellMtext = (text, ctx) => {
+  if (text.content.trim() === "") return "";
+  const eff = resolveTextStyle(text, ctx.doc.textStyles);
+  const face = fontFace(eff.font, eff.bold, eff.italic);
+  const { font, bold, italic } = parseFontFace(face);
+  const height = eff.textHeight * text.scale;
+  const body = text.spans?.length ? encodeRichMtext(text.content, text.spans, face) : encodeMtext(text.content);
+  return `{\\f${fontTypeface(resolveFont(font))}|b${bold ? 1 : 0}|i${italic ? 1 : 0}|c0|p34;\\H${+height.toFixed(6)};` + (eff.widthFactor !== 1 ? `\\W${eff.widthFactor};` : "") + `${body}}`;
+};
+var attachmentOf = (hAlign, vAlign) => (vAlign === "top" ? 0 : vAlign === "center" ? 3 : 6) + (hAlign === "left" ? 1 : hAlign === "center" ? 2 : 3);
+var writeNativeTable = (space, obj, ctx) => {
+  const layout = tableLayout(obj, ctx.doc.textStyles);
+  const name = `*T${++ctx.tableBlockCount}`;
+  const block = ctx.writer.document.blocks.addBlock(
+    name,
+    ctx.writer.document.objects,
+    false
+  );
+  block.flags = 1;
+  const before = ctx.exported;
+  const origin = { x: 0, y: 0 };
+  for (const child of layout.children)
+    writeObject(
+      block,
+      rotateObject(
+        translateObject(child, { x: -obj.position.x, y: -obj.position.y }),
+        origin,
+        -obj.rotation
+      ),
+      ctx
+    );
+  ctx.exported = before;
+  const blockRecordHandle = ctx.writer.document.tables.blockRecordTable.records.find(
+    (r) => r.name === name
+  )?.handle ?? "0";
+  const rows = obj.rows.length;
+  const cols = obj.columns.length;
+  const anchorAt = new Map(
+    layout.anchors.map((a) => [`${a.row}:${a.col}`, a])
+  );
+  const cells = [];
+  for (let r = 0; r < rows; r++)
+    for (let c = 0; c < cols; c++) {
+      const a = anchorAt.get(`${r}:${c}`);
+      if (!a) {
+        cells.push({ text: "", cols: 1, rows: 1, merged: true, alignment: 1 });
+        continue;
+      }
+      const { text } = tableCellFrame(obj, ctx.doc.textStyles, r, c);
+      cells.push({
+        text: tableCellMtext(text, ctx),
+        cols: a.cols,
+        rows: a.rows,
+        merged: false,
+        alignment: attachmentOf(text.hAlign, text.vAlign)
+      });
+    }
+  const diffs = (xs) => xs.slice(1).map((x, i) => x - xs[i]);
+  const entity = new AcadTableEntity({
+    blockName: name,
+    blockRecordHandle,
+    tableStyleHandle: ctx.tableStyleHandle,
+    position: obj.position,
+    direction: { x: Math.cos(obj.rotation), y: Math.sin(obj.rotation) },
+    rowHeights: diffs(layout.rowY),
+    colWidths: diffs(layout.colX),
+    cells
+  });
+  entity.layerName = ctx.layerNames.get(obj.layerId) ?? "0";
+  if (obj.color) {
+    entity.colorNumber = nearestAci(obj.color);
+    const tc = hexToTrueColor(obj.color);
+    if (tc !== null) entity.trueColor = String(tc);
+  }
+  space.addEntity(entity);
+};
 var writeObject = (space, obj, ctx) => {
+  const before = space.entities.length;
+  writeObjectEntities(space, obj, ctx);
+  if (obj.lineWidth !== void 0)
+    for (const entity of space.entities.slice(before))
+      setLineWeight(entity, mmToLineWeight(obj.lineWidth));
+};
+var writeObjectEntities = (space, obj, ctx) => {
   const opts = optionsFor(obj, ctx);
   switch (obj.type) {
     case "line":
@@ -7523,12 +9780,27 @@ var writeObject = (space, obj, ctx) => {
       );
       break;
     case "hatch":
-      writeHatch(space, obj, opts);
+      writeHatch(space, obj, opts, ctx);
       break;
     case "text": {
       const eff = resolveTextStyle(obj, ctx.doc.textStyles);
       const { arrowSize, arrowType } = eff;
       const face = fontFace(eff.font, eff.bold, eff.italic);
+      for (const part of textFrameGeometry(
+        obj,
+        ctx.measure,
+        ctx.doc.textStyles
+      ))
+        space.addLWPolyline(
+          part.points.map((v) => ({
+            point: { x: v.x, y: v.y },
+            bulge: v.bulge
+          })),
+          {
+            flags: part.closed ? LWPolylineFlags.Closed : LWPolylineFlags.None,
+            ...opts
+          }
+        );
       if (obj.leaderLines.length > 0 && ctx.explodeLeaders) {
         for (const line of obj.leaderLines) {
           space.addLWPolyline(
@@ -7562,13 +9834,15 @@ var writeObject = (space, obj, ctx) => {
           junction,
           doglegDirection: { x: toText.x / gap, y: toText.y / gap },
           doglegLength: gap,
-          content: escapeMtext(obj.content),
+          content: obj.spans?.length ? encodeRichMtext(obj.content, obj.spans, face) : encodeMtext(obj.content),
           textHeight: eff.textHeight,
           arrowSize,
           overallScale: obj.scale,
           textLocation: obj.position,
+          // Model alignment → MTEXT-style attachment point (1–9).
+          attachment: 1 + 3 * ["top", "center", "bottom"].indexOf(obj.vAlign) + ["left", "center", "right"].indexOf(obj.hAlign),
           styleHandle: ctx.mleaderStyleHandle,
-          textStyleHandle: textStyleFor2(ctx, face).handle,
+          textStyleHandle: textRecordFor(ctx, obj, face).handle,
           lineTypeHandle: ctx.lineTypeHandle
         });
         entity.layerName = ctx.layerNames.get(obj.layerId) ?? "0";
@@ -7592,9 +9866,10 @@ var writeObject = (space, obj, ctx) => {
         ctx.measure,
         obj.width === void 0 ? void 0 : obj.width * obj.scale,
         {
-          styleName: textStyleFor2(ctx, face).name,
+          styleName: textRecordFor(ctx, obj, face).name,
           font: face,
-          widthFactor: eff.widthFactor
+          widthFactor: eff.widthFactor,
+          spans: obj.spans
         }
       );
       break;
@@ -7606,6 +9881,10 @@ var writeObject = (space, obj, ctx) => {
       }
       break;
     case "block": {
+      if (ctx.blockChain.includes(obj.definitionId)) {
+        skip(ctx, "block");
+        return;
+      }
       const children = getEvaluatedWorldChildren(
         obj,
         ctx.doc.blockDefinitions,
@@ -7617,14 +9896,23 @@ var writeObject = (space, obj, ctx) => {
         return;
       }
       const before = ctx.exported;
-      for (const child of children) {
-        if (child.type === "block" || child.type === "viewport") continue;
-        writeObject(space, child, ctx);
+      ctx.blockChain.push(obj.definitionId);
+      try {
+        for (const child of children) {
+          if (child.type === "viewport") continue;
+          writeObject(space, child, ctx);
+        }
+      } finally {
+        ctx.blockChain.pop();
       }
       ctx.exported = before;
       break;
     }
     case "table": {
+      if (!ctx.explodeTables) {
+        writeNativeTable(space, obj, ctx);
+        break;
+      }
       const before = ctx.exported;
       for (const child of tableLayout(obj, ctx.doc.textStyles).children)
         writeObject(space, child, ctx);
@@ -7634,9 +9922,6 @@ var writeObject = (space, obj, ctx) => {
     case "viewport":
       skip(ctx, "viewport");
       return;
-    case "image":
-      skip(ctx, "image");
-      return;
     case "reference": {
       if (obj.hidden || obj.format !== "dxf" && obj.format !== "dwg" || obj.source.kind !== "path") {
         skip(ctx, "reference");
@@ -7690,10 +9975,22 @@ var writeViewport = (space, vp, id, ctx) => {
   );
   ctx.exported++;
 };
+var DWG_DXF_OPTIONS = {
+  explodeLeaders: true,
+  explodeTables: true
+};
 var buildDxf = (doc, measure, options = {}) => {
   const writer = new DxfWriter();
   writer.setUnits(Units.Millimeters);
   const emittedLtypes = /* @__PURE__ */ new Set();
+  for (const t of doc.lineTypes) {
+    if (t.dashesMm.length === 0) continue;
+    const dxfName = t.name.toUpperCase();
+    if (emittedLtypes.has(dxfName)) continue;
+    emittedLtypes.add(dxfName);
+    const descriptive = (t.description ?? t.name).replace(/[^\x20-\x7e]/g, "").slice(0, 47);
+    writer.addLType(dxfName, descriptive, t.dashesMm);
+  }
   for (const p of LINE_TYPE_DEFS) {
     if (p.dashesMm.length === 0) continue;
     const dxfName = p.dxfName ?? p.name.toUpperCase();
@@ -7715,18 +10012,22 @@ var buildDxf = (doc, measure, options = {}) => {
     layerNames.set(layer.id, name);
     if (name === "0") {
       const zero = writer.layer("0");
-      if (zero) layerRecords.set(layer.id, zero);
+      if (zero) {
+        setLineWeight(zero, mmToLineWeight(layer.lineWidth));
+        layerRecords.set(layer.id, zero);
+      }
       continue;
     }
     const flags = (layer.visible ? 0 : LayerFlags.Frozen) | (layer.locked ? LayerFlags.Locked : 0);
     const record = writer.addLayer(
       name,
       nearestAci(layer.color),
-      dxfLineTypeName(layer.lineType) ?? "Continuous",
+      dxfLineTypeName(layer.lineType, doc.lineTypes) ?? "Continuous",
       flags || void 0
     );
     const tc = hexToTrueColor(layer.color);
     if (tc !== null) record.trueColor = tc;
+    setLineWeight(record, mmToLineWeight(layer.lineWidth));
     layerRecords.set(layer.id, record);
   }
   const textStyleHandle = writer.document.tables.styleTable.records.find((r) => r.name === "Standard")?.handle ?? "0";
@@ -7747,6 +10048,22 @@ var buildDxf = (doc, measure, options = {}) => {
   );
   mleaderStyle.ownerObjecthandle = mleaderDict.handle;
   mleaderDict.addEntryObject("Standard", mleaderStyle.handle);
+  const tableStyleDict = writer.document.objects.addDictionary();
+  writer.document.objects.addEntryToRoot(
+    "ACAD_TABLESTYLE",
+    tableStyleDict.handle
+  );
+  const tableStyle = writer.document.objects.addObject(
+    new TableStyleObject({
+      name: "Standard",
+      textStyleName: "Standard",
+      textHeight: doc.textStyles[0]?.textHeight ?? 2.5,
+      margin: 1.5,
+      dictionaryHandle: tableStyleDict.handle
+    })
+  );
+  tableStyle.ownerObjecthandle = tableStyleDict.handle;
+  tableStyleDict.addEntryObject("Standard", tableStyle.handle);
   const ctx = {
     doc,
     measure,
@@ -7757,14 +10074,24 @@ var buildDxf = (doc, measure, options = {}) => {
     exported: 0,
     dimBlockCount: 0,
     xrefBlocks: /* @__PURE__ */ new Map(),
+    blockChain: [],
     explodeLeaders: options.explodeLeaders ?? false,
+    explodeTables: options.explodeTables ?? false,
+    tableStyleHandle: tableStyle.handle,
+    tableBlockCount: 0,
     mleaderStyleHandle: mleaderStyle.handle,
     textStyleHandle,
     lineTypeHandle,
     textStyles: /* @__PURE__ */ new Map(),
-    dimStyles: /* @__PURE__ */ new Map()
+    styleNames: /* @__PURE__ */ new Set(),
+    dimStyleRecords: /* @__PURE__ */ new Map(),
+    dimStyleNames: /* @__PURE__ */ new Set(),
+    dimStyles: /* @__PURE__ */ new Map(),
+    dimOverrideCounts: /* @__PURE__ */ new Map(),
+    hatchOrigins: /* @__PURE__ */ new Map()
   };
-  dimStyleFor2(ctx, doc.dimStyles[0]);
+  createDocTextStyles(ctx);
+  createDocDimStyles(ctx);
   for (const obj of doc.objects)
     writeObject(writer.document.blocks.modelSpace, obj, ctx);
   const layoutRecords = [];
@@ -7836,16 +10163,35 @@ var buildDxf = (doc, measure, options = {}) => {
     );
     if (record) record.layoutObject = layoutObj.handle;
   }
+  const content = injectHatchPatternLines(
+    injectStyleTypefaces(writer.stringify(), ctx.textStyles),
+    ctx
+  );
   return {
-    content: injectStyleTypefaces(writer.stringify(), ctx.textStyles),
+    // The writer's CLASSES section is always empty: declare the non-fixed
+    // types this file uses (AutoCAD expects them declared).
+    content: content.replace(
+      "\n0\nSECTION\n2\nCLASSES\n0\nENDSEC\n",
+      `
+0
+SECTION
+2
+CLASSES
+${classesSection(content)}0
+ENDSEC
+`
+    ),
     exported: ctx.exported,
     skipped: ctx.skipped
   };
 };
 var injectStyleTypefaces = (content, textStyles) => {
   let out = content;
-  for (const [fontId, rec] of textStyles) {
-    const typeface = fontTypeface(resolveFont(fontId));
+  for (const rec of textStyles.values()) {
+    const fontId = rec.face;
+    const { font: bare } = parseFontFace(fontId);
+    const def = resolveFont(fontId);
+    const typeface = bare !== void 0 && bare !== def.id ? bare : fontTypeface(def);
     const { bold, italic } = parseFontFace(fontId);
     const flags = (italic ? 16777216 : 0) | (bold ? 33554432 : 0);
     const marker = `
@@ -7875,6 +10221,7 @@ export {
   add,
   sub,
   scale,
+  dot,
   len,
   dist,
   norm,
@@ -7885,8 +10232,6 @@ export {
   normAngle,
   closestPointOnSegment,
   remapBlockInputRefs,
-  imageCenter,
-  imageCorners,
   translateObject,
   rotateObject,
   scaleObjectUniform,
@@ -7894,10 +10239,12 @@ export {
   Vec2Schema,
   ColorSchema,
   FONTS,
+  fontFace,
   parseFontFace,
   REAL_FACES,
   realFace,
   resolveFont,
+  fontFromDxfStyle,
   TextStyleSchema,
   DEFAULT_TEXT_STYLE,
   textStyleFor,
@@ -7916,6 +10263,8 @@ export {
   approximateTextMeasurer,
   lineSegments,
   textBlock,
+  normalizeSpans,
+  richTextBlock,
   textHeight,
   textArrowSize,
   textArrowType,
@@ -7923,10 +10272,34 @@ export {
   textBoxCorners,
   textFrameGeometry,
   tableLayout,
+  hashAsset,
+  dataUrlBytes,
+  bytesToDataUrl,
+  imagePixelSize,
+  PX_TO_MM,
+  embeddedAssetId,
+  matIdentity,
+  matMultiply,
+  matApply,
+  signedArcSweep,
+  arcToBeziers,
+  computeHatchLines,
+  ellipseArcToBeziers,
+  getHatchPattern,
+  MAX_HATCH_SEGMENTS,
+  estimatePatternSegments,
+  computePatternGeometry,
+  HatchPatternSchema,
+  hatchPatternKey,
+  resolveHatchPattern,
   getLineType,
   renderDashes,
+  LineTypeSchema,
+  lineTypeKey,
+  resolveLineType,
   CURRENT_DOCUMENT_VERSION,
   dimensionRawToOffset,
+  dimensionRawToLabels,
   migrateDocument,
   HEX_COLOR,
   valueParams,
@@ -7935,6 +10308,7 @@ export {
   ensureScriptTranspiler,
   executeScriptModule,
   scriptTranspilerReady,
+  BlockChildSchema,
   expandWithBlockDependents,
   invalidateBlockCache,
   getBlockError,
@@ -7949,9 +10323,18 @@ export {
   testBlockDefinition,
   getEvaluatedWorldChildren,
   ANSI31_BASE_SPACING,
+  linearAxis,
   dimensionGeometry,
+  hexToRgb,
   rgbToHex,
   aciToHex,
+  lineWeightToMm,
+  decodeTextEscapes,
+  mtextWidthFactor,
+  mtextFontFlags,
+  cleanText,
+  cleanRichText,
+  DWG_DXF_OPTIONS,
   buildDxf
 };
-//# sourceMappingURL=chunk-NCNZ7A6M.js.map
+//# sourceMappingURL=chunk-BQCSFVAF.js.map