@field/cascade 0.2.22 → 0.3.0

package/dist/runtime/expressions/math.js

@@ -0,0 +1,140 @@
+/**
+ * Expression math utilities.
+ *
+ * Pure functions, no ambient state, deterministic for a given input — the same
+ * contract the rest of the runtime holds. `noise` and `random` are seeded
+ * closed forms rather than anything drawn from process state.
+ */
+/** Remap a value from one range to another. */
+export function fit(value, oldMin, oldMax, newMin, newMax) {
+    if (oldMax === oldMin)
+        return newMin;
+    const t = (value - oldMin) / (oldMax - oldMin);
+    return newMin + t * (newMax - newMin);
+}
+/** Remap a 0..1 value into a new range. */
+export function fit01(value, newMin, newMax) {
+    return newMin + value * (newMax - newMin);
+}
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+/** Smooth hermite interpolation (smoothstep). */
+export function smooth(value, min, max) {
+    if (value <= min)
+        return 0;
+    if (value >= max)
+        return 1;
+    const t = (value - min) / (max - min);
+    return t * t * (3 - 2 * t);
+}
+/**
+ * Perlin-like noise in -1..1. Not true Perlin — a deterministic sum of sines.
+ */
+export function noise(...coords) {
+    if (coords.length === 0)
+        return 0;
+    let result = 0;
+    const frequencies = [1, 2.3, 4.7, 8.1];
+    const amplitudes = [1, 0.5, 0.25, 0.125];
+    for (let i = 0; i < frequencies.length; i++) {
+        let sum = 0;
+        for (let j = 0; j < coords.length; j++) {
+            sum += Math.sin(coords[j] * frequencies[i] * (j + 1) * 1.7 + j * 3.14159);
+        }
+        result += sum * amplitudes[i];
+    }
+    return Math.sin(result * 0.5);
+}
+/** Deterministic random in 0..1 from a seed. */
+export function random(seed) {
+    const x = Math.sin(seed * 12.9898) * 43758.5453;
+    return x - Math.floor(x);
+}
+/** Zero-pad a number to a given number of digits. */
+export function padzero(digits, value) {
+    return String(Math.floor(value)).padStart(digits, "0");
+}
+// ============ Bare maths, as Houdini exposes it ============
+//
+// An expression language whose users write `sin($T)` and get "sin is not
+// defined" is one they stop trusting. Houdini exposes the whole maths library
+// bare, and so do we.
+//
+// Angles are RADIANS, unlike Houdini's degrees. Two reasons, and the second is
+// the deciding one. `$T` in radians oscillates over 2pi seconds, which is a
+// usable animation period, where in degrees `sin($T)` would take six minutes to
+// come round. And `Math` is also in scope, so a degree-based `sin()` would
+// disagree with `Math.sin()` inside the same expression — a trap far worse than
+// having to type `radians()`. The `sind`/`cosd`/`tand` trio is there for anyone
+// carrying a formula over from Houdini.
+/** Degrees to radians. */
+export function radians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+/** Radians to degrees. */
+export function degrees(radians) {
+    return (radians * 180) / Math.PI;
+}
+/** Sine of an angle in degrees — Houdini's `sin()`. */
+export function sind(degrees) {
+    return Math.sin(radians(degrees));
+}
+/** Cosine of an angle in degrees — Houdini's `cos()`. */
+export function cosd(degrees) {
+    return Math.cos(radians(degrees));
+}
+/** Tangent of an angle in degrees — Houdini's `tan()`. */
+export function tand(degrees) {
+    return Math.tan(radians(degrees));
+}
+/**
+ * The bare maths names available to every expression. Spread into the
+ * evaluation scope; kept as one object so adding a function is a one-line
+ * change here rather than a change in two files.
+ */
+export const MATH_SCOPE = {
+    // Trigonometry, in radians
+    sin: Math.sin,
+    cos: Math.cos,
+    tan: Math.tan,
+    asin: Math.asin,
+    acos: Math.acos,
+    atan: Math.atan,
+    atan2: Math.atan2,
+    sinh: Math.sinh,
+    cosh: Math.cosh,
+    tanh: Math.tanh,
+    // Trigonometry, in degrees, for formulae carried over from Houdini
+    sind,
+    cosd,
+    tand,
+    radians,
+    degrees,
+    // Powers and logs
+    sqrt: Math.sqrt,
+    cbrt: Math.cbrt,
+    pow: Math.pow,
+    exp: Math.exp,
+    log: Math.log,
+    log2: Math.log2,
+    log10: Math.log10,
+    hypot: Math.hypot,
+    // Rounding and sign
+    abs: Math.abs,
+    sign: Math.sign,
+    floor: Math.floor,
+    ceil: Math.ceil,
+    round: Math.round,
+    trunc: Math.trunc,
+    min: Math.min,
+    max: Math.max,
+    // Constants
+    PI: Math.PI,
+    TAU: Math.PI * 2,
+    E: Math.E
+};
+//# sourceMappingURL=math.js.map

package/dist/runtime/expressions/preprocess.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Expression preprocessing: Houdini-style `$` time variables.
+ *
+ * Expressions compile to raw JS (`return (<expr>)`) evaluated against a context
+ * object, so `$F` is not valid input. This pass rewrites the `$` spellings to
+ * the plain identifiers the context carries, before compilation. The bare
+ * identifiers remain valid aliases — `time`, `frame`, `fframe`, `fps` — so
+ * nothing already authored breaks.
+ *
+ *   $F    -> frame    integer frame
+ *   $FF   -> fframe   fractional frame
+ *   $T    -> time     seconds
+ *   $FPS  -> fps      rate
+ *
+ * `$` is rewritten only in code position: occurrences inside string or template
+ * literals are left alone, so `chs("$F")` stays a string.
+ */
+/** The `$` time tokens, longest first so `$FPS` wins over `$F`. */
+export declare const TIME_TOKENS: ReadonlyArray<readonly [token: string, identifier: string]>;
+/** Bare identifiers that carry time, kept as aliases for the `$` spellings. */
+export declare const TIME_IDENTIFIERS: readonly string[];
+/**
+ * Rewrite `$` time variables to their plain identifiers.
+ * Returns the source unchanged when it contains no `$`.
+ */
+export declare function preprocessExpression(source: string): string;
+/**
+ * True if an expression references any time variable, in either spelling.
+ * This is what sets `isTimeDependent`, which is what lets a per-frame cook
+ * recompute only the time-dependent subgraph.
+ */
+export declare function hasTimeReference(source: string): boolean;
+//# sourceMappingURL=preprocess.d.ts.map

package/dist/runtime/expressions/preprocess.js

@@ -0,0 +1,102 @@
+/**
+ * Expression preprocessing: Houdini-style `$` time variables.
+ *
+ * Expressions compile to raw JS (`return (<expr>)`) evaluated against a context
+ * object, so `$F` is not valid input. This pass rewrites the `$` spellings to
+ * the plain identifiers the context carries, before compilation. The bare
+ * identifiers remain valid aliases — `time`, `frame`, `fframe`, `fps` — so
+ * nothing already authored breaks.
+ *
+ *   $F    -> frame    integer frame
+ *   $FF   -> fframe   fractional frame
+ *   $T    -> time     seconds
+ *   $FPS  -> fps      rate
+ *
+ * `$` is rewritten only in code position: occurrences inside string or template
+ * literals are left alone, so `chs("$F")` stays a string.
+ */
+/** The `$` time tokens, longest first so `$FPS` wins over `$F`. */
+export const TIME_TOKENS = [
+    ["$FPS", "fps"],
+    ["$FF", "fframe"],
+    ["$F", "frame"],
+    ["$T", "time"]
+];
+/** Bare identifiers that carry time, kept as aliases for the `$` spellings. */
+export const TIME_IDENTIFIERS = ["time", "frame", "fframe", "fps"];
+const DOLLAR_TIME_PATTERN = /\$(FPS|FF|F|T)\b/g;
+const BARE_TIME_PATTERN = /\b(?:time|frame|fframe|fps)\b/;
+const DOLLAR_TO_IDENTIFIER = {
+    FPS: "fps",
+    FF: "fframe",
+    F: "frame",
+    T: "time"
+};
+/**
+ * Split an expression into code and literal spans, so a rewrite can skip
+ * string and template literals. Deliberately small: it handles quotes and
+ * escapes, which is all an expression field contains.
+ */
+function codeSpans(source) {
+    const spans = [];
+    let spanStart = 0;
+    let index = 0;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === '"' || char === "'" || char === "`") {
+            spans.push({ start: spanStart, end: index });
+            const quote = char;
+            index += 1;
+            while (index < source.length) {
+                if (source[index] === "\\") {
+                    index += 2;
+                    continue;
+                }
+                if (source[index] === quote) {
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
+            spanStart = index;
+            continue;
+        }
+        index += 1;
+    }
+    spans.push({ start: spanStart, end: source.length });
+    return spans;
+}
+/**
+ * Rewrite `$` time variables to their plain identifiers.
+ * Returns the source unchanged when it contains no `$`.
+ */
+export function preprocessExpression(source) {
+    if (!source.includes("$"))
+        return source;
+    let out = "";
+    let cursor = 0;
+    for (const span of codeSpans(source)) {
+        // Literal text between spans is copied verbatim.
+        if (span.start > cursor)
+            out += source.slice(cursor, span.start);
+        out += source
+            .slice(span.start, span.end)
+            .replace(DOLLAR_TIME_PATTERN, (_match, key) => DOLLAR_TO_IDENTIFIER[key]);
+        cursor = span.end;
+    }
+    if (cursor < source.length)
+        out += source.slice(cursor);
+    return out;
+}
+/**
+ * True if an expression references any time variable, in either spelling.
+ * This is what sets `isTimeDependent`, which is what lets a per-frame cook
+ * recompute only the time-dependent subgraph.
+ */
+export function hasTimeReference(source) {
+    if (BARE_TIME_PATTERN.test(source))
+        return true;
+    DOLLAR_TIME_PATTERN.lastIndex = 0;
+    return DOLLAR_TIME_PATTERN.test(source);
+}
+//# sourceMappingURL=preprocess.js.map

package/dist/runtime/expressions/scope.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The host binding for expression evaluation.
+ *
+ * The expression engine needs to read parameters off neighbouring nodes and to
+ * follow inputs, but it must not know what a node *is* — that is what kept it
+ * pinned to Studio's compatibility `Graph`/`Node`. A host supplies a scope; the
+ * engine stays neutral and works unchanged in a headless cook.
+ */
+/** The minimum a node must offer to be addressable from an expression. */
+export interface Node {
+    id: string;
+}
+export interface ExpressionScope<TNode = Node> {
+    /**
+     * Resolve a channel path relative to a node, e.g. `./radius`,
+     * `../blur1/amount`, `/root/node/value`. Return null when it does not
+     * resolve — the engine turns that into 0 / '' / [] per accessor.
+     */
+    resolveParam(from: TNode, path: string): {
+        value: unknown;
+    } | null;
+    /** True if a node exists at the path, relative to `from`. */
+    nodeExists(from: TNode, path: string): boolean;
+    /** The node connected to `from`'s input at `index`, if any. */
+    inputNode(from: TNode, index: number): TNode | null;
+}
+//# sourceMappingURL=scope.d.ts.map

package/dist/runtime/expressions/scope.js

@@ -0,0 +1,10 @@
+/**
+ * The host binding for expression evaluation.
+ *
+ * The expression engine needs to read parameters off neighbouring nodes and to
+ * follow inputs, but it must not know what a node *is* — that is what kept it
+ * pinned to Studio's compatibility `Graph`/`Node`. A host supplies a scope; the
+ * engine stays neutral and works unchanged in a headless cook.
+ */
+export {};
+//# sourceMappingURL=scope.js.map

package/dist/runtime/expressions/time.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Time state for expression evaluation.
+ *
+ * Frames are stored as a real number so sub-frame time exists. `frame` is the
+ * integer frame ($F), `frameFraction` is the exact fractional frame ($FF), and
+ * `time` is seconds ($T). Nothing here reads a clock: time is set by the caller
+ * (a cook request, a frame-range loop, a transport) and the engine only ever
+ * reports what it was told. That is what keeps a cook deterministic.
+ */
+export declare const DEFAULT_FPS = 30;
+export declare const MIN_FRAME = 1;
+export declare class TimeState {
+    /** Exact, possibly fractional frame. Never below MIN_FRAME. */
+    private _frame;
+    private _fps;
+    /**
+     * Set the current frame. Fractional values are preserved; only the lower
+     * bound is enforced. Non-finite input is ignored.
+     */
+    setFrame(frame: number): void;
+    /** Set the current time in seconds, keeping the sub-frame remainder. */
+    setTime(seconds: number): void;
+    setFps(fps: number): void;
+    /** Integer frame — $F. */
+    get frame(): number;
+    /** Fractional frame — $FF. */
+    get frameFraction(): number;
+    /**
+     * Seconds — $T. Derived from the fractional frame, so it round-trips.
+     *
+     * Zero at the first frame, which is Houdini's convention: $T = ($FF - 1)/$FPS.
+     * The previous definition was frame/fps, making $T equal 1/fps at frame 1 —
+     * so `sin($T)` started part-way through its cycle and an animation's first
+     * frame was never t=0. Changed 2026-09-07 because Marcus named Houdini as the
+     * reference for these variables, and because "time starts at zero" is the
+     * thing anybody writing an expression will assume.
+     */
+    get time(): number;
+    /** Frame rate — $FPS. */
+    get fps(): number;
+    /** Immutable snapshot of the four time variables. */
+    snapshot(): TimeVariables;
+}
+export interface TimeVariables {
+    /** Integer frame — $F */
+    frame: number;
+    /** Fractional frame — $FF */
+    frameFraction: number;
+    /** Seconds — $T */
+    time: number;
+    /** Frame rate — $FPS */
+    fps: number;
+}
+//# sourceMappingURL=time.d.ts.map

package/dist/runtime/expressions/time.js

@@ -0,0 +1,71 @@
+/**
+ * Time state for expression evaluation.
+ *
+ * Frames are stored as a real number so sub-frame time exists. `frame` is the
+ * integer frame ($F), `frameFraction` is the exact fractional frame ($FF), and
+ * `time` is seconds ($T). Nothing here reads a clock: time is set by the caller
+ * (a cook request, a frame-range loop, a transport) and the engine only ever
+ * reports what it was told. That is what keeps a cook deterministic.
+ */
+export const DEFAULT_FPS = 30;
+export const MIN_FRAME = 1;
+export class TimeState {
+    /** Exact, possibly fractional frame. Never below MIN_FRAME. */
+    _frame = MIN_FRAME;
+    _fps = DEFAULT_FPS;
+    /**
+     * Set the current frame. Fractional values are preserved; only the lower
+     * bound is enforced. Non-finite input is ignored.
+     */
+    setFrame(frame) {
+        if (!Number.isFinite(frame))
+            return;
+        this._frame = Math.max(MIN_FRAME, frame);
+    }
+    /** Set the current time in seconds, keeping the sub-frame remainder. */
+    setTime(seconds) {
+        if (!Number.isFinite(seconds))
+            return;
+        this.setFrame(seconds * this._fps + MIN_FRAME);
+    }
+    setFps(fps) {
+        if (!Number.isFinite(fps))
+            return;
+        this._fps = Math.max(1, fps);
+    }
+    /** Integer frame — $F. */
+    get frame() {
+        return Math.floor(this._frame);
+    }
+    /** Fractional frame — $FF. */
+    get frameFraction() {
+        return this._frame;
+    }
+    /**
+     * Seconds — $T. Derived from the fractional frame, so it round-trips.
+     *
+     * Zero at the first frame, which is Houdini's convention: $T = ($FF - 1)/$FPS.
+     * The previous definition was frame/fps, making $T equal 1/fps at frame 1 —
+     * so `sin($T)` started part-way through its cycle and an animation's first
+     * frame was never t=0. Changed 2026-09-07 because Marcus named Houdini as the
+     * reference for these variables, and because "time starts at zero" is the
+     * thing anybody writing an expression will assume.
+     */
+    get time() {
+        return (this._frame - MIN_FRAME) / this._fps;
+    }
+    /** Frame rate — $FPS. */
+    get fps() {
+        return this._fps;
+    }
+    /** Immutable snapshot of the four time variables. */
+    snapshot() {
+        return {
+            frame: this.frame,
+            frameFraction: this.frameFraction,
+            time: this.time,
+            fps: this.fps
+        };
+    }
+}
+//# sourceMappingURL=time.js.map

package/dist/runtime/expressions/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Expression types.
+ *
+ * These live in the runtime rather than in contracts because a compiled
+ * expression carries a function, so it is runtime machinery rather than a
+ * serializable DTO. Contracts stays dependency-free and data-only.
+ */
+import type { Node as NodeShape } from "./scope.js";
+/**
+ * The context an expression is evaluated against. Everything an expression can
+ * see is on this object — there is no ambient global, and in particular no
+ * clock: the time variables are values placed here by the caller.
+ */
+export interface ExpressionContext<TNode = NodeShape> {
+    /** seconds — $T */
+    time: number;
+    /** integer frame — $F */
+    frame: number;
+    /** fractional frame — $FF */
+    fframe: number;
+    /** rate — $FPS */
+    fps: number;
+    /** The node whose parameter is being evaluated. */
+    self: TNode;
+    ch: (path: string) => number;
+    chs: (path: string) => string;
+    chv: (path: string) => number[];
+    opexist: (path: string) => 0 | 1;
+    opinput: (index: number) => TNode | null;
+    fit: (value: number, oldMin: number, oldMax: number, newMin: number, newMax: number) => number;
+    fit01: (value: number, newMin: number, newMax: number) => number;
+    clamp: (value: number, min: number, max: number) => number;
+    lerp: (a: number, b: number, t: number) => number;
+    smooth: (value: number, min: number, max: number) => number;
+    noise: (...coords: number[]) => number;
+    random: (seed: number) => number;
+    padzero: (digits: number, value: number) => string;
+    Math: typeof Math;
+}
+/** A compiled, cached expression ready to evaluate against a context. */
+export interface CompiledExpression<TNode = NodeShape> {
+    /** The expression as authored, `$` spellings intact. */
+    source: string;
+    /** The expression after `$` preprocessing — what was actually compiled. */
+    compiledSource: string;
+    evaluate: (context: ExpressionContext<TNode>) => unknown;
+    /** Parameter paths referenced through ch/chs/chv, for dirty tracking. */
+    dependencies: string[];
+    /** True if the expression references any time variable, in either spelling. */
+    isTimeDependent: boolean;
+    error?: string;
+}
+/** Result of evaluating one expression. */
+export interface ExpressionResult {
+    value: unknown;
+    error?: string;
+}
+/** A referenced path that does not resolve. */
+export interface PathWarning {
+    nodeId: string;
+    nodePath: string;
+    propName: string;
+    expression: string;
+    brokenPath: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/expressions/types.js

@@ -0,0 +1,9 @@
+/**
+ * Expression types.
+ *
+ * These live in the runtime rather than in contracts because a compiled
+ * expression carries a function, so it is runtime machinery rather than a
+ * serializable DTO. Contracts stays dependency-free and data-only.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runtime/geometry/attributes.d.ts

@@ -1,4 +1,4 @@
-import { type AnyAttribute, type Attribute, type AttributeLevel, type AttributeSet, type AttributeStorage, type DetailValue, type ElementLevel, type Geometry, type StringAttribute } from "cascade/contracts";
+import { type AnyAttribute, type Attribute, type AttributeLevel, type AttributeSet, type AttributeStorage, type DetailValue, type ElementLevel, type Geometry, type StringAttribute } from "@field/cascade/contracts";
 /**
  * Attribute reads and writes. Every write returns a new `Geometry` and shares
  * the arrays it did not touch, which is the whole reason the format is
@@ -61,5 +61,5 @@ export interface AttributeCreateOptions {
  */
 export declare function attributeCreate(geometry: Geometry, options: AttributeCreateOptions): Geometry;
 /** A same-storage copy of an attribute's array, for a write-in-place pass. */
-export declare function copyAttributeArray(attribute: Attribute): import("cascade/contracts").AttributeArray;
+export declare function copyAttributeArray(attribute: Attribute): import("@field/cascade/contracts").AttributeArray;
 //# sourceMappingURL=attributes.d.ts.map

package/dist/runtime/geometry/attributes.js

@@ -1,4 +1,4 @@
-import { attributeArray, attributeArrayFrom, createGeometry, isStringAttribute, levelCount, POSITION_ATTRIBUTE, } from "cascade/contracts";
+import { attributeArray, attributeArrayFrom, createGeometry, isStringAttribute, levelCount, POSITION_ATTRIBUTE, } from "@field/cascade/contracts";
 /**
  * Attribute reads and writes. Every write returns a new `Geometry` and shares
  * the arrays it did not touch, which is the whole reason the format is

package/dist/runtime/geometry/builder.d.ts

@@ -1,4 +1,4 @@
-import { emptyGeometry, type AnyAttribute, type AttributeStorage, type DetailValue, type ElementLevel, type Geometry, type PrimitiveKind } from "cascade/contracts";
+import { emptyGeometry, type AnyAttribute, type AttributeStorage, type DetailValue, type ElementLevel, type Geometry, type PrimitiveKind } from "@field/cascade/contracts";
 export { emptyGeometry };
 export interface GeometryBuilderOptions {
     /** 2 by default: the reference workloads are two-component. */

package/dist/runtime/geometry/builder.js

@@ -1,4 +1,4 @@
-import { attributeArrayFrom, createGeometry, emptyGeometry, POSITION_ATTRIBUTE, PRIMITIVE_KINDS, } from "cascade/contracts";
+import { attributeArrayFrom, createGeometry, emptyGeometry, POSITION_ATTRIBUTE, PRIMITIVE_KINDS, } from "@field/cascade/contracts";
 import { createStringAttribute, geometryError } from "./attributes.js";
 export { emptyGeometry };
 /**

package/dist/runtime/geometry/copy.d.ts

@@ -1,4 +1,4 @@
-import { type Geometry } from "cascade/contracts";
+import { type Geometry } from "@field/cascade/contracts";
 /**
  * Copy to Points: one geometry instanced onto every point of another.
  *

package/dist/runtime/geometry/copy.js

@@ -1,4 +1,4 @@
-import { emptyGeometry, isStringAttribute, POSITION_ATTRIBUTE, } from "cascade/contracts";
+import { emptyGeometry, isStringAttribute, POSITION_ATTRIBUTE, } from "@field/cascade/contracts";
 import { createAttribute, createStringAttribute, geometryError, getPosition, numericAttribute, positionSize, readComponent, readElement, readString, setAttribute, } from "./attributes.js";
 import { groupIndices, groupMask } from "./groups.js";
 import { transformMatrix } from "./matrix.js";

package/dist/runtime/geometry/generate.d.ts

@@ -1,4 +1,4 @@
-import type { Geometry } from "cascade/contracts";
+import type { Geometry } from "@field/cascade/contracts";
 /**
  * The generators. Each returns one primitive in a geometry of its own, so a
  * graph composes them with `Merge` rather than with a multi-shape node.

package/dist/runtime/geometry/groups.d.ts

@@ -1,4 +1,4 @@
-import { type Geometry } from "cascade/contracts";
+import { type Geometry } from "@field/cascade/contracts";
 /**
  * Groups are named subsets, stored as one byte per element. A mask is the right
  * shape because membership is tested far more often than it is enumerated, and

package/dist/runtime/geometry/groups.js

@@ -1,4 +1,4 @@
-import { createGeometry, levelCount } from "cascade/contracts";
+import { createGeometry, levelCount } from "@field/cascade/contracts";
 import { geometryError } from "./attributes.js";
 const KEYS = {
     point: "pointGroups",

package/dist/runtime/geometry/matrix.d.ts

@@ -1,4 +1,4 @@
-import type { Mat3 } from "cascade/contracts";
+import type { Mat3 } from "@field/cascade/contracts";
 /**
  * The `mat3` a transform node or an instancing operation needs, built from the
  * four parameters a Houdini user already knows: translate, rotate, scale and

package/dist/runtime/geometry/merge.d.ts

@@ -1,4 +1,4 @@
-import { type AttributeStorage, type Geometry } from "cascade/contracts";
+import { type AttributeStorage, type Geometry } from "@field/cascade/contracts";
 /**
  * Merge concatenates geometries and renumbers points, vertices and primitives.
  *

package/dist/runtime/geometry/merge.js

@@ -1,4 +1,4 @@
-import { attributeArray, createGeometry, emptyGeometry, isStringAttribute, levelCount, } from "cascade/contracts";
+import { attributeArray, createGeometry, emptyGeometry, isStringAttribute, levelCount, } from "@field/cascade/contracts";
 import { createStringAttribute, geometryError, readString } from "./attributes.js";
 /**
  * Merge concatenates geometries and renumbers points, vertices and primitives.

package/dist/runtime/geometry/primitives.d.ts

@@ -1,4 +1,4 @@
-import type { Geometry, PrimitiveKind } from "cascade/contracts";
+import type { Geometry, PrimitiveKind } from "@field/cascade/contracts";
 /** Topology and measurement reads that the operations share. */
 export declare function primitiveKind(geometry: Geometry, primitive: number): PrimitiveKind;
 export declare function isClosed(geometry: Geometry, primitive: number): boolean;

package/dist/runtime/geometry/primitives.js

@@ -1,4 +1,4 @@
-import { BEZIER_STRIDE, PRIMITIVE_KINDS } from "cascade/contracts";
+import { BEZIER_STRIDE, PRIMITIVE_KINDS } from "@field/cascade/contracts";
 import { geometryError, positionAttribute, positionSize, } from "./attributes.js";
 /** Topology and measurement reads that the operations share. */
 export function primitiveKind(geometry, primitive) {

package/dist/runtime/geometry/promote.d.ts

@@ -1,4 +1,4 @@
-import { type AttributeLevel, type ElementLevel, type Geometry } from "cascade/contracts";
+import { type AttributeLevel, type ElementLevel, type Geometry } from "@field/cascade/contracts";
 /**
  * Moving an attribute between levels, and copying one between geometries.
  *

package/dist/runtime/geometry/promote.js

@@ -1,4 +1,4 @@
-import { attributeArray, isStringAttribute, levelCount, POSITION_ATTRIBUTE, } from "cascade/contracts";
+import { attributeArray, isStringAttribute, levelCount, POSITION_ATTRIBUTE, } from "@field/cascade/contracts";
 import { createStringAttribute, geometryError, readString, removeAttribute, removeDetail, setAttribute, setDetail, } from "./attributes.js";
 /**
  * Which source elements feed each target element. This one table is the whole

package/dist/runtime/geometry/resample.d.ts

@@ -1,4 +1,4 @@
-import { type Geometry } from "cascade/contracts";
+import { type Geometry } from "@field/cascade/contracts";
 /**
  * Rewrite each primitive at a uniform arc-length spacing, or at a target
  * vertex count. Most curve operations want a uniformly sampled chain, so this

package/dist/runtime/geometry/resample.js

@@ -1,4 +1,4 @@
-import { attributeArray, createGeometry, isStringAttribute, } from "cascade/contracts";
+import { attributeArray, createGeometry, isStringAttribute, } from "@field/cascade/contracts";
 import { createStringAttribute, geometryError, readString, } from "./attributes.js";
 import { groupMask } from "./groups.js";
 import { arcLengths, isBezier, isClosed, loosePointMask, primitivePoints, } from "./primitives.js";

package/dist/runtime/geometry/svg.d.ts

@@ -1,4 +1,4 @@
-import { Color, type Geometry } from "cascade/contracts";
+import { Color, type Geometry } from "@field/cascade/contracts";
 /**
  * Geometry to an SVG document. The node that makes the library provably useful,
  * because it produces a file to print or plot rather than an assertion.