@holoscript/core 8.0.7 → 8.0.9

package/dist/chunk-3ILD7TKP.cjs

@@ -0,0 +1,187 @@
+'use strict';
+
+// src/traits/KinematicChainTrait.ts
+function mat4Identity() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function dhTransform(a, alpha, d, theta) {
+  const ct = Math.cos(theta);
+  const st = Math.sin(theta);
+  const ca = Math.cos(alpha);
+  const sa = Math.sin(alpha);
+  return [
+    ct,
+    -st * ca,
+    st * sa,
+    a * ct,
+    st,
+    ct * ca,
+    -ct * sa,
+    a * st,
+    0,
+    sa,
+    ca,
+    d,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function mat4Mul(a, b) {
+  const r = new Array(16).fill(0);
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      for (let k = 0; k < 4; k++) {
+        r[i * 4 + j] += a[i * 4 + k] * b[k * 4 + j];
+      }
+    }
+  }
+  return r;
+}
+function extractFrame(T) {
+  return {
+    z: { x: T[2], y: T[6], z: T[10] },
+    p: { x: T[3], y: T[7], z: T[11] }
+  };
+}
+function computeAllFrames(links, q) {
+  const frames = [];
+  let T = mat4Identity();
+  frames.push(extractFrame(T));
+  for (let i = 0; i < links.length; i++) {
+    const { a, alpha, d, theta: off } = links[i];
+    T = mat4Mul(T, dhTransform(a, alpha, d, off + q[i]));
+    frames.push(extractFrame(T));
+  }
+  return frames;
+}
+function solve3x3(A, b) {
+  const a = A.map((row) => [...row]);
+  const x = [...b];
+  for (let k = 0; k < 3; k++) {
+    let maxVal = Math.abs(a[k][k]);
+    let maxRow = k;
+    for (let i = k + 1; i < 3; i++) {
+      if (Math.abs(a[i][k]) > maxVal) {
+        maxVal = Math.abs(a[i][k]);
+        maxRow = i;
+      }
+    }
+    [a[k], a[maxRow]] = [a[maxRow], a[k]];
+    [x[k], x[maxRow]] = [x[maxRow], x[k]];
+    for (let i = k + 1; i < 3; i++) {
+      if (Math.abs(a[k][k]) < 1e-12) continue;
+      const f = a[i][k] / a[k][k];
+      for (let j = k; j < 3; j++) a[i][j] -= f * a[k][j];
+      x[i] -= f * x[k];
+    }
+  }
+  const result = [0, 0, 0];
+  for (let i = 2; i >= 0; i--) {
+    if (Math.abs(a[i][i]) < 1e-12) {
+      result[i] = 0;
+      continue;
+    }
+    result[i] = x[i];
+    for (let j = i + 1; j < 3; j++) result[i] -= a[i][j] * result[j];
+    result[i] /= a[i][i];
+  }
+  return result;
+}
+function solveFk(links, jointAngles) {
+  const frameTransforms = [];
+  let T = mat4Identity();
+  for (let i = 0; i < links.length; i++) {
+    const { a, alpha, d, theta: off } = links[i];
+    T = mat4Mul(T, dhTransform(a, alpha, d, off + jointAngles[i]));
+    frameTransforms.push([...T]);
+  }
+  return {
+    endEffectorPosition: { x: T[3], y: T[7], z: T[11] },
+    endEffectorTransform: T,
+    frameTransforms
+  };
+}
+function solveIk(req) {
+  const { links, target, maxIterations = 100, tolerance = 1e-4, damping = 0.01 } = req;
+  const n = links.length;
+  const q = [...req.initialAngles ?? new Array(n).fill(0)];
+  const lam2 = damping * damping;
+  for (let iter = 0; iter < maxIterations; iter++) {
+    const frames = computeAllFrames(links, q);
+    const ee = frames[n].p;
+    const dx = target.x - ee.x;
+    const dy = target.y - ee.y;
+    const dz = target.z - ee.z;
+    const error = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (error < tolerance) {
+      return { jointAngles: [...q], converged: true, finalError: error, iterations: iter };
+    }
+    const J = [
+      new Array(n).fill(0),
+      new Array(n).fill(0),
+      new Array(n).fill(0)
+    ];
+    for (let j = 0; j < n; j++) {
+      const { z, p } = frames[j];
+      const dpx = ee.x - p.x;
+      const dpy = ee.y - p.y;
+      const dpz = ee.z - p.z;
+      J[0][j] = z.y * dpz - z.z * dpy;
+      J[1][j] = z.z * dpx - z.x * dpz;
+      J[2][j] = z.x * dpy - z.y * dpx;
+    }
+    const JJT = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    for (let r = 0; r < 3; r++) {
+      for (let c = 0; c < 3; c++) {
+        for (let j = 0; j < n; j++) JJT[r][c] += J[r][j] * J[c][j];
+      }
+    }
+    for (let i = 0; i < 3; i++) JJT[i][i] += lam2;
+    const y = solve3x3(JJT, [dx, dy, dz]);
+    for (let j = 0; j < n; j++) {
+      q[j] += J[0][j] * y[0] + J[1][j] * y[1] + J[2][j] * y[2];
+    }
+  }
+  const finalEe = computeAllFrames(links, q)[n].p;
+  const finalError = Math.sqrt(
+    (target.x - finalEe.x) ** 2 + (target.y - finalEe.y) ** 2 + (target.z - finalEe.z) ** 2
+  );
+  return { jointAngles: [...q], converged: false, finalError, iterations: maxIterations };
+}
+var kinematicChainHandler = {
+  name: "kinematic_chain",
+  defaultConfig: { links: [], jointAngles: [] },
+  onAttach(node, config) {
+    if (config.links.length > 0 && config.jointAngles.length === config.links.length) {
+      node.__kinematic_fk = solveFk(config.links, config.jointAngles);
+    }
+  },
+  onEvent(node, config, _ctx, event) {
+    if (event.type === "kinematic_chain.solve_fk") {
+      const e = event;
+      const links = e.links ?? config.links;
+      const angles = e.jointAngles ?? config.jointAngles;
+      node.__kinematic_fk = solveFk(links, angles);
+    }
+    if (event.type === "kinematic_chain.solve_ik") {
+      const req = event;
+      node.__kinematic_ik = solveIk({
+        links: req.links ?? config.links,
+        target: req.target ?? { x: 0, y: 0, z: 0 },
+        initialAngles: req.initialAngles,
+        maxIterations: req.maxIterations,
+        tolerance: req.tolerance,
+        damping: req.damping
+      });
+    }
+  }
+};
+
+exports.dhTransform = dhTransform;
+exports.kinematicChainHandler = kinematicChainHandler;
+exports.solveFk = solveFk;
+exports.solveIk = solveIk;
+//# sourceMappingURL=chunk-3ILD7TKP.cjs.map
+//# sourceMappingURL=chunk-3ILD7TKP.cjs.map

package/dist/{chunk-X27QRG4C.cjs → chunk-3IUHTGDD.cjs}

@@ -1,13 +1,45 @@
 'use strict';
 
-var chunkGH6C2QGW_cjs = require('./chunk-GH6C2QGW.cjs');
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkQEDMOGF3_cjs = require('./chunk-QEDMOGF3.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var ans = require('@holoscript/core-types/ans');
 
+// src/compiler/udon/udon-extern-manifest.ts
+var UDON_RETURN_ADDRESS;
+var init_udon_extern_manifest = chunkZHPMP447_cjs.__esm({
+  "src/compiler/udon/udon-extern-manifest.ts"() {
+    UDON_RETURN_ADDRESS = "0xFFFFFFFF";
+  }
+});
+
+// src/compiler/udon/udon-assembly.ts
+function renderUdonAssembly(program) {
+  const lines = [];
+  lines.push(".data_start");
+  for (const v of program.heap) {
+    lines.push(`${INDENT}${v.name}: %${v.type}, ${v.init}`);
+  }
+  lines.push(".data_end");
+  lines.push("");
+  lines.push(".code_start");
+  for (const c of program.code) {
+    lines.push(`${INDENT}${c}`);
+  }
+  lines.push(".code_end");
+  lines.push("");
+  return lines.join("\n");
+}
+var INDENT;
+var init_udon_assembly = chunkZHPMP447_cjs.__esm({
+  "src/compiler/udon/udon-assembly.ts"() {
+    INDENT = "    ";
+  }
+});
+
 // src/compiler/VRChatCompiler.ts
 var VRChatCompiler_exports = {};
-chunkHCCQLAA4_cjs.__export(VRChatCompiler_exports, {
+chunkZHPMP447_cjs.__export(VRChatCompiler_exports, {
   VRChatCompiler: () => exports.VRChatCompiler,
   compileToVRChat: () => compileToVRChat
 });
@@ -16,11 +48,13 @@ function compileToVRChat(composition, options) {
   return Promise.resolve(compiler.compile(composition, ""));
 }
 exports.VRChatCompiler = void 0;
-var init_VRChatCompiler = chunkHCCQLAA4_cjs.__esm({
+var init_VRChatCompiler = chunkZHPMP447_cjs.__esm({
   "src/compiler/VRChatCompiler.ts"() {
-    chunkLODTHGST_cjs.init_CompilerBase();
-    chunkGH6C2QGW_cjs.init_DomainBlockCompilerMixin();
-    exports.VRChatCompiler = class extends chunkLODTHGST_cjs.CompilerBase {
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    init_udon_assembly();
+    init_udon_extern_manifest();
+    chunkQEDMOGF3_cjs.init_DomainBlockCompilerMixin();
+    exports.VRChatCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "VRChatCompiler";
@@ -46,6 +80,9 @@ var init_VRChatCompiler = chunkHCCQLAA4_cjs.__esm({
       }
       compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
+        if (this.options.outputFormat === "udon-assembly") {
+          return this.compileToUdonAssembly(composition);
+        }
         this.assertSupportedOutputFormat();
         this.lines = [];
         this.udonScripts.clear();
@@ -63,6 +100,81 @@ var init_VRChatCompiler = chunkHCCQLAA4_cjs.__esm({
           worldDescriptor
         };
       }
+      /**
+       * Byte target codegen — `.holo` → Udon Assembly. Phase-2 vertical slice scope:
+       * `@clickable`/`@pointable` objects lower to an `_interact` toggle behaviour; every
+       * world emits a trivial `_start`. Other traits (grabbable/networked/portal/mirror) are
+       * NOT yet lowered to UASM — they intentionally produce no behaviour here rather than a
+       * silently-fake one (see roadmap Phase 2 breadth). Output is validated offline by
+       * `validateUdonAssembly` against the EXTERN manifest.
+       */
+      compileToUdonAssembly(composition) {
+        const className = this.options.className;
+        const udonAssembly = {};
+        const mainUasm = this.generateMainUdonAssembly();
+        udonAssembly[`${className}.uasm`] = mainUasm;
+        for (const obj of composition.objects || []) {
+          const isClickable = obj.traits?.some(
+            (t) => t.name === "pointable" || t.name === "clickable"
+          );
+          if (isClickable) {
+            udonAssembly[`${this.sanitizeName(obj.name)}Behaviour.uasm`] = this.generateClickableToggleAssembly(obj);
+          }
+        }
+        return {
+          outputFormat: "udon-assembly",
+          mainScript: mainUasm,
+          udonScripts: /* @__PURE__ */ new Map(),
+          prefabHierarchy: this.generatePrefabHierarchy(composition),
+          worldDescriptor: this.generateWorldDescriptor(composition),
+          udonAssembly
+        };
+      }
+      /** Trivial world-init behaviour: an exported `_start` that returns immediately. */
+      generateMainUdonAssembly() {
+        const program = {
+          heap: [],
+          code: [".export _start", "_start:", `JUMP, ${UDON_RETURN_ADDRESS}`]
+        };
+        return renderUdonAssembly(program);
+      }
+      /**
+       * `@clickable` → toggle the object's active state on Interact, using only real,
+       * manifest-resolvable Udon nodes (get_activeSelf + SetActive) and control flow —
+       * no invented "boolean-negation" node. The target is a null-initialised GameObject
+       * slot wired in the Unity inspector at bundle time (Phase 3), avoiding the
+       * self-disable footgun of toggling the behaviour's own GameObject.
+       */
+      generateClickableToggleAssembly(obj) {
+        const target = `${this.sanitizeName(obj.name)}Target`;
+        const program = {
+          heap: [
+            { name: target, type: "UnityEngineGameObject", init: "null" },
+            { name: "isActive", type: "SystemBoolean", init: "null" },
+            { name: "constTrue", type: "SystemBoolean", init: "true" },
+            { name: "constFalse", type: "SystemBoolean", init: "false" }
+          ],
+          code: [
+            ".export _interact",
+            "_interact:",
+            `PUSH, ${target}`,
+            "PUSH, isActive",
+            'EXTERN, "UnityEngineGameObject.__get_activeSelf__SystemBoolean"',
+            "PUSH, isActive",
+            "JUMP_IF_FALSE, _activate",
+            `PUSH, ${target}`,
+            "PUSH, constFalse",
+            'EXTERN, "UnityEngineGameObject.__SetActive__SystemBoolean__SystemVoid"',
+            `JUMP, ${UDON_RETURN_ADDRESS}`,
+            "_activate:",
+            `PUSH, ${target}`,
+            "PUSH, constTrue",
+            'EXTERN, "UnityEngineGameObject.__SetActive__SystemBoolean__SystemVoid"',
+            `JUMP, ${UDON_RETURN_ADDRESS}`
+          ]
+        };
+        return renderUdonAssembly(program);
+      }
       assertSupportedOutputFormat() {
         if (this.options.outputFormat === "udonsharp-csharp" && this.options.useUdonSharp) {
           return;
@@ -185,59 +297,59 @@ var init_VRChatCompiler = chunkHCCQLAA4_cjs.__esm({
         this.emit("");
         this.emit("// === v4.2 Domain Blocks (VRChat/Unity) ===");
         let blockIdx = 0;
-        const compiled = chunkGH6C2QGW_cjs.compileDomainBlocks(
+        const compiled = chunkQEDMOGF3_cjs.compileDomainBlocks(
           domainBlocks,
           {
             material: (block) => {
-              const mat = chunkGH6C2QGW_cjs.compileMaterialBlock(block);
-              return chunkGH6C2QGW_cjs.materialToVRChat(mat, `db${blockIdx++}`);
+              const mat = chunkQEDMOGF3_cjs.compileMaterialBlock(block);
+              return chunkQEDMOGF3_cjs.materialToVRChat(mat, `db${blockIdx++}`);
             },
             physics: (block) => {
-              const phys = chunkGH6C2QGW_cjs.compilePhysicsBlock(block);
-              return chunkGH6C2QGW_cjs.physicsToUnity(phys, `db${blockIdx++}`);
+              const phys = chunkQEDMOGF3_cjs.compilePhysicsBlock(block);
+              return chunkQEDMOGF3_cjs.physicsToUnity(phys, `db${blockIdx++}`);
             },
             vfx: (block) => {
-              const ps = chunkGH6C2QGW_cjs.compileParticleBlock(block);
-              return chunkGH6C2QGW_cjs.particlesToUnity(ps, `db${blockIdx++}`);
+              const ps = chunkQEDMOGF3_cjs.compileParticleBlock(block);
+              return chunkQEDMOGF3_cjs.particlesToUnity(ps, `db${blockIdx++}`);
             },
             postfx: (block) => {
-              const pp = chunkGH6C2QGW_cjs.compilePostProcessingBlock(block);
-              return chunkGH6C2QGW_cjs.postProcessingToUnity(pp);
+              const pp = chunkQEDMOGF3_cjs.compilePostProcessingBlock(block);
+              return chunkQEDMOGF3_cjs.postProcessingToUnity(pp);
             },
             audio: (block) => {
-              const audio = chunkGH6C2QGW_cjs.compileAudioSourceBlock(block);
-              return chunkGH6C2QGW_cjs.audioSourceToUnity(audio, `db${blockIdx++}`);
+              const audio = chunkQEDMOGF3_cjs.compileAudioSourceBlock(block);
+              return chunkQEDMOGF3_cjs.audioSourceToUnity(audio, `db${blockIdx++}`);
             },
             weather: (block) => {
-              const weather = chunkGH6C2QGW_cjs.compileWeatherBlock(block);
-              return chunkGH6C2QGW_cjs.weatherToUnity(weather);
+              const weather = chunkQEDMOGF3_cjs.compileWeatherBlock(block);
+              return chunkQEDMOGF3_cjs.weatherToUnity(weather);
             },
             narrative: (block) => {
-              const narr = chunkGH6C2QGW_cjs.compileNarrativeBlock(block);
-              return chunkGH6C2QGW_cjs.narrativeToVRChat(narr);
+              const narr = chunkQEDMOGF3_cjs.compileNarrativeBlock(block);
+              return chunkQEDMOGF3_cjs.narrativeToVRChat(narr);
             },
             payment: (block) => {
-              const pay = chunkGH6C2QGW_cjs.compilePaymentBlock(block);
-              return chunkGH6C2QGW_cjs.paymentToVRChat(pay);
+              const pay = chunkQEDMOGF3_cjs.compilePaymentBlock(block);
+              return chunkQEDMOGF3_cjs.paymentToVRChat(pay);
             },
             healthcare: (block) => {
-              const h = chunkGH6C2QGW_cjs.compileHealthcareBlock(block);
-              return chunkGH6C2QGW_cjs.healthcareToVRChat(h);
+              const h = chunkQEDMOGF3_cjs.compileHealthcareBlock(block);
+              return chunkQEDMOGF3_cjs.healthcareToVRChat(h);
             },
             robotics: (block) => {
-              const r = chunkGH6C2QGW_cjs.compileRoboticsBlock(block);
-              return chunkGH6C2QGW_cjs.roboticsToVRChat(r);
+              const r = chunkQEDMOGF3_cjs.compileRoboticsBlock(block);
+              return chunkQEDMOGF3_cjs.roboticsToVRChat(r);
             },
-            iot: (block) => chunkGH6C2QGW_cjs.iotToVRChat(chunkGH6C2QGW_cjs.compileIoTBlock(block)),
-            dataviz: (block) => chunkGH6C2QGW_cjs.datavizToVRChat(chunkGH6C2QGW_cjs.compileDataVizBlock(block)),
-            education: (block) => chunkGH6C2QGW_cjs.educationToVRChat(chunkGH6C2QGW_cjs.compileEducationBlock(block)),
-            music: (block) => chunkGH6C2QGW_cjs.musicToVRChat(chunkGH6C2QGW_cjs.compileMusicBlock(block)),
-            architecture: (block) => chunkGH6C2QGW_cjs.architectureToVRChat(chunkGH6C2QGW_cjs.compileArchitectureBlock(block)),
-            web3: (block) => chunkGH6C2QGW_cjs.web3ToVRChat(chunkGH6C2QGW_cjs.compileWeb3Block(block)),
-            procedural: (block) => chunkGH6C2QGW_cjs.proceduralToVRChat(chunkGH6C2QGW_cjs.compileProceduralBlock(block)),
-            rendering: (block) => chunkGH6C2QGW_cjs.renderingToVRChat(chunkGH6C2QGW_cjs.compileRenderingBlock(block)),
-            navigation: (block) => chunkGH6C2QGW_cjs.navigationToVRChat(chunkGH6C2QGW_cjs.compileNavigationBlock(block)),
-            input: (block) => chunkGH6C2QGW_cjs.inputToVRChat(chunkGH6C2QGW_cjs.compileInputBlock(block))
+            iot: (block) => chunkQEDMOGF3_cjs.iotToVRChat(chunkQEDMOGF3_cjs.compileIoTBlock(block)),
+            dataviz: (block) => chunkQEDMOGF3_cjs.datavizToVRChat(chunkQEDMOGF3_cjs.compileDataVizBlock(block)),
+            education: (block) => chunkQEDMOGF3_cjs.educationToVRChat(chunkQEDMOGF3_cjs.compileEducationBlock(block)),
+            music: (block) => chunkQEDMOGF3_cjs.musicToVRChat(chunkQEDMOGF3_cjs.compileMusicBlock(block)),
+            architecture: (block) => chunkQEDMOGF3_cjs.architectureToVRChat(chunkQEDMOGF3_cjs.compileArchitectureBlock(block)),
+            web3: (block) => chunkQEDMOGF3_cjs.web3ToVRChat(chunkQEDMOGF3_cjs.compileWeb3Block(block)),
+            procedural: (block) => chunkQEDMOGF3_cjs.proceduralToVRChat(chunkQEDMOGF3_cjs.compileProceduralBlock(block)),
+            rendering: (block) => chunkQEDMOGF3_cjs.renderingToVRChat(chunkQEDMOGF3_cjs.compileRenderingBlock(block)),
+            navigation: (block) => chunkQEDMOGF3_cjs.navigationToVRChat(chunkQEDMOGF3_cjs.compileNavigationBlock(block)),
+            input: (block) => chunkQEDMOGF3_cjs.inputToVRChat(chunkQEDMOGF3_cjs.compileInputBlock(block))
           },
           (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "CSharp")}"`
         );
@@ -623,5 +735,5 @@ var init_VRChatCompiler = chunkHCCQLAA4_cjs.__esm({
 exports.VRChatCompiler_exports = VRChatCompiler_exports;
 exports.compileToVRChat = compileToVRChat;
 exports.init_VRChatCompiler = init_VRChatCompiler;
-//# sourceMappingURL=chunk-X27QRG4C.cjs.map
-//# sourceMappingURL=chunk-X27QRG4C.cjs.map
+//# sourceMappingURL=chunk-3IUHTGDD.cjs.map
+//# sourceMappingURL=chunk-3IUHTGDD.cjs.map

package/dist/{chunk-PXNZ6TME.js → chunk-4376VHNJ.js}

@@ -1,9 +1,10 @@
 import { ReactiveState, ExpressionEvaluator, createState } from './chunk-XL6INWKT.js';
-import { lazyPeerSymbol, definePeerNamespace, getSharedEventBus, telemetry } from './chunk-IELX2OKI.js';
-import { HoloScriptCodeParser } from './chunk-MDR235RZ.js';
-import { JEPAPredictor, jepObjectiveHandler, mitosisHandler, orbitalHandler } from './chunk-TVANHNJ7.js';
+import { coronaSimulationHandler } from './chunk-D3HSRXYB.js';
+import { lazyPeerSymbol, definePeerNamespace, telemetry } from './chunk-H4LJ4HEA.js';
+import { HoloScriptCodeParser } from './chunk-734OB5SK.js';
+import { JEPAPredictor, jepObjectiveHandler, mitosisHandler, orbitalHandler, getSharedEventBus, applyEasing } from './chunk-IK6Z2HNC.js';
 import { logger } from './chunk-PHENW4MQ.js';
-import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
+import { init_safeJsonParse, readJson } from './chunk-RAN3ECAS.js';
 
 // src/HoloScriptRuntime.ts
 init_safeJsonParse();
@@ -278,27 +279,6 @@ async function applyTransformation(data, transform, ctx) {
   }
 }
 
-// src/runtime/easing.ts
-function applyEasing(t, easing) {
-  switch (easing) {
-    case "easeIn":
-      return t * t;
-    case "easeOut":
-      return t * (2 - t);
-    case "easeInOut":
-      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-    case "easeInQuad":
-      return t * t;
-    case "easeOutQuad":
-      return t * (2 - t);
-    case "easeInOutQuad":
-      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-    case "linear":
-    default:
-      return t;
-  }
-}
-
 // src/runtime/animation-system.ts
 function updateAnimations(animations, setVariable, now) {
   for (const [key, anim] of animations) {
@@ -1493,13 +1473,24 @@ function updateTraits(julianDate, ctx) {
           d.config || {},
           {
             emit: (event, payload) => {
-              if (event === "position_update") {
+              if (event === "position_update" || event === "set_position") {
                 const posPayload = payload;
                 if (posPayload?.position) {
                   const p = posPayload.position;
                   const tuple = Array.isArray(p) ? p : [p[0], p[1], p[2]];
                   ctx.setOrbPosition(name, tuple);
                 }
+              } else if (event === "set_rotation") {
+                const rotPayload = payload;
+                if (rotPayload?.rotation) {
+                  const r = rotPayload.rotation;
+                  const tuple = Array.isArray(r) ? r : [r[0], r[1], r[2]];
+                  if (ctx.setOrbRotation) {
+                    ctx.setOrbRotation(name, tuple);
+                  } else {
+                    orb.rotation = tuple;
+                  }
+                }
               }
               return ctx.emit(event, payload);
             },
@@ -2452,6 +2443,7 @@ var HoloScriptAgentRuntime = class _HoloScriptAgentRuntime {
     this.rawEpisodes = [];
     this.semanticFacts = [];
     this.consolidationInterval = null;
+    this.consolidating = false;
     // JEPA action-planning loop (Phase 8)
     // Default latentDim=64, condDim=16 (action conditioning). Caller can swap
     // weights externally via this.jepaPredictor.setWeights() after training.
@@ -2557,7 +2549,7 @@ var HoloScriptAgentRuntime = class _HoloScriptAgentRuntime {
       state: this.localState.getSnapshot(),
       properties: this.agentNode.properties});
     if (!this.consolidationInterval) {
-      this.consolidationInterval = setInterval(() => this.consolidateMemory(), 3e4);
+      this.consolidationInterval = setInterval(() => void this.consolidateMemory(), 3e4);
     }
   }
   /**
@@ -2584,14 +2576,22 @@ var HoloScriptAgentRuntime = class _HoloScriptAgentRuntime {
   /**
    * Internal idle tick leveraging the MemoryConsolidator subsystem to offload processing constraints.
    */
-  consolidateMemory() {
-    if (this.isDestroyed || this.rawEpisodes.length < 5) return;
-    const { newFacts, prunedEpisodes } = MemoryConsolidator.compressEpisodes(this.rawEpisodes);
-    if (newFacts.length > 0) {
-      this.semanticFacts.push(...newFacts);
-      this.rawEpisodes = this.rawEpisodes.filter((e) => !prunedEpisodes.includes(e.id));
+  async consolidateMemory() {
+    if (this.isDestroyed || this.consolidating || this.rawEpisodes.length < 5) return;
+    this.consolidating = true;
+    try {
+      const { newFacts, prunedEpisodes } = await MemoryConsolidator.compressEpisodes(this.rawEpisodes);
+      if (this.isDestroyed) return;
+      if (newFacts.length > 0) {
+        this.semanticFacts.push(...newFacts);
+        this.rawEpisodes = this.rawEpisodes.filter((e) => !prunedEpisodes.includes(e.id));
+      }
+      this.semanticFacts = MemoryConsolidator.pruneStaleFacts(this.semanticFacts);
+    } catch (err) {
+      console.warn("[HoloScriptAgentRuntime] memory consolidation tick failed (non-fatal):", err);
+    } finally {
+      this.consolidating = false;
     }
-    this.semanticFacts = MemoryConsolidator.pruneStaleFacts(this.semanticFacts);
   }
   /**
    * Lazily attach the JEPAObjective trait on first use so constructor stays fast.
@@ -3095,6 +3095,10 @@ var HoloScriptRuntime = class {
     });
     this.traitHandlers.set("mitosis", mitosisHandler);
     this.traitHandlers.set("orbital", orbitalHandler);
+    this.traitHandlers.set(
+      "corona_simulation",
+      coronaSimulationHandler
+    );
     this.extensionRegistry = new ExtensionRegistry(this);
     engineRuntime.stateMachineInterpreter.setHookExecutor((code) => this.evaluateExpression(code));
     engineRuntime.stateMachineInterpreter.setGuardEvaluator(
@@ -4300,6 +4304,25 @@ var HoloScriptRuntime = class {
       });
     }
   }
+  /**
+   * Apply an orb's rotation (euler [x, y, z] in radians) to the scene and
+   * broadcast it — the rotation counterpart of setOrbPosition. Movement traits
+   * (LocomotionTrait snap-turn / look-direction, PatrolTrait look-ahead) emit
+   * `set_rotation`; this lands that output natively so turning is perceivable.
+   */
+  setOrbRotation(orbName, rotation) {
+    const orb = this.context.variables.get(orbName);
+    if (orb && typeof orb === "object" && orb.__type === "orb") {
+      orb.rotation = rotation;
+      this.broadcast("orb_update", {
+        orb: {
+          id: orbName,
+          name: orbName,
+          rotation
+        }
+      });
+    }
+  }
   /**
    * Per-frame trait update — dispatches onUpdate on all active
    * orbs (W1-T4 slice 27: impl extracted to ./runtime/skills-directives).
@@ -4311,6 +4334,7 @@ var HoloScriptRuntime = class {
       emit: (event, payload) => this.emit(event, payload),
       getCurrentScale: () => this.context.currentScale,
       setOrbPosition: (name, position) => this.setOrbPosition(name, position),
+      setOrbRotation: (name, rotation) => this.setOrbRotation(name, rotation),
       getState: () => this.getState(),
       setState: (updates) => this.context.state.update(updates)
     });
@@ -4318,5 +4342,5 @@ var HoloScriptRuntime = class {
 };
 
 export { HoloScriptAgentRuntime, HoloScriptRuntime, TRAIT_OWNER_KEY, registerPluginTraits };
-//# sourceMappingURL=chunk-PXNZ6TME.js.map
-//# sourceMappingURL=chunk-PXNZ6TME.js.map
+//# sourceMappingURL=chunk-4376VHNJ.js.map
+//# sourceMappingURL=chunk-4376VHNJ.js.map