@motionscript/plot 0.0.0-stage → 0.1.0-alpha.3

package/dist/graph2d/shared.js

@@ -0,0 +1,70 @@
+/**
+ * The mappers and tweens the {@link Graph2D} node is built from — the same shape
+ * `graph3d/impl/shared.ts` has, and mostly the same short list, because a
+ * `@property` is only as good as the `mapper`/`tween` it is declared with.
+ *
+ * Almost everything here is a re-export. That is the point: the match-by-id
+ * equation tween lives in `nodes/graph-kit` because both graphs animate a list of
+ * equations the same way, and colour normalisation lives in `nodes/view3d-kit`
+ * because the 3D nodes needed it first. What is genuinely this node's own is one
+ * function: turning a two-argument compiled expression into the one-argument
+ * curve the sampler asks for, without losing the identity the tween compares.
+ */
+import { CURVE_VARIABLES, compileExpressionCached, lerpGraphEquations, } from "../kit/index.js";
+/**
+ * Colour normalisation and its tween, plus the two number tweens that fix what a
+ * plain lerp gets wrong.
+ *
+ * They live in `view3d-kit` because the 3D nodes needed them first, and there is
+ * nothing three-dimensional about any of them — a `NormalizedColor` is an RGBA
+ * tuple, which is both interpolatable and still a valid `Color` to hand back to
+ * `Graphics`. Renamed on the way through so the call sites don't read as though
+ * this node draws in perspective.
+ */
+export { resolveColor3D as resolveColor, lerpColor3D as lerpColor, lerpCount, snapFlag, snapValue, } from "@motionscript/sdk/component";
+/**
+ * Compiles `source` as `y = f(x)`, memoised, returning `null` for anything that
+ * doesn't parse.
+ *
+ * Two caches deep and both earn their place. The inner one memoises the *parse*,
+ * which is what keeps a node that re-draws sixty times a second from re-reading
+ * its own expressions; this one memoises the **adapter**, and without it every
+ * write would produce a fresh closure over the same parse — which the equation
+ * tween reads as "this expression changed" and would blend a function into
+ * itself, at double the sampling cost, for no visible difference.
+ *
+ * The adapter exists because arity is fixed in the parser for the sake of the
+ * hot path (see `CompiledExpression`) while the sampler quite reasonably wants
+ * to call `f(x)`. The unused second argument is 0 and unreachable: a curve is
+ * compiled with `x` as its only variable, so nothing in the tree reads it.
+ */
+const curves = new Map();
+export function compileCurveCached(source) {
+    const trimmed = source.trim();
+    if (trimmed === "")
+        return null;
+    const hit = curves.get(trimmed);
+    if (hit !== undefined)
+        return hit;
+    const compiled = compileExpressionCached(trimmed, CURVE_VARIABLES);
+    const curve = compiled === null ? null : (x) => compiled(x, 0);
+    curves.set(trimmed, curve);
+    return curve;
+}
+/**
+ * Tween for the curve list — the shared match-by-id walk, with the one thing a
+ * curve does differently: mid-morph its height is sampled from both functions
+ * and blended, so it deforms into the new one rather than cross-fading through
+ * a frame where both are drawn.
+ */
+export function lerpCurves(from, to, t) {
+    return lerpGraphEquations(from, to, t, blendCurve);
+}
+/** How two curves blend mid-tween. */
+function blendCurve(a, b, t) {
+    return (x) => {
+        const start = a(x);
+        return start + (b(x) - start) * t;
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/graph2d/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../src/graph2d/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,kBAAkB,GAEnB,MAAM,QAAQ,CAAA;AAGf;;;;;;;;;GASG;AACH,OAAO,EACL,cAAc,IAAI,YAAY,EAC9B,WAAW,IAAI,SAAS,EACxB,SAAS,EACT,QAAQ,EACR,SAAS,GACV,MAAM,6BAA6B,CAAA;AASpC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,GAAG,IAAI,GAAG,EAAgC,CAAA;AAEtD,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,EAAE,CAAA;IAC7B,IAAI,OAAO,KAAK,EAAE;QAAE,OAAO,IAAI,CAAA;IAE/B,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAC/B,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,GAAG,CAAA;IAEjC,MAAM,QAAQ,GAAG,uBAAuB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;IAClE,MAAM,KAAK,GACT,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IAC1D,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IAC1B,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CACxB,IAAqB,EACrB,EAAmB,EACnB,CAAS;IAET,OAAO,kBAAkB,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,UAAU,CAAC,CAAA;AACpD,CAAC;AAED,sCAAsC;AACtC,SAAS,UAAU,CACjB,CAAgB,EAChB,CAAgB,EAChB,CAAS;IAET,OAAO,CAAC,CAAC,EAAE,EAAE;QACX,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;QAClB,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;IACnC,CAAC,CAAA;AACH,CAAC","sourcesContent":["/**\n * The mappers and tweens the {@link Graph2D} node is built from — the same shape\n * `graph3d/impl/shared.ts` has, and mostly the same short list, because a\n * `@property` is only as good as the `mapper`/`tween` it is declared with.\n *\n * Almost everything here is a re-export. That is the point: the match-by-id\n * equation tween lives in `nodes/graph-kit` because both graphs animate a list of\n * equations the same way, and colour normalisation lives in `nodes/view3d-kit`\n * because the 3D nodes needed it first. What is genuinely this node's own is one\n * function: turning a two-argument compiled expression into the one-argument\n * curve the sampler asks for, without losing the identity the tween compares.\n */\n\nimport {\n  CURVE_VARIABLES,\n  compileExpressionCached,\n  lerpGraphEquations,\n  type GraphEquationResolved,\n} from \"../kit\"\nimport type { CurveFunction } from \"./curve\"\n\n/**\n * Colour normalisation and its tween, plus the two number tweens that fix what a\n * plain lerp gets wrong.\n *\n * They live in `view3d-kit` because the 3D nodes needed them first, and there is\n * nothing three-dimensional about any of them — a `NormalizedColor` is an RGBA\n * tuple, which is both interpolatable and still a valid `Color` to hand back to\n * `Graphics`. Renamed on the way through so the call sites don't read as though\n * this node draws in perspective.\n */\nexport {\n  resolveColor3D as resolveColor,\n  lerpColor3D as lerpColor,\n  lerpCount,\n  snapFlag,\n  snapValue,\n} from \"@motionscript/sdk/component\"\n\n/**\n * One curve after {@link Graph2D}'s mapper has run: compiled, resolved and fully\n * defaulted, so the per-frame draw never re-derives anything and the tween never\n * tests for an absent field.\n */\nexport type CurveResolved = GraphEquationResolved<CurveFunction>\n\n/**\n * Compiles `source` as `y = f(x)`, memoised, returning `null` for anything that\n * doesn't parse.\n *\n * Two caches deep and both earn their place. The inner one memoises the *parse*,\n * which is what keeps a node that re-draws sixty times a second from re-reading\n * its own expressions; this one memoises the **adapter**, and without it every\n * write would produce a fresh closure over the same parse — which the equation\n * tween reads as \"this expression changed\" and would blend a function into\n * itself, at double the sampling cost, for no visible difference.\n *\n * The adapter exists because arity is fixed in the parser for the sake of the\n * hot path (see `CompiledExpression`) while the sampler quite reasonably wants\n * to call `f(x)`. The unused second argument is 0 and unreachable: a curve is\n * compiled with `x` as its only variable, so nothing in the tree reads it.\n */\nconst curves = new Map<string, CurveFunction | null>()\n\nexport function compileCurveCached(source: string): CurveFunction | null {\n  const trimmed = source.trim()\n  if (trimmed === \"\") return null\n\n  const hit = curves.get(trimmed)\n  if (hit !== undefined) return hit\n\n  const compiled = compileExpressionCached(trimmed, CURVE_VARIABLES)\n  const curve: CurveFunction | null =\n    compiled === null ? null : (x: number) => compiled(x, 0)\n  curves.set(trimmed, curve)\n  return curve\n}\n\n/**\n * Tween for the curve list — the shared match-by-id walk, with the one thing a\n * curve does differently: mid-morph its height is sampled from both functions\n * and blended, so it deforms into the new one rather than cross-fading through\n * a frame where both are drawn.\n */\nexport function lerpCurves(\n  from: CurveResolved[],\n  to: CurveResolved[],\n  t: number\n): CurveResolved[] {\n  return lerpGraphEquations(from, to, t, blendCurve)\n}\n\n/** How two curves blend mid-tween. */\nfunction blendCurve(\n  a: CurveFunction,\n  b: CurveFunction,\n  t: number\n): CurveFunction {\n  return (x) => {\n    const start = a(x)\n    return start + (b(x) - start) * t\n  }\n}\n"]}

package/dist/graph3d/expression.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The `z = f(x, y)` expression language, as this node reaches for it.
+ *
+ * The parser itself now lives in `nodes/graph-kit/expression`, because the 2D
+ * graph writes its curves in the same language and neither node owns it — the
+ * same move `shared.ts` made when the Protein node needed the colour and camera
+ * helpers. What is left here is the *binding*: a surface's two free variables
+ * are `x` and `y`, which is the one thing about the grammar that differs between
+ * the two graphs, and every function below has it applied.
+ *
+ * Re-exported rather than re-implemented so this stays the one import a graph3d
+ * module reaches for, and so the vocabulary the inspector lists cannot drift
+ * from the names the parser will actually accept.
+ */
+import { type CompiledExpression } from "../kit/expression.js";
+export { EXPRESSION_VOCABULARY } from "../kit/expression.js";
+export type { CompiledExpression, ExpressionVocabulary, } from "../kit/expression.js";
+/** Compiles `source` as `z = f(x, y)`. Throws on a syntax error. */
+export declare function compileExpression(source: string): CompiledExpression;
+/** Why `source` won't compile as `z = f(x, y)`, or `null` when it does. */
+export declare function expressionError(source: string): string | null;
+/**
+ * Compiles with memoisation, returning `null` for anything that doesn't parse.
+ *
+ * The memoisation is what makes the equation tween cheap — equal source compiles
+ * to the identical closure, so "did this equation change" is an `===` — and what
+ * `surfaceRevision` reduces to a number. See the shared module for the rest.
+ */
+export declare function compileExpressionCached(source: string): CompiledExpression | null;
+//# sourceMappingURL=expression.d.ts.map

package/dist/graph3d/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../src/graph3d/expression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAKL,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AACzD,YAAY,EACV,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,mBAAmB,CAAA;AAE1B,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAEpE;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,GACb,kBAAkB,GAAG,IAAI,CAE3B"}

package/dist/graph3d/expression.js

@@ -0,0 +1,35 @@
+/**
+ * The `z = f(x, y)` expression language, as this node reaches for it.
+ *
+ * The parser itself now lives in `nodes/graph-kit/expression`, because the 2D
+ * graph writes its curves in the same language and neither node owns it — the
+ * same move `shared.ts` made when the Protein node needed the colour and camera
+ * helpers. What is left here is the *binding*: a surface's two free variables
+ * are `x` and `y`, which is the one thing about the grammar that differs between
+ * the two graphs, and every function below has it applied.
+ *
+ * Re-exported rather than re-implemented so this stays the one import a graph3d
+ * module reaches for, and so the vocabulary the inspector lists cannot drift
+ * from the names the parser will actually accept.
+ */
+import { SURFACE_VARIABLES, compileExpression as compile, compileExpressionCached as compileCached, expressionError as errorOf, } from "../kit/expression.js";
+export { EXPRESSION_VOCABULARY } from "../kit/expression.js";
+/** Compiles `source` as `z = f(x, y)`. Throws on a syntax error. */
+export function compileExpression(source) {
+    return compile(source, SURFACE_VARIABLES);
+}
+/** Why `source` won't compile as `z = f(x, y)`, or `null` when it does. */
+export function expressionError(source) {
+    return errorOf(source, SURFACE_VARIABLES);
+}
+/**
+ * Compiles with memoisation, returning `null` for anything that doesn't parse.
+ *
+ * The memoisation is what makes the equation tween cheap — equal source compiles
+ * to the identical closure, so "did this equation change" is an `===` — and what
+ * `surfaceRevision` reduces to a number. See the shared module for the rest.
+ */
+export function compileExpressionCached(source) {
+    return compileCached(source, SURFACE_VARIABLES);
+}
+//# sourceMappingURL=expression.js.map

package/dist/graph3d/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.js","sourceRoot":"","sources":["../../src/graph3d/expression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,iBAAiB,EACjB,iBAAiB,IAAI,OAAO,EAC5B,uBAAuB,IAAI,aAAa,EACxC,eAAe,IAAI,OAAO,GAE3B,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAMzD,oEAAoE;AACpE,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,OAAO,OAAO,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAC3C,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,eAAe,CAAC,MAAc;IAC5C,OAAO,OAAO,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAC3C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,MAAc;IAEd,OAAO,aAAa,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AACjD,CAAC","sourcesContent":["/**\n * The `z = f(x, y)` expression language, as this node reaches for it.\n *\n * The parser itself now lives in `nodes/graph-kit/expression`, because the 2D\n * graph writes its curves in the same language and neither node owns it — the\n * same move `shared.ts` made when the Protein node needed the colour and camera\n * helpers. What is left here is the *binding*: a surface's two free variables\n * are `x` and `y`, which is the one thing about the grammar that differs between\n * the two graphs, and every function below has it applied.\n *\n * Re-exported rather than re-implemented so this stays the one import a graph3d\n * module reaches for, and so the vocabulary the inspector lists cannot drift\n * from the names the parser will actually accept.\n */\n\nimport {\n  SURFACE_VARIABLES,\n  compileExpression as compile,\n  compileExpressionCached as compileCached,\n  expressionError as errorOf,\n  type CompiledExpression,\n} from \"../kit/expression\"\n\nexport { EXPRESSION_VOCABULARY } from \"../kit/expression\"\nexport type {\n  CompiledExpression,\n  ExpressionVocabulary,\n} from \"../kit/expression\"\n\n/** Compiles `source` as `z = f(x, y)`. Throws on a syntax error. */\nexport function compileExpression(source: string): CompiledExpression {\n  return compile(source, SURFACE_VARIABLES)\n}\n\n/** Why `source` won't compile as `z = f(x, y)`, or `null` when it does. */\nexport function expressionError(source: string): string | null {\n  return errorOf(source, SURFACE_VARIABLES)\n}\n\n/**\n * Compiles with memoisation, returning `null` for anything that doesn't parse.\n *\n * The memoisation is what makes the equation tween cheap — equal source compiles\n * to the identical closure, so \"did this equation change\" is an `===` — and what\n * `surfaceRevision` reduces to a number. See the shared module for the rest.\n */\nexport function compileExpressionCached(\n  source: string\n): CompiledExpression | null {\n  return compileCached(source, SURFACE_VARIABLES)\n}\n"]}

package/dist/graph3d/graph3d.d.ts

@@ -0,0 +1,186 @@
+import { type Command, type CommandArgs, Canvas3D, Scene3D, type Color, type NodeConfig, type Canvas3DProps } from "@motionscript/sdk";
+import { type OrbitTarget } from "@motionscript/sdk/component";
+/** One plotted surface, `z = f(x, y)`. */
+export interface Graph3DEquation {
+    /** Identity across list changes — see {@link Graph3D.equations}. */
+    id: string | number;
+    /** The expression, evaluated as `z = f(x, y)` (e.g. `sin(x) + cos(y)`). */
+    expression: string;
+    /** The mesh's colour: any {@link Color} — a CSS string or an RGBA tuple. */
+    color: Color;
+    /** Whether the surface is drawn. Defaults to true. */
+    visible?: boolean;
+    /**
+     * How solid the mesh is, 0–1. Defaults to 1.
+     *
+     * Anything below 1 makes the surface blend rather than write depth, so
+     * overlapping surfaces layer instead of occluding each other. Left at 1 the
+     * surface is genuinely opaque and reads crisp — which is why that is the
+     * default, and why fading one in or out still looks right on the way through.
+     */
+    opacity?: number;
+}
+/**
+ * Where the camera may go.
+ *
+ * Deliberately *not* OrbitControls. Those drive a camera from live mouse input,
+ * and a rendered timeline has no pointer — worse, their damping is an
+ * accumulator, so a scrubbed frame would differ from a played one and export
+ * would stop being deterministic. What is honoured here is the framing
+ * ({@link initialPosition}) and the limits; to *move* the camera, animate
+ * {@link Graph3DProps.orbit} / {@link Graph3DProps.elevation} /
+ * {@link Graph3DProps.zoom} from the timeline, which stays seekable.
+ */
+export interface Graph3DCamera {
+    /** Initial camera position, which seeds the three spherical props. */
+    initialPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Closest the camera may come to the origin. */
+    minZoom?: number;
+    /** Furthest it may pull back. */
+    maxZoom?: number;
+}
+/** The helper grid and the axes drawn under the surfaces. */
+export interface Graph3DGrid {
+    /** Whether to draw the ground grid at all. Defaults to true. */
+    showGrid?: boolean;
+    /** Total width and depth of the grid. Defaults to 20. */
+    size?: number;
+    /** How many cells across. Defaults to 20. */
+    divisions?: number;
+    /** Colour of the two lines through the origin. */
+    colorCenterLine?: Color;
+    /** Colour of every other grid line. */
+    colorGrid?: Color;
+    /** Whether to draw the X/Y/Z axes. Defaults to true. */
+    showAxes?: boolean;
+    /** How far each axis reaches from the origin. Defaults to 10. */
+    axesSize?: number;
+}
+export interface Graph3DProps extends Canvas3DProps {
+    /** The surfaces to plot, each evaluated as `z = f(x, y)` over the domain. */
+    equations: Graph3DEquation[];
+    camera: Graph3DCamera;
+    grid: Graph3DGrid;
+    /** Half-width of the plotted domain: x and y run `-domain … +domain`. Default 10. */
+    domain: number;
+    /**
+     * Surface resolution per axis. Default 80, i.e. ~6.4k vertices per equation.
+     * Lower it when plotting several surfaces at once.
+     */
+    segments: number;
+    /**
+     * Clamp on `|z|`. Default 20. Without it a function with an asymptote (`1/x`,
+     * `tan`) produces near-infinite vertices that stretch the mesh across the
+     * whole scene and wreck the framing.
+     */
+    maxHeight: number;
+    /** Camera orbit about the vertical axis, in **degrees**. Animate this to spin. */
+    orbit: number;
+    /** Camera elevation above the ground plane, in **degrees**. */
+    elevation: number;
+    /** Camera distance from the origin, clamped by the camera's zoom limits. */
+    zoom: number;
+    /** The 3D scene's background. */
+    background: Color;
+    /** Skips the background entirely, letting the 2D scene behind show through. */
+    transparentBackground: boolean;
+}
+/**
+ * A 3D function grapher — any number of `z = f(x, y)` surfaces over a helper
+ * grid, with axes.
+ *
+ * Extends {@link Canvas3D} rather than `Node3D`: a grapher is a *viewport* on a
+ * scene it owns entirely, not a thing placed inside somebody else's. `Canvas3D`
+ * owns the bridge from the 2D scene graph into the 3D renderer, so subclassing
+ * it means this class only has to describe *what* to draw. It overrides
+ * `buildScene3D`, the single seam both the real render and the asset
+ * declaration pass go through.
+ *
+ *   <Graph3D
+ *     width="fill" height="fill"
+ *     equations={[{ id: 1, expression: "sin(sqrt(x^2 + y^2))", color: "#3B82F6" }]}
+ *   />
+ *
+ * Every prop is a `@property`, so a constant, a `() => signal()` binding, and
+ * `set()`/`to()` on a ref all work and agree. The non-scalar props each declare
+ * a `mapper` (loose authored shape → one canonical internal shape) and a `tween`
+ * (how that shape interpolates) — without the tween, `to({ grid: … })` would
+ * hold the old value and snap at the end, which is the standard trap for an
+ * object-valued attribute.
+ *
+ * **There is no OrbitControls and no pointer.** The camera is driven by the
+ * node's own `orbit`/`elevation`/`zoom` props, which is what keeps every frame
+ * reproducible under scrubbing and export — see {@link Graph3DCamera}.
+ */
+export declare class Graph3D extends Canvas3D<Graph3DProps> {
+    /**
+     * The plotted surfaces.
+     *
+     * The mapper compiles each expression **once per write** (memoised by source),
+     * so the builder — which re-runs every frame — never re-parses; and it folds
+     * `visible`/`opacity` into a single number, so hiding is expressible as a
+     * fade. An expression that doesn't parse is dropped and the rest still draw,
+     * which is what lets the inspector commit on every keystroke.
+     *
+     * The tween matches the two lists by `id` — see `lerpEquations`.
+     */
+    equations: Graph3DEquation[];
+    /** The camera limits, and the framing that seeds the three spherical props. */
+    camera: Graph3DCamera;
+    /** The helper grid and axes. Flags snap at the end of a tween; the rest lerp. */
+    grid: Graph3DGrid;
+    domain: number;
+    /**
+     * Surface resolution. Tweenable, but *structural*: a geometry is immutable, so
+     * every intermediate value reallocates each surface's buffers. Set it once
+     * unless the resolution change is itself the point.
+     */
+    segments: number;
+    maxHeight: number;
+    background: Color;
+    transparentBackground: boolean;
+    orbit: number;
+    elevation: number;
+    zoom: number;
+    constructor(props?: NodeConfig<Graph3D, Graph3DProps>);
+    /**
+     * Frame the scene at a spherical camera placement. Every axis is optional,
+     * so "pull back" and "spin round" stay separate intentions — see
+     * {@link OrbitTarget}.
+     */
+    orbitTo(args: CommandArgs<{
+        target: OrbitTarget;
+    }> & {
+        duration: number;
+    }): Command<Graph3DProps>;
+    /**
+     * Seeds `orbit`/`elevation`/`zoom` from `camera.initialPosition`, so a caller
+     * who gives a raw position gets that framing and one who gives none gets
+     * {@link DEFAULT_POSITION} — without having to restate the other two axes.
+     *
+     * Bound reactively rather than copied, so the default *tracks* the camera and
+     * a camera signal keeps working. Writing any of the three (a `set`, or the
+     * first frame of a `to`) replaces the binding with the explicit value, which
+     * is exactly the handover wanted.
+     */
+    private applyCameraDefaults;
+    protected buildScene3D(): Scene3D;
+    /**
+     * One `z = f(x, y)` surface, keyed by equation id rather than by position in
+     * the op list — see {@link Graph3D.equations}.
+     */
+    private addSurface;
+    /**
+     * The ground grid, as two line ops — the centre cross and everything else —
+     * because a line op carries a single colour and the centre lines are drawn
+     * differently from the rest.
+     */
+    private addGrid;
+    /** X/Y/Z axes in red/green/blue, the conventional colouring. */
+    private addAxes;
+}
+//# sourceMappingURL=graph3d.d.ts.map

package/dist/graph3d/graph3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph3d.d.ts","sourceRoot":"","sources":["../../src/graph3d/graph3d.ts"],"names":[],"mappings":"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"}