@almadar/runtime 6.43.0 → 6.45.0

package/dist/{OrbitalServerRuntime-f0EZSw4f.d.ts → OrbitalServerRuntime-A2h0EikK.d.ts}

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { I as IEventBus, R as RuntimeEvent, a as EventListener, U as Unsubscribe, T as TraitDefinition, b as RuntimeConfig, c as TransitionObserver, d as TraitState, C as ConfigContext, e as TransitionResult, f as EvaluationContextExtensions, E as EffectHandlers } from './types-p_L8-Sk4.js';
+import { I as IEventBus, R as RuntimeEvent, a as EventListener, U as Unsubscribe, T as TraitDefinition, b as RuntimeConfig, c as TransitionObserver, d as TraitState, C as ConfigContext, e as TransitionResult, f as EvaluationContextExtensions, E as EffectHandlers } from './types-CL03tjGU.js';
 import { EventPayload, EventId, EntityRow, UserContext, Orbital, ServiceCallResult, TraitConfig, DeclaredTraitConfig, Entity, OrbitalSchema, Trait, PatternConfig, ResolvedPatternProps, SExpr, BusEventSource, RawUserClaims, OrbitalDefinition, TraitTick } from '@almadar/core';
 
 /**
@@ -937,6 +937,13 @@ interface RegisteredOrbital {
      * `state.fields`. The trait's `@entity` binding is a three-layer merge:
      * declared entity field defaults < persistence entityData < this map.
      * Mutated only by the `set` effect handler.
+     *
+     * For a `[shared]` linked entity the map is keyed `$shared::<entityName>`
+     * instead of the trait name — ONE frame across every bound trait, the
+     * server half of the client hook's `sharedKeyByTraitName` groups. Without
+     * it a writer trait's `(set @entity.X …)` was invisible to a sibling's
+     * effect interpolation (the chat thread's refetch filter read "" while the
+     * composer held the open channel).
      */
     traitFieldStates: Map<string, EntityRow>;
 }
@@ -1199,6 +1206,14 @@ declare class OrbitalServerRuntime {
      * std registry on disk.
      */
     register(schema: OrbitalSchema): Promise<void>;
+    /**
+     * Teach the mock seeder which columns hold the viewer's id, derived from the
+     * schema's `[identity]` entity. No-op for a program that declares none, so
+     * unmigrated apps seed exactly as before. Mirrors
+     * `orbital-core/src/runtime/seed.rs::owner_fields_from_schema` — a feature
+     * that lives on only one execution path is not a feature.
+     */
+    private applyIdentityOwnerFields;
     /**
      * Register an OrbitalSchema synchronously (for backward compatibility).
      * Note: This version doesn't wait for instance seeding to complete.
@@ -1333,6 +1348,19 @@ declare class OrbitalServerRuntime {
     setDefaultUser(user: UserContext | undefined): void;
     /** The viewer a dev host is currently presenting the app as. */
     getDefaultUser(): UserContext | undefined;
+    /**
+     * `traitFieldStates` key for one trait: its own name, or — when its linked
+     * entity is `[shared]` — `$shared::<entityName>` so every trait bound to
+     * that entity reads/writes ONE frame. The server twin of the client hook's
+     * `sharedKeyByTraitName` (useTraitStateMachine): without it, a sibling
+     * trait's effect interpolation (a fetch filter reading
+     * `@entity.activeChannel`) never saw the writer's `(set …)`.
+     */
+    private sharedFieldKey;
+    /** Resolve an entity name to its declared `shared` flag: the orbital's own
+     *  entity, its auxiliary entities, then other registered orbitals' primary
+     *  entities (cross-orbital binds like a membership rail in the chat page). */
+    private isSharedEntity;
     /**
      * Process an event for an orbital
      *

package/dist/OrbitalServerRuntime.d.ts

@@ -1,4 +1,4 @@
 import 'express';
-export { F as ClientEffectTuple, G as ClientNavigateTuple, H as ClientNotifyTuple, J as ClientRenderUITuple, K as EffectResult, e as InMemoryPersistence, M as LiveBroadcastItem, N as LoaderConfig, O as OrbitalEventRequest, f as OrbitalEventResponse, Q as OrbitalServerRuntime, g as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RegisteredOrbital, l as RuntimeOrbital, m as RuntimeOrbitalSchema, n as RuntimeTrait, T as RuntimeTraitTick, p as collectDeclaredConfigDefaults, V as createOrbitalServerRuntime } from './OrbitalServerRuntime-f0EZSw4f.js';
-import './types-p_L8-Sk4.js';
+export { F as ClientEffectTuple, G as ClientNavigateTuple, H as ClientNotifyTuple, J as ClientRenderUITuple, K as EffectResult, e as InMemoryPersistence, M as LiveBroadcastItem, N as LoaderConfig, O as OrbitalEventRequest, f as OrbitalEventResponse, Q as OrbitalServerRuntime, g as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RegisteredOrbital, l as RuntimeOrbital, m as RuntimeOrbitalSchema, n as RuntimeTrait, T as RuntimeTraitTick, p as collectDeclaredConfigDefaults, V as createOrbitalServerRuntime } from './OrbitalServerRuntime-A2h0EikK.js';
+import './types-CL03tjGU.js';
 import '@almadar/core';

package/dist/OrbitalServerRuntime.js

@@ -1,5 +1,5 @@
-import { createTickScheduler, EventBus, createUnifiedLoader, MockPersistenceAdapter, InMemoryPersistence, preprocessSchema, normalizeCallSiteConfigToValues, StateMachineManager, parseDurationString, createContextFromBindings, validateEventPayload, formatPayloadValidationError, collectDeclaredConfigDefaults, resolveCallSitePayloadCaptures, collectDeclaredEntityDefaults, EffectExecutor } from './chunk-2SM626PK.js';
-export { InMemoryPersistence, collectDeclaredConfigDefaults } from './chunk-2SM626PK.js';
+import { createTickScheduler, EventBus, createUnifiedLoader, MockPersistenceAdapter, InMemoryPersistence, preprocessSchema, normalizeCallSiteConfigToValues, StateMachineManager, parseDurationString, createContextFromBindings, validateEventPayload, formatPayloadValidationError, collectDeclaredConfigDefaults, resolveCallSitePayloadCaptures, collectDeclaredEntityDefaults, EffectExecutor } from './chunk-FIBEYLME.js';
+export { InMemoryPersistence, collectDeclaredConfigDefaults } from './chunk-FIBEYLME.js';
 import { isValidCronExpression } from './chunk-OU3ITB5S.js';
 import './chunk-T4VDAB4C.js';
 import './chunk-SCRAHWOC.js';
@@ -7,7 +7,8 @@ import './chunk-MLKGABMK.js';
 import { createLogger } from '@almadar/logger';
 import * as nodeModule from 'module';
 import { evaluateListenPayloadExpr, evaluateGuard, evaluate } from '@almadar/evaluator';
-import { buildResolvedTraitConfigs, isInlineTrait, isEntityCall, applyListenPayloadMapping, normalizeUserContext } from '@almadar/core';
+import { DEFAULT_VIEWER, buildResolvedTraitConfigs, isInlineTrait, isEntityCall, applyListenPayloadMapping, normalizeUserContext, isRuntimeEntity } from '@almadar/core';
+import { ownerFieldsFromSchema, identityEntityName } from '@almadar/core/mock';
 
 // src/identity/routing.ts
 function eventRouteKey(eventName, eventId) {
@@ -115,7 +116,12 @@ var OrbitalServerRuntime = class {
       // Default to mock mode for preview
       autoPreprocess: false,
       namespaceEvents: true,
-      ...config
+      ...config,
+      // `@user` is never Null. A host that named no viewer (no ALMADAR_PERSONA,
+      // no auth yet) otherwise renders every `viewerName: @user.name` blank, so
+      // the app cannot say who you are. DEFAULT_VIEWER carries an empty `role`,
+      // so no `@user.role` guard changes outcome — see its doc in @almadar/core.
+      defaultUser: config.defaultUser ?? DEFAULT_VIEWER
     };
     this.eventBus = new EventBus();
     if (config.loaderConfig?.loader) {
@@ -135,7 +141,9 @@ var OrbitalServerRuntime = class {
         // Let the dev viewer own some seeded rows, so ownership-scoped views
         // ("only mine") have data instead of being indistinguishable from a
         // broken filter. Columns are declared, never inferred by name.
-        ownerId: config.defaultUser?.id,
+        // `this.config`, not `config` — the DEFAULT_VIEWER fallback is applied
+        // there, and reading the raw param leaves every seeded row unowned.
+        ownerId: this.config.defaultUser?.id,
         ownerFields: config.mockOwnerFields
       });
       if (config.debug) {
@@ -293,6 +301,7 @@ var OrbitalServerRuntime = class {
         registerLog.warn("register:no-loader", { name: schema.name });
       }
     }
+    this.applyIdentityOwnerFields(schema);
     for (const orbital of schema.orbitals) {
       await this.registerOrbitalAsync(orbital);
     }
@@ -301,6 +310,23 @@ var OrbitalServerRuntime = class {
     this.resolvedSchema = schema;
     this.resolvedTraitConfigs = buildResolvedTraitConfigs(schema);
   }
+  /**
+   * Teach the mock seeder which columns hold the viewer's id, derived from the
+   * schema's `[identity]` entity. No-op for a program that declares none, so
+   * unmigrated apps seed exactly as before. Mirrors
+   * `orbital-core/src/runtime/seed.rs::owner_fields_from_schema` — a feature
+   * that lives on only one execution path is not a feature.
+   */
+  applyIdentityOwnerFields(schema) {
+    if (!(this.persistence instanceof MockPersistenceAdapter)) return;
+    const derived = ownerFieldsFromSchema(schema);
+    if (derived.length === 0) return;
+    this.persistence.addOwnerFields(derived);
+    persistLog.debug("mock:identity-owner-fields", {
+      identity: identityEntityName(schema),
+      columns: derived
+    });
+  }
   /**
    * Register an OrbitalSchema synchronously (for backward compatibility).
    * Note: This version doesn't wait for instance seeding to complete.
@@ -310,6 +336,7 @@ var OrbitalServerRuntime = class {
     if (this.config.debug) {
       registerLog.debug("register:schema-sync", { name: schema.name });
     }
+    this.applyIdentityOwnerFields(schema);
     for (const orbital of schema.orbitals) {
       this.registerOrbital(orbital);
     }
@@ -317,6 +344,7 @@ var OrbitalServerRuntime = class {
     this.setupTicks();
     this.resolvedSchema = schema;
     this.resolvedTraitConfigs = buildResolvedTraitConfigs(schema);
+    this.applyIdentityOwnerFields(schema);
   }
   /**
    * Returns the schema that this runtime is currently executing, post-
@@ -622,6 +650,16 @@ var OrbitalServerRuntime = class {
           const routeKey = eventRouteKey(bareEvent, listener.eventId);
           const cleanup = this.eventBus.on(routeKey, async (event) => {
             if (!matcher(event.source)) return;
+            if (event.source?.originClientId !== void 0) {
+              if (this.config.debug) {
+                xOrbitalLog.debug("listen:skip-client-origin", {
+                  receiverTrait: trait.name,
+                  event: listener.event,
+                  originClientId: event.source.originClientId
+                });
+              }
+              return;
+            }
             if (this.config.debug) {
               xOrbitalLog.debug("listen:received", () => ({
                 receiverOrbital: orbitalName,
@@ -887,6 +925,34 @@ var OrbitalServerRuntime = class {
   // ==========================================================================
   // Event Processing
   // ==========================================================================
+  /**
+   * `traitFieldStates` key for one trait: its own name, or — when its linked
+   * entity is `[shared]` — `$shared::<entityName>` so every trait bound to
+   * that entity reads/writes ONE frame. The server twin of the client hook's
+   * `sharedKeyByTraitName` (useTraitStateMachine): without it, a sibling
+   * trait's effect interpolation (a fetch filter reading
+   * `@entity.activeChannel`) never saw the writer's `(set …)`.
+   */
+  sharedFieldKey(registered, traitName) {
+    const trait = registered.traits.find((t) => t.name === traitName);
+    const linked = trait?.linkedEntity ?? registered.entity.name;
+    return this.isSharedEntity(registered, linked) ? `$shared::${linked}` : traitName;
+  }
+  /** Resolve an entity name to its declared `shared` flag: the orbital's own
+   *  entity, its auxiliary entities, then other registered orbitals' primary
+   *  entities (cross-orbital binds like a membership rail in the chat page). */
+  isSharedEntity(registered, entityName) {
+    if (registered.entity.name === entityName) return registered.entity.shared === true;
+    for (const aux of registered.schema.auxiliaryEntities ?? []) {
+      if (typeof aux === "object" && !isEntityCall(aux) && aux.name === entityName) {
+        return aux.shared === true;
+      }
+    }
+    for (const other of this.orbitals.values()) {
+      if (other.entity.name === entityName) return other.entity.shared === true;
+    }
+    return false;
+  }
   /**
    * Process an event for an orbital
    *
@@ -982,9 +1048,10 @@ var OrbitalServerRuntime = class {
         }
       }
       const entityByTrait = {};
-      for (const [name, fields] of registered.traitFieldStates) {
+      for (const trait of registered.traits) {
+        const fields = registered.traitFieldStates.get(this.sharedFieldKey(registered, trait.name));
         if (fields && Object.keys(fields).length > 0) {
-          entityByTrait[name] = fields;
+          entityByTrait[trait.name] = fields;
         }
       }
       const results = registered.manager.sendEvent(
@@ -1099,6 +1166,9 @@ var OrbitalServerRuntime = class {
         if (stamp.eventId === void 0 && emitContract?.eventId !== void 0) {
           stamp.eventId = emitContract.eventId;
         }
+        if (originClientId !== void 0 && stamp.originClientId === void 0) {
+          stamp.originClientId = originClientId;
+        }
         this.eventBus.emit(event, eventPayload, stamp, eventRouteKey(event, stamp.eventId));
         const emittedItem = { event, payload: eventPayload, source: stamp };
         emittedEvents.push(emittedItem);
@@ -1127,10 +1197,11 @@ var OrbitalServerRuntime = class {
         }
       },
       set: async (targetId, field, value) => {
-        let fieldState = registered.traitFieldStates.get(traitName);
+        const fieldKey = this.sharedFieldKey(registered, traitName);
+        let fieldState = registered.traitFieldStates.get(fieldKey);
         if (!fieldState) {
           fieldState = {};
-          registered.traitFieldStates.set(traitName, fieldState);
+          registered.traitFieldStates.set(fieldKey, fieldState);
         }
         fieldState[field] = value;
         effectResults.push({
@@ -1503,7 +1574,10 @@ var OrbitalServerRuntime = class {
           bindings: bindingsRef ?? {},
           context: contextRef ?? { traitName, orbitalName: registered.schema.name, state: "unknown", transition: "unknown" },
           debug: this.config.debug,
-          contextExtensions: this.config.contextExtensions
+          contextExtensions: this.config.contextExtensions,
+          // Same render-time marker boundary as the outer executor
+          // (including the [shared]-defers-regardless-of-persistence rule).
+          deferRenderBindings: registered.entity === void 0 || isRuntimeEntity(registered.entity) || registered.entity.shared === true
         });
         for (const innerEffect of atomicEffects) {
           if (atomicFailed) break;
@@ -1591,7 +1665,7 @@ var OrbitalServerRuntime = class {
       };
     }
     const entityFieldDefaults = collectDeclaredEntityDefaults(registered.entity);
-    const traitFieldState = registered.traitFieldStates.get(traitName);
+    const traitFieldState = registered.traitFieldStates.get(this.sharedFieldKey(registered, traitName));
     if (entityFieldDefaults || traitFieldState) {
       bindings.entity = {
         ...entityFieldDefaults ?? {},
@@ -1616,7 +1690,19 @@ var OrbitalServerRuntime = class {
       bindings,
       context,
       debug: this.config.debug,
-      contextExtensions: this.config.contextExtensions
+      contextExtensions: this.config.contextExtensions,
+      // Carry `@entity`-dependent render-ui leaves as render-time markers
+      // for runtime-only (and unlinked) entities: the client's local state
+      // machines execute the same `(set)` writes, so the renderer resolves
+      // markers against its live store — otherwise these SSE-pushed eager
+      // props clobber the client's live marker frames on every event.
+      // Persistent NON-shared entities stay eager: their `@entity` merges
+      // persistence rows the client does not hold. A `[shared]` entity is
+      // deferred REGARDLESS of persistence — its trait frame's scalars are
+      // client-held by contract (one live frame across bound traits), and
+      // the eager clobber pinned the chat composer's controlled input to
+      // the server's flush-time "" on every keystroke round-trip.
+      deferRenderBindings: registered.entity === void 0 || isRuntimeEntity(registered.entity) || registered.entity.shared === true
     });
     await executor.executeAll(effects);
   }

package/dist/ServerBridge.d.ts

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

package/dist/{chunk-2SM626PK.js → chunk-FIBEYLME.js}

@@ -5,7 +5,7 @@ import { createLogger, setNamespaceLevel } from '@almadar/logger';
 import { createMinimalContext, resolveBinding, evaluate, evaluateGuard, SExpressionEvaluator } from '@almadar/evaluator';
 export { createMinimalContext } from '@almadar/evaluator';
 import { isKnownStdOperator } from '@almadar/std/registry';
-import { OrbitalSchemaSchema, isInlineTrait, isEntityCall, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef, isReferenceConfigType, configRefEventKnob, normalizeCallSiteConfigToValues, resolveConfigRefEventName } from '@almadar/core';
+import { containsEntityBinding, containsPayloadBinding, RENDER_BINDING_MARKER, OrbitalSchemaSchema, isInlineTrait, isEntityCall, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef, isReferenceConfigType, configRefEventKnob, normalizeCallSiteConfigToValues, resolveConfigRefEventName } from '@almadar/core';
 export { normalizeCallSiteConfigToValues } from '@almadar/core';
 import { sampleRowCount, sampleRow } from '@almadar/core/mock';
 
@@ -291,6 +291,7 @@ function isValidDurationString(interval) {
 }
 var bindLog = createLogger("almadar:runtime:bindings");
 setNamespaceLevel("almadar:runtime:bindings", "WARN");
+var deferLog = createLogger("almadar:runtime:defer");
 var renderLog = createLogger("almadar:runtime:render-ui");
 var CLIENT_ONLY_BINDING_ROOTS = /* @__PURE__ */ new Set(["trait"]);
 var CALLSITE_PAYLOAD_PREFIX = "@callsitePayload.";
@@ -396,6 +397,45 @@ function interpolateValue(value, ctx) {
   }
   return value;
 }
+function deferEntityBindings(value, ctx, configHops = 0) {
+  if (typeof value === "string") {
+    if (containsEntityBinding(value) && !containsPayloadBinding(value)) {
+      return { [RENDER_BINDING_MARKER]: true, expression: value };
+    }
+    if (value.startsWith("@config.") && !value.includes(" ") && configHops < 8) {
+      const hop = ctx.config?.[value.slice("@config.".length)];
+      deferLog.debug("defer:config-hop", () => ({
+        forward: value,
+        hopType: typeof hop,
+        hopPreview: typeof hop === "string" ? hop : Array.isArray(hop) ? "array" : hop === void 0 ? "undefined" : "object"
+      }));
+      if (hop !== void 0 && hop !== value) {
+        return deferEntityBindings(hop, ctx, configHops + 1);
+      }
+    }
+    return interpolateValue(value, ctx);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 3 && value[0] === "fn" && typeof value[1] === "string") {
+      return value;
+    }
+    if (isSExpression(value)) {
+      if (containsEntityBinding(value) && !containsPayloadBinding(value)) {
+        return { [RENDER_BINDING_MARKER]: true, expression: value };
+      }
+      return interpolateValue(value, ctx);
+    }
+    return value.map((item) => deferEntityBindings(item, ctx));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = deferEntityBindings(item, ctx);
+    }
+    return out;
+  }
+  return value;
+}
 var inFlightConfigRecursions = /* @__PURE__ */ new Set();
 function interpolateString(value, ctx) {
   if (value.startsWith("@") && isPureBinding(value)) {
@@ -1178,6 +1218,18 @@ function resolveArgs(args, bindings, strictBindings, contextExtensions) {
   const ctx = createContextFromBindings(bindings, strictBindings, contextExtensions);
   return args.map((arg) => interpolateValue(arg, ctx));
 }
+function interpolateFilterTraitRefs(value, ctx) {
+  if (typeof value === "string") {
+    return value === "@entity" || value.startsWith("@entity.") ? interpolateValue(value, ctx) : value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length >= 2 && value[0] === "object/get" && value[1] === "@entity") {
+      return value;
+    }
+    return value.map((v) => interpolateFilterTraitRefs(v, ctx));
+  }
+  return value;
+}
 var EffectExecutor = class _EffectExecutor {
   handlers;
   bindings;
@@ -1186,6 +1238,7 @@ var EffectExecutor = class _EffectExecutor {
   strictBindings;
   contextExtensions;
   evaluator;
+  deferRenderBindings;
   constructor(options) {
     this.handlers = options.handlers;
     this.bindings = options.bindings;
@@ -1194,6 +1247,7 @@ var EffectExecutor = class _EffectExecutor {
     this.strictBindings = options.strictBindings ?? false;
     this.contextExtensions = options.contextExtensions;
     this.evaluator = options.evaluator;
+    this.deferRenderBindings = options.deferRenderBindings ?? false;
   }
   _evaluator;
   getEvaluator() {
@@ -1293,9 +1347,15 @@ var EffectExecutor = class _EffectExecutor {
     const isCompound = operator === "do" || operator === "when" || operator === "let" || operator === "if";
     const isSetPathForm = operator === "set" && args.length >= 2 && typeof args[0] === "string" && args[0].startsWith("@entity.");
     const isFetchLike = (operator === "fetch" || operator === "ref" || operator === "deref" || operator === "os/watch-collection" || operator === "os/watch") && args.length >= 2 && args[1] !== null && typeof args[1] === "object" && !Array.isArray(args[1]);
+    const isDeferringRenderUI = (operator === "render-ui" || operator === "render") && this.deferRenderBindings;
     let resolvedArgs;
     if (isCompound) {
       resolvedArgs = args;
+    } else if (isDeferringRenderUI) {
+      const ctx = createContextFromBindings(this.bindings, this.strictBindings, this.contextExtensions);
+      resolvedArgs = args.map(
+        (arg, index) => index === 0 ? interpolateValue(arg, ctx) : deferEntityBindings(arg, ctx)
+      );
     } else if (isSetPathForm) {
       const ctx = createContextFromBindings(this.bindings, this.strictBindings, this.contextExtensions);
       const resolvedRest = [];
@@ -1316,7 +1376,7 @@ var EffectExecutor = class _EffectExecutor {
       const opts = args[1];
       const resolvedOpts = {
         ...opts.id !== void 0 && { id: interpolateValue(opts.id, ctx) },
-        ...opts.filter !== void 0 && { filter: opts.filter },
+        ...opts.filter !== void 0 && { filter: interpolateFilterTraitRefs(opts.filter, ctx) },
         ...opts.limit !== void 0 && { limit: interpolateValue(opts.limit, ctx) },
         ...opts.offset !== void 0 && { offset: interpolateValue(opts.offset, ctx) },
         ...opts.include !== void 0 && { include: interpolateValue(opts.include, ctx) },
@@ -1868,7 +1928,8 @@ var EffectExecutor = class _EffectExecutor {
           context: this.context,
           debug: this.debug,
           strictBindings: this.strictBindings,
-          contextExtensions: this.contextExtensions
+          contextExtensions: this.contextExtensions,
+          deferRenderBindings: this.deferRenderBindings
         });
         await bodyExecutor.execute(body);
         break;
@@ -2346,6 +2407,22 @@ var MockPersistenceAdapter = class {
     seedRandom(this.config.seed);
     mockLog.debug("mock:adapter:init", { seed: this.config.seed });
   }
+  /**
+   * Add owner columns discovered after construction.
+   *
+   * The adapter is built before any schema is registered, so schema-DERIVED
+   * owner columns (relation fields pointing at the `[identity]` entity) can
+   * only arrive later.
+   *
+   * ⚠️ Seeding is EAGER — `registerEntity()` seeds immediately — so callers must
+   * supply these columns BEFORE registering any orbital. Calling this afterwards
+   * silently stamps nothing.
+   */
+  addOwnerFields(fields) {
+    if (fields.length === 0) return;
+    const merged = /* @__PURE__ */ new Set([...this.config.ownerFields ?? [], ...fields]);
+    this.config.ownerFields = [...merged];
+  }
   /** Re-anchor the PRNG to the configured seed. Called before every
    *  re-seed loop so identical reseed sequences produce identical rows
    *  (timestamps + generated fields). Without this, the first
@@ -2422,6 +2499,9 @@ var MockPersistenceAdapter = class {
       if (relationFields.length === 0) continue;
       for (const row of store.values()) {
         for (const field of relationFields) {
+          if (this.config.ownerId !== void 0 && row[field.name] === this.config.ownerId) {
+            continue;
+          }
           const targetNormalized = (field.relation.entityId && this.storeNameById.get(field.relation.entityId)) ?? field.relation.entity.toLowerCase();
           const targetStore = this.stores.get(targetNormalized);
           if (!targetStore || targetStore.size === 0) continue;
@@ -3642,6 +3722,96 @@ function renameEntityInEffect(effect, rename, props) {
   }
   return effect;
 }
+var TRAIT_EMBED_PREFIX = "@trait.";
+function renameTraitEmbedsInValue(node, subs) {
+  if (node === null || node === void 0) return node;
+  if (typeof node === "string") {
+    if (!node.startsWith(TRAIT_EMBED_PREFIX)) return node;
+    const rest = node.slice(TRAIT_EMBED_PREFIX.length);
+    const dot = rest.search(/[.[]/);
+    const name = dot === -1 ? rest : rest.slice(0, dot);
+    const suffix = dot === -1 ? "" : rest.slice(dot);
+    const to = subs.get(name);
+    return to === void 0 ? node : `${TRAIT_EMBED_PREFIX}${to}${suffix}`;
+  }
+  if (Array.isArray(node)) return node.map((item) => renameTraitEmbedsInValue(item, subs));
+  if (typeof node !== "object") return node;
+  const next = {};
+  for (const [key, value] of Object.entries(node)) {
+    next[key] = renameTraitEmbedsInValue(value, subs);
+  }
+  return next;
+}
+function renameTraitEmbeds(trait, subs) {
+  if (subs.size === 0) return trait;
+  const sm = trait.stateMachine;
+  const next = { ...trait };
+  if (sm) {
+    next.stateMachine = {
+      ...sm,
+      transitions: (sm.transitions ?? []).map(
+        (t) => t.effects ? { ...t, effects: renameTraitEmbedsInValue(t.effects, subs) } : t
+      )
+    };
+  }
+  if (trait.ticks) {
+    next.ticks = trait.ticks.map(
+      (tick) => tick.effects ? { ...tick, effects: renameTraitEmbedsInValue(tick.effects, subs) } : tick
+    );
+  }
+  if (trait.config) {
+    const nextConfig = {};
+    for (const [key, field] of Object.entries(trait.config)) {
+      nextConfig[key] = field.default === void 0 ? field : {
+        ...field,
+        default: renameTraitEmbedsInValue(
+          field.default,
+          subs
+        )
+      };
+    }
+    next.config = nextConfig;
+  }
+  return next;
+}
+function findTraitEntryInOrbital(orbital, localName) {
+  for (const traitRef of orbital.traits ?? []) {
+    if (typeof traitRef === "string") continue;
+    if ("stateMachine" in traitRef) {
+      if (traitRef.name === localName) return traitRef;
+      continue;
+    }
+    if (!("ref" in traitRef)) continue;
+    const refObj = traitRef;
+    const declared = refObj.name ?? parseImportedTraitRef(refObj.ref)?.traitName;
+    if (declared === localName) return traitRef;
+  }
+  return null;
+}
+function traitEmbedNamesOf(trait) {
+  const found = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    if (node === null || node === void 0) return;
+    if (typeof node === "string") {
+      if (!node.startsWith(TRAIT_EMBED_PREFIX)) return;
+      const rest = node.slice(TRAIT_EMBED_PREFIX.length);
+      const dot = rest.search(/[.[]/);
+      const name = dot === -1 ? rest : rest.slice(0, dot);
+      if (name.length > 0) found.add(name);
+      return;
+    }
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item);
+      return;
+    }
+    if (typeof node !== "object") return;
+    for (const value of Object.values(node)) walk(value);
+  };
+  for (const t of trait.stateMachine?.transitions ?? []) walk(t.effects);
+  for (const tick of trait.ticks ?? []) walk(tick.effects);
+  for (const field of Object.values(trait.config ?? {})) walk(field.default);
+  return [...found];
+}
 function applyLinkedEntityRename(trait, linkedEntity) {
   const atomLinked = trait.linkedEntity;
   if (!linkedEntity || !atomLinked || linkedEntity === atomLinked) return trait;
@@ -3813,6 +3983,8 @@ var ReferenceResolver = class {
   localTraits;
   /** id-keyed mirror of `localTraits`, populated wherever the trait carries an `id`. */
   localTraitsById = /* @__PURE__ */ new Map();
+  /** Import scope of each loaded source orbital, keyed by its source path. */
+  sourceImportsCache = /* @__PURE__ */ new Map();
   loaderInitialized = false;
   constructor(options) {
     this.options = options;
@@ -3869,6 +4041,10 @@ var ReferenceResolver = class {
     if (!entityResult.success || !traitsResult.success || !pagesResult.success) {
       return { success: false, errors: ["Internal error: unexpected failure state"] };
     }
+    const pullErrors = await this.pullSiblingTraits(traitsResult.data, imports, importChain);
+    if (pullErrors.length > 0) {
+      return { success: false, errors: pullErrors };
+    }
     for (const resolvedTrait of traitsResult.data) {
       resolvedTrait.trait = resolveEntityTokensById(resolvedTrait.trait, imports.idIndex);
       resolvedTrait.trait = resolveConfigRefsById(resolvedTrait.trait, imports.idIndex);
@@ -4042,6 +4218,191 @@ var ReferenceResolver = class {
     }
     return { success: true, data: resolved, warnings: [] };
   }
+  /**
+   * The import scope of an already-loaded orbital, memoised per source path.
+   * A sibling that is itself a ref names its target through the SOURCE atom's
+   * aliases, so it can only be resolved against those.
+   */
+  async importsOfSource(imported, chain) {
+    const key = imported.sourcePath ?? `${imported.alias}:${imported.from}`;
+    const cached = this.sourceImportsCache.get(key);
+    if (cached) return cached;
+    const result = await this.resolveImports(
+      imported.orbital.uses ?? [],
+      imported.sourcePath,
+      chain
+    );
+    if (!result.success) return null;
+    result.data.idIndex = buildIdIndex(imported.orbital, result.data.orbitals);
+    this.sourceImportsCache.set(key, result.data);
+    return result.data;
+  }
+  /**
+   * Sibling-trait auto-pull — the JS twin of the compiler's
+   * `phases/inline/trait.rs` pass, appending to `resolved` in place.
+   *
+   * An atom's main trait embeds its own sub-views as `@trait.<Sibling>` string
+   * literals (`std-browse`'s `bodyContent: {children: [@trait.DataGrid1]}`).
+   * A consumer that imports only the main trait never instantiates those
+   * siblings, so the token dangles: no state machine, no fetch, an empty list
+   * where the grid should be. The compiled path materialises them; without this
+   * pass the interpreted path did not, so a raw `.orb` handed straight to
+   * `OrbitalServerRuntime` rendered a different app than the same `.orb` run
+   * through `orbital resolve`.
+   *
+   * Pulls are keyed per EMBEDDER (`owner` = the top-level consumer trait that
+   * started the chain), not per atom. Two rebinds of one atom in one orbital
+   * (`ChannelRail -> Channel` and `ChatThread -> ChatMessage`, both std-browse)
+   * carry different entity rebinds and different hosts to listen to, so one
+   * shared copy can only ever serve one of them. The first owner keeps the
+   * source name; later owners pull under `<Owner><Sibling>` — unique by
+   * construction, since owner names are unique within the orbital.
+   */
+  async pullSiblingTraits(resolved, imports, chain) {
+    const work = [];
+    const ownerSubs = /* @__PURE__ */ new Map();
+    const subsFor = (owner) => {
+      let m = ownerSubs.get(owner);
+      if (!m) {
+        m = /* @__PURE__ */ new Map();
+        ownerSubs.set(owner, m);
+      }
+      return m;
+    };
+    for (const rt of resolved) {
+      if (rt.source.type !== "imported" || !rt.trait.name) continue;
+      const owner = rt.trait.name;
+      subsFor(owner).set(rt.source.traitName, owner);
+      for (const sibling of traitEmbedNamesOf(rt.trait)) {
+        work.push({ alias: rt.source.alias, sibling, linkedEntity: rt.linkedEntity, parent: owner, owner });
+      }
+    }
+    if (work.length === 0) return [];
+    const errors = [];
+    const consumerDeclared = new Set(resolved.map((r) => r.trait.name).filter(Boolean));
+    const seen = new Set(consumerDeclared);
+    const visited = /* @__PURE__ */ new Set();
+    const pulledAs = /* @__PURE__ */ new Map();
+    const ownerOf = /* @__PURE__ */ new Map();
+    const parentRewrites = /* @__PURE__ */ new Map();
+    const pulled = [];
+    const noteRewrite = (parent, from, to) => {
+      let m = parentRewrites.get(parent);
+      if (!m) {
+        m = /* @__PURE__ */ new Map();
+        parentRewrites.set(parent, m);
+      }
+      m.set(from, to);
+    };
+    for (let item = work.pop(); item !== void 0; item = work.pop()) {
+      const { alias, sibling, linkedEntity, parent, owner } = item;
+      const pullKey = `${alias}\0${sibling}\0${owner}`;
+      const existing = pulledAs.get(pullKey);
+      if (existing !== void 0) {
+        if (existing !== sibling) noteRewrite(parent, sibling, existing);
+        continue;
+      }
+      let finalName = sibling;
+      if (seen.has(sibling)) {
+        if (consumerDeclared.has(sibling)) continue;
+        finalName = `${owner}${sibling}`;
+        if (seen.has(finalName)) continue;
+      }
+      if (visited.has(pullKey)) continue;
+      visited.add(pullKey);
+      const imported = imports.orbitals.get(alias);
+      if (!imported) continue;
+      const atomEntry = findTraitEntryInOrbital(imported.orbital, sibling);
+      if (!atomEntry) continue;
+      let atomTrait;
+      if ("stateMachine" in atomEntry) {
+        const { trait: cfgResolved, errors: cfgErrors } = resolveConfigRefEmitNames(
+          atomEntry
+        );
+        if (cfgErrors.length > 0) {
+          errors.push(...cfgErrors);
+          continue;
+        }
+        atomTrait = cfgResolved;
+      } else {
+        const srcImports = await this.importsOfSource(imported, chain);
+        if (!srcImports) continue;
+        const refObj = atomEntry;
+        const nested = this.resolveTraitRefString(
+          refObj.ref,
+          srcImports,
+          refObj.config,
+          refObj.linkedEntity,
+          refObj.name ?? sibling,
+          refObj.events,
+          refObj.listens,
+          refObj.refId
+        );
+        if (!nested.success) {
+          errors.push(...nested.errors);
+          continue;
+        }
+        atomTrait = nested.data.trait;
+      }
+      let copy = applyLinkedEntityRename(atomTrait, linkedEntity);
+      if (finalName !== sibling) {
+        copy = { ...copy, name: finalName };
+        noteRewrite(parent, sibling, finalName);
+      }
+      for (const next of traitEmbedNamesOf(copy)) {
+        work.push({ alias, sibling: next, linkedEntity, parent: finalName, owner });
+      }
+      pulledAs.set(pullKey, finalName);
+      subsFor(owner).set(sibling, finalName);
+      ownerOf.set(finalName, owner);
+      seen.add(finalName);
+      pulled.push({
+        trait: copy,
+        source: { type: "imported", alias, traitName: sibling },
+        ...linkedEntity !== void 0 ? { linkedEntity } : {}
+      });
+    }
+    if (pulled.length === 0 && parentRewrites.size === 0) return errors;
+    const applyRewrites = (rt) => {
+      const subs = rt.trait.name ? parentRewrites.get(rt.trait.name) : void 0;
+      if (subs) rt.trait = renameTraitEmbeds(rt.trait, subs);
+    };
+    for (const rt of resolved) applyRewrites(rt);
+    for (const rt of pulled) applyRewrites(rt);
+    const idByName = /* @__PURE__ */ new Map();
+    for (const rt of [...resolved, ...pulled]) {
+      if (rt.trait.name) idByName.set(rt.trait.name, rt.trait.id);
+    }
+    for (const rt of pulled) {
+      const listens = rt.trait.listens;
+      const owner = rt.trait.name ? ownerOf.get(rt.trait.name) : void 0;
+      const subs = owner ? ownerSubs.get(owner) : void 0;
+      if (!listens || listens.length === 0 || !subs) continue;
+      let changed = false;
+      const nextListens = listens.map((listen) => {
+        const source = listen.source;
+        if (!source || source.kind !== "trait") return listen;
+        const target = subs.get(source.trait);
+        if (target === void 0 || target === source.trait) return listen;
+        changed = true;
+        const traitId = idByName.get(target);
+        return {
+          ...listen,
+          source: { kind: "trait", trait: target, ...traitId ? { traitId } : {} }
+        };
+      });
+      if (changed) rt.trait = { ...rt.trait, listens: nextListens };
+    }
+    refResolverLog.info("sibling-pull", {
+      pulled: pulled.map((p) => ({
+        trait: p.trait.name,
+        owner: p.trait.name ? ownerOf.get(p.trait.name) : void 0,
+        linkedEntity: p.linkedEntity ?? p.trait.linkedEntity
+      }))
+    });
+    resolved.push(...pulled);
+    return errors;
+  }
   /**
    * Resolve a single trait reference.
    */
@@ -4582,4 +4943,4 @@ var InMemoryPersistence = class {
   }
 };
 
-export { CALLSITE_PAYLOAD_PREFIX, EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, TickScheduler, buildEmitsFromTraits, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createTestExecutor, createTickScheduler, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, isValidDurationString, normalizeEventKey, parseDurationString, parseNamespacedEvent, preprocessSchema, processEvent, resolveCallSitePayloadCaptures, validateEventPayload, validatePayloadShapes };
+export { CALLSITE_PAYLOAD_PREFIX, EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, TickScheduler, buildEmitsFromTraits, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createTestExecutor, createTickScheduler, createUnifiedLoader, deferEntityBindings, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, isValidDurationString, normalizeEventKey, parseDurationString, parseNamespacedEvent, preprocessSchema, processEvent, resolveCallSitePayloadCaptures, validateEventPayload, validatePayloadShapes };

package/dist/createOsHandlers.d.ts

@@ -1,4 +1,4 @@
-import { E as EffectHandlers } from './types-p_L8-Sk4.js';
+import { E as EffectHandlers } from './types-CL03tjGU.js';
 import { EventPayload } from '@almadar/core';
 
 /**

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { B as BindingContext, f as EvaluationContextExtensions, P as PatternProps, E as EffectHandlers, g as EffectContext, h as ExecutionEnvironment, i as EffectResult, T as TraitDefinition } from './types-p_L8-Sk4.js';
-export { j as BrowserFileMeta, k as BrowserFilePickerOptions, l as BrowserGeolocationOptions, m as BrowserGeolocationPosition, C as ConfigContext, n as Effect, a as EventListener, H as HANDLER_MANIFEST, I as IEventBus, b as RuntimeConfig, R as RuntimeEvent, d as TraitState, c as TransitionObserver, e as TransitionResult, U as Unsubscribe } from './types-p_L8-Sk4.js';
-import { U as UnifiedLoaderOptions, S as SchemaLoader, I as ImportChainLike, L as LoadResult, a as LoadedSchema, b as LoadedOrbital, P as PersistenceAdapter } from './OrbitalServerRuntime-f0EZSw4f.js';
-export { E as EntitySharingMap, c as EventBus, d as EventNamespaceMap, e as InMemoryPersistence, O as OrbitalEventRequest, f as OrbitalEventResponse, g as OrbitalServerRuntimeConfig, h as PreprocessOptions, i as PreprocessResult, j as PreprocessedSchema, k as ProcessEventOptions, R as RegisteredOrbital, l as RuntimeOrbital, m as RuntimeOrbitalSchema, n as RuntimeTrait, o as StateMachineManager, p as collectDeclaredConfigDefaults, q as collectDeclaredEntityDefaults, r as createInitialTraitState, s as findInitialState, t as findTransition, u as getIsolatedCollectionName, v as getNamespacedEvent, w as isBrowser, x as isElectron, y as isNamespacedEvent, z as isNode, A as normalizeEventKey, B as parseNamespacedEvent, C as preprocessSchema, D as processEvent } from './OrbitalServerRuntime-f0EZSw4f.js';
+import { g as RuntimePatternValue, B as BindingContext, f as EvaluationContextExtensions, P as PatternProps, E as EffectHandlers, h as EffectContext, i as ExecutionEnvironment, j as EffectResult, T as TraitDefinition } from './types-CL03tjGU.js';
+export { k as BrowserFileMeta, l as BrowserFilePickerOptions, m as BrowserGeolocationOptions, n as BrowserGeolocationPosition, C as ConfigContext, o as Effect, a as EventListener, H as HANDLER_MANIFEST, I as IEventBus, b as RuntimeConfig, R as RuntimeEvent, d as TraitState, c as TransitionObserver, e as TransitionResult, U as Unsubscribe } from './types-CL03tjGU.js';
+import { U as UnifiedLoaderOptions, S as SchemaLoader, I as ImportChainLike, L as LoadResult, a as LoadedSchema, b as LoadedOrbital, P as PersistenceAdapter } from './OrbitalServerRuntime-A2h0EikK.js';
+export { E as EntitySharingMap, c as EventBus, d as EventNamespaceMap, e as InMemoryPersistence, O as OrbitalEventRequest, f as OrbitalEventResponse, g as OrbitalServerRuntimeConfig, h as PreprocessOptions, i as PreprocessResult, j as PreprocessedSchema, k as ProcessEventOptions, R as RegisteredOrbital, l as RuntimeOrbital, m as RuntimeOrbitalSchema, n as RuntimeTrait, o as StateMachineManager, p as collectDeclaredConfigDefaults, q as collectDeclaredEntityDefaults, r as createInitialTraitState, s as findInitialState, t as findTransition, u as getIsolatedCollectionName, v as getNamespacedEvent, w as isBrowser, x as isElectron, y as isNamespacedEvent, z as isNode, A as normalizeEventKey, B as parseNamespacedEvent, C as preprocessSchema, D as processEvent } from './OrbitalServerRuntime-A2h0EikK.js';
 import { EvaluationContext, SExpressionEvaluator } from '@almadar/evaluator';
 export { EvaluationContext, createMinimalContext } from '@almadar/evaluator';
-import { TraitConfigObject, EventPayload, PatternConfig, EntityId, EntityField, EntityRow, EntityPersistence, ServiceParams, PayloadField, OrbitalDefinition, OrbitalSchema } from '@almadar/core';
+import { RenderBindingMarker, SExpr, TraitConfigObject, EventPayload, PatternConfig, EntityId, EntityField, EntityRow, EntityPersistence, ServiceParams, PayloadField, OrbitalDefinition, OrbitalSchema } from '@almadar/core';
 export { EntityField, normalizeCallSiteConfigToValues } from '@almadar/core';
 export { ServerBridgeConfig, ServerBridgeState } from './ServerBridge.js';
 export { OsHandlerContext, OsHandlerResult } from './createOsHandlers.js';
@@ -284,6 +284,28 @@ declare function interpolateProps(props: PatternProps, ctx: EvaluationContext):
  * Interpolate a single value.
  */
 declare function interpolateValue(value: unknown, ctx: EvaluationContext): unknown;
+/**
+ * Value a deferred render-ui prop tree can carry: interpolated runtime
+ * values, raw pass-through S-expressions (`fn` lambdas), render-time
+ * binding markers, and nested arrays/records of the same. No `unknown`
+ * escape hatch.
+ */
+type DeferredPatternValue = RuntimePatternValue | RenderBindingMarker | SExpr | Date | readonly DeferredPatternValue[] | {
+    readonly [prop: string]: DeferredPatternValue;
+};
+/**
+ * Carry `@entity`-dependent prop leaves into slot content as
+ * `RenderBindingMarker`s instead of resolving them at flush time — the
+ * renderer (`@almadar/ui`'s SlotContentRenderer) evaluates each marker
+ * against the live entity store on every React render, the same model the
+ * compiled shell uses. Everything else resolves eagerly through the same
+ * `interpolateValue` path the non-deferring executor uses:
+ * - payload-referencing leaves stay eager (`@payload` is event-scoped and
+ *   does not exist at render time);
+ * - `fn` render lambdas pass through raw (they are already render-time);
+ * - literal arrays (children lists) and plain objects recurse per item.
+ */
+declare function deferEntityBindings(value: SExpr, ctx: EvaluationContext, configHops?: number): DeferredPatternValue;
 /**
  * Check if a value contains any binding references.
  */
@@ -328,6 +350,14 @@ interface EffectExecutorOptions {
     contextExtensions?: EvaluationContextExtensions;
     /** Evaluator for resolving nested S-expression values in `set` (e.g., substrate operators) */
     evaluator?: SExpressionEvaluator;
+    /**
+     * When true, render-ui args keep `@entity`-dependent prop leaves as
+     * `RenderBindingMarker`s for render-time evaluation instead of resolving
+     * them eagerly at flush time. Set by the client-side interpreter
+     * (`useTraitStateMachine`); server-side executors resolve eagerly so
+     * SSE-pushed props stay concrete.
+     */
+    deferRenderBindings?: boolean;
 }
 /**
  * EffectExecutor - Routes effects to handlers.
@@ -363,6 +393,7 @@ declare class EffectExecutor {
     private strictBindings;
     private contextExtensions?;
     private evaluator?;
+    private deferRenderBindings;
     constructor(options: EffectExecutorOptions);
     private _evaluator?;
     private getEvaluator;
@@ -585,6 +616,18 @@ declare class MockPersistenceAdapter implements PersistenceAdapter {
     private storeNameById;
     private config;
     constructor(config?: MockPersistenceConfig);
+    /**
+     * Add owner columns discovered after construction.
+     *
+     * The adapter is built before any schema is registered, so schema-DERIVED
+     * owner columns (relation fields pointing at the `[identity]` entity) can
+     * only arrive later.
+     *
+     * ⚠️ Seeding is EAGER — `registerEntity()` seeds immediately — so callers must
+     * supply these columns BEFORE registering any orbital. Calling this afterwards
+     * silently stamps nothing.
+     */
+    addOwnerFields(fields: readonly string[]): void;
     /** Re-anchor the PRNG to the configured seed. Called before every
      *  re-seed loop so identical reseed sequences produce identical rows
      *  (timestamps + generated fields). Without this, the first
@@ -1033,4 +1076,4 @@ declare namespace index {
   export { type index_ComposeBehaviorsInput as ComposeBehaviorsInput, type index_ComposeBehaviorsResult as ComposeBehaviorsResult, type index_EventWiringEntry as EventWiringEntry, type index_LayoutStrategy as LayoutStrategy, type index_PipeStep as PipeStep, index_applyEventWiring as applyEventWiring, index_composeBehaviors as composeBehaviors, index_detectLayoutStrategy as detectLayoutStrategy, index_pipeBehaviors as pipeBehaviors };
 }
 
-export { BindingContext, CALLSITE_PAYLOAD_PREFIX, type ClientEventBus, type ComposeBehaviorsInput, type ComposeBehaviorsResult, type CreateClientEffectHandlersOptions, type CreateServerEffectHandlersOptions, type CronFields, EffectContext, EffectExecutor, type EffectExecutorOptions, EffectHandlers, EffectResult, type EntitySchema, type EventWiringEntry, ExecutionEnvironment, ImportChainLike, type LayoutStrategy, LoadResult, LoadedOrbital, LoadedSchema, MockPersistenceAdapter, type MockPersistenceConfig, type PayloadMismatch, type PayloadValidationFailure, PersistenceAdapter, type PipeStep, SchemaLoader, type ServerEffectResult, type SlotSetter, type TickHandle, TickScheduler, TraitDefinition, UnifiedLoaderOptions, applyEventWiring, buildEmitsFromTraits, composeBehaviors, index as composition, containsBindings, createClientEffectHandlers, createContextFromBindings, createMockPersistence, createServerEffectHandlers, createTestExecutor, createTickScheduler, createUnifiedLoader, cronMatches, cronMinuteKey, detectLayoutStrategy, extractBindings, formatPayloadValidationError, interpolateProps, interpolateValue, isValidCronExpression, isValidDurationString, parseCron, parseCronField, parseDurationString, pipeBehaviors, resolveCallSitePayloadCaptures, validateEventPayload, validatePayloadShapes };
+export { BindingContext, CALLSITE_PAYLOAD_PREFIX, type ClientEventBus, type ComposeBehaviorsInput, type ComposeBehaviorsResult, type CreateClientEffectHandlersOptions, type CreateServerEffectHandlersOptions, type CronFields, type DeferredPatternValue, EffectContext, EffectExecutor, type EffectExecutorOptions, EffectHandlers, EffectResult, type EntitySchema, type EventWiringEntry, ExecutionEnvironment, ImportChainLike, type LayoutStrategy, LoadResult, LoadedOrbital, LoadedSchema, MockPersistenceAdapter, type MockPersistenceConfig, type PayloadMismatch, type PayloadValidationFailure, PersistenceAdapter, type PipeStep, SchemaLoader, type ServerEffectResult, type SlotSetter, type TickHandle, TickScheduler, TraitDefinition, UnifiedLoaderOptions, applyEventWiring, buildEmitsFromTraits, composeBehaviors, index as composition, containsBindings, createClientEffectHandlers, createContextFromBindings, createMockPersistence, createServerEffectHandlers, createTestExecutor, createTickScheduler, createUnifiedLoader, cronMatches, cronMinuteKey, deferEntityBindings, detectLayoutStrategy, extractBindings, formatPayloadValidationError, interpolateProps, interpolateValue, isValidCronExpression, isValidDurationString, parseCron, parseCronField, parseDurationString, pipeBehaviors, resolveCallSitePayloadCaptures, validateEventPayload, validatePayloadShapes };

package/dist/index.js

@@ -1,5 +1,5 @@
-import { EffectExecutor, createContextFromBindings } from './chunk-2SM626PK.js';
-export { CALLSITE_PAYLOAD_PREFIX, EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, TickScheduler, buildEmitsFromTraits, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMinimalContext, createMockPersistence, createTestExecutor, createTickScheduler, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, isValidDurationString, normalizeCallSiteConfigToValues, normalizeEventKey, parseDurationString, parseNamespacedEvent, preprocessSchema, processEvent, resolveCallSitePayloadCaptures, validateEventPayload, validatePayloadShapes } from './chunk-2SM626PK.js';
+import { EffectExecutor, createContextFromBindings } from './chunk-FIBEYLME.js';
+export { CALLSITE_PAYLOAD_PREFIX, EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, TickScheduler, buildEmitsFromTraits, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMinimalContext, createMockPersistence, createTestExecutor, createTickScheduler, createUnifiedLoader, deferEntityBindings, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, isValidDurationString, normalizeCallSiteConfigToValues, normalizeEventKey, parseDurationString, parseNamespacedEvent, preprocessSchema, processEvent, resolveCallSitePayloadCaptures, validateEventPayload, validatePayloadShapes } from './chunk-FIBEYLME.js';
 export { cronMatches, cronMinuteKey, isValidCronExpression, parseCron, parseCronField } from './chunk-OU3ITB5S.js';
 import './chunk-T4VDAB4C.js';
 export { PERF_NAMESPACE, RendererContractViolationError, adjustSchemaForMockData, aggregateSlotContent, assertIsMultiSourceSlotManager, assertIsSlotManager, bindEventBus, bindTraitStateGetter, buildMockData, buildOrbitalsByTrait, clearPerf, createSlotSetter, ensureVerificationApi, getOrbitalVerification, perfEnd, perfStart, perfStore, perfTime, prepareSchemaForPreview, pushPerfEntry, validateSlotContent, wrapCallbackForEvent } from './chunk-FOFLEZRJ.js';

package/dist/{types-p_L8-Sk4.d.ts → types-CL03tjGU.d.ts}

@@ -3,6 +3,25 @@ import { TraitId, EventId, SExpr, TraitEventListener, AgentContext, LlmContext,
 
 /** Alias for ResolvedPatternProps to avoid breaking internal consumers */
 type PatternProps = ResolvedPatternProps;
+/**
+ * Value a render-ui pattern prop can carry AFTER interpolation. Mirrors
+ * `FieldValue` but extends with `RuntimeRenderPattern` so nested pattern
+ * configs (children, slot props that are themselves render-ui nodes)
+ * round-trip without an `unknown` escape hatch.
+ */
+type RuntimePatternValue = string | number | boolean | null | undefined | EntityRow | EntityRow[] | readonly RuntimePatternValue[] | RuntimeRenderPattern;
+/**
+ * Shape of a render-ui pattern AFTER interpolation, as the runtime hands
+ * it to `EffectHandlers.renderUI`. Different from `ResolvedPatternProps`
+ * (`@almadar/core`) because the post-interpolation pattern carries
+ * resolved EntityRow values (e.g. `{ entity: <row> }` from `@payload.row`)
+ * not just primitives. Used by render-ui observability helpers to narrow
+ * safely without `unknown` casts.
+ */
+interface RuntimeRenderPattern {
+    readonly [prop: string]: RuntimePatternValue;
+}
+
 type ConfigContext = TraitConfig;
 /**
  * Event structure for cross-trait communication.
@@ -432,7 +451,7 @@ interface TransitionObserver {
         guardResult?: boolean;
         effects: Array<{
             type: string;
-            args: unknown[];
+            args: SExpr[];
             status: "executed" | "failed" | "skipped";
             error?: string;
             durationMs?: number;
@@ -444,4 +463,4 @@ interface TransitionObserver {
  */
 declare const HANDLER_MANIFEST: Record<ExecutionEnvironment, string[]>;
 
-export { type BindingContext as B, type ConfigContext as C, type EffectHandlers as E, HANDLER_MANIFEST as H, type IEventBus as I, type PatternProps as P, type RuntimeEvent as R, type TraitDefinition as T, type Unsubscribe as U, type EventListener as a, type RuntimeConfig as b, type TransitionObserver as c, type TraitState as d, type TransitionResult as e, type EvaluationContextExtensions as f, type EffectContext as g, type ExecutionEnvironment as h, type EffectResult as i, type BrowserFileMeta as j, type BrowserFilePickerOptions as k, type BrowserGeolocationOptions as l, type BrowserGeolocationPosition as m, type Effect as n };
+export { type BindingContext as B, type ConfigContext as C, type EffectHandlers as E, HANDLER_MANIFEST as H, type IEventBus as I, type PatternProps as P, type RuntimeEvent as R, type TraitDefinition as T, type Unsubscribe as U, type EventListener as a, type RuntimeConfig as b, type TransitionObserver as c, type TraitState as d, type TransitionResult as e, type EvaluationContextExtensions as f, type RuntimePatternValue as g, type EffectContext as h, type ExecutionEnvironment as i, type EffectResult as j, type BrowserFileMeta as k, type BrowserFilePickerOptions as l, type BrowserGeolocationOptions as m, type BrowserGeolocationPosition as n, type Effect as o };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/runtime",
-  "version": "6.43.0",
+  "version": "6.45.0",
   "description": "Interpreted runtime for Almadar orbital applications (OrbitalServerRuntime)",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,11 +52,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@almadar/core": "^10.40.0",
-    "@almadar/evaluator": "^2.37.0",
+    "@almadar/core": "^10.43.0",
+    "@almadar/evaluator": "^2.38.0",
     "@almadar/logger": "^1.10.0",
     "@almadar/server": "^2.29.0",
-    "@almadar/std": "^16.151.0"
+    "@almadar/std": "^16.153.0"
   },
   "peerDependencies": {
     "express": "^5.0.0"