@oeave/bakery3 0.0.0-stage → 0.2.0

package/dist/timeline-ChwgD7bT.d.ts

@@ -0,0 +1,470 @@
+import { Camera, Scene, Object3D } from 'three';
+import { A as AnimationSpec } from './animation-B1h0Ryvj.js';
+
+/**
+ * Easing, in one implementation.
+ *
+ * The named easings are the CSS cubic-bezier control points, not hand-rolled
+ * polynomials, so `'ease-in-out'` here means what it means in every stylesheet
+ * and in gsap: a motion tuned in CSS comes back from the render as the same
+ * curve.
+ *
+ * This is also the only place easing exists. The renderer never sees a curve:
+ * the SDK samples the timeline at every output frame and ships the numbers,
+ * which is what keeps the browser preview and the rendered frame agreeing on
+ * where things are.
+ */
+/** A CSS easing: one of the four names, or the four control points of a
+ *  cubic-bezier, `[x1, y1, x2, y2]`, exactly as a stylesheet writes them. */
+type Easing = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | [number, number, number, number];
+
+/**
+ * Orbits, and the lookAt → quaternion conversion the wire format needs.
+ *
+ * A camera move between two points has two honest answers and they look
+ * nothing alike. Lerping the positions drives the camera through the middle
+ * of the product; interpolating in spherical coordinates around the thing
+ * being looked at swings around it at a constant distance. The second one is
+ * what everybody means by "orbit the camera 90°", so it is a first-class path
+ * type rather than something you have to build out of forty keyframes.
+ *
+ * Angles here are in radians and are not wrapped. An orbit of +370° is a full
+ * turn plus ten degrees, not minus ten: wrapping it into ±180° would silently
+ * reverse a turntable.
+ */
+type Vec3 = [number, number, number];
+/** glTF order (x, y, z, w), matching the protocol's `Quat` and three's own
+ *  `Quaternion.toArray()`. Nothing on this side of the wire reorders. */
+type Quat = [number, number, number, number];
+
+/**
+ * What can be animated, how to read it off the live object, and how to put it
+ * back.
+ *
+ * One table, because three consumers must agree exactly: the panel (which
+ * offers a list), `seek()` (which drives the live three scene, so the browser
+ * is the preview) and `bake()` (which writes the numbers the renderer plays).
+ * A property that reads differently from how it writes is a preview that lies
+ * about the render.
+ *
+ * Everything is duck-typed rather than `instanceof Mesh`. three is a peer
+ * dependency with no runtime import here, and duck typing is what three does
+ * internally anyway, so this keeps working across a version that adds a type.
+ */
+
+/** Values are always arrays, scalars included. One interpolation path, one
+ *  storage shape, and `size` is then simply `value.length`. */
+type PropertyValue = number[];
+
+/**
+ * A timeline you author in keyframes and ship as frames.
+ *
+ *     const tl = createTimeline({ duration: 5, fps: 30, camera, scene });
+ *
+ *     tl.push({ object: 'camera', orbitY: 90 });
+ *     tl.to(mesh, { color: '#ff2d95' }, { at: 1, duration: 2, easing: 'ease-in-out' });
+ *
+ *     tl.seek(2.5);            // the live scene is the preview
+ *     await bakery3.renderVideo({ timeline: tl });
+ *
+ * It looks like gsap and differs from it in two ways, because a shot has a
+ * known length rather than being a queue of tweens:
+ *
+ *   - `at` defaults to 0 and `duration` to the rest of the timeline, so
+ *     `tl.push({ object: 'camera', orbitY: 15 })` on a five-second timeline is
+ *     a five-second move. Nothing appends itself to the end.
+ *   - `seek()` drives your actual three objects. There is no shadow copy of
+ *     the scene, so what you scrub to is what gets rendered.
+ *
+ * Everything that interpolates lives here, in easing.ts and in orbit.ts. The
+ * renderer sees none of it: `bake()` samples this evaluator at every output
+ * frame and ships the numbers.
+ */
+
+/** `'camera'` rather than the camera object, because a live R3F camera is
+ *  frequently swapped out from under the application and an id that survives
+ *  that is worth more than a reference that does not. */
+type TrackTarget = 'camera' | Object3D;
+/** One value, at one time, on one track. Times are seconds from the start of
+ *  the timeline, never relative to the keyframe before, so retiming one
+ *  keyframe cannot cascade through the rest of the lane. */
+type Keyframe = {
+    time: number;
+    value: PropertyValue;
+    /** Governs the segment ending here: the ease passed to the `.to()` that
+     *  created this keyframe. */
+    easing?: Easing;
+    path?: 'line' | 'orbit';
+    /**
+     * Where an orbit segment ends, in spherical coordinates about `center`.
+     *
+     * Carried alongside the position rather than instead of it, so a consumer
+     * that does not understand orbits (the panel's diamonds, a JSON reader)
+     * still sees the right endpoint. `yaw` is unwrapped: +370° means a full turn
+     * plus ten degrees.
+     */
+    orbit?: {
+        center: Vec3;
+        radius: number;
+        yaw: number;
+        pitch: number;
+    };
+};
+/** One property of one target, over time: a lane in the panel and a channel
+ *  in the bake. One track per (target, property) pair, always: two lanes
+ *  driving one property would fight over the live object on every `seek()`. */
+type Track = {
+    id: string;
+    target: TrackTarget;
+    property: string;
+    size: number;
+    /** What the panel shows. Falls back to the object's name or type. */
+    label: string;
+    keyframes: Keyframe[];
+};
+/**
+ * What a panel can listen for.
+ *
+ * `time` fires on every `seek()`, sixty times a second while playing, so a
+ * listener must be cheap. `change` is structural (a keyframe, the duration,
+ * the fps) and also fires the `time` listeners, because every readout that
+ * watches the playhead also wants to know the lanes moved underneath it.
+ */
+type TimelineEvent = 'change' | 'time' | 'play' | 'pause';
+/** Everything a timeline needs to know before anything is authored on it.
+ *  All optional: a timeline with no scene and no camera is still a valid
+ *  document, which is what makes one testable without a renderer. */
+type TimelineOptions = {
+    /** Seconds. Default 5. */
+    duration?: number;
+    /** Frames per second the bake samples at. Default 30. */
+    fps?: number;
+    camera?: Camera;
+    scene?: Scene;
+    /**
+     * What camera orbits turn around and lookAt tracks default to. Defaults to
+     * the center of the scene's bounding box, which is what "orbit the product"
+     * usually means.
+     */
+    lookAt?: Vec3;
+    loop?: boolean;
+    /** The host's orbit-controls target, when it has one. Read on keyframe
+     *  capture so the After Effects flow (frame it with the mouse, press the
+     *  button) records the point you were actually orbiting. */
+    controlsTarget?: () => Vec3;
+};
+/** Where a `.to()`, `.fromTo()` or `.orbit()` sits on the timeline. */
+type SegmentOptions = {
+    /** Seconds from the start of the timeline. Default 0. */
+    at?: number;
+    /** Seconds. Default: the rest of the timeline. */
+    duration?: number;
+    easing?: Easing;
+};
+/** A camera swing. Everything is relative to where the camera already is,
+ *  except `radius`: an orbit is a nudge from the pose you framed, not a jump
+ *  to coordinates you would have to work out first. */
+type OrbitOptions = SegmentOptions & {
+    /** Degrees about the up axis. Not wrapped: -540 is one and a half turns. */
+    yaw?: number;
+    /** Degrees of elevation change. */
+    pitch?: number;
+    /** Absolute end distance from the center. */
+    radius?: number;
+    /** Distance change, relative to where the camera starts. */
+    dolly?: number;
+    lookAt?: Vec3 | Object3D;
+};
+/** The one-call shorthand: `tl.push({ object: 'camera', orbitY: +15 })`. */
+type PushSpec = SegmentOptions & {
+    object: TrackTarget;
+    /** Degrees, horizontal. Positive swings the camera to its right. */
+    orbitY?: number;
+    /** Degrees, vertical. Positive lifts the camera. */
+    orbitX?: number;
+    /** Distance change, relative to where the camera starts. */
+    dolly?: number;
+    lookAt?: Vec3 | Object3D;
+} & Record<string, unknown>;
+/** Anything `.to()` accepts as a value: a number, a vector, a hex color, or
+ *  a three Vector3/Color/Euler read straight off the scene. */
+type AuthoredValue = number | number[] | string | {
+    x: number;
+    y: number;
+    z: number;
+} | {
+    r: number;
+    g: number;
+    b: number;
+};
+/** Keyframes in, frames out. The file header has the two places this differs
+ *  from gsap. */
+declare class Timeline {
+    private _duration;
+    private _fps;
+    private _time;
+    private _tracks;
+    private _playing;
+    private _raf;
+    private _lastTick;
+    private _listeners;
+    private _center;
+    private _nextId;
+    /** Playback only. A bake is always exactly one pass of the duration, so
+     *  looping in the panel never changes what a video contains. */
+    loop: boolean;
+    private _camera?;
+    private _scene?;
+    /** The host's orbit-controls target, when it has one. */
+    controlsTarget?: () => Vec3;
+    constructor(options?: TimelineOptions);
+    /**
+     * What `seek()` drives and `captureCameraKeyframe()` reads. Settable after
+     * construction because an R3F camera is frequently swapped out from under
+     * the application. A timeline from `bakery3.timeline()` that was given no
+     * camera reads the client's attached one each time it needs it.
+     */
+    get camera(): Camera | undefined;
+    set camera(camera: Camera | undefined);
+    /** Used to find the orbit center, and to check at bake time that every
+     *  animated object is actually in what gets exported. Read from the
+     *  client's attachment, like `camera`, when it was not given. */
+    get scene(): Scene | undefined;
+    set scene(scene: Scene | undefined);
+    get duration(): number;
+    /**
+     * Setting this moves the end, not the keyframes.
+     *
+     * Existing keyframes keep their absolute times, because the common reason to
+     * change the duration is "I need two more seconds at the end", and silently
+     * rescaling every ease you already tuned would be the opposite of that.
+     * `scaleToFit()` is the other intent, spelled out.
+     */
+    set duration(seconds: number);
+    get fps(): number;
+    set fps(value: number);
+    get time(): number;
+    get playing(): boolean;
+    get tracks(): readonly Track[];
+    /** Frames a bake at the current settings will produce. */
+    get frameCount(): number;
+    /** Proportionally rescale every keyframe into a new duration. */
+    scaleToFit(seconds: number): this;
+    /**
+     * The point orbits turn around.
+     *
+     * Resolved lazily so a timeline created before the model finished loading
+     * still centers on it. `createTimeline()` at mount is the normal case, and
+     * an empty scene's bounding box is the origin, which would be wrong for
+     * every model that is not at the origin.
+     */
+    get center(): Vec3;
+    set center(value: Vec3);
+    /**
+     * Tween to a value from wherever the target is at `at`.
+     *
+     * "Wherever it is at `at`" means the timeline's own value if something else
+     * already animates that property, and the live object's value if not, so
+     * chaining two `.to()` calls on one property does what it looks like.
+     */
+    to(target: TrackTarget, props: Record<string, AuthoredValue>, options?: SegmentOptions): this;
+    /** Both ends stated. Nothing is read off the live object. */
+    fromTo(target: TrackTarget, from: Record<string, AuthoredValue>, to: Record<string, AuthoredValue>, options?: SegmentOptions): this;
+    /**
+     * Swing the camera around what it is looking at.
+     *
+     * The lookAt point is pinned for the whole segment. That is the difference
+     * between an orbit and a camera drifting sideways past the product, and it
+     * is why this writes a `lookAt` track as well as a `position` one.
+     */
+    orbit(camera: TrackTarget, options?: OrbitOptions): this;
+    /**
+     * One-call shorthand:
+     *
+     *     tl.push({ object: 'camera', orbitY: +15 });
+     *
+     * The camera starts where it is now and ends fifteen degrees round its
+     * current lookAt, holding that lookAt, over the whole timeline. Any other
+     * key is treated as if it had been passed to `.to()`.
+     */
+    push(spec: PushSpec): this;
+    /**
+     * Save a property where it is right now.
+     *
+     * The After Effects flow: put the playhead somewhere, pose the scene, press
+     * the button. Both arguments default to exactly that: the playhead, and the
+     * live value.
+     */
+    keyframe(target: TrackTarget, property: string, time?: number, value?: AuthoredValue): Keyframe;
+    /**
+     * The camera, as the developer framed it.
+     *
+     * Position and the point it is aimed at, because a camera keyframe that
+     * records only position leaves the render free to aim it somewhere else.
+     * The aim comes from the host's orbit controls when there are any (that is
+     * the point you were dragging around), and is otherwise projected along the
+     * camera's own forward axis, never assumed to be the origin.
+     */
+    captureCameraKeyframe(time?: number, lookAt?: Vec3): void;
+    removeKeyframe(trackId: string, index: number): void;
+    /** Retime one keyframe, clamped into the timeline. A keyframe dragged past
+     *  the end would still be baked, at a frame nobody renders, so it is pinned
+     *  to the duration rather than allowed to leave the shot. */
+    moveKeyframe(trackId: string, index: number, time: number): void;
+    /** Re-curve the segment ending at this keyframe, the same convention `.to()`
+     *  writes, so the panel's dropdown and the authoring API mean the same thing
+     *  by "the ease on this diamond". */
+    setEasing(trackId: string, index: number, easing: Easing): void;
+    /** Drop a lane and everything on it. The live object keeps whatever value it
+     *  last had: removing a track stops driving a property, it does not restore
+     *  what the property was before the timeline touched it. */
+    removeTrack(trackId: string): void;
+    /**
+     * Re-attach tracks to the scene as it is now, and report what could not be.
+     *
+     * An application that rebuilds part of its graph (a configurator swapping a
+     * variant, R3F remounting a subtree) leaves tracks pointing at Object3Ds
+     * that are no longer in the scene, even though an object that is for every
+     * purpose "the same one" is standing right there. Rather than fail at
+     * export, look for that object: first by the identity you pinned
+     * (`userData.bakery3Id`, which is exactly what survives a rebuild), then by
+     * an unambiguous name match.
+     *
+     * Nothing is dropped silently. Every track that could not be healed is
+     * returned, so the caller can say what happened; that is the difference
+     * between repairing a timeline and quietly losing a motion you authored.
+     */
+    reconcile(scene: Object3D): {
+        healed: Array<{
+            trackId: string;
+            property: string;
+            label: string;
+        }>;
+        stale: Array<{
+            trackId: string;
+            property: string;
+            label: string;
+            reason: string;
+        }>;
+    };
+    /** Find or create a lane. Public because the panel's "add track" picker
+     *  needs to create one without also writing a keyframe. */
+    track(target: TrackTarget, property: string): Track;
+    /**
+     * Evaluate every track and drive the live scene.
+     *
+     * The same evaluator `bake()` samples, which is the whole design: what you
+     * scrub to and what the renderer traces cannot drift apart, because there is
+     * only one of them.
+     */
+    seek(time: number): this;
+    play(): this;
+    pause(): this;
+    /** Pause and rewind. */
+    stop(): this;
+    /** Stop the clock and forget every listener. The scene is left exactly where
+     *  the playhead left it: a timeline being torn down should not also move
+     *  your camera back. */
+    dispose(): void;
+    private tick;
+    /** The value of one track at a time, without touching the scene. Exposed
+     *  because the bake samples it. */
+    valueAt(track: Track, time: number): PropertyValue | undefined;
+    /** What the timeline says everything is at `time`, for a panel readout or a
+     *  test: the same numbers `seek()` applies. */
+    sample(time: number): Array<{
+        track: Track;
+        value: PropertyValue;
+    }>;
+    /** The camera pose at a time: position and the rotation the wire format
+     *  carries. Shared by `seek()` and `bake()` so the preview cannot aim
+     *  somewhere the render does not. */
+    cameraPoseAt(time: number): {
+        position: Vec3;
+        lookAt: Vec3;
+        quaternion: Quat;
+    } | undefined;
+    private apply;
+    /**
+     * Every track, sampled at every output frame. The wire format is flat
+     * samples, so the renderer needs no evaluator of its own.
+     */
+    bake(options?: {
+        scene?: Scene;
+        fps?: number;
+        duration?: number;
+    }): AnimationSpec;
+    /** The timeline as a storable document. See `TimelineJSON`, and `fromJSON`
+     *  for how stored ids find their live objects again. */
+    toJSON(): TimelineJSON;
+    /**
+     * Rebuild a timeline against a live scene.
+     *
+     * `resolve` maps a stored object id back to a live object. An id that does
+     * not resolve is refused rather than skipped: a track that silently
+     * disappears is a video missing a motion you authored, and you would find
+     * out by watching the finished render.
+     */
+    static fromJSON(json: TimelineJSON, context?: {
+        resolve?: (objectId: string) => Object3D | undefined;
+        camera?: Camera;
+        scene?: Scene;
+    }): Timeline;
+    /** Subscribe. Returns the unsubscribe, so a panel's teardown is one call and
+     *  a forgotten listener cannot keep a disposed scene alive. */
+    on(event: TimelineEvent, listener: (payload: never) => void): () => void;
+    private emit;
+    /** The live value of a property, read through the shared property table. */
+    live(target: TrackTarget, property: string): PropertyValue | undefined;
+    private find;
+    private normalizeTarget;
+    private span;
+    /** Make sure a segment has something to start from at `at`. */
+    private anchor;
+    private insert;
+    private requireCamera;
+    /**
+     * The camera, when one is needed. A client's timeline that has none by then
+     * refuses, because the move it was asked for would otherwise be authored
+     * from a made-up pose, or silently drive nothing. A standalone timeline
+     * with no camera is a document that can still be read and sampled.
+     */
+    private cameraOrThrow;
+}
+/**
+ * A timeline as a document.
+ *
+ * Targets travel as object ids rather than references, so this survives a page
+ * reload, a database column and a git diff. `version` is here so a stored
+ * timeline can be migrated rather than silently misread, the same reason the
+ * manifest carries `protocolVersion`.
+ */
+type TimelineJSON = {
+    version: 1;
+    duration: number;
+    fps: number;
+    center?: Vec3;
+    tracks: Array<{
+        target: {
+            type: 'camera';
+        } | {
+            type: 'object';
+            objectId: string;
+        };
+        property: string;
+        label?: string;
+        keyframes: Keyframe[];
+    }>;
+};
+/**
+ * A timeline, standing on its own.
+ *
+ * `bakery3.timeline()` is the same call with the attached scene and camera
+ * filled in, and is what an application should normally use. This one exists
+ * for the cases where there is no Bakery3 instance yet (a test, a timeline
+ * built at module scope and handed to the panel), because authoring a camera
+ * move should not need an API key.
+ */
+declare function createTimeline(options?: TimelineOptions): Timeline;
+
+export { type AuthoredValue as A, type Easing as E, type Keyframe as K, type OrbitOptions as O, type PushSpec as P, type SegmentOptions as S, Timeline as T, type TimelineOptions as a, type Track as b, createTimeline as c, type TrackTarget as d, type TimelineEvent as e, type TimelineJSON as f };

package/dist/tsl/index.d.ts

@@ -0,0 +1,165 @@
+import { float, vec3, vec4 } from 'three/tsl';
+
+/**
+ * @oeave/bakery3/tsl: the renderer's shading vocabulary, usable from TSL.
+ *
+ * Two things happen here, and importing this module is what turns both on:
+ *
+ * 1. Registration. TSL's anonymous singletons (`positionWorld`, `time`,
+ *    `cameraPosition`) carry no recognizable structure, so the extractor can
+ *    only know them by being introduced. This module imports them from
+ *    `three/tsl` and registers them by uuid. It is its own entry point
+ *    because it needs three r170 (one of the nodes it imports is not
+ *    exported before that); the core SDK keeps working for anyone older.
+ *
+ * 2. Renderer-only nodes. The renderer has procedural textures and shading
+ *    inputs a browser cannot compute: traced ambient occlusion, shade-time
+ *    bevel, pointiness, the classic noise textures. Each function below
+ *    returns a real TSL node that draws an approximation in the WebGPU
+ *    viewport and carries a marker the extractor serializes exactly for the
+ *    render. The viewport is the sketch; the render is the real one.
+ *    `check()` reports their use as info, never as an error.
+ *
+ * Everything accepts plain numbers for its dials, and a TSL expression for
+ * its coordinate input. Dials are baked into the manifest, so a dial driven
+ * by another node is not accepted, rather than accepted and ignored.
+ */
+
+type TSLExpr = ReturnType<typeof float>;
+type Coord = TSLExpr | null | undefined;
+/** A float node: a mask, a factor, a texture's fac output. */
+type FloatNode = ReturnType<typeof float>;
+/** A three-component node: a color or a normal. */
+type Vec3Node = ReturnType<typeof vec3>;
+/** A color with alpha. */
+type Vec4Node = ReturnType<typeof vec4>;
+type NoiseTextureOptions = {
+    scale?: number;
+    detail?: number;
+    roughness?: number;
+    lacunarity?: number;
+    distortion?: number;
+    dimensions?: 2 | 3 | 4;
+};
+/**
+ * The renderer's fractal noise texture. Preview: MaterialX fractal noise,
+ * the same character on a different lattice.
+ */
+declare function bakeryNoiseTexture(coord?: Coord, options?: NoiseTextureOptions): FloatNode;
+type VoronoiTextureOptions = {
+    scale?: number;
+    randomness?: number;
+    feature?: 'F1' | 'F2' | 'SMOOTH_F1' | 'DISTANCE_TO_EDGE';
+    metric?: 'EUCLIDEAN' | 'MANHATTAN' | 'CHEBYCHEV';
+    dimensions?: 2 | 3 | 4;
+};
+/** The renderer's Voronoi texture (distance output). Preview: MaterialX Worley. */
+declare function bakeryVoronoiTexture(coord?: Coord, options?: VoronoiTextureOptions): FloatNode;
+type WaveTextureOptions = {
+    scale?: number;
+    distortion?: number;
+    detail?: number;
+    detailScale?: number;
+    detailRoughness?: number;
+    phase?: number;
+    type?: 'BANDS' | 'RINGS';
+    direction?: 'X' | 'Y' | 'Z' | 'DIAGONAL';
+    profile?: 'SIN' | 'SAW' | 'TRI';
+};
+/** The renderer's wave texture. Preview: a sine along the chosen axis. */
+declare function bakeryWaveTexture(coord?: Coord, options?: WaveTextureOptions): FloatNode;
+type MagicTextureOptions = {
+    scale?: number;
+    distortion?: number;
+    depth?: number;
+};
+/** The renderer's interference "magic" texture. Preview: interfering sines,
+ *  the flavor and not the math. */
+declare function bakeryMagicTexture(coord?: Coord, options?: MagicTextureOptions): FloatNode;
+type GradientType = 'LINEAR' | 'QUADRATIC' | 'EASING' | 'DIAGONAL' | 'SPHERICAL' | 'QUADRATIC_SPHERE' | 'RADIAL';
+type GradientTextureOptions = {
+    type?: GradientType;
+};
+/** The renderer's gradient texture. Preview: the linear ramp. */
+declare function bakeryGradientTexture(coord?: Coord, options?: GradientTextureOptions): FloatNode;
+type BrickTextureOptions = {
+    offset?: number;
+    offsetFrequency?: number;
+    squash?: number;
+    squashFrequency?: number;
+    scale?: number;
+    mortarSize?: number;
+    mortarSmooth?: number;
+    bias?: number;
+    brickWidth?: number;
+    rowHeight?: number;
+};
+/** The renderer's brick texture (fac output, the mortar mask). Preview: a grid. */
+declare function bakeryBrickTexture(coord?: Coord, options?: BrickTextureOptions): FloatNode;
+/** White noise, a hash of the coordinate. Preview: cell noise. */
+declare function bakeryWhiteNoise(coord?: Coord, options?: {
+    dimensions?: 2 | 3 | 4;
+}): FloatNode;
+/**
+ * Traced ambient occlusion. The browser has no rays, so the preview is plain
+ * white, which is exactly what an unoccluded surface reads as. The render
+ * traces the real thing.
+ */
+declare function bakeryAmbientOcclusion(options?: {
+    distance?: number;
+    samples?: number;
+    onlyLocal?: boolean;
+}): FloatNode;
+/**
+ * Shade-time edge rounding. Preview: the unrounded normal, so geometry looks
+ * crisp in the viewport and gets the worn edge in the render.
+ */
+declare function bakeryBevel(options?: {
+    radius?: number;
+    samples?: number;
+}): Vec3Node;
+/** Surface curvature: concave 0, flat 0.5, convex 1. Preview: flat 0.5. */
+declare function bakeryPointiness(): FloatNode;
+/** 1 on triangle edges. Preview: 0, no wires in the viewport. */
+declare function bakeryWireframe(options?: {
+    size?: number;
+    pixelSize?: boolean;
+}): FloatNode;
+/** Physically correct fresnel. Preview: Schlick's approximation, close enough
+ *  that the viewport and the render agree on where the rim light lives. */
+declare function bakeryFresnel(ior?: number): FloatNode;
+/** A facing/fresnel layer weight. Preview: the facing term it is built from. */
+declare function bakeryLayerWeight(blend?: number, options?: {
+    output?: 'FRESNEL' | 'FACING';
+}): FloatNode;
+type ColorRampStop = {
+    position: number;
+    color: [number, number, number] | [number, number, number, number];
+};
+/**
+ * A color ramp. Preview: the same ramp, rebuilt from mix chains; for LINEAR
+ * and CONSTANT interpolation the viewport matches the render.
+ */
+declare function bakeryColorRamp(fac: TSLExpr, stops: ColorRampStop[], options?: {
+    interpolation?: 'LINEAR' | 'CONSTANT';
+}): Vec4Node;
+/** Blackbody temperature to color. Preview: a two-anchor tint, warm below
+ *  and cool above. */
+declare function bakeryBlackbody(kelvin?: number): Vec3Node;
+/** A gamma curve. The preview is the same math. */
+declare function bakeryGamma(color: TSLExpr, gamma?: number): Vec3Node;
+/** Brightness/contrast. Preview: the same formula the render uses. */
+declare function bakeryBrightnessContrast(color: TSLExpr, options?: {
+    brightness?: number;
+    contrast?: number;
+}): Vec3Node;
+/** Hue/saturation/value. Preview: value and saturation only; a hue rotation
+ *  in the viewport is not worth a hand-rolled HSV conversion. */
+declare function bakeryHueSaturation(color: TSLExpr, options?: {
+    hue?: number;
+    saturation?: number;
+    value?: number;
+    fac?: number;
+}): Vec3Node;
+
+export { type BrickTextureOptions, type ColorRampStop, type GradientTextureOptions, type GradientType, type MagicTextureOptions, type NoiseTextureOptions, type VoronoiTextureOptions, type WaveTextureOptions, bakeryAmbientOcclusion, bakeryBevel, bakeryBlackbody, bakeryBrickTexture, bakeryBrightnessContrast, bakeryColorRamp, bakeryFresnel, bakeryGamma, bakeryGradientTexture, bakeryHueSaturation, bakeryLayerWeight, bakeryMagicTexture, bakeryNoiseTexture, bakeryPointiness, bakeryVoronoiTexture, bakeryWaveTexture, bakeryWhiteNoise, bakeryWireframe };