@chanmeng666/archlang 0.5.0 → 0.7.0

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\r\n/** ArchLang CLI: `arch compile <in.arch> [-o out.svg]`, `arch watch <in.arch>`. */\r\n\r\nimport { readFileSync, writeFileSync, watchFile } from \"node:fs\";\r\nimport { resolve } from \"node:path\";\r\nimport { compile, formatDiagnostic } from \"./index.js\";\r\n\r\nfunction compileFile(input: string, output: string, width?: number): boolean {\r\n  let source: string;\r\n  try {\r\n    source = readFileSync(input, \"utf8\");\r\n  } catch {\r\n    process.stderr.write(`error: cannot read ${input}\\n`);\r\n    return false;\r\n  }\r\n  const { svg, diagnostics } = compile(source, { width, noCache: true });\r\n  for (const d of diagnostics) {\r\n    process.stderr.write(`${formatDiagnostic(source, d)}\\n\\n`);\r\n  }\r\n  const errorCount = diagnostics.filter((d) => d.severity === \"error\").length;\r\n  if (errorCount > 0) {\r\n    process.stderr.write(`✗ compilation failed (${errorCount} error${errorCount > 1 ? \"s\" : \"\"})\\n`);\r\n    return false;\r\n  }\r\n  writeFileSync(output, svg, \"utf8\");\r\n  process.stdout.write(`✓ ${input} → ${output} (${svg.length} bytes)\\n`);\r\n  return true;\r\n}\r\n\r\nfunction parseArgs(argv: string[]): { _: string[]; o?: string; width?: number } {\r\n  const res: { _: string[]; o?: string; width?: number } = { _: [] };\r\n  for (let i = 0; i < argv.length; i++) {\r\n    const a = argv[i];\r\n    if (a === \"-o\" || a === \"--out\") res.o = argv[++i];\r\n    else if (a === \"-w\" || a === \"--width\") res.width = Number(argv[++i]);\r\n    else res._.push(a);\r\n  }\r\n  return res;\r\n}\r\n\r\nfunction defaultOut(input: string): string {\r\n  return input.replace(/\\.arch$/i, \"\") + \".svg\";\r\n}\r\n\r\nfunction main(): void {\r\n  const [cmd, ...rest] = process.argv.slice(2);\r\n  const args = parseArgs(rest);\r\n\r\n  if (!cmd || cmd === \"help\" || cmd === \"--help\" || cmd === \"-h\") {\r\n    process.stdout.write(\r\n      `arch — ArchLang compiler\\n\\n` +\r\n        `Usage:\\n` +\r\n        `  arch compile <in.arch> [-o out.svg] [-w width]\\n` +\r\n        `  arch watch   <in.arch> [-o out.svg] [-w width]\\n`,\r\n    );\r\n    process.exit(cmd ? 0 : 1);\r\n  }\r\n\r\n  const input = args._[0];\r\n  if (!input) {\r\n    process.stderr.write(\"error: missing input file\\n\");\r\n    process.exit(1);\r\n  }\r\n  const output = args.o ? resolve(args.o) : defaultOut(resolve(input));\r\n\r\n  if (cmd === \"compile\") {\r\n    process.exit(compileFile(resolve(input), output, args.width) ? 0 : 1);\r\n  } else if (cmd === \"watch\") {\r\n    compileFile(resolve(input), output, args.width);\r\n    process.stdout.write(`watching ${input} … (Ctrl+C to stop)\\n`);\r\n    watchFile(resolve(input), { interval: 300 }, () => compileFile(resolve(input), output, args.width));\r\n  } else {\r\n    process.stderr.write(`error: unknown command \"${cmd}\"\\n`);\r\n    process.exit(1);\r\n  }\r\n}\r\n\r\nmain();\r\n"],"mappings":";;;;;;;AAGA,SAAS,cAAc,eAAe,iBAAiB;AACvD,SAAS,eAAe;AAGxB,SAAS,YAAY,OAAe,QAAgB,OAAyB;AAC3E,MAAI;AACJ,MAAI;AACF,aAAS,aAAa,OAAO,MAAM;AAAA,EACrC,QAAQ;AACN,YAAQ,OAAO,MAAM,sBAAsB,KAAK;AAAA,CAAI;AACpD,WAAO;AAAA,EACT;AACA,QAAM,EAAE,KAAK,YAAY,IAAI,QAAQ,QAAQ,EAAE,OAAO,SAAS,KAAK,CAAC;AACrE,aAAW,KAAK,aAAa;AAC3B,YAAQ,OAAO,MAAM,GAAG,iBAAiB,QAAQ,CAAC,CAAC;AAAA;AAAA,CAAM;AAAA,EAC3D;AACA,QAAM,aAAa,YAAY,OAAO,CAAC,MAAM,EAAE,aAAa,OAAO,EAAE;AACrE,MAAI,aAAa,GAAG;AAClB,YAAQ,OAAO,MAAM,8BAAyB,UAAU,SAAS,aAAa,IAAI,MAAM,EAAE;AAAA,CAAK;AAC/F,WAAO;AAAA,EACT;AACA,gBAAc,QAAQ,KAAK,MAAM;AACjC,UAAQ,OAAO,MAAM,UAAK,KAAK,WAAM,MAAM,KAAK,IAAI,MAAM;AAAA,CAAW;AACrE,SAAO;AACT;AAEA,SAAS,UAAU,MAA6D;AAC9E,QAAM,MAAmD,EAAE,GAAG,CAAC,EAAE;AACjE,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,IAAI,KAAK,CAAC;AAChB,QAAI,MAAM,QAAQ,MAAM,QAAS,KAAI,IAAI,KAAK,EAAE,CAAC;AAAA,aACxC,MAAM,QAAQ,MAAM,UAAW,KAAI,QAAQ,OAAO,KAAK,EAAE,CAAC,CAAC;AAAA,QAC/D,KAAI,EAAE,KAAK,CAAC;AAAA,EACnB;AACA,SAAO;AACT;AAEA,SAAS,WAAW,OAAuB;AACzC,SAAO,MAAM,QAAQ,YAAY,EAAE,IAAI;AACzC;AAEA,SAAS,OAAa;AACpB,QAAM,CAAC,KAAK,GAAG,IAAI,IAAI,QAAQ,KAAK,MAAM,CAAC;AAC3C,QAAM,OAAO,UAAU,IAAI;AAE3B,MAAI,CAAC,OAAO,QAAQ,UAAU,QAAQ,YAAY,QAAQ,MAAM;AAC9D,YAAQ,OAAO;AAAA,MACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAIF;AACA,YAAQ,KAAK,MAAM,IAAI,CAAC;AAAA,EAC1B;AAEA,QAAM,QAAQ,KAAK,EAAE,CAAC;AACtB,MAAI,CAAC,OAAO;AACV,YAAQ,OAAO,MAAM,6BAA6B;AAClD,YAAQ,KAAK,CAAC;AAAA,EAChB;AACA,QAAM,SAAS,KAAK,IAAI,QAAQ,KAAK,CAAC,IAAI,WAAW,QAAQ,KAAK,CAAC;AAEnE,MAAI,QAAQ,WAAW;AACrB,YAAQ,KAAK,YAAY,QAAQ,KAAK,GAAG,QAAQ,KAAK,KAAK,IAAI,IAAI,CAAC;AAAA,EACtE,WAAW,QAAQ,SAAS;AAC1B,gBAAY,QAAQ,KAAK,GAAG,QAAQ,KAAK,KAAK;AAC9C,YAAQ,OAAO,MAAM,YAAY,KAAK;AAAA,CAAuB;AAC7D,cAAU,QAAQ,KAAK,GAAG,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,QAAQ,KAAK,GAAG,QAAQ,KAAK,KAAK,CAAC;AAAA,EACpG,OAAO;AACL,YAAQ,OAAO,MAAM,2BAA2B,GAAG;AAAA,CAAK;AACxD,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;AAEA,KAAK;","names":[]}
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\r\n/** ArchLang CLI: `arch compile <in.arch> [-o out.svg]`, `arch watch <in.arch>`. */\r\n\r\nimport { readFileSync, writeFileSync, watchFile } from \"node:fs\";\r\nimport { resolve as resolvePath } from \"node:path\";\r\nimport { compile, formatDiagnostic, toDxf, toPdf } from \"./index.js\";\r\n\r\ntype Format = \"svg\" | \"dxf\" | \"pdf\";\r\n\r\nasync function compileFile(input: string, output: string, format: Format, width?: number): Promise<boolean> {\r\n  let source: string;\r\n  try {\r\n    source = readFileSync(input, \"utf8\");\r\n  } catch {\r\n    process.stderr.write(`error: cannot read ${input}\\n`);\r\n    return false;\r\n  }\r\n  const { svg, diagnostics, scene } = compile(source, { width, noCache: true });\r\n  for (const d of diagnostics) {\r\n    process.stderr.write(`${formatDiagnostic(source, d)}\\n\\n`);\r\n  }\r\n  const errorCount = diagnostics.filter((d) => d.severity === \"error\").length;\r\n  if (errorCount > 0 || !scene) {\r\n    process.stderr.write(`✗ compilation failed (${errorCount} error${errorCount > 1 ? \"s\" : \"\"})\\n`);\r\n    return false;\r\n  }\r\n\r\n  if (format === \"dxf\") {\r\n    const dxf = toDxf(scene);\r\n    writeFileSync(output, dxf, \"utf8\");\r\n    process.stdout.write(`✓ ${input} → ${output} (${dxf.length} bytes, DXF)\\n`);\r\n    return true;\r\n  }\r\n  if (format === \"pdf\") {\r\n    try {\r\n      const pdf = await toPdf(scene);\r\n      writeFileSync(output, pdf);\r\n      process.stdout.write(`✓ ${input} → ${output} (${pdf.length} bytes, PDF)\\n`);\r\n      return true;\r\n    } catch (e) {\r\n      process.stderr.write(`error: ${(e as Error).message}\\n`);\r\n      return false;\r\n    }\r\n  }\r\n  writeFileSync(output, svg, \"utf8\");\r\n  process.stdout.write(`✓ ${input} → ${output} (${svg.length} bytes)\\n`);\r\n  return true;\r\n}\r\n\r\nfunction parseArgs(argv: string[]): { _: string[]; o?: string; width?: number; format?: string } {\r\n  const res: { _: string[]; o?: string; width?: number; format?: string } = { _: [] };\r\n  for (let i = 0; i < argv.length; i++) {\r\n    const a = argv[i];\r\n    if (a === \"-o\" || a === \"--out\") res.o = argv[++i];\r\n    else if (a === \"-w\" || a === \"--width\") res.width = Number(argv[++i]);\r\n    else if (a === \"-f\" || a === \"--format\") res.format = argv[++i];\r\n    else res._.push(a);\r\n  }\r\n  return res;\r\n}\r\n\r\nfunction defaultOut(input: string, format: Format): string {\r\n  return input.replace(/\\.arch$/i, \"\") + \".\" + format;\r\n}\r\n\r\nasync function main(): Promise<void> {\r\n  const [cmd, ...rest] = process.argv.slice(2);\r\n  const args = parseArgs(rest);\r\n\r\n  if (!cmd || cmd === \"help\" || cmd === \"--help\" || cmd === \"-h\") {\r\n    process.stdout.write(\r\n      `arch — ArchLang compiler\\n\\n` +\r\n        `Usage:\\n` +\r\n        `  arch compile <in.arch> [-o out] [-w width] [-f svg|dxf|pdf]\\n` +\r\n        `  arch watch   <in.arch> [-o out] [-w width] [-f svg|dxf|pdf]\\n\\n` +\r\n        `Formats: svg (default) · dxf (zero-dep) · pdf (needs optional pdfkit + svg-to-pdfkit)\\n`,\r\n    );\r\n    process.exit(cmd ? 0 : 1);\r\n  }\r\n\r\n  const fmt = (args.format ?? \"svg\").toLowerCase();\r\n  if (fmt !== \"svg\" && fmt !== \"dxf\" && fmt !== \"pdf\") {\r\n    process.stderr.write(`error: unknown format \"${args.format}\" (use svg, dxf, or pdf)\\n`);\r\n    process.exit(1);\r\n  }\r\n  const format = fmt as Format;\r\n\r\n  const input = args._[0];\r\n  if (!input) {\r\n    process.stderr.write(\"error: missing input file\\n\");\r\n    process.exit(1);\r\n  }\r\n  const inPath = resolvePath(input);\r\n  const output = args.o ? resolvePath(args.o) : defaultOut(inPath, format);\r\n\r\n  if (cmd === \"compile\") {\r\n    process.exit((await compileFile(inPath, output, format, args.width)) ? 0 : 1);\r\n  } else if (cmd === \"watch\") {\r\n    await compileFile(inPath, output, format, args.width);\r\n    process.stdout.write(`watching ${input} … (Ctrl+C to stop)\\n`);\r\n    watchFile(inPath, { interval: 300 }, () => {\r\n      void compileFile(inPath, output, format, args.width);\r\n    });\r\n  } else {\r\n    process.stderr.write(`error: unknown command \"${cmd}\"\\n`);\r\n    process.exit(1);\r\n  }\r\n}\r\n\r\nvoid main();\r\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -243,6 +243,163 @@ interface PlanNode {
     body: Statement[];
 }
 
+/** Pure geometry helpers. All coordinates in millimetres. Deterministic. */
+
+interface Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+interface WallSegment {
+    a: Point;
+    b: Point;
+    thickness: number;
+    category: string;
+}
+
+/**
+ * Backend-neutral **Scene IR** — the keystone drawing intermediate.
+ *
+ * `resolve()` produces semantic geometry (rooms, walls, openings); this module
+ * defines a flat list of *positioned drawing primitives* tagged with a layer and
+ * paint. Geometry is computed exactly **once** here (by the elements, lowered via
+ * `scene-build.ts`); every backend (SVG, DXF, PDF, …) is then a thin, pure
+ * serializer of the same `Scene`. This kills the geometry duplication the
+ * string-based `RenderOp` forced (DXF re-deriving door arcs, PDF rasterizing SVG).
+ *
+ * Prior art: Typst's `Frame`/`FrameItem` (crates/typst-library/src/layout/frame.rs)
+ * — a positioned list of drawable items — and D2's `d2target` (a flat, pointer-free
+ * render target consumed by independent backends). ArchLang has no nested
+ * transforms, so unlike Typst's `Frame` the node list is flat (no sub-frames).
+ *
+ * Phase v0.7 keeps this deliberately small: line-weight/line-type/named-layer
+ * metadata, hatch primitives, and circles are intentionally deferred to Phase v0.9
+ * (roadmap §6). Poché stays an SVG `<pattern>` fill string; page chrome (north
+ * arrow, scale bar, title block) stays in the backends for now.
+ */
+
+/**
+ * Ordered draw layers. Nodes are bucketed by `layer` and emitted in this order,
+ * preserving collection order within a layer — this exactly reproduces the v0.1
+ * global draw order (all wall fills, then all wall faces, doors before windows,
+ * labels above fills, …). Doubles as the discriminant of {@link SceneNode.layer}.
+ */
+declare const RENDER_PASSES: readonly ["floor", "furniture", "wallFill", "wallFace", "doors", "windows", "labels", "dims", "annotations"];
+type RenderPass = (typeof RENDER_PASSES)[number];
+/** Render-derived sizes (in mm), scaled from the drawing's reference dimension. */
+interface RenderSizes {
+    refDim: number;
+    wallStroke: number;
+    thin: number;
+    roomFont: number;
+    areaFont: number;
+    dimFont: number;
+    furnFont: number;
+    margin: number;
+    hatchGap: number;
+}
+/**
+ * How a primitive is painted. Strokes/fills carry colours (already theme-resolved
+ * and escaped at the serialization boundary); `width`/`dash` carry *raw* numbers
+ * that each backend formats. The optional `linecap`/`linejoin`/`fillRule` cover
+ * the exact SVG attributes the original element emitters used, so the SVG
+ * serializer reproduces today's output byte-for-byte.
+ */
+interface Paint {
+    /** A colour, `"none"`, or an SVG pattern ref like `"url(#poche)"`. */
+    fill?: string;
+    stroke?: string;
+    /** Raw stroke width in mm (backend applies its own number formatting). */
+    width?: number;
+    /** `stroke-dasharray` pair in mm (e.g. door swing arc). */
+    dash?: [number, number];
+    linecap?: "square";
+    linejoin?: "miter";
+    fillRule?: "nonzero";
+}
+/**
+ * A positioned drawing primitive. Coordinates are absolute millimetres in the
+ * plan's space (origin top-left, +x right, +y down — SVG convention); backends
+ * apply their own transforms (e.g. DXF's Y-flip).
+ */
+type ScenePrim = 
+/** A filled/stroked closed polygon (room, furniture, column, opening cover, per-segment wall fill). */
+{
+    t: "polygon";
+    pts: Point[];
+}
+/** A single straight segment (wall face, door leaf, window pane, dimension lines/ticks). */
+ | {
+    t: "line";
+    a: Point;
+    b: Point;
+}
+/**
+ * A multi-loop closed region drawn as one path (`fill-rule` nonzero), used for
+ * unioned orthogonal walls so the poché fills with proper holes and the outline
+ * has no internal seams.
+ */
+ | {
+    t: "region";
+    loops: Point[][];
+}
+/**
+ * A circular arc (door swing). Carries the `center`/`r` a CAD backend needs to
+ * emit a native arc, plus the explicit `start`/`end` points + `sweep` flag an
+ * SVG `A` command needs — so neither backend re-derives endpoints from trig.
+ */
+ | {
+    t: "arc";
+    center: Point;
+    r: number;
+    start: Point;
+    end: Point;
+    sweep: 0 | 1;
+}
+/** A text label. `value` is the raw (unescaped) string; backends escape on emit. */
+ | {
+    t: "text";
+    at: Point;
+    value: string;
+    size: number;
+    anchor: "start" | "middle" | "end";
+    baseline: "central";
+    /** SVG `font-weight` (e.g. 600 for a room name). */
+    weight?: number;
+    /** Rotation in degrees about `at` (e.g. dimension text along its line). */
+    rotate?: number;
+};
+/** One drawable: a primitive on a layer, with paint and an optional source span. */
+interface SceneNode {
+    layer: RenderPass;
+    prim: ScenePrim;
+    paint: Paint;
+    span?: Span;
+}
+/**
+ * A complete, backend-neutral drawing. `nodes` is the geometry; the remaining
+ * fields are the page-level context backends need (viewBox sizing, theme colours
+ * for chrome, north/scale/title block, hatch materials in use). Theme is baked
+ * into node paint already — it is carried here only for the page chrome.
+ */
+interface Scene {
+    /** Padded page width/height in mm (drawing extent + annotation margin). */
+    width: number;
+    height: number;
+    /** Tight drawing bounds (before margin), for chrome placement. */
+    bounds: Bounds;
+    nodes: SceneNode[];
+    theme: Theme;
+    sizes: RenderSizes;
+    north: NorthDir;
+    scale?: string;
+    title?: TitleNode;
+    name: string;
+    /** Distinct wall materials in use (stable order), so the SVG backend can emit hatch `<pattern>`s. */
+    materials: string[];
+}
+
 interface CompileError {
     /** Human-readable message. */
     message: string;
@@ -280,7 +437,159 @@ interface CompileResult {
     diagnostics: Diagnostic[];
     /** The validated AST, present whenever parsing succeeded. */
     ast?: PlanNode;
+    /**
+     * The backend-neutral Scene IR (positioned drawing primitives), present
+     * whenever rendering succeeded (i.e. no fatal errors). Feed it to alternate
+     * backends: `toDxf(scene)`, `toPdf(scene)`.
+     */
+    scene?: Scene;
+}
+
+/**
+ * Intermediate representation + `resolve(ast)`.
+ *
+ * `resolve` is the single place semantics live: it grid-snaps coordinates,
+ * assigns ids, hosts openings, and runs semantic checks — producing a NEW
+ * immutable IR (the input AST is never mutated). `render` consumes IR only.
+ */
+
+interface RBase {
+    kind: ElementKind;
+    id: string;
+    span?: Span;
+}
+interface RWall extends RBase {
+    kind: "wall";
+    category: string;
+    thickness: number;
+    /** Resolved hatch material (always a known material; defaults to "poche"). */
+    material: string;
+    points: Point[];
+    closed: boolean;
 }
+interface RRoom extends RBase {
+    kind: "room";
+    at: Point;
+    size: {
+        w: number;
+        h: number;
+    };
+    label?: string;
+}
+interface RDoor extends RBase {
+    kind: "door";
+    at: Point;
+    width: number;
+    hinge: "left" | "right";
+    swing: "in" | "out";
+    host: WallSegment | null;
+}
+interface RWindow extends RBase {
+    kind: "window";
+    at: Point;
+    width: number;
+    host: WallSegment | null;
+}
+interface RFurniture extends RBase {
+    kind: "furniture";
+    category: string;
+    at: Point;
+    size: {
+        w: number;
+        h: number;
+    };
+    label?: string;
+}
+interface RDim extends RBase {
+    kind: "dim";
+    from: Point;
+    to: Point;
+    offset: number;
+    text?: string;
+}
+interface RColumn extends RBase {
+    kind: "column";
+    at: Point;
+    size: {
+        w: number;
+        h: number;
+    };
+}
+type ResolvedElement = RWall | RRoom | RDoor | RWindow | RFurniture | RDim | RColumn;
+interface ResolvedPlan {
+    name: string;
+    units: "mm";
+    grid: number;
+    scale?: string;
+    north: NorthDir;
+    title?: TitleNode;
+    theme?: Partial<Theme>;
+    /** Resolved elements, in source order (for rendering). */
+    elements: ResolvedElement[];
+    /** Resolved walls (for bounds/hosting), in source order. */
+    walls: RWall[];
+}
+declare function resolve(ast: PlanNode): {
+    ir: ResolvedPlan;
+    diagnostics: Diagnostic[];
+};
+
+/**
+ * Lowers a resolved plan (IR) to the backend-neutral {@link Scene}.
+ *
+ * This is the single place geometry is assembled: each element contributes
+ * positioned primitives via its registry `render`, walls are unioned/offset here
+ * (the only element needing cross-segment treatment), and the page-level sizing
+ * (reference dimension, derived font/stroke sizes, bounds) is computed once and
+ * carried on the Scene for the backends. Pure & deterministic — no I/O, no time.
+ */
+
+/**
+ * Build the {@link Scene} for a resolved plan. The theme is merged + sanitized
+ * once here and baked into node paint; it is also carried on the Scene for the
+ * page chrome (north/scale/title). `opts.width` does not affect the Scene (it is
+ * an SVG-only attribute) — only `opts.theme` participates.
+ */
+declare function toScene(ir: ResolvedPlan, opts?: CompileOptions): Scene;
+
+/**
+ * DXF export backend — a pure serializer of the {@link Scene}. Emits ASCII DXF
+ * (R12 / AC1009, the most broadly importable flavor). Pure, synchronous,
+ * zero-dep: DXF is plain text, so this needs no external library and ships in the
+ * core. Build a Scene with `toScene(resolve(ast).ir)` (or `compile().scene`).
+ *
+ * As of v0.7 the geometry is NOT re-derived here: door arcs, window panes, and
+ * dimension ticks are the very `ScenePrim`s the elements produced. Each primitive
+ * maps generically to a DXF entity; the only element-aware step is mapping a draw
+ * layer to a DXF layer name. DXF's Y axis points up while ArchLang's points down,
+ * so every Y is negated to keep plans right-side-up in CAD.
+ */
+
+/** Render a {@link Scene} as an ASCII DXF document string. */
+declare function toDxf(scene: Scene): string;
+
+/**
+ * PDF export backend — a **true vector** serializer of the {@link Scene}.
+ *
+ * Walks the Scene's positioned primitives into pdfkit drawing ops, so strokes
+ * are real vector paths and text is selectable (no SVG rasterization round-trip).
+ * `pdfkit` is an OPTIONAL dependency, lazy-`import()`ed so the zero-dep core never
+ * hard-requires it; a clear error is thrown if it is absent. Async + Node-oriented
+ * — NOT part of `compile()`. Build a Scene with `toScene(ir)` or `compile().scene`.
+ *
+ * Coordinates: ArchLang is mm, top-left origin, +y down — pdfkit's user space is
+ * the same orientation, so we map the viewBox by translating by its top-left and
+ * treat 1mm as 1pt (as the previous SVG-based exporter did with `assumePt`).
+ *
+ * Page chrome (north arrow, scale bar, title block) is drawn with PDF-native
+ * helpers to keep parity with the SVG output. This duplicates the chrome geometry
+ * (also in `backends/svg.ts`) — a deliberate, bounded cost until chrome itself
+ * moves into the Scene in a later phase. Hatch patterns are SVG-specific, so
+ * poché regions fill with the solid poché base colour in PDF.
+ */
+
+/** Convert a {@link Scene} to a vector PDF (Uint8Array). Requires optional `pdfkit`. */
+declare function toPdf(scene: Scene): Promise<Uint8Array>;
 
 /**
  * ArchLang — compile declarative floor-plan source to a professional SVG.
@@ -294,4 +603,4 @@ declare function compile(source: string, opts?: CompileOptions): CompileResult;
 /** Clear the internal compile cache (useful in long-lived processes/tests). */
 declare function clearCache(): void;
 
-export { type AstElement, type ColumnNode, type CompileError, type CompileOptions, type CompileResult, type CompileWarning, type ComponentDef, type Diagnostic, type DimNode, type DoorNode, type ElementKind, type ExprPoint, type FurnitureNode, type InstanceNode, type LetNode, type NodeBase, type NorthDir, type PlanNode, type Point, type RoomNode, type Severity, type Span, type Statement, type TitleNode, type WallNode, type WindowNode, clearCache, compile, formatDiagnostic, offsetToLineCol };
+export { type AstElement, type ColumnNode, type CompileError, type CompileOptions, type CompileResult, type CompileWarning, type ComponentDef, type Diagnostic, type DimNode, type DoorNode, type ElementKind, type ExprPoint, type FurnitureNode, type InstanceNode, type LetNode, type NodeBase, type NorthDir, type Paint, type PlanNode, type Point, type RColumn, type RDim, type RDoor, type RFurniture, type RRoom, type RWall, type RWindow, type RenderPass, type RenderSizes, type ResolvedElement, type ResolvedPlan, type RoomNode, type Scene, type SceneNode, type ScenePrim, type Severity, type Span, type Statement, type TitleNode, type WallNode, type WindowNode, clearCache, compile, formatDiagnostic, offsetToLineCol, resolve, toDxf, toPdf, toScene };

package/dist/index.js

@@ -2,12 +2,20 @@ import {
   clearCache,
   compile,
   formatDiagnostic,
-  offsetToLineCol
-} from "./chunk-GUNWYUR2.js";
+  offsetToLineCol,
+  resolve,
+  toDxf,
+  toPdf,
+  toScene
+} from "./chunk-CPK5CI5Y.js";
 export {
   clearCache,
   compile,
   formatDiagnostic,
-  offsetToLineCol
+  offsetToLineCol,
+  resolve,
+  toDxf,
+  toPdf,
+  toScene
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chanmeng666/archlang",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "A small declarative language that compiles to professional SVG floor plans — like Typst/LaTeX, but for architecture.",
   "keywords": [
     "architecture",
@@ -52,6 +52,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "cli": "tsx src/cli.ts",
+    "bench": "tsx bench/run.ts",
     "prepublishOnly": "npm run build && npm run test"
   },
   "devDependencies": {
@@ -60,6 +61,11 @@
     "tsup": "^8.3.5",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.8",
+    "vscode-oniguruma": "^2.0.1",
+    "vscode-textmate": "^9.3.2"
+  },
+  "optionalDependencies": {
+    "pdfkit": "^0.15.2"
   }
 }