@glissade/scene 0.11.0 → 0.12.0-pre.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { $ as breakLines, A as Polyline, B as validateHachure, C as Video, Ct as IDENTITY, D as revealSchedule, Dt as invert, E as pathFromSegs, Et as fromTRS, F as flatten, G as HitArea, H as AnchorSpec, I as hachureLines, J as PropInit, K as Node, L as resolveSketch, M as SketchStyle, N as SketchValidationError, O as roundedRectSegs, Ot as matEquals, P as arcLength, Q as TextMetricsLite, R as roughen, S as TextProps, St as validateFilters, T as WordBox, Tt as applyToPoint, U as BindablePropTarget, V as validateSketch, W as EvalContext, X as MEASURE_QUANTUM_PX, Y as resolveAnchor, Z as TextMeasurer, _ as PathProps, _t as ShaderRef, a as LayoutEngineMissingError, at as BlendMode, b as ShapeProps, bt as filtersToCanvasFilter, c as requireLayoutEngine, ct as DrawCommand, d as Custom, dt as FontSpec, et as estimatingMeasurer, f as Group, ft as Paint, g as Path, gt as ResourceId, h as LineBox, ht as Resource, i as LayoutEngine, it as setDefaultMeasurer, j as ResolvedSketch, k as HachureSpec, kt as multiply, l as setLayoutEngine, lt as FilterSpec, m as ImageProps, mt as Rect$1, n as LayoutChildSpec, nt as segmentGraphemes, ot as DisplayList, p as ImageNode, pt as PathSeg, q as NodeProps, r as LayoutContainerSpec, rt as segmentWords, s as getLayoutEngine, st as DisplayListBuilder, t as LayoutBox, tt as quantize, u as Circle, ut as FilterValidationError, v as Rect, vt as StrokeStyle, w as VideoProps, wt as Mat2x3, x as Text, xt as glow, y as RevealMark, yt as createDisplayListBuilder, z as sketchStrokes } from "./layoutEngine.js";
-import { BindableSignal, BoundTimeline, CompiledTimeline, CoverageReport, EaseSpec, FontMode, FontUsage, PathValue, Playhead, Timeline, Track, Vec2 } from "@glissade/core";
+import { $ as breakLines, A as Polyline, At as invert, B as validateHachure, C as Video, Ct as filtersToCanvasFilter, D as revealSchedule, Dt as Mat2x3, E as pathFromSegs, Et as IDENTITY, F as flatten, G as HitArea, H as AnchorSpec, I as hachureLines, J as PropInit, K as Node, L as resolveSketch, M as SketchStyle, Mt as multiply, N as SketchValidationError, O as roundedRectSegs, Ot as applyToPoint, P as arcLength, Q as TextMetricsLite, R as roughen, S as TextProps, St as createDisplayListBuilder, T as WordBox, Tt as validateFilters, U as BindablePropTarget, V as validateSketch, W as EvalContext, X as MEASURE_QUANTUM_PX, Y as resolveAnchor, Z as TextMeasurer, _ as PathProps, _t as Rect$1, a as LayoutEngineMissingError, at as BlendMode, b as ShapeProps, bt as ShaderRef, c as requireLayoutEngine, ct as DrawCommand, d as Custom, dt as FontSpec, et as estimatingMeasurer, f as Group, ft as MeshInterpolation, g as Path, gt as PathSeg, h as LineBox, ht as Paint, i as LayoutEngine, it as setDefaultMeasurer, j as ResolvedSketch, jt as matEquals, k as HachureSpec, kt as fromTRS, l as setLayoutEngine, lt as FilterSpec, m as ImageProps, mt as MeshPoint, n as LayoutChildSpec, nt as segmentGraphemes, ot as DisplayList, p as ImageNode, pt as MeshPaint, q as NodeProps, r as LayoutContainerSpec, rt as segmentWords, s as getLayoutEngine, st as DisplayListBuilder, t as LayoutBox, tt as quantize, u as Circle, ut as FilterValidationError, v as Rect, vt as Resource, w as VideoProps, wt as glow, x as Text, xt as StrokeStyle, y as RevealMark, yt as ResourceId, z as sketchStrokes } from "./layoutEngine.js";
+import { BindableSignal, BoundTimeline, CompiledTimeline, CoverageReport, EaseSpec, FontMode, FontUsage, MeshPaint as MeshPaint$1, PathValue, Playhead, Timeline, Track, Vec2 } from "@glissade/core";
 
 //#region src/taxonomy.d.ts
 
@@ -180,6 +180,102 @@ type GuardMode = 'throw' | 'warn' | 'off';
  */
 declare function withDeterminismGuards<T>(mode: GuardMode, fn: () => T): T;
 //#endregion
+//#region src/displayDiff.d.ts
+/**
+ * The collapse-replacer shared by the cacheKey serializer
+ * (`createDisplayListBuilder().cacheKey`), `cacheColdAudit.hashDisplayList`,
+ * and `serializeDisplayList` here. CRITICAL: this is BYTE-PRESERVING — the
+ * cacheKey it backs stamps into pushGroup and keys the §3.5 raster cache, so
+ * its output must not move. The three call sites previously DUPLICATED this
+ * byte-for-byte; it lives here once.
+ *
+ *  - ArrayBuffer / typed-array views collapse to a `ab:<len>` / `view:<len>`
+ *    length marker (opaque binary never belongs in a structural key).
+ *  - Functions drop (JSON would already drop them; explicit for parity).
+ *
+ * NOTE: `-0` is intentionally NOT normalized here. The matrix layer
+ * (`matrix.ts`) already normalizes `-0 → 0` at the source, and adding a `-0`
+ * pass to THIS replacer would change the cacheKey bytes for any list that ever
+ * carried a raw `-0` — silently invalidating the cache cluster-wide. Byte
+ * preservation wins; the regression guard pins the exact key.
+ */
+declare function collapseReplacer(_key: string, value: unknown): unknown;
+/**
+ * One index-aligned, positional delta between two DisplayList command streams.
+ *
+ * This is the natural per-command shape that `gs verify-determinism --bisect`
+ * (a later card) will consume to drill a cache-cold divergence down to the
+ * exact op/field. Keep it stable.
+ */
+interface CommandDelta {
+  /** Positional command index in BOTH lists (or the longer one for add/remove). */
+  index: number;
+  /**
+   *  - `change`  — same index present in both, but the commands differ.
+   *  - `add`     — present in `b` only (b is longer past this index).
+   *  - `remove`  — present in `a` only (a is longer past this index).
+   */
+  kind: 'change' | 'add' | 'remove';
+  /** op of the `a` command (undefined for `add`). */
+  opA?: DrawCommand['op'];
+  /** op of the `b` command (undefined for `remove`). */
+  opB?: DrawCommand['op'];
+  /**
+   * Field-level changes when both ops match (op changed → a single `op` field).
+   * Each entry names the changed prop path with its `from`/`to` JSON values.
+   */
+  fields: FieldChange[];
+}
+interface FieldChange {
+  /** dotted field path within the command, e.g. `paint.color`, `m`, `text`, `filters`. */
+  path: string;
+  from: unknown;
+  to: unknown;
+}
+interface DisplayDiff {
+  /** true when the two lists are byte-identical (the §3.3 determinism contract holds). */
+  equal: boolean;
+  /** per-command positional deltas, in index order (empty iff `equal`). */
+  deltas: CommandDelta[];
+  /** size mismatch, when the canvases differ (rare, but a real divergence). */
+  size?: {
+    from: DisplayList['size'];
+    to: DisplayList['size'];
+  };
+}
+/**
+ * Index-aligned positional diff of two DisplayLists. Command i in `a` is
+ * compared to command i in `b`; trailing commands become `add`/`remove`. A
+ * single insert/remove cascades — this is the documented v1 cliff.
+ */
+declare function diffDisplayLists(a: DisplayList, b: DisplayList): DisplayDiff;
+/** Human-readable, multi-line rendering of a DisplayDiff (CLI command-tree). */
+declare function formatDisplayDiff(diff: DisplayDiff): string;
+/**
+ * The `.dl.json` snapshot interchange schema (DESIGN §7.4). Users commit
+ * `.dl.json` baselines, so this carries the SAME break-policy obligation as
+ * `Timeline.version` and `SidecarDoc.sidecarVersion`: bump on a breaking shape
+ * change. Independent of the API version.
+ */
+declare const DL_SNAPSHOT_VERSION: 1;
+interface DlSnapshot {
+  /** Interchange schema version (§7.4) — the third versioned interchange document. */
+  dlSnapshotVersion: typeof DL_SNAPSHOT_VERSION;
+  size: DisplayList['size'];
+  commands: DrawCommand[];
+  resources: Resource[];
+}
+/**
+ * Serialize a DisplayList to a stable `.dl.json` document string (reusing the
+ * byte-preserving collapse-replacer). Round-trips through `parseDisplaySnapshot`.
+ */
+declare function serializeDisplayList(dl: DisplayList): string;
+declare class DlSnapshotError extends Error {
+  constructor(message: string);
+}
+/** Parse a `.dl.json` snapshot back into a DisplayList (validates the version). */
+declare function parseDisplaySnapshot(json: string): DisplayList;
+//#endregion
 //#region src/scene.d.ts
 interface Scene {
   readonly root: Group;
@@ -237,6 +333,14 @@ interface CacheColdResult {
   ok: boolean;
   /** id of the first node whose isolated emit() diverged (set only when !ok). */
   node?: string;
+  /**
+   * The FIRST command-level delta of the divergent node's isolated emit (set only
+   * when a specific leaf diverged — never for a Group fallback or a missing node).
+   * The WHOLE `CommandDelta` is embedded — index, kind, opA/opB, and every
+   * field change — so a multi-field divergence isn't flattened away. `gs
+   * verify-determinism --bisect` consumes this to name the (frame, node, op).
+   */
+  delta?: CommandDelta;
 }
 /**
  * Evaluate two fresh scenes from `createScene` at `t` and confirm the
@@ -505,6 +609,17 @@ interface Ctx2DLike<TPath, TDrawable> {
   globalCompositeOperation: string;
   filter: string;
   imageSmoothingEnabled: boolean;
+  /** §3 mesh Paint: write a straight-RGBA buffer into an offscreen tile, then
+   * blit it (clip + drawImage). Both DOM and @napi-rs/canvas expose these. */
+  createImageData(w: number, h: number): ImageDataLike;
+  putImageData(data: ImageDataLike, x: number, y: number): void;
+}
+/** The structural ImageData surface the mesh blit drives — DOM ImageData and
+ * @napi-rs/canvas ImageData both satisfy it (writable `.data`). */
+interface ImageDataLike {
+  readonly data: Uint8ClampedArray;
+  readonly width: number;
+  readonly height: number;
 }
 interface CanvasLike {
   width: number;
@@ -569,6 +684,20 @@ declare class Raster2D<TCanvas extends CanvasLike, TPath extends PathLike, TDraw
    */
   private cacheStore;
   private cacheTouch;
+  /**
+   * §3 mesh Paint blit (the spike-chosen mechanism: clip + drawImage, NOT
+   * createPattern — the pattern path leaks edge-AA/alpha contamination and an
+   * uncontrolled resample filter across backends, breaking SSIM; clip+drawImage
+   * is fully controlled and clips to the actual path, not just its bounds box).
+   *
+   * The mesh is rasterized by the SHARED kernel into a fixed downscaled buffer
+   * (identical bytes on both backends), written into an offscreen tile, then
+   * upscaled into the path-local bounds with `imageSmoothingEnabled` PINNED true.
+   * The clip is the real fill path, so a circle/star fills correctly. Only this
+   * final blit's AA differs per backend — the source ImageData is byte-identical,
+   * which is what makes the golden byte-exact and browser↔Skia SSIM ≥ 0.97.
+   */
+  private fillMesh;
   /**
    * §3.4/§3.5 composite of a finished group layer onto its parent — the EXACT
    * same save/resetTransform/clip/globalAlpha/filter/blend/drawImage sequence
@@ -582,4 +711,40 @@ declare class Raster2D<TCanvas extends CanvasLike, TPath extends PathLike, TDraw
   render(target: TCanvas, list: DisplayList): void;
 }
 //#endregion
-export { ALL_FILTER_KINDS, type AnchorSpec, type BackendCaps, type BindablePropTarget, type BlendMode, type CacheColdResult, type CanvasLike, Circle, ColdAssetError, type Ctx2DLike, Custom, DeterminismViolationError, type DisplayList, type DisplayListBuilder, type DrawCommand, type DrawOnEachOptions, type DrawOnOptions, DuplicateNodeIdError, type EditMark, type EvalContext, type FilterKind, type FilterSpec, FilterValidationError, FollowPath, type FollowPathProps, type FontByteLoader, type FontSpec, Group, type GuardMode, type HachureSpec, Highlight, type HighlightProps, type HitArea, IDENTITY, ImageNode as Image, ImageNode, type ImageHandle, type ImageProps, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, type LineBox, MEASURE_QUANTUM_PX, type Mat2x3, NODE_TAXONOMY, Node, type NodeProps, type NodeTypeName, type Paint, Path, type PathLike, type PathProps, type PathSampler, type PathSeg, type Polyline, type PropInit, Raster2D, type Raster2DHost, Rect, type Rect$1 as RectShape, type RenderBackend, ReservedNodeIdError, type ResolvedSketch, type Resource, type ResourceId, type RevealMark, type Scene, type SceneInit, type SceneModule, type ShaderCaps, ShaderEffect, type ShaderEffectProps, type ShaderRef, type ShapeProps, type SketchStyle, SketchValidationError, type StepMark, type StrokeStyle, Text, TextCursor, type TextCursorProps, type TextMeasurer, type TextMetricsLite, type TextProps, TokenHighlight, type TokenHighlightProps, TokenMatchError, type TokenRange, type TypeEdit, type TypewriterResult, type ValidateSceneFontsOptions, Video, type VideoFrameSource, type VideoProps, type WordBox, applyToPoint, arcLength, auditCacheCold, bindScene, breakLines, collectTextUsages, createDisplayListBuilder, createScene, drawOn, drawOnEach, estimatingMeasurer, evaluate, filtersToCanvasFilter, flatten, followPath, fontString, fromTRS, getLayoutEngine, glow, hachureLines, highlight, invert, matEquals, matchTokenRun, motionPath, multiply, pathFromSegs, pathLength, pointAtLength, quantize, requireLayoutEngine, resolveAnchor, resolveSketch, revealSchedule, roughen, roundedRectSegs, segmentGraphemes, segmentWords, setDefaultMeasurer, setLayoutEngine, sketchStrokes, textCursor, tokenHighlight, typewriter, validateFilters, validateHachure, validateSceneFonts, validateSketch, withDeterminismGuards };
+//#region src/meshGradient.d.ts
+/**
+ * The mesh raster resolution divisor. The mesh is computed at
+ * ceil(bounds / MESH_DOWNSCALE) and the backend upscales it (clip + drawImage,
+ * `imageSmoothingEnabled` pinned true) — a gradient is low-frequency, so the
+ * downscale is invisible while cutting the per-pixel kernel cost ~16×. PINNED:
+ * both backends compute the identical low-res ImageData.
+ */
+declare const MESH_DOWNSCALE = 4;
+/** Inverse-distance exponent for `smooth`/`oklab` (Shepard's method). Higher =
+ * sharper points; 2 is the classic IDW value and the pinned default. */
+declare const MESH_SHEPARD_POWER = 2;
+/**
+ * Gaussian weight sigma for `gaussian` mode, in NORMALIZED [0,1] mesh space
+ * (a point's influence falls to ~60% one sigma away). Pinned so the melt width
+ * is identical on both backends — the GAUSS_K precedent from gradient.ts.
+ */
+declare const MESH_SIGMA = 0.32;
+/**
+ * Rasterize a mesh Paint into an RGBA `Uint8ClampedArray` of `w*h` pixels
+ * (row-major, premultiply-free straight alpha). PURE function of
+ * (mesh, w, h): identical inputs → byte-identical buffer, on any backend.
+ *
+ * `w`/`h` are the DOWNSCALED dimensions (the caller divides the fill bounds by
+ * MESH_DOWNSCALE). Each output pixel's center maps to mesh space [0,1]²; the
+ * blend is Shepard IDW (smooth/oklab) or a pinned-sigma gaussian (gaussian) of
+ * the point colors in OKLab, with an optional `bg` color as a zero-weight floor
+ * (a baseline so sparse meshes don't smear a single point across the whole rect).
+ */
+declare function rasterizeMesh(mesh: MeshPaint$1, w: number, h: number): Uint8ClampedArray;
+/** Downscaled raster dimensions for a fill of `bw×bh` local px (≥1, capped). */
+declare function meshRasterSize(bw: number, bh: number): {
+  w: number;
+  h: number;
+};
+//#endregion
+export { ALL_FILTER_KINDS, type AnchorSpec, type BackendCaps, type BindablePropTarget, type BlendMode, type CacheColdResult, type CanvasLike, Circle, ColdAssetError, type CommandDelta, type Ctx2DLike, Custom, DL_SNAPSHOT_VERSION, DeterminismViolationError, type DisplayDiff, type DisplayList, type DisplayListBuilder, type DlSnapshot, DlSnapshotError, type DrawCommand, type DrawOnEachOptions, type DrawOnOptions, DuplicateNodeIdError, type EditMark, type EvalContext, type FieldChange, type FilterKind, type FilterSpec, FilterValidationError, FollowPath, type FollowPathProps, type FontByteLoader, type FontSpec, Group, type GuardMode, type HachureSpec, Highlight, type HighlightProps, type HitArea, IDENTITY, ImageNode as Image, ImageNode, type ImageDataLike, type ImageHandle, type ImageProps, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, type LineBox, MEASURE_QUANTUM_PX, MESH_DOWNSCALE, MESH_SHEPARD_POWER, MESH_SIGMA, type Mat2x3, type MeshInterpolation, type MeshPaint, type MeshPoint, NODE_TAXONOMY, Node, type NodeProps, type NodeTypeName, type Paint, Path, type PathLike, type PathProps, type PathSampler, type PathSeg, type Polyline, type PropInit, Raster2D, type Raster2DHost, Rect, type Rect$1 as RectShape, type RenderBackend, ReservedNodeIdError, type ResolvedSketch, type Resource, type ResourceId, type RevealMark, type Scene, type SceneInit, type SceneModule, type ShaderCaps, ShaderEffect, type ShaderEffectProps, type ShaderRef, type ShapeProps, type SketchStyle, SketchValidationError, type StepMark, type StrokeStyle, Text, TextCursor, type TextCursorProps, type TextMeasurer, type TextMetricsLite, type TextProps, TokenHighlight, type TokenHighlightProps, TokenMatchError, type TokenRange, type TypeEdit, type TypewriterResult, type ValidateSceneFontsOptions, Video, type VideoFrameSource, type VideoProps, type WordBox, applyToPoint, arcLength, auditCacheCold, bindScene, breakLines, collapseReplacer, collectTextUsages, createDisplayListBuilder, createScene, diffDisplayLists, drawOn, drawOnEach, estimatingMeasurer, evaluate, filtersToCanvasFilter, flatten, followPath, fontString, formatDisplayDiff, fromTRS, getLayoutEngine, glow, hachureLines, highlight, invert, matEquals, matchTokenRun, meshRasterSize, motionPath, multiply, parseDisplaySnapshot, pathFromSegs, pathLength, pointAtLength, quantize, rasterizeMesh, requireLayoutEngine, resolveAnchor, resolveSketch, revealSchedule, roughen, roundedRectSegs, segmentGraphemes, segmentWords, serializeDisplayList, setDefaultMeasurer, setLayoutEngine, sketchStrokes, textCursor, tokenHighlight, typewriter, validateFilters, validateHachure, validateSceneFonts, validateSketch, withDeterminismGuards };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { A as fallbackMeasurer, B as IDENTITY, C as validateHachure, D as MEASURE_QUANTUM_PX, E as resolveAnchor, F as FilterValidationError, G as multiply, H as fromTRS, I as createDisplayListBuilder, L as filtersToCanvasFilter, M as segmentGraphemes, N as segmentWords, O as breakLines, P as setDefaultMeasurer, R as glow, S as sketchStrokes, T as Node, U as invert, V as applyToPoint, W as matEquals, _ as arcLength, a as Circle, b as resolveSketch, c as ImageNode, d as Text, f as Video, g as SketchValidationError, h as roundedRectSegs, i as setLayoutEngine, j as quantize, k as estimatingMeasurer, l as Path, m as revealSchedule, n as getLayoutEngine, o as Custom, p as pathFromSegs, r as requireLayoutEngine, s as Group, t as LayoutEngineMissingError, u as Rect, v as flatten, w as validateSketch, x as roughen, y as hachureLines, z as validateFilters } from "./layoutEngine.js";
-import { bindTimeline, buildFontRegistry, compileTimeline, createPlayhead, emitDevWarning, evaluateAt, key, lerpColor, parseCmap, signal, stagger, track, validateFonts, vec2Signal } from "@glissade/core";
+import { A as fallbackMeasurer, B as DL_SNAPSHOT_VERSION, C as validateHachure, D as MEASURE_QUANTUM_PX, E as resolveAnchor, F as FilterValidationError, G as parseDisplaySnapshot, H as collapseReplacer, I as createDisplayListBuilder, J as applyToPoint, K as serializeDisplayList, L as filtersToCanvasFilter, M as segmentGraphemes, N as segmentWords, O as breakLines, P as setDefaultMeasurer, Q as multiply, R as glow, S as sketchStrokes, T as Node, U as diffDisplayLists, V as DlSnapshotError, W as formatDisplayDiff, X as invert, Y as fromTRS, Z as matEquals, _ as arcLength, a as Circle, b as resolveSketch, c as ImageNode, d as Text, f as Video, g as SketchValidationError, h as roundedRectSegs, i as setLayoutEngine, j as quantize, k as estimatingMeasurer, l as Path, m as revealSchedule, n as getLayoutEngine, o as Custom, p as pathFromSegs, q as IDENTITY, r as requireLayoutEngine, s as Group, t as LayoutEngineMissingError, u as Rect, v as flatten, w as validateSketch, x as roughen, y as hachureLines, z as validateFilters } from "./layoutEngine.js";
+import { bindTimeline, buildFontRegistry, compileTimeline, createPlayhead, emitDevWarning, evaluateAt, key, lerpColor, oklabToRgba, parseCmap, parseColor, rgbaToOklab, signal, stagger, track, validateFonts, vec2Signal } from "@glissade/core";
 //#region src/taxonomy.ts
 /**
 * The CLOSED node taxonomy (DESIGN.md §3.1): exactly nine built-in node TYPES.
@@ -457,12 +457,7 @@ function evaluate(scene, doc, t) {
 //#region src/cacheColdAudit.ts
 /** Stable string of a DisplayList for comparison (opaque resources collapse to a marker). */
 function hashDisplayList(dl) {
-	return JSON.stringify(dl, (_key, value) => {
-		if (value instanceof ArrayBuffer) return `ab:${value.byteLength}`;
-		if (ArrayBuffer.isView(value)) return `view:${value.byteLength}`;
-		if (typeof value === "function") return void 0;
-		return value;
-	});
+	return JSON.stringify(dl, collapseReplacer);
 }
 /**
 * Evaluate two fresh scenes from `createScene` at `t` and confirm the
@@ -498,14 +493,18 @@ function auditCacheCold(createScene, doc, t) {
 		nodeA.emit(ea, ctxA);
 		const eb = createDisplayListBuilder(cold.size);
 		nodeB.emit(eb, ctxB);
-		if (hashDisplayList(ea.finish()) === hashDisplayList(eb.finish())) continue;
+		const dlA = ea.finish();
+		const dlB = eb.finish();
+		if (hashDisplayList(dlA) === hashDisplayList(dlB)) continue;
 		if (nodeA instanceof Group) {
 			groupFallback ??= id;
 			continue;
 		}
+		const first = diffDisplayLists(dlA, dlB).deltas[0];
 		return {
 			ok: false,
-			node: id
+			node: id,
+			...first !== void 0 ? { delta: first } : {}
 		};
 	}
 	return {
@@ -1016,6 +1015,149 @@ function densifyStops(stops, mode) {
 	return out;
 }
 //#endregion
+//#region src/meshGradient.ts
+/**
+* Mesh-gradient kernel (§3 Paint, 0.12). A `mesh` Paint is N color points
+* scattered across the [0,1]² fill rectangle, blended into ONE animatable fill
+* — the native replacement for the "N blurred blobs" aurora backdrop.
+*
+* THE DETERMINISM TENTPOLE: `@napi-rs/canvas` exposes NO SkSL RuntimeEffect /
+* makeShader, so there is no SkSL-vs-fallback fork — there is exactly ONE shared
+* CPU kernel that BOTH backends run. This file is that kernel, mirroring
+* `densifyStops` (gradient.ts): pinned named constants (`MESH_SIGMA`,
+* `MESH_SHEPARD_POWER`, `MESH_DOWNSCALE`) so neither backend picks its own, OKLab
+* blend reused bit-identically from `@glissade/core`, and integer `Uint8ClampedArray`
+* quantization so the buffer is reproducible run-to-run and byte-identical across
+* backends. Only the FINAL blit (clip + drawImage upscale) differs per backend —
+* the source pixels are identical, which is what makes browser↔Skia SSIM ≥ 0.97.
+*
+* The blend is ONE deterministic Shepard inverse-distance kernel with a
+* colorspace knob: `smooth` = inverse-distance weighting in OKLab; `gaussian` =
+* a pinned-sigma gaussian weight (a softer, blurrier melt); `oklab` is an alias
+* for `smooth` (the blend space is always OKLab — the gradient path's contract).
+* NO triangulator (Gouraud/Delaunay/Coons are deferred).
+*/
+/**
+* The mesh raster resolution divisor. The mesh is computed at
+* ceil(bounds / MESH_DOWNSCALE) and the backend upscales it (clip + drawImage,
+* `imageSmoothingEnabled` pinned true) — a gradient is low-frequency, so the
+* downscale is invisible while cutting the per-pixel kernel cost ~16×. PINNED:
+* both backends compute the identical low-res ImageData.
+*/
+const MESH_DOWNSCALE = 4;
+/** Inverse-distance exponent for `smooth`/`oklab` (Shepard's method). Higher =
+* sharper points; 2 is the classic IDW value and the pinned default. */
+const MESH_SHEPARD_POWER = 2;
+/**
+* Gaussian weight sigma for `gaussian` mode, in NORMALIZED [0,1] mesh space
+* (a point's influence falls to ~60% one sigma away). Pinned so the melt width
+* is identical on both backends — the GAUSS_K precedent from gradient.ts.
+*/
+const MESH_SIGMA = .32;
+/** Epsilon so a sample sitting exactly on a point doesn't divide by zero; small
+* enough to be a hard pin to that point's color. Pinned (folds into the bytes). */
+const MESH_EPS = 1e-6;
+/** Cap the mesh raster so a pathological tiny-downscale × huge-bounds can't OOM;
+* far above any real fill at /4. Pinned (it changes nothing for real meshes). */
+const MESH_MAX_DIM = 1024;
+/**
+* Rasterize a mesh Paint into an RGBA `Uint8ClampedArray` of `w*h` pixels
+* (row-major, premultiply-free straight alpha). PURE function of
+* (mesh, w, h): identical inputs → byte-identical buffer, on any backend.
+*
+* `w`/`h` are the DOWNSCALED dimensions (the caller divides the fill bounds by
+* MESH_DOWNSCALE). Each output pixel's center maps to mesh space [0,1]²; the
+* blend is Shepard IDW (smooth/oklab) or a pinned-sigma gaussian (gaussian) of
+* the point colors in OKLab, with an optional `bg` color as a zero-weight floor
+* (a baseline so sparse meshes don't smear a single point across the whole rect).
+*/
+function rasterizeMesh(mesh, w, h) {
+	const out = new Uint8ClampedArray(Math.max(1, w) * Math.max(1, h) * 4);
+	const pts = mesh.points.map((p) => ({
+		u: p.pos[0],
+		v: p.pos[1],
+		lab: rgbaToOklab(parseColor(p.color))
+	}));
+	const bg = mesh.bg !== void 0 ? rgbaToOklab(parseColor(mesh.bg)) : null;
+	const gaussian = mesh.interpolation === "gaussian";
+	const twoSigmaSq = 2 * MESH_SIGMA * MESH_SIGMA;
+	for (let y = 0; y < h; y++) {
+		const v = h > 1 ? (y + .5) / h : .5;
+		for (let x = 0; x < w; x++) {
+			const u = w > 1 ? (x + .5) / w : .5;
+			let wsum = 0;
+			let L = 0;
+			let A = 0;
+			let B = 0;
+			let alpha = 0;
+			if (bg) {
+				wsum = 1;
+				L = bg.L;
+				A = bg.a;
+				B = bg.b;
+				alpha = bg.alpha;
+			}
+			let pinned = false;
+			for (let i = 0; i < pts.length; i++) {
+				const p = pts[i];
+				const du = u - p.u;
+				const dv = v - p.v;
+				const d2 = du * du + dv * dv;
+				if (d2 <= MESH_EPS * MESH_EPS) {
+					L = p.lab.L;
+					A = p.lab.a;
+					B = p.lab.b;
+					alpha = p.lab.alpha;
+					pinned = true;
+					break;
+				}
+				let weight;
+				if (gaussian) weight = Math.exp(-d2 / twoSigmaSq);
+				else weight = 1 / d2;
+				wsum += weight;
+				L += weight * p.lab.L;
+				A += weight * p.lab.a;
+				B += weight * p.lab.b;
+				alpha += weight * p.lab.alpha;
+			}
+			let rgba;
+			if (pinned) rgba = oklabToRgba({
+				L,
+				a: A,
+				b: B,
+				alpha
+			});
+			else if (wsum > 0) {
+				const inv = 1 / wsum;
+				rgba = oklabToRgba({
+					L: L * inv,
+					a: A * inv,
+					b: B * inv,
+					alpha: alpha * inv
+				});
+			} else rgba = {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 0
+			};
+			const o = (y * w + x) * 4;
+			out[o] = rgba.r;
+			out[o + 1] = rgba.g;
+			out[o + 2] = rgba.b;
+			out[o + 3] = Math.round(rgba.a * 255);
+		}
+	}
+	return out;
+}
+/** Downscaled raster dimensions for a fill of `bw×bh` local px (≥1, capped). */
+function meshRasterSize(bw, bh) {
+	return {
+		w: Math.min(MESH_MAX_DIM, Math.max(1, Math.ceil(Math.abs(bw) / 4))),
+		h: Math.min(MESH_MAX_DIM, Math.max(1, Math.ceil(Math.abs(bh) / 4)))
+	};
+}
+//#endregion
 //#region src/raster2d.ts
 /**
 * The shared DisplayList interpreter (§3.4): one command walk over the
@@ -1024,8 +1166,19 @@ function densifyStops(stops, mode) {
 * four-line adapters, so the twin rasterizers structurally cannot drift —
 * the golden + SSIM suites verify the refactor preserved every byte.
 */
+/** Stroke/text mesh paint has no clippable fill region — pick a deterministic
+* representative solid (bg, else the first point) so it renders without a crash. */
+let warnedMeshStroke = false;
+function meshRepresentativeColor(paint) {
+	if (!warnedMeshStroke) {
+		warnedMeshStroke = true;
+		emitDevWarning("mesh Paint on a stroke/text resolves to a representative solid color (mesh fill is supported only on filled paths, §3 Paint) — use a fillPath for the mesh gradient");
+	}
+	return paint.bg ?? paint.points[0]?.color ?? "#00000000";
+}
 function resolveFill(ctx, paint, bounds) {
 	if (paint.kind === "color") return paint.color;
+	if (paint.kind === "mesh") return meshRepresentativeColor(paint);
 	let g;
 	if (paint.kind === "radial") {
 		const cx = paint.center ? paint.center[0] : bounds ? (bounds.minX + bounds.maxX) / 2 : 0;
@@ -1256,6 +1409,37 @@ var Raster2D = class {
 		return hit;
 	}
 	/**
+	* §3 mesh Paint blit (the spike-chosen mechanism: clip + drawImage, NOT
+	* createPattern — the pattern path leaks edge-AA/alpha contamination and an
+	* uncontrolled resample filter across backends, breaking SSIM; clip+drawImage
+	* is fully controlled and clips to the actual path, not just its bounds box).
+	*
+	* The mesh is rasterized by the SHARED kernel into a fixed downscaled buffer
+	* (identical bytes on both backends), written into an offscreen tile, then
+	* upscaled into the path-local bounds with `imageSmoothingEnabled` PINNED true.
+	* The clip is the real fill path, so a circle/star fills correctly. Only this
+	* final blit's AA differs per backend — the source ImageData is byte-identical,
+	* which is what makes the golden byte-exact and browser↔Skia SSIM ≥ 0.97.
+	*/
+	fillMesh(ctx, path, paint, bounds) {
+		const bw = bounds.maxX - bounds.minX;
+		const bh = bounds.maxY - bounds.minY;
+		if (bw <= 0 || bh <= 0) return;
+		const { w, h } = meshRasterSize(bw, bh);
+		const buf = rasterizeMesh(paint, w, h);
+		const tile = this.acquire(w, h);
+		const tileCtx = this.host.context(tile);
+		const img = tileCtx.createImageData(w, h);
+		img.data.set(buf);
+		tileCtx.putImageData(img, 0, 0);
+		ctx.save();
+		ctx.clip(path, "nonzero");
+		ctx.imageSmoothingEnabled = true;
+		ctx.drawImage(tile, 0, 0, w, h, bounds.minX, bounds.minY, bw, bh);
+		ctx.restore();
+		this.release(tile);
+	}
+	/**
 	* §3.4/§3.5 composite of a finished group layer onto its parent — the EXACT
 	* same save/resetTransform/clip/globalAlpha/filter/blend/drawImage sequence
 	* for both the freshly-rasterized miss path and a cache-blit hit, so a HIT is
@@ -1337,8 +1521,11 @@ var Raster2D = class {
 				case "fillPath": {
 					const ctx = ctxOf();
 					const b = this.pathBounds(list.resources, cmd.path);
-					ctx.fillStyle = resolveFill(ctx, cmd.paint, b);
-					ctx.fill(this.path(list.resources, cmd.path));
+					if (cmd.paint.kind === "mesh" && b) this.fillMesh(ctx, this.path(list.resources, cmd.path), cmd.paint, b);
+					else {
+						ctx.fillStyle = resolveFill(ctx, cmd.paint, b);
+						ctx.fill(this.path(list.resources, cmd.path));
+					}
 					if (b) accumulateRect(top(), mat, b.minX, b.minY, b.maxX, b.maxY);
 					break;
 				}
@@ -1468,4 +1655,4 @@ var Raster2D = class {
 	}
 };
 //#endregion
-export { ALL_FILTER_KINDS, Circle, ColdAssetError, Custom, DeterminismViolationError, DuplicateNodeIdError, FilterValidationError, FollowPath, Group, Highlight, IDENTITY, ImageNode as Image, ImageNode, LayoutEngineMissingError, MEASURE_QUANTUM_PX, NODE_TAXONOMY, Node, Path, Raster2D, Rect, ReservedNodeIdError, ShaderEffect, SketchValidationError, Text, TextCursor, TokenHighlight, TokenMatchError, Video, applyToPoint, arcLength, auditCacheCold, bindScene, breakLines, collectTextUsages, createDisplayListBuilder, createScene, drawOn, drawOnEach, estimatingMeasurer, evaluate, filtersToCanvasFilter, flatten, followPath, fontString, fromTRS, getLayoutEngine, glow, hachureLines, highlight, invert, matEquals, matchTokenRun, motionPath, multiply, pathFromSegs, pathLength, pointAtLength, quantize, requireLayoutEngine, resolveAnchor, resolveSketch, revealSchedule, roughen, roundedRectSegs, segmentGraphemes, segmentWords, setDefaultMeasurer, setLayoutEngine, sketchStrokes, textCursor, tokenHighlight, typewriter, validateFilters, validateHachure, validateSceneFonts, validateSketch, withDeterminismGuards };
+export { ALL_FILTER_KINDS, Circle, ColdAssetError, Custom, DL_SNAPSHOT_VERSION, DeterminismViolationError, DlSnapshotError, DuplicateNodeIdError, FilterValidationError, FollowPath, Group, Highlight, IDENTITY, ImageNode as Image, ImageNode, LayoutEngineMissingError, MEASURE_QUANTUM_PX, MESH_DOWNSCALE, MESH_SHEPARD_POWER, MESH_SIGMA, NODE_TAXONOMY, Node, Path, Raster2D, Rect, ReservedNodeIdError, ShaderEffect, SketchValidationError, Text, TextCursor, TokenHighlight, TokenMatchError, Video, applyToPoint, arcLength, auditCacheCold, bindScene, breakLines, collapseReplacer, collectTextUsages, createDisplayListBuilder, createScene, diffDisplayLists, drawOn, drawOnEach, estimatingMeasurer, evaluate, filtersToCanvasFilter, flatten, followPath, fontString, formatDisplayDiff, fromTRS, getLayoutEngine, glow, hachureLines, highlight, invert, matEquals, matchTokenRun, meshRasterSize, motionPath, multiply, parseDisplaySnapshot, pathFromSegs, pathLength, pointAtLength, quantize, rasterizeMesh, requireLayoutEngine, resolveAnchor, resolveSketch, revealSchedule, roughen, roundedRectSegs, segmentGraphemes, segmentWords, serializeDisplayList, setDefaultMeasurer, setLayoutEngine, sketchStrokes, textCursor, tokenHighlight, typewriter, validateFilters, validateHachure, validateSceneFonts, validateSketch, withDeterminismGuards };

package/dist/layoutEngine.d.ts

@@ -1,4 +1,4 @@
-import { BindableSignal, Paint, PathValue, ReadonlySignal, Rng, Track, Vec2, Vec2Signal } from "@glissade/core";
+import { BindableSignal, MeshInterpolation, MeshPaint as MeshPaint$1, MeshPoint, Paint, PathValue, ReadonlySignal, Rng, Track, Vec2, Vec2Signal } from "@glissade/core";
 
 //#region src/matrix.d.ts
 
@@ -846,4 +846,4 @@ declare function setLayoutEngine(e: LayoutEngine): void;
 declare function getLayoutEngine(): LayoutEngine | null;
 declare function requireLayoutEngine(): LayoutEngine;
 //#endregion
-export { breakLines as $, Polyline as A, validateHachure as B, Video as C, IDENTITY as Ct, revealSchedule as D, invert as Dt, pathFromSegs as E, fromTRS as Et, flatten as F, HitArea as G, AnchorSpec as H, hachureLines as I, PropInit as J, Node as K, resolveSketch as L, SketchStyle as M, SketchValidationError as N, roundedRectSegs as O, matEquals as Ot, arcLength as P, TextMetricsLite as Q, roughen as R, TextProps as S, validateFilters as St, WordBox as T, applyToPoint as Tt, BindablePropTarget as U, validateSketch as V, EvalContext as W, MEASURE_QUANTUM_PX as X, resolveAnchor as Y, TextMeasurer as Z, PathProps as _, ShaderRef as _t, LayoutEngineMissingError as a, BlendMode as at, ShapeProps as b, filtersToCanvasFilter as bt, requireLayoutEngine as c, DrawCommand as ct, Custom as d, FontSpec as dt, estimatingMeasurer as et, Group as f, Paint as ft, Path as g, ResourceId as gt, LineBox as h, Resource as ht, LayoutEngine as i, setDefaultMeasurer as it, ResolvedSketch as j, HachureSpec as k, multiply as kt, setLayoutEngine as l, FilterSpec as lt, ImageProps as m, Rect$1 as mt, LayoutChildSpec as n, segmentGraphemes as nt, LayoutResult as o, DisplayList as ot, ImageNode as p, PathSeg as pt, NodeProps as q, LayoutContainerSpec as r, segmentWords as rt, getLayoutEngine as s, DisplayListBuilder as st, LayoutBox as t, quantize as tt, Circle as u, FilterValidationError as ut, Rect as v, StrokeStyle as vt, VideoProps as w, Mat2x3 as wt, Text as x, glow as xt, RevealMark as y, createDisplayListBuilder as yt, sketchStrokes as z };
+export { breakLines as $, Polyline as A, invert as At, validateHachure as B, Video as C, filtersToCanvasFilter as Ct, revealSchedule as D, Mat2x3 as Dt, pathFromSegs as E, IDENTITY as Et, flatten as F, HitArea as G, AnchorSpec as H, hachureLines as I, PropInit as J, Node as K, resolveSketch as L, SketchStyle as M, multiply as Mt, SketchValidationError as N, roundedRectSegs as O, applyToPoint as Ot, arcLength as P, TextMetricsLite as Q, roughen as R, TextProps as S, createDisplayListBuilder as St, WordBox as T, validateFilters as Tt, BindablePropTarget as U, validateSketch as V, EvalContext as W, MEASURE_QUANTUM_PX as X, resolveAnchor as Y, TextMeasurer as Z, PathProps as _, Rect$1 as _t, LayoutEngineMissingError as a, BlendMode as at, ShapeProps as b, ShaderRef as bt, requireLayoutEngine as c, DrawCommand as ct, Custom as d, FontSpec as dt, estimatingMeasurer as et, Group as f, MeshInterpolation as ft, Path as g, PathSeg as gt, LineBox as h, Paint as ht, LayoutEngine as i, setDefaultMeasurer as it, ResolvedSketch as j, matEquals as jt, HachureSpec as k, fromTRS as kt, setLayoutEngine as l, FilterSpec as lt, ImageProps as m, MeshPoint as mt, LayoutChildSpec as n, segmentGraphemes as nt, LayoutResult as o, DisplayList as ot, ImageNode as p, MeshPaint$1 as pt, NodeProps as q, LayoutContainerSpec as r, segmentWords as rt, getLayoutEngine as s, DisplayListBuilder as st, LayoutBox as t, quantize as tt, Circle as u, FilterValidationError as ut, Rect as v, Resource as vt, VideoProps as w, glow as wt, Text as x, StrokeStyle as xt, RevealMark as y, ResourceId as yt, sketchStrokes as z };

package/dist/layoutEngine.js

@@ -61,6 +61,162 @@ function matEquals(a, b) {
 	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5];
 }
 //#endregion
+//#region src/displayDiff.ts
+/**
+* The collapse-replacer shared by the cacheKey serializer
+* (`createDisplayListBuilder().cacheKey`), `cacheColdAudit.hashDisplayList`,
+* and `serializeDisplayList` here. CRITICAL: this is BYTE-PRESERVING — the
+* cacheKey it backs stamps into pushGroup and keys the §3.5 raster cache, so
+* its output must not move. The three call sites previously DUPLICATED this
+* byte-for-byte; it lives here once.
+*
+*  - ArrayBuffer / typed-array views collapse to a `ab:<len>` / `view:<len>`
+*    length marker (opaque binary never belongs in a structural key).
+*  - Functions drop (JSON would already drop them; explicit for parity).
+*
+* NOTE: `-0` is intentionally NOT normalized here. The matrix layer
+* (`matrix.ts`) already normalizes `-0 → 0` at the source, and adding a `-0`
+* pass to THIS replacer would change the cacheKey bytes for any list that ever
+* carried a raw `-0` — silently invalidating the cache cluster-wide. Byte
+* preservation wins; the regression guard pins the exact key.
+*/
+function collapseReplacer(_key, value) {
+	if (value instanceof ArrayBuffer) return `ab:${value.byteLength}`;
+	if (ArrayBuffer.isView(value)) return `view:${value.byteLength}`;
+	if (typeof value === "function") return void 0;
+	return value;
+}
+/** A flat, stable JSON value for one command with its resource ids INLINED to content. */
+function commandView(cmd, resources) {
+	const out = {};
+	for (const [k, v] of Object.entries(cmd)) out[k] = v;
+	if (cmd.op === "clip" || cmd.op === "fillPath" || cmd.op === "strokePath") out["path"] = resources[cmd.path];
+	else if (cmd.op === "drawImage") out["image"] = resources[cmd.image];
+	return out;
+}
+const stable = (v) => JSON.stringify(v, collapseReplacer);
+/** Field-level diff of two same-op command views (shallow over top-level props). */
+function diffFields(a, b) {
+	const changes = [];
+	const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+	for (const k of keys) {
+		if (k === "op") continue;
+		if (stable(a[k]) !== stable(b[k])) changes.push({
+			path: k,
+			from: a[k],
+			to: b[k]
+		});
+	}
+	return changes;
+}
+/**
+* Index-aligned positional diff of two DisplayLists. Command i in `a` is
+* compared to command i in `b`; trailing commands become `add`/`remove`. A
+* single insert/remove cascades — this is the documented v1 cliff.
+*/
+function diffDisplayLists(a, b) {
+	const deltas = [];
+	const n = Math.max(a.commands.length, b.commands.length);
+	for (let i = 0; i < n; i++) {
+		const ca = a.commands[i];
+		const cb = b.commands[i];
+		if (ca !== void 0 && cb !== void 0) {
+			const va = commandView(ca, a.resources);
+			const vb = commandView(cb, b.resources);
+			if (stable(va) === stable(vb)) continue;
+			if (ca.op !== cb.op) deltas.push({
+				index: i,
+				kind: "change",
+				opA: ca.op,
+				opB: cb.op,
+				fields: [{
+					path: "op",
+					from: ca.op,
+					to: cb.op
+				}]
+			});
+			else deltas.push({
+				index: i,
+				kind: "change",
+				opA: ca.op,
+				opB: cb.op,
+				fields: diffFields(va, vb)
+			});
+		} else if (cb !== void 0) deltas.push({
+			index: i,
+			kind: "add",
+			opB: cb.op,
+			fields: []
+		});
+		else if (ca !== void 0) deltas.push({
+			index: i,
+			kind: "remove",
+			opA: ca.op,
+			fields: []
+		});
+	}
+	const sizeDiffers = a.size.w !== b.size.w || a.size.h !== b.size.h;
+	return {
+		equal: deltas.length === 0 && !sizeDiffers,
+		deltas,
+		...sizeDiffers ? { size: {
+			from: a.size,
+			to: b.size
+		} } : {}
+	};
+}
+/** Human-readable, multi-line rendering of a DisplayDiff (CLI command-tree). */
+function formatDisplayDiff(diff) {
+	if (diff.equal) return "DisplayLists are identical.";
+	const lines = [];
+	if (diff.size) lines.push(`size  ${diff.size.from.w}x${diff.size.from.h} -> ${diff.size.to.w}x${diff.size.to.h}`);
+	for (const d of diff.deltas) if (d.kind === "add") lines.push(`+ [${d.index}] add    ${d.opB ?? "?"}`);
+	else if (d.kind === "remove") lines.push(`- [${d.index}] remove ${d.opA ?? "?"}`);
+	else {
+		const op = d.opA === d.opB ? d.opA : `${d.opA ?? "?"} -> ${d.opB ?? "?"}`;
+		lines.push(`~ [${d.index}] ${op}`);
+		for (const f of d.fields) lines.push(`      ${f.path}: ${stable(f.from)} -> ${stable(f.to)}`);
+	}
+	return lines.join("\n");
+}
+/**
+* The `.dl.json` snapshot interchange schema (DESIGN §7.4). Users commit
+* `.dl.json` baselines, so this carries the SAME break-policy obligation as
+* `Timeline.version` and `SidecarDoc.sidecarVersion`: bump on a breaking shape
+* change. Independent of the API version.
+*/
+const DL_SNAPSHOT_VERSION = 1;
+/**
+* Serialize a DisplayList to a stable `.dl.json` document string (reusing the
+* byte-preserving collapse-replacer). Round-trips through `parseDisplaySnapshot`.
+*/
+function serializeDisplayList(dl) {
+	const snapshot = {
+		dlSnapshotVersion: 1,
+		size: dl.size,
+		commands: dl.commands,
+		resources: dl.resources
+	};
+	return JSON.stringify(snapshot, collapseReplacer, 2);
+}
+var DlSnapshotError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DlSnapshotError";
+	}
+};
+/** Parse a `.dl.json` snapshot back into a DisplayList (validates the version). */
+function parseDisplaySnapshot(json) {
+	const doc = JSON.parse(json);
+	if (doc.dlSnapshotVersion !== 1) throw new DlSnapshotError(`unsupported dlSnapshotVersion ${String(doc.dlSnapshotVersion)}; this build reads 1`);
+	if (!doc.size || !Array.isArray(doc.commands) || !Array.isArray(doc.resources)) throw new DlSnapshotError("malformed .dl.json snapshot (need size, commands[], resources[])");
+	return {
+		size: doc.size,
+		commands: doc.commands,
+		resources: doc.resources
+	};
+}
+//#endregion
 //#region src/displayList.ts
 var FilterValidationError = class extends Error {
 	constructor(message) {
@@ -190,12 +346,7 @@ function createDisplayListBuilder(size) {
 			return fnv1a(JSON.stringify({
 				c: sliceCmds,
 				r: usedResources
-			}, (_k, value) => {
-				if (value instanceof ArrayBuffer) return `ab:${value.byteLength}`;
-				if (ArrayBuffer.isView(value)) return `view:${value.byteLength}`;
-				if (typeof value === "function") return void 0;
-				return value;
-			}));
+			}, collapseReplacer));
 		},
 		patchCacheKey: (i, key) => {
 			const cmd = commands[i];
@@ -1853,4 +2004,4 @@ function requireLayoutEngine() {
 	return engine;
 }
 //#endregion
-export { fallbackMeasurer as A, IDENTITY as B, validateHachure as C, MEASURE_QUANTUM_PX as D, resolveAnchor as E, FilterValidationError as F, multiply as G, fromTRS as H, createDisplayListBuilder as I, filtersToCanvasFilter as L, segmentGraphemes as M, segmentWords as N, breakLines as O, setDefaultMeasurer as P, glow as R, sketchStrokes as S, Node as T, invert as U, applyToPoint as V, matEquals as W, arcLength as _, Circle as a, resolveSketch as b, ImageNode as c, Text as d, Video as f, SketchValidationError as g, roundedRectSegs as h, setLayoutEngine as i, quantize as j, estimatingMeasurer as k, Path as l, revealSchedule as m, getLayoutEngine as n, Custom as o, pathFromSegs as p, requireLayoutEngine as r, Group as s, LayoutEngineMissingError as t, Rect as u, flatten as v, validateSketch as w, roughen as x, hachureLines as y, validateFilters as z };
+export { fallbackMeasurer as A, DL_SNAPSHOT_VERSION as B, validateHachure as C, MEASURE_QUANTUM_PX as D, resolveAnchor as E, FilterValidationError as F, parseDisplaySnapshot as G, collapseReplacer as H, createDisplayListBuilder as I, applyToPoint as J, serializeDisplayList as K, filtersToCanvasFilter as L, segmentGraphemes as M, segmentWords as N, breakLines as O, setDefaultMeasurer as P, multiply as Q, glow as R, sketchStrokes as S, Node as T, diffDisplayLists as U, DlSnapshotError as V, formatDisplayDiff as W, invert as X, fromTRS as Y, matEquals as Z, arcLength as _, Circle as a, resolveSketch as b, ImageNode as c, Text as d, Video as f, SketchValidationError as g, roundedRectSegs as h, setLayoutEngine as i, quantize as j, estimatingMeasurer as k, Path as l, revealSchedule as m, getLayoutEngine as n, Custom as o, pathFromSegs as p, IDENTITY as q, requireLayoutEngine as r, Group as s, LayoutEngineMissingError as t, Rect as u, flatten as v, validateSketch as w, roughen as x, hachureLines as y, validateFilters as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/scene",
-  "version": "0.11.0",
+  "version": "0.12.0-pre.0",
   "description": "glissade scene graph: nodes, transforms, DisplayList emission. Renderer-agnostic; zero DOM/Node dependencies.",
   "license": "Apache-2.0",
   "engines": {
@@ -23,7 +23,7 @@
   ],
   "dependencies": {
     "yoga-layout": "^3.2.1",
-    "@glissade/core": "0.11.0"
+    "@glissade/core": "0.12.0-pre.0"
   },
   "repository": {
     "type": "git",