@field/cascade 0.2.22 → 0.3.1

package/dist/runtime/expressions/evaluator.js

@@ -0,0 +1,193 @@
+/**
+ * The neutral expression evaluator.
+ *
+ * Compiles parameter expressions and evaluates them against a time state and a
+ * host-supplied scope. It imports nothing from Studio and touches no platform
+ * API, so a headless cook can resolve `sin($T)` on a parameter exactly as the
+ * editor does.
+ *
+ * Determinism: an expression is a parameter resolved *before* execute runs, so
+ * the node receives a plain number and stays pure. Same graph plus same frame
+ * gives the same output.
+ */
+import { clamp, fit, fit01, lerp, MATH_SCOPE, noise, padzero, random, smooth } from "./math.js";
+import { hasTimeReference, preprocessExpression } from "./preprocess.js";
+import { TimeState } from "./time.js";
+const DEPENDENCY_PATTERN = /\b(?:ch|chs|chv)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+export class ExpressionEvaluator {
+    timeState = new TimeState();
+    compiledCache = new Map();
+    scope;
+    constructor(scope = null) {
+        this.scope = scope;
+    }
+    /** Bind (or rebind) the host scope. Clears nothing: compilation is scope-free. */
+    setScope(scope) {
+        this.scope = scope;
+    }
+    getScope() {
+        return this.scope;
+    }
+    // ============ Time ============
+    /** Set the current frame. Fractional frames are preserved. */
+    setFrame(frame) {
+        this.timeState.setFrame(frame);
+    }
+    /** Set the current time in seconds, keeping the sub-frame remainder. */
+    setTime(seconds) {
+        this.timeState.setTime(seconds);
+    }
+    setFps(fps) {
+        this.timeState.setFps(fps);
+    }
+    /** seconds — $T */
+    get time() {
+        return this.timeState.time;
+    }
+    /** integer frame — $F */
+    get frame() {
+        return this.timeState.frame;
+    }
+    /** fractional frame — $FF */
+    get fframe() {
+        return this.timeState.frameFraction;
+    }
+    /** rate — $FPS */
+    get fps() {
+        return this.timeState.fps;
+    }
+    // ============ Compile / evaluate ============
+    compile(expression) {
+        const cached = this.compiledCache.get(expression);
+        if (cached)
+            return cached;
+        const dependencies = this.extractDependencies(expression);
+        const isTimeDependent = hasTimeReference(expression);
+        const compiledSource = preprocessExpression(expression);
+        try {
+            const fnBody = `
+        with (context) {
+          return (${compiledSource});
+        }
+      `;
+            const evaluator = new Function("context", fnBody);
+            const compiled = {
+                source: expression,
+                compiledSource,
+                evaluate: evaluator,
+                dependencies,
+                isTimeDependent
+            };
+            this.compiledCache.set(expression, compiled);
+            return compiled;
+        }
+        catch (err) {
+            return {
+                source: expression,
+                compiledSource,
+                evaluate: () => undefined,
+                dependencies,
+                isTimeDependent,
+                error: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    evaluate(expression, node) {
+        const compiled = this.compile(expression);
+        if (compiled.error)
+            return { value: undefined, error: compiled.error };
+        try {
+            return { value: compiled.evaluate(this.createContext(node)) };
+        }
+        catch (err) {
+            return {
+                value: undefined,
+                error: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    /** Build the context an expression sees. */
+    createContext(node) {
+        return {
+            time: this.timeState.time,
+            frame: this.timeState.frame,
+            fframe: this.timeState.frameFraction,
+            fps: this.timeState.fps,
+            self: node,
+            ch: (path) => this.ch(node, path),
+            chs: (path) => this.chs(node, path),
+            chv: (path) => this.chv(node, path),
+            opexist: (path) => (this.scope?.nodeExists(node, path) ? 1 : 0),
+            opinput: (index) => this.scope?.inputNode(node, index) ?? null,
+            fit,
+            fit01,
+            clamp,
+            lerp,
+            smooth,
+            noise,
+            random,
+            padzero,
+            // Bare maths — `sin($FF * 0.5)` rather than `Math.sin(...)`. Spread
+            // before `Math` so nothing here can shadow the namespace itself.
+            ...MATH_SCOPE,
+            Math
+        };
+    }
+    // ============ Channel functions ============
+    ch(node, path) {
+        const resolved = this.resolveParam(node, path);
+        if (!resolved)
+            return 0;
+        const value = resolved.value;
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string")
+            return parseFloat(value) || 0;
+        if (typeof value === "boolean")
+            return value ? 1 : 0;
+        return 0;
+    }
+    chs(node, path) {
+        const resolved = this.resolveParam(node, path);
+        if (!resolved)
+            return "";
+        return String(resolved.value ?? "");
+    }
+    chv(node, path) {
+        const resolved = this.resolveParam(node, path);
+        if (!resolved)
+            return [];
+        const value = resolved.value;
+        if (Array.isArray(value)) {
+            return value.map((v) => (typeof v === "number" ? v : parseFloat(String(v)) || 0));
+        }
+        if (typeof value === "number")
+            return [value];
+        return [];
+    }
+    resolveParam(node, path) {
+        return this.scope?.resolveParam(node, path) ?? null;
+    }
+    /** True if a referenced path resolves from this node. */
+    validatePath(fromNode, path) {
+        return this.resolveParam(fromNode, path) !== null;
+    }
+    /** Parameter paths referenced through ch/chs/chv. */
+    extractDependencies(expression) {
+        const deps = [];
+        DEPENDENCY_PATTERN.lastIndex = 0;
+        let match;
+        while ((match = DEPENDENCY_PATTERN.exec(expression)) !== null) {
+            deps.push(match[1]);
+        }
+        return deps;
+    }
+    /** True if the expression references time, in either the bare or `$` spelling. */
+    hasTimeReference(expression) {
+        return hasTimeReference(expression);
+    }
+    clearCache() {
+        this.compiledCache.clear();
+    }
+}
+//# sourceMappingURL=evaluator.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Parameter expressions, neutral runtime.
+ *
+ * Compilation, `$` time variables, math utilities and the host scope binding.
+ * Depends on nothing outside this folder, so both Studio and a headless host
+ * evaluate parameters with the same engine.
+ */
+export { ExpressionEvaluator } from "./evaluator.js";
+export { clamp, fit, fit01, lerp, noise, padzero, random, smooth } from "./math.js";
+export { TIME_IDENTIFIERS, TIME_TOKENS, hasTimeReference, preprocessExpression } from "./preprocess.js";
+export { DEFAULT_FPS, MIN_FRAME, TimeState } from "./time.js";
+export type { TimeVariables } from "./time.js";
+export type { ExpressionScope, Node as ExpressionNode } from "./scope.js";
+export type { CompiledExpression, ExpressionContext, ExpressionResult, PathWarning } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/expressions/index.js

@@ -0,0 +1,12 @@
+/**
+ * Parameter expressions, neutral runtime.
+ *
+ * Compilation, `$` time variables, math utilities and the host scope binding.
+ * Depends on nothing outside this folder, so both Studio and a headless host
+ * evaluate parameters with the same engine.
+ */
+export { ExpressionEvaluator } from "./evaluator.js";
+export { clamp, fit, fit01, lerp, noise, padzero, random, smooth } from "./math.js";
+export { TIME_IDENTIFIERS, TIME_TOKENS, hasTimeReference, preprocessExpression } from "./preprocess.js";
+export { DEFAULT_FPS, MIN_FRAME, TimeState } from "./time.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,75 @@
+/**
+ * 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 declare function fit(value: number, oldMin: number, oldMax: number, newMin: number, newMax: number): number;
+/** Remap a 0..1 value into a new range. */
+export declare function fit01(value: number, newMin: number, newMax: number): number;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function lerp(a: number, b: number, t: number): number;
+/** Smooth hermite interpolation (smoothstep). */
+export declare function smooth(value: number, min: number, max: number): number;
+/**
+ * Perlin-like noise in -1..1. Not true Perlin — a deterministic sum of sines.
+ */
+export declare function noise(...coords: number[]): number;
+/** Deterministic random in 0..1 from a seed. */
+export declare function random(seed: number): number;
+/** Zero-pad a number to a given number of digits. */
+export declare function padzero(digits: number, value: number): string;
+/** Degrees to radians. */
+export declare function radians(degrees: number): number;
+/** Radians to degrees. */
+export declare function degrees(radians: number): number;
+/** Sine of an angle in degrees — Houdini's `sin()`. */
+export declare function sind(degrees: number): number;
+/** Cosine of an angle in degrees — Houdini's `cos()`. */
+export declare function cosd(degrees: number): number;
+/** Tangent of an angle in degrees — Houdini's `tan()`. */
+export declare function tand(degrees: number): number;
+/**
+ * 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 declare const MATH_SCOPE: {
+    readonly sin: (x: number) => number;
+    readonly cos: (x: number) => number;
+    readonly tan: (x: number) => number;
+    readonly asin: (x: number) => number;
+    readonly acos: (x: number) => number;
+    readonly atan: (x: number) => number;
+    readonly atan2: (y: number, x: number) => number;
+    readonly sinh: (x: number) => number;
+    readonly cosh: (x: number) => number;
+    readonly tanh: (x: number) => number;
+    readonly sind: typeof sind;
+    readonly cosd: typeof cosd;
+    readonly tand: typeof tand;
+    readonly radians: typeof radians;
+    readonly degrees: typeof degrees;
+    readonly sqrt: (x: number) => number;
+    readonly cbrt: (x: number) => number;
+    readonly pow: (x: number, y: number) => number;
+    readonly exp: (x: number) => number;
+    readonly log: (x: number) => number;
+    readonly log2: (x: number) => number;
+    readonly log10: (x: number) => number;
+    readonly hypot: (...values: number[]) => number;
+    readonly abs: (x: number) => number;
+    readonly sign: (x: number) => number;
+    readonly floor: (x: number) => number;
+    readonly ceil: (x: number) => number;
+    readonly round: (x: number) => number;
+    readonly trunc: (x: number) => number;
+    readonly min: (...values: number[]) => number;
+    readonly max: (...values: number[]) => number;
+    readonly PI: number;
+    readonly TAU: number;
+    readonly E: number;
+};
+//# sourceMappingURL=math.d.ts.map

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