import { C as Mat2x3, D as matEquals, E as invert, O as multiply, S as IDENTITY, T as fromTRS, _ as StrokeStyle, a as FilterSpec, b as glow, c as MeshInterpolation, d as Paint, f as PathSeg, g as ShaderRef, h as ResourceId, i as DrawCommand, l as MeshPaint, m as Resource, n as DisplayList, o as FilterValidationError, p as Rect$1, r as DisplayListBuilder, s as FontSpec, t as BlendMode, u as MeshPoint, v as createDisplayListBuilder, w as applyToPoint, x as validateFilters, y as filtersToCanvasFilter } from "./displayList.js";
import { $ as estimatingMeasurer, A as flatten, B as HitArea, C as roundedRectSegs, D as SketchStyle, E as ResolvedSketch, F as validateHachure, G as resolveAnchor, H as NodeConstructionError, I as validateSketch, J as TextMeasurer, K as MEASURE_QUANTUM_PX, L as AnchorSpec, M as resolveSketch, N as roughen, O as SketchValidationError, P as sketchStrokes, Q as breakLines, R as BindablePropTarget, S as revealSchedule, T as Polyline, U as NodeProps, V as Node, W as PropInit, X as WrappedTextMetrics, Y as TextMetricsLite, Z as assertFiniteFontSize, _ as Video, a as GraphemeBox, at as setDefaultMeasurer, b as coercePathData, c as ImageProps, d as PathProps, et as isEstimatingMeasurer, f as Rect, g as TextProps, h as Text, i as GeometryOpts, it as segmentWords, j as hachureLines, k as arcLength, l as LineBox, m as ShapeProps, n as ClipRegion, nt as quantize, o as Group, p as RevealMark, q as MeasurerRequiredError, r as Custom, rt as segmentGraphemes, s as ImageNode, t as Circle, tt as measureWrappedText, u as Path, v as VideoProps, w as HachureSpec, x as pathFromSegs, y as WordBox, z as EvalContext } from "./nodes.js";
import { a as withDeterminismGuards, g as collapseReplacer, i as ViolationLocator, n as GuardMode, r as ViolationDetail, t as DeterminismViolationError } from "./guards.js";
import { a as SceneInit, c as createScene, i as Scene, l as evaluate, n as DuplicateNodeIdError, o as SceneModule, r as ReservedNodeIdError, s as bindScene, t as BindSceneOptions } from "./scene.js";
import { a as typewriter, c as textCursor, i as TypewriterResult, n as StepMark, o as TextCursor, r as TypeEdit, s as TextCursorProps, t as EditMark } from "./typewriter.js";
import { a as EachLayout, c as EachResult, i as EachError, l as Place, n as EachContext, o as EachMotion, r as EachDistribute, s as EachOpts, t as EachBox, u as each } from "./each.js";
import { a as LayoutEngineMissingError, c as requireLayoutEngine, i as LayoutEngine, l as setLayoutEngine, n as LayoutChildSpec, r as LayoutContainerSpec, s as getLayoutEngine, t as LayoutBox } from "./layoutEngine.js";
import { BindableSignal, EaseSpec, MeshPaint as MeshPaint$1, Track } from "@glissade/core";

//#region src/taxonomy.d.ts

/**
 * The CLOSED node taxonomy (DESIGN.md §3.1): exactly nine built-in node TYPES.
 * This frozen tuple is the lock — the enumerated, testable form of the "small,
 * closed set" guarantee. Adding a tenth name is an intentional, reviewed spec
 * change, not an accident.
 *
 * Most names map to an exported scene-node class from the base index
 * (Group/Rect/Circle/Path/Text/Image/Video/Custom). 'Layout' is the lone
 * exception: the Layout node lives in the separately-budgeted './layout' entry
 * (§3.2, Yoga), so the NAME is in the taxonomy but the class is not pulled into
 * the base index — keeping the base scene bundle free of Yoga.
 */
declare const NODE_TAXONOMY: readonly ["Group", "Rect", "Circle", "Path", "Text", "Image", "Video", "Layout", "Custom"];
/** The name of one of the nine taxonomy node types (§3.1). */
type NodeTypeName = (typeof NODE_TAXONOMY)[number];
//#endregion
//#region src/highlight.d.ts
interface HighlightProps extends NodeProps {
  /** The Text whose lines get the marker. Place this node as an EARLIER
   * sibling (same parent) so it paints behind the glyphs. */
  text: Text;
  color?: PropInit<string>;
  /** 0→1 sweep across all lines in reading order, at constant speed weighted
   * by line width; default 1 (fully highlighted). Track: '<id>/progress'. */
  progress?: PropInit<number>;
  /** Marker overhang beyond each line's ink box, [x, y] px; default [4, 2]. */
  padding?: [number, number];
  /** Rounded marker ends; default 4 (clamped to the box). */
  cornerRadius?: number;
}
declare class Highlight extends Node {
  readonly target: Text;
  readonly color: BindableSignal<string>;
  readonly progress: BindableSignal<number>;
  readonly padding: [number, number];
  readonly cornerRadius: number;
  constructor(props: HighlightProps);
  protected draw(out: DisplayListBuilder, ctx: EvalContext): void;
}
/** `children: [highlight(title, { color: '#ffe066' }), title]` — marker behind the text. */
declare function highlight(text: Text, props?: Omit<HighlightProps, 'text'>): Highlight;
//#endregion
//#region src/drawOn.d.ts
interface DrawOnOptions {
  /** when the stroke-on starts, seconds; default 0 */
  start?: number;
  /** how long it takes, seconds; default 1 */
  duration?: number;
  /** the ease arriving at fully drawn; default 'easeInOutCubic' */
  ease?: EaseSpec;
}
/** A `<id>/reveal` track running 0→1 — point a stroked/sketched shape at it to
 * hand-draw itself on. `target` is the node id. */
declare function drawOn(target: string, opts?: DrawOnOptions): Track<number>;
interface DrawOnEachOptions extends DrawOnOptions {
  /** gap between each shape starting, seconds; default 0.6 × duration */
  delay?: number;
}
/** Cascade several shapes drawing themselves on, one after another — the
 * whiteboard sequence. Returns one reveal track per id, staggered by `delay`. */
declare function drawOnEach(targets: readonly string[], opts?: DrawOnEachOptions): Track<number>[];
//#endregion
//#region src/assets.d.ts
/**
 * Asset contracts (DESIGN.md §3.8): evaluate() never awaits — callers warm
 * sources first (§2.5 readiness precondition), then emission is pure. The
 * VideoFrameSource seam isolates decoder differences (WebCodecs vs FFmpeg);
 * backends resolve asset ids to their own bitmap types.
 */
interface VideoFrameSource {
  /** Source duration in seconds. */
  readonly duration: number;
  /** Frames per second of the source grid (mediaT quantization). */
  readonly fps: number;
  /**
   * Ensure getFrameSync can serve [fromT, toT] (seconds, media time).
   * O(GOP) for backward/random seeks; a readiness latency, never state.
   */
  warm(fromT: number, toT: number): Promise<void>;
  /**
   * The decoded frame for the source-grid frame containing mediaT.
   * Precondition: warmed. The return is backend-consumable (VideoFrame,
   * ImageBitmap, HTMLCanvasElement, or a node Image) — opaque here.
   */
  getFrameSync(mediaT: number): unknown;
  close(): void;
}
/** A decoded still image — opaque to scene/core, consumed by backends. */
type ImageHandle = unknown;
declare class ColdAssetError extends Error {
  readonly assetId: string;
  readonly detail: string;
  /** Media time that was requested cold, when known — drives demand warming. */
  readonly mediaT: number | undefined;
  constructor(assetId: string, detail: string, mediaT?: number);
}
//#endregion
//#region src/renderBackend.d.ts
/** A filter kind the document layer can emit (mirrors `FilterSpec['kind']`). */
type FilterKind = FilterSpec['kind'];
/** Every filter kind the shared Raster2D interpreter rasterizes (§3.4). */
declare const ALL_FILTER_KINDS: ReadonlySet<FilterKind>;
/** What a backend can do — queried, never assumed (§3.4 capability negotiation). */
interface BackendCaps {
  /** Filter kinds this backend rasterizes. */
  readonly filters: ReadonlySet<FilterKind>;
  /** Can it run a ShaderEffect pass (WebGPU)? Headless Skia: false. */
  readonly shaders: boolean;
  /** Largest texture/canvas dimension it will allocate. */
  readonly maxTextureSize: number;
}
interface RenderBackend extends TextMeasurer {
  readonly caps: BackendCaps;
  render(list: DisplayList): void;
  readPixels(): Promise<Uint8ClampedArray>;
  /**
   * Browser zero-copy encode path (§3.4): a decoded frame for VideoEncoder.
   * Absent on headless backends. Typed `unknown` because `VideoFrame` is a DOM
   * type and `@glissade/scene` carries no DOM lib — browser backends cast.
   */
  toVideoFrame?(timestampUs: number): unknown;
  setImageAsset(assetId: string, image: unknown): void;
  setVideoAsset(assetId: string, source: VideoFrameSource): void;
  dispose(): void;
}
//#endregion
//#region src/shaderEffect.d.ts
interface ShaderEffectProps extends NodeProps {
  children?: Node[];
  /** WGSL fragment module: `struct Uniforms {...}` + `@fragment fn effect(@location(0) uv: vec2f) -> @location(0) vec4f`. */
  wgsl: string;
  /** Initial scalar uniforms; each becomes an animatable signal + track target 'u.<name>'. */
  uniforms?: Record<string, number>;
}
declare class ShaderEffect extends Group {
  readonly wgsl: string;
  readonly uniformSignals: ReadonlyMap<string, BindableSignal<number>>;
  constructor(props: ShaderEffectProps);
  /** The live uniform signal (throws on unknown names — typos fail loudly). */
  uniform(name: string): BindableSignal<number>;
  protected groupShader(): ShaderRef;
}
//#endregion
//#region src/echo.d.ts
interface EchoProps extends NodeProps {
  children?: Node[];
  /** total copies including the live one (≥ 1); default 5. */
  count?: number;
  /** seconds between successive copies (the trail's time spread); default 0.08. */
  spacing?: number;
  /** opacity multiplier per trailing step — copy i has opacity decay^i (0..1); default 0.6. */
  decay?: number;
}
declare class Echo extends Group {
  get describeType(): string;
  readonly count: number;
  readonly spacing: number;
  readonly decay: number;
  constructor(props?: EchoProps);
  protected draw(out: DisplayListBuilder, ctx: EvalContext): void;
}
/** `children: [echo(mover, { count: 6, spacing: 0.05 })]` — mover leaves a fading trail.
 * A convenience wrapper: pass the trailing content as children of the returned Echo. */
declare function echo(child: Node, props?: Omit<EchoProps, 'children'>): Echo;
//#endregion
//#region src/motionBlur.d.ts
interface MotionBlurProps extends NodeProps {
  children?: Node[];
  /** the shutter interval in SECONDS, centered on the frame time (0 = no blur); default 0.04. */
  shutter?: number;
  /** number of sub-frame samples averaged across the shutter (≥ 1); default 8. */
  samples?: number;
}
declare class MotionBlur extends Group {
  get describeType(): string;
  readonly shutter: number;
  readonly samples: number;
  constructor(props?: MotionBlurProps);
  protected draw(out: DisplayListBuilder, ctx: EvalContext): void;
}
/** `children: [motionBlur(fastDot, { shutter: 0.05 })]` — fastDot smears with real
 * sub-frame motion blur. Wrap the moving content; its background stays crisp. */
declare function motionBlur(child: Node, props?: Omit<MotionBlurProps, 'children'>): MotionBlur;
//#endregion
//#region src/matte.d.ts
interface TrackMatteProps extends NodeProps {
  /** the visible content — masked by the matte. */
  content: Node;
  /** the mask — its alpha (or luma) decides which content pixels survive. */
  matte: Node;
  /** 'alpha' (default): matte opacity masks. 'luma': matte brightness masks
   *  (white = keep, black = erase), via the shared deterministic CPU kernel. */
  mode?: 'alpha' | 'luma';
}
declare class TrackMatte extends Group {
  get describeType(): string;
  readonly content: Node;
  readonly matte: Node;
  readonly mode: 'alpha' | 'luma';
  constructor(props: TrackMatteProps);
  /** destination-in must not leak past this node — always isolate in a layer. */
  protected requiresGroup(): boolean;
  protected draw(out: DisplayListBuilder, ctx: EvalContext): void;
}
/** `trackMatte(photo, circleWipe)` — photo visible only inside the (animatable)
 * circle. Pass `{ mode: 'luma' }` to mask by matte brightness instead of alpha. */
declare function trackMatte(content: Node, matte: Node, props?: Omit<TrackMatteProps, 'content' | 'matte'>): TrackMatte;
//#endregion
//#region src/raster2d.d.ts
/** A backend gradient handle (DOM CanvasGradient and @napi-rs CanvasGradient both satisfy it). */
interface CanvasGradientLike {
  addColorStop(offset: number, color: string): void;
}
/** The structural path surface buildPath drives — DOM Path2D and @napi-rs Path2D both satisfy it. */
interface PathLike {
  moveTo(x: number, y: number): void;
  lineTo(x: number, y: number): void;
  bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): void;
  quadraticCurveTo(cx: number, cy: number, x: number, y: number): void;
  ellipse(cx: number, cy: number, rx: number, ry: number, rot: number, a0: number, a1: number): void;
  closePath(): void;
}
/** The exact 2D-context surface the interpreter uses — nothing more. */
interface Ctx2DLike<TPath, TDrawable> {
  save(): void;
  restore(): void;
  transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
  resetTransform(): void;
  getTransform(): unknown;
  setTransform(m: unknown): void;
  clearRect(x: number, y: number, w: number, h: number): void;
  clip(path: TPath, rule: 'nonzero' | 'evenodd'): void;
  fill(path: TPath): void;
  stroke(path: TPath): void;
  fillText(text: string, x: number, y: number): void;
  measureText(text: string): {
    width: number;
  };
  drawImage(image: TDrawable, x: number, y: number, w?: number, h?: number): void;
  drawImage(image: TDrawable, sx: number, sy: number, sw: number, sh: number, x: number, y: number, w: number, h: number): void;
  setLineDash(segments: number[]): void;
  createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradientLike;
  createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradientLike;
  lineDashOffset: number;
  fillStyle: unknown;
  strokeStyle: unknown;
  lineWidth: number;
  lineCap: string;
  lineJoin: string;
  font: string;
  /**
   * Variable-font axes (CSS `font-variation-settings` form). PRESENT on
   * `@napi-rs/canvas` (a settable context property — the Skia/export path
   * renders the axes) and ABSENT on the browser DOM 2D context (the optional
   * `?` makes it a guarded no-op there, never a throw). The `fillText` case
   * writes it only when a FontSpec carries axes, then resets to `'normal'`, so
   * default Text never touches it (byte-identical FontSpec / pixels).
   */
  fontVariationSettings?: string;
  textBaseline: string;
  textAlign: string;
  globalAlpha: number;
  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;
  /** Read straight-RGBA back out — used to persist a cached layer's raster to
   * the disk layer store (§3.5 tier). Both DOM and @napi-rs/canvas expose it. */
  getImageData(sx: number, sy: number, sw: number, sh: number): ImageDataLike;
}
/** 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;
  height: number;
}
/** What a backend supplies: constructors and context access for its canvas flavor. */
interface Raster2DHost<TCanvas extends CanvasLike, TPath extends PathLike, TDrawable> {
  context(canvas: TCanvas): Ctx2DLike<TPath, TDrawable>;
  createCanvas(w: number, h: number): TCanvas;
  newPath(): TPath;
  /**
   * §3.7 shader pass: run the WGSL effect over the group layer and return a
   * drawable replacement, or null when unavailable. Absent/null → the layer
   * composites unfiltered per caps.shaders (warn by default, error opt-in).
   * Only browser hosts wire this (via @glissade/effects-webgpu); headless
   * backends stay GPU-free by construction.
   */
  applyShader?(layer: TCanvas, shader: ShaderRef, w: number, h: number): TDrawable | null;
}
type ShaderCaps = 'warn' | 'error';
declare function fontString(font: FontSpec): string;
interface Bounds {
  minX: number;
  minY: number;
  maxX: number;
  maxY: number;
}
/**
 * §3.5 DISK layer-cache tier. The in-memory raster LRU below spans one render;
 * an injected `LayerStore` persists a cached layer's DEVICE-space RGBA across
 * renders (and re-narrations), so an expensive static subtree — a blurred mesh
 * backdrop — rasterizes ONCE and re-blits on later runs even when the whole-frame
 * cache is defeated by a caption/timing change. The store is injected (scene stays
 * Node-dep-free); the CLI provides an fs-backed impl that salts the key with the
 * toolchain version + backend caps + frame size. A restored RGBA composites
 * byte-identically to a fresh raster (getImageData → store → putImageData
 * round-trips exactly — the same guarantee the frame cache relies on).
 */
interface LayerCacheEntry {
  /** straight-RGBA of the full w×h device-space layer canvas */
  readonly rgba: Uint8ClampedArray;
  readonly w: number;
  readonly h: number;
  /** device-space painted bounds (or null); rides along — the hit can't recompute it */
  readonly bounds: Bounds | null;
  readonly unbounded: boolean;
}
interface LayerStore {
  /** key = `<sub-DisplayList fnv1a>@<deviceTransformKey>` (the store salts version/caps/size). */
  get(key: string): LayerCacheEntry | undefined;
  put(key: string, entry: LayerCacheEntry): void;
}
declare class Raster2D<TCanvas extends CanvasLike, TPath extends PathLike, TDrawable> {
  private readonly host;
  /** caps.shaders (§3.7): what happens when a shader can't run here. */
  private readonly shaderCaps;
  /**
   * §3.5 disk layer-cache tier: an injected persistent store for cached-layer
   * rasters (spans renders, survives re-narration). Undefined = in-memory only.
   * Also settable post-construction (the CLI needs backend caps to salt the
   * store's key, which aren't known until the backend exists).
   */
  private layerStore;
  private readonly pool;
  private readonly pathCache;
  private readonly pathBoundsCache;
  private readonly images;
  private readonly videos;
  private warnedShaders;
  private warnedFontVariation;
  /**
   * §3.5 bitmap LRU: device-transform-qualified cacheKey → rasterized layer.
   * A Map preserves insertion order, so the oldest key is `keys().next()` —
   * touch-on-hit by delete+set keeps it a true LRU. Disabled (stays empty) when
   * `cacheEnabled` is false, so cache-cold === cache-warm is testable directly.
   */
  private readonly rasterCache;
  private readonly cacheEnabled;
  constructor(host: Raster2DHost<TCanvas, TPath, TDrawable>, /** caps.shaders (§3.7): what happens when a shader can't run here. */
  shaderCaps?: ShaderCaps,
  /**
   * §3.5: opt-OUT switch for the bitmap LRU. Defaults on, but the env var
   * RASTER_CACHE=0 force-disables it (the equality test renders both ways).
   * A disabled cache is byte-identical — it just always takes the miss path.
   */
  cacheEnabled?: boolean,
  /**
   * §3.5 disk layer-cache tier: an injected persistent store for cached-layer
   * rasters (spans renders, survives re-narration). Undefined = in-memory only.
   * Also settable post-construction (the CLI needs backend caps to salt the
   * store's key, which aren't known until the backend exists).
   */
  layerStore?: LayerStore | undefined);
  /** Attach (or clear) the §3.5 disk layer-cache store after construction. */
  setLayerStore(store: LayerStore | undefined): void;
  /** Register a decoded still (kind 'image' assets). */
  setImageAsset(assetId: string, image: TDrawable): void;
  /** Register a warmed-on-demand video source (kind 'video' assets, §3.8). */
  setVideoAsset(assetId: string, source: VideoFrameSource): void;
  dispose(): void;
  private resolveDrawable;
  private path;
  private pathBounds;
  private buildPath;
  private acquire;
  private release;
  /**
   * §3.5 LRU insert with touch-on-hit + eviction-to-pool. Storing under a key
   * that already holds a (different) canvas releases the old one first.
   */
  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
   * for both the freshly-rasterized miss path and a cache-blit hit, so a HIT is
   * byte-identical to a MISS. `bounds`/`unbounded` come from the layer (miss) or
   * the cache entry (hit); the composite params (opacity/blend/filters) always
   * come from the LIVE pushGroup command, never the cache.
   */
  /**
   * 0.34 luma matte: convert a layer's LUMINANCE to its alpha, in place —
   * `a' = round(luma(r,g,b) × a / 255)` with Rec.709 integer coefficients over
   * STRAIGHT (non-premultiplied) RGBA, the same discipline as the mesh kernel,
   * so both backends run one deterministic CPU pass and the result byte-compares.
   */
  private lumaToAlpha;
  private composite;
  /** The command walk — order and operations identical to the pre-extraction twins. */
  render(target: TCanvas, list: DisplayList): void;
}
//#endregion
//#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 BindSceneOptions, type BindablePropTarget, type BlendMode, type Bounds, type CanvasLike, Circle, type ClipRegion, ColdAssetError, type Ctx2DLike, Custom, DeterminismViolationError, type DisplayList, type DisplayListBuilder, type DrawCommand, type DrawOnEachOptions, type DrawOnOptions, DuplicateNodeIdError, type EachBox, type EachContext, type EachDistribute, EachError, type EachLayout, type EachMotion, type EachOpts, type EachResult, Echo, type EchoProps, type EditMark, type EvalContext, type FilterKind, type FilterSpec, FilterValidationError, type FontSpec, type GeometryOpts, type GraphemeBox, Group, type GuardMode, type HachureSpec, Highlight, type HighlightProps, type HitArea, IDENTITY, ImageNode as Image, ImageNode, type ImageDataLike, type ImageHandle, type ImageProps, type LayerCacheEntry, type LayerStore, type LayoutBox, type LayoutChildSpec, type LayoutContainerSpec, type LayoutEngine, LayoutEngineMissingError, type LineBox, MEASURE_QUANTUM_PX, MESH_DOWNSCALE, MESH_SHEPARD_POWER, MESH_SIGMA, type Mat2x3, MeasurerRequiredError, type MeshInterpolation, type MeshPaint, type MeshPoint, MotionBlur, type MotionBlurProps, NODE_TAXONOMY, Node, NodeConstructionError, type NodeProps, type NodeTypeName, type Paint, Path, type PathLike, type PathProps, type PathSeg, type Place, 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, TrackMatte, type TrackMatteProps, type TypeEdit, type TypewriterResult, Video, type VideoFrameSource, type VideoProps, type ViolationDetail, type ViolationLocator, type WordBox, type WrappedTextMetrics, applyToPoint, arcLength, assertFiniteFontSize, bindScene, breakLines, coercePathData, collapseReplacer, createDisplayListBuilder, createScene, drawOn, drawOnEach, each, echo, estimatingMeasurer, evaluate, filtersToCanvasFilter, flatten, fontString, fromTRS, getLayoutEngine, glow, hachureLines, highlight, invert, isEstimatingMeasurer, matEquals, measureWrappedText, meshRasterSize, motionBlur, multiply, pathFromSegs, quantize, rasterizeMesh, requireLayoutEngine, resolveAnchor, resolveSketch, revealSchedule, roughen, roundedRectSegs, segmentGraphemes, segmentWords, setDefaultMeasurer, setLayoutEngine, sketchStrokes, textCursor, trackMatte, typewriter, validateFilters, validateHachure, validateSketch, withDeterminismGuards };