@3driseai/3drise-viewer 0.1.27 → 0.1.29

package/dist/triggers/kinds/effects.js

@@ -0,0 +1,27 @@
+// Triggerables: a single effect (an operation on its targets) and a saved effect clip.
+// They run through the operations runtime exactly as before the engine.
+import { getOperation } from '../../operations/registry.js';
+import { isEffectClipOn, isEffectOn, runEffect, runEffectClip } from '../../operations/runtime.js';
+import { defineTriggerable } from '../registry.js';
+const ids = (targets) => (targets ?? []).filter(t => t && t !== 'self');
+defineTriggerable({
+    kind: 'effect',
+    commands: ['trigger', 'apply', 'revert', 'toggle'],
+    timeline: 'state',
+    targets: (c) => ids(c.effect?.targets),
+    subject: (c) => c.effect?.operation ?? '',
+    // only operations that can be undone are "on" (a spin just plays)
+    claimKey: (c) => (c.effect?.id && getOperation(c.effect.operation)?.revert ? `effect:${c.effect.id}` : null),
+    isOn: (c, ctx) => isEffectOn(c.effect, ctx.self),
+    run: (c, ctx) => runEffect(c.effect, c.command, ctx.self),
+});
+defineTriggerable({
+    kind: 'effectClip',
+    commands: ['apply', 'revert', 'toggle'],
+    timeline: 'state',
+    targets: (c) => ids(c.use?.targets),
+    subject: (c) => c.use?.clip ?? '',
+    claimKey: (c) => (c.use?.id ? `effectClip:${c.use.id}` : null),
+    isOn: (c, ctx) => isEffectClipOn(c.use, ctx.self),
+    run: (c, ctx) => { runEffectClip(c.use, c.command, ctx.self); },
+});

package/dist/triggers/kinds/index.d.ts

@@ -0,0 +1,4 @@
+import './effects';
+import './action';
+import './animations';
+//# sourceMappingURL=index.d.ts.map

package/dist/triggers/kinds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/index.ts"],"names":[],"mappings":"AACA,OAAO,WAAW,CAAC;AACnB,OAAO,UAAU,CAAC;AAClB,OAAO,cAAc,CAAC"}

package/dist/triggers/kinds/index.js

@@ -0,0 +1,4 @@
+// Every built-in triggerable kind. Importing this registers them.
+import './effects.js';
+import './action.js';
+import './animations.js';

package/dist/triggers/log.d.ts

@@ -0,0 +1,21 @@
+import type { SceneCommandKind, TriggerSource } from '@3driseai/3drise-core';
+export type TriggerLogType = 'run' | 'queued' | 'waiting' | 'timeout' | 'claim' | 'release' | 'clash' | 'cycle' | 'refused' | 'unknown';
+export interface TriggerLogEntry {
+    t: number;
+    type: TriggerLogType;
+    kind?: SceneCommandKind | string;
+    /** What it acted on (an action / clip / sequence id, an effect operation…). */
+    subject?: string;
+    source: TriggerSource;
+    /** The sources above it, outermost first. */
+    chain: TriggerSource[];
+    detail?: string;
+}
+export declare const describeSource: (s: TriggerSource) => string;
+export declare function logTrigger(e: Omit<TriggerLogEntry, 't'>): void;
+/** The recent entries (oldest first), optionally of some types. */
+export declare function getTriggerLog(types?: TriggerLogType[]): TriggerLogEntry[];
+export declare function clearTriggerLog(): void;
+/** Subscribe to new entries. Returns the unsubscribe. */
+export declare function onTriggerLog(listener: (e: TriggerLogEntry) => void): () => void;
+//# sourceMappingURL=log.d.ts.map

package/dist/triggers/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/triggers/log.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE7E,MAAM,MAAM,cAAc,GACpB,KAAK,GACL,QAAQ,GACR,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,OAAO,GACP,OAAO,GACP,SAAS,GACT,SAAS,CAAC;AAEhB,MAAM,WAAW,eAAe;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IACjC,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;IACtB,6CAA6C;IAC7C,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAOD,eAAO,MAAM,cAAc,GAAI,GAAG,aAAa,WAAwB,CAAC;AAQxE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,CAAC,GAAG,IAAI,CAU9D;AAED,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,cAAc,EAAE,GAAG,eAAe,EAAE,CAEzE;AAED,wBAAgB,eAAe,IAAI,IAAI,CAAwB;AAE/D,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,IAAI,GAAG,MAAM,IAAI,CAG/E"}

package/dist/triggers/log.js

@@ -0,0 +1,43 @@
+const MAX = 500;
+const entries = [];
+const listeners = new Set();
+const LOUD = new Set(['timeout', 'clash', 'cycle', 'refused', 'unknown']);
+export const describeSource = (s) => `${s.host}:${s.id}`;
+function debugOn() {
+    try {
+        return !!globalThis.__3driseTriggersDebug || (typeof localStorage !== 'undefined' && localStorage.getItem('3drise:triggers') === '1');
+    }
+    catch {
+        return false;
+    }
+}
+export function logTrigger(e) {
+    const entry = { t: Date.now(), ...e };
+    entries.push(entry);
+    if (entries.length > MAX)
+        entries.splice(0, entries.length - MAX);
+    if (LOUD.has(e.type) || debugOn()) {
+        const via = e.chain.length ? ` via ${e.chain.map(describeSource).join(' → ')}` : '';
+        const msg = `[3drise] triggers: ${e.type} ${e.kind ?? ''}${e.subject ? ` "${e.subject}"` : ''} from ${describeSource(e.source)}${via}${e.detail ? ` — ${e.detail}` : ''}`;
+        if (LOUD.has(e.type))
+            console.warn(msg);
+        else
+            console.info(msg);
+    }
+    for (const l of listeners) {
+        try {
+            l(entry);
+        }
+        catch { /* listener error */ }
+    }
+}
+/** The recent entries (oldest first), optionally of some types. */
+export function getTriggerLog(types) {
+    return types ? entries.filter(e => types.includes(e.type)) : entries.slice();
+}
+export function clearTriggerLog() { entries.length = 0; }
+/** Subscribe to new entries. Returns the unsubscribe. */
+export function onTriggerLog(listener) {
+    listeners.add(listener);
+    return () => { listeners.delete(listener); };
+}

package/dist/triggers/readiness.d.ts

@@ -0,0 +1,40 @@
+export type SceneReadinessStatus = 'idle' | 'loading' | 'ready';
+declare class SceneReadiness {
+    private status;
+    private expected;
+    /** Reports arrive whenever a model lands — before begin() too, so they are kept. */
+    private loaded;
+    private failed;
+    private compile;
+    private waiters;
+    private listeners;
+    private timer;
+    private startedAt;
+    private finishing;
+    private generation;
+    getStatus(): SceneReadinessStatus;
+    /** True when nothing is gating (studio) or the scene is ready. */
+    isReady(): boolean;
+    /** A published scene starts: wait for these models, then compile, then one frame. */
+    begin(modelIds: string[], opts?: {
+        compile?: () => Promise<unknown>;
+    }): void;
+    /** A model's Object3D is in the scene. */
+    report(id: string): void;
+    /** A model failed to load — it will never report; don't wait for it. */
+    fail(id: string, reason?: unknown): void;
+    /** Run now if ready, else once the scene is ready. Returns a cancel. */
+    whenReady(fn: () => void): () => void;
+    subscribe: (listener: () => void) => (() => void);
+    /** The scene left the page: forget everything, gate open. */
+    reset(): void;
+    private check;
+    private finish;
+    private clearTimer;
+    private emit;
+}
+export declare const sceneReadiness: SceneReadiness;
+/** True when the scene is ready (or nothing gates it, as in the studio). Re-renders on change. */
+export declare function useSceneReady(): boolean;
+export {};
+//# sourceMappingURL=readiness.d.ts.map

package/dist/triggers/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../../src/triggers/readiness.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAMhE,cAAM,cAAc;IAChB,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,QAAQ,CAAqB;IACrC,oFAAoF;IACpF,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,OAAO,CAAyC;IACxD,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,KAAK,CAA8C;IAC3D,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAK;IAEvB,SAAS,IAAI,oBAAoB;IACjC,kEAAkE;IAClE,OAAO,IAAI,OAAO;IAElB,qFAAqF;IACrF,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;KAAO,GAAG,IAAI;IAmBhF,0CAA0C;IAC1C,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAMxB,wEAAwE;IACxE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAOxC,wEAAwE;IACxE,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAMrC,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAG9C;IAEF,6DAA6D;IAC7D,KAAK,IAAI,IAAI;IAab,OAAO,CAAC,KAAK;YAMC,MAAM;IA2BpB,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,IAAI;CAGf;AAED,eAAO,MAAM,cAAc,gBAAuB,CAAC;AAEnD,kGAAkG;AAClG,wBAAgB,aAAa,IAAI,OAAO,CAEvC"}

package/dist/triggers/readiness.js

@@ -0,0 +1,158 @@
+// =============================================================================
+// Scene readiness — nothing runs before the scene is ready.
+// =============================================================================
+//
+// A published scene (SceneBuilder) is READY when:
+//   1. every model it holds has loaded (ModelPrimitive reports it) or failed (ModelBoundary), and
+//   2. the scene's shaders are compiled (renderer.compileAsync), and
+//   3. one frame has rendered.
+// Only then do autoplay sequences start, object effects start, onSceneReady fires and the
+// loading cover lifts. A model that never reports doesn't hold the scene forever: after
+// TIMEOUT_MS it goes ready anyway and the missing ids are logged.
+//
+// Objects other than models mount in the same commit as the scene and are not waited on.
+//
+// The studio never calls begin(): its scene is live (objects come and go), so the gate
+// stays open there ('idle' counts as ready). Targets that don't exist yet are the
+// triggers engine's per-target wait (plan phase 2).
+//
+// One scene per page, like SceneStore.
+//
+import { useSyncExternalStore } from 'react';
+const TIMEOUT_MS = 15000;
+const COMPILE_TIMEOUT_MS = 5000;
+const log = (...a) => console.info('[3drise] scene', ...a);
+class SceneReadiness {
+    status = 'idle';
+    expected = new Set();
+    /** Reports arrive whenever a model lands — before begin() too, so they are kept. */
+    loaded = new Set();
+    failed = new Set();
+    compile = null;
+    waiters = [];
+    listeners = new Set();
+    timer = null;
+    startedAt = 0;
+    finishing = false;
+    generation = 0;
+    getStatus() { return this.status; }
+    /** True when nothing is gating (studio) or the scene is ready. */
+    isReady() { return this.status !== 'loading'; }
+    /** A published scene starts: wait for these models, then compile, then one frame. */
+    begin(modelIds, opts = {}) {
+        this.clearTimer();
+        this.generation++;
+        this.status = 'loading';
+        this.finishing = false;
+        this.expected = new Set(modelIds.filter(Boolean));
+        this.compile = opts.compile ?? null;
+        this.startedAt = performance.now();
+        this.emit();
+        const gen = this.generation;
+        this.timer = setTimeout(() => {
+            if (gen !== this.generation || this.status !== 'loading')
+                return;
+            const missing = [...this.expected].filter(id => !this.loaded.has(id) && !this.failed.has(id));
+            console.warn(`[3drise] scene: ${missing.length} model(s) never reported within ${TIMEOUT_MS / 1000}s — going ready without them`, missing);
+            void this.finish();
+        }, TIMEOUT_MS);
+        this.check();
+    }
+    /** A model's Object3D is in the scene. */
+    report(id) {
+        if (!id || this.loaded.has(id))
+            return;
+        this.loaded.add(id);
+        this.check();
+    }
+    /** A model failed to load — it will never report; don't wait for it. */
+    fail(id, reason) {
+        if (!id || this.failed.has(id))
+            return;
+        this.failed.add(id);
+        console.warn(`[3drise] scene: model ${id} failed to load — not waiting for it`, reason ?? '');
+        this.check();
+    }
+    /** Run now if ready, else once the scene is ready. Returns a cancel. */
+    whenReady(fn) {
+        if (this.isReady()) {
+            fn();
+            return () => { };
+        }
+        this.waiters.push(fn);
+        return () => { this.waiters = this.waiters.filter(w => w !== fn); };
+    }
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    /** The scene left the page: forget everything, gate open. */
+    reset() {
+        this.clearTimer();
+        this.generation++;
+        this.status = 'idle';
+        this.finishing = false;
+        this.expected.clear();
+        this.loaded.clear();
+        this.failed.clear();
+        this.compile = null;
+        this.waiters = [];
+        this.emit();
+    }
+    check() {
+        if (this.status !== 'loading' || this.finishing)
+            return;
+        for (const id of this.expected)
+            if (!this.loaded.has(id) && !this.failed.has(id))
+                return;
+        void this.finish();
+    }
+    async finish() {
+        if (this.finishing || this.status !== 'loading')
+            return;
+        this.finishing = true;
+        this.clearTimer();
+        const gen = this.generation;
+        const modelsAt = performance.now();
+        if (this.compile) {
+            try {
+                await Promise.race([this.compile(), new Promise(r => setTimeout(r, COMPILE_TIMEOUT_MS))]);
+            }
+            catch (e) {
+                console.warn('[3drise] scene: shader compile failed, going on', e);
+            }
+        }
+        // one rendered frame, so what is shown is what runs
+        await new Promise(r => requestAnimationFrame(() => requestAnimationFrame(() => r())));
+        if (gen !== this.generation)
+            return; // reset / begun again meanwhile
+        this.status = 'ready';
+        const t = (n) => `${Math.round(n - this.startedAt)}ms`;
+        log(`ready in ${t(performance.now())} (models ${t(modelsAt)}, ${[...this.expected].filter(id => this.loaded.has(id)).length}/${this.expected.size} loaded${this.failed.size ? `, ${this.failed.size} failed` : ''})`);
+        this.emit();
+        const run = this.waiters;
+        this.waiters = [];
+        for (const w of run) {
+            try {
+                w();
+            }
+            catch (e) {
+                console.error('[3drise] scene: a ready callback failed', e);
+            }
+        }
+    }
+    clearTimer() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+    emit() {
+        for (const l of this.listeners)
+            l();
+    }
+}
+export const sceneReadiness = new SceneReadiness();
+/** True when the scene is ready (or nothing gates it, as in the studio). Re-renders on change. */
+export function useSceneReady() {
+    return useSyncExternalStore(sceneReadiness.subscribe, () => sceneReadiness.isReady(), () => true);
+}

package/dist/triggers/registry.d.ts

@@ -0,0 +1,41 @@
+import type { Object3D } from 'three';
+import type { SceneCommand, SceneCommandKind, TriggerSource } from '@3driseai/3drise-core';
+export interface TriggerContext {
+    source: TriggerSource;
+    /** The sources above this one, outermost first (what triggered what). */
+    chain: TriggerSource[];
+    /** The object an interaction is on ('self' in targets). */
+    self?: Object3D | null;
+    /** Action only: false = its patches without its effects (a sequence posed / scrubbed, the editor's preview). */
+    effects?: boolean;
+}
+export type CommandOf<K extends SceneCommandKind> = Extract<SceneCommand, {
+    kind: K;
+}>;
+export interface Triggerable<K extends SceneCommandKind = SceneCommandKind> {
+    kind: K;
+    /** Command verbs it accepts. */
+    commands: readonly string[];
+    /**
+     * As a cue on a timeline: 'state' — on / off at any moment (scrub-safe);
+     * 'event' — fires when the playhead moves forward across it.
+     */
+    timeline: 'state' | 'event';
+    /** A timeline itself (clip / sequence): a timeline can't trigger one. */
+    isTimeline?: boolean;
+    /** Scene object ids it acts on ('self' excluded) — the engine waits for them to mount. */
+    targets?(cmd: CommandOf<K>): string[];
+    /** A short name of what it acts on, for the log. */
+    subject(cmd: CommandOf<K>): string;
+    /**
+     * Stateful kinds: the claim key and whether it is on now — the engine tracks who
+     * switched it on, to notice clashes. Event kinds leave it out.
+     */
+    claimKey?(cmd: CommandOf<K>): string | null;
+    isOn?(cmd: CommandOf<K>, ctx: TriggerContext): boolean;
+    run(cmd: CommandOf<K>, ctx: TriggerContext): void;
+}
+export declare function defineTriggerable<K extends SceneCommandKind>(def: Triggerable<K>): Triggerable<K>;
+export declare const getTriggerable: (kind: string) => Triggerable<any> | undefined;
+export declare const triggerableKinds: () => string[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/triggers/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/triggers/registry.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3F,MAAM,WAAW,cAAc;IAC3B,MAAM,EAAE,aAAa,CAAC;IACtB,yEAAyE;IACzE,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACvB,gHAAgH;IAChH,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC;AAEvF,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB;IACtE,IAAI,EAAE,CAAC,CAAC;IACR,gCAAgC;IAChC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;OAGG;IACH,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC;IAC5B,yEAAyE;IACzE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,0FAA0F;IAC1F,OAAO,CAAC,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC;IACtC,oDAAoD;IACpD,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;IAC5C,IAAI,CAAC,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;IACvD,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI,CAAC;CACrD;AAID,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,gBAAgB,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAGjG;AAED,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,WAAW,CAAC,GAAG,CAAC,GAAG,SAA4B,CAAC;AAC9F,eAAO,MAAM,gBAAgB,QAAO,MAAM,EAAuB,CAAC"}

package/dist/triggers/registry.js

@@ -0,0 +1,7 @@
+const kinds = new Map();
+export function defineTriggerable(def) {
+    kinds.set(def.kind, def);
+    return def;
+}
+export const getTriggerable = (kind) => kinds.get(kind);
+export const triggerableKinds = () => [...kinds.keys()];

package/dist/types/gridConfigs.d.ts

@@ -38,8 +38,6 @@ export interface GridSurfaceConfig {
     size: number;
     /** plane subdivisions per side; auto-derived when omitted, bumped when `displace > 0` */
     segments?: number;
-    /** lay flat on XZ (true) or stand upright on XY (false) */
-    flat: boolean;
     /** base size of one tile in world units */
     cellSize: number;
     lineMode: GridLineMode;
@@ -64,8 +62,6 @@ export interface GridSurfaceConfig {
     glowColor: string;
     bgColor: string;
     bgOpacity: number;
-    /** project the pointer onto the plane and feed it to the focus point */
-    followMouse: boolean;
     /**
      * 0..1 assemble amount. The build boundary sweeps outward from the focus
      * point with a bright leading edge. Defaults to 1 (fully built); animate it
@@ -83,7 +79,7 @@ export interface GridSurfaceConfig {
  * Honeycomb tiling. `cellSize` is the hex's flat-to-flat width, `sectionSize`
  * groups hexes into super-hexes drawn in `sectionColor`.
  */
-export interface HexGridConfig extends GridSurfaceConfig {
+export interface HexGridConfig extends GridSurfaceBaseConfig {
     /**
      * With `displace > 0`, each hex lifts to its own height instead of riding a
      * smooth wave — a plated, tessellated-terrain look with vertical walls.
@@ -94,7 +90,7 @@ export interface HexGridConfig extends GridSurfaceConfig {
  * Truchet circuit board. Each tile picks one of two arc rotations, so traces
  * connect across tiles into long meandering paths.
  */
-export interface CircuitGridConfig extends GridSurfaceConfig {
+export interface CircuitGridConfig extends GridSurfaceBaseConfig {
     /** 0..1 — fraction of tiles that carry a powered trace */
     powered: number;
     /** 0..1 — fraction of tiles replaced by an IC package. 0 disables chips */
@@ -106,7 +102,7 @@ export interface CircuitGridConfig extends GridSurfaceConfig {
  * Voronoi lattice — irregular cells that drift and morph. `cellSize` is the
  * average cell width; `sectionColor`/`sectionWidth` draw the cell nuclei.
  */
-export interface VoronoiGridConfig extends GridSurfaceConfig {
+export interface VoronoiGridConfig extends GridSurfaceBaseConfig {
     /** 0 = regular square lattice, 1 = fully scattered seeds */
     jitter: number;
     /** how far the seeds wander over time; 0 freezes the lattice */
@@ -116,7 +112,7 @@ export interface VoronoiGridConfig extends GridSurfaceConfig {
  * Polar HUD. `cellSize` is the ring spacing, `sectionSize` marks every Nth ring
  * as a major ring, and the surface is masked to a disc of `fadeDistance`.
  */
-export interface RadarGridConfig extends GridSurfaceConfig {
+export interface RadarGridConfig extends GridSurfaceBaseConfig {
     /** number of radial spokes; 0 disables them */
     spokes: number;
     /** angular length of the sweep trail, as a fraction of a full turn; 0 disables the sweep */
@@ -129,7 +125,7 @@ export interface RadarGridConfig extends GridSurfaceConfig {
  * pattern. `cellSize` is the base spacing; the second layer differs from the
  * first by `layerAngle` and `layerScale`.
  */
-export interface MoireGridConfig extends GridSurfaceConfig {
+export interface MoireGridConfig extends GridSurfaceBaseConfig {
     /** lattice shape for both layers */
     shape: 'square' | 'hex' | 'rings';
     /** fixed angle between the two layers, in radians. Small values beat slowly */
@@ -144,7 +140,7 @@ export interface MoireGridConfig extends GridSurfaceConfig {
  * where you are pointing and coarse at the edges. `cellSize` is the level-0
  * cell; each level halves it.
  */
-export interface FractalGridConfig extends GridSurfaceConfig {
+export interface FractalGridConfig extends GridSurfaceBaseConfig {
     /** maximum subdivision levels, 1..6 */
     depth: number;
     /** radius around the focus, in level-0 cells, inside which cells subdivide */
@@ -159,7 +155,7 @@ export interface FractalGridConfig extends GridSurfaceConfig {
  * `displace` is literal here rather than decorative: the vertex stage raises
  * the surface to exactly the elevation the contours describe.
  */
-export interface ContourGridConfig extends GridSurfaceConfig {
+export interface ContourGridConfig extends GridSurfaceBaseConfig {
     /** number of contour steps across the full height range */
     levels: number;
     /** fbm gain — 0.35 rolling, 0.65 craggy */
@@ -172,7 +168,7 @@ export interface ContourGridConfig extends GridSurfaceConfig {
  * The intersections never repeat, so the pattern never tiles back on itself
  * however far the camera travels.
  */
-export interface QuasiGridConfig extends GridSurfaceConfig {
+export interface QuasiGridConfig extends GridSurfaceBaseConfig {
     /**
      * How many line families, 3..9. 5 is Penrose. 4 and 6 divide the half-turn
      * evenly and so come out periodic; everything else is quasiperiodic.
@@ -185,7 +181,7 @@ export interface QuasiGridConfig extends GridSurfaceConfig {
  * Potential flow past a cylinder, drawn as a flow net. `cellSize` is the net
  * spacing; the cylinder sits at the focus point, so `followMouse` drags it.
  */
-export interface FlowNetGridConfig extends GridSurfaceConfig {
+export interface FlowNetGridConfig extends GridSurfaceBaseConfig {
     /** cylinder radius, in cells */
     obstacleRadius: number;
     /** circulation around the cylinder, in whole units; shifts the flow to one side (lift) */
@@ -198,7 +194,7 @@ export interface FlowNetGridConfig extends GridSurfaceConfig {
  * the size of one plate; `sectionSize` plates make one outlined group.
  * `displace` vibrates the plate with the wave itself.
  */
-export interface ChladniGridConfig extends GridSurfaceConfig {
+export interface ChladniGridConfig extends GridSurfaceBaseConfig {
     /** first mode number of the standing wave, 1..12 */
     modeN: number;
     /** second mode number of the standing wave, 1..12 */
@@ -213,7 +209,7 @@ export interface ChladniGridConfig extends GridSurfaceConfig {
  * units; `lineWidth` / `sectionWidth` are hyperbolic widths, so edges thin
  * toward the rim; every `sectionSize`-th generation of polygons is accented.
  */
-export interface HyperbolicGridConfig extends GridSurfaceConfig {
+export interface HyperbolicGridConfig extends GridSurfaceBaseConfig {
     /** sides of each polygon (p), 3..12 */
     sides: number;
     /** polygons around each vertex (q), 3..12; raised until (p-2)(q-2) > 4 */
@@ -223,7 +219,7 @@ export interface HyperbolicGridConfig extends GridSurfaceConfig {
 }
 /** Every grid config this package can render, tagged by `type`. */
 /** A spacetime lattice around a binary black-hole inspiral. The Newtonian wells pinch the lines, and quadrupole waves, evaluated at the retarded time, spiral outward and chirp toward the merger before the remnant rings down. */
-export interface GravWaveGridConfig extends GridSurfaceConfig {
+export interface GravWaveGridConfig extends GridSurfaceBaseConfig {
     /** wave amplitude multiplier; 0 leaves only the static wells */
     strain: number;
     /** seconds per inspiral-merger-ringdown cycle (clamped to at least 4 in the shader) */
@@ -234,7 +230,7 @@ export interface GravWaveGridConfig extends GridSurfaceConfig {
     massRatio: number;
 }
 /** An Islamic star pattern drawn by Hankin polygons-in-contact. One ray per dihedral sector, from the edge midpoint to the sector bisector, generates the whole interlaced star-and-rosette strapwork over an octagon-square, hexagonal or trihexagonal tiling. */
-export interface GirihGridConfig extends GridSurfaceConfig {
+export interface GirihGridConfig extends GridSurfaceBaseConfig {
     /** base tiling: 0 = 4.8.8, 1 = regular hexagons, 2 = 3.6.3.6 (trihexagonal) */
     tiling: number;
     /** Hankin contact angle in degrees (20..85); 67.5 is the classic 8-point star */
@@ -245,7 +241,7 @@ export interface GirihGridConfig extends GridSurfaceConfig {
     angleDrift: number;
 }
 /** Wallpaper-group kaleidoscope: a drifting lattice-periodic Fourier motif summed over the coset representatives of one of the 17 plane crystallographic groups. The runtime builds the group tables and crossfades from group to group. */
-export interface WallpaperGridConfig extends GridSurfaceConfig {
+export interface WallpaperGridConfig extends GridSurfaceBaseConfig {
     /** Wallpaper group index (-1 cycles), read by the runtime */
     group: number;
     /** Seconds per group while cycling, read by the runtime */
@@ -256,7 +252,7 @@ export interface WallpaperGridConfig extends GridSurfaceConfig {
     levels: number;
 }
 /** A Gray-Scott reaction-diffusion field simulated on the GPU and sampled by the plane: coral, labyrinths and dividing spots grow, merge and keep evolving, wrapped seamlessly as a torus. */
-export interface ReactionDiffusionGridConfig extends GridSurfaceConfig {
+export interface ReactionDiffusionGridConfig extends GridSurfaceBaseConfig {
     /** Gray-Scott feed rate F. */
     feed: number;
     /** Gray-Scott kill rate k. */
@@ -266,6 +262,94 @@ export interface ReactionDiffusionGridConfig extends GridSurfaceConfig {
     /** Cells covered by one simulation tile before it repeats. */
     tileCells: number;
 }
+/**
+ * Every grid lies flat (orientation is the parent object's transform) and leaves
+ * pointer behaviour to the Pointer tab, so the shared surface is the whole base.
+ */
+export type GridSurfaceBaseConfig = GridSurfaceConfig;
+/** A square lattice seen through a point-mass gravitational lens: the thin-lens equation bends it into an Einstein ring, an inverted inner image and a dark shadow at the core. */
+export interface LensingGridConfig extends GridSurfaceBaseConfig {
+    /** Einstein radius of the lens, in cells; 0 leaves the lattice undistorted */
+    mass: number;
+    /** Radius the lens circles the centre on, in cells; 0 holds it at the centre */
+    orbit: number;
+    /** Brightness of the Einstein ring and its halo */
+    ringGlow: number;
+}
+/** A square lattice pulled back through an ideal-flow complex potential. Cauchy–Riemann keeps every cell square; colour is the flow speed, alternate stream tubes carry dye and hydrogen-bubble dashes ride the flow. */
+export interface ConformalGridConfig extends GridSurfaceBaseConfig {
+    /** The flow: 0 source + sink, 1 spiral vortex, 2 spinning cylinder, 3 corner */
+    flowMap: number;
+    /** Distance from the centre to the poles, or the cylinder radius, in world units */
+    poleSpread: number;
+    /** Lattice lines per turn round a pole (whole number, so the log seam closes) */
+    spokes: number;
+    /** Spiral arms of the vortex flow; 0 gives a plain polar web */
+    arms: number;
+    /** Circulation round the cylinder (lift); at ±2 both stagnation points meet */
+    circulation: number;
+    /** How fast the lattice streams along the flow; negative reverses it */
+    drift: number;
+    /** Strength of the speed-coloured stream-tube fill */
+    fill: number;
+    /** Brightness of the dashes carried along the streamlines */
+    dye: number;
+}
+/** Smith quarter-circle Truchet tiles: arcs always meet arcs, so the plane fills with endless two-coloured loops. Tiles re-deal by turning a quarter turn, and comets travel the loops in one direction. */
+export interface TruchetGridConfig extends GridSurfaceBaseConfig {
+    /** Chance a tile re-deals its orientation each epoch; 0 freezes the paths */
+    flip: number;
+    /** Balance of the two tile orientations: 0.5 is a maze, the ends are stripes */
+    bias: number;
+    /** Brightness of the comets travelling the loops */
+    pulse: number;
+    /** Fill of one colour of the two-colouring */
+    regionFill: number;
+}
+/** Vogel's sunflower: florets at the golden angle, each a lit dome coloured by age and carrying a mark aligned to the head's radius. Bloom rings travel from the rim to the centre and open the marks; the head itself never turns. */
+export interface PhyllotaxisGridConfig extends GridSurfaceBaseConfig {
+    /** Angle between successive seeds, degrees; 137.508 is the golden angle */
+    divergence: number;
+    /** Speed of the bloom rings travelling rim to centre; negative reverses them */
+    bloomRate: number;
+    /** Depth of the lit dome on each floret */
+    relief: number;
+    /** The mark each floret carries (0 draws only the domes) */
+    shape: number;
+    /** Size of the mark relative to its floret */
+    shapeSize: number;
+    /** Brightness of the marks */
+    shapeGlow: number;
+}
+/** The sunflower's crossed Fibonacci spiral families as a grid of their own: sectionSize spirals one way, sectionSize/φ the other, every crossing a seed, and the difference family cutting each cell into triangles. Light runs inward along the spirals. */
+export interface ParastichyGridConfig extends GridSurfaceBaseConfig {
+    /** Angle between successive seeds, degrees; 137.508 is the golden angle */
+    divergence: number;
+    /** Weight of the third spiral family that splits cells into triangles */
+    third: number;
+    /** Brightness of the light running inward along the spirals */
+    sap: number;
+    /** Strength of the faceted cell fill */
+    fill: number;
+}
+/** An Apollonian gasket by circle inversion: a point is walked out of nested gaps through the four dual circles, so every tangent circle gets a pixel-true rim. A slow Möbius disk flow re-balances the packing while every tangency holds. */
+export interface ApollonianGridConfig extends GridSurfaceBaseConfig {
+    /** Inversion levels: how deep the packing nests */
+    depth: number;
+    /** Strength of the Möbius flow that re-balances the packing; 0 holds it symmetric */
+    morph: number;
+}
+/** A closed Moore curve — four Hilbert curves joined into one loop — threads every cell once while keeping neighbours on the line neighbours on the plane. Signals with exponential trails circulate along it; the accent is the same curve one level coarser. */
+export interface HilbertGridConfig extends GridSurfaceBaseConfig {
+    /** Curve order: the loop covers 2^order cells per side */
+    order: number;
+    /** Signals circulating round the loop */
+    signals: number;
+    /** Length of each signal trail, in cells */
+    trail: number;
+    /** Signal speed, in cells per second */
+    signalSpeed: number;
+}
 export type AnyGridConfig = (HexGridConfig & {
     type: 'hexGrid';
 }) | (CircuitGridConfig & {
@@ -296,5 +380,19 @@ export type AnyGridConfig = (HexGridConfig & {
     type: 'wallpaperGrid';
 }) | (ReactionDiffusionGridConfig & {
     type: 'reactionDiffusionGrid';
+}) | (LensingGridConfig & {
+    type: 'lensingGrid';
+}) | (ConformalGridConfig & {
+    type: 'conformalGrid';
+}) | (TruchetGridConfig & {
+    type: 'truchetGrid';
+}) | (PhyllotaxisGridConfig & {
+    type: 'phyllotaxisGrid';
+}) | (ParastichyGridConfig & {
+    type: 'parastichyGrid';
+}) | (ApollonianGridConfig & {
+    type: 'apollonianGrid';
+}) | (HilbertGridConfig & {
+    type: 'hilbertGrid';
 });
 //# sourceMappingURL=gridConfigs.d.ts.map