@holoscript/core 8.0.8 → 8.0.10

package/dist/chunk-RAJMAX6D.js

@@ -0,0 +1,131 @@
+// src/keyword-registry/PluginKeywordRegistry.ts
+var NODE_TYPE_FAMILIES = [
+  // ── Existing reaction categories (from ReactionCategory) ──────────────────
+  "movement",
+  // locomotion: move, turn, strafe, jump, land
+  "interaction",
+  // object interaction verbs
+  "collision",
+  // physics collision response
+  "lifecycle",
+  // attach, detach, spawn, destroy
+  "combat",
+  // combat/attack verbs
+  "signal",
+  // event emission verbs
+  // ── H2 additions ─────────────────────────────────────────────────────────
+  "cognitive",
+  // AI/LLM: llm_call, recall, rag_query, plan, reflect
+  "control",
+  // actuate, drive, set_joint, emit_gcode (ControlLoopTrait)
+  "sensor",
+  // measure, read, sample, measure_qubits (robotics/IoT/QM)
+  "transaction"
+  // pay, transfer, stake (x402 economic)
+];
+var PluginKeywordRegistry = class {
+  constructor() {
+    this.table = /* @__PURE__ */ new Map();
+    this._sealed = false;
+    this._registerBuiltins();
+  }
+  _registerBuiltins() {
+    for (const verb of ["move", "turn", "strafe", "jump", "land"]) {
+      this.table.set(verb, { verb, family: "movement", registeredBy: "core" });
+    }
+    for (const verb of ["llm_call", "recall", "rag_query", "plan", "reflect"]) {
+      this.table.set(verb, { verb, family: "cognitive", registeredBy: "core" });
+    }
+  }
+  /**
+   * Register a plugin-supplied verb.
+   *
+   * @param verb      The .hs verb (e.g., `'actuate'`, `'emit_gcode'`). Must be
+   *                  a non-empty string containing only `[a-z0-9_]`.
+   * @param family    Must be a known `NodeTypeFamily`. Conformance gate rejects
+   *                  anything outside the fixed set.
+   * @param pluginId  The registering plugin's manifest id (e.g., `'robotics'`).
+   *
+   * @throws If the registry is sealed, the family is unknown, or the verb is
+   *         already registered by a DIFFERENT plugin (idempotent for same plugin).
+   */
+  register(verb, family, pluginId) {
+    if (this._sealed) {
+      throw new Error(
+        `[PluginKeywordRegistry] Registry is sealed \u2014 cannot register verb "${verb}" after scene init.`
+      );
+    }
+    if (!verb || !/^[a-z][a-z0-9_]*$/.test(verb)) {
+      throw new Error(
+        `[PluginKeywordRegistry] Invalid verb "${verb}". Must match [a-z][a-z0-9_]*.`
+      );
+    }
+    if (!NODE_TYPE_FAMILIES.includes(family)) {
+      throw new Error(
+        `[PluginKeywordRegistry] Unknown node-type family "${family}". Must be one of: ${NODE_TYPE_FAMILIES.join(", ")}.`
+      );
+    }
+    const existing = this.table.get(verb);
+    if (existing) {
+      if (existing.registeredBy === pluginId) {
+        return;
+      }
+      throw new Error(
+        `[PluginKeywordRegistry] Verb "${verb}" is already registered by plugin "${existing.registeredBy}". Cannot be re-registered by "${pluginId}".`
+      );
+    }
+    this.table.set(verb, { verb, family, registeredBy: pluginId });
+  }
+  /**
+   * Seal the registry after scene init. All plugin verbs must be registered
+   * before this call. After sealing, `register()` throws.
+   *
+   * Idempotent — calling seal() on an already-sealed registry is a no-op.
+   */
+  seal() {
+    this._sealed = true;
+  }
+  /** Whether the registry has been sealed. */
+  get isSealed() {
+    return this._sealed;
+  }
+  /**
+   * Look up the `NodeTypeFamily` for a verb.
+   * Returns `undefined` for unregistered verbs.
+   */
+  lookupFamily(verb) {
+    return this.table.get(verb)?.family;
+  }
+  /** Returns `true` if the verb is registered (built-in or plugin-supplied). */
+  isKnownVerb(verb) {
+    return this.table.has(verb);
+  }
+  /**
+   * Return all registered `VerbEntry` objects — the flat machine-introspectable
+   * table. Safe for LSP / marketplace / Brittney to read without importing TS.
+   */
+  entries() {
+    return [...this.table.values()];
+  }
+  /** Return all registered verbs for a given family. */
+  verbsInFamily(family) {
+    return [...this.table.values()].filter((e) => e.family === family).map((e) => e.verb);
+  }
+  /** Total number of registered verbs. */
+  get size() {
+    return this.table.size;
+  }
+};
+var globalKeywordRegistry = new PluginKeywordRegistry();
+function registerPluginVerb(verb, family, pluginId) {
+  globalKeywordRegistry.register(verb, family, pluginId);
+}
+function registerPluginVerbs(pluginId, verbs) {
+  for (const { verb, family } of verbs) {
+    globalKeywordRegistry.register(verb, family, pluginId);
+  }
+}
+
+export { NODE_TYPE_FAMILIES, PluginKeywordRegistry, globalKeywordRegistry, registerPluginVerb, registerPluginVerbs };
+//# sourceMappingURL=chunk-RAJMAX6D.js.map
+//# sourceMappingURL=chunk-RAJMAX6D.js.map

package/dist/{chunk-VVKVQZI6.js → chunk-RAN3ECAS.js}

@@ -1,4 +1,4 @@
-import { __esm } from './chunk-OL46QLBJ.js';
+import { __esm } from './chunk-W4GABFCR.js';
 import { z } from 'zod';
 
 function safeJsonParse(s, schema) {
@@ -51,5 +51,5 @@ var init_safeJsonParse = __esm({
 });
 
 export { init_safeJsonParse, jsonClone, readJson, safeJsonParse, safeJsonParseSchema, tryParseJson };
-//# sourceMappingURL=chunk-VVKVQZI6.js.map
-//# sourceMappingURL=chunk-VVKVQZI6.js.map
+//# sourceMappingURL=chunk-RAN3ECAS.js.map
+//# sourceMappingURL=chunk-RAN3ECAS.js.map

package/dist/chunk-RKGUZBOC.js

@@ -0,0 +1,79 @@
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
+
+// src/plugin-manifest/PluginManifest.ts
+function traitName(entry) {
+  return typeof entry === "string" ? entry : entry.name;
+}
+function manifestTraitNames(manifest) {
+  return manifest.traits.map(traitName);
+}
+function combinePluginRegistrations(registrar, plugins) {
+  const pluginIds = [];
+  const traitNames = [];
+  for (const registration of plugins) {
+    registration.register(registrar);
+    pluginIds.push(registration.manifest.id);
+    traitNames.push(...manifestTraitNames(registration.manifest));
+  }
+  return { pluginIds, traitNames };
+}
+async function autoLoadPluginsFromManifests(pluginsDir, registrar) {
+  const loaded = [];
+  const skipped = [];
+  const failed = [];
+  let dirs;
+  try {
+    dirs = readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch (e) {
+    return { loaded, skipped, failed: [{ id: "<root>", error: e.message }] };
+  }
+  for (const dir of dirs) {
+    const manifestPath = join(pluginsDir, dir, "plugin.manifest.json");
+    if (!existsSync(manifestPath)) continue;
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    } catch (e) {
+      failed.push({ id: dir, error: `manifest parse: ${e.message}` });
+      continue;
+    }
+    if (!manifest.autoRegister) {
+      skipped.push(manifest.id);
+      continue;
+    }
+    const entry = manifest.runtimeEntry ?? "./src/runtime.ts";
+    const entryAbs = resolve(join(pluginsDir, dir), entry);
+    if (!existsSync(entryAbs)) {
+      failed.push({ id: manifest.id, error: `runtimeEntry not found: ${entryAbs}` });
+      continue;
+    }
+    try {
+      const mod = await import(pathToFileURL(entryAbs).href);
+      let fn = mod["registerTraitHandlers"];
+      if (typeof fn !== "function") {
+        const found = Object.entries(mod).find(
+          ([k, v]) => typeof v === "function" && /^register\w+TraitHandlers$/.test(k)
+        );
+        fn = found?.[1];
+      }
+      if (typeof fn !== "function") {
+        failed.push({
+          id: manifest.id,
+          error: `no registerTraitHandlers export in ${entry}`
+        });
+        continue;
+      }
+      fn(registrar);
+      loaded.push(manifest.id);
+    } catch (e) {
+      failed.push({ id: manifest.id, error: e.message });
+    }
+  }
+  return { loaded, skipped, failed };
+}
+
+export { autoLoadPluginsFromManifests, combinePluginRegistrations, manifestTraitNames, traitName };
+//# sourceMappingURL=chunk-RKGUZBOC.js.map
+//# sourceMappingURL=chunk-RKGUZBOC.js.map

package/dist/{chunk-HLFDZ35S.cjs → chunk-RRQIAJLQ.cjs}

@@ -1,21 +1,21 @@
 'use strict';
 
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/DTDLCompiler.ts
 var DTDLCompiler_exports = {};
-chunkHCCQLAA4_cjs.__export(DTDLCompiler_exports, {
+chunkZHPMP447_cjs.__export(DTDLCompiler_exports, {
   DTDLCompiler: () => exports.DTDLCompiler,
   DTDL_TRAIT_COMPONENTS: () => exports.DTDL_TRAIT_COMPONENTS,
   default: () => exports.DTDLCompiler_default
 });
 exports.DTDLCompiler = void 0; exports.DTDL_TRAIT_COMPONENTS = void 0; exports.DTDLCompiler_default = void 0;
-var init_DTDLCompiler = chunkHCCQLAA4_cjs.__esm({
+var init_DTDLCompiler = chunkZHPMP447_cjs.__esm({
   "src/compiler/DTDLCompiler.ts"() {
-    chunkLODTHGST_cjs.init_CompilerBase();
-    exports.DTDLCompiler = class extends chunkLODTHGST_cjs.CompilerBase {
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    exports.DTDLCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "DTDLCompiler";
@@ -420,5 +420,5 @@ var init_DTDLCompiler = chunkHCCQLAA4_cjs.__esm({
 
 exports.DTDLCompiler_exports = DTDLCompiler_exports;
 exports.init_DTDLCompiler = init_DTDLCompiler;
-//# sourceMappingURL=chunk-HLFDZ35S.cjs.map
-//# sourceMappingURL=chunk-HLFDZ35S.cjs.map
+//# sourceMappingURL=chunk-RRQIAJLQ.cjs.map
+//# sourceMappingURL=chunk-RRQIAJLQ.cjs.map

package/dist/{chunk-PABONWKI.js → chunk-RXQNRZ5F.js}

@@ -1,4 +1,4 @@
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
+import { init_CompilerBase, CompilerBase } from './chunk-DUG3OQAS.js';
 import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/LLMProviderCapabilitiesCompiler.ts
@@ -734,5 +734,5 @@ function daysBetween(earlier, later) {
 }
 
 export { LLMCapabilityCompileError, LLMProviderCapabilitiesCompiler, createLLMProviderCapabilitiesCompiler };
-//# sourceMappingURL=chunk-PABONWKI.js.map
-//# sourceMappingURL=chunk-PABONWKI.js.map
+//# sourceMappingURL=chunk-RXQNRZ5F.js.map
+//# sourceMappingURL=chunk-RXQNRZ5F.js.map

package/dist/{chunk-7ZHYEITD.cjs → chunk-S4O7CFHQ.cjs}

@@ -1,12 +1,11 @@
 'use strict';
 
-var chunkUVFI7XIR_cjs = require('./chunk-UVFI7XIR.cjs');
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
+var chunkV6GXFSK7_cjs = require('./chunk-V6GXFSK7.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
 
 // src/compiler/TraitCompositionCompiler.ts
-chunkLODTHGST_cjs.init_AgentRBAC();
-chunkLODTHGST_cjs.init_CompilerBase();
-chunkUVFI7XIR_cjs.init_ProvenanceSemiring();
+chunkZK7KX5CD_cjs.init_AgentRBAC();
+chunkZK7KX5CD_cjs.init_CompilerBase();
 var CompositionConflictError = class extends Error {
   constructor(traitA, traitB, conflictKey) {
     super(
@@ -63,7 +62,7 @@ var TraitCompositionCompiler = class {
    */
   validateAccess(agentToken) {
     if (!agentToken) return;
-    const rbac = chunkLODTHGST_cjs.getRBAC();
+    const rbac = chunkZK7KX5CD_cjs.getRBAC();
     const decision = rbac.checkAccess({
       token: agentToken,
       resourceType: "ast" /* AST */,
@@ -83,12 +82,12 @@ var TraitCompositionCompiler = class {
       if (!handler) throw new MissingComponentError(decl.name, name);
       return { name, handler };
     });
-    if (chunkUVFI7XIR_cjs.authorityWeight(
+    if (chunkV6GXFSK7_cjs.authorityWeight(
       decl.provenance?.context?.authorityLevel ?? 0
     ) < 100) {
       this.detectConflicts(handlers);
     }
-    const semiring = new chunkUVFI7XIR_cjs.ProvenanceSemiring();
+    const semiring = new chunkV6GXFSK7_cjs.ProvenanceSemiring();
     const applications = [];
     for (const { name, handler } of handlers) {
       let configAccumulator = {};
@@ -154,7 +153,7 @@ var TraitCompositionCompiler = class {
     }
   }
 };
-var UnauthorizedTraitCompositionAccessError = class extends chunkLODTHGST_cjs.UnauthorizedCompilerAccessError {
+var UnauthorizedTraitCompositionAccessError = class extends chunkZK7KX5CD_cjs.UnauthorizedCompilerAccessError {
   constructor(decision, compilerName) {
     super(decision, "trait composition", compilerName);
     this.name = "UnauthorizedTraitCompositionAccessError";
@@ -165,5 +164,5 @@ exports.CompositionConflictError = CompositionConflictError;
 exports.MissingComponentError = MissingComponentError;
 exports.TraitCompositionCompiler = TraitCompositionCompiler;
 exports.UnauthorizedTraitCompositionAccessError = UnauthorizedTraitCompositionAccessError;
-//# sourceMappingURL=chunk-7ZHYEITD.cjs.map
-//# sourceMappingURL=chunk-7ZHYEITD.cjs.map
+//# sourceMappingURL=chunk-S4O7CFHQ.cjs.map
+//# sourceMappingURL=chunk-S4O7CFHQ.cjs.map

package/dist/chunk-SE7ANBGN.js

@@ -0,0 +1,128 @@
+import { HoloScriptPlusParser } from './chunk-DBH3D2MU.js';
+
+// src/parser/HsplusGrammar.ts
+function normalizeHsplusGrammarErrors(errors) {
+  if (!Array.isArray(errors)) return [];
+  return errors.map((error) => {
+    const record = error && typeof error === "object" ? error : {};
+    return {
+      message: typeof record.message === "string" ? record.message : String(error),
+      line: typeof record.line === "number" ? record.line : 0,
+      column: typeof record.column === "number" ? record.column : 0
+    };
+  });
+}
+var TypeScriptHsplusGrammar = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.source = "typescript-fallback";
+  }
+  parse(source) {
+    const result = this.parseWithTypeScript(source);
+    return {
+      success: result.success,
+      ast: result.ast,
+      errors: normalizeHsplusGrammarErrors(result.errors),
+      raw: result
+    };
+  }
+  validate(source) {
+    return this.validateDetailed(source).valid;
+  }
+  validateDetailed(source) {
+    const parsed = this.parse(source);
+    return {
+      valid: parsed.success,
+      errors: parsed.errors,
+      raw: parsed.raw
+    };
+  }
+  version() {
+    return "typescript-hsplus";
+  }
+  parseWithTypeScript(source) {
+    const parser = new HoloScriptPlusParser(this.options);
+    return parser.parse(source);
+  }
+};
+
+// src/parser/GrammarModuleRegistry.ts
+var GrammarModuleRegistryImpl = class {
+  constructor() {
+    this.modules = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a new grammar module.
+   * @throws Error if a module with the same name already exists
+   */
+  register(descriptor) {
+    if (this.modules.has(descriptor.name)) {
+      throw new Error(
+        `Grammar module "${descriptor.name}" is already registered. Use GrammarModuleRegistry.override() to replace an existing module.`
+      );
+    }
+    this.modules.set(descriptor.name, descriptor);
+  }
+  /**
+   * Override an existing grammar module registration.
+   */
+  override(descriptor) {
+    this.modules.set(descriptor.name, descriptor);
+  }
+  /**
+   * Unregister a grammar module.
+   */
+  unregister(name) {
+    return this.modules.delete(name);
+  }
+  /**
+   * Check if a grammar module is registered.
+   */
+  has(name) {
+    return this.modules.has(name);
+  }
+  /**
+   * Get a registered grammar module descriptor (includes the callable parse fn).
+   */
+  get(name) {
+    return this.modules.get(name);
+  }
+  /**
+   * Parse source using a registered grammar module.
+   * @throws Error if module not found
+   */
+  parseWith(name, source) {
+    const desc = this.modules.get(name);
+    if (!desc) {
+      const available = [...this.modules.keys()].join(", ");
+      throw new Error(`Unknown grammar module "${name}". Available: ${available}`);
+    }
+    return desc.parse(source);
+  }
+  /**
+   * List all registered grammar modules (discovery info only, no parse fn).
+   */
+  list() {
+    return [...this.modules.values()].map((desc) => ({
+      name: desc.name,
+      description: desc.description
+    }));
+  }
+  /**
+   * Get all registered grammar module names.
+   */
+  names() {
+    return [...this.modules.keys()];
+  }
+  /**
+   * Get count of registered grammar modules.
+   */
+  get size() {
+    return this.modules.size;
+  }
+};
+var GrammarModuleRegistry = new GrammarModuleRegistryImpl();
+
+export { GrammarModuleRegistry, TypeScriptHsplusGrammar, normalizeHsplusGrammarErrors };
+//# sourceMappingURL=chunk-SE7ANBGN.js.map
+//# sourceMappingURL=chunk-SE7ANBGN.js.map

package/dist/{chunk-X2AVEAZM.cjs → chunk-SJIRCTIS.cjs}

@@ -2,6 +2,118 @@
 
 var chunkILRBGFVD_cjs = require('./chunk-ILRBGFVD.cjs');
 
+// src/events/EventBus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.history = [];
+    this.maxHistory = 100;
+    this.nextId = 0;
+    this.paused = false;
+  }
+  /**
+   * Subscribe to an event.
+   */
+  on(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: false, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Subscribe to an event once (auto-removes after first fire).
+   */
+  once(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: true, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Unsubscribe by listener ID.
+   */
+  off(listenerId) {
+    for (const [event, list] of this.listeners) {
+      const idx = list.findIndex((l) => l.id === listenerId);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+        return;
+      }
+    }
+  }
+  /**
+   * Unsubscribe all listeners for an event.
+   */
+  offAll(event) {
+    this.listeners.delete(event);
+  }
+  /**
+   * Emit an event to all subscribers.
+   */
+  emit(event, data) {
+    if (this.paused) return;
+    this.history.push({ event, data, timestamp: Date.now() });
+    if (this.history.length > this.maxHistory) this.history.shift();
+    const list = this.listeners.get(event);
+    if (list) {
+      const toRemove = [];
+      for (const listener of list) {
+        listener.callback(data);
+        if (listener.once) toRemove.push(listener.id);
+      }
+      for (const id of toRemove) {
+        const idx = list.findIndex((l) => l.id === id);
+        if (idx !== -1) list.splice(idx, 1);
+      }
+    }
+    if (event !== "*") {
+      const wildcardList = this.listeners.get("*");
+      if (wildcardList) {
+        for (const listener of wildcardList) {
+          listener.callback({ event, data });
+        }
+      }
+    }
+  }
+  /**
+   * Get event history.
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Get listener count for an event.
+   */
+  listenerCount(event) {
+    return this.listeners.get(event)?.length || 0;
+  }
+  /**
+   * Pause/resume event emission.
+   */
+  setPaused(paused) {
+    this.paused = paused;
+  }
+  /**
+   * Clear all listeners and history.
+   */
+  clear() {
+    this.listeners.clear();
+    this.history = [];
+  }
+};
+var sharedBus = null;
+function getSharedEventBus() {
+  if (!sharedBus) sharedBus = new EventBus();
+  return sharedBus;
+}
+function setSharedEventBus(bus) {
+  sharedBus = bus;
+}
+
 // src/traits/MitosisTrait.ts
 var mitosisHandler = {
   name: "mitosis",
@@ -604,10 +716,72 @@ var orbitalHandler = {
   }
 };
 
+// src/runtime/easing.ts
+var SPRING_ZETA = 0.35;
+var SPRING_OMEGA = 8.38;
+var SPRING_OMEGA_D = SPRING_OMEGA * Math.sqrt(1 - SPRING_ZETA * SPRING_ZETA);
+function springStepResponse(t) {
+  const decay = Math.exp(-SPRING_ZETA * SPRING_OMEGA * t);
+  const osc = Math.cos(SPRING_OMEGA_D * t) + SPRING_ZETA * SPRING_OMEGA / SPRING_OMEGA_D * Math.sin(SPRING_OMEGA_D * t);
+  return 1 - decay * osc;
+}
+var SPRING_RESIDUAL = 1 - springStepResponse(1);
+function springEasing(t) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  return springStepResponse(t) + t * SPRING_RESIDUAL;
+}
+function bounceEasing(t) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (t < 1 / d1) {
+    return n1 * t * t;
+  } else if (t < 2 / d1) {
+    const u2 = t - 1.5 / d1;
+    return n1 * u2 * u2 + 0.75;
+  } else if (t < 2.5 / d1) {
+    const u2 = t - 2.25 / d1;
+    return n1 * u2 * u2 + 0.9375;
+  }
+  const u = t - 2.625 / d1;
+  return n1 * u * u + 0.984375;
+}
+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 "spring":
+      return springEasing(t);
+    case "bounce":
+      return bounceEasing(t);
+    case "smoothstep":
+      return t * t * (3 - 2 * t);
+    case "linear":
+    default:
+      return t;
+  }
+}
+
+exports.EventBus = EventBus;
 exports.JEPAPredictor = JEPAPredictor;
+exports.applyEasing = applyEasing;
 exports.embeddingHandler = embeddingHandler;
+exports.getSharedEventBus = getSharedEventBus;
 exports.jepObjectiveHandler = jepObjectiveHandler;
 exports.mitosisHandler = mitosisHandler;
 exports.orbitalHandler = orbitalHandler;
-//# sourceMappingURL=chunk-X2AVEAZM.cjs.map
-//# sourceMappingURL=chunk-X2AVEAZM.cjs.map
+exports.setSharedEventBus = setSharedEventBus;
+//# sourceMappingURL=chunk-SJIRCTIS.cjs.map
+//# sourceMappingURL=chunk-SJIRCTIS.cjs.map

package/dist/{chunk-WXQ57LAO.js → chunk-SQXAZHDG.js}

@@ -1,5 +1,5 @@
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
-import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { init_CompilerBase, CompilerBase } from './chunk-DUG3OQAS.js';
+import { __export, __esm } from './chunk-W4GABFCR.js';
 import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/DTDLCompiler.ts
@@ -417,5 +417,5 @@ var init_DTDLCompiler = __esm({
 });
 
 export { DTDLCompiler, DTDLCompiler_default, DTDLCompiler_exports, DTDL_TRAIT_COMPONENTS, init_DTDLCompiler };
-//# sourceMappingURL=chunk-WXQ57LAO.js.map
-//# sourceMappingURL=chunk-WXQ57LAO.js.map
+//# sourceMappingURL=chunk-SQXAZHDG.js.map
+//# sourceMappingURL=chunk-SQXAZHDG.js.map