lecodes-sdk 1.2.0 → 2.0.1

package/src/canvas/gen/recorder.ts

@@ -0,0 +1,212 @@
+// GENERATED by scripts/vendor-canvas.ts from engines/canvas/recorders/ts/src/recorder.ts @ ae6bc30b952b — do not edit here.
+// Bump the submodule and run `bun run vendor:canvas`; `bun run check:canvas-ops` fails when this copy is stale.
+// The TypeScript recorder: a Canvas2D-shaped API whose calls WRITE the opcode stream of spec/ops.h.
+// Nothing is drawn here — the stream goes to the core interpreter (native, or wasm on the web), which
+// turns it into a draw list a painter replays. An app-facing Canvas class wraps a Recorder and adds
+// what needs a painter (measureText, surfaces, textures).
+//
+// Differences from the browser, on purpose:
+//   - colors and fonts are CSS strings resolved by the core (an invalid one keeps the previous style)
+//   - a Gradient is serialized when it is ASSIGNED to fillStyle / strokeStyle; stops added later
+//     do not affect an assignment already made
+//   - drawImage takes a surface id (an ImageRef with its device size for the short forms)
+//   - every drawing call returns `this`, so drawing chains
+import { OP, LineJoin, LineCap, TextAlign, TextBaseline, FillRule, Gradient as GradientKind } from "./spec"
+
+export type FillRuleName = "nonzero" | "evenodd"
+export type LineJoinName = "miter" | "round" | "bevel"
+export type LineCapName = "butt" | "round" | "square"
+export type TextAlignName = "left" | "center" | "right" | "start" | "end"
+export type TextBaselineName = "alphabetic" | "top" | "middle" | "bottom" | "hanging" | "ideographic"
+
+const JOIN: Record<LineJoinName, number> = { miter: LineJoin.MITER, round: LineJoin.ROUND, bevel: LineJoin.BEVEL }
+const CAP: Record<LineCapName, number> = { butt: LineCap.BUTT, round: LineCap.ROUND, square: LineCap.SQUARE }
+const ALIGN: Record<TextAlignName, number> = { left: TextAlign.LEFT, center: TextAlign.CENTER, right: TextAlign.RIGHT, start: TextAlign.START, end: TextAlign.END }
+const BASELINE: Record<TextBaselineName, number> = {
+  alphabetic: TextBaseline.ALPHABETIC, top: TextBaseline.TOP, middle: TextBaseline.MIDDLE,
+  bottom: TextBaseline.BOTTOM, hanging: TextBaseline.HANGING, ideographic: TextBaseline.IDEOGRAPHIC,
+}
+const RULE: Record<FillRuleName, number> = { nonzero: FillRule.NONZERO, evenodd: FillRule.EVENODD }
+// The shadowed style fields save() / restore() snapshot, as the core's state stack does.
+const SHADOWED = ["_globalAlpha", "_fillStyle", "_strokeStyle", "_lineWidth", "_lineJoin", "_lineCap", "_miterLimit",
+  "_lineDash", "_lineDashOffset", "_font", "_textAlign", "_textBaseline", "_letterSpacing"] as const
+
+/** A gradient built by createLinearGradient / createRadialGradient; assign it to fillStyle / strokeStyle. */
+export class Gradient {
+  readonly stops: { offset: number, color: string }[] = []
+  readonly kind: number
+  readonly coords: [number, number, number, number, number, number]
+  /** @internal */
+  constructor(kind: number, coords: [number, number, number, number, number, number]) { this.kind = kind; this.coords = coords }
+  addColorStop(offset: number, color: string): this {
+    if (!(offset >= 0 && offset <= 1)) throw new RangeError(`gradient stop offset ${offset} is outside 0..1`)
+    this.stops.push({ offset, color })
+    return this
+  }
+}
+
+/** The recorded stream: the f32 words and the string table the core reads. */
+export interface Stream { cmd: Float32Array, refs: string[] }
+
+/** A surface with its device size, for the short drawImage forms. */
+export interface ImageRef { surface: number, width: number, height: number }
+
+export class Recorder {
+  private cmd: number[] = []
+  private refs: string[] = []
+  private refIndex = new Map<string, number>()
+
+  // Shadowed state so the getters read back what was set (the stream itself is write-only).
+  private _globalAlpha = 1
+  private _fillStyle: string | Gradient = "#000000"
+  private _strokeStyle: string | Gradient = "#000000"
+  private _lineWidth = 1
+  private _lineJoin: LineJoinName = "miter"
+  private _lineCap: LineCapName = "butt"
+  private _miterLimit = 10
+  private _lineDash: number[] = []
+  private _lineDashOffset = 0
+  private _font = "10px sans-serif"
+  private _textAlign: TextAlignName = "start"
+  private _textBaseline: TextBaselineName = "alphabetic"
+  private _letterSpacing = 0
+  // One snapshot of the shadowed fields per open save(), so the getters read back what restore()
+  // brings back (by reference: setLineDash stores a fresh array, a Gradient is the assigned object).
+  private _saved: Record<string, unknown>[] = []
+
+  // ---- the stream -----------------------------------------------------------------------------
+
+  /** The words recorded so far (a copy) + the string table. */
+  stream(): Stream { return { cmd: new Float32Array(this.cmd), refs: this.refs.slice() } }
+  /** Plain arrays, for a JSON file (the golden tests' input). */
+  toJSON(): { cmd: number[], refs: string[] } { return { cmd: this.cmd.slice(), refs: this.refs.slice() } }
+  /** The number of words recorded. */
+  get length(): number { return this.cmd.length }
+  /** Discard the recording; the shadowed state is reset too (a fresh replay starts from defaults). */
+  reset(): this {
+    this.cmd.length = 0
+    this.refs.length = 0
+    this.refIndex.clear()
+    this._globalAlpha = 1; this._fillStyle = "#000000"; this._strokeStyle = "#000000"
+    this._lineWidth = 1; this._lineJoin = "miter"; this._lineCap = "butt"; this._miterLimit = 10
+    this._lineDash = []; this._lineDashOffset = 0
+    this._font = "10px sans-serif"; this._textAlign = "start"; this._textBaseline = "alphabetic"; this._letterSpacing = 0
+    this._saved.length = 0
+    return this
+  }
+
+  private ref(s: string): number {
+    let i = this.refIndex.get(s)
+    if (i === undefined) { i = this.refs.length; this.refs.push(s); this.refIndex.set(s, i) }
+    return i
+  }
+  private push(...words: number[]): this { for (const w of words) this.cmd.push(w); return this }
+
+  // ---- state stack + transforms ---------------------------------------------------------------
+
+  save(): this {
+    const s: Record<string, unknown> = {}
+    for (const k of SHADOWED) s[k] = this[k]
+    this._saved.push(s)
+    return this.push(OP.SAVE)
+  }
+  restore(): this {
+    const s = this._saved.pop()   // an unbalanced restore() keeps the state, like the core
+    if (s) Object.assign(this, s)
+    return this.push(OP.RESTORE)
+  }
+  translate(x: number, y: number): this { return this.push(OP.TRANSLATE, x, y) }
+  scale(sx: number, sy: number): this { return this.push(OP.SCALE, sx, sy) }
+  rotate(rad: number): this { return this.push(OP.ROTATE, rad) }
+  transform(a: number, b: number, c: number, d: number, e: number, f: number): this { return this.push(OP.TRANSFORM, a, b, c, d, e, f) }
+  setTransform(a: number, b: number, c: number, d: number, e: number, f: number): this { return this.push(OP.SET_TRANSFORM, a, b, c, d, e, f) }
+  resetTransform(): this { return this.push(OP.RESET_TRANSFORM) }
+
+  // ---- styles ---------------------------------------------------------------------------------
+
+  get globalAlpha(): number { return this._globalAlpha }
+  set globalAlpha(a: number) { this._globalAlpha = a; this.push(OP.GLOBAL_ALPHA, a) }
+
+  get fillStyle(): string | Gradient { return this._fillStyle }
+  set fillStyle(v: string | Gradient) { this._fillStyle = v; this.style(OP.FILL_STYLE, OP.FILL_GRADIENT, v) }
+  get strokeStyle(): string | Gradient { return this._strokeStyle }
+  set strokeStyle(v: string | Gradient) { this._strokeStyle = v; this.style(OP.STROKE_STYLE, OP.STROKE_GRADIENT, v) }
+  private style(colorOp: number, gradientOp: number, v: string | Gradient): void {
+    if (typeof v === "string") { this.push(colorOp, this.ref(v)); return }
+    this.push(gradientOp, v.kind, ...v.coords, v.stops.length)
+    for (const s of v.stops) this.push(s.offset, this.ref(s.color))
+  }
+
+  createLinearGradient(x0: number, y0: number, x1: number, y1: number): Gradient {
+    return new Gradient(GradientKind.LINEAR, [x0, y0, x1, y1, 0, 0])
+  }
+  createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): Gradient {
+    return new Gradient(GradientKind.RADIAL, [x0, y0, x1, y1, r0, r1])
+  }
+
+  get lineWidth(): number { return this._lineWidth }
+  set lineWidth(w: number) { this._lineWidth = w; this.push(OP.LINE_WIDTH, w) }
+  get lineJoin(): LineJoinName { return this._lineJoin }
+  set lineJoin(j: LineJoinName) { this._lineJoin = j; this.push(OP.LINE_JOIN, JOIN[j]) }
+  get lineCap(): LineCapName { return this._lineCap }
+  set lineCap(c: LineCapName) { this._lineCap = c; this.push(OP.LINE_CAP, CAP[c]) }
+  get miterLimit(): number { return this._miterLimit }
+  set miterLimit(m: number) { this._miterLimit = m; this.push(OP.MITER_LIMIT, m) }
+  setLineDash(segments: number[]): this {
+    this._lineDash = segments.slice()
+    return this.push(OP.LINE_DASH, segments.length, ...segments)
+  }
+  getLineDash(): number[] { return this._lineDash.slice() }
+  get lineDashOffset(): number { return this._lineDashOffset }
+  set lineDashOffset(o: number) { this._lineDashOffset = o; this.push(OP.LINE_DASH_OFFSET, o) }
+
+  get font(): string { return this._font }
+  set font(f: string) { this._font = f; this.push(OP.FONT, this.ref(f)) }
+  get textAlign(): TextAlignName { return this._textAlign }
+  set textAlign(a: TextAlignName) { this._textAlign = a; this.push(OP.TEXT_ALIGN, ALIGN[a]) }
+  get textBaseline(): TextBaselineName { return this._textBaseline }
+  set textBaseline(b: TextBaselineName) { this._textBaseline = b; this.push(OP.TEXT_BASELINE, BASELINE[b]) }
+  get letterSpacing(): number { return this._letterSpacing }
+  set letterSpacing(px: number) { this._letterSpacing = px; this.push(OP.LETTER_SPACING, px) }
+
+  // ---- paths ----------------------------------------------------------------------------------
+
+  beginPath(): this { return this.push(OP.PATH_BEGIN) }
+  closePath(): this { return this.push(OP.PATH_CLOSE) }
+  moveTo(x: number, y: number): this { return this.push(OP.MOVE_TO, x, y) }
+  lineTo(x: number, y: number): this { return this.push(OP.LINE_TO, x, y) }
+  quadraticCurveTo(cx: number, cy: number, x: number, y: number): this { return this.push(OP.QUADRATIC_TO, cx, cy, x, y) }
+  bezierCurveTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): this {
+    return this.push(OP.BEZIER_TO, c1x, c1y, c2x, c2y, x, y)
+  }
+  arc(x: number, y: number, r: number, a0: number, a1: number, ccw = false): this { return this.push(OP.ARC, x, y, r, a0, a1, ccw ? 1 : 0) }
+  arcTo(x1: number, y1: number, x2: number, y2: number, r: number): this { return this.push(OP.ARC_TO, x1, y1, x2, y2, r) }
+  ellipse(x: number, y: number, rx: number, ry: number, rotation: number, a0: number, a1: number, ccw = false): this {
+    return this.push(OP.ELLIPSE, x, y, rx, ry, rotation, a0, a1, ccw ? 1 : 0)
+  }
+  rect(x: number, y: number, w: number, h: number): this { return this.push(OP.RECT, x, y, w, h) }
+  roundRect(x: number, y: number, w: number, h: number, r: number): this { return this.push(OP.ROUND_RECT, x, y, w, h, r) }
+
+  fill(rule: FillRuleName = "nonzero"): this { return this.push(OP.FILL, RULE[rule]) }
+  stroke(): this { return this.push(OP.STROKE) }
+  clip(rule: FillRuleName = "nonzero"): this { return this.push(OP.CLIP, RULE[rule]) }
+
+  // ---- rectangles, text, images ---------------------------------------------------------------
+
+  fillRect(x: number, y: number, w: number, h: number): this { return this.push(OP.FILL_RECT, x, y, w, h) }
+  strokeRect(x: number, y: number, w: number, h: number): this { return this.push(OP.STROKE_RECT, x, y, w, h) }
+  clearRect(x: number, y: number, w: number, h: number): this { return this.push(OP.CLEAR_RECT, x, y, w, h) }
+  fillText(text: string, x: number, y: number, maxWidth = 0): this { return this.push(OP.FILL_TEXT, this.ref(text), x, y, maxWidth) }
+  strokeText(text: string, x: number, y: number, maxWidth = 0): this { return this.push(OP.STROKE_TEXT, this.ref(text), x, y, maxWidth) }
+
+  /** Blit a surface. Three browser-style forms; the source rect is in the surface's device px. */
+  drawImage(img: ImageRef, dx: number, dy: number): this
+  drawImage(img: ImageRef, dx: number, dy: number, dw: number, dh: number): this
+  drawImage(img: ImageRef, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): this
+  drawImage(img: ImageRef, a: number, b: number, c?: number, d?: number, e?: number, f?: number, g?: number, h?: number): this {
+    if (e === undefined) {
+      return this.push(OP.DRAW_IMAGE, img.surface, 0, 0, img.width, img.height, a, b, c ?? img.width, d ?? img.height)
+    }
+    return this.push(OP.DRAW_IMAGE, img.surface, a, b, c!, d!, e, f!, g!, h!)
+  }
+}

package/src/canvas/gen/spec.ts

@@ -0,0 +1,201 @@
+// GENERATED by scripts/vendor-canvas.ts from engines/canvas/spec/gen/spec.ts @ ae6bc30b952b — do not edit here.
+// Bump the submodule and run `bun run vendor:canvas`; `bun run check:canvas-ops` fails when this copy is stale.
+// GENERATED by spec/generate.ts from spec/*.h — do not edit.
+
+export const SPEC_VERSION = 1
+
+export const LineJoin = {
+  MITER: 0,
+  ROUND: 1,
+  BEVEL: 2,
+} as const
+export type LineJoin = (typeof LineJoin)[keyof typeof LineJoin]
+export const LineJoinName: readonly string[] = ["miter", "round", "bevel"]
+
+export const LineCap = {
+  BUTT: 0,
+  ROUND: 1,
+  SQUARE: 2,
+} as const
+export type LineCap = (typeof LineCap)[keyof typeof LineCap]
+export const LineCapName: readonly string[] = ["butt", "round", "square"]
+
+export const TextAlign = {
+  LEFT: 0,
+  CENTER: 1,
+  RIGHT: 2,
+  START: 3,
+  END: 4,
+} as const
+export type TextAlign = (typeof TextAlign)[keyof typeof TextAlign]
+export const TextAlignName: readonly string[] = ["left", "center", "right", "start", "end"]
+
+export const TextBaseline = {
+  ALPHABETIC: 0,
+  TOP: 1,
+  MIDDLE: 2,
+  BOTTOM: 3,
+  HANGING: 4,
+  IDEOGRAPHIC: 5,
+} as const
+export type TextBaseline = (typeof TextBaseline)[keyof typeof TextBaseline]
+export const TextBaselineName: readonly string[] = ["alphabetic", "top", "middle", "bottom", "hanging", "ideographic"]
+
+export const FillRule = {
+  NONZERO: 0,
+  EVENODD: 1,
+} as const
+export type FillRule = (typeof FillRule)[keyof typeof FillRule]
+export const FillRuleName: readonly string[] = ["nonzero", "evenodd"]
+
+export const Spread = {
+  PAD: 0,
+  REFLECT: 1,
+  REPEAT: 2,
+} as const
+export type Spread = (typeof Spread)[keyof typeof Spread]
+export const SpreadName: readonly string[] = ["pad", "reflect", "repeat"]
+
+export const Gradient = {
+  LINEAR: 0,
+  RADIAL: 1,
+} as const
+export type Gradient = (typeof Gradient)[keyof typeof Gradient]
+export const GradientName: readonly string[] = ["linear", "radial"]
+
+export const Paint = {
+  COLOR: 0,
+  LINEAR: 1,
+  RADIAL: 2,
+} as const
+export type Paint = (typeof Paint)[keyof typeof Paint]
+export const PaintName: readonly string[] = ["color", "linear", "radial"]
+
+export const PathVerb = {
+  MOVE: 0,
+  LINE: 1,
+  QUAD: 2,
+  CUBIC: 3,
+  CLOSE: 4,
+} as const
+export type PathVerb = (typeof PathVerb)[keyof typeof PathVerb]
+export const PathVerbName: readonly string[] = ["move", "line", "quad", "cubic", "close"]
+
+export const ImageFormat = {
+  PNG: 0,
+  JPEG: 1,
+} as const
+export type ImageFormat = (typeof ImageFormat)[keyof typeof ImageFormat]
+export const ImageFormatName: readonly string[] = ["png", "jpeg"]
+
+/** The opcode stream: op id → the word after it. */
+export const OP = {
+  SAVE: 0,
+  RESTORE: 1,
+  TRANSLATE: 2,
+  SCALE: 3,
+  ROTATE: 4,
+  TRANSFORM: 5,
+  SET_TRANSFORM: 6,
+  RESET_TRANSFORM: 7,
+  GLOBAL_ALPHA: 8,
+  FILL_STYLE: 9,
+  STROKE_STYLE: 10,
+  FILL_GRADIENT: 11,
+  STROKE_GRADIENT: 12,
+  LINE_WIDTH: 13,
+  LINE_JOIN: 14,
+  LINE_CAP: 15,
+  MITER_LIMIT: 16,
+  LINE_DASH: 17,
+  LINE_DASH_OFFSET: 18,
+  FONT: 19,
+  TEXT_ALIGN: 20,
+  TEXT_BASELINE: 21,
+  LETTER_SPACING: 22,
+  PATH_BEGIN: 23,
+  PATH_CLOSE: 24,
+  MOVE_TO: 25,
+  LINE_TO: 26,
+  QUADRATIC_TO: 27,
+  BEZIER_TO: 28,
+  ARC: 29,
+  ARC_TO: 30,
+  ELLIPSE: 31,
+  RECT: 32,
+  ROUND_RECT: 33,
+  FILL: 34,
+  STROKE: 35,
+  CLIP: 36,
+  FILL_RECT: 37,
+  STROKE_RECT: 38,
+  CLEAR_RECT: 39,
+  FILL_TEXT: 40,
+  STROKE_TEXT: 41,
+  DRAW_IMAGE: 42,
+} as const
+export type OP = (typeof OP)[keyof typeof OP]
+/** Operand layout per op: `args` is one letter per fixed word (f float, i int, r string ref);
+ *  `repeat` is the group that follows the trailing count. */
+export const OP_ARGS: Record<number, { args: string, repeat: string }> = {
+  0: { args: "", repeat: "" },
+  1: { args: "", repeat: "" },
+  2: { args: "ff", repeat: "" },
+  3: { args: "ff", repeat: "" },
+  4: { args: "f", repeat: "" },
+  5: { args: "ffffff", repeat: "" },
+  6: { args: "ffffff", repeat: "" },
+  7: { args: "", repeat: "" },
+  8: { args: "f", repeat: "" },
+  9: { args: "r", repeat: "" },
+  10: { args: "r", repeat: "" },
+  11: { args: "iffffffi", repeat: "fr" },
+  12: { args: "iffffffi", repeat: "fr" },
+  13: { args: "f", repeat: "" },
+  14: { args: "i", repeat: "" },
+  15: { args: "i", repeat: "" },
+  16: { args: "f", repeat: "" },
+  17: { args: "i", repeat: "f" },
+  18: { args: "f", repeat: "" },
+  19: { args: "r", repeat: "" },
+  20: { args: "i", repeat: "" },
+  21: { args: "i", repeat: "" },
+  22: { args: "f", repeat: "" },
+  23: { args: "", repeat: "" },
+  24: { args: "", repeat: "" },
+  25: { args: "ff", repeat: "" },
+  26: { args: "ff", repeat: "" },
+  27: { args: "ffff", repeat: "" },
+  28: { args: "ffffff", repeat: "" },
+  29: { args: "fffffi", repeat: "" },
+  30: { args: "fffff", repeat: "" },
+  31: { args: "fffffffi", repeat: "" },
+  32: { args: "ffff", repeat: "" },
+  33: { args: "fffff", repeat: "" },
+  34: { args: "i", repeat: "" },
+  35: { args: "", repeat: "" },
+  36: { args: "i", repeat: "" },
+  37: { args: "ffff", repeat: "" },
+  38: { args: "ffff", repeat: "" },
+  39: { args: "ffff", repeat: "" },
+  40: { args: "rfff", repeat: "" },
+  41: { args: "rfff", repeat: "" },
+  42: { args: "iffffffff", repeat: "" },
+}
+export const OP_NAME: readonly string[] = ["save", "restore", "translate", "scale", "rotate", "transform", "setTransform", "resetTransform", "globalAlpha", "fillStyle", "strokeStyle", "fillGradient", "strokeGradient", "lineWidth", "lineJoin", "lineCap", "miterLimit", "lineDash", "lineDashOffset", "font", "textAlign", "textBaseline", "letterSpacing", "pathBegin", "pathClose", "moveTo", "lineTo", "quadraticTo", "bezierTo", "arc", "arcTo", "ellipse", "rect", "roundRect", "fill", "stroke", "clip", "fillRect", "strokeRect", "clearRect", "fillText", "strokeText", "drawImage"]
+
+/** The draw list: command id → the word after it. */
+export const DRAW = {
+  SET_TRANSFORM: 0,
+  SAVE: 1,
+  RESTORE: 2,
+  CLIP: 3,
+  FILL_PATH: 4,
+  STROKE_PATH: 5,
+  FILL_TEXT: 6,
+  STROKE_TEXT: 7,
+  DRAW_IMAGE: 8,
+  CLEAR_RECT: 9,
+} as const
+export type DRAW = (typeof DRAW)[keyof typeof DRAW]
+export const DRAW_NAME: readonly string[] = ["setTransform", "save", "restore", "clip", "fillPath", "strokePath", "fillText", "strokeText", "drawImage", "clearRect"]

package/src/chisel.ts

@@ -0,0 +1,193 @@
+/**
+ * The chisel vocabulary: every SDK name the bundler's passes key on, declared by the SDK itself.
+ *
+ * chisel (@letary/chisel) holds the ALGORITHMS — method-granular DCE, chain fusion, curve folding,
+ * the UI rewrites — and reads the NAMES from here: compile/bundler.ts passes this object as the
+ * `vocab` field of every bundle input, and chisel uses only it. A rename in the SDK is an edit
+ * here (tests/compile/chisel-vocab.test.ts fails until it is made), never a chisel release; a chisel
+ * release is for algorithms only, or when the schema grows.
+ *
+ * Rules:
+ *  - Plain data. No imports, no computed values — chisel's own tests read a JSON copy
+ *    (`<chisel>/fixtures/vocab.json`, held equal by `bun scripts/chisel-parity.ts --fixture`).
+ *  - `schema` is the contract version. chisel rejects a newer schema than it implements (upgrade
+ *    @letary/chisel) and falls back to its built-in defaults for a group an older one lacks.
+ *  - Role maps (`methods`, `stops`, `range`): the key is the role chisel lowers (its algorithm
+ *    mirrors that method's body), the value is the SDK's name for it.
+ *  - Global names (factories, classes, helpers) are the names user code sees — inject.ts exports
+ *    (`asset` is a host global). The date helpers are module-private names of runtime/datetime.ts:
+ *    chisel finds them beside `date`.
+ *  - Changing a list changes bundles (adding a chain method makes more calls provably nodes, so
+ *    more of them skip the runtime dispatch). Keep the lists exact.
+ */
+
+export interface ChiselVocab {
+  schema: number
+  ui: {
+    /** Factories going through the variadic `buildUI` dispatch (+ UIPager, which flattens its
+     *  arguments the same way): literal array arguments are spliced into variadic ones. */
+    factories: string[]
+    /** factory → its dispatch-free builder (an inject export): a call whose arguments are all
+     *  provably nodes skips the dispatch. Every key is also in `factories`. */
+    raw: Record<string, string>
+    /** The other free calls that return a node (argument provability). */
+    leaves: string[]
+    /** Containers whose function-valued children argument is a reactive children binding. */
+    containers: string[]
+    /** The text factory: its text argument is a binding position. */
+    text: string
+    /** Builder methods that keep a chain a node (a conservative whitelist). */
+    chain: string[]
+    /** The children setter (`x.setContent(() => …)`). */
+    setContent: string
+    /** Member calls whose object-literal values are bindings (`.style({…})`, `.class({…})`). */
+    bindingMethods: string[]
+    /** The memoized children-map helper (`__uiMap(list, fn, slot)`). */
+    mapHelper: string
+  }
+  signals: {
+    /** Calls that create a signal (the roots of chisel's signal-type inference). */
+    factories: string[]
+    /** The property a signal is read through. */
+    value: string
+  }
+  fusion: {
+    vec3: {
+      class: string
+      /** The component fields, in order. */
+      fields: [ string, string, string ]
+      /** Statics that yield a Vec3. */
+      statics: string[]
+      /** Instance methods that return a Vec3 (local type inference). */
+      returning: string[]
+      methods: Record<"add" | "sub" | "mul" | "scale" | "negate" | "scaleAndAdd" | "cross" | "normalize" | "dot" | "lengthSq" | "length" | "distanceTo", string>
+    }
+    date: {
+      /** The factory global. */
+      factory: string
+      /** The value class, and the module-private helpers a fused chain calls (runtime/datetime.ts). */
+      class: string
+      toMs: string
+      formatImpl: string
+      timeAgoImpl: string
+      /** A value's epoch-ms field. */
+      field: string
+      /** Methods that return a date (local type inference). */
+      returning: string[]
+      methods: Record<"add" | "subtract" | "format" | "timeAgo" | "valueOf" | "unix" | "diff" | "isBefore" | "isAfter" | "isSame", string>
+    }
+    curve: {
+      factory: string
+      colorFactory: string
+      /** The builders' payload getter (a fused chain becomes `{ <data>: new Float32Array([…]) }`). */
+      data: string
+      /** The bounds of a `Range` object. */
+      range: Record<"min" | "max", string>
+      /** The stop methods. */
+      stops: Record<"from" | "via" | "to" | "fade", string>
+    }
+  }
+  compWrite: {
+    /** `__compWrite(owner, prop, axis, v)` / `__compOp(owner, prop, axis, op, v)` — inject exports. */
+    write: string
+    op: string
+    /** The owner's hook the helpers call, and its static list of routed props (stripped once read). */
+    hook: string
+    list: string
+    /** The component names a routed write may target. */
+    axes: string[]
+  }
+  assets: {
+    /** `asset("./x")` → the asset's URL, at compile time. */
+    macro: string
+  }
+}
+
+export const chiselVocab: ChiselVocab = {
+  schema: 1,
+  ui: {
+    factories: [
+      "UIColumn", "UIRow", "UIBox", "UIButton", "UIScrollable", "UIScreen", "UIWidget",
+      "UIModal", "UIPopover", "UIBottomSheet", "UIPager",
+    ],
+    raw: {
+      UIColumn: "__UIColumn", UIRow: "__UIRow", UIBox: "__UIBox", UIButton: "__UIButton",
+      UIScrollable: "__UIScrollable", UIScreen: "__UIScreen", UIWidget: "__UIWidget",
+    },
+    leaves: [
+      "UIText", "UIImage", "UIVideo", "UIInput", "UITextArea", "UISpacer",
+      "UITabs", "UIVirtualizedList", "NativeView", "CameraView", "MapView", "QRScanner",
+    ],
+    containers: [ "UIColumn", "UIRow", "UIBox", "UIButton", "UIScrollable", "UIScreen", "UIWidget" ],
+    text: "UIText",
+    // Exactly the builder methods that return the node (tests/compile/chisel-vocab.test.ts proves it against
+    // the interfaces): `animateTo` / `animateFrom` return an Animation, so they are NOT here.
+    chain: [
+      "style", "class", "named",
+      "onClick", "onTouchStart", "onLongPress", "onMouseEnter", "onLayout", "onOpen", "onClose", "onBack",
+      "onScroll", "onScrollRelease", "onOverscroll", "onRefresh", "onSubmit",
+      "onSelect", "onChange", "onFocus", "onBlur", "onOverlayTap", "onDetent",
+      "onEndReached", "onStartReached",
+      "append", "insert", "remove", "setContent", "keepAlive",
+      "attachTo", "detents", "dismissible", "transition", "setSourceRect",
+      "push", "pop", "popToRoot", "replace", "select",
+      // UITabs / UIVirtualizedList / the native views (NativeView, CameraView, MapView, QRScanner)
+      "badge", "setData", "update", "prepend", "removeByKey",
+      "on", "off", "onReady", "onError", "onTap", "onMove", "onScan",
+      "flyTo", "jumpTo", "fitPoints", "setPadding", "setUserLocation",
+    ],
+    setContent: "setContent",
+    bindingMethods: [ "style", "class" ],
+    mapHelper: "__uiMap",
+  },
+  signals: {
+    factories: [ "signal", "computed" ],
+    value: "value",
+  },
+  fusion: {
+    vec3: {
+      class: "Vec3",
+      fields: [ "x", "y", "z" ],
+      statics: [ "up", "down", "left", "right", "forward", "back", "zero", "one", "from" ],
+      returning: [
+        "add", "sub", "mul", "div", "scale", "negate", "scaleAndAdd", "cross", "lerp", "clamp", "min",
+        "max", "reflect", "project", "rotateX", "rotateY", "rotateZ", "rotate", "transform", "withX",
+        "withY", "withZ", "clone", "normalize", "copy", "set",
+      ],
+      methods: {
+        add: "add", sub: "sub", mul: "mul", scale: "scale", negate: "negate", scaleAndAdd: "scaleAndAdd",
+        cross: "cross", normalize: "normalize", dot: "dot", lengthSq: "lengthSq", length: "length", distanceTo: "distanceTo",
+      },
+    },
+    date: {
+      factory: "date",
+      class: "DateValue",
+      toMs: "toMs",
+      formatImpl: "formatImpl",
+      timeAgoImpl: "timeAgoImpl",
+      field: "t",
+      returning: [ "add", "subtract", "startOf", "endOf" ],
+      methods: {
+        add: "add", subtract: "subtract", format: "format", timeAgo: "timeAgo", valueOf: "valueOf",
+        unix: "unix", diff: "diff", isBefore: "isBefore", isAfter: "isAfter", isSame: "isSame",
+      },
+    },
+    curve: {
+      factory: "curve",
+      colorFactory: "colorCurve",
+      data: "_data",
+      range: { min: "min", max: "max" },
+      stops: { from: "from", via: "via", to: "to", fade: "fade" },
+    },
+  },
+  compWrite: {
+    write: "__compWrite",
+    op: "__compOp",
+    hook: "_writeComp",
+    list: "_comps",
+    axes: [ "x", "y", "z", "w" ],
+  },
+  assets: {
+    macro: "asset",
+  },
+}

package/src/compile/assetMacro.ts

@@ -1,4 +1,4 @@
-// Ported from packages/lecodes-cli/src/compile/assetMacro.ts (itself from the backend). The
+// Ported from tools/cli/src/compile/assetMacro.ts (itself from the backend). The
 // compile-time `asset('./x.png')` macro is desugared into a real import so it goes through the same
 // loader/resolver as a hand-written import.
 

package/src/compile/bundler.ts

@@ -7,6 +7,7 @@ import { collectAssetMacros, desugarAssetMacros, hasAssetMacro, type AssetMacroR
 import { scanModulesFallback, type ScanModule } from "./detectEntry"
 import { hasAspectExtends, injectAspectNames } from "./aspectMacro"
 import { hasImportStatement, rewriteLibraryImports } from "./libraryImports"
+import { chiselVocab } from "../chisel"
 
 /*
  * The user-project bundler. Project files live in an in-memory map; the whole SDK is delivered via
@@ -49,7 +50,9 @@ const normalize = (path: string): string => {
 // `EDITOR` is a boolean define: `false` (const-folded, `if (EDITOR)` branches DCE'd away) in
 // every shipped bundle, `true` only in scene-editor compiles (CompileOptions.editor). Requires a
 // chisel with boolean-define support — an older binary ignores the entry and leaves `EDITOR` as a
-// free identifier (a runtime ReferenceError only in code that actually uses it).
+// free identifier (a runtime ReferenceError in code that uses it). The SDK itself uses it: the
+// edit-mode branches of src/scene/defineScene.ts read `EDITOR && isEditMode()`, so a shipped bundle
+// carries no editor code (sdk/tests/scene/editor-contract.test.ts).
 const CHISEL_DEFINE: Record<string, string> = { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" }
 
 // Methods the native host invokes by name have no in-bundle caller, so method-DCE can't see them.
@@ -62,6 +65,9 @@ const CHISEL_KEEP = [ "_*" ]
  *  src/server/inject.ts). A bundle gets exactly one of them. */
 export const CLIENT_INJECT = "/__sdk/inject.ts"
 export const SERVER_INJECT = "/__sdk/server/inject.ts"
+/** What an EDITOR bundle gets on top of the client SDK (`editor: true`): the scene editor's
+ *  contract, `__sceneEditor` (src/inject.editor.ts → src/scene/editor.ts). Never in a shipped bundle. */
+export const EDITOR_INJECT = "/__sdk/inject.editor.ts"
 
 /** The SDK source root (parent of `inject.ts`). chisel needs the source tree, not a prebuilt bundle. */
 const resolveSdkSrc = (): string => {
@@ -248,7 +254,7 @@ const bundleProjectChisel = async (
   const input = JSON.stringify({
     files: { ...sdkFiles, ...projFiles },
     entry,
-    inject: [ inject ],
+    inject: editor ? [ inject, EDITOR_INJECT ] : [ inject ],
     format,
     minify,
     // Chain fusion, ON by default (`LECODES_CHISEL_FUSE=0` opts out): Vec3/date math chains lower to
@@ -268,6 +274,9 @@ const bundleProjectChisel = async (
     // this only drops an array allocation per call site. Safe to always request: the sibling SDK
     // source above has the variadic dispatch, and an older binary ignores the unknown field.
     flatten_ui: process.env.LECODES_CHISEL_FLATTEN_UI !== "0",
+    // The SDK names the passes key on (src/chisel.ts). chisel uses only these; a chisel that
+    // predates the field ignores it and keeps its built-in lists.
+    vocab: chiselVocab,
   })
 
   const bin = resolveChiselBin()