@almadar/runtime 6.70.0 → 6.72.0

package/dist/OrbitalServerRuntime.js

@@ -1,14 +1,14 @@
-import { createTickScheduler, EventBus, createUnifiedLoader, MockPersistenceAdapter, InMemoryPersistence, preprocessSchema, normalizeCallSiteConfigToValues, StateMachineManager, parseDurationString, validateEventPayload, formatPayloadValidationError, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, EffectExecutor } from './chunk-PAEMYGKV.js';
-export { InMemoryPersistence, collectDeclaredConfigDefaults } from './chunk-PAEMYGKV.js';
+import { createTickScheduler, EventBus, createUnifiedLoader, MockPersistenceAdapter, InMemoryPersistence, preprocessSchema, normalizeCallSiteConfigToValues, StateMachineManager, parseDurationString, validateEventPayload, formatPayloadValidationError, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, EffectExecutor, LIFECYCLE_EVENTS } from './chunk-A474B57C.js';
+export { InMemoryPersistence, collectDeclaredConfigDefaults } from './chunk-A474B57C.js';
 import { isValidCronExpression } from './chunk-OU3ITB5S.js';
-import { createContextFromBindings, checkMutationAccess, resolveCallSitePayloadCaptures, applyRowAccess, accessDeniedMessage } from './chunk-ZJ62H3ES.js';
+import { createContextFromBindings, checkMutationAccess, applyRowAccess, accessDeniedMessage } from './chunk-ZWAOJT6R.js';
 import './chunk-T4VDAB4C.js';
 import './chunk-SCRAHWOC.js';
 import './chunk-MLKGABMK.js';
 import { createLogger } from '@almadar/logger';
 import * as nodeModule from 'module';
 import { evaluateListenPayloadExpr, evaluateGuard, evaluate } from '@almadar/evaluator';
-import { DEFAULT_VIEWER, buildResolvedTraitConfigs, isInlineTrait, isEntityCall, applyListenPayloadMapping, personaFromIdentityRow, normalizeUserContext, isRuntimeEntity, isPageReference } from '@almadar/core';
+import { DEFAULT_VIEWER, buildResolvedTraitConfigs, collectCallsiteCaptureChildren, isInlineTrait, isEntityCall, applyListenPayloadMapping, personaFromIdentityRow, normalizeUserContext, isRuntimeEntity, isPageReference } from '@almadar/core';
 import { ownerFieldsFromSchema, identityEntityName, entityAccessPoliciesByStoreKey, entityAccessPolicies } from '@almadar/core/mock';
 import { getPatternFieldsContract } from '@almadar/core/patterns';
 
@@ -115,6 +115,10 @@ var OrbitalServerRuntime = class {
   orbitals = /* @__PURE__ */ new Map();
   eventBus;
   config;
+  /** The bound persistence adapter (mock/in-memory/consumer-supplied). Public
+   *  so a test can inspect committed rows honestly — `(runtime as any)
+   *  .persistence` was the alternative, and that cast is what this field
+   *  visibility replaces. */
   persistence;
   listenerCleanups = [];
   tickBindings = [];
@@ -156,6 +160,15 @@ var OrbitalServerRuntime = class {
    * `declaredDefaults` and ahead of `callSiteOverride`.
    */
   resolvedTraitConfigs = {};
+  /**
+   * Referrer trait name → the DIRECT children (via `@trait.X`) that need
+   * their lifecycle transition re-run under the referrer's `callsitePayload`
+   * whenever the referrer's own transition fires — computed once per
+   * `register()` via `@almadar/core`'s `collectCallsiteCaptureChildren`
+   * (merged across every orbital in the schema, same flattening
+   * `resolvedTraitConfigs` uses). See `rerenderCallsiteCaptureChildren`.
+   */
+  callsiteCaptureChildrenByTrait = /* @__PURE__ */ new Map();
   constructor(config = {}) {
     this.config = {
       mode: "mock",
@@ -356,6 +369,7 @@ var OrbitalServerRuntime = class {
     this.setupTicks();
     this.resolvedSchema = schema;
     this.resolvedTraitConfigs = buildResolvedTraitConfigs(schema);
+    this.callsiteCaptureChildrenByTrait = this.buildCallsiteCaptureChildrenByTrait(schema);
     this.installOwnerGate();
   }
   /**
@@ -375,6 +389,22 @@ var OrbitalServerRuntime = class {
       columns: derived
     });
   }
+  /**
+   * Merge `collectCallsiteCaptureChildren` across every orbital in the
+   * schema into ONE flat referrer-trait-name → children map — same
+   * flattening `resolvedTraitConfigs` uses, safe because trait names are
+   * unique within one running schema (the compose/resolve pipeline already
+   * relies on that for `configByTrait` and `resolvedTraitConfigs`).
+   */
+  buildCallsiteCaptureChildrenByTrait(schema) {
+    const merged = /* @__PURE__ */ new Map();
+    for (const orbital of schema.orbitals) {
+      for (const [referrer, children] of collectCallsiteCaptureChildren(orbital)) {
+        merged.set(referrer, children);
+      }
+    }
+    return merged;
+  }
   /**
    * Register an OrbitalSchema synchronously (for backward compatibility).
    * Note: This version doesn't wait for instance seeding to complete.
@@ -393,6 +423,7 @@ var OrbitalServerRuntime = class {
     this.setupTicks();
     this.resolvedSchema = schema;
     this.resolvedTraitConfigs = buildResolvedTraitConfigs(schema);
+    this.callsiteCaptureChildrenByTrait = this.buildCallsiteCaptureChildrenByTrait(schema);
     this.installOwnerGate();
   }
   /**
@@ -760,6 +791,40 @@ var OrbitalServerRuntime = class {
       });
     });
   }
+  /**
+   * The id of the SOURCE event a `listens {}` entry names, derived from the
+   * emitting trait's own declared `emits[]` contract rather than trusted
+   * from `listener.eventId` alone.
+   *
+   * `TraitEventListener.eventId` is "optional until the Phase-7 flip" (see
+   * `@almadar/core`'s `trait.ts`) — the compose/resolve pipeline stamps a
+   * V4 ledger id onto every `emits[]` entry (the emitter's own contract)
+   * well before it stamps the matching id onto every `listens[]` entry that
+   * names that event (source-qualified `Trait.EVENT -> X` listens compiled
+   * from `uses`-resolved atoms carry `triggersId` for their OWN triggered
+   * event but no `eventId` for the event they're listening to). The emit
+   * handler (`executeEffects`'s `emit` closure below) always looks up and
+   * stamps `emittingTrait.emits[].eventId` when present, so during that
+   * transitional window the emit side routes under an id-qualified bus key
+   * while the listen side — reading only its own possibly-absent
+   * `eventId` — subscribes under the bare name, and the two never meet.
+   *
+   * Fix: derive the SAME id the emitter will stamp by resolving the
+   * listener's declared `source` (trait/orbital, name or id) to the actual
+   * registered trait and reading ITS `emits[]` contract for `listener.event`
+   * — the single canonical place an event's id lives. `kind: "any"` sources
+   * are left alone (no single emitter to resolve against; bare-name routing
+   * is already the correct, safe default there).
+   */
+  resolveSourceEmitEventId(source, event, listenerOrbital) {
+    if (!source || source.kind === "any") return void 0;
+    const ownerOrbitalName = source.kind === "orbital" ? source.orbital : listenerOrbital;
+    const owner = this.orbitals.get(ownerOrbitalName);
+    if (!owner) return void 0;
+    const sourceTrait = source.traitId !== void 0 ? owner.traits.find((t) => t.id === source.traitId) : owner.traits.find((t) => t.name === source.trait);
+    if (!sourceTrait) return void 0;
+    return sourceTrait.emits?.find((e) => e.event === event)?.eventId;
+  }
   /**
    * Set up event listeners for cross-orbital communication
    */
@@ -773,7 +838,8 @@ var OrbitalServerRuntime = class {
         if (!trait.listens) continue;
         for (const listener of trait.listens) {
           const { bareEvent, matcher } = parseListenSource(listener, orbitalName);
-          const routeKey = eventRouteKey(bareEvent, listener.eventId);
+          const effectiveEventId = listener.eventId ?? this.resolveSourceEmitEventId(listener.source, bareEvent, orbitalName);
+          const routeKey = eventRouteKey(bareEvent, effectiveEventId);
           const cleanup = this.eventBus.on(routeKey, async (event) => {
             if (!matcher(event.source)) return;
             if (event.source?.originClientId !== void 0) {
@@ -1337,6 +1403,21 @@ var OrbitalServerRuntime = class {
             onPush,
             clientId
           );
+          await this.rerenderCallsiteCaptureChildren(
+            registered,
+            traitName,
+            cleanPayload ?? {},
+            entityData,
+            entityId,
+            emittedEvents,
+            fetchedData,
+            clientEffects,
+            effectResults,
+            viewer,
+            clientEffectsByTrait,
+            onPush,
+            clientId
+          );
         }
       }
       const states = {};
@@ -1382,7 +1463,7 @@ var OrbitalServerRuntime = class {
   /**
    * Execute effects from a transition
    */
-  async executeEffects(registered, traitName, effects, payload, entityData, entityId, emittedEvents, fetchedData, clientEffects, effectResults, user, clientEffectsByTrait, onPush, originClientId) {
+  async executeEffects(registered, traitName, effects, payload, entityData, entityId, emittedEvents, fetchedData, clientEffects, effectResults, user, clientEffectsByTrait, onPush, originClientId, callsitePayload) {
     const entityType = registered.entity.name;
     for (const eff of effects) {
       if (Array.isArray(eff) && eff[0] === "fetch") {
@@ -1498,7 +1579,7 @@ var OrbitalServerRuntime = class {
                 case "create": {
                   const createData = opRest[0] || {};
                   const { id: newId } = await this.persistence.create(opEntityType, createData);
-                  batchResults.push({ action: "create", entityType: opEntityType, id: newId, ...createData });
+                  batchResults.push({ ...createData, action: "create", entityType: opEntityType, id: newId });
                   completed.push({ action: "create", entityType: opEntityType, id: newId });
                   break;
                 }
@@ -1507,7 +1588,7 @@ var OrbitalServerRuntime = class {
                   const updateData = opRest[1] || {};
                   await this.persistence.update(opEntityType, updateId, updateData);
                   const updated = await this.persistence.getById(opEntityType, updateId);
-                  batchResults.push({ action: "update", entityType: opEntityType, id: updateId, ...updated || updateData });
+                  batchResults.push({ ...updated || updateData, action: "update", entityType: opEntityType, id: updateId });
                   completed.push({ action: "update", entityType: opEntityType, id: updateId });
                   break;
                 }
@@ -1546,6 +1627,7 @@ var OrbitalServerRuntime = class {
         const type = targetEntityType || entityType;
         let resultData;
         const sizeBefore = (await this.persistence.list(type)).length;
+        let deniedReason;
         try {
           if (action === "create" || action === "update") {
             this.validateRelationCardinality(type, data || {});
@@ -1555,10 +1637,11 @@ var OrbitalServerRuntime = class {
           switch (action) {
             case "create": {
               if (!checkMutationAccess(data || {}, mutationPolicy, accessBindings)) {
+                deniedReason = "access-denied";
                 throw new Error(accessDeniedMessage("create", type));
               }
               const { id } = await this.persistence.create(type, data || {});
-              resultData = { id, ...data || {} };
+              resultData = { ...data || {}, id };
               break;
             }
             case "update":
@@ -1567,15 +1650,17 @@ var OrbitalServerRuntime = class {
                 if (mutationPolicy !== void 0) {
                   const existing = await this.persistence.getById(type, updateId);
                   if (!existing || !checkMutationAccess(existing, mutationPolicy, accessBindings)) {
+                    deniedReason = "access-denied";
                     throw new Error(accessDeniedMessage("update", type));
                   }
                 }
                 await this.persistence.update(type, updateId, data || {});
                 const updated = await this.persistence.getById(type, updateId);
-                resultData = updated || { id: updateId, ...data || {} };
+                resultData = updated || { ...data || {}, id: updateId };
               } else {
                 effectLog.error("persist:no-row-key", { action, entityType: type });
                 if (NO_ROW_KEY_IS_FATAL) {
+                  deniedReason = "no-row-key";
                   throw new Error(
                     `persist ${action} ${type} resolved no row key \u2014 the id was neither on the row being written nor on the request. Bind it before the write, e.g. (set @entity.id ?row.id) on the transition that selects it.`
                   );
@@ -1590,6 +1675,7 @@ var OrbitalServerRuntime = class {
                 if (mutationPolicy !== void 0) {
                   const existing = await this.persistence.getById(type, deleteId);
                   if (!existing || !checkMutationAccess(existing, mutationPolicy, accessBindings)) {
+                    deniedReason = "access-denied";
                     throw new Error(accessDeniedMessage("delete", type));
                   }
                 }
@@ -1599,6 +1685,7 @@ var OrbitalServerRuntime = class {
               } else {
                 effectLog.error("persist:no-row-key", { action, entityType: type });
                 if (NO_ROW_KEY_IS_FATAL) {
+                  deniedReason = "no-row-key";
                   throw new Error(
                     `persist ${action} ${type} resolved no row key \u2014 the id was neither on the row being written nor on the request. Bind it before the write, e.g. (set @entity.id ?row.id) on the transition that selects it.`
                   );
@@ -1607,6 +1694,17 @@ var OrbitalServerRuntime = class {
               break;
             }
           }
+          if (resultData === void 0 && (action === "update" || action === "delete")) {
+            effectResults.push({
+              effect: "persist",
+              action,
+              entityType: type,
+              success: false,
+              denied: true,
+              error: `persist ${action} ${type} resolved no row key`
+            });
+            return void 0;
+          }
           const sizeAfter = (await this.persistence.list(type)).length;
           effectLog.debug("persist:store-mutate", {
             action,
@@ -1635,6 +1733,7 @@ var OrbitalServerRuntime = class {
             action,
             entityType: type,
             success: false,
+            ...deniedReason !== void 0 ? { denied: true } : {},
             error: err instanceof Error ? err.message : String(err)
           });
         }
@@ -1929,17 +2028,17 @@ var OrbitalServerRuntime = class {
       state: state?.currentState || "unknown",
       user
     };
+    if (callsitePayload) {
+      bindings.callsitePayload = callsitePayload;
+    }
     const traitDef = registered.traits.find((t) => t.name === traitName);
     const declaredDefaults = collectDeclaredConfigDefaults(traitDef);
     const resolvedDefaults = this.resolvedTraitConfigs[traitName];
     const callSiteOverrideRaw = registered.configByTrait.get(traitName);
-    const callSiteOverride = callSiteOverrideRaw ? resolveCallSitePayloadCaptures(
-      Object.fromEntries(
-        Object.entries(callSiteOverrideRaw).filter(
-          ([, v]) => !(typeof v === "string" && v.startsWith("@config."))
-        )
-      ),
-      payload
+    const callSiteOverride = callSiteOverrideRaw ? Object.fromEntries(
+      Object.entries(callSiteOverrideRaw).filter(
+        ([, v]) => !(typeof v === "string" && v.startsWith("@config."))
+      )
     ) : void 0;
     if (declaredDefaults || resolvedDefaults || callSiteOverride) {
       bindings.config = {
@@ -2022,6 +2121,85 @@ var OrbitalServerRuntime = class {
     });
     await executor.executeAll(effects);
   }
+  /**
+   * Re-run a JSX-hoisted inline child trait's (`@trait.X`) lifecycle
+   * transition under `callsitePayload` — the payload of the transition that
+   * just composed it — so its `@callsitePayload.<field>` captures reflect
+   * the composing event instead of staying frozen at whatever the child
+   * captured at its own mount-time INIT (a child renders once at mount and
+   * never again on its own).
+   *
+   * `this.callsiteCaptureChildrenByTrait` (built at `register()` via
+   * `@almadar/core`'s `collectCallsiteCaptureChildren`) gives `traitName`'s
+   * DIRECT children that need this — either because the child itself
+   * captures, or because it is a pass-through to a capturing descendant.
+   * The child's lifecycle event (INIT/LOAD/$MOUNT) is re-dispatched
+   * TARGETED at just that trait, from its CURRENT state (the same
+   * guard-aware `sendEvent`/`canHandleEvent` lookup a mount-time INIT
+   * uses), then its effects run through the SAME `executeEffects` used
+   * everywhere else, with `payload: {}` (a lifecycle event carries none)
+   * and `callsitePayload` set so `@callsitePayload.*` resolves — pushing
+   * into the SAME `clientEffects`/`clientEffectsByTrait`/`effectResults`
+   * so the child's refreshed frame reaches the sidecar under its own trait
+   * name. Recurses into the child's own entry in the same map (still under
+   * the SAME `callsitePayload` — the capture resolves up the embed chain to
+   * the nearest transition that actually has one) for grandchildren;
+   * `visited` guards against a malformed embed graph cycling on itself.
+   * Never goes through `processOrbitalEvent` (that would be re-entrant) —
+   * calls this internal executor directly, exactly like every other
+   * transition's effects.
+   */
+  async rerenderCallsiteCaptureChildren(registered, traitName, callsitePayload, entityData, entityId, emittedEvents, fetchedData, clientEffects, effectResults, user, clientEffectsByTrait, onPush, originClientId, visited = /* @__PURE__ */ new Set()) {
+    const children = this.callsiteCaptureChildrenByTrait.get(traitName);
+    if (!children || children.size === 0) return;
+    for (const childName of children) {
+      if (visited.has(childName)) continue;
+      visited.add(childName);
+      const lifecycleEvent = LIFECYCLE_EVENTS.find((evt) => registered.manager.canHandleEvent(childName, evt));
+      if (lifecycleEvent === void 0) continue;
+      const [entry] = registered.manager.sendEvent(lifecycleEvent, {}, entityData, void 0, void 0, childName, user);
+      if (!entry || !entry.result.executed) continue;
+      xOrbitalLog.debug("callsite-capture-child:rerender", () => ({
+        referrer: traitName,
+        child: childName,
+        lifecycleEvent,
+        callsitePayload: JSON.stringify(callsitePayload)
+      }));
+      await this.executeEffects(
+        registered,
+        childName,
+        entry.result.effects,
+        {},
+        entityData,
+        entityId,
+        emittedEvents,
+        fetchedData,
+        clientEffects,
+        effectResults,
+        user,
+        clientEffectsByTrait,
+        onPush,
+        originClientId,
+        callsitePayload
+      );
+      await this.rerenderCallsiteCaptureChildren(
+        registered,
+        childName,
+        callsitePayload,
+        entityData,
+        entityId,
+        emittedEvents,
+        fetchedData,
+        clientEffects,
+        effectResults,
+        user,
+        clientEffectsByTrait,
+        onPush,
+        originClientId,
+        visited
+      );
+    }
+  }
   // ==========================================================================
   // Relation Population
   // ==========================================================================
@@ -2281,6 +2459,7 @@ var OrbitalServerRuntime = class {
    * Routes:
    * - GET  /              - List registered orbitals
    * - GET  /:orbital      - Get orbital info and current states
+   * - GET  /:orbital/entities/:entityType - Full mock-store row set (verification/tooling only)
    * - POST /:orbital/events - Send event to orbital (includes data from `fetch` effects)
    */
   router() {
@@ -2326,6 +2505,17 @@ var OrbitalServerRuntime = class {
         }
       });
     });
+    router.get("/:orbital/entities/:entityType", (req, res, next) => {
+      const orbitalName = req.params.orbital;
+      const entityType = req.params.entityType;
+      if (!this.orbitals.has(orbitalName)) {
+        res.status(404).json({ success: false, error: "Orbital not found" });
+        return;
+      }
+      this.persistence.list(entityType).then((rows) => {
+        res.json({ success: true, entityType, rows });
+      }).catch(next);
+    });
     router.post(
       "/:orbital/events",
       async (req, res, next) => {

package/dist/ServerBridge.d.ts

@@ -1,4 +1,4 @@
-import { I as IEventBus } from './types-BaD_ox7e.js';
+import { I as IEventBus } from './types-CWaIuEQn.js';
 import { EventPayload } from '@almadar/core';
 
 /**