@3driseai/3drise-viewer 0.1.27 → 0.1.29

package/dist/shaders/terrain/TerrainMaterial.js

@@ -1,7 +1,8 @@
 import * as THREE from 'three';
 import { extend } from '@react-three/fiber';
 import { skyLib } from '../glsl/cloudCore.glsl.js';
-import { terrainFull } from '../glsl/terrainCore.glsl.js';
+import { terrainFull, terrainTextured } from '../glsl/terrainCore.glsl.js';
+import { surfaceSampling } from '../glsl/surfaceCore.glsl.js';
 /**
  * The terrain surface material. Used by all four landforms — they are one height
  * field with different shaping operators, not four shaders.
@@ -57,6 +58,40 @@ varying float vCell;
 varying float vDist;
 varying float vShadow;
 
+#ifdef TERRAIN_PATCH
+// A land object. The mesh is a unit grid on XZ (-0.5..0.5) that the object's
+// transform places, rotates and sizes. The field is sampled in terrain space —
+// metres from the object's origin, plus the seed offset — so a wider footprint
+// shows more land rather than stretching it, and the land rides with the object.
+// Height comes back in terrain metres (elevation x scale.y) and is divided by
+// scale.y on the way out, because the model matrix multiplies it back.
+void main(){
+  vec2 tp = position.xz * u_patchSize + u_patchOffset;
+  float cellLod = u_patchCell;
+
+  vec2 grad;
+  float h = terrainSurfaceAt(tp, cellLod, grad);
+
+  vec3 wp = vec3(tp.x, h, tp.y);
+  float camDist = distance(wp, TERRAIN_CAM);
+  vShadow = terrainShadowAt(wp, terrainNormal(grad), cellLod, camDist);
+
+  vec3 transformed = vec3(position.x, (h - u_seaLevel) / max(u_scaleY, 1e-4), position.z);
+  vec3 objectNormal = vec3(0.0, 1.0, 0.0);
+  vec3 transformedNormal = normalMatrix * objectNormal;
+
+  vWorld = wp;
+  vCell = cellLod;
+  vDist = camDist;
+
+  vec4 mvPosition = modelViewMatrix * vec4(transformed, 1.0);
+  gl_Position = projectionMatrix * mvPosition;
+
+  #include <worldpos_vertex>
+  #include <shadowmap_vertex>
+  #include <fog_vertex>
+}
+#else
 void main(){
   // Geomorph. Across the outer band of each ring, odd vertices slide onto their
   // even neighbours, so by the ring boundary the edge polyline is EXACTLY the
@@ -118,6 +153,7 @@ void main(){
   #include <shadowmap_vertex>
   #include <fog_vertex>
 }
+#endif
 `;
 const fragment = /* glsl */ `
 #include <common>
@@ -133,6 +169,10 @@ const fragment = /* glsl */ `
 
 ${skyLib}
 ${terrainFull}
+#ifdef TERRAIN_TEXTURED
+${surfaceSampling}
+#endif
+${terrainTextured}
 
 uniform float u_receiveShadows;
 
@@ -142,7 +182,7 @@ varying float vDist;
 varying float vShadow;
 
 void main(){
-  vec3 viewDir = normalize(vWorld - cameraPosition);
+  vec3 viewDir = normalize(vWorld - TERRAIN_CAM);
 
   // The shading footprint. Finer than the mesh cell, because a ridge 5 km out
   // lands on a 256 m clipmap cell but still covers only a few pixels - clamping
@@ -159,9 +199,9 @@ void main(){
   // - a central difference would need four more, and this shader used to pay for
   // them on every pixel.
   vec2 grad;
-  float shadeHeight = terrainSample(vWorld.xz, lod, grad);
-  vec3 n = terrainNormal(grad);
-  n = terrainDetailNormal(n, vWorld, vDist);
+  float shadeHeight = terrainSurfaceAt(vWorld.xz, lod, grad);
+  vec3 nBase = terrainNormal(grad);
+  vec3 n = terrainDetailNormal(nBase, vWorld, vDist);
 
   // Shade against the analytically evaluated surface, not the interpolated mesh
   // vertex. The mesh is a coarse approximation of this field and its height is
@@ -176,7 +216,39 @@ void main(){
   float slope = acos(clamp(n.y, -1.0, 1.0)) * 0.6366197724;
   float h01 = saturate((shadeHeight - u_seaLevel) / max(u_elevation, 1e-3));
 
-  vec3 albedo = terrainAlbedo(surface, h01, slope);
+  vec4 layerW = terrainLayerWeights(h01, slope);
+  vec3 albedo = terrainAlbedo(surface, layerW);
+  float roughness = u_roughness;
+  float ao = 1.0;
+
+  #ifdef TERRAIN_TEXTURED
+  // World-position derivatives, taken HERE in uniform control flow: the layers a
+  // pixel samples are chosen per pixel, and dFdx inside that choice is undefined.
+  vec3 dpx = dFdx(vWorld);
+  vec3 dpy = dFdy(vWorld);
+  TerrainGrads grads = TerrainGrads(dpx.xz, dpy.xz, dpx.zy, dpy.zy, dpx.xy, dpy.xy);
+
+  // Textured near field, fading into the flat far colours past u_tDistance. Past
+  // the fade nothing is fetched, so the horizon costs what it always did.
+  float near = 1.0 - smoothstep(u_tDistance * 0.7, u_tDistance, vDist);
+  if (near > 0.001){
+    vec3 nearAlbedo;
+    vec3 nearN;
+    float nearRough;
+    float nearAo;
+    // Against the analytic normal WITHOUT the noise bump. The bump is the far
+    // field's stand-in for surface detail; up close the texture normals are the
+    // detail, and the two together read as bubble wrap under the grass.
+    terrainSurfaceNear(surface, nBase, layerW, grads, nearAlbedo, nearN, nearRough, nearAo);
+    albedo = mix(albedo, nearAlbedo * terrainMacro(surface), near);
+    n = normalize(mix(n, nearN, near));
+    // The scan's roughness only VARIES the terrain's own roughness. Taken raw,
+    // a granite or snow scan's low values put sharp highlights on every facet
+    // and the mountains read as wet plastic.
+    roughness = mix(roughness, clamp(u_roughness * (0.75 + 0.5 * nearRough), 0.35, 1.0), near);
+    ao = mix(1.0, nearAo, near);
+  }
+  #endif
 
   float selfShadow = mix(1.0, saturate(vShadow), saturate(u_sunShadow));
 
@@ -185,7 +257,7 @@ void main(){
     sceneShadow = mix(1.0, getShadowMask(), u_receiveShadows);
   #endif
 
-  vec3 col = terrainLight(albedo, n, viewDir, selfShadow, sceneShadow);
+  vec3 col = terrainLight(albedo, n, viewDir, selfShadow, sceneShadow, roughness, ao);
   col = terrainAerial(col, viewDir, vDist, shadeHeight);
   col *= u_exposure;
 
@@ -220,6 +292,13 @@ export const terrainMaterialDefaults = {
     u_valleyWidth: 0.25,
     u_cellSize: 2,
     u_curvature: 1 / (2 * 6371000),
+    // Land objects only (TERRAIN_PATCH); set by applyLandPatchUniforms.
+    u_patchSize: new THREE.Vector2(1000, 1000),
+    u_patchOffset: new THREE.Vector2(0, 0),
+    u_edgeWidth: 100,
+    u_camTerrain: new THREE.Vector3(),
+    u_scaleY: 1,
+    u_patchCell: 4,
     u_lowColor: new THREE.Color('#3f5326'),
     u_midColor: new THREE.Color('#55663a'),
     u_rockColor: new THREE.Color('#7a7266'),
@@ -236,6 +315,19 @@ export const terrainMaterialDefaults = {
     u_detailFade: 1 / 900,
     u_roughness: 0.9,
     u_specular: 0.03,
+    // Ground textures. u_tFar is read with or without textures; the rest only
+    // when TERRAIN_TEXTURED is defined (see applyTerrainTextures).
+    u_tFar: [new THREE.Color('#3f5326'), new THREE.Color('#55663a'), new THREE.Color('#7a7266'), new THREE.Color('#8d9a6a')],
+    u_tColor: null,
+    u_tNormal: null,
+    u_tOrm: null,
+    u_tLayer: [0, 1, 2, 3].map(() => new THREE.Vector4(1 / 3, 1, 0, 0)),
+    u_tTint: [0, 1, 2, 3].map(() => new THREE.Color(1, 1, 1)),
+    u_tMeanC: [0, 1, 2, 3].map(() => new THREE.Vector4(0.5, 0.5, 0.5, 1)),
+    u_tMeanN: [0, 1, 2, 3].map(() => new THREE.Vector4(0.5, 0.5, 1, 0.5)),
+    u_tMeanO: [0, 1, 2, 3].map(() => new THREE.Vector4(1, 0.9, 0, 1)),
+    u_tDistance: 1500,
+    u_tHeightBlend: 0.7,
     u_ambient: 1,
     u_bounce: 0.35,
     u_sunShadow: 1,
@@ -263,11 +355,18 @@ function buildUniforms() {
     for (const [key, value] of Object.entries(terrainMaterialDefaults)) {
         own[key] = { value };
     }
-    return THREE.UniformsUtils.merge([
+    const merged = THREE.UniformsUtils.merge([
         THREE.UniformsLib.lights,
         THREE.UniformsLib.fog,
         own,
     ]);
+    // cloneUniforms copies arrays with slice(), which keeps the SAME Color and
+    // Vector instances — every material would then write into the module-level
+    // defaults. The layer arrays are cloned element by element instead.
+    for (const key of ['u_tFar', 'u_tLayer', 'u_tTint', 'u_tMeanC', 'u_tMeanN', 'u_tMeanO']) {
+        merged[key].value = merged[key].value.map((v) => v.clone());
+    }
+    return merged;
 }
 /**
  * `UniformsUtils.merge` clones by `Uniform.clone()`, which deep-copies Colors and

package/dist/triggers/engine.d.ts

@@ -0,0 +1,44 @@
+import type { ActionSequence, SceneCommand, TriggerSource } from '@3driseai/3drise-core';
+import type { AnimationClip, AnimationSequence } from '../animationsV2/types';
+import type { ClipLookup } from '../animationsV2/sequenceUtils';
+import { type TriggerContext } from './registry';
+/** Where a command's refs (action / clip / sequence ids) are looked up. */
+export interface TriggerCatalog {
+    action?(id: string): ActionSequence | undefined;
+    clip?(id: string): AnimationClip | undefined;
+    sequence?(id: string): AnimationSequence | undefined;
+    clips?(): ClipLookup;
+}
+export interface RunOptions {
+    source: TriggerSource;
+    self?: TriggerContext['self'];
+    /** Defaults to the chain of the command running now (a nested trigger), else none. */
+    chain?: TriggerSource[];
+    catalog?: TriggerCatalog;
+    effects?: boolean;
+}
+export type RunResult = 'ran' | 'queued' | 'waiting' | 'cycle' | 'refused' | 'unknown' | 'invalid';
+export interface EngineContext extends TriggerContext {
+    catalog: TriggerCatalog;
+}
+export declare function registerTriggerCatalog(catalog: TriggerCatalog): () => void;
+/**
+ * May a trigger of this host fire this kind at all? (The UI offers only what may run.)
+ * The full rule is checked on every run against the whole chain.
+ */
+export declare function canTrigger(kind: string, host: TriggerSource['host']): boolean;
+/** Is a stateful command's subject on now (an action applied, an effect clip / effect on)? */
+export declare function isCommandOn(cmd: SceneCommand, self?: TriggerContext['self']): boolean;
+/** Who switched this on (a kind's claim key), if the engine saw it. */
+export declare const claimHolder: (key: string) => TriggerSource | undefined;
+/** The chain a trigger fired from inside a running command gets. */
+export declare function currentChain(): TriggerSource[];
+export declare function runCommand(cmd: SceneCommand, opts: RunOptions): RunResult;
+/**
+ * Record a clash the engine didn't run itself — e.g. a sequence cue that leaves an
+ * action alone because another source applied it.
+ */
+export declare function noteClash(kind: SceneCommand['kind'], subject: string, source: TriggerSource, detail: string, claimKey?: string): void;
+/** Forget every claim (the scene left the page). */
+export declare function resetTriggerClaims(): void;
+//# sourceMappingURL=engine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/triggers/engine.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjE,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC3B,MAAM,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAChD,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAAC;IACrD,KAAK,CAAC,IAAI,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACvB,MAAM,EAAE,aAAa,CAAC;IACtB,IAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAC9B,sFAAsF;IACtF,KAAK,CAAC,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEnG,MAAM,WAAW,aAAc,SAAQ,cAAc;IACjD,OAAO,EAAE,cAAc,CAAC;CAC3B;AAmBD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,IAAI,CAG1E;AAYD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAI7E;AAED,8FAA8F;AAC9F,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,GAAG,OAAO,CAIrF;AAED,uEAAuE;AACvE,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,aAAa,GAAG,SAA4B,CAAC;AAEvF,oEAAoE;AACpE,wBAAgB,YAAY,IAAI,aAAa,EAAE,CAG9C;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,SAAS,CAiCzE;AA6CD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAGrI;AAED,oDAAoD;AACpD,wBAAgB,kBAAkB,IAAI,IAAI,CAAoB"}

package/dist/triggers/engine.js

@@ -0,0 +1,165 @@
+import { findById } from '../utils/sceneQuery.js';
+import { sceneReadiness } from './readiness.js';
+import { getTriggerable } from './registry.js';
+import { describeSource, logTrigger } from './log.js';
+const TARGET_WAIT_MS = 8000;
+const TARGET_POLL_MS = 100;
+const same = (a, b) => a.host === b.host && a.id === b.id;
+const isTimelineHost = (s) => s.host === 'sequence' || s.host === 'clip';
+/** The commands running now, innermost last — nested triggers inherit their chain and catalog. */
+const stack = [];
+/** Stateful things that are on, and the source that switched them on. */
+const claims = new Map();
+const unknownLogged = new Set();
+/**
+ * Catalogs the mounted scene registers (its actions, clips, sequences) — used when a command
+ * comes with none of its own (an action applied from a studio button, a nested trigger…).
+ */
+const registered = [];
+export function registerTriggerCatalog(catalog) {
+    registered.push(catalog);
+    return () => { const i = registered.lastIndexOf(catalog); if (i >= 0)
+        registered.splice(i, 1); };
+}
+const firstOf = (pick) => {
+    for (let i = registered.length - 1; i >= 0; i--) {
+        const v = pick(registered[i]);
+        if (v !== undefined)
+            return v;
+    }
+    return undefined;
+};
+const SCENE_CATALOG = {
+    action: (id) => firstOf(c => c.action?.(id)),
+    clip: (id) => firstOf(c => c.clip?.(id)),
+    sequence: (id) => firstOf(c => c.sequence?.(id)),
+    clips: () => firstOf(c => c.clips?.()) ?? new Map(),
+};
+/**
+ * May a trigger of this host fire this kind at all? (The UI offers only what may run.)
+ * The full rule is checked on every run against the whole chain.
+ */
+export function canTrigger(kind, host) {
+    const def = getTriggerable(kind);
+    if (!def)
+        return false;
+    return !(def.isTimeline && (host === 'sequence' || host === 'clip'));
+}
+/** Is a stateful command's subject on now (an action applied, an effect clip / effect on)? */
+export function isCommandOn(cmd, self) {
+    const def = getTriggerable(cmd?.kind);
+    if (!def?.isOn)
+        return false;
+    return safe(() => def.isOn(cmd, { source: { host: 'code', id: '' }, chain: [], self }), false);
+}
+/** Who switched this on (a kind's claim key), if the engine saw it. */
+export const claimHolder = (key) => claims.get(key);
+/** The chain a trigger fired from inside a running command gets. */
+export function currentChain() {
+    const top = stack[stack.length - 1];
+    return top ? [...top.chain, top.source] : [];
+}
+export function runCommand(cmd, opts) {
+    if (!cmd || typeof cmd !== 'object' || !cmd.kind)
+        return 'invalid';
+    const top = stack[stack.length - 1];
+    const ctx = {
+        source: opts.source,
+        chain: opts.chain ?? currentChain(),
+        self: opts.self,
+        effects: opts.effects,
+        catalog: opts.catalog ?? top?.catalog ?? SCENE_CATALOG,
+    };
+    const def = getTriggerable(cmd.kind);
+    if (!def) {
+        if (!unknownLogged.has(cmd.kind)) {
+            unknownLogged.add(cmd.kind);
+            logTrigger({ type: 'unknown', kind: cmd.kind, source: ctx.source, chain: ctx.chain, detail: 'this viewer does not know this kind (a newer project?) — skipped' });
+        }
+        return 'unknown';
+    }
+    const subject = safe(() => def.subject(cmd), '');
+    if (ctx.chain.some(s => same(s, ctx.source))) {
+        logTrigger({ type: 'cycle', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain, detail: `${describeSource(ctx.source)} is already in the chain — stopped` });
+        return 'cycle';
+    }
+    if (def.isTimeline && [...ctx.chain, ctx.source].some(isTimelineHost)) {
+        logTrigger({ type: 'refused', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain, detail: 'a timeline cannot trigger a timeline' });
+        return 'refused';
+    }
+    if (!sceneReadiness.isReady()) {
+        logTrigger({ type: 'queued', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain });
+        sceneReadiness.whenReady(() => { startWhenMounted(cmd, def, ctx, subject); });
+        return 'queued';
+    }
+    return startWhenMounted(cmd, def, ctx, subject);
+}
+function startWhenMounted(cmd, def, ctx, subject) {
+    const missing = () => (def.targets ? safe(() => def.targets(cmd), []) : []).filter(id => id && id !== 'self' && !findById(id));
+    if (!missing().length) {
+        execute(cmd, def, ctx, subject);
+        return 'ran';
+    }
+    logTrigger({ type: 'waiting', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain, detail: `targets not in the scene yet: ${missing().join(', ')}` });
+    const until = Date.now() + TARGET_WAIT_MS;
+    const timer = setInterval(() => {
+        const still = missing();
+        if (still.length && Date.now() < until)
+            return;
+        clearInterval(timer);
+        if (still.length)
+            logTrigger({ type: 'timeout', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain, detail: `targets never mounted: ${still.join(', ')} — ran anyway` });
+        execute(cmd, def, ctx, subject);
+    }, TARGET_POLL_MS);
+    return 'waiting';
+}
+function execute(cmd, def, ctx, subject) {
+    const key = def.claimKey ? safe(() => def.claimKey(cmd), null) : null;
+    const wasOn = key && def.isOn ? safe(() => def.isOn(cmd, ctx), false) : false;
+    stack.push(ctx);
+    try {
+        def.run(cmd, ctx);
+    }
+    catch (e) {
+        console.error(`[3drise] triggers: ${cmd.kind} "${subject}" failed`, e);
+    }
+    finally {
+        stack.pop();
+    }
+    logTrigger({ type: 'run', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain, detail: cmd.command });
+    if (!key || !def.isOn)
+        return;
+    const nowOn = safe(() => def.isOn(cmd, ctx), false);
+    if (!wasOn && nowOn) {
+        claims.set(key, ctx.source);
+        logTrigger({ type: 'claim', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain });
+    }
+    else if (wasOn && !nowOn) {
+        const holder = claims.get(key);
+        claims.delete(key);
+        if (holder && !same(holder, ctx.source)) {
+            logTrigger({ type: 'clash', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain, detail: `switched off what ${describeSource(holder)} switched on` });
+        }
+        else {
+            logTrigger({ type: 'release', kind: cmd.kind, subject, source: ctx.source, chain: ctx.chain });
+        }
+    }
+}
+/**
+ * Record a clash the engine didn't run itself — e.g. a sequence cue that leaves an
+ * action alone because another source applied it.
+ */
+export function noteClash(kind, subject, source, detail, claimKey) {
+    const holder = claimKey ? claims.get(claimKey) : undefined;
+    logTrigger({ type: 'clash', kind, subject, source, chain: currentChain(), detail: holder ? `${detail} (held by ${describeSource(holder)})` : detail });
+}
+/** Forget every claim (the scene left the page). */
+export function resetTriggerClaims() { claims.clear(); }
+function safe(fn, fallback) {
+    try {
+        return fn();
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/triggers/hosts/actions.d.ts

@@ -0,0 +1,8 @@
+import type { ActionSequence, OperationEffect, SceneCommand } from '@3driseai/3drise-core';
+/** An action's commands, in the order they run. */
+export declare const actionCommandsOf: (action: Partial<ActionSequence> | null | undefined) => SceneCommand[];
+/** The effects among an action's commands (to pre-warm their shaders). */
+export declare const actionEffectsOf: (action: Partial<ActionSequence> | null | undefined) => OperationEffect[];
+/** Switch an action's commands on (apply) or off (revert). */
+export declare function runActionCommands(action: ActionSequence, mode: 'apply' | 'revert'): void;
+//# sourceMappingURL=actions.d.ts.map

package/dist/triggers/hosts/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/triggers/hosts/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG3F,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,YAAY,EACrC,CAAC;AAE9D,0EAA0E;AAC1E,eAAO,MAAM,eAAe,GAAI,QAAQ,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,eAAe,EAClB,CAAC;AAEnF,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAUxF"}

package/dist/triggers/hosts/actions.js

@@ -0,0 +1,22 @@
+import { runCommand } from '../engine.js';
+/** An action's commands, in the order they run. */
+export const actionCommandsOf = (action) => (Array.isArray(action?.commands) ? action.commands : []);
+/** The effects among an action's commands (to pre-warm their shaders). */
+export const actionEffectsOf = (action) => actionCommandsOf(action).flatMap(c => (c.kind === 'effect' ? [c.effect] : []));
+/** Switch an action's commands on (apply) or off (revert). */
+export function runActionCommands(action, mode) {
+    const source = { host: 'action', id: action.id };
+    const list = actionCommandsOf(action);
+    for (const c of mode === 'revert' ? [...list].reverse() : list) {
+        if (c.kind === 'effect')
+            runCommand({ ...c, command: mode }, { source });
+        else if (c.kind === 'effectClip')
+            runCommand({ ...c, command: mode }, { source });
+        else if (c.kind === 'action')
+            runCommand({ ...c, command: mode }, { source });
+        else if (mode === 'apply')
+            runCommand(c, { source });
+        else if (c.command === 'play' || c.command === 'toggle')
+            runCommand({ ...c, command: 'stop', options: undefined }, { source });
+    }
+}

package/dist/triggers/hosts/interactions.d.ts

@@ -0,0 +1,6 @@
+import type { Interaction, SceneCommand } from '@3driseai/3drise-core';
+/** An interaction's commands, in the order they run. */
+export declare const commandsOf: (interaction: Partial<Interaction> | null | undefined) => SceneCommand[];
+/** The effects among an interaction's commands (to pre-warm their shaders). */
+export declare const effectsOf: (interaction: Partial<Interaction> | null | undefined) => import("@3driseai/3drise-core").OperationEffect[];
+//# sourceMappingURL=interactions.d.ts.map

package/dist/triggers/hosts/interactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactions.d.ts","sourceRoot":"","sources":["../../../src/triggers/hosts/interactions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEvE,wDAAwD;AACxD,eAAO,MAAM,UAAU,GAAI,aAAa,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,YAAY,EACvB,CAAC;AAExE,+EAA+E;AAC/E,eAAO,MAAM,SAAS,GAAI,aAAa,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,GAAG,SAAS,sDACG,CAAC"}

package/dist/triggers/hosts/interactions.js

@@ -0,0 +1,4 @@
+/** An interaction's commands, in the order they run. */
+export const commandsOf = (interaction) => (Array.isArray(interaction?.commands) ? interaction.commands : []);
+/** The effects among an interaction's commands (to pre-warm their shaders). */
+export const effectsOf = (interaction) => commandsOf(interaction).flatMap(c => (c.kind === 'effect' ? [c.effect] : []));

package/dist/triggers/hosts/timelineCues.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=timelineCues.d.ts.map

package/dist/triggers/hosts/timelineCues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timelineCues.d.ts","sourceRoot":"","sources":["../../../src/triggers/hosts/timelineCues.ts"],"names":[],"mappings":""}

package/dist/triggers/hosts/timelineCues.js

@@ -0,0 +1,22 @@
+// Trigger host: clip and sequence cues. ClipsRuntime decides WHEN (lane state at the
+// playhead, or a forward crossing for fire cues); the switch itself runs through the
+// engine with the timeline as its source. A timeline can't start a timeline — the engine
+// refuses animation commands from here (and the UI doesn't offer them).
+import ClipsRuntime from '../../animationsV2/ClipsRuntime.js';
+import { isCommandOn, noteClash, runCommand } from '../engine.js';
+import { getTriggerable } from '../registry.js';
+ClipsRuntime.setCueRunner((cmd, mode, { effects, host, timelineId, getAction }) => {
+    const source = { host, id: timelineId };
+    const catalog = getAction ? { action: getAction } : undefined;
+    if (mode === 'apply' && isCommandOn(cmd)) {
+        const def = getTriggerable(cmd.kind);
+        noteClash(cmd.kind, def ? def.subject(cmd) : '', source, 'a cue wanted it on but it was already on — left alone (the timeline will not switch it off)', def?.claimKey ? (def.claimKey(cmd) ?? undefined) : undefined);
+        return false;
+    }
+    // fire: one-shot — an effect plays (apply), anything else runs its own command
+    const run = mode === 'fire'
+        ? (cmd.kind === 'effect' ? { ...cmd, command: 'apply' } : cmd)
+        : cmd.kind === 'effect' || cmd.kind === 'effectClip' || cmd.kind === 'action' ? { ...cmd, command: mode } : cmd;
+    runCommand(run, { source, chain: [], effects, ...(catalog ? { catalog } : {}) });
+    return true;
+});

package/dist/triggers/index.d.ts

@@ -0,0 +1,13 @@
+import './kinds';
+import './hosts/timelineCues';
+export { commandsOf, effectsOf } from './hosts/interactions';
+export { actionCommandsOf, actionEffectsOf, runActionCommands } from './hosts/actions';
+export { runCommand, canTrigger, isCommandOn, registerTriggerCatalog, currentChain, claimHolder, noteClash, resetTriggerClaims } from './engine';
+export type { TriggerCatalog, RunOptions as RunCommandOptions, RunResult as RunCommandResult } from './engine';
+export { defineTriggerable, getTriggerable, triggerableKinds } from './registry';
+export type { Triggerable, TriggerContext } from './registry';
+export { getTriggerLog, onTriggerLog, clearTriggerLog } from './log';
+export type { TriggerLogEntry, TriggerLogType } from './log';
+export { sceneReadiness, useSceneReady } from './readiness';
+export type { SceneReadinessStatus } from './readiness';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/triggers/index.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,CAAC;AACjB,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEvF,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,sBAAsB,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AACjJ,YAAY,EAAE,cAAc,EAAE,UAAU,IAAI,iBAAiB,EAAE,SAAS,IAAI,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC/G,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACjF,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AACrE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5D,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC"}

package/dist/triggers/index.js

@@ -0,0 +1,9 @@
+// The triggers engine (see engine.ts and the project doc claude/triggers-engine-plan.md).
+import './kinds/index.js';
+import './hosts/timelineCues.js';
+export { commandsOf, effectsOf } from './hosts/interactions.js';
+export { actionCommandsOf, actionEffectsOf, runActionCommands } from './hosts/actions.js';
+export { runCommand, canTrigger, isCommandOn, registerTriggerCatalog, currentChain, claimHolder, noteClash, resetTriggerClaims } from './engine.js';
+export { defineTriggerable, getTriggerable, triggerableKinds } from './registry.js';
+export { getTriggerLog, onTriggerLog, clearTriggerLog } from './log.js';
+export { sceneReadiness, useSceneReady } from './readiness.js';

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=action.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/action.ts"],"names":[],"mappings":""}

package/dist/triggers/kinds/action.js

@@ -0,0 +1,31 @@
+// Triggerable: an action (SceneActions). Its own effects then run through the engine
+// too (operations/runtime runActionEffects), with this command's chain.
+import { SceneActions } from '@3driseai/3drise-core';
+import { defineTriggerable } from '../registry.js';
+defineTriggerable({
+    kind: 'action',
+    commands: ['apply', 'revert', 'toggle'],
+    timeline: 'state',
+    subject: (c) => c.ref,
+    claimKey: (c) => `action:${c.ref}`,
+    isOn: (c) => SceneActions.isActionApplied(c.ref),
+    run: (c, ctx) => {
+        const action = ctx.catalog?.action?.(c.ref);
+        if (!action) {
+            // not in this scene's list: revert by id still works (it was applied with its definition)
+            if (c.command === 'revert' || (c.command === 'toggle' && SceneActions.isActionApplied(c.ref)))
+                SceneActions.revertAction(c.ref);
+            return;
+        }
+        if (c.command === 'revert')
+            SceneActions.revertAction(action);
+        else if (c.command === 'toggle') {
+            if (SceneActions.isActionApplied(action.id))
+                SceneActions.revertAction(action.id);
+            else
+                SceneActions.applyAction(action, { effects: ctx.effects !== false });
+        }
+        else
+            SceneActions.applyAction(action, { effects: ctx.effects !== false });
+    },
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=animations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animations.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/animations.ts"],"names":[],"mappings":""}

package/dist/triggers/kinds/animations.js

@@ -0,0 +1,75 @@
+// Triggerables: an animation clip and an animation sequence (ClipsRuntime).
+// The interaction semantics moved here unchanged:
+//   play    resume when paused part-way, else from the start (a sequence: from the start edge of its direction)
+//   toggle  forward, then back, … (back = the opposite of a sequence's own reverse)
+//   pause / stop
+// A command with `options` (code: from / speed / reverse) plays exactly with those.
+import ClipsRuntime from '../../animationsV2/ClipsRuntime.js';
+import { clipMap } from '../../animationsV2/sequenceUtils.js';
+import { defineTriggerable } from '../registry.js';
+/** Animation ids whose last toggle went forward. */
+const toggled = new Set();
+const nextIsBack = (key) => {
+    const back = toggled.has(key);
+    if (back)
+        toggled.delete(key);
+    else
+        toggled.add(key);
+    return back;
+};
+defineTriggerable({
+    kind: 'animationClip',
+    commands: ['play', 'pause', 'stop', 'toggle'],
+    timeline: 'event',
+    isTimeline: true,
+    subject: (c) => c.ref,
+    run: (c, ctx) => {
+        const clip = ctx.catalog?.clip?.(c.ref);
+        if (!clip)
+            return;
+        if (c.command === 'pause')
+            ClipsRuntime.pause(clip.id);
+        else if (c.command === 'stop')
+            ClipsRuntime.stop(clip.id);
+        else if (c.command === 'toggle')
+            ClipsRuntime.play(clip, { reverse: nextIsBack(`clip:${clip.id}`) });
+        else if (c.options)
+            ClipsRuntime.play(clip, c.options);
+        else if (ClipsRuntime.isActive(clip.id) && !ClipsRuntime.isPlaying(clip.id) && ClipsRuntime.getTime(clip.id) < clip.duration)
+            ClipsRuntime.resume(clip.id);
+        else
+            ClipsRuntime.play(clip, { from: 0 });
+    },
+});
+defineTriggerable({
+    kind: 'animationSequence',
+    commands: ['play', 'pause', 'stop', 'toggle'],
+    timeline: 'event',
+    isTimeline: true,
+    subject: (c) => c.ref,
+    run: (c, ctx) => {
+        const cat = ctx.catalog;
+        const seq = cat?.sequence?.(c.ref);
+        if (!seq)
+            return;
+        const clips = cat?.clips?.() ?? clipMap([]);
+        if (c.command === 'pause')
+            ClipsRuntime.pauseSequence(seq.id);
+        else if (c.command === 'stop')
+            ClipsRuntime.stopSequence(seq.id);
+        else if (c.command === 'toggle') {
+            const back = nextIsBack(`seq:${seq.id}`);
+            ClipsRuntime.playSequence(seq, clips, { reverse: back ? !seq.reverse : seq.reverse });
+        }
+        else if (c.options) {
+            ClipsRuntime.playSequence(seq, clips, c.options);
+        }
+        else if (ClipsRuntime.isSequenceActive(seq.id) && !ClipsRuntime.isSequencePlaying(seq.id) && ClipsRuntime.getSequenceProgress(seq.id) < 1) {
+            ClipsRuntime.resumeSequence(seq.id);
+        }
+        else {
+            const total = ClipsRuntime.getSequenceDuration(seq.id);
+            ClipsRuntime.playSequence(seq, clips, { from: seq.reverse && total > 0 ? total : 0 });
+        }
+    },
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=effects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effects.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/effects.ts"],"names":[],"mappings":""}