@almadar/runtime 6.43.0 → 6.44.0

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

@@ -1199,6 +1199,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.

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';
+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-Dz0oubQ_.js';
 import './types-p_L8-Sk4.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-EJHMWSUS.js';
+export { InMemoryPersistence, collectDeclaredConfigDefaults } from './chunk-EJHMWSUS.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 } 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-

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

@@ -2346,6 +2346,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 +2438,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 +3661,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 +3922,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 +3980,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 +4157,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.
    */

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 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 { U as UnifiedLoaderOptions, S as SchemaLoader, I as ImportChainLike, L as LoadResult, a as LoadedSchema, b as LoadedOrbital, P as PersistenceAdapter } from './OrbitalServerRuntime-Dz0oubQ_.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-Dz0oubQ_.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';
@@ -585,6 +585,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

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-EJHMWSUS.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-EJHMWSUS.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/runtime",
-  "version": "6.43.0",
+  "version": "6.44.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/core": "^10.42.0",
     "@almadar/evaluator": "^2.37.0",
     "@almadar/logger": "^1.10.0",
     "@almadar/server": "^2.29.0",
-    "@almadar/std": "^16.151.0"
+    "@almadar/std": "^16.152.0"
   },
   "peerDependencies": {
     "express": "^5.0.0"