@motionscript/code 0.0.0-stage → 0.1.0-alpha.0

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './node.js';
+export * from './engine.js';
+export { NODES } from "./nodes.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC","sourcesContent":["export * from './node';\nexport * from './engine';\nexport { NODES } from \"./nodes\";\n"]}

package/dist/layout.d.ts

@@ -0,0 +1,77 @@
+import type { InsetsResolved, MeasureContext2D, RenderContext2D } from "@motionscript/core";
+import type { TokenAdvanceCache } from "./measure-cache.js";
+import type { IdLine } from "./tokens.js";
+/**
+ * Everything about a listing's geometry that is *not* its content — the type,
+ * the padding, whether there is a gutter. Split out from the node so a layout
+ * can be computed for a token structure the node is no longer holding: during a
+ * structural transition the frame is the interpolation of two of them, and the
+ * one that is going away is not reachable through `this` any more.
+ */
+export interface CodeMetrics {
+    fontSize: number;
+    fontFamily: string;
+    lineHeight: number;
+    letterSpacing: number;
+    padding: InsetsResolved;
+    showLineNumbers: boolean;
+    lineNumberGap: number;
+}
+/** Where one token sits: its LEFT edge, and the vertical CENTRE of its line's slot. */
+export interface TokenBox {
+    x: number;
+    y: number;
+}
+/**
+ * A resolved listing geometry: every token placed, in the node's own space
+ * (origin at the block's centre, y-up).
+ *
+ * Positions are absolute rather than "a running sum plus a width scale", which
+ * is the whole point. A token's place in the *next* structure is knowable
+ * without drawing it, so a transition can move a token from where it was to
+ * where it will be instead of faking the motion by collapsing the advance of
+ * its neighbours — which is what made an insert look like a pile of glyphs at
+ * the left margin springing apart.
+ */
+export interface CodeLayout {
+    /** Token id → placement. */
+    tokens: Map<number, TokenBox>;
+    /** Vertical centre of each line's slot, by line index. */
+    lineY: number[];
+    /**
+     * Width of each line's ink, by line index — the sum of its tokens' advances,
+     * so a blank line is `0` and a short line is short.
+     *
+     * Returned rather than kept local because it is the only thing that knows a
+     * listing is **ragged**: `innerW` is the longest line, and everything that
+     * asks where the text actually is (hit testing, for one) would otherwise have
+     * to treat the block as a rectangle the width of its longest row.
+     */
+    lineW: number[];
+    /** Line id → its index in this structure (i.e. its line *number* minus one). */
+    lineIndex: Map<number, number>;
+    gutter: number;
+    gutterGap: number;
+    /** Content size, no padding. */
+    innerW: number;
+    innerH: number;
+    /** Content size plus padding — what the block draws and measures as. */
+    blockW: number;
+    blockH: number;
+    /** Left edge of the code column (after padding and gutter). */
+    startX: number;
+}
+/**
+ * Signature of everything a layout depends on other than the token structure
+ * itself. A cached layout survives exactly as long as this is unchanged.
+ */
+export declare function metricsSignature(m: CodeMetrics): string;
+/**
+ * Place every token of `lines`.
+ *
+ * Pure in (lines, metrics, font measurements), which is what lets a caller cache
+ * one per structure rather than recomputing it per frame — a transition's two
+ * endpoints are both fixed for its whole duration.
+ */
+export declare function layoutCode(lines: IdLine[], m: CodeMetrics, cache: TokenAdvanceCache, scope: MeasureContext2D | RenderContext2D): CodeLayout;
+//# sourceMappingURL=layout.d.ts.map

package/dist/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,uFAAuF;AACvF,MAAM,WAAW,QAAQ;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,UAAU;IACvB,4BAA4B;IAC5B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC9B,0DAA0D;IAC1D,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,gFAAgF;IAChF,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAOvD;AAwBD;;;;;;GAMG;AACH,wBAAgB,UAAU,CACtB,KAAK,EAAE,MAAM,EAAE,EACf,CAAC,EAAE,WAAW,EACd,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,gBAAgB,GAAG,eAAe,GAC1C,UAAU,CA0CZ"}

package/dist/layout.js

@@ -0,0 +1,74 @@
+/**
+ * Signature of everything a layout depends on other than the token structure
+ * itself. A cached layout survives exactly as long as this is unchanged.
+ */
+export function metricsSignature(m) {
+    const p = m.padding;
+    return [
+        m.fontSize, m.fontFamily, m.lineHeight, m.letterSpacing,
+        p.left, p.right, p.top, p.bottom,
+        m.showLineNumbers ? 1 : 0, m.lineNumberGap,
+    ].join("|");
+}
+/**
+ * Horizontal gap between the line-number column and the code text. Sized in
+ * space-widths so it scales with the font, and measured with letterSpacing 0 —
+ * line numbers and the gap don't carry the code's letter-spacing.
+ */
+function gutterGapOf(scope, m, cache) {
+    return cache.advance(scope, " ", m.fontSize, m.fontFamily, 0) * m.lineNumberGap;
+}
+/** Width of the line-number column for a structure of `lineCount` lines, gap included. */
+function gutterOf(scope, m, cache, lineCount, gap) {
+    if (!m.showLineNumbers)
+        return 0;
+    const sample = String(Math.max(1, lineCount));
+    return cache.advance(scope, sample, m.fontSize, m.fontFamily, 0) + gap;
+}
+/**
+ * Place every token of `lines`.
+ *
+ * Pure in (lines, metrics, font measurements), which is what lets a caller cache
+ * one per structure rather than recomputing it per frame — a transition's two
+ * endpoints are both fixed for its whole duration.
+ */
+export function layoutCode(lines, m, cache, scope) {
+    const lineH = m.fontSize * m.lineHeight;
+    const gutterGap = m.showLineNumbers ? gutterGapOf(scope, m, cache) : 0;
+    const gutter = gutterOf(scope, m, cache, lines.length, gutterGap);
+    const widths = new Array(lines.length);
+    let maxLineWidth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        let w = 0;
+        for (const tok of lines[i].tokens) {
+            w += cache.advance(scope, tok.content, m.fontSize, m.fontFamily, m.letterSpacing);
+        }
+        widths[i] = w;
+        if (w > maxLineWidth)
+            maxLineWidth = w;
+    }
+    const innerW = maxLineWidth + gutter;
+    const innerH = lines.length * lineH;
+    const blockW = innerW + m.padding.left + m.padding.right;
+    const blockH = innerH + m.padding.top + m.padding.bottom;
+    const startX = -blockW / 2 + m.padding.left + gutter;
+    // y-up author space: the first line sits at the TOP of the block, so the
+    // cursor starts at the top edge (+half height, minus top padding) and steps
+    // DOWNWARD by subtracting a line height per row.
+    const startY = blockH / 2 - m.padding.top;
+    const tokens = new Map();
+    const lineY = new Array(lines.length);
+    const lineIndex = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const centerY = startY - i * lineH - lineH / 2;
+        lineY[i] = centerY;
+        lineIndex.set(lines[i].id, i);
+        let x = startX;
+        for (const tok of lines[i].tokens) {
+            tokens.set(tok.id, { x, y: centerY });
+            x += cache.advance(scope, tok.content, m.fontSize, m.fontFamily, m.letterSpacing);
+        }
+    }
+    return { tokens, lineY, lineW: widths, lineIndex, gutter, gutterGap, innerW, innerH, blockW, blockH, startX };
+}
+//# sourceMappingURL=layout.js.map

package/dist/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"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","sourcesContent":["import type { InsetsResolved, MeasureContext2D, RenderContext2D } from \"@motionscript/core\";\nimport type { TokenAdvanceCache } from \"./measure-cache\";\nimport type { IdLine } from \"./tokens\";\n\n/**\n * Everything about a listing's geometry that is *not* its content — the type,\n * the padding, whether there is a gutter. Split out from the node so a layout\n * can be computed for a token structure the node is no longer holding: during a\n * structural transition the frame is the interpolation of two of them, and the\n * one that is going away is not reachable through `this` any more.\n */\nexport interface CodeMetrics {\n    fontSize: number;\n    fontFamily: string;\n    lineHeight: number;\n    letterSpacing: number;\n    padding: InsetsResolved;\n    showLineNumbers: boolean;\n    lineNumberGap: number;\n}\n\n/** Where one token sits: its LEFT edge, and the vertical CENTRE of its line's slot. */\nexport interface TokenBox {\n    x: number;\n    y: number;\n}\n\n/**\n * A resolved listing geometry: every token placed, in the node's own space\n * (origin at the block's centre, y-up).\n *\n * Positions are absolute rather than \"a running sum plus a width scale\", which\n * is the whole point. A token's place in the *next* structure is knowable\n * without drawing it, so a transition can move a token from where it was to\n * where it will be instead of faking the motion by collapsing the advance of\n * its neighbours — which is what made an insert look like a pile of glyphs at\n * the left margin springing apart.\n */\nexport interface CodeLayout {\n    /** Token id → placement. */\n    tokens: Map<number, TokenBox>;\n    /** Vertical centre of each line's slot, by line index. */\n    lineY: number[];\n    /**\n     * Width of each line's ink, by line index — the sum of its tokens' advances,\n     * so a blank line is `0` and a short line is short.\n     *\n     * Returned rather than kept local because it is the only thing that knows a\n     * listing is **ragged**: `innerW` is the longest line, and everything that\n     * asks where the text actually is (hit testing, for one) would otherwise have\n     * to treat the block as a rectangle the width of its longest row.\n     */\n    lineW: number[];\n    /** Line id → its index in this structure (i.e. its line *number* minus one). */\n    lineIndex: Map<number, number>;\n    gutter: number;\n    gutterGap: number;\n    /** Content size, no padding. */\n    innerW: number;\n    innerH: number;\n    /** Content size plus padding — what the block draws and measures as. */\n    blockW: number;\n    blockH: number;\n    /** Left edge of the code column (after padding and gutter). */\n    startX: number;\n}\n\n/**\n * Signature of everything a layout depends on other than the token structure\n * itself. A cached layout survives exactly as long as this is unchanged.\n */\nexport function metricsSignature(m: CodeMetrics): string {\n    const p = m.padding;\n    return [\n        m.fontSize, m.fontFamily, m.lineHeight, m.letterSpacing,\n        p.left, p.right, p.top, p.bottom,\n        m.showLineNumbers ? 1 : 0, m.lineNumberGap,\n    ].join(\"|\");\n}\n\n/**\n * Horizontal gap between the line-number column and the code text. Sized in\n * space-widths so it scales with the font, and measured with letterSpacing 0 —\n * line numbers and the gap don't carry the code's letter-spacing.\n */\nfunction gutterGapOf(scope: MeasureContext2D | RenderContext2D, m: CodeMetrics, cache: TokenAdvanceCache): number {\n    return cache.advance(scope, \" \", m.fontSize, m.fontFamily, 0) * m.lineNumberGap;\n}\n\n/** Width of the line-number column for a structure of `lineCount` lines, gap included. */\nfunction gutterOf(\n    scope: MeasureContext2D | RenderContext2D,\n    m: CodeMetrics,\n    cache: TokenAdvanceCache,\n    lineCount: number,\n    gap: number,\n): number {\n    if (!m.showLineNumbers) return 0;\n    const sample = String(Math.max(1, lineCount));\n    return cache.advance(scope, sample, m.fontSize, m.fontFamily, 0) + gap;\n}\n\n/**\n * Place every token of `lines`.\n *\n * Pure in (lines, metrics, font measurements), which is what lets a caller cache\n * one per structure rather than recomputing it per frame — a transition's two\n * endpoints are both fixed for its whole duration.\n */\nexport function layoutCode(\n    lines: IdLine[],\n    m: CodeMetrics,\n    cache: TokenAdvanceCache,\n    scope: MeasureContext2D | RenderContext2D,\n): CodeLayout {\n    const lineH = m.fontSize * m.lineHeight;\n    const gutterGap = m.showLineNumbers ? gutterGapOf(scope, m, cache) : 0;\n    const gutter = gutterOf(scope, m, cache, lines.length, gutterGap);\n\n    const widths: number[] = new Array(lines.length);\n    let maxLineWidth = 0;\n    for (let i = 0; i < lines.length; i++) {\n        let w = 0;\n        for (const tok of lines[i].tokens) {\n            w += cache.advance(scope, tok.content, m.fontSize, m.fontFamily, m.letterSpacing);\n        }\n        widths[i] = w;\n        if (w > maxLineWidth) maxLineWidth = w;\n    }\n\n    const innerW = maxLineWidth + gutter;\n    const innerH = lines.length * lineH;\n    const blockW = innerW + m.padding.left + m.padding.right;\n    const blockH = innerH + m.padding.top + m.padding.bottom;\n    const startX = -blockW / 2 + m.padding.left + gutter;\n    // y-up author space: the first line sits at the TOP of the block, so the\n    // cursor starts at the top edge (+half height, minus top padding) and steps\n    // DOWNWARD by subtracting a line height per row.\n    const startY = blockH / 2 - m.padding.top;\n\n    const tokens = new Map<number, TokenBox>();\n    const lineY: number[] = new Array(lines.length);\n    const lineIndex = new Map<number, number>();\n\n    for (let i = 0; i < lines.length; i++) {\n        const centerY = startY - i * lineH - lineH / 2;\n        lineY[i] = centerY;\n        lineIndex.set(lines[i].id, i);\n        let x = startX;\n        for (const tok of lines[i].tokens) {\n            tokens.set(tok.id, { x, y: centerY });\n            x += cache.advance(scope, tok.content, m.fontSize, m.fontFamily, m.letterSpacing);\n        }\n    }\n\n    return { tokens, lineY, lineW: widths, lineIndex, gutter, gutterGap, innerW, innerH, blockW, blockH, startX };\n}\n"]}

package/dist/measure-cache.d.ts

@@ -0,0 +1,38 @@
+import { MeasureContext2D, RenderContext2D } from "@motionscript/core";
+/**
+ * Memoizes text-advance measurements for the Code node.
+ *
+ * `scope.measureText` runs a full CanvasKit/Skia paragraph layout (shaping plus
+ * font object alloc/free) on every call — far too expensive to repeat for every
+ * token on every frame. A token's advance only depends on (content, fontSize,
+ * fontFamily, letterSpacing); content changes only at edit time and the font
+ * inputs only change via props, so the same string measures to the same width
+ * across the many static frames the player renders.
+ *
+ * fontSize + fontFamily fold into a `signature` checked once per frame: when it
+ * changes the cache clears. letterSpacing folds into the per-entry key so the
+ * letter-spaced token advances and the unspaced gutter advances coexist in one
+ * map. The signature check (not the node's `set()`) is the invalidation point on
+ * purpose — animated/bound font props (`to({ fontSize })`, `fontSize={() => …}`)
+ * bypass `set()` but still flow through the per-frame signature comparison.
+ *
+ * NOTE: the two `measureText` implementations in packages/browser/src
+ * (measure-scope.ts and render-context.ts) are uncached and shape+free fonts on
+ * every call. A shared cache there would speed up all text nodes, but it touches
+ * shared infra and cross-font correctness, so it's intentionally left out here.
+ */
+export declare class TokenAdvanceCache {
+    private cache;
+    private sig;
+    /** Signature of the font inputs that, when changed, invalidate every entry. */
+    signature(fontSize: number, fontFamily: string): string;
+    /** Clear the cache if the font signature changed since the last frame. */
+    sync(sig: string): void;
+    /**
+     * Advance width of `content`, measured once per unique (content,
+     * letterSpacing) pair under the current font signature. Call `sync()` first
+     * each frame so a font change is reflected.
+     */
+    advance(scope: MeasureContext2D | RenderContext2D, content: string, fontSize: number, fontFamily: string, letterSpacing: number): number;
+}
+//# sourceMappingURL=measure-cache.d.ts.map

package/dist/measure-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-cache.d.ts","sourceRoot":"","sources":["../src/measure-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,GAAG,CAAM;IAEjB,+EAA+E;IAC/E,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAIvD,0EAA0E;IAC1E,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOvB;;;;OAIG;IACH,OAAO,CACH,KAAK,EAAE,gBAAgB,GAAG,eAAe,EACzC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,GACtB,MAAM;CAYZ"}

package/dist/measure-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure-cache.js","sourceRoot":"","sources":["../src/measure-cache.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,iBAAiB;IAClB,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IAClC,GAAG,GAAG,EAAE,CAAC;IAEjB,+EAA+E;IAC/E,SAAS,CAAC,QAAgB,EAAE,UAAkB;QAC1C,OAAO,GAAG,QAAQ,IAAI,UAAU,EAAE,CAAC;IACvC,CAAC;IAED,0EAA0E;IAC1E,IAAI,CAAC,GAAW;QACZ,IAAI,GAAG,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;YACnB,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACnB,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,OAAO,CACH,KAAyC,EACzC,OAAe,EACf,QAAgB,EAChB,UAAkB,EAClB,aAAqB;QAErB,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;QACnC,MAAM,GAAG,GAAG,GAAG,OAAO,IAAI,aAAa,EAAE,CAAC;QAC1C,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,GAAG,KAAK,SAAS;YAAE,OAAO,GAAG,CAAC;QAClC,wEAAwE;QACxE,8DAA8D;QAC9D,iDAAiD;QACjD,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;QAC7F,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC3B,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ","sourcesContent":["import { MeasureContext2D, RenderContext2D } from \"@motionscript/core\";\r\n\r\n/**\r\n * Memoizes text-advance measurements for the Code node.\r\n *\r\n * `scope.measureText` runs a full CanvasKit/Skia paragraph layout (shaping plus\r\n * font object alloc/free) on every call — far too expensive to repeat for every\r\n * token on every frame. A token's advance only depends on (content, fontSize,\r\n * fontFamily, letterSpacing); content changes only at edit time and the font\r\n * inputs only change via props, so the same string measures to the same width\r\n * across the many static frames the player renders.\r\n *\r\n * fontSize + fontFamily fold into a `signature` checked once per frame: when it\r\n * changes the cache clears. letterSpacing folds into the per-entry key so the\r\n * letter-spaced token advances and the unspaced gutter advances coexist in one\r\n * map. The signature check (not the node's `set()`) is the invalidation point on\r\n * purpose — animated/bound font props (`to({ fontSize })`, `fontSize={() => …}`)\r\n * bypass `set()` but still flow through the per-frame signature comparison.\r\n *\r\n * NOTE: the two `measureText` implementations in packages/browser/src\r\n * (measure-scope.ts and render-context.ts) are uncached and shape+free fonts on\r\n * every call. A shared cache there would speed up all text nodes, but it touches\r\n * shared infra and cross-font correctness, so it's intentionally left out here.\r\n */\r\nexport class TokenAdvanceCache {\r\n    private cache = new Map<string, number>();\r\n    private sig = \"\";\r\n\r\n    /** Signature of the font inputs that, when changed, invalidate every entry. */\r\n    signature(fontSize: number, fontFamily: string): string {\r\n        return `${fontSize}|${fontFamily}`;\r\n    }\r\n\r\n    /** Clear the cache if the font signature changed since the last frame. */\r\n    sync(sig: string): void {\r\n        if (sig !== this.sig) {\r\n            this.cache.clear();\r\n            this.sig = sig;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Advance width of `content`, measured once per unique (content,\r\n     * letterSpacing) pair under the current font signature. Call `sync()` first\r\n     * each frame so a font change is reflected.\r\n     */\r\n    advance(\r\n        scope: MeasureContext2D | RenderContext2D,\r\n        content: string,\r\n        fontSize: number,\r\n        fontFamily: string,\r\n        letterSpacing: number,\r\n    ): number {\r\n        if (content.length === 0) return 0;\r\n        const key = `${content}\u0000${letterSpacing}`;\r\n        const hit = this.cache.get(key);\r\n        if (hit !== undefined) return hit;\r\n        // Only the advance width is cached: a code block's geometry is a column\r\n        // of x offsets, and its line height comes from the node's own\r\n        // `lineHeight` prop rather than from the shaper.\r\n        const { width } = scope.measureText(content, fontSize, fontFamily, undefined, letterSpacing);\r\n        this.cache.set(key, width);\r\n        return width;\r\n    }\r\n}\r\n"]}

package/dist/node.d.ts

@@ -0,0 +1,293 @@
+import { RenderContext2D, RenderPass2D, Clip, EasingFunction, NodeConfig, Size2D, SizeConstraints, Node2D, Node2DProps, MeasureContext2D, InsetsResolved, InsetsProps, type AssetScope, type Command, type CommandArgs, type Node, type TweenStepper, type Vector2 } from "@motionscript/core";
+import { CodeRange, type CodeDiffStrategy, type CodePhaseStrategy, CodeTheme } from "./engine.js";
+/**
+ * A listing and nothing else — no paint slots, and no box behind the tokens.
+ *
+ * It did carry a `fill`/`overlay`/`stroke`/`shadow` set and the corner radius
+ * that shaped them, so a block could draw its own panel. That was one node doing
+ * two jobs, and the second one is a `Rect`'s: a listing set on a card is a `Code`
+ * inside a hugging `Rect`, which tracks the block's size for the same reason
+ * every other hugging container tracks its child's. What is left here is the
+ * listing — its source, how it is coloured, the face it is set in, and the space
+ * it keeps around itself.
+ */
+export interface CodeProps extends Node2DProps {
+    code: string;
+    language: string;
+    fontSize: number;
+    fontFamily: string;
+    /** A built-in/registered theme name (e.g. `'github-dark'`), or a {@link CodeHighlightStyle} object. */
+    theme: CodeTheme;
+    lineHeight: number;
+    letterSpacing: number;
+    showLineNumbers: boolean;
+    lineNumberGap: number;
+    padding: InsetsProps;
+}
+/**
+ * Construction-time-only options: pluggable engine behavior, set once when
+ * the node is created. Deliberately *not* part of {@link CodeProps} — every
+ * `@property` field accepts either a value or a zero-arg reactive binding
+ * (`value | (() => value)`, see `PropInputs`), and the node's own reactive
+ * write path (`_writeProp`) treats any function value as the latter. A
+ * strategy *is* a function, so it can't be told apart from a binding that
+ * computes one — it has to stay outside the reactive prop system entirely.
+ */
+export interface CodeStrategies {
+    /** Decides which token became which across an edit. Defaults to `defaultCodeDiff`. */
+    diffStrategy?: CodeDiffStrategy;
+    /** Decides when (in normalized transition time) each part of an edit happens. Defaults to `defaultCodePhases`. */
+    phaseStrategy?: CodePhaseStrategy;
+}
+export declare class Code extends Node2D<CodeProps> {
+    readonly code: string;
+    readonly language: string;
+    readonly fontFamily: string;
+    readonly theme: CodeTheme;
+    readonly fontSize: number;
+    readonly lineHeight: number;
+    readonly letterSpacing: number;
+    readonly showLineNumbers: boolean;
+    readonly lineNumberGap: number;
+    readonly padding: InsetsResolved;
+    /** The settled structure. During an edit, the structure the edit lands on. */
+    private tokenLines;
+    private tokenized;
+    private transitions;
+    private advanceCache;
+    private structureVersion;
+    private layoutCacheKey;
+    private layoutCache;
+    private highlightDimOpacity;
+    private highlightedIds;
+    /**
+     * Which token became which across an edit, and when each part of that
+     * edit happens. Construction-time-only (see {@link CodeStrategies}) —
+     * resolved once here rather than left as `?? defaultX` at every call site.
+     */
+    private readonly diffStrategy;
+    private readonly phaseStrategy;
+    constructor(props: NodeConfig<Code, CodeProps> & CodeStrategies);
+    set(props: {
+        [K in keyof CodeProps]?: CodeProps[K] | (() => CodeProps[K]);
+    }): void;
+    private tokenize;
+    /**
+     * Swap in a new settled structure, invalidating the layout cache.
+     *
+     * The one place `tokenLines` is written, because the cache key is a version
+     * counter rather than a hash of the content — a write that skipped the bump
+     * would keep serving the previous frame's geometry for the new listing.
+     */
+    private setLines;
+    /**
+     * The monospaced face this block measures and draws with, and the syntax
+     * grammar it tokenizes with.
+     *
+     * Both belong to *layout*: token x positions are measured against the face,
+     * and how many tokens there are depends on the grammar. Declared here, the
+     * grammar goes on the timeline as an ordinary asset: `AssetManager.loadAt`
+     * waits for it before the frame is laid out, so the first measurement is the
+     * right one. Nothing is freed on eviction — parsers are cheap to keep
+     * resident. The loader touches no node: `renderContent` re-tokenizes once
+     * the grammar is there.
+     */
+    declareAssets(assets: AssetScope): void;
+    private metrics;
+    /** The structural edit currently in flight, if any. */
+    private activeEdit;
+    private settledLayout;
+    /**
+     * The one or two layouts this frame is drawn from.
+     *
+     * A settled frame has one. A frame inside an edit has two — where every
+     * token was, and where it is going — and the frame is a point between them.
+     * That is the whole reason an insert no longer piles its glyphs at the left
+     * margin: a token's destination is *computed*, not approximated by collapsing
+     * the advance of everything around it.
+     *
+     * Both endpoints are fixed for the edit's duration, so they are built once
+     * and cached on the transition rather than rebuilt per frame.
+     */
+    private frameLayout;
+    measure(constraints: SizeConstraints, scope: MeasureContext2D): Partial<Size2D>;
+    protected renderContent(ctx: RenderPass2D): void;
+    protected renderSelf(ctx: RenderContext2D): void;
+    /** A listing holds a listing — `append`/`insert`/`erase` are how it grows. */
+    protected acceptsChild(_child: Node): boolean;
+    /**
+     * The node's laid-out rect as a clip outline, so `clip` and any backdrop
+     * effect are confined to the block rather than to nothing — a listing set on
+     * a card is exactly where a backdrop blur is asked for.
+     */
+    protected clipSelf(): Clip;
+    /**
+     * A listing is grabbed by its **text**, line by ragged line, rather than by
+     * the rectangle the lines were laid out in.
+     *
+     * The default narrows a node's grab region to the outline it declares, and
+     * this node's outline is a box it no longer paints anything into. Code is
+     * mostly whitespace: a ten-line snippet with one long line is a rectangle
+     * that is largely empty, and in an editor every one of those empty pixels
+     * swallows a click meant for whatever sits behind or beneath it. Short of the
+     * text itself there is nothing there to have clicked.
+     *
+     * So the region is the union of the lines' own extents — each a line-height
+     * slot as wide as that line's ink — plus the gutter where line numbers are
+     * showing, since those are drawn glyphs too.
+     *
+     * Answered from the **cached** layout, which is what the last frame drew
+     * from, because a hit test arrives with no measurement scope and text cannot
+     * be measured without one. Where there is no usable cache — before the first
+     * frame, or mid-edit, when the geometry is an interpolation of two structures
+     * held on the transition — the box is the honest answer rather than a
+     * silhouette measured against stale metrics.
+     */
+    protected hitTestSelf(local: Vector2, tolerance: number): boolean;
+    /**
+     * The layout a hit test may be answered from: the settled cache, and only
+     * while it still matches the node's current metrics.
+     *
+     * The key is the one {@link settledLayout} writes minus its scope-dependent
+     * half — every input to it (`metricsSignature`, the advance cache's own
+     * signature) is readable without a measurer, which is precisely what makes
+     * the check possible here.
+     */
+    private hitLayout;
+    /**
+     * Append `code` to the end of the listing.
+     *
+     * Stated as *what the source becomes*; {@link editTo} works out the rest —
+     * which is why appending a line that closes a block re-highlights the lines
+     * above it, instead of colouring the new text as its own program.
+     */
+    append(args: CommandArgs<{
+        code: string;
+    }> & {
+        duration: number;
+    }): Command<Record<string, never>>;
+    /** Insert `code` above the listing. */
+    prepend(args: CommandArgs<{
+        code: string;
+    }> & {
+        duration: number;
+    }): Command<Record<string, never>>;
+    /**
+     * Insert `code` at the given (line, col). Both are 1-indexed; col is the
+     * column BEFORE which the new content is inserted (col=1 means start of
+     * line). If `code` contains newlines, new lines are created in the middle
+     * of the existing line.
+     */
+    insert(args: CommandArgs<{
+        position: [number, number];
+        code: string;
+    }> & {
+        duration: number;
+    }): Command<Record<string, never>>;
+    /**
+     * Erase the code in `codeRange`.
+     *
+     * Named `erase` rather than `remove` because a `Code` is also a node, and
+     * `Node.remove(child)` takes a child out of the tree. Two methods spelled
+     * the same on one object, doing entirely different things, is worse than one
+     * of them having a slightly less obvious name.
+     *
+     * A range that covers whole lines takes their line breaks with it, so the
+     * rows below close up; a range inside a line takes only the characters, and
+     * the rest of the line reflows around the hole.
+     */
+    erase(args: CommandArgs<{
+        target: CodeRange;
+    }> & {
+        duration: number;
+    }): Command<Record<string, never>>;
+    /** Replace the code in `codeRange` with `replacement`. */
+    replace(args: CommandArgs<{
+        target: CodeRange;
+        replacement: string;
+    }> & {
+        duration: number;
+    }): Command<Record<string, never>>;
+    /**
+     * Highlight a range of code — or several at once (e.g.
+     * `CodeRanges.lines(2).word(5, 1, 3)`) — highlighted as one set: tokens
+     * within any of the ranges stay at opacity 1, tokens outside dim to
+     * `dim`. Persistent — call resetHighlight() to undo, or call highlight()
+     * again with a different range to cross-fade.
+     */
+    highlight(args: CommandArgs<{
+        target: CodeRange | Iterable<CodeRange>;
+        dim?: number;
+    }> & {
+        duration: number;
+    }): Command<Record<string, never>>;
+    /**
+     * Fade all dimmed tokens back to opacity 1 and clear the persistent
+     * highlight state.
+     */
+    resetHighlight(args: CommandArgs<Record<string, never>> & {
+        duration: number;
+    }): Command<Record<string, never>>;
+    /**
+     * Animate the listing to a new source.
+     *
+     * The engine behind every editing command, and behind `to({ code })`. Every
+     * edit is expressed as the source it produces, tokenized, and then *diffed*
+     * against what is on screen — so a token that survived the edit keeps its
+     * identity and simply travels to its new column, and only what genuinely
+     * changed is faded.
+     *
+     * The result runs in three phases (see `phaseStrategy`): what is leaving
+     * fades out, what stays reflows, and only then does what is new arrive.
+     * Playing them together is what made a replacement read as a cross-dissolve
+     * of two unrelated listings rather than as an edit being made.
+     */
+    private editTo;
+    /**
+     * Put a dim transition on the stack, drive its progress, take it off and
+     * commit at the end.
+     *
+     * A {@link Command} rather than a generator, which is what makes a listing
+     * scrubbable: membership is a function of `t` (on the stack for `0 < t < 1`,
+     * off it outside), `settle(done)` replaces the `finally` and takes *which
+     * way*, and `progress` is assigned from `t` rather than accumulated.
+     */
+    private runDim;
+    /**
+     * Route a tweened `code` through the diff engine.
+     *
+     * `to({ code })` is the form an author reaches for first — it is how every
+     * other prop is animated — and a bare string prop would otherwise land in the
+     * generic tween's discrete-snap bucket and simply cut at the end. Intercepted
+     * here it becomes the same three-phase edit the named commands produce, while
+     * the rest of the step's props tween alongside it untouched.
+     */
+    _prepareStep(to: Partial<CodeProps>, duration: number, easing?: EasingFunction): TweenStepper;
+    /**
+     * Find every range matching the literal string `text` in the current
+     * source. Multi-line matches are supported.
+     */
+    findAllRanges(text: string): CodeRange[];
+    /** Find the `index`th range matching `text`. Returns null if not found. */
+    findRangeAt(text: string, index: number): CodeRange | null;
+    /** Find the first range matching `text`. Returns null if not found. */
+    findFirstRange(text: string): CodeRange | null;
+    private joinedSource;
+    private lineLengths;
+    /** Character offset of a 1-indexed (line, col), clamped into the document. */
+    private offsetAt;
+    /**
+     * Resolve one or more CodeRanges to the set of token ids whose content
+     * overlaps any of them. Tokens that partially overlap are included.
+     */
+    private tokenIdsInRanges;
+    /**
+     * Thin delegator: everything about *how* a frame is painted (settled or
+     * mid structural-edit, entry/exit motion, colour cross-fade) lives in
+     * `drawCode` (the engine's `render.ts`) as a pure function over plain
+     * state — this just gathers that state from the node's own instance
+     * fields and caches.
+     */
+    protected drawSelf(draw: RenderContext2D): void;
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,eAAe,EACxF,MAAM,EAAE,WAAW,EAAE,gBAAgB,EAAE,cAAc,EAAE,WAAW,EAE3C,KAAK,UAAU,EAAE,KAAK,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,IAAI,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EACrH,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACH,SAAS,EAOT,KAAK,gBAAgB,EAUrB,KAAK,iBAAiB,EAKtB,SAAS,EAGZ,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAU,SAAQ,WAAW;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,uGAAuG;IACvG,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,WAAW,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC3B,sFAAsF;IACtF,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,kHAAkH;IAClH,aAAa,CAAC,EAAE,iBAAiB,CAAC;CACrC;AAED,qBAUa,IAAK,SAAQ,MAAM,CAAC,SAAS,CAAC;IAEvC,SAA4C,IAAI,EAAE,MAAM,CAAC;IACzD,SAAsD,QAAQ,EAAE,MAAM,CAAC;IACvE,SAAqD,UAAU,EAAE,MAAM,CAAC;IACxE,SAAoE,KAAK,EAAE,SAAS,CAAC;IACrF,SAA4C,QAAQ,EAAE,MAAM,CAAC;IAC7D,SAA6C,UAAU,EAAE,MAAM,CAAC;IAIhE,SAA6C,aAAa,EAAE,MAAM,CAAC;IACnE,SAA+C,eAAe,EAAE,OAAO,CAAC;IAIxE,SAA2C,aAAa,EAAE,MAAM,CAAC;IACjE,SAA6F,OAAO,EAAE,cAAc,CAAC;IAErH,8EAA8E;IAC9E,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO,CAAC,WAAW,CAAwB;IAI3C,OAAO,CAAC,YAAY,CAA2B;IAM/C,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,WAAW,CAA2B;IAI9C,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,cAAc,CAA0B;IAEhD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmB;IAChD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoB;gBAEtC,KAAK,EAAE,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,cAAc;IAiB/D,GAAG,CAAC,KAAK,EAAE;SAAG,CAAC,IAAI,MAAM,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC;KAAE,GAAG,IAAI;IAOlF,OAAO,CAAC,QAAQ;IAOhB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAQhB;;;;;;;;;;;OAWG;IACM,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAQhD,OAAO,CAAC,OAAO;IAYf,uDAAuD;IACvD,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,aAAa;IASrB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,WAAW;IAoBV,OAAO,CAAC,WAAW,EAAE,eAAe,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;cAyBrE,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;cA4BtC,UAAU,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI;IAIzD,8EAA8E;cAC3D,YAAY,CAAC,MAAM,EAAE,IAAI,GAAG,OAAO;IAItD;;;;OAIG;cACgB,QAAQ,IAAI,IAAI;IAOnC;;;;;;;;;;;;;;;;;;;;;OAqBG;cACgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAwB1E;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IASjB;;;;;;OAMG;IAEH,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAKlG,uCAAuC;IAEvC,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAKnG;;;;;OAKG;IAeH,MAAM,CACF,IAAI,EAAE,WAAW,CAAC;QAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GACvF,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAOjC;;;;;;;;;;;OAWG;IAEH,KAAK,CACD,IAAI,EAAE,WAAW,CAAC;QAAE,MAAM,EAAE,SAAS,CAAA;KAAE,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAChE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAsBjC,0DAA0D;IAE1D,OAAO,CACH,IAAI,EAAE,WAAW,CAAC;QAAE,MAAM,EAAE,SAAS,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GACrF,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAOjC;;;;;;OAMG;IAEH,SAAS,CACL,IAAI,EAAE,WAAW,CAAC;QAAE,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GACpG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAgCjC;;;OAGG;IAEH,cAAc,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAsB/G;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM;IAkDd;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM;IAmBd;;;;;;;;OAQG;IACM,YAAY,CACjB,EAAE,EAAE,OAAO,CAAC,SAAS,CAAC,EACtB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,cAAc,GACxB,YAAY;IA6Bf;;;OAGG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE;IAexC,2EAA2E;IAC3E,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAK1D,uEAAuE;IACvE,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAI9C,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,WAAW;IAMnB,8EAA8E;IAC9E,OAAO,CAAC,QAAQ;IAUhB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IA2BxB;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;CAWlD"}