@almadar/runtime 3.3.0 → 4.1.0

package/dist/{OrbitalServerRuntime-DMRvEfcT.d.ts → OrbitalServerRuntime-DXMHHVZI.d.ts}

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { I as IEventBus, g as RuntimeEvent, f as EventListener, U as Unsubscribe, T as TraitDefinition, R as RuntimeConfig, i as TransitionObserver, h as TraitState, j as TransitionResult, E as EvaluationContextExtensions, a as EffectHandlers } from './types-B8OfRFfV.js';
+import { I as IEventBus, g as RuntimeEvent, f as EventListener, U as Unsubscribe, T as TraitDefinition, R as RuntimeConfig, i as TransitionObserver, h as TraitState, j as TransitionResult, E as EvaluationContextExtensions, a as EffectHandlers } from './types-CVSBlnzV.js';
 import { EventPayload, EntityRow, OrbitalSchema, Orbital, Trait, OrbitalDefinition, Entity, TraitTick } from '@almadar/core';
 
 /**
@@ -748,14 +748,16 @@ interface OrbitalEventResponse {
     success: boolean;
     transitioned: boolean;
     states: Record<string, string>;
+    /**
+     * Events emitted during processing, in declaration order. Payloads are
+     * typed against `@almadar/core`'s `EventPayload` — the recursive record of
+     * primitive + nested EventPayload values the state machine already uses
+     * internally. Kept as the single source of truth for emit-payload shape.
+     */
     emittedEvents: Array<{
         event: string;
-        payload?: unknown;
+        payload?: EventPayload;
     }>;
-    /** Entity data fetched by `fetch` effects - keyed by entity type */
-    data?: {
-        [entityType: string]: EntityRow | EntityRow[];
-    };
     /** Client-side effects to execute (render-ui, navigate, notify) */
     clientEffects?: Array<unknown>;
     /**
@@ -883,13 +885,30 @@ declare class OrbitalServerRuntime {
     private osHandlers;
     private localPersistence;
     constructor(config?: OrbitalServerRuntimeConfig);
+    /**
+     * Lazily construct a default loader when the caller didn't provide one
+     * but `register()` needs to preprocess. Looks for `@almadar/std` in the
+     * nearest `node_modules` so cross-orbital `std/behaviors/<name>` imports
+     * resolve to the tiered registry on disk.
+     *
+     * Node only — browsers should receive already-preprocessed schemas from
+     * their server.
+     */
+    private ensureLoader;
     /**
      * Register an OrbitalSchema for execution.
      *
-     * If `autoPreprocess` is enabled in config and schema has `uses` declarations,
-     * it will be preprocessed first to resolve imports.
+     * Auto-preprocesses the schema when it contains `uses` declarations or
+     * unresolved cross-orbital trait references (e.g. a trait with
+     * `ref: "Modal.traits.ModalRecordModal"` and no inline `stateMachine`).
+     * Without preprocessing, those refs arrive empty at the state machine and
+     * button clicks silently do nothing — see Phase 9.5.H.
      *
-     * For explicit preprocessing control, use `registerWithPreprocess()`.
+     * Preprocessing needs a loader. If `loaderConfig` is set, that loader is
+     * used. Otherwise, a default loader is constructed that points at
+     * `<cwd>` (for `basePath`) and the nearest `node_modules/@almadar/std` (for
+     * `stdLibPath`), which matches how every caller in this monorepo has the
+     * std registry on disk.
      */
     register(schema: OrbitalSchema): Promise<void>;
     /**

package/dist/OrbitalServerRuntime.d.ts

@@ -1,4 +1,4 @@
 import 'express';
-export { B as EffectResult, C as LoaderConfig, D as LocalPersistenceAdapter, O as OrbitalEventRequest, e as OrbitalEventResponse, F as OrbitalServerRuntime, f as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RegisteredOrbital, k as RuntimeOrbital, l as RuntimeOrbitalSchema, m as RuntimeTrait, G as RuntimeTraitTick, H as createOrbitalServerRuntime } from './OrbitalServerRuntime-DMRvEfcT.js';
-import './types-B8OfRFfV.js';
+export { B as EffectResult, C as LoaderConfig, D as LocalPersistenceAdapter, O as OrbitalEventRequest, e as OrbitalEventResponse, F as OrbitalServerRuntime, f as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RegisteredOrbital, k as RuntimeOrbital, l as RuntimeOrbitalSchema, m as RuntimeTrait, G as RuntimeTraitTick, H as createOrbitalServerRuntime } from './OrbitalServerRuntime-DXMHHVZI.js';
+import './types-CVSBlnzV.js';
 import '@almadar/core';

package/dist/OrbitalServerRuntime.js

@@ -1,4 +1,4 @@
-import { EventBus, createUnifiedLoader, preprocessSchema, StateMachineManager, createContextFromBindings, EffectExecutor } from './chunk-II3JSETH.js';
+import { EventBus, createUnifiedLoader, preprocessSchema, StateMachineManager, createContextFromBindings, EffectExecutor } from './chunk-Z72NLOSF.js';
 import './chunk-PZ5AY32C.js';
 import { Router } from 'express';
 import * as fs from 'fs';
@@ -649,6 +649,23 @@ var InMemoryPersistence = class {
     return collection ? Array.from(collection.values()) : [];
   }
 };
+function needsPreprocessing(schema) {
+  for (const orbital of schema.orbitals) {
+    const uses = orbital.uses;
+    if (Array.isArray(uses) && uses.length > 0) {
+      return true;
+    }
+    const traits = orbital.traits ?? [];
+    for (const t of traits) {
+      if (!t || typeof t !== "object") continue;
+      const obj = t;
+      if (typeof obj.ref === "string" && obj.ref.includes(".") && !obj.stateMachine) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 var OrbitalServerRuntime = class {
   orbitals = /* @__PURE__ */ new Map();
   eventBus;
@@ -701,21 +718,102 @@ var OrbitalServerRuntime = class {
       ...this.config.effectHandlers
     };
   }
+  /**
+   * Lazily construct a default loader when the caller didn't provide one
+   * but `register()` needs to preprocess. Looks for `@almadar/std` in the
+   * nearest `node_modules` so cross-orbital `std/behaviors/<name>` imports
+   * resolve to the tiered registry on disk.
+   *
+   * Node only — browsers should receive already-preprocessed schemas from
+   * their server.
+   */
+  async ensureLoader() {
+    if (this.loader) return;
+    if (typeof process === "undefined" || !process.versions?.node) {
+      return;
+    }
+    try {
+      const [{ createRequire }, path2] = await Promise.all([
+        import('module'),
+        import('path')
+      ]);
+      const require2 = createRequire(import.meta.url);
+      const stdPkgJson = require2.resolve("@almadar/std/package.json");
+      const stdLibPath = path2.dirname(stdPkgJson);
+      const basePath = this.config.loaderConfig?.basePath ?? process.cwd();
+      this.loader = createUnifiedLoader({
+        basePath,
+        stdLibPath,
+        scopedPaths: this.config.loaderConfig?.scopedPaths
+      });
+      if (this.config.debug) {
+        console.log(
+          `[OrbitalRuntime] Default loader constructed: basePath=${basePath} stdLibPath=${stdLibPath}`
+        );
+      }
+    } catch (err) {
+      if (this.config.debug) {
+        console.warn(
+          `[OrbitalRuntime] Could not auto-construct loader: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
   // ==========================================================================
   // Schema Registration
   // ==========================================================================
   /**
    * Register an OrbitalSchema for execution.
    *
-   * If `autoPreprocess` is enabled in config and schema has `uses` declarations,
-   * it will be preprocessed first to resolve imports.
+   * Auto-preprocesses the schema when it contains `uses` declarations or
+   * unresolved cross-orbital trait references (e.g. a trait with
+   * `ref: "Modal.traits.ModalRecordModal"` and no inline `stateMachine`).
+   * Without preprocessing, those refs arrive empty at the state machine and
+   * button clicks silently do nothing — see Phase 9.5.H.
    *
-   * For explicit preprocessing control, use `registerWithPreprocess()`.
+   * Preprocessing needs a loader. If `loaderConfig` is set, that loader is
+   * used. Otherwise, a default loader is constructed that points at
+   * `<cwd>` (for `basePath`) and the nearest `node_modules/@almadar/std` (for
+   * `stdLibPath`), which matches how every caller in this monorepo has the
+   * std registry on disk.
    */
   async register(schema) {
     if (this.config.debug) {
       console.log(`[OrbitalRuntime] Registering schema: ${schema.name}`);
     }
+    if (needsPreprocessing(schema)) {
+      await this.ensureLoader();
+      if (this.loader) {
+        if (this.config.debug) {
+          console.log(`[OrbitalRuntime] Schema has uses/refs \u2014 auto-preprocessing`);
+        }
+        const result = await preprocessSchema(schema, {
+          basePath: this.config.loaderConfig?.basePath || process.cwd(),
+          stdLibPath: this.config.loaderConfig?.stdLibPath,
+          scopedPaths: this.config.loaderConfig?.scopedPaths,
+          loader: this.loader,
+          namespaceEvents: this.config.namespaceEvents
+        });
+        if (!result.success) {
+          throw new Error(
+            `Schema preprocessing failed: ${result.errors.join("; ")}`
+          );
+        }
+        schema = result.data.schema;
+        this.entitySharingMap = {
+          ...this.entitySharingMap,
+          ...result.data.entitySharing
+        };
+        this.eventNamespaceMap = {
+          ...this.eventNamespaceMap,
+          ...result.data.eventNamespaces
+        };
+      } else if (this.config.debug) {
+        console.warn(
+          `[OrbitalRuntime] Schema has uses/refs but no loader available \u2014 proceeding without preprocessing. Cross-orbital trait refs will be empty.`
+        );
+      }
+    }
     for (const orbital of schema.orbitals) {
       await this.registerOrbitalAsync(orbital);
     }
@@ -953,10 +1051,12 @@ var OrbitalServerRuntime = class {
       for (const trait of registered.traits) {
         if (!trait.listens) continue;
         for (const listener of trait.listens) {
-          const cleanup = this.eventBus.on(listener.event, async (event) => {
+          const { bareEvent, matcher } = parseListenSource(listener, orbitalName);
+          const cleanup = this.eventBus.on(bareEvent, async (event) => {
+            if (!matcher(event.source)) return;
             if (this.config.debug) {
               console.log(
-                `[OrbitalRuntime] ${orbitalName}.${trait.name} received: ${listener.event}`
+                `[OrbitalRuntime] ${orbitalName}.${trait.name} received: ${listener.event} (from ${event.source?.orbital ?? "?"}.${event.source?.trait ?? "?"})`
               );
             }
             let mappedPayload = event.payload;
@@ -1223,32 +1323,6 @@ var OrbitalServerRuntime = class {
         );
       }
     }
-    const persistedTypes = /* @__PURE__ */ new Set();
-    for (const er of effectResults) {
-      if ((er.effect === "persist" || er.effect === "set" || er.effect === "swap") && er.success && er.entityType) {
-        persistedTypes.add(er.entityType);
-      }
-    }
-    const refTypes = /* @__PURE__ */ new Set();
-    for (const trait of registered.traits) {
-      const transitions = trait.stateMachine?.transitions ?? [];
-      for (const trans of transitions) {
-        for (const eff of trans.effects ?? []) {
-          if (Array.isArray(eff) && eff[0] === "ref" && typeof eff[1] === "string") {
-            refTypes.add(eff[1]);
-          }
-        }
-      }
-    }
-    for (const mutatedEntityType of persistedTypes) {
-      if (refTypes.has(mutatedEntityType)) {
-        try {
-          const fresh = await this.persistence.list(mutatedEntityType);
-          fetchedData[mutatedEntityType] = fresh;
-        } catch {
-        }
-      }
-    }
     const states = {};
     for (const [name, state] of registered.manager.getAllStates()) {
       states[name] = state.currentState;
@@ -1259,9 +1333,6 @@ var OrbitalServerRuntime = class {
       states,
       emittedEvents
     };
-    if (Object.keys(fetchedData).length > 0) {
-      response.data = fetchedData;
-    }
     if (clientEffects.length > 0) {
       response.clientEffects = clientEffects;
     }
@@ -1285,11 +1356,15 @@ var OrbitalServerRuntime = class {
     let bindingsRef = null;
     let contextRef = null;
     const handlers = {
-      emit: (event, eventPayload) => {
+      emit: (event, eventPayload, source) => {
         if (this.config.debug) {
-          console.log(`[OrbitalRuntime] Emitting: ${event}`, eventPayload);
+          console.log(`[OrbitalRuntime] Emitting: ${event}`, eventPayload, source);
         }
-        this.eventBus.emit(event, eventPayload);
+        const stamp = source ?? {
+          orbital: registered.schema.name,
+          trait: traitName
+        };
+        this.eventBus.emit(event, eventPayload, stamp);
         emittedEvents.push({ event, payload: eventPayload });
       },
       set: async (targetId, field, value) => {
@@ -1623,7 +1698,7 @@ var OrbitalServerRuntime = class {
         const atomicExecutor = new EffectExecutor({
           handlers,
           bindings: bindingsRef ?? {},
-          context: contextRef ?? { traitName, state: "unknown", transition: "unknown" },
+          context: contextRef ?? { traitName, orbitalName: registered.schema.name, state: "unknown", transition: "unknown" },
           debug: this.config.debug,
           contextExtensions: this.config.contextExtensions
         });
@@ -1684,6 +1759,7 @@ var OrbitalServerRuntime = class {
     bindingsRef = bindings;
     const context = {
       traitName,
+      orbitalName: registered.schema.name,
       state: state?.currentState || "unknown",
       transition: "unknown",
       entityId
@@ -2029,6 +2105,53 @@ var OrbitalServerRuntime = class {
 function createOrbitalServerRuntime(config) {
   return new OrbitalServerRuntime(config);
 }
+function parseListenSource(listener, listenerOrbital) {
+  const explicit = listener.source;
+  if (explicit && typeof explicit === "object") {
+    return {
+      bareEvent: listener.event,
+      matcher: buildMatcher(explicit, listenerOrbital)
+    };
+  }
+  const key = listener.event;
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    return { bareEvent: key, matcher: () => true };
+  }
+  if (parts.length === 2) {
+    const [sourceOrStar, eventName] = parts;
+    if (sourceOrStar === "*") {
+      return { bareEvent: eventName, matcher: () => true };
+    }
+    return {
+      bareEvent: eventName,
+      matcher: buildMatcher(
+        { kind: "trait", trait: sourceOrStar },
+        listenerOrbital
+      )
+    };
+  }
+  if (parts.length >= 3) {
+    const eventName = parts[parts.length - 1];
+    const trait = parts[parts.length - 2];
+    const orbital = parts.slice(0, parts.length - 2).join(".");
+    return {
+      bareEvent: eventName,
+      matcher: buildMatcher({ kind: "orbital", orbital, trait }, listenerOrbital)
+    };
+  }
+  return { bareEvent: key, matcher: () => true };
+}
+function buildMatcher(src, listenerOrbital) {
+  if (src.kind === "any") return () => true;
+  if (src.kind === "trait") {
+    const wantedTrait2 = src.trait;
+    return (source) => !!source && source.orbital === listenerOrbital && source.trait === wantedTrait2;
+  }
+  const wantedOrbital = src.orbital;
+  const wantedTrait = src.trait;
+  return (source) => !!source && source.orbital === wantedOrbital && source.trait === wantedTrait;
+}
 
 export { LocalPersistenceAdapter, OrbitalServerRuntime, createOrbitalServerRuntime };
 //# sourceMappingURL=OrbitalServerRuntime.js.map