@almadar/runtime 6.9.2 → 6.9.4

package/dist/{chunk-VUXJJPIQ.js → chunk-R6Y4IJ7I.js}

@@ -1,10 +1,9 @@
 import { createLogger } from '@almadar/logger';
 import { resolveBinding, evaluate, createMinimalContext, evaluateGuard } from '@almadar/evaluator';
 export { createMinimalContext } from '@almadar/evaluator';
-import { isKnownOperator } from '@almadar/std';
-import * as nodeModule from 'module';
-import { isInlineTrait, isEntityCall, OrbitalSchemaSchema, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef } from '@almadar/core';
+import { isKnownStdOperator } from '@almadar/std/registry';
 import { faker } from '@faker-js/faker';
+import { OrbitalSchemaSchema, isInlineTrait, isEntityCall, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef } from '@almadar/core';
 
 // src/EventBus.ts
 var log = createLogger("almadar:runtime:eventbus");
@@ -261,7 +260,7 @@ function isSExpression(value) {
   if (value.length === 0) return false;
   const first = value[0];
   if (typeof first !== "string") return false;
-  if (isKnownOperator(first)) return true;
+  if (isKnownStdOperator(first)) return true;
   if (first.includes("/")) return true;
   if (first === "lambda" || first === "let") return true;
   return false;
@@ -1696,6 +1695,25 @@ function buildEmitsFromTraits(traits, explicitEmits) {
   }
   return result;
 }
+
+// src/config-defaults.ts
+function collectDeclaredConfigDefaults(trait) {
+  if (!trait) return void 0;
+  const schema = trait.config;
+  if (!schema || typeof schema !== "object") return void 0;
+  const defaults = {};
+  let hasAny = false;
+  for (const [key, field] of Object.entries(schema)) {
+    if (field && typeof field === "object" && !Array.isArray(field) && "default" in field) {
+      const def = field.default;
+      if (def !== void 0) {
+        defaults[key] = def;
+        hasAny = true;
+      }
+    }
+  }
+  return hasAny ? defaults : void 0;
+}
 var mockLog = createLogger("almadar:runtime:mock");
 var DEFAULT_MOCK_SEED = 42;
 function picsumUrl(entityName, fieldName, width = 400, height = 400) {
@@ -2116,820 +2134,509 @@ var MockPersistenceAdapter = class _MockPersistenceAdapter {
 function createMockPersistence(config) {
   return new MockPersistenceAdapter(config);
 }
-var refResolverLog = createLogger("almadar:runtime:ref-resolver");
-function renameEventsInRenderUiConfig(node, rename) {
-  if (node === null || node === void 0) return node;
-  if (Array.isArray(node)) {
-    return node.map((item) => renameEventsInRenderUiConfig(item, rename));
-  }
-  if (typeof node !== "object") return node;
-  const obj = node;
-  const next = { ...obj };
-  for (const [key, value] of Object.entries(obj)) {
-    if (key === "action" && typeof value === "string" && !value.startsWith("@")) {
-      next[key] = rename(value) ?? value;
-      continue;
-    }
-    if (/^on[A-Z]/.test(key) && typeof value === "string" && !value.startsWith("@")) {
-      next[key] = rename(value) ?? value;
-      continue;
-    }
-    if (key.endsWith("Event") && typeof value === "string" && !value.startsWith("@")) {
-      next[key] = rename(value) ?? value;
-      continue;
-    }
-    if ((key === "actions" || key === "itemActions") && Array.isArray(value)) {
-      const rewrittenArray = value.map((entry) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
-        const action = entry;
-        if (typeof action.event === "string" && !action.event.startsWith("@")) {
-          return { ...action, event: rename(action.event) ?? action.event };
-        }
-        return action;
-      });
-      next[key] = rewrittenArray;
-      continue;
-    }
-    next[key] = renameEventsInRenderUiConfig(value, rename);
-  }
-  return next;
+
+// src/loader/schema-loader.ts
+function isElectron() {
+  return typeof process !== "undefined" && !!process.versions?.electron;
 }
-function renameEventsInEffects(effects, rename) {
-  return effects.map((effect) => {
-    if (!Array.isArray(effect)) return effect;
-    if (effect[0] === "render-ui" && effect.length >= 3) {
-      const slot = effect[1];
-      const config = effect[2];
-      const nextConfig = renameEventsInRenderUiConfig(config, rename);
-      return [effect[0], slot, nextConfig, ...effect.slice(3)];
-    }
-    return effect;
-  });
+function isBrowser() {
+  return typeof window !== "undefined" && !isElectron();
 }
-function renameEntityInRenderUiConfig(node, oldName, newName) {
-  if (node === null || node === void 0) return node;
-  if (Array.isArray(node)) {
-    return node.map((item) => renameEntityInRenderUiConfig(item, oldName, newName));
-  }
-  if (typeof node !== "object") return node;
-  const obj = node;
-  const next = { ...obj };
-  for (const [key, value] of Object.entries(obj)) {
-    if (key === "entity" && value === oldName) {
-      next[key] = newName;
-      continue;
+function isNode() {
+  return typeof process !== "undefined" && !isBrowser();
+}
+var HttpImportChain = class _HttpImportChain {
+  chain = [];
+  /**
+   * Try to add a path to the chain.
+   * @returns Error message if circular, null if OK
+   */
+  push(absolutePath) {
+    if (this.chain.includes(absolutePath)) {
+      const cycle = [
+        ...this.chain.slice(this.chain.indexOf(absolutePath)),
+        absolutePath
+      ];
+      return `Circular import detected: ${cycle.join(" -> ")}`;
     }
-    next[key] = renameEntityInRenderUiConfig(value, oldName, newName);
+    this.chain.push(absolutePath);
+    return null;
   }
-  return next;
-}
-function renameEntityInEffects(effects, oldName, newName) {
-  return effects.map((effect) => renameEntityInEffect(effect, oldName, newName));
-}
-var ENTITY_AT_POS_1 = /* @__PURE__ */ new Set(["fetch", "ref", "deref", "spawn"]);
-var ALL_ARGS_ARE_EFFECTS = /* @__PURE__ */ new Set([
-  "do",
-  "atomic",
-  "async/race",
-  "async/all",
-  "async/sequence"
-]);
-var ARGS_FROM_POS_2_ARE_EFFECTS = /* @__PURE__ */ new Set([
-  "if",
-  "when",
-  "let",
-  "async/delay",
-  "async/debounce",
-  "async/throttle",
-  "async/interval"
-]);
-function renameEntityInEffect(effect, oldName, newName) {
-  if (!Array.isArray(effect) || effect.length === 0) return effect;
-  const op = effect[0];
-  if (typeof op !== "string") return effect;
-  if (op === "render-ui" && effect.length >= 3) {
-    const [, slot, config, ...rest] = effect;
-    const nextConfig = renameEntityInRenderUiConfig(config, oldName, newName);
-    return [op, slot, nextConfig, ...rest];
+  /**
+   * Remove the last path from the chain.
+   */
+  pop() {
+    this.chain.pop();
   }
-  if (op === "persist" && effect.length >= 3 && effect[2] === oldName) {
-    return [op, effect[1], newName, ...effect.slice(3)];
+  /**
+   * Clone the chain for nested loading.
+   */
+  clone() {
+    const newChain = new _HttpImportChain();
+    newChain.chain = [...this.chain];
+    return newChain;
   }
-  if (ENTITY_AT_POS_1.has(op) && effect[1] === oldName) {
-    return [op, newName, ...effect.slice(2)];
+};
+var HttpLoaderCache = class {
+  cache = /* @__PURE__ */ new Map();
+  get(url) {
+    return this.cache.get(url);
   }
-  const skipFirstNonEffectArg = ARGS_FROM_POS_2_ARE_EFFECTS.has(op);
-  const recurseAll = ALL_ARGS_ARE_EFFECTS.has(op);
-  if (recurseAll || skipFirstNonEffectArg) {
-    const startIndex = skipFirstNonEffectArg ? 2 : 1;
-    return effect.map((arg, i) => {
-      if (i < startIndex) return arg;
-      if (Array.isArray(arg)) {
-        return renameEntityInEffect(arg, oldName, newName);
-      }
-      return arg;
-    });
+  set(url, schema) {
+    this.cache.set(url, schema);
   }
-  return effect;
-}
-function applyLinkedEntityRename(trait, linkedEntity) {
-  const atomLinked = trait.linkedEntity;
-  if (!linkedEntity || !atomLinked || linkedEntity === atomLinked) return trait;
-  const sm = trait.stateMachine;
-  if (!sm) return { ...trait, linkedEntity };
-  const nextTransitions = (sm.transitions ?? []).map((t) => {
-    const nextEffects = t.effects ? renameEntityInEffects(
-      t.effects,
-      atomLinked,
-      linkedEntity
-    ) : t.effects;
-    return { ...t, effects: nextEffects };
-  });
-  refResolverLog.info("linkedEntity:rename", {
-    trait: trait.name,
-    from: atomLinked,
-    to: linkedEntity,
-    transitionCount: nextTransitions.length
-  });
-  return {
-    ...trait,
-    linkedEntity,
-    stateMachine: { ...sm, transitions: nextTransitions }
-  };
-}
-function applyEventRenames(trait, renames) {
-  if (!renames || Object.keys(renames).length === 0) return trait;
-  const rename = (k) => k !== void 0 && k in renames ? renames[k] : k;
-  const sm = trait.stateMachine;
-  if (!sm) return trait;
-  const nextTransitions = (sm.transitions ?? []).map((t) => {
-    const nextEvent = rename(t.event) ?? t.event;
-    const nextEffects = t.effects ? renameEventsInEffects(t.effects, rename) : t.effects;
-    return { ...t, event: nextEvent, effects: nextEffects };
-  });
-  const nextEvents = (sm.events ?? []).map((e) => {
-    const newKey = rename(e.key);
-    if (newKey === e.key) return e;
-    return { ...e, key: newKey ?? e.key };
-  });
-  const nextEmits = (trait.emits ?? []).map((em) => {
-    if (typeof em === "string") return rename(em) ?? em;
-    const newEvent = rename(em.event);
-    return newEvent === em.event ? em : { ...em, event: newEvent ?? em.event };
-  });
-  return {
-    ...trait,
-    stateMachine: {
-      ...sm,
-      transitions: nextTransitions,
-      events: nextEvents
-    },
-    emits: nextEmits
-  };
-}
-var ReferenceResolver = class {
-  loader;
+  has(url) {
+    return this.cache.has(url);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var HttpLoader = class {
   options;
-  localTraits;
-  loaderInitialized = false;
+  cache;
   constructor(options) {
-    this.options = options;
-    this.loader = options.loader;
-    this.localTraits = options.localTraits ?? /* @__PURE__ */ new Map();
-  }
-  async ensureLoader() {
-    if (this.loader || this.loaderInitialized) return;
-    this.loaderInitialized = true;
-    try {
-      const { ExternalOrbitalLoader } = await import('./external-loader-IN246DQM.js');
-      this.loader = new ExternalOrbitalLoader(this.options);
-    } catch {
-    }
+    this.options = {
+      basePath: options.basePath,
+      stdLibPath: options.stdLibPath ?? "",
+      scopedPaths: options.scopedPaths ?? {},
+      fetchOptions: options.fetchOptions,
+      timeout: options.timeout ?? 3e4,
+      credentials: options.credentials ?? "same-origin"
+    };
+    this.cache = new HttpLoaderCache();
   }
   /**
-   * Resolve all references in an orbital.
+   * Load a schema from an import path.
    */
-  async resolve(orbital, sourcePath, chain) {
-    const errors = [];
-    const warnings = [];
-    const importChain = chain ?? { push: () => null, pop: () => {
-    }, clone() {
-      return this;
-    } };
-    const traitsList = orbital.traits ?? [];
-    const alreadyResolved = traitsList.length > 0 && traitsList.every((t) => isInlineTrait(t));
-    const importsResult = alreadyResolved ? { success: true, data: { orbitals: /* @__PURE__ */ new Map() }} : await this.resolveImports(orbital.uses ?? [], sourcePath, importChain);
-    if (!importsResult.success) {
-      return { success: false, errors: importsResult.errors };
-    }
-    const imports = importsResult.data;
-    const entityResult = this.resolveEntity(orbital.entity, imports);
-    if (!entityResult.success) {
-      errors.push(...entityResult.errors);
+  async load(importPath, fromPath, chain) {
+    const importChain = chain ?? new HttpImportChain();
+    const resolveResult = this.resolvePath(importPath, fromPath);
+    if (!resolveResult.success) {
+      return resolveResult;
     }
-    const traitsResult = this.resolveTraits(orbital.traits, imports);
-    if (!traitsResult.success) {
-      errors.push(...traitsResult.errors);
+    const absoluteUrl = resolveResult.data;
+    const circularError = importChain.push(absoluteUrl);
+    if (circularError) {
+      return { success: false, error: circularError };
     }
-    const pagesResult = this.resolvePages(orbital.pages, imports);
-    if (!pagesResult.success) {
-      errors.push(...pagesResult.errors);
+    try {
+      const cached = this.cache.get(absoluteUrl);
+      if (cached) {
+        return { success: true, data: cached };
+      }
+      const loadResult = await this.fetchSchema(absoluteUrl);
+      if (!loadResult.success) {
+        return loadResult;
+      }
+      const loaded = {
+        schema: loadResult.data,
+        sourcePath: absoluteUrl,
+        importPath
+      };
+      this.cache.set(absoluteUrl, loaded);
+      return { success: true, data: loaded };
+    } finally {
+      importChain.pop();
     }
-    if (errors.length > 0) {
-      return { success: false, errors };
+  }
+  /**
+   * Load a specific orbital from a schema by name.
+   */
+  async loadOrbital(importPath, orbitalName, fromPath, chain) {
+    const schemaResult = await this.load(importPath, fromPath, chain);
+    if (!schemaResult.success) {
+      return schemaResult;
     }
-    if (!entityResult.success || !traitsResult.success || !pagesResult.success) {
-      return { success: false, errors: ["Internal error: unexpected failure state"] };
+    const schema = schemaResult.data.schema;
+    let orbital;
+    if (orbitalName) {
+      const found = schema.orbitals.find(
+        (o) => o.name === orbitalName
+      );
+      if (!found) {
+        return {
+          success: false,
+          error: `Orbital "${orbitalName}" not found in ${importPath}. Available: ${schema.orbitals.map((o) => o.name).join(", ")}`
+        };
+      }
+      orbital = found;
+    } else {
+      if (schema.orbitals.length === 0) {
+        return {
+          success: false,
+          error: `No orbitals found in ${importPath}`
+        };
+      }
+      orbital = schema.orbitals[0];
     }
     return {
       success: true,
       data: {
-        name: orbital.name,
-        entity: entityResult.data.entity,
-        entitySource: entityResult.data.source,
-        traits: traitsResult.data,
-        pages: pagesResult.data,
-        imports,
-        original: orbital
-      },
-      warnings
+        orbital,
+        sourcePath: schemaResult.data.sourcePath,
+        importPath
+      }
     };
   }
   /**
-   * Resolve `uses` declarations to loaded orbitals.
+   * Resolve an import path to an absolute URL.
    */
-  async resolveImports(uses, sourcePath, chain) {
-    const errors = [];
-    const orbitals = /* @__PURE__ */ new Map();
-    if (this.options.skipExternalLoading) {
-      return {
-        success: true,
-        data: { orbitals },
-        warnings: ["External loading skipped"]
-      };
+  resolvePath(importPath, fromPath) {
+    if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
+      return { success: true, data: importPath };
     }
-    for (const use of uses) {
-      if (orbitals.has(use.as)) {
-        errors.push(`Duplicate import alias: ${use.as}`);
-        continue;
-      }
-      await this.ensureLoader();
-      if (!this.loader) {
-        errors.push(`No loader available to resolve import: ${use.from}`);
-        continue;
-      }
-      const loadResult = await this.loader.loadOrbital(
-        use.from,
-        void 0,
-        sourcePath,
-        chain
-      );
-      if (!loadResult.success) {
-        errors.push(`Failed to load "${use.from}" as "${use.as}": ${loadResult.error}`);
-        continue;
-      }
-      orbitals.set(use.as, {
-        alias: use.as,
-        from: use.from,
-        orbital: loadResult.data.orbital,
-        sourcePath: loadResult.data.sourcePath
-      });
+    if (importPath.startsWith("std/")) {
+      return this.resolveStdPath(importPath);
     }
-    if (errors.length > 0) {
-      return { success: false, errors };
+    if (importPath.startsWith("@")) {
+      return this.resolveScopedPath(importPath);
     }
-    return { success: true, data: { orbitals }, warnings: [] };
+    if (importPath.startsWith("./") || importPath.startsWith("../")) {
+      return this.resolveRelativePath(importPath, fromPath);
+    }
+    return this.resolveRelativePath(`./${importPath}`, fromPath);
   }
   /**
-   * Resolve entity reference.
+   * Resolve a standard library path.
    */
-  resolveEntity(entityRef, imports) {
-    if (isEntityCall(entityRef)) {
-      const fallbackName = entityRef.name ?? entityRef.extends.replace(/\.entity$/, "");
+  resolveStdPath(importPath) {
+    if (!this.options.stdLibPath) {
       return {
-        success: true,
-        data: {
-          entity: {
-            name: fallbackName,
-            fields: entityRef.fields ?? [],
-            ...entityRef.persistence ? { persistence: entityRef.persistence } : {},
-            ...entityRef.collection ? { collection: entityRef.collection } : {}
-          }
-        },
-        warnings: []
+        success: false,
+        error: `Standard library URL not configured. Cannot load: ${importPath}`
       };
     }
-    if (!isEntityReference(entityRef)) {
-      return {
-        success: true,
-        data: { entity: entityRef },
-        warnings: []
-      };
+    const relativePath = importPath.slice(4);
+    let absoluteUrl = this.joinUrl(this.options.stdLibPath, relativePath);
+    if (!absoluteUrl.endsWith(".orb")) {
+      absoluteUrl += ".orb";
     }
-    const parsed = parseEntityRef(entityRef);
-    if (!parsed) {
+    return { success: true, data: absoluteUrl };
+  }
+  /**
+   * Resolve a scoped package path.
+   */
+  resolveScopedPath(importPath) {
+    const match = importPath.match(/^(@[^/]+)/);
+    if (!match) {
       return {
         success: false,
-        errors: [`Invalid entity reference format: ${entityRef}. Expected "Alias.entity"`]
+        error: `Invalid scoped package path: ${importPath}`
       };
     }
-    const imported = imports.orbitals.get(parsed.alias);
-    if (!imported) {
+    const scope = match[1];
+    const scopeRoot = this.options.scopedPaths[scope];
+    if (!scopeRoot) {
       return {
         success: false,
-        errors: [
-          `Unknown import alias in entity reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
-        ]
+        error: `Scoped package "${scope}" not configured. Available: ${Object.keys(this.options.scopedPaths).join(", ") || "none"}`
       };
     }
-    const importedEntity = this.getEntityFromOrbital(imported.orbital);
-    if (!importedEntity) {
-      return {
-        success: false,
-        errors: [
-          `Imported orbital "${parsed.alias}" does not have an inline entity. Entity references cannot be chained.`
-        ]
-      };
+    const relativePath = importPath.slice(scope.length + 1);
+    let absoluteUrl = this.joinUrl(scopeRoot, relativePath);
+    if (!absoluteUrl.endsWith(".orb")) {
+      absoluteUrl += ".orb";
     }
-    const persistence = importedEntity.persistence ?? "persistent";
-    return {
-      success: true,
-      data: {
-        entity: importedEntity,
-        source: {
-          alias: parsed.alias,
-          persistence
-        }
-      },
-      warnings: []
-    };
+    return { success: true, data: absoluteUrl };
   }
   /**
-   * Get the entity from an orbital (handling EntityRef).
+   * Resolve a relative path.
    */
-  getEntityFromOrbital(orbital) {
-    const entityRef = orbital.entity;
-    if (typeof entityRef === "string") {
-      return null;
-    }
-    if (isEntityCall(entityRef)) {
-      const fallbackName = entityRef.name ?? entityRef.extends.replace(/\.entity$/, "");
-      return {
-        name: fallbackName,
-        fields: entityRef.fields ?? [],
-        ...entityRef.persistence ? { persistence: entityRef.persistence } : {},
-        ...entityRef.collection ? { collection: entityRef.collection } : {}
-      };
+  resolveRelativePath(importPath, fromPath) {
+    const baseUrl = fromPath ? this.getParentUrl(fromPath) : this.options.basePath;
+    let absoluteUrl = this.joinUrl(baseUrl, importPath);
+    if (!absoluteUrl.endsWith(".orb")) {
+      absoluteUrl += ".orb";
     }
-    return entityRef;
+    return { success: true, data: absoluteUrl };
   }
   /**
-   * Resolve trait references.
+   * Fetch and parse an OrbitalSchema from a URL.
    */
-  resolveTraits(traitRefs, imports) {
-    const errors = [];
-    const resolved = [];
-    for (const traitRef of traitRefs) {
-      const result = this.resolveTraitRef(traitRef, imports);
-      if (!result.success) {
-        errors.push(...result.errors);
-      } else {
-        resolved.push(result.data);
-      }
-    }
-    if (errors.length > 0) {
-      return { success: false, errors };
-    }
-    return { success: true, data: resolved, warnings: [] };
-  }
-  /**
-   * Resolve a single trait reference.
-   */
-  resolveTraitRef(traitRef, imports) {
-    if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
-      return {
-        success: true,
-        data: {
-          trait: traitRef,
-          source: { type: "inline" }
-        },
-        warnings: []
-      };
-    }
-    if (typeof traitRef !== "string" && "ref" in traitRef) {
-      const refObj = traitRef;
-      return this.resolveTraitRefString(
-        refObj.ref,
-        imports,
-        refObj.config,
-        refObj.linkedEntity,
-        refObj.name,
-        refObj.events,
-        refObj.listens
+  async fetchSchema(url) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.options.timeout
       );
-    }
-    if (typeof traitRef === "string") {
-      return this.resolveTraitRefString(traitRef, imports);
-    }
-    return {
-      success: false,
-      errors: [`Unknown trait reference format: ${JSON.stringify(traitRef)}`]
-    };
-  }
-  /**
-   * Resolve a trait reference string.
-   */
-  resolveTraitRefString(ref, imports, config, linkedEntity, overrideName, eventRenames, listensOverride) {
-    const parsed = parseImportedTraitRef(ref);
-    if (parsed) {
-      const imported = imports.orbitals.get(parsed.alias);
-      if (!imported) {
-        return {
-          success: false,
-          errors: [
-            `Unknown import alias in trait reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
-          ]
-        };
+      try {
+        const response = await fetch(url, {
+          ...this.options.fetchOptions,
+          credentials: this.options.credentials,
+          signal: controller.signal,
+          headers: {
+            Accept: "application/json",
+            ...this.options.fetchOptions?.headers
+          }
+        });
+        if (!response.ok) {
+          return {
+            success: false,
+            error: `HTTP ${response.status}: ${response.statusText} for ${url}`
+          };
+        }
+        const text = await response.text();
+        let data;
+        try {
+          data = JSON.parse(text);
+        } catch (e) {
+          return {
+            success: false,
+            error: `Invalid JSON in ${url}: ${e instanceof Error ? e.message : String(e)}`
+          };
+        }
+        const parseResult = OrbitalSchemaSchema.safeParse(data);
+        if (!parseResult.success) {
+          const errors = parseResult.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+          return {
+            success: false,
+            error: `Invalid schema in ${url}:
+${errors}`
+          };
+        }
+        return { success: true, data: parseResult.data };
+      } finally {
+        clearTimeout(timeoutId);
       }
-      const trait = this.findTraitInOrbital(imported.orbital, parsed.traitName);
-      if (!trait) {
+    } catch (e) {
+      if (e instanceof Error && e.name === "AbortError") {
         return {
           success: false,
-          errors: [
-            `Trait "${parsed.traitName}" not found in imported orbital "${parsed.alias}". Available traits: ${this.listTraitsInOrbital(imported.orbital).join(", ") || "none"}`
-          ]
+          error: `Request timeout for ${url} (${this.options.timeout}ms)`
         };
       }
-      const baseTrait = overrideName ? { ...trait, name: overrideName } : trait;
-      const reboundTrait = applyLinkedEntityRename(baseTrait, linkedEntity);
-      const renamedTrait = applyEventRenames(reboundTrait, eventRenames);
-      const finalTrait = listensOverride !== void 0 ? { ...renamedTrait, listens: listensOverride } : renamedTrait;
-      if (listensOverride !== void 0) {
-        refResolverLog.info("listens-override:imported", {
-          trait: finalTrait.name,
-          ref,
-          atomListens: trait.listens?.length ?? 0,
-          callSiteListens: listensOverride.length
-        });
-      }
-      return {
-        success: true,
-        data: {
-          trait: finalTrait,
-          source: { type: "imported", alias: parsed.alias, traitName: parsed.traitName },
-          config,
-          linkedEntity
-        },
-        warnings: []
-      };
-    }
-    const localTrait = this.localTraits.get(ref);
-    if (localTrait) {
-      const baseLocal = overrideName ? { ...localTrait, name: overrideName } : localTrait;
-      const reboundLocal = applyLinkedEntityRename(baseLocal, linkedEntity);
-      const renamedLocalTrait = applyEventRenames(reboundLocal, eventRenames);
-      const finalLocalTrait = listensOverride !== void 0 ? { ...renamedLocalTrait, listens: listensOverride } : renamedLocalTrait;
-      if (listensOverride !== void 0) {
-        refResolverLog.info("listens-override:local", {
-          trait: finalLocalTrait.name,
-          ref,
-          atomListens: localTrait.listens?.length ?? 0,
-          callSiteListens: listensOverride.length
-        });
-      }
       return {
-        success: true,
-        data: {
-          trait: finalLocalTrait,
-          source: { type: "local", name: ref },
-          config,
-          linkedEntity
-        },
-        warnings: []
+        success: false,
+        error: `Failed to fetch ${url}: ${e instanceof Error ? e.message : String(e)}`
       };
     }
-    return {
-      success: false,
-      errors: [
-        `Trait "${ref}" not found. For imported traits, use format "Alias.traits.TraitName". Local traits available: ${Array.from(this.localTraits.keys()).join(", ") || "none"}`
-      ]
-    };
   }
   /**
-   * Find a trait in an orbital by name.
+   * Join URL parts, handling relative paths and trailing slashes.
    */
-  findTraitInOrbital(orbital, traitName) {
-    for (const traitRef of orbital.traits) {
-      if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
-        if (traitRef.name === traitName) {
-          return traitRef;
-        }
-      }
-      if (typeof traitRef !== "string" && "ref" in traitRef) {
-        const refObj = traitRef;
-        if (refObj.ref === traitName || refObj.name === traitName) ;
+  joinUrl(base, path) {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path;
+    }
+    if (typeof URL !== "undefined") {
+      try {
+        const baseUrl = base.endsWith("/") ? base : base + "/";
+        return new URL(path, baseUrl).href;
+      } catch {
       }
     }
-    return null;
+    const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+    const normalizedPath = path.startsWith("/") ? path : "/" + path;
+    if (normalizedPath.startsWith("/./")) {
+      return normalizedBase + normalizedPath.slice(2);
+    }
+    if (normalizedPath.startsWith("/../")) {
+      const baseParts = normalizedBase.split("/");
+      baseParts.pop();
+      return baseParts.join("/") + normalizedPath.slice(3);
+    }
+    return normalizedBase + normalizedPath;
   }
   /**
-   * List trait names in an orbital.
+   * Get parent URL (directory) from a URL.
    */
-  listTraitsInOrbital(orbital) {
-    const names = [];
-    for (const traitRef of orbital.traits) {
-      if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
-        names.push(traitRef.name);
+  getParentUrl(url) {
+    if (typeof URL !== "undefined") {
+      try {
+        const urlObj = new URL(url);
+        const pathParts = urlObj.pathname.split("/");
+        pathParts.pop();
+        urlObj.pathname = pathParts.join("/");
+        return urlObj.href;
+      } catch {
       }
     }
-    return names;
+    const lastSlash = url.lastIndexOf("/");
+    if (lastSlash !== -1) {
+      return url.slice(0, lastSlash);
+    }
+    return url;
   }
   /**
-   * Resolve page references.
+   * Clear the cache.
    */
-  resolvePages(pageRefs, imports) {
-    const errors = [];
-    const resolved = [];
-    for (const pageRef of pageRefs) {
-      const result = this.resolvePageRef(pageRef, imports);
-      if (!result.success) {
-        errors.push(...result.errors);
-      } else {
-        resolved.push(result.data);
-      }
-    }
-    if (errors.length > 0) {
-      return { success: false, errors };
-    }
-    return { success: true, data: resolved, warnings: [] };
+  clearCache() {
+    this.cache.clear();
   }
   /**
-   * Resolve a single page reference.
+   * Get cache statistics.
    */
-  resolvePageRef(pageRef, imports) {
-    if (!isPageReference(pageRef)) {
-      return {
-        success: true,
-        data: {
-          page: pageRef,
-          source: { type: "inline" },
-          pathOverridden: false
-        },
-        warnings: []
-      };
-    }
-    if (isPageReferenceString(pageRef)) {
-      return this.resolvePageRefString(pageRef, imports);
-    }
-    if (isPageReferenceObject(pageRef)) {
-      return this.resolvePageRefObject(pageRef, imports);
-    }
-    return {
-      success: false,
-      errors: [`Unknown page reference format: ${JSON.stringify(pageRef)}`]
-    };
-  }
-  /**
-   * Resolve a page reference string.
-   */
-  resolvePageRefString(ref, imports) {
-    const parsed = parsePageRef(ref);
-    if (!parsed) {
-      return {
-        success: false,
-        errors: [`Invalid page reference format: ${ref}. Expected "Alias.pages.PageName"`]
-      };
-    }
-    const imported = imports.orbitals.get(parsed.alias);
-    if (!imported) {
-      return {
-        success: false,
-        errors: [
-          `Unknown import alias in page reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
-        ]
-      };
-    }
-    const page = this.findPageInOrbital(imported.orbital, parsed.pageName);
-    if (!page) {
-      return {
-        success: false,
-        errors: [
-          `Page "${parsed.pageName}" not found in imported orbital "${parsed.alias}". Available pages: ${this.listPagesInOrbital(imported.orbital).join(", ") || "none"}`
-        ]
-      };
-    }
-    return {
-      success: true,
-      data: {
-        page,
-        source: { type: "imported", alias: parsed.alias, pageName: parsed.pageName },
-        pathOverridden: false
-      },
-      warnings: []
-    };
-  }
-  /**
-   * Resolve a page reference object with optional path override.
-   */
-  resolvePageRefObject(refObj, imports) {
-    const baseResult = this.resolvePageRefString(refObj.ref, imports);
-    if (!baseResult.success) {
-      return baseResult;
-    }
-    const resolved = baseResult.data;
-    if (refObj.path) {
-      const originalPath = resolved.page.path;
-      resolved.page = {
-        ...resolved.page,
-        path: refObj.path
-      };
-      resolved.pathOverridden = true;
-      resolved.originalPath = originalPath;
-    }
-    return {
-      success: true,
-      data: resolved,
-      warnings: baseResult.warnings
-    };
-  }
-  /**
-   * Find a page in an orbital by name.
-   */
-  findPageInOrbital(orbital, pageName) {
-    const pages = orbital.pages;
-    if (!pages) return null;
-    for (const pageRef of pages) {
-      if (typeof pageRef !== "string" && !("ref" in pageRef)) {
-        const page = pageRef;
-        if (page.name === pageName) {
-          return { ...page };
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * List page names in an orbital.
-   */
-  listPagesInOrbital(orbital) {
-    const pages = orbital.pages;
-    if (!pages) return [];
-    const names = [];
-    for (const pageRef of pages) {
-      if (typeof pageRef !== "string" && !("ref" in pageRef)) {
-        names.push(pageRef.name);
-      }
-    }
-    return names;
-  }
-  /**
-   * Add local traits for resolution.
-   */
-  addLocalTraits(traits) {
-    for (const trait of traits) {
-      this.localTraits.set(trait.name, trait);
-    }
-  }
-  /**
-   * Clear loader cache.
-   */
-  clearCache() {
-    this.loader?.clearCache();
+  getCacheStats() {
+    return { size: this.cache.size };
   }
 };
-async function resolveSchema(schema, options) {
-  const resolver = new ReferenceResolver(options);
-  const errors = [];
-  const warnings = [];
-  const resolved = [];
-  for (const orbital of schema.orbitals) {
-    const inlineTraits = orbital.traits.filter(
-      (t) => typeof t !== "string" && "stateMachine" in t
-    );
-    resolver.addLocalTraits(inlineTraits);
+
+// src/loader/unified-loader.ts
+var externalLoaderModule = null;
+async function getExternalLoaderModule() {
+  if (externalLoaderModule) {
+    return externalLoaderModule;
   }
-  for (const orbital of schema.orbitals) {
-    const result = await resolver.resolve(orbital);
-    if (!result.success) {
-      errors.push(`Orbital "${orbital.name}": ${result.errors.join(", ")}`);
-    } else {
-      resolved.push(result.data);
-      warnings.push(...result.warnings.map((w) => `Orbital "${orbital.name}": ${w}`));
-    }
+  if (isBrowser()) {
+    return null;
   }
-  if (errors.length > 0) {
-    return { success: false, errors };
+  try {
+    externalLoaderModule = await import('./external-loader-IN246DQM.js');
+    return externalLoaderModule;
+  } catch {
+    return null;
   }
-  return { success: true, data: resolved, warnings };
-}
-
-// src/loader/schema-loader.ts
-function isElectron() {
-  return typeof process !== "undefined" && !!process.versions?.electron;
-}
-function isBrowser() {
-  return typeof window !== "undefined" && !isElectron();
-}
-function isNode() {
-  return typeof process !== "undefined" && !isBrowser();
 }
-var HttpImportChain = class _HttpImportChain {
+var UnifiedImportChain = class _UnifiedImportChain {
   chain = [];
-  /**
-   * Try to add a path to the chain.
-   * @returns Error message if circular, null if OK
-   */
-  push(absolutePath) {
-    if (this.chain.includes(absolutePath)) {
+  push(path) {
+    const normalized = this.normalizePath(path);
+    if (this.chain.includes(normalized)) {
       const cycle = [
-        ...this.chain.slice(this.chain.indexOf(absolutePath)),
-        absolutePath
+        ...this.chain.slice(this.chain.indexOf(normalized)),
+        normalized
       ];
       return `Circular import detected: ${cycle.join(" -> ")}`;
     }
-    this.chain.push(absolutePath);
+    this.chain.push(normalized);
     return null;
   }
-  /**
-   * Remove the last path from the chain.
-   */
   pop() {
     this.chain.pop();
   }
-  /**
-   * Clone the chain for nested loading.
-   */
   clone() {
-    const newChain = new _HttpImportChain();
+    const newChain = new _UnifiedImportChain();
     newChain.chain = [...this.chain];
     return newChain;
   }
-};
-var HttpLoaderCache = class {
-  cache = /* @__PURE__ */ new Map();
-  get(url) {
-    return this.cache.get(url);
-  }
-  set(url, schema) {
-    this.cache.set(url, schema);
-  }
-  has(url) {
-    return this.cache.has(url);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  get size() {
-    return this.cache.size;
+  normalizePath(path) {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path;
+    }
+    return path.replace(/\\/g, "/");
   }
 };
-var HttpLoader = class {
+var UnifiedLoader = class {
   options;
-  cache;
+  httpLoader = null;
+  fsLoader = null;
+  fsLoaderInitialized = false;
+  cache = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.options = {
+    this.options = options;
+    this.httpLoader = new HttpLoader({
       basePath: options.basePath,
-      stdLibPath: options.stdLibPath ?? "",
-      scopedPaths: options.scopedPaths ?? {},
-      fetchOptions: options.fetchOptions,
-      timeout: options.timeout ?? 3e4,
-      credentials: options.credentials ?? "same-origin"
-    };
-    this.cache = new HttpLoaderCache();
+      stdLibPath: options.stdLibPath,
+      scopedPaths: options.scopedPaths,
+      ...options.http
+    });
   }
   /**
-   * Load a schema from an import path.
+   * Initialize the filesystem loader if available.
    */
-  async load(importPath, fromPath, chain) {
-    const importChain = chain ?? new HttpImportChain();
-    const resolveResult = this.resolvePath(importPath, fromPath);
-    if (!resolveResult.success) {
-      return resolveResult;
+  async initFsLoader() {
+    if (this.fsLoaderInitialized) {
+      return;
     }
-    const absoluteUrl = resolveResult.data;
-    const circularError = importChain.push(absoluteUrl);
-    if (circularError) {
-      return { success: false, error: circularError };
+    this.fsLoaderInitialized = true;
+    if (this.options.forceLoader === "http") {
+      return;
     }
-    try {
-      const cached = this.cache.get(absoluteUrl);
-      if (cached) {
-        return { success: true, data: cached };
-      }
-      const loadResult = await this.fetchSchema(absoluteUrl);
-      if (!loadResult.success) {
-        return loadResult;
-      }
-      const loaded = {
-        schema: loadResult.data,
-        sourcePath: absoluteUrl,
-        importPath
-      };
-      this.cache.set(absoluteUrl, loaded);
-      return { success: true, data: loaded };
-    } finally {
-      importChain.pop();
+    const module = await getExternalLoaderModule();
+    if (module) {
+      this.fsLoader = new module.ExternalOrbitalLoader({
+        basePath: this.options.basePath,
+        stdLibPath: this.options.stdLibPath,
+        scopedPaths: this.options.scopedPaths,
+        ...this.options.fileSystem
+      });
+    }
+  }
+  /**
+   * Determine which loader to use for an import path.
+   */
+  getLoaderForPath(importPath) {
+    if (this.options.forceLoader) {
+      return this.options.forceLoader;
+    }
+    if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
+      return "http";
+    }
+    if (importPath.startsWith("std/") && this.options.stdLibPath) {
+      if (this.options.stdLibPath.startsWith("http://") || this.options.stdLibPath.startsWith("https://")) {
+        return "http";
+      }
+    }
+    if (importPath.startsWith("@") && this.options.scopedPaths) {
+      const match = importPath.match(/^(@[^/]+)/);
+      if (match) {
+        const scopePath = this.options.scopedPaths[match[1]];
+        if (scopePath && (scopePath.startsWith("http://") || scopePath.startsWith("https://"))) {
+          return "http";
+        }
+      }
+    }
+    if (isBrowser()) {
+      return "http";
+    }
+    return "filesystem";
+  }
+  /**
+   * Load a schema from an import path.
+   *
+   * Note: We delegate chain management to the inner loader (HttpLoader or FsLoader).
+   * The inner loader handles circular import detection, so we don't push/pop here.
+   * We only use the unified cache to avoid duplicate loads across loaders.
+   */
+  async load(importPath, fromPath, chain) {
+    await this.initFsLoader();
+    const importChain = chain ?? new UnifiedImportChain();
+    const loaderType = this.getLoaderForPath(importPath);
+    const resolveResult = this.resolvePath(importPath, fromPath);
+    if (!resolveResult.success) {
+      return resolveResult;
+    }
+    const absolutePath = resolveResult.data;
+    const cached = this.cache.get(absolutePath);
+    if (cached) {
+      return { success: true, data: cached };
+    }
+    let result;
+    if (loaderType === "http") {
+      if (!this.httpLoader) {
+        return {
+          success: false,
+          error: "HTTP loader not available"
+        };
+      }
+      result = await this.httpLoader.load(importPath, fromPath, importChain);
+    } else {
+      if (!this.fsLoader) {
+        if (this.httpLoader) {
+          result = await this.httpLoader.load(
+            importPath,
+            fromPath,
+            importChain
+          );
+        } else {
+          return {
+            success: false,
+            error: `Filesystem loader not available and import "${importPath}" cannot be loaded via HTTP. This typically happens when loading local files in a browser environment.`
+          };
+        }
+      } else {
+        result = await this.fsLoader.load(importPath, fromPath, importChain);
+      }
+    }
+    if (result.success) {
+      this.cache.set(absolutePath, result.data);
     }
+    return result;
   }
   /**
    * Load a specific orbital from a schema by name.
@@ -2940,2546 +2647,995 @@ var HttpLoader = class {
       return schemaResult;
     }
     const schema = schemaResult.data.schema;
-    let orbital;
     if (orbitalName) {
-      const found = schema.orbitals.find(
-        (o) => o.name === orbitalName
-      );
+      const found = schema.orbitals.find((o) => o.name === orbitalName);
       if (!found) {
         return {
           success: false,
           error: `Orbital "${orbitalName}" not found in ${importPath}. Available: ${schema.orbitals.map((o) => o.name).join(", ")}`
         };
       }
-      orbital = found;
-    } else {
-      if (schema.orbitals.length === 0) {
-        return {
-          success: false,
-          error: `No orbitals found in ${importPath}`
-        };
-      }
-      orbital = schema.orbitals[0];
+      return {
+        success: true,
+        data: {
+          orbital: found,
+          sourcePath: schemaResult.data.sourcePath,
+          importPath
+        }
+      };
+    }
+    if (schema.orbitals.length === 0) {
+      return {
+        success: false,
+        error: `No orbitals found in ${importPath}`
+      };
     }
     return {
       success: true,
       data: {
-        orbital,
+        orbital: schema.orbitals[0],
         sourcePath: schemaResult.data.sourcePath,
         importPath
       }
     };
   }
   /**
-   * Resolve an import path to an absolute URL.
+   * Resolve an import path to an absolute path/URL.
    */
   resolvePath(importPath, fromPath) {
-    if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
-      return { success: true, data: importPath };
-    }
-    if (importPath.startsWith("std/")) {
-      return this.resolveStdPath(importPath);
+    const loaderType = this.getLoaderForPath(importPath);
+    if (loaderType === "http" && this.httpLoader) {
+      return this.httpLoader.resolvePath(importPath, fromPath);
     }
-    if (importPath.startsWith("@")) {
-      return this.resolveScopedPath(importPath);
+    if (this.fsLoader) {
+      return this.fsLoader.resolvePath(importPath, fromPath);
     }
-    if (importPath.startsWith("./") || importPath.startsWith("../")) {
-      return this.resolveRelativePath(importPath, fromPath);
+    if (this.httpLoader) {
+      return this.httpLoader.resolvePath(importPath, fromPath);
     }
-    return this.resolveRelativePath(`./${importPath}`, fromPath);
+    return {
+      success: false,
+      error: "No loader available for path resolution"
+    };
   }
   /**
-   * Resolve a standard library path.
+   * Clear all caches.
    */
-  resolveStdPath(importPath) {
-    if (!this.options.stdLibPath) {
-      return {
-        success: false,
-        error: `Standard library URL not configured. Cannot load: ${importPath}`
-      };
-    }
-    const relativePath = importPath.slice(4);
-    let absoluteUrl = this.joinUrl(this.options.stdLibPath, relativePath);
-    if (!absoluteUrl.endsWith(".orb")) {
-      absoluteUrl += ".orb";
-    }
-    return { success: true, data: absoluteUrl };
+  clearCache() {
+    this.cache.clear();
+    this.httpLoader?.clearCache();
+    this.fsLoader?.clearCache();
   }
   /**
-   * Resolve a scoped package path.
+   * Get combined cache statistics.
    */
-  resolveScopedPath(importPath) {
-    const match = importPath.match(/^(@[^/]+)/);
-    if (!match) {
-      return {
-        success: false,
-        error: `Invalid scoped package path: ${importPath}`
-      };
-    }
-    const scope = match[1];
-    const scopeRoot = this.options.scopedPaths[scope];
-    if (!scopeRoot) {
-      return {
-        success: false,
-        error: `Scoped package "${scope}" not configured. Available: ${Object.keys(this.options.scopedPaths).join(", ") || "none"}`
-      };
+  getCacheStats() {
+    let size = this.cache.size;
+    if (this.httpLoader) {
+      size += this.httpLoader.getCacheStats().size;
     }
-    const relativePath = importPath.slice(scope.length + 1);
-    let absoluteUrl = this.joinUrl(scopeRoot, relativePath);
-    if (!absoluteUrl.endsWith(".orb")) {
-      absoluteUrl += ".orb";
+    if (this.fsLoader) {
+      size += this.fsLoader.getCacheStats().size;
     }
-    return { success: true, data: absoluteUrl };
+    return { size };
   }
   /**
-   * Resolve a relative path.
+   * Check if filesystem loading is available.
    */
-  resolveRelativePath(importPath, fromPath) {
-    const baseUrl = fromPath ? this.getParentUrl(fromPath) : this.options.basePath;
-    let absoluteUrl = this.joinUrl(baseUrl, importPath);
-    if (!absoluteUrl.endsWith(".orb")) {
-      absoluteUrl += ".orb";
-    }
-    return { success: true, data: absoluteUrl };
+  async hasFilesystemAccess() {
+    await this.initFsLoader();
+    return this.fsLoader !== null;
   }
   /**
-   * Fetch and parse an OrbitalSchema from a URL.
+   * Get current environment info.
    */
-  async fetchSchema(url) {
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(
-        () => controller.abort(),
-        this.options.timeout
-      );
-      try {
-        const response = await fetch(url, {
-          ...this.options.fetchOptions,
-          credentials: this.options.credentials,
-          signal: controller.signal,
-          headers: {
-            Accept: "application/json",
-            ...this.options.fetchOptions?.headers
-          }
-        });
-        if (!response.ok) {
-          return {
-            success: false,
-            error: `HTTP ${response.status}: ${response.statusText} for ${url}`
-          };
-        }
-        const text = await response.text();
-        let data;
-        try {
-          data = JSON.parse(text);
-        } catch (e) {
-          return {
-            success: false,
-            error: `Invalid JSON in ${url}: ${e instanceof Error ? e.message : String(e)}`
-          };
-        }
-        const parseResult = OrbitalSchemaSchema.safeParse(data);
-        if (!parseResult.success) {
-          const errors = parseResult.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
-          return {
-            success: false,
-            error: `Invalid schema in ${url}:
-${errors}`
-          };
-        }
-        return { success: true, data: parseResult.data };
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    } catch (e) {
-      if (e instanceof Error && e.name === "AbortError") {
-        return {
-          success: false,
-          error: `Request timeout for ${url} (${this.options.timeout}ms)`
-        };
-      }
-      return {
-        success: false,
-        error: `Failed to fetch ${url}: ${e instanceof Error ? e.message : String(e)}`
-      };
-    }
+  getEnvironmentInfo() {
+    return {
+      isElectron: isElectron(),
+      isBrowser: isBrowser(),
+      isNode: isNode(),
+      hasFilesystem: this.fsLoader !== null
+    };
   }
-  /**
-   * Join URL parts, handling relative paths and trailing slashes.
-   */
-  joinUrl(base, path) {
-    if (path.startsWith("http://") || path.startsWith("https://")) {
-      return path;
+};
+function createUnifiedLoader(options) {
+  return new UnifiedLoader(options);
+}
+createLogger("almadar:runtime:studio-config");
+var refResolverLog = createLogger("almadar:runtime:ref-resolver");
+function renameEventsInRenderUiConfig(node, rename) {
+  if (node === null || node === void 0) return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => renameEventsInRenderUiConfig(item, rename));
+  }
+  if (typeof node !== "object") return node;
+  const obj = node;
+  const next = { ...obj };
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "action" && typeof value === "string" && !value.startsWith("@")) {
+      next[key] = rename(value) ?? value;
+      continue;
     }
-    if (typeof URL !== "undefined") {
-      try {
-        const baseUrl = base.endsWith("/") ? base : base + "/";
-        return new URL(path, baseUrl).href;
-      } catch {
-      }
+    if (/^on[A-Z]/.test(key) && typeof value === "string" && !value.startsWith("@")) {
+      next[key] = rename(value) ?? value;
+      continue;
     }
-    const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
-    const normalizedPath = path.startsWith("/") ? path : "/" + path;
-    if (normalizedPath.startsWith("/./")) {
-      return normalizedBase + normalizedPath.slice(2);
+    if (key.endsWith("Event") && typeof value === "string" && !value.startsWith("@")) {
+      next[key] = rename(value) ?? value;
+      continue;
     }
-    if (normalizedPath.startsWith("/../")) {
-      const baseParts = normalizedBase.split("/");
-      baseParts.pop();
-      return baseParts.join("/") + normalizedPath.slice(3);
+    if ((key === "actions" || key === "itemActions") && Array.isArray(value)) {
+      const rewrittenArray = value.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) return entry;
+        const action = entry;
+        if (typeof action.event === "string" && !action.event.startsWith("@")) {
+          return { ...action, event: rename(action.event) ?? action.event };
+        }
+        return action;
+      });
+      next[key] = rewrittenArray;
+      continue;
     }
-    return normalizedBase + normalizedPath;
+    next[key] = renameEventsInRenderUiConfig(value, rename);
   }
-  /**
-   * Get parent URL (directory) from a URL.
-   */
-  getParentUrl(url) {
-    if (typeof URL !== "undefined") {
-      try {
-        const urlObj = new URL(url);
-        const pathParts = urlObj.pathname.split("/");
-        pathParts.pop();
-        urlObj.pathname = pathParts.join("/");
-        return urlObj.href;
-      } catch {
-      }
-    }
-    const lastSlash = url.lastIndexOf("/");
-    if (lastSlash !== -1) {
-      return url.slice(0, lastSlash);
+  return next;
+}
+function renameEventsInEffects(effects, rename) {
+  return effects.map((effect) => {
+    if (!Array.isArray(effect)) return effect;
+    if (effect[0] === "render-ui" && effect.length >= 3) {
+      const slot = effect[1];
+      const config = effect[2];
+      const nextConfig = renameEventsInRenderUiConfig(config, rename);
+      return [effect[0], slot, nextConfig, ...effect.slice(3)];
     }
-    return url;
-  }
-  /**
-   * Clear the cache.
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-  /**
-   * Get cache statistics.
-   */
-  getCacheStats() {
-    return { size: this.cache.size };
-  }
-};
-
-// src/loader/unified-loader.ts
-var externalLoaderModule = null;
-async function getExternalLoaderModule() {
-  if (externalLoaderModule) {
-    return externalLoaderModule;
-  }
-  if (isBrowser()) {
-    return null;
-  }
-  try {
-    externalLoaderModule = await import('./external-loader-IN246DQM.js');
-    return externalLoaderModule;
-  } catch {
-    return null;
-  }
+    return effect;
+  });
 }
-var UnifiedImportChain = class _UnifiedImportChain {
-  chain = [];
-  push(path) {
-    const normalized = this.normalizePath(path);
-    if (this.chain.includes(normalized)) {
-      const cycle = [
-        ...this.chain.slice(this.chain.indexOf(normalized)),
-        normalized
-      ];
-      return `Circular import detected: ${cycle.join(" -> ")}`;
+function renameEntityInRenderUiConfig(node, oldName, newName) {
+  if (node === null || node === void 0) return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => renameEntityInRenderUiConfig(item, oldName, newName));
+  }
+  if (typeof node !== "object") return node;
+  const obj = node;
+  const next = { ...obj };
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "entity" && value === oldName) {
+      next[key] = newName;
+      continue;
     }
-    this.chain.push(normalized);
-    return null;
+    next[key] = renameEntityInRenderUiConfig(value, oldName, newName);
   }
-  pop() {
-    this.chain.pop();
+  return next;
+}
+function renameEntityInEffects(effects, oldName, newName) {
+  return effects.map((effect) => renameEntityInEffect(effect, oldName, newName));
+}
+var ENTITY_AT_POS_1 = /* @__PURE__ */ new Set(["fetch", "ref", "deref", "spawn"]);
+var ALL_ARGS_ARE_EFFECTS = /* @__PURE__ */ new Set([
+  "do",
+  "atomic",
+  "async/race",
+  "async/all",
+  "async/sequence"
+]);
+var ARGS_FROM_POS_2_ARE_EFFECTS = /* @__PURE__ */ new Set([
+  "if",
+  "when",
+  "let",
+  "async/delay",
+  "async/debounce",
+  "async/throttle",
+  "async/interval"
+]);
+function renameEntityInEffect(effect, oldName, newName) {
+  if (!Array.isArray(effect) || effect.length === 0) return effect;
+  const op = effect[0];
+  if (typeof op !== "string") return effect;
+  if (op === "render-ui" && effect.length >= 3) {
+    const [, slot, config, ...rest] = effect;
+    const nextConfig = renameEntityInRenderUiConfig(config, oldName, newName);
+    return [op, slot, nextConfig, ...rest];
   }
-  clone() {
-    const newChain = new _UnifiedImportChain();
-    newChain.chain = [...this.chain];
-    return newChain;
+  if (op === "persist" && effect.length >= 3 && effect[2] === oldName) {
+    return [op, effect[1], newName, ...effect.slice(3)];
   }
-  normalizePath(path) {
-    if (path.startsWith("http://") || path.startsWith("https://")) {
-      return path;
-    }
-    return path.replace(/\\/g, "/");
+  if (ENTITY_AT_POS_1.has(op) && effect[1] === oldName) {
+    return [op, newName, ...effect.slice(2)];
   }
-};
-var UnifiedLoader = class {
-  options;
-  httpLoader = null;
-  fsLoader = null;
-  fsLoaderInitialized = false;
-  cache = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = options;
-    this.httpLoader = new HttpLoader({
-      basePath: options.basePath,
-      stdLibPath: options.stdLibPath,
-      scopedPaths: options.scopedPaths,
-      ...options.http
+  const skipFirstNonEffectArg = ARGS_FROM_POS_2_ARE_EFFECTS.has(op);
+  const recurseAll = ALL_ARGS_ARE_EFFECTS.has(op);
+  if (recurseAll || skipFirstNonEffectArg) {
+    const startIndex = skipFirstNonEffectArg ? 2 : 1;
+    return effect.map((arg, i) => {
+      if (i < startIndex) return arg;
+      if (Array.isArray(arg)) {
+        return renameEntityInEffect(arg, oldName, newName);
+      }
+      return arg;
     });
   }
-  /**
-   * Initialize the filesystem loader if available.
-   */
-  async initFsLoader() {
-    if (this.fsLoaderInitialized) {
-      return;
-    }
-    this.fsLoaderInitialized = true;
-    if (this.options.forceLoader === "http") {
-      return;
-    }
-    const module = await getExternalLoaderModule();
-    if (module) {
-      this.fsLoader = new module.ExternalOrbitalLoader({
-        basePath: this.options.basePath,
-        stdLibPath: this.options.stdLibPath,
-        scopedPaths: this.options.scopedPaths,
-        ...this.options.fileSystem
-      });
-    }
-  }
-  /**
-   * Determine which loader to use for an import path.
-   */
-  getLoaderForPath(importPath) {
-    if (this.options.forceLoader) {
-      return this.options.forceLoader;
-    }
-    if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
-      return "http";
-    }
-    if (importPath.startsWith("std/") && this.options.stdLibPath) {
-      if (this.options.stdLibPath.startsWith("http://") || this.options.stdLibPath.startsWith("https://")) {
-        return "http";
-      }
-    }
-    if (importPath.startsWith("@") && this.options.scopedPaths) {
-      const match = importPath.match(/^(@[^/]+)/);
-      if (match) {
-        const scopePath = this.options.scopedPaths[match[1]];
-        if (scopePath && (scopePath.startsWith("http://") || scopePath.startsWith("https://"))) {
-          return "http";
-        }
-      }
-    }
-    if (isBrowser()) {
-      return "http";
-    }
-    return "filesystem";
-  }
-  /**
-   * Load a schema from an import path.
-   *
-   * Note: We delegate chain management to the inner loader (HttpLoader or FsLoader).
-   * The inner loader handles circular import detection, so we don't push/pop here.
-   * We only use the unified cache to avoid duplicate loads across loaders.
-   */
-  async load(importPath, fromPath, chain) {
-    await this.initFsLoader();
-    const importChain = chain ?? new UnifiedImportChain();
-    const loaderType = this.getLoaderForPath(importPath);
-    const resolveResult = this.resolvePath(importPath, fromPath);
-    if (!resolveResult.success) {
-      return resolveResult;
-    }
-    const absolutePath = resolveResult.data;
-    const cached = this.cache.get(absolutePath);
-    if (cached) {
-      return { success: true, data: cached };
-    }
-    let result;
-    if (loaderType === "http") {
-      if (!this.httpLoader) {
-        return {
-          success: false,
-          error: "HTTP loader not available"
-        };
-      }
-      result = await this.httpLoader.load(importPath, fromPath, importChain);
-    } else {
-      if (!this.fsLoader) {
-        if (this.httpLoader) {
-          result = await this.httpLoader.load(
-            importPath,
-            fromPath,
-            importChain
-          );
-        } else {
-          return {
-            success: false,
-            error: `Filesystem loader not available and import "${importPath}" cannot be loaded via HTTP. This typically happens when loading local files in a browser environment.`
-          };
-        }
-      } else {
-        result = await this.fsLoader.load(importPath, fromPath, importChain);
-      }
-    }
-    if (result.success) {
-      this.cache.set(absolutePath, result.data);
-    }
-    return result;
-  }
-  /**
-   * Load a specific orbital from a schema by name.
-   */
-  async loadOrbital(importPath, orbitalName, fromPath, chain) {
-    const schemaResult = await this.load(importPath, fromPath, chain);
-    if (!schemaResult.success) {
-      return schemaResult;
-    }
-    const schema = schemaResult.data.schema;
-    if (orbitalName) {
-      const found = schema.orbitals.find((o) => o.name === orbitalName);
-      if (!found) {
-        return {
-          success: false,
-          error: `Orbital "${orbitalName}" not found in ${importPath}. Available: ${schema.orbitals.map((o) => o.name).join(", ")}`
-        };
-      }
-      return {
-        success: true,
-        data: {
-          orbital: found,
-          sourcePath: schemaResult.data.sourcePath,
-          importPath
-        }
-      };
-    }
-    if (schema.orbitals.length === 0) {
-      return {
-        success: false,
-        error: `No orbitals found in ${importPath}`
-      };
-    }
-    return {
-      success: true,
-      data: {
-        orbital: schema.orbitals[0],
-        sourcePath: schemaResult.data.sourcePath,
-        importPath
-      }
-    };
-  }
-  /**
-   * Resolve an import path to an absolute path/URL.
-   */
-  resolvePath(importPath, fromPath) {
-    const loaderType = this.getLoaderForPath(importPath);
-    if (loaderType === "http" && this.httpLoader) {
-      return this.httpLoader.resolvePath(importPath, fromPath);
-    }
-    if (this.fsLoader) {
-      return this.fsLoader.resolvePath(importPath, fromPath);
-    }
-    if (this.httpLoader) {
-      return this.httpLoader.resolvePath(importPath, fromPath);
-    }
-    return {
-      success: false,
-      error: "No loader available for path resolution"
-    };
-  }
-  /**
-   * Clear all caches.
-   */
-  clearCache() {
-    this.cache.clear();
-    this.httpLoader?.clearCache();
-    this.fsLoader?.clearCache();
-  }
-  /**
-   * Get combined cache statistics.
-   */
-  getCacheStats() {
-    let size = this.cache.size;
-    if (this.httpLoader) {
-      size += this.httpLoader.getCacheStats().size;
-    }
-    if (this.fsLoader) {
-      size += this.fsLoader.getCacheStats().size;
-    }
-    return { size };
-  }
-  /**
-   * Check if filesystem loading is available.
-   */
-  async hasFilesystemAccess() {
-    await this.initFsLoader();
-    return this.fsLoader !== null;
-  }
-  /**
-   * Get current environment info.
-   */
-  getEnvironmentInfo() {
-    return {
-      isElectron: isElectron(),
-      isBrowser: isBrowser(),
-      isNode: isNode(),
-      hasFilesystem: this.fsLoader !== null
-    };
-  }
-};
-function createUnifiedLoader(options) {
-  return new UnifiedLoader(options);
+  return effect;
 }
-createLogger("almadar:runtime:studio-config");
-
-// src/UsesIntegration.ts
-async function preprocessSchema(schema, options) {
-  const namespaceEvents = options.namespaceEvents ?? true;
-  const resolveResult = await resolveSchema(schema, options);
-  if (!resolveResult.success) {
-    return { success: false, errors: resolveResult.errors };
-  }
-  const resolved = resolveResult.data;
-  const warnings = resolveResult.warnings;
-  const preprocessedOrbitals = [];
-  const entitySharing = {};
-  const eventNamespaces = {};
-  for (const resolvedOrbital of resolved) {
-    const orbitalName = resolvedOrbital.name;
-    const persistence = resolvedOrbital.entitySource?.persistence ?? resolvedOrbital.entity.persistence ?? "persistent";
-    entitySharing[orbitalName] = {
-      entityName: resolvedOrbital.entity.name,
-      persistence,
-      isShared: persistence !== "runtime",
-      sourceAlias: resolvedOrbital.entitySource?.alias,
-      collectionName: resolvedOrbital.entity.collection
-    };
-    eventNamespaces[orbitalName] = {};
-    for (const resolvedTrait of resolvedOrbital.traits) {
-      const traitName = resolvedTrait.trait.name;
-      const namespace = {
-        emits: {},
-        listens: {}
-      };
-      if (namespaceEvents && resolvedTrait.source.type === "imported") {
-        const emits = resolvedTrait.trait.emits ?? [];
-        for (const emit of emits) {
-          const eventName = typeof emit === "string" ? emit : emit.event;
-          namespace.emits[eventName] = `${orbitalName}.${traitName}.${eventName}`;
-        }
-        const listens = resolvedTrait.trait.listens ?? [];
-        for (const listen of listens) {
-          namespace.listens[listen.event] = listen.event;
-        }
-      }
-      eventNamespaces[orbitalName][traitName] = namespace;
-    }
-    const preprocessedOrbital = {
-      name: orbitalName,
-      description: resolvedOrbital.original.description,
-      visual_prompt: resolvedOrbital.original.visual_prompt,
-      // Resolved entity (always inline now)
-      entity: resolvedOrbital.entity,
-      // Resolved traits (inline definitions)
-      traits: (resolvedOrbital.traits || []).map((rt) => {
-        if (rt.config || rt.linkedEntity) {
-          return {
-            ref: rt.trait.name,
-            config: rt.config,
-            linkedEntity: rt.linkedEntity,
-            // Include the resolved trait definition for runtime
-            _resolved: rt.trait
-          };
-        }
-        return rt.trait;
-      }),
-      // Resolved pages (inline definitions with path overrides applied)
-      pages: resolvedOrbital.pages.map((rp) => rp.page),
-      // Preserve other fields
-      exposes: resolvedOrbital.original.exposes,
-      domainContext: resolvedOrbital.original.domainContext,
-      design: resolvedOrbital.original.design,
-      // Gap #22: pass through auxiliary entities so OrbitalServerRuntime's
-      // mock-seed branch registers SearchResult / FilterTarget / PagedItem
-      // alongside the molecule's primary entity. Without this, an inlined
-      // .orb that has `auxiliaryEntities` populated by the Rust inline
-      // phase still loses them here, and `(set @entity.searchTerm ...)` /
-      // `(fetch SearchResult ...)` from no-rebind imports hit unregistered
-      // persistence and silently no-op.
-      auxiliaryEntities: resolvedOrbital.original.auxiliaryEntities
-    };
-    preprocessedOrbitals.push(preprocessedOrbital);
-  }
-  const preprocessedSchema = {
-    ...schema,
-    orbitals: preprocessedOrbitals
-  };
+function applyLinkedEntityRename(trait, linkedEntity) {
+  const atomLinked = trait.linkedEntity;
+  if (!linkedEntity || !atomLinked || linkedEntity === atomLinked) return trait;
+  const sm = trait.stateMachine;
+  if (!sm) return { ...trait, linkedEntity };
+  const nextTransitions = (sm.transitions ?? []).map((t) => {
+    const nextEffects = t.effects ? renameEntityInEffects(
+      t.effects,
+      atomLinked,
+      linkedEntity
+    ) : t.effects;
+    return { ...t, effects: nextEffects };
+  });
+  refResolverLog.info("linkedEntity:rename", {
+    trait: trait.name,
+    from: atomLinked,
+    to: linkedEntity,
+    transitionCount: nextTransitions.length
+  });
   return {
-    success: true,
-    data: {
-      schema: preprocessedSchema,
-      entitySharing,
-      eventNamespaces,
-      warnings
-    }
+    ...trait,
+    linkedEntity,
+    stateMachine: { ...sm, transitions: nextTransitions }
   };
 }
-function getIsolatedCollectionName(orbitalName, entitySharing) {
-  const info = entitySharing[orbitalName];
-  if (!info) {
-    throw new Error(`Unknown orbital: ${orbitalName}`);
-  }
-  if (info.persistence === "runtime") {
-    return `${orbitalName}_${info.entityName}`;
-  }
-  return info.collectionName || info.entityName.toLowerCase() + "s";
-}
-function getNamespacedEvent(orbitalName, traitName, eventName, eventNamespaces) {
-  const orbitalNs = eventNamespaces[orbitalName];
-  if (!orbitalNs) return eventName;
-  const traitNs = orbitalNs[traitName];
-  if (!traitNs) return eventName;
-  return traitNs.emits[eventName] || eventName;
-}
-function isNamespacedEvent(eventName) {
-  return eventName.includes(".");
-}
-function parseNamespacedEvent(eventName) {
-  const parts = eventName.split(".");
-  if (parts.length === 3) {
-    return { orbital: parts[0], trait: parts[1], event: parts[2] };
-  }
-  if (parts.length === 2) {
-    return { trait: parts[0], event: parts[1] };
-  }
-  return { event: eventName };
-}
-
-// src/PersistenceAdapter.ts
-var InMemoryPersistence = class {
-  data = /* @__PURE__ */ new Map();
-  idCounter = 0;
-  /**
-   * Seed the store with pre-existing rows.
-   *
-   * Accepts either a plain `Record<entityType, EntityRow[]>` or an iterable
-   * of `[entityType, EntityRow[]]` entries. Rows without an `id` get one
-   * generated at insert time; rows with an `id` keep it (so re-seeding
-   * after a schema rebuild preserves identities used in render bindings).
-   */
-  seed(seedData) {
-    const entries = Symbol.iterator in Object(seedData) ? seedData : Object.entries(seedData);
-    for (const [entityType, rows] of entries) {
-      if (!this.data.has(entityType)) {
-        this.data.set(entityType, /* @__PURE__ */ new Map());
-      }
-      const collection = this.data.get(entityType);
-      for (const row of rows) {
-        const id = row.id || `${entityType}-${++this.idCounter}`;
-        collection.set(id, { ...row, id });
-      }
-    }
-  }
-  async create(entityType, data) {
-    const id = data.id || `${entityType}-${++this.idCounter}`;
-    if (!this.data.has(entityType)) {
-      this.data.set(entityType, /* @__PURE__ */ new Map());
-    }
-    this.data.get(entityType).set(id, { ...data, id });
-    return { id };
+function applyEventRenames(trait, renames) {
+  if (!renames || Object.keys(renames).length === 0) return trait;
+  const rename = (k) => k !== void 0 && k in renames ? renames[k] : k;
+  const sm = trait.stateMachine;
+  if (!sm) return trait;
+  const nextTransitions = (sm.transitions ?? []).map((t) => {
+    const nextEvent = rename(t.event) ?? t.event;
+    const nextEffects = t.effects ? renameEventsInEffects(t.effects, rename) : t.effects;
+    return { ...t, event: nextEvent, effects: nextEffects };
+  });
+  const nextEvents = (sm.events ?? []).map((e) => {
+    const newKey = rename(e.key);
+    if (newKey === e.key) return e;
+    return { ...e, key: newKey ?? e.key };
+  });
+  const nextEmits = (trait.emits ?? []).map((em) => {
+    if (typeof em === "string") return rename(em) ?? em;
+    const newEvent = rename(em.event);
+    return newEvent === em.event ? em : { ...em, event: newEvent ?? em.event };
+  });
+  return {
+    ...trait,
+    stateMachine: {
+      ...sm,
+      transitions: nextTransitions,
+      events: nextEvents
+    },
+    emits: nextEmits
+  };
+}
+var ReferenceResolver = class {
+  loader;
+  options;
+  localTraits;
+  loaderInitialized = false;
+  constructor(options) {
+    this.options = options;
+    this.loader = options.loader;
+    this.localTraits = options.localTraits ?? /* @__PURE__ */ new Map();
   }
-  async update(entityType, id, data) {
-    const collection = this.data.get(entityType);
-    if (collection?.has(id)) {
-      const existing = collection.get(id);
-      collection.set(id, { ...existing, ...data });
+  async ensureLoader() {
+    if (this.loader || this.loaderInitialized) return;
+    this.loaderInitialized = true;
+    try {
+      const { ExternalOrbitalLoader } = await import('./external-loader-IN246DQM.js');
+      this.loader = new ExternalOrbitalLoader(this.options);
+    } catch {
     }
   }
-  async delete(entityType, id) {
-    this.data.get(entityType)?.delete(id);
-  }
-  async getById(entityType, id) {
-    return this.data.get(entityType)?.get(id) || null;
-  }
-  async list(entityType) {
-    const collection = this.data.get(entityType);
-    return collection ? Array.from(collection.values()) : [];
-  }
   /**
-   * Snapshot the entire store as a plain object (entityType → rows).
-   * Useful for feeding a fresh render-time binding layer with the
-   * current persistence view.
+   * Resolve all references in an orbital.
    */
-  snapshot() {
-    const out = {};
-    for (const [entityType, collection] of this.data) {
-      out[entityType] = Array.from(collection.values());
-    }
-    return out;
-  }
-};
-
-// src/OrbitalServerRuntime.ts
-var _resolvedNodeRequire = null;
-function nodeRequire(modulePath) {
-  if (!_resolvedNodeRequire) {
-    const evalRequire = (0, eval)('typeof require !== "undefined" ? require : null');
-    if (evalRequire) {
-      _resolvedNodeRequire = evalRequire;
-    } else {
-      const createReq = nodeModule.createRequire;
-      if (typeof createReq !== "function") {
-        throw new Error(
-          "[OrbitalServerRuntime] No synchronous require available. This branch is Node-only \u2014 invoking it from a browser indicates an isNodeEnv() guard regression upstream."
-        );
-      }
-      _resolvedNodeRequire = createReq(import.meta.url);
-    }
-  }
-  return _resolvedNodeRequire(modulePath);
-}
-var _nodeRequireExt = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
-var effectLog2 = createLogger("almadar:runtime:effects");
-var busLog = createLogger("almadar:runtime:bus");
-var renderLog2 = createLogger("almadar:runtime:render-ui");
-var xOrbitalLog = createLogger("almadar:runtime:cross-orbital");
-var persistLog = createLogger("almadar:runtime:persist");
-var registerLog = createLogger("almadar:runtime:register");
-var dynamicLog = createLogger("almadar:runtime:dynamic");
-function isNodeEnv() {
-  return typeof process !== "undefined" && Boolean(process.versions?.node);
-}
-function collectDeclaredConfigDefaults(trait) {
-  if (!trait) return void 0;
-  const schema = trait.config;
-  if (!schema || typeof schema !== "object") return void 0;
-  const defaults = {};
-  let hasAny = false;
-  for (const [key, field] of Object.entries(schema)) {
-    if (field && typeof field === "object" && !Array.isArray(field) && "default" in field) {
-      const def = field.default;
-      if (def !== void 0) {
-        defaults[key] = def;
-        hasAny = true;
-      }
+  async resolve(orbital, sourcePath, chain) {
+    const errors = [];
+    const warnings = [];
+    const importChain = chain ?? { push: () => null, pop: () => {
+    }, clone() {
+      return this;
+    } };
+    const traitsList = orbital.traits ?? [];
+    const alreadyResolved = traitsList.length > 0 && traitsList.every((t) => isInlineTrait(t));
+    const importsResult = alreadyResolved ? { success: true, data: { orbitals: /* @__PURE__ */ new Map() }} : await this.resolveImports(orbital.uses ?? [], sourcePath, importChain);
+    if (!importsResult.success) {
+      return { success: false, errors: importsResult.errors };
     }
-  }
-  return hasAny ? defaults : void 0;
-}
-function needsPreprocessing(schema) {
-  for (const orbital of schema.orbitals) {
-    const uses = orbital.uses;
-    if (Array.isArray(uses) && uses.length > 0) {
-      return true;
-    }
-    const traits = orbital.traits ?? [];
-    for (const t of traits) {
-      if (!t || typeof t !== "object") continue;
-      const obj = t;
-      if (typeof obj.ref === "string" && obj.ref.includes(".") && !obj.stateMachine) {
-        return true;
-      }
+    const imports = importsResult.data;
+    const entityResult = this.resolveEntity(orbital.entity, imports);
+    if (!entityResult.success) {
+      errors.push(...entityResult.errors);
     }
-  }
-  return false;
-}
-var OrbitalServerRuntime = class {
-  orbitals = /* @__PURE__ */ new Map();
-  eventBus;
-  config;
-  persistence;
-  listenerCleanups = [];
-  tickBindings = [];
-  loader = null;
-  preprocessedCache = /* @__PURE__ */ new Map();
-  entitySharingMap = {};
-  eventNamespaceMap = {};
-  osHandlers = null;
-  localPersistence = null;
-  resolvedSchema = null;
-  constructor(config = {}) {
-    this.config = {
-      mode: "mock",
-      // Default to mock mode for preview
-      autoPreprocess: false,
-      namespaceEvents: true,
-      ...config
-    };
-    this.eventBus = new EventBus();
-    if (config.loaderConfig?.loader) {
-      this.loader = config.loaderConfig.loader;
-    } else if (config.loaderConfig?.stdLibPath) {
-      this.loader = createUnifiedLoader({
-        basePath: config.loaderConfig.basePath,
-        stdLibPath: config.loaderConfig.stdLibPath,
-        scopedPaths: config.loaderConfig.scopedPaths
-      });
+    const traitsResult = this.resolveTraits(orbital.traits, imports);
+    if (!traitsResult.success) {
+      errors.push(...traitsResult.errors);
     }
-    if (this.config.mode === "mock" && !config.persistence) {
-      this.persistence = new MockPersistenceAdapter({
-        seed: config.mockSeed,
-        defaultSeedCount: config.mockSeedCount ?? 6,
-        debug: config.debug
-      });
-      if (config.debug) {
-        persistLog.debug("mock:init", { adapter: "MockPersistenceAdapter" });
-      }
-    } else {
-      this.persistence = config.persistence || new InMemoryPersistence();
+    const pagesResult = this.resolvePages(orbital.pages, imports);
+    if (!pagesResult.success) {
+      errors.push(...pagesResult.errors);
     }
-    if (config.localStorageRoot && isNodeEnv()) {
-      const { LocalPersistenceAdapter } = nodeRequire(`./LocalPersistenceAdapter${_nodeRequireExt}`);
-      this.localPersistence = new LocalPersistenceAdapter(config.localStorageRoot);
+    if (errors.length > 0) {
+      return { success: false, errors };
     }
-    if (isNodeEnv()) {
-      const { createOsHandlers } = nodeRequire(`./createOsHandlers${_nodeRequireExt}`);
-      this.osHandlers = createOsHandlers({
-        emitEvent: (type, payload) => this.eventBus.emit(type, payload)
-      });
-    } else {
-      this.osHandlers = { handlers: {}, cleanup: () => {
-      } };
+    if (!entityResult.success || !traitsResult.success || !pagesResult.success) {
+      return { success: false, errors: ["Internal error: unexpected failure state"] };
     }
-    this.config.effectHandlers = {
-      ...this.osHandlers.handlers,
-      ...this.config.effectHandlers
+    return {
+      success: true,
+      data: {
+        name: orbital.name,
+        entity: entityResult.data.entity,
+        entitySource: entityResult.data.source,
+        traits: traitsResult.data,
+        pages: pagesResult.data,
+        imports,
+        original: orbital
+      },
+      warnings
     };
   }
   /**
-   * Lazily construct a default loader when the caller didn't provide one
-   * but `register()` needs to preprocess. Looks for `@almadar/std` in the
-   * nearest `node_modules` so cross-orbital `std/behaviors/<name>` imports
-   * resolve to the tiered registry on disk.
-   *
-   * Node only — browsers should receive already-preprocessed schemas from
-   * their server.
+   * Resolve `uses` declarations to loaded orbitals.
    */
-  async ensureLoader() {
-    if (this.loader) return;
-    if (typeof process === "undefined" || !process.versions?.node) {
-      return;
+  async resolveImports(uses, sourcePath, chain) {
+    const errors = [];
+    const orbitals = /* @__PURE__ */ new Map();
+    if (this.options.skipExternalLoading) {
+      return {
+        success: true,
+        data: { orbitals },
+        warnings: ["External loading skipped"]
+      };
     }
-    try {
-      const [{ fileURLToPath }, path, fs] = await Promise.all([
-        import('url'),
-        import('path'),
-        import('fs')
-      ]);
-      const mainEntryUrl = import.meta.resolve("@almadar/std");
-      const mainEntry = fileURLToPath(mainEntryUrl);
-      let stdLibPath = path.dirname(mainEntry);
-      while (stdLibPath !== path.dirname(stdLibPath)) {
-        if (fs.existsSync(path.join(stdLibPath, "package.json"))) {
-          const pkg = JSON.parse(
-            fs.readFileSync(path.join(stdLibPath, "package.json"), "utf-8")
-          );
-          if (pkg.name === "@almadar/std") break;
-        }
-        stdLibPath = path.dirname(stdLibPath);
-      }
-      const basePath = this.config.loaderConfig?.basePath ?? process.cwd();
-      this.loader = createUnifiedLoader({
-        basePath,
-        stdLibPath,
-        scopedPaths: this.config.loaderConfig?.scopedPaths
-      });
-      if (this.config.debug) {
-        registerLog.debug("loader:constructed", { basePath, stdLibPath });
-      }
-    } catch (err) {
-      if (this.config.debug) {
-        registerLog.warn("loader:construct-failed", { error: err instanceof Error ? err : String(err) });
+    for (const use of uses) {
+      if (orbitals.has(use.as)) {
+        errors.push(`Duplicate import alias: ${use.as}`);
+        continue;
       }
-    }
-  }
-  // ==========================================================================
-  // Schema Registration
-  // ==========================================================================
-  /**
-   * Register an OrbitalSchema for execution.
-   *
-   * Auto-preprocesses the schema when it contains `uses` declarations or
-   * unresolved cross-orbital trait references (e.g. a trait with
-   * `ref: "Modal.traits.ModalRecordModal"` and no inline `stateMachine`).
-   * Without preprocessing, those refs arrive empty at the state machine and
-   * button clicks silently do nothing — see Phase 9.5.H.
-   *
-   * Preprocessing needs a loader. If `loaderConfig` is set, that loader is
-   * used. Otherwise, a default loader is constructed that points at
-   * `<cwd>` (for `basePath`) and the nearest `node_modules/@almadar/std` (for
-   * `stdLibPath`), which matches how every caller in this monorepo has the
-   * std registry on disk.
-   */
-  async register(schema) {
-    if (this.config.debug) {
-      registerLog.debug("register:schema", { name: schema.name });
-    }
-    if (needsPreprocessing(schema)) {
       await this.ensureLoader();
-      if (this.loader) {
-        if (this.config.debug) {
-          registerLog.debug("register:auto-preprocessing", { name: schema.name });
-        }
-        const result = await preprocessSchema(schema, {
-          basePath: this.config.loaderConfig?.basePath || process.cwd(),
-          stdLibPath: this.config.loaderConfig?.stdLibPath,
-          scopedPaths: this.config.loaderConfig?.scopedPaths,
-          loader: this.loader,
-          namespaceEvents: this.config.namespaceEvents
-        });
-        if (!result.success) {
-          throw new Error(
-            `Schema preprocessing failed: ${result.errors.join("; ")}`
-          );
-        }
-        schema = result.data.schema;
-        this.entitySharingMap = {
-          ...this.entitySharingMap,
-          ...result.data.entitySharing
-        };
-        this.eventNamespaceMap = {
-          ...this.eventNamespaceMap,
-          ...result.data.eventNamespaces
-        };
-      } else if (this.config.debug) {
-        registerLog.warn("register:no-loader", { name: schema.name });
+      if (!this.loader) {
+        errors.push(`No loader available to resolve import: ${use.from}`);
+        continue;
       }
+      const loadResult = await this.loader.loadOrbital(
+        use.from,
+        void 0,
+        sourcePath,
+        chain
+      );
+      if (!loadResult.success) {
+        errors.push(`Failed to load "${use.from}" as "${use.as}": ${loadResult.error}`);
+        continue;
+      }
+      orbitals.set(use.as, {
+        alias: use.as,
+        from: use.from,
+        orbital: loadResult.data.orbital,
+        sourcePath: loadResult.data.sourcePath
+      });
     }
-    for (const orbital of schema.orbitals) {
-      await this.registerOrbitalAsync(orbital);
-    }
-    this.setupEventListeners();
-    this.setupTicks();
-    this.resolvedSchema = schema;
-  }
-  /**
-   * Register an OrbitalSchema synchronously (for backward compatibility).
-   * Note: This version doesn't wait for instance seeding to complete.
-   * Use async register() for guaranteed instance seeding.
-   */
-  registerSync(schema) {
-    if (this.config.debug) {
-      registerLog.debug("register:schema-sync", { name: schema.name });
-    }
-    for (const orbital of schema.orbitals) {
-      this.registerOrbital(orbital);
+    if (errors.length > 0) {
+      return { success: false, errors };
     }
-    this.setupEventListeners();
-    this.setupTicks();
-    this.resolvedSchema = schema;
-  }
-  /**
-   * Returns the schema that this runtime is currently executing, post-
-   * preprocessing. Safe to expose from an HTTP `/api/schema` endpoint — every
-   * cross-orbital trait ref will have an inline `stateMachine` already, which
-   * is what the browser's `schema-to-ir` resolver needs to wire button clicks
-   * back to state transitions.
-   *
-   * Returns `null` if `register()` hasn't run yet.
-   */
-  getResolvedSchema() {
-    return this.resolvedSchema;
+    return { success: true, data: { orbitals }, warnings: [] };
   }
   /**
-   * One-call entry point: read an `.orb` file from disk, parse it, preprocess
-   * cross-orbital imports, and register the result. Callers never touch raw
-   * `.orb` bytes — `register()` handles preprocessing internally.
-   *
-   * Node only. Browsers must receive already-resolved schemas from their
-   * server (see `getResolvedSchema()`).
+   * Resolve entity reference.
    */
-  async registerFromFile(path) {
-    if (typeof process === "undefined" || !process.versions?.node) {
-      throw new Error(
-        "registerFromFile is Node-only. Browsers should receive resolved schemas from their server."
-      );
+  resolveEntity(entityRef, imports) {
+    if (isEntityCall(entityRef)) {
+      const fallbackName = entityRef.name ?? entityRef.extends.replace(/\.entity$/, "");
+      return {
+        success: true,
+        data: {
+          entity: {
+            name: fallbackName,
+            fields: entityRef.fields ?? [],
+            ...entityRef.persistence ? { persistence: entityRef.persistence } : {},
+            ...entityRef.collection ? { collection: entityRef.collection } : {}
+          }
+        },
+        warnings: []
+      };
     }
-    const { readFile } = await import('fs/promises');
-    const raw = await readFile(path, "utf-8");
-    let schema;
-    try {
-      schema = JSON.parse(raw);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`registerFromFile: ${path} is not valid JSON: ${msg}`);
+    if (!isEntityReference(entityRef)) {
+      return {
+        success: true,
+        data: { entity: entityRef },
+        warnings: []
+      };
     }
-    await this.register(schema);
-  }
-  /**
-   * Register an OrbitalSchema with preprocessing to resolve `uses` imports.
-   *
-   * This method:
-   * 1. Loads all external orbitals referenced in `uses` declarations
-   * 2. Expands entity/trait/page references to inline definitions
-   * 3. Builds entity sharing and event namespace maps
-   * 4. Caches the preprocessed result
-   * 5. Registers the resolved schema
-   *
-   * @param schema - Schema with potential `uses` declarations
-   * @param options - Optional preprocessing options
-   * @returns Preprocessing result with entity sharing info
-   *
-   * @example
-   * ```typescript
-   * const runtime = new OrbitalServerRuntime({
-   *   loaderConfig: {
-   *     basePath: '/schemas',
-   *     stdLibPath: '/std',
-   *   },
-   * });
-   *
-   * const result = await runtime.registerWithPreprocess(schema);
-   * if (result.success) {
-   *   console.log('Registered with', Object.keys(result.entitySharing).length, 'orbitals');
-   * }
-   * ```
-   */
-  async registerWithPreprocess(schema, options) {
-    if (!this.loader && !this.config.loaderConfig) {
+    const parsed = parseEntityRef(entityRef);
+    if (!parsed) {
       return {
         success: false,
-        errors: ["Loader not configured. Set loaderConfig in OrbitalServerRuntimeConfig."]
+        errors: [`Invalid entity reference format: ${entityRef}. Expected "Alias.entity"`]
       };
     }
-    if (!this.loader && this.config.loaderConfig) {
-      this.loader = this.config.loaderConfig.loader ?? createUnifiedLoader({
-        basePath: this.config.loaderConfig.basePath,
-        stdLibPath: this.config.loaderConfig.stdLibPath,
-        scopedPaths: this.config.loaderConfig.scopedPaths
-      });
-    }
-    const cacheKey = `${schema.name}:${schema.version || "1.0.0"}`;
-    const cached = this.preprocessedCache.get(cacheKey);
-    if (cached) {
-      if (this.config.debug) {
-        registerLog.debug("preprocess:cache-hit", { name: schema.name });
-      }
-      this.register(cached.schema);
-      this.entitySharingMap = { ...this.entitySharingMap, ...cached.entitySharing };
-      this.eventNamespaceMap = { ...this.eventNamespaceMap, ...cached.eventNamespaces };
+    const imported = imports.orbitals.get(parsed.alias);
+    if (!imported) {
       return {
-        success: true,
-        entitySharing: cached.entitySharing,
-        eventNamespaces: cached.eventNamespaces,
-        warnings: cached.warnings
+        success: false,
+        errors: [
+          `Unknown import alias in entity reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
+        ]
       };
     }
-    if (this.config.debug) {
-      registerLog.debug("preprocess:start", { name: schema.name });
-    }
-    const result = await preprocessSchema(schema, {
-      basePath: this.config.loaderConfig?.basePath || ".",
-      stdLibPath: this.config.loaderConfig?.stdLibPath,
-      scopedPaths: this.config.loaderConfig?.scopedPaths,
-      loader: this.loader,
-      namespaceEvents: this.config.namespaceEvents
-    });
-    if (!result.success) {
+    const importedEntity = this.getEntityFromOrbital(imported.orbital);
+    if (!importedEntity) {
       return {
         success: false,
-        errors: result.errors
+        errors: [
+          `Imported orbital "${parsed.alias}" does not have an inline entity. Entity references cannot be chained.`
+        ]
       };
     }
-    this.preprocessedCache.set(cacheKey, result.data);
-    this.entitySharingMap = { ...this.entitySharingMap, ...result.data.entitySharing };
-    this.eventNamespaceMap = { ...this.eventNamespaceMap, ...result.data.eventNamespaces };
-    this.register(result.data.schema);
+    const persistence = importedEntity.persistence ?? "persistent";
     return {
       success: true,
-      entitySharing: result.data.entitySharing,
-      eventNamespaces: result.data.eventNamespaces,
-      warnings: result.data.warnings
+      data: {
+        entity: importedEntity,
+        source: {
+          alias: parsed.alias,
+          persistence
+        }
+      },
+      warnings: []
     };
   }
   /**
-   * Get entity sharing information for registered orbitals.
-   * Useful for determining entity isolation and collection names.
-   */
-  getEntitySharing() {
-    return { ...this.entitySharingMap };
-  }
-  /**
-   * Get event namespace mapping for registered orbitals.
-   * Useful for debugging cross-orbital event routing.
-   */
-  getEventNamespaces() {
-    return { ...this.eventNamespaceMap };
-  }
-  /**
-   * Clear the preprocessing cache.
-   */
-  clearPreprocessCache() {
-    this.preprocessedCache.clear();
-  }
-  /**
-   * Register a single orbital
+   * Get the entity from an orbital (handling EntityRef).
    */
-  async registerOrbitalAsync(orbital) {
-    const configByTrait = /* @__PURE__ */ new Map();
-    const unwrapped = (orbital.traits || []).map((t) => {
-      if (t && typeof t === "object" && "ref" in t && "_resolved" in t) {
-        const wrapper = t;
-        const inner = wrapper._resolved;
-        if (wrapper.config && inner?.name) {
-          configByTrait.set(inner.name, wrapper.config);
-        }
-        return inner;
-      }
-      return t;
-    });
-    const inlineTraits = unwrapped.filter(isInlineTrait);
-    const traitDefs = inlineTraits.map((t) => {
-      const sm = t.stateMachine;
-      const states = sm?.states || [];
-      const transitions = sm?.transitions || [];
-      return {
-        name: t.name,
-        states,
-        transitions,
-        listens: t.listens
-      };
-    });
-    const manager = new StateMachineManager(traitDefs, {
-      contextExtensions: this.config.contextExtensions
-    });
-    for (const [traitName, traitConfig] of configByTrait) {
-      manager.setTraitConfig(traitName, traitConfig);
-    }
+  getEntityFromOrbital(orbital) {
     const entityRef = orbital.entity;
-    let entity;
     if (typeof entityRef === "string") {
-      entity = { name: entityRef, fields: [] };
-    } else if (isEntityCall(entityRef)) {
+      return null;
+    }
+    if (isEntityCall(entityRef)) {
       const fallbackName = entityRef.name ?? entityRef.extends.replace(/\.entity$/, "");
-      entity = {
+      return {
         name: fallbackName,
         fields: entityRef.fields ?? [],
         ...entityRef.persistence ? { persistence: entityRef.persistence } : {},
         ...entityRef.collection ? { collection: entityRef.collection } : {}
       };
-    } else {
-      entity = entityRef;
-    }
-    this.orbitals.set(orbital.name, {
-      schema: orbital,
-      entity,
-      traits: inlineTraits,
-      configByTrait,
-      manager,
-      entityData: /* @__PURE__ */ new Map(),
-      traitFieldStates: /* @__PURE__ */ new Map()
-    });
-    if (entity?.name && entity.instances && Array.isArray(entity.instances)) {
-      const instances = entity.instances;
-      if (instances.length > 0) {
-        persistLog.debug("seed:start", { entity: entity.name, count: instances.length });
-        const results = await Promise.all(
-          instances.map(async (instance) => {
-            try {
-              const result = await this.persistence.create(entity.name, instance);
-              persistLog.debug("seed:instance", { entity: entity.name, id: instance.id ?? "no-id" });
-              return result;
-            } catch (err) {
-              persistLog.error("seed:instance-error", {
-                entity: entity.name,
-                id: instance.id,
-                error: err instanceof Error ? err : String(err)
-              });
-              return null;
-            }
-          })
-        );
-        const successCount = results.filter((r) => r !== null).length;
-        persistLog.debug("seed:done", { entity: entity.name, success: successCount, total: instances.length });
-      }
-    } else if (this.config.mode === "mock" && this.persistence instanceof MockPersistenceAdapter) {
-      if (this.config.debug) {
-        persistLog.debug("mock:generate", { entity: entity?.name });
-      }
-      if (entity?.name && entity.fields) {
-        const fields = entity.fields.filter(
-          (f) => typeof f.name === "string" && f.name.length > 0
-        );
-        this.persistence.registerEntity({ name: entity.name, fields });
-        if (this.config.debug) {
-          persistLog.debug("mock:seeded", { entity: entity.name, count: this.persistence.count(entity.name) });
-        }
-      }
-    }
-    const auxiliaryEntities = orbital.auxiliaryEntities;
-    if (auxiliaryEntities !== void 0 && auxiliaryEntities.length > 0 && this.config.mode === "mock" && this.persistence instanceof MockPersistenceAdapter) {
-      for (const auxRef of auxiliaryEntities) {
-        if (typeof auxRef === "string" || isEntityCall(auxRef)) continue;
-        const auxEntity = auxRef;
-        if (!auxEntity.name || !auxEntity.fields) continue;
-        const auxFields = auxEntity.fields.filter(
-          (f) => typeof f.name === "string" && f.name.length > 0
-        );
-        this.persistence.registerEntity({ name: auxEntity.name, fields: auxFields });
-        if (this.config.debug) {
-          persistLog.debug("mock:seeded-auxiliary", {
-            entity: auxEntity.name,
-            count: this.persistence.count(auxEntity.name)
-          });
-        }
-      }
-    }
-    if (this.config.debug) {
-      registerLog.debug("register:orbital", {
-        name: orbital.name,
-        traitCount: (orbital.traits || []).length
-      });
-    }
-  }
-  /**
-   * Register a single orbital (sync wrapper for backward compatibility)
-   */
-  registerOrbital(orbital) {
-    this.registerOrbitalAsync(orbital).catch((err) => {
-      registerLog.error("register:failed", {
-        name: orbital.name,
-        error: err instanceof Error ? err : String(err)
-      });
-    });
-  }
-  /**
-   * Set up event listeners for cross-orbital communication
-   */
-  setupEventListeners() {
-    for (const cleanup of this.listenerCleanups) {
-      cleanup();
-    }
-    this.listenerCleanups = [];
-    for (const [orbitalName, registered] of this.orbitals) {
-      for (const trait of registered.traits) {
-        if (!trait.listens) continue;
-        for (const listener of trait.listens) {
-          const { bareEvent, matcher } = parseListenSource(listener, orbitalName);
-          const cleanup = this.eventBus.on(bareEvent, async (event) => {
-            if (!matcher(event.source)) return;
-            if (this.config.debug) {
-              xOrbitalLog.debug("listen:received", () => ({
-                receiverOrbital: orbitalName,
-                receiverTrait: trait.name,
-                event: listener.event,
-                sourceOrbital: event.source?.orbital ?? "?",
-                sourceTrait: event.source?.trait ?? "?"
-              }));
-            }
-            let mappedPayload = event.payload;
-            if (listener.payloadMapping && event.payload) {
-              mappedPayload = {};
-              for (const [key, expr] of Object.entries(
-                listener.payloadMapping
-              )) {
-                if (typeof expr === "string" && expr.startsWith("@payload.")) {
-                  const field = expr.slice("@payload.".length);
-                  mappedPayload[key] = event.payload[field];
-                } else {
-                  mappedPayload[key] = expr;
-                }
-              }
-            }
-            const raw = event.payload;
-            const mapped = mappedPayload;
-            const pickId = (field) => mapped?.[field] ?? raw?.[field];
-            const forwardedEntityId = pickId("entityId") ?? pickId("orbitalName");
-            await this.processOrbitalEvent(orbitalName, {
-              event: listener.triggers,
-              payload: mappedPayload,
-              entityId: forwardedEntityId
-            });
-          });
-          this.listenerCleanups.push(cleanup);
-        }
-      }
     }
+    return entityRef;
   }
   /**
-   * Set up scheduled ticks for all traits
+   * Resolve trait references.
    */
-  setupTicks() {
-    this.cleanupTicks();
-    for (const [orbitalName, registered] of this.orbitals) {
-      for (const trait of registered.traits || []) {
-        if (!trait.ticks || trait.ticks.length === 0) continue;
-        for (const tick of trait.ticks) {
-          this.registerTick(orbitalName, trait.name, tick, registered);
-        }
+  resolveTraits(traitRefs, imports) {
+    const errors = [];
+    const resolved = [];
+    for (const traitRef of traitRefs) {
+      const result = this.resolveTraitRef(traitRef, imports);
+      if (!result.success) {
+        errors.push(...result.errors);
+      } else {
+        resolved.push(result.data);
       }
     }
-    if (this.config.debug && this.tickBindings.length > 0) {
-      registerLog.debug("register:ticks", { count: this.tickBindings.length });
+    if (errors.length > 0) {
+      return { success: false, errors };
     }
+    return { success: true, data: resolved, warnings: [] };
   }
   /**
-   * Register a single tick
+   * Resolve a single trait reference.
    */
-  registerTick(orbitalName, traitName, tick, registered) {
-    let intervalMs;
-    if (typeof tick.interval === "number") {
-      intervalMs = tick.interval;
-    } else if (typeof tick.interval === "string") {
-      intervalMs = this.parseIntervalString(tick.interval);
-    } else {
-      intervalMs = 1e3;
+  resolveTraitRef(traitRef, imports) {
+    if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
+      return {
+        success: true,
+        data: {
+          trait: traitRef,
+          source: { type: "inline" }
+        },
+        warnings: []
+      };
     }
-    if (this.config.debug) {
-      registerLog.debug("register:tick", {
-        orbital: orbitalName,
-        trait: traitName,
-        tick: tick.name,
-        intervalMs
-      });
+    if (typeof traitRef !== "string" && "ref" in traitRef) {
+      const refObj = traitRef;
+      return this.resolveTraitRefString(
+        refObj.ref,
+        imports,
+        refObj.config,
+        refObj.linkedEntity,
+        refObj.name,
+        refObj.events,
+        refObj.listens
+      );
     }
-    const timerId = setInterval(async () => {
-      await this.executeTick(orbitalName, traitName, tick, registered);
-    }, intervalMs);
-    this.tickBindings.push({
-      orbitalName,
-      traitName,
-      tick,
-      timerId
-    });
+    if (typeof traitRef === "string") {
+      return this.resolveTraitRefString(traitRef, imports);
+    }
+    return {
+      success: false,
+      errors: [`Unknown trait reference format: ${JSON.stringify(traitRef)}`]
+    };
   }
   /**
-   * Parse interval string to milliseconds
-   * Supports: '5s', '1m', '1h', '30000' (ms)
+   * Resolve a trait reference string.
    */
-  parseIntervalString(interval) {
-    const match = interval.match(/^(\d+)(ms|s|m|h)?$/);
-    if (!match) {
-      registerLog.warn("register:tick-invalid-interval", { interval, defaultMs: 1e3 });
-      return 1e3;
-    }
-    const value = parseInt(match[1], 10);
-    const unit = match[2] || "ms";
-    switch (unit) {
-      case "ms":
-        return value;
-      case "s":
-        return value * 1e3;
-      case "m":
-        return value * 60 * 1e3;
-      case "h":
-        return value * 60 * 60 * 1e3;
-      default:
-        return value;
+  resolveTraitRefString(ref, imports, config, linkedEntity, overrideName, eventRenames, listensOverride) {
+    const parsed = parseImportedTraitRef(ref);
+    if (parsed) {
+      const imported = imports.orbitals.get(parsed.alias);
+      if (!imported) {
+        return {
+          success: false,
+          errors: [
+            `Unknown import alias in trait reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
+          ]
+        };
+      }
+      const trait = this.findTraitInOrbital(imported.orbital, parsed.traitName);
+      if (!trait) {
+        return {
+          success: false,
+          errors: [
+            `Trait "${parsed.traitName}" not found in imported orbital "${parsed.alias}". Available traits: ${this.listTraitsInOrbital(imported.orbital).join(", ") || "none"}`
+          ]
+        };
+      }
+      const baseTrait = overrideName ? { ...trait, name: overrideName } : trait;
+      const reboundTrait = applyLinkedEntityRename(baseTrait, linkedEntity);
+      const renamedTrait = applyEventRenames(reboundTrait, eventRenames);
+      const finalTrait = listensOverride !== void 0 ? { ...renamedTrait, listens: listensOverride } : renamedTrait;
+      if (listensOverride !== void 0) {
+        refResolverLog.info("listens-override:imported", {
+          trait: finalTrait.name,
+          ref,
+          atomListens: trait.listens?.length ?? 0,
+          callSiteListens: listensOverride.length
+        });
+      }
+      return {
+        success: true,
+        data: {
+          trait: finalTrait,
+          source: { type: "imported", alias: parsed.alias, traitName: parsed.traitName },
+          config,
+          linkedEntity
+        },
+        warnings: []
+      };
+    }
+    const localTrait = this.localTraits.get(ref);
+    if (localTrait) {
+      const baseLocal = overrideName ? { ...localTrait, name: overrideName } : localTrait;
+      const reboundLocal = applyLinkedEntityRename(baseLocal, linkedEntity);
+      const renamedLocalTrait = applyEventRenames(reboundLocal, eventRenames);
+      const finalLocalTrait = listensOverride !== void 0 ? { ...renamedLocalTrait, listens: listensOverride } : renamedLocalTrait;
+      if (listensOverride !== void 0) {
+        refResolverLog.info("listens-override:local", {
+          trait: finalLocalTrait.name,
+          ref,
+          atomListens: localTrait.listens?.length ?? 0,
+          callSiteListens: listensOverride.length
+        });
+      }
+      return {
+        success: true,
+        data: {
+          trait: finalLocalTrait,
+          source: { type: "local", name: ref },
+          config,
+          linkedEntity
+        },
+        warnings: []
+      };
     }
+    return {
+      success: false,
+      errors: [
+        `Trait "${ref}" not found. For imported traits, use format "Alias.traits.TraitName". Local traits available: ${Array.from(this.localTraits.keys()).join(", ") || "none"}`
+      ]
+    };
   }
   /**
-   * Execute a tick for all applicable entities
+   * Find a trait in an orbital by name.
    */
-  async executeTick(orbitalName, traitName, tick, registered) {
-    const entityType = registered.entity.name;
-    const emittedEvents = [];
-    try {
-      let entities = await this.persistence.list(entityType);
-      if (tick.appliesTo && tick.appliesTo.length > 0) {
-        const appliesToSet = new Set(tick.appliesTo);
-        entities = entities.filter((e) => appliesToSet.has(e.id));
-      }
-      if (this.config.debug && entities.length > 0) {
-        effectLog2.debug("tick:processing", () => ({
-          orbital: orbitalName,
-          trait: traitName,
-          tick: tick.name,
-          entityCount: entities.length
-        }));
-      }
-      for (const entity of entities) {
-        if (tick.guard) {
-          try {
-            const ctx = createContextFromBindings({
-              entity,
-              payload: {},
-              state: registered.manager.getState(traitName)?.currentState || "unknown"
-            }, false, this.config.contextExtensions);
-            const guardPasses = evaluateGuard(
-              tick.guard,
-              ctx
-            );
-            if (!guardPasses) {
-              if (this.config.debug) {
-                effectLog2.debug("tick:guard-failed", () => ({
-                  tick: tick.name,
-                  entityId: typeof entity.id === "string" ? entity.id : void 0
-                }));
-              }
-              continue;
-            }
-          } catch (error) {
-            effectLog2.error("tick:guard-error", {
-              tick: tick.name,
-              entityId: typeof entity.id === "string" ? entity.id : void 0,
-              error: error instanceof Error ? error : String(error)
-            });
-            continue;
-          }
-        }
-        if (tick.effects && tick.effects.length > 0) {
-          const fetchedData = {};
-          const clientEffects = [];
-          const tickEffectResults = [];
-          await this.executeEffects(
-            registered,
-            traitName,
-            tick.effects,
-            {},
-            // No payload for ticks
-            entity,
-            entity.id,
-            emittedEvents,
-            fetchedData,
-            clientEffects,
-            tickEffectResults
-          );
-          if (this.config.debug) {
-            effectLog2.debug("tick:effects-executed", () => ({
-              tick: tick.name,
-              entityId: typeof entity.id === "string" ? entity.id : void 0
-            }));
-          }
+  findTraitInOrbital(orbital, traitName) {
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
+        if (traitRef.name === traitName) {
+          return traitRef;
         }
       }
-    } catch (error) {
-      effectLog2.error("tick:execute-error", {
-        tick: tick.name,
-        error: error instanceof Error ? error : String(error)
-      });
+      if (typeof traitRef !== "string" && "ref" in traitRef) {
+        const refObj = traitRef;
+        if (refObj.ref === traitName || refObj.name === traitName) ;
+      }
     }
+    return null;
   }
   /**
-   * Clean up all active ticks
+   * List trait names in an orbital.
    */
-  cleanupTicks() {
-    for (const binding of this.tickBindings) {
-      clearInterval(binding.timerId);
+  listTraitsInOrbital(orbital) {
+    const names = [];
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
+        names.push(traitRef.name);
+      }
     }
-    this.tickBindings = [];
+    return names;
   }
   /**
-   * Unregister all orbitals and clean up
+   * Resolve page references.
    */
-  unregisterAll() {
-    this.cleanupTicks();
-    for (const cleanup of this.listenerCleanups) {
-      cleanup();
-    }
-    this.listenerCleanups = [];
-    this.orbitals.clear();
-    this.eventBus.clear();
-    if (this.persistence instanceof MockPersistenceAdapter) {
-      this.persistence.clearAll();
+  resolvePages(pageRefs, imports) {
+    const errors = [];
+    const resolved = [];
+    for (const pageRef of pageRefs) {
+      const result = this.resolvePageRef(pageRef, imports);
+      if (!result.success) {
+        errors.push(...result.errors);
+      } else {
+        resolved.push(result.data);
+      }
     }
-    if (this.osHandlers) {
-      this.osHandlers.cleanup();
-      this.osHandlers = null;
+    if (errors.length > 0) {
+      return { success: false, errors };
     }
+    return { success: true, data: resolved, warnings: [] };
   }
   /**
-   * Reset the mock persistence store to a clean-slate re-seed without
-   * unregistering orbitals. Exposed for verifier tools that want to
-   * start each test with deterministic seeded rows, not the residue of
-   * the previous walk's persist-creates. No-op when the persistence
-   * layer is not MockPersistenceAdapter.
+   * Resolve a single page reference.
    */
-  resetMockPersistence() {
-    if (!(this.persistence instanceof MockPersistenceAdapter)) return;
-    busLog.debug("mock:reset:enter", {
-      orbitalCount: this.orbitals.size,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    this.persistence.clearAll();
-    for (const registered of this.orbitals.values()) {
-      const entity = registered.entity;
-      if (entity?.name && entity.fields) {
-        const fields = entity.fields.filter(
-          (f) => typeof f.name === "string" && f.name.length > 0
-        );
-        this.persistence.registerEntity({ name: entity.name, fields });
-      }
+  resolvePageRef(pageRef, imports) {
+    if (!isPageReference(pageRef)) {
+      return {
+        success: true,
+        data: {
+          page: pageRef,
+          source: { type: "inline" },
+          pathOverridden: false
+        },
+        warnings: []
+      };
     }
+    if (isPageReferenceString(pageRef)) {
+      return this.resolvePageRefString(pageRef, imports);
+    }
+    if (isPageReferenceObject(pageRef)) {
+      return this.resolvePageRefObject(pageRef, imports);
+    }
+    return {
+      success: false,
+      errors: [`Unknown page reference format: ${JSON.stringify(pageRef)}`]
+    };
   }
-  // ==========================================================================
-  // Event Processing
-  // ==========================================================================
   /**
-   * Process an event for an orbital
+   * Resolve a page reference string.
    */
-  async processOrbitalEvent(orbitalName, request) {
-    const registered = this.orbitals.get(orbitalName);
-    if (!registered) {
+  resolvePageRefString(ref, imports) {
+    const parsed = parsePageRef(ref);
+    if (!parsed) {
       return {
         success: false,
-        transitioned: false,
-        states: {},
-        emittedEvents: [],
-        error: `Orbital not found: ${orbitalName}`
+        errors: [`Invalid page reference format: ${ref}. Expected "Alias.pages.PageName"`]
       };
     }
-    const payloadRow = request.payload?.["row"];
-    const payloadRowAsPayload = payloadRow !== null && typeof payloadRow === "object" && !Array.isArray(payloadRow) ? payloadRow : void 0;
-    const payloadRowId = payloadRowAsPayload?.["id"];
-    renderLog2.debug("processOrbitalEvent:enter", {
-      orbital: orbitalName,
-      event: request.event,
-      hasPayloadRow: payloadRowAsPayload !== void 0,
-      payloadRowId: typeof payloadRowId === "string" || typeof payloadRowId === "number" ? payloadRowId : void 0,
-      entityId: request.entityId
-    });
-    busLog.debug("bus:incoming", () => ({
-      orbital: orbitalName,
-      event: request.event,
-      payload: JSON.stringify(request.payload ?? null),
-      entityId: request.entityId,
-      traitStates: JSON.stringify(
-        Array.from(registered.manager.getAllStates().entries()).map(([traitName, state]) => ({
-          traitName,
-          currentState: state.currentState
-        }))
-      )
-    }));
-    xOrbitalLog.info("processOrbitalEvent:enter", () => ({
-      orbital: orbitalName,
-      event: request.event,
-      traitsInOrbital: registered.traits.map((t) => t.name).join(","),
-      payloadActiveTraits: JSON.stringify(
-        request.payload?.["_activeTraits"] ?? null
-      )
-    }));
-    const { event, payload, entityId, user } = request;
-    const validationFailures = [];
-    for (const trait of registered.traits) {
-      const eventSchema = trait.stateMachine?.events?.find((e) => e.key === event);
-      if (eventSchema?.payloadSchema && eventSchema.payloadSchema.length > 0) {
-        validationFailures.push(
-          ...validateEventPayload(event, payload, eventSchema.payloadSchema)
-        );
-      }
-    }
-    if (validationFailures.length > 0) {
+    const imported = imports.orbitals.get(parsed.alias);
+    if (!imported) {
       return {
         success: false,
-        transitioned: false,
-        states: {},
-        emittedEvents: [],
-        error: formatPayloadValidationError(validationFailures)
+        errors: [
+          `Unknown import alias in page reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
+        ]
       };
     }
-    const emittedEvents = [];
-    const fetchedData = {};
-    const clientEffects = [];
-    const clientEffectsByTrait = [];
-    const effectResults = [];
-    const activeTraits = payload?._activeTraits;
-    const cleanPayload = payload ? { ...payload } : void 0;
-    if (cleanPayload) {
-      delete cleanPayload._activeTraits;
-    }
-    let entityData = {};
-    if (entityId) {
-      const stored = await this.persistence.getById(
-        registered.entity.name,
-        entityId
-      );
-      if (stored) {
-        entityData = stored;
-      }
-    }
-    const entityByTrait = {};
-    for (const [name, fields] of registered.traitFieldStates) {
-      if (fields && Object.keys(fields).length > 0) {
-        entityByTrait[name] = fields;
-      }
-    }
-    const results = registered.manager.sendEvent(
-      event,
-      cleanPayload,
-      entityData,
-      entityByTrait
-    );
-    const filteredResults = activeTraits && activeTraits.length > 0 ? results.filter(({ traitName }) => activeTraits.includes(traitName)) : results;
-    if (this.config.debug && activeTraits) {
-      busLog.debug("dispatch:filter-traits", () => ({
-        total: results.length,
-        active: filteredResults.length,
-        activeTraits: activeTraits.join(",")
-      }));
-    }
-    for (const { traitName, result } of filteredResults) {
-      if (result.effects.length > 0) {
-        await this.executeEffects(
-          registered,
-          traitName,
-          result.effects,
-          cleanPayload,
-          entityData,
-          entityId,
-          emittedEvents,
-          fetchedData,
-          clientEffects,
-          effectResults,
-          user,
-          clientEffectsByTrait
-        );
-      }
-    }
-    const states = {};
-    for (const [name, state] of registered.manager.getAllStates()) {
-      states[name] = state.currentState;
+    const page = this.findPageInOrbital(imported.orbital, parsed.pageName);
+    if (!page) {
+      return {
+        success: false,
+        errors: [
+          `Page "${parsed.pageName}" not found in imported orbital "${parsed.alias}". Available pages: ${this.listPagesInOrbital(imported.orbital).join(", ") || "none"}`
+        ]
+      };
     }
-    const response = {
+    return {
       success: true,
-      transitioned: results.length > 0,
-      states,
-      emittedEvents
+      data: {
+        page,
+        source: { type: "imported", alias: parsed.alias, pageName: parsed.pageName },
+        pathOverridden: false
+      },
+      warnings: []
     };
-    if (clientEffects.length > 0) {
-      response.clientEffects = clientEffects;
-    }
-    if (clientEffectsByTrait.length > 0) {
-      response.clientEffectsByTrait = clientEffectsByTrait;
+  }
+  /**
+   * Resolve a page reference object with optional path override.
+   */
+  resolvePageRefObject(refObj, imports) {
+    const baseResult = this.resolvePageRefString(refObj.ref, imports);
+    if (!baseResult.success) {
+      return baseResult;
     }
-    if (effectResults.length > 0) {
-      response.effectResults = effectResults;
+    const resolved = baseResult.data;
+    if (refObj.path) {
+      const originalPath = resolved.page.path;
+      resolved.page = {
+        ...resolved.page,
+        path: refObj.path
+      };
+      resolved.pathOverridden = true;
+      resolved.originalPath = originalPath;
     }
-    return response;
+    return {
+      success: true,
+      data: resolved,
+      warnings: baseResult.warnings
+    };
   }
   /**
-   * Execute effects from a transition
+   * Find a page in an orbital by name.
    */
-  async executeEffects(registered, traitName, effects, payload, entityData, entityId, emittedEvents, fetchedData, clientEffects, effectResults, user, clientEffectsByTrait) {
-    const entityType = registered.entity.name;
-    const pushClientEffect = (effect) => {
-      clientEffects.push(effect);
-      clientEffectsByTrait?.push({ traitName, effect });
-    };
-    let bindingsRef = null;
-    let contextRef = null;
-    const handlers = {
-      emit: (event, eventPayload, source) => {
-        if (this.config.debug) {
-          busLog.debug("emit:dispatch", () => ({
-            event,
-            payloadJson: JSON.stringify(eventPayload ?? null),
-            sourceOrbital: source?.orbital,
-            sourceTrait: source?.trait
-          }));
-        }
-        const stamp = source ?? {
-          orbital: registered.schema.name,
-          trait: traitName
-        };
-        this.eventBus.emit(event, eventPayload, stamp);
-        emittedEvents.push({ event, payload: eventPayload, source: stamp });
-        effectLog2.debug("emit:push", {
-          event,
-          cumulativeEmittedCount: emittedEvents.length,
-          sourceTrait: stamp.trait,
-          sourceOrbital: stamp.orbital
-        });
-        xOrbitalLog.info("emit:server", {
-          event,
-          sourceOrbital: stamp.orbital,
-          sourceTrait: stamp.trait,
-          dispatchOrbital: registered.schema.name
-        });
-      },
-      set: async (targetId, field, value) => {
-        let fieldState = registered.traitFieldStates.get(traitName);
-        if (!fieldState) {
-          fieldState = {};
-          registered.traitFieldStates.set(traitName, fieldState);
-        }
-        fieldState[field] = value;
-        effectResults.push({
-          effect: "set",
-          entityType,
-          data: { id: targetId || entityId || "", field, value },
-          success: true
-        });
-      },
-      persist: async (action, targetEntityType, data) => {
-        if (action === "batch") {
-          const operations = data?.operations;
-          if (!Array.isArray(operations) || operations.length === 0) {
-            effectResults.push({
-              effect: "persist",
-              action: "batch",
-              success: false,
-              error: "Batch requires a non-empty operations array"
-            });
-            return;
-          }
-          const batchResults = [];
-          const completed = [];
-          let batchFailed = false;
-          let batchError = "";
-          for (const op of operations) {
-            if (!Array.isArray(op) || op.length < 2) {
-              batchFailed = true;
-              batchError = `Invalid batch operation format: ${JSON.stringify(op)}`;
-              break;
-            }
-            const [opAction, opEntityType, ...opRest] = op;
-            try {
-              switch (opAction) {
-                case "create": {
-                  const createData = opRest[0] || {};
-                  const { id: newId } = await this.persistence.create(opEntityType, createData);
-                  batchResults.push({ action: "create", entityType: opEntityType, id: newId, ...createData });
-                  completed.push({ action: "create", entityType: opEntityType, id: newId });
-                  break;
-                }
-                case "update": {
-                  const updateId = opRest[0];
-                  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 });
-                  completed.push({ action: "update", entityType: opEntityType, id: updateId });
-                  break;
-                }
-                case "delete": {
-                  const deleteId = opRest[0];
-                  await this.persistence.delete(opEntityType, deleteId);
-                  batchResults.push({ action: "delete", entityType: opEntityType, id: deleteId, deleted: true });
-                  completed.push({ action: "delete", entityType: opEntityType, id: deleteId });
-                  break;
-                }
-                default:
-                  batchFailed = true;
-                  batchError = `Unknown batch operation action: ${opAction}`;
-                  break;
-              }
-            } catch (err) {
-              batchFailed = true;
-              batchError = `Batch operation [${opAction}, ${opEntityType}] failed: ${err instanceof Error ? err.message : String(err)}`;
-              break;
-            }
-            if (batchFailed) break;
-          }
-          effectResults.push({
-            effect: "persist",
-            action: "batch",
-            data: {
-              operations: batchResults,
-              completedCount: completed.length,
-              totalCount: operations.length
-            },
-            success: !batchFailed,
-            ...batchFailed ? { error: batchError } : {}
-          });
-          return;
-        }
-        const type = targetEntityType || entityType;
-        let resultData;
-        const sizeBefore = (await this.persistence.list(type)).length;
-        try {
-          if (action === "create" || action === "update") {
-            this.validateRelationCardinality(type, data || {});
-          }
-          switch (action) {
-            case "create": {
-              const { id } = await this.persistence.create(type, data || {});
-              resultData = { id, ...data || {} };
-              break;
-            }
-            case "update":
-              if (data?.id || entityId) {
-                const updateId = data?.id || entityId;
-                await this.persistence.update(type, updateId, data || {});
-                const updated = await this.persistence.getById(type, updateId);
-                resultData = updated || { id: updateId, ...data || {} };
-              }
-              break;
-            case "delete": {
-              const directId = typeof data === "string" ? data : void 0;
-              const nestedId = typeof data === "object" && data !== null ? data.id : void 0;
-              const deleteId = directId ?? nestedId ?? entityId;
-              if (deleteId) {
-                await this.enforceOnDeleteRules(type, deleteId);
-                await this.persistence.delete(type, deleteId);
-                resultData = { id: deleteId, deleted: true };
-              }
-              break;
-            }
-          }
-          const sizeAfter = (await this.persistence.list(type)).length;
-          effectLog2.debug("persist:store-mutate", {
-            action,
-            entityType: type,
-            resultId: resultData?.id,
-            sizeBefore,
-            sizeAfter,
-            delta: sizeAfter - sizeBefore
-          });
-          effectResults.push({
-            effect: "persist",
-            action,
-            entityType: type,
-            data: resultData,
-            success: true
-          });
-        } catch (err) {
-          effectLog2.error("persist:store-mutate-error", {
-            action,
-            entityType: type,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          effectResults.push({
-            effect: "persist",
-            action,
-            entityType: type,
-            success: false,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-      },
-      callService: async (service, action, params) => {
-        try {
-          let result = null;
-          if (this.config.effectHandlers?.callService) {
-            result = await this.config.effectHandlers.callService(
-              service,
-              action,
-              params
-            );
-          } else if (this.config.mode === "mock") {
-            const mockId = `mock_${service}_${action}_${Math.random().toString(36).slice(2, 10)}`;
-            const paramsEcho = {};
-            if (params) {
-              for (const [k, v] of Object.entries(params)) {
-                if (v !== void 0 && (typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v === null || v instanceof Date)) {
-                  paramsEcho[k] = v;
-                }
-              }
-            }
-            result = {
-              id: mockId,
-              clientSecret: `secret_${mockId}`,
-              success: true,
-              status: "succeeded",
-              ...paramsEcho
-            };
-          } else {
-            effectLog2.warn("call-service:not-configured", { service, action });
-          }
-          effectResults.push({
-            effect: "call-service",
-            action: `${service}.${action}`,
-            data: result,
-            success: true
-          });
-          return result;
-        } catch (err) {
-          effectResults.push({
-            effect: "call-service",
-            action: `${service}.${action}`,
-            success: false,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          return null;
-        }
-      },
-      fetch: async (fetchEntityType, options) => {
-        try {
-          xOrbitalLog.info("fetch:enter", () => ({
-            entityType: fetchEntityType,
-            hasOptions: options !== void 0 && options !== null,
-            optionsKeys: options ? Object.keys(options).join(",") : "",
-            filterType: typeof options?.filter,
-            filterIsArray: Array.isArray(options?.filter),
-            filterJson: JSON.stringify(options?.filter ?? null).slice(0, 300),
-            payloadJson: JSON.stringify(bindingsRef?.payload ?? null).slice(0, 300)
-          }));
-          let result = null;
-          let total = 0;
-          if (options?.id) {
-            const entity = await this.persistence.getById(fetchEntityType, options.id);
-            if (entity) {
-              if (options?.include && options.include.length > 0) {
-                await this.populateRelations([entity], fetchEntityType, options.include);
-              }
-              fetchedData[fetchEntityType] = [entity];
-              result = entity;
-              total = 1;
-            }
-          } else {
-            let entities = await this.persistence.list(fetchEntityType);
-            if (options?.filter !== void 0 && options.filter !== null) {
-              const predicate = options.filter;
-              entities = entities.filter((entity) => {
-                const ctx = createContextFromBindings(
-                  { entity, payload: bindingsRef?.payload, current: entity },
-                  false
-                );
-                try {
-                  return Boolean(evaluate(predicate, ctx));
-                } catch (err) {
-                  effectLog2.error("fetch:filter-eval-error", {
-                    entityType: fetchEntityType,
-                    error: err instanceof Error ? err : String(err)
-                  });
-                  return false;
-                }
-              });
-            }
-            total = entities.length;
-            if (options?.offset && options.offset > 0) {
-              entities = entities.slice(options.offset);
-            }
-            if (options?.limit && options.limit > 0) {
-              entities = entities.slice(0, options.limit);
-            }
-            if (options?.include && options.include.length > 0) {
-              await this.populateRelations(entities, fetchEntityType, options.include);
-            }
-            fetchedData[fetchEntityType] = entities;
-            result = entities;
-          }
-          return result === null ? null : { rows: result, total };
-        } catch (error) {
-          effectLog2.error("fetch:error", {
-            entityType: fetchEntityType,
-            error: error instanceof Error ? error : String(error)
-          });
-          return null;
-        }
-      },
-      // Resource operators: ref, deref, swap, watch, atomic
-      ref: async (refEntityType, options) => {
-        try {
-          return await handlers.fetch(refEntityType, options);
-        } catch (error) {
-          effectLog2.error("ref:error", {
-            entityType: refEntityType,
-            error: error instanceof Error ? error : String(error)
-          });
-          return null;
-        }
-      },
-      deref: async (derefEntityType, options) => {
-        try {
-          let result = null;
-          let total = 0;
-          if (options?.id) {
-            const entity = await this.persistence.getById(derefEntityType, options.id);
-            if (entity) {
-              fetchedData[derefEntityType] = [entity];
-              result = entity;
-              total = 1;
-            }
-          } else {
-            const entities = await this.persistence.list(derefEntityType);
-            fetchedData[derefEntityType] = entities;
-            result = entities;
-            total = entities.length;
-          }
-          effectResults.push({
-            effect: "deref",
-            entityType: derefEntityType,
-            success: true
-          });
-          return result === null ? null : { rows: result, total };
-        } catch (error) {
-          effectResults.push({
-            effect: "deref",
-            entityType: derefEntityType,
-            success: false,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          return null;
-        }
-      },
-      swap: async (swapEntityType, swapEntityId, transform) => {
-        try {
-          const current = await this.persistence.getById(swapEntityType, swapEntityId);
-          if (!current) {
-            effectResults.push({
-              effect: "swap",
-              entityType: swapEntityType,
-              success: false,
-              error: `Entity ${swapEntityType}/${swapEntityId} not found`
-            });
-            return null;
-          }
-          const ctx = createContextFromBindings({
-            current,
-            entity: entityData,
-            payload
-          }, false, this.config.contextExtensions);
-          let newData;
-          if (Array.isArray(transform)) {
-            const result = evaluate(
-              transform,
-              ctx
-            );
-            if (result && typeof result === "object" && !Array.isArray(result)) {
-              newData = result;
-            } else {
-              newData = current;
-            }
-          } else if (typeof transform === "object" && transform !== null) {
-            newData = { ...current, ...transform };
-          } else {
-            effectResults.push({
-              effect: "swap",
-              entityType: swapEntityType,
-              success: false,
-              error: "swap! transform must be an S-expression or object"
-            });
-            return null;
-          }
-          await this.persistence.update(swapEntityType, swapEntityId, newData);
-          effectResults.push({
-            effect: "swap",
-            entityType: swapEntityType,
-            data: { id: swapEntityId, ...newData },
-            success: true
-          });
-          return newData;
-        } catch (error) {
-          effectResults.push({
-            effect: "swap",
-            entityType: swapEntityType,
-            success: false,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          return null;
-        }
-      },
-      watch: (_watchEntityType, _watchOptions) => {
-        if (this.config.debug) {
-          effectLog2.debug("watch:noop-server", { entityType: _watchEntityType });
-        }
-      },
-      atomic: async (atomicEffects) => {
-        let atomicFailed = false;
-        let atomicError = "";
-        const atomicExecutor = new EffectExecutor({
-          handlers,
-          bindings: bindingsRef ?? {},
-          context: contextRef ?? { traitName, orbitalName: registered.schema.name, state: "unknown", transition: "unknown" },
-          debug: this.config.debug,
-          contextExtensions: this.config.contextExtensions
-        });
-        for (const innerEffect of atomicEffects) {
-          if (atomicFailed) break;
-          try {
-            await atomicExecutor.execute(innerEffect);
-          } catch (err) {
-            atomicFailed = true;
-            atomicError = err instanceof Error ? err.message : String(err);
-          }
-        }
-        if (atomicFailed) {
-          effectResults.push({
-            effect: "atomic",
-            success: false,
-            error: `Atomic block failed: ${atomicError}`
-          });
-        } else {
-          effectResults.push({
-            effect: "atomic",
-            success: true,
-            data: { innerCount: atomicEffects.length }
-          });
-        }
-      },
-      // Client-side effects - collect for forwarding to client
-      renderUI: (slot, pattern, props, priority) => {
-        const patternNode = pattern !== null && typeof pattern === "object" && !Array.isArray(pattern) ? pattern : null;
-        const patternEntity = patternNode?.entity;
-        const entityRow = patternEntity !== null && typeof patternEntity === "object" && !Array.isArray(patternEntity) ? patternEntity : null;
-        const patternTypeRaw = patternNode?.["type"];
-        renderLog2.debug("renderUI:push", {
-          trait: traitName,
-          slot,
-          patternType: typeof patternTypeRaw === "string" ? patternTypeRaw : void 0,
-          entityRowId: typeof entityRow?.id === "string" ? entityRow.id : void 0,
-          entityIsObject: entityRow !== null
-        });
-        pushClientEffect(["render-ui", slot, pattern, props, priority]);
-      },
-      navigate: (path, params) => {
-        pushClientEffect(["navigate", path, params]);
-      },
-      notify: (message, type) => {
-        if (this.config.debug) {
-          effectLog2.info("notify", { type, message });
-        }
-        pushClientEffect(["notify", message, { type }]);
-      },
-      log: (message, level) => {
-        if (level === "error") {
-          dynamicLog.error(message);
-        } else if (level === "warn") {
-          dynamicLog.warn(message);
-        } else {
-          dynamicLog.debug(message);
+  findPageInOrbital(orbital, pageName) {
+    const pages = orbital.pages;
+    if (!pages) return null;
+    for (const pageRef of pages) {
+      if (typeof pageRef !== "string" && !("ref" in pageRef)) {
+        const page = pageRef;
+        if (page.name === pageName) {
+          return { ...page };
         }
-      },
-      // Allow custom handlers to override
-      ...this.config.effectHandlers
-    };
-    const state = registered.manager.getState(traitName);
-    const bindings = {
-      entity: entityData,
-      payload,
-      state: state?.currentState || "unknown",
-      user
-      // @user bindings from Firebase auth
-    };
-    const traitDef = registered.traits.find((t) => t.name === traitName);
-    const declaredDefaults = collectDeclaredConfigDefaults(traitDef);
-    const callSiteOverride = registered.configByTrait.get(traitName);
-    if (declaredDefaults || callSiteOverride) {
-      bindings.config = { ...declaredDefaults ?? {}, ...callSiteOverride ?? {} };
-    }
-    const traitFieldState = registered.traitFieldStates.get(traitName);
-    if (traitFieldState) {
-      bindings.entity = traitFieldState;
-    }
-    if (entityType) {
-      bindings[entityType] = bindings.entity ?? entityData;
-    }
-    bindingsRef = bindings;
-    const context = {
-      traitName,
-      orbitalName: registered.schema.name,
-      state: state?.currentState || "unknown",
-      transition: "unknown",
-      entityId
-    };
-    contextRef = context;
-    const executor = new EffectExecutor({
-      handlers,
-      bindings,
-      context,
-      debug: this.config.debug,
-      contextExtensions: this.config.contextExtensions
-    });
-    await executor.executeAll(effects);
+      }
+    }
+    return null;
   }
-  // ==========================================================================
-  // Relation Population
-  // ==========================================================================
   /**
-   * Populate relation fields on entities
-   *
-   * For each field in `include`, find the relation field configuration and
-   * fetch the related entity, attaching it to the parent entity.
-   *
-   * @param entities - Entities to populate
-   * @param entityType - Entity type name
-   * @param include - Relation field names to populate
+   * List page names in an orbital.
    */
+  listPagesInOrbital(orbital) {
+    const pages = orbital.pages;
+    if (!pages) return [];
+    const names = [];
+    for (const pageRef of pages) {
+      if (typeof pageRef !== "string" && !("ref" in pageRef)) {
+        names.push(pageRef.name);
+      }
+    }
+    return names;
+  }
   /**
-   * Validate that relation field values match their declared cardinality.
-   * Called before create/update to ensure data integrity.
+   * Add local traits for resolution.
    */
-  validateRelationCardinality(entityType, data) {
-    for (const [, registered] of this.orbitals) {
-      if (registered.entity.name !== entityType) continue;
-      for (const field of registered.entity.fields ?? []) {
-        if (field.type !== "relation") continue;
-        if (field.name === void 0) continue;
-        const fieldName = field.name;
-        const value = data[fieldName];
-        if (value === void 0 || value === null) continue;
-        const cardinality = field.relation?.cardinality || "one";
-        if (cardinality === "one" || cardinality === "many-to-one") {
-          if (Array.isArray(value)) {
-            throw new Error(
-              `Cardinality violation: ${entityType}.${fieldName} has cardinality '${cardinality}' but received an array. Expected a single string ID.`
-            );
-          }
-        } else if (cardinality === "many" || cardinality === "many-to-many" || cardinality === "one-to-many") {
-          if (typeof value === "string") {
-            data[fieldName] = [value];
-          } else if (Array.isArray(value)) {
-            const nonStrings = value.filter((v) => typeof v !== "string");
-            if (nonStrings.length > 0) {
-              throw new Error(
-                `Cardinality violation: ${entityType}.${fieldName} has cardinality '${cardinality}' but array contains non-string values.`
-              );
-            }
-          }
-        }
-      }
-      break;
+  addLocalTraits(traits) {
+    for (const trait of traits) {
+      this.localTraits.set(trait.name, trait);
+    }
+  }
+  /**
+   * Clear loader cache.
+   */
+  clearCache() {
+    this.loader?.clearCache();
+  }
+};
+async function resolveSchema(schema, options) {
+  const resolver = new ReferenceResolver(options);
+  const errors = [];
+  const warnings = [];
+  const resolved = [];
+  for (const orbital of schema.orbitals) {
+    const inlineTraits = orbital.traits.filter(
+      (t) => typeof t !== "string" && "stateMachine" in t
+    );
+    resolver.addLocalTraits(inlineTraits);
+  }
+  for (const orbital of schema.orbitals) {
+    const result = await resolver.resolve(orbital);
+    if (!result.success) {
+      errors.push(`Orbital "${orbital.name}": ${result.errors.join(", ")}`);
+    } else {
+      resolved.push(result.data);
+      warnings.push(...result.warnings.map((w) => `Orbital "${orbital.name}": ${w}`));
     }
   }
-  /**
-   * Enforce onDelete rules for relation fields pointing to the entity being deleted.
-   * Scans all registered entities for relation fields targeting the given entity type,
-   * finds records referencing the ID being deleted, and applies cascade/nullify/restrict.
-   */
-  async enforceOnDeleteRules(entityType, deletedId) {
-    for (const [, registered] of this.orbitals) {
-      const entity = registered.entity;
-      const fields = entity.fields ?? [];
-      for (const field of fields) {
-        if (field.type !== "relation") continue;
-        if (field.relation?.entity !== entityType) continue;
-        if (field.name === void 0) continue;
-        const fieldName = field.name;
-        const onDelete = field.relation.onDelete || "restrict";
-        const referringEntityType = entity.name;
-        const allRecords = await this.persistence.list(referringEntityType);
-        const affectedRecords = allRecords.filter((record) => {
-          const fkValue = record[fieldName];
-          if (typeof fkValue === "string") return fkValue === deletedId;
-          if (Array.isArray(fkValue)) return fkValue.includes(deletedId);
-          return false;
-        });
-        if (affectedRecords.length === 0) continue;
-        switch (onDelete) {
-          case "restrict":
-            throw new Error(
-              `Cannot delete ${entityType} ${deletedId}: ${affectedRecords.length} ${referringEntityType} record(s) reference it via ${field.name}. Rule: restrict.`
-            );
-          case "cascade":
-            for (const record of affectedRecords) {
-              const recordId = record.id;
-              if (recordId) {
-                await this.persistence.delete(referringEntityType, recordId);
-              }
-            }
-            if (this.config.debug) {
-              persistLog.debug("cascade-delete", {
-                count: affectedRecords.length,
-                entityType: referringEntityType
-              });
-            }
-            break;
-          case "nullify":
-            for (const record of affectedRecords) {
-              const recordId = record.id;
-              if (recordId && field.name !== void 0) {
-                const fieldName2 = field.name;
-                const update = {};
-                const fkValue = record[fieldName2];
-                if (Array.isArray(fkValue)) {
-                  update[fieldName2] = fkValue.filter((id) => id !== deletedId);
-                } else {
-                  update[fieldName2] = null;
-                }
-                await this.persistence.update(referringEntityType, recordId, update);
-              }
-            }
-            if (this.config.debug) {
-              persistLog.debug("nullify", {
-                field: field.name,
-                count: affectedRecords.length,
-                entityType: referringEntityType
-              });
-            }
-            break;
-        }
-      }
-    }
+  if (errors.length > 0) {
+    return { success: false, errors };
   }
-  async populateRelations(entities, entityType, include, depth = 0, visited = /* @__PURE__ */ new Set()) {
-    const maxDepth = 2;
-    if (depth >= maxDepth || visited.has(entityType)) {
-      if (this.config.debug) {
-        persistLog.debug("populate:skip", {
-          entityType,
-          depth,
-          visited: visited.has(entityType)
-        });
-      }
-      return;
-    }
-    visited.add(entityType);
-    let entityFields;
-    for (const [, registered] of this.orbitals) {
-      if (registered.entity.name === entityType) {
-        entityFields = registered.entity.fields.filter(
-          (f) => typeof f.name === "string" && f.name.length > 0
-        );
-        break;
-      }
-    }
-    if (!entityFields) {
-      if (this.config.debug) {
-        persistLog.warn("populate:no-entity-def", { entityType });
-      }
-      return;
-    }
-    for (const includeField of include) {
-      const relationField = entityFields.find((f) => {
-        if (f.type !== "relation") return false;
-        return f.name === includeField || f.name === `${includeField}Id` || f.name.replace(/Id$/, "") === includeField;
-      });
-      if (!relationField?.relation?.entity) {
-        if (this.config.debug) {
-          persistLog.warn("populate:no-relation-field", { includeField, entityType });
-        }
-        continue;
-      }
-      const foreignKeyField = relationField.name;
-      const relatedEntityType = relationField.relation.entity;
-      const cardinality = relationField.relation.cardinality || "one";
-      const foreignKeyIds = /* @__PURE__ */ new Set();
-      for (const entity of entities) {
-        const fkValue = entity[foreignKeyField];
-        if (fkValue && typeof fkValue === "string") {
-          foreignKeyIds.add(fkValue);
-        } else if (Array.isArray(fkValue)) {
-          for (const id of fkValue) {
-            if (id && typeof id === "string") {
-              foreignKeyIds.add(id);
-            }
-          }
+  return { success: true, data: resolved, warnings };
+}
+
+// src/UsesIntegration.ts
+async function preprocessSchema(schema, options) {
+  const namespaceEvents = options.namespaceEvents ?? true;
+  const resolveResult = await resolveSchema(schema, options);
+  if (!resolveResult.success) {
+    return { success: false, errors: resolveResult.errors };
+  }
+  const resolved = resolveResult.data;
+  const warnings = resolveResult.warnings;
+  const preprocessedOrbitals = [];
+  const entitySharing = {};
+  const eventNamespaces = {};
+  for (const resolvedOrbital of resolved) {
+    const orbitalName = resolvedOrbital.name;
+    const persistence = resolvedOrbital.entitySource?.persistence ?? resolvedOrbital.entity.persistence ?? "persistent";
+    entitySharing[orbitalName] = {
+      entityName: resolvedOrbital.entity.name,
+      persistence,
+      isShared: persistence !== "runtime",
+      sourceAlias: resolvedOrbital.entitySource?.alias,
+      collectionName: resolvedOrbital.entity.collection
+    };
+    eventNamespaces[orbitalName] = {};
+    for (const resolvedTrait of resolvedOrbital.traits) {
+      const traitName = resolvedTrait.trait.name;
+      const namespace = {
+        emits: {},
+        listens: {}
+      };
+      if (namespaceEvents && resolvedTrait.source.type === "imported") {
+        const emits = resolvedTrait.trait.emits ?? [];
+        for (const emit of emits) {
+          const eventName = typeof emit === "string" ? emit : emit.event;
+          namespace.emits[eventName] = `${orbitalName}.${traitName}.${eventName}`;
         }
-      }
-      if (foreignKeyIds.size === 0) continue;
-      const relatedEntities = /* @__PURE__ */ new Map();
-      for (const fkId of foreignKeyIds) {
-        try {
-          const related = await this.persistence.getById(relatedEntityType, fkId);
-          if (related) {
-            relatedEntities.set(fkId, related);
-          }
-        } catch (error) {
-          if (this.config.debug) {
-            persistLog.error("populate:fetch-related-error", {
-              entityType: relatedEntityType,
-              error: error instanceof Error ? error : String(error)
-            });
-          }
+        const listens = resolvedTrait.trait.listens ?? [];
+        for (const listen of listens) {
+          namespace.listens[listen.event] = listen.event;
         }
       }
-      const populatedFieldName = includeField.endsWith("Id") ? includeField.slice(0, -2) : includeField;
-      const isSelfRef = relatedEntityType === entityType;
-      const hydrateClone = (id) => {
-        const related = relatedEntities.get(id);
-        if (!related) return void 0;
-        const copy = { ...related };
-        if (isSelfRef) copy[foreignKeyField] = [];
-        return copy;
-      };
-      for (const entity of entities) {
-        const fkValue = entity[foreignKeyField];
-        if (cardinality === "one" || cardinality === "many-to-one") {
-          if (typeof fkValue === "string" && relatedEntities.has(fkValue)) {
-            Object.defineProperty(entity, populatedFieldName, {
-              value: hydrateClone(fkValue),
-              writable: true,
-              enumerable: true,
-              configurable: true
-            });
-          }
-        } else {
-          if (Array.isArray(fkValue)) {
-            const fkIds = fkValue.filter((id) => typeof id === "string");
-            Object.defineProperty(entity, populatedFieldName, {
-              value: fkIds.map(hydrateClone).filter(Boolean),
-              writable: true,
-              enumerable: true,
-              configurable: true
-            });
-          } else if (typeof fkValue === "string" && relatedEntities.has(fkValue)) {
-            Object.defineProperty(entity, populatedFieldName, {
-              value: [hydrateClone(fkValue)],
-              writable: true,
-              enumerable: true,
-              configurable: true
-            });
-          }
+      eventNamespaces[orbitalName][traitName] = namespace;
+    }
+    const preprocessedOrbital = {
+      name: orbitalName,
+      description: resolvedOrbital.original.description,
+      visual_prompt: resolvedOrbital.original.visual_prompt,
+      // Resolved entity (always inline now)
+      entity: resolvedOrbital.entity,
+      // Resolved traits (inline definitions)
+      traits: (resolvedOrbital.traits || []).map((rt) => {
+        if (rt.config || rt.linkedEntity) {
+          return {
+            ref: rt.trait.name,
+            config: rt.config,
+            linkedEntity: rt.linkedEntity,
+            // Include the resolved trait definition for runtime
+            _resolved: rt.trait
+          };
         }
-      }
-      if (this.config.debug) {
-        persistLog.debug("populate:done", {
-          field: populatedFieldName,
-          count: entities.length,
-          entityType
-        });
-      }
+        return rt.trait;
+      }),
+      // Resolved pages (inline definitions with path overrides applied)
+      pages: resolvedOrbital.pages.map((rp) => rp.page),
+      // Preserve other fields
+      exposes: resolvedOrbital.original.exposes,
+      domainContext: resolvedOrbital.original.domainContext,
+      design: resolvedOrbital.original.design,
+      // Gap #22: pass through auxiliary entities so OrbitalServerRuntime's
+      // mock-seed branch registers SearchResult / FilterTarget / PagedItem
+      // alongside the molecule's primary entity. Without this, an inlined
+      // .orb that has `auxiliaryEntities` populated by the Rust inline
+      // phase still loses them here, and `(set @entity.searchTerm ...)` /
+      // `(fetch SearchResult ...)` from no-rebind imports hit unregistered
+      // persistence and silently no-op.
+      auxiliaryEntities: resolvedOrbital.original.auxiliaryEntities
+    };
+    preprocessedOrbitals.push(preprocessedOrbital);
+  }
+  const preprocessedSchema = {
+    ...schema,
+    orbitals: preprocessedOrbitals
+  };
+  return {
+    success: true,
+    data: {
+      schema: preprocessedSchema,
+      entitySharing,
+      eventNamespaces,
+      warnings
     }
+  };
+}
+function getIsolatedCollectionName(orbitalName, entitySharing) {
+  const info = entitySharing[orbitalName];
+  if (!info) {
+    throw new Error(`Unknown orbital: ${orbitalName}`);
   }
-  // ==========================================================================
-  // Express Router
-  // ==========================================================================
+  if (info.persistence === "runtime") {
+    return `${orbitalName}_${info.entityName}`;
+  }
+  return info.collectionName || info.entityName.toLowerCase() + "s";
+}
+function getNamespacedEvent(orbitalName, traitName, eventName, eventNamespaces) {
+  const orbitalNs = eventNamespaces[orbitalName];
+  if (!orbitalNs) return eventName;
+  const traitNs = orbitalNs[traitName];
+  if (!traitNs) return eventName;
+  return traitNs.emits[eventName] || eventName;
+}
+function isNamespacedEvent(eventName) {
+  return eventName.includes(".");
+}
+function parseNamespacedEvent(eventName) {
+  const parts = eventName.split(".");
+  if (parts.length === 3) {
+    return { orbital: parts[0], trait: parts[1], event: parts[2] };
+  }
+  if (parts.length === 2) {
+    return { trait: parts[0], event: parts[1] };
+  }
+  return { event: eventName };
+}
+
+// src/PersistenceAdapter.ts
+var InMemoryPersistence = class {
+  data = /* @__PURE__ */ new Map();
+  idCounter = 0;
   /**
-   * Create Express router for orbital API endpoints
-   *
-   * All data access goes through trait events with guards.
-   * No direct CRUD routes - use events with `fetch` effects.
+   * Seed the store with pre-existing rows.
    *
-   * Routes:
-   * - GET  /              - List registered orbitals
-   * - GET  /:orbital      - Get orbital info and current states
-   * - POST /:orbital/events - Send event to orbital (includes data from `fetch` effects)
+   * Accepts either a plain `Record<entityType, EntityRow[]>` or an iterable
+   * of `[entityType, EntityRow[]]` entries. Rows without an `id` get one
+   * generated at insert time; rows with an `id` keep it (so re-seeding
+   * after a schema rebuild preserves identities used in render bindings).
    */
-  router() {
-    if (!isNodeEnv()) {
-      throw new Error(
-        "OrbitalServerRuntime.router() is Node-only (uses Express). For in-browser use, mount <BrowserPlayground> from @almadar/ui instead."
-      );
-    }
-    const { Router } = nodeRequire("express");
-    const router = Router();
-    router.get("/", (_req, res) => {
-      const orbitals = Array.from(this.orbitals.entries()).map(
-        ([name, reg]) => ({
-          name,
-          entity: reg.entity?.name,
-          traits: (reg.traits || []).map((t) => t.name)
-        })
-      );
-      res.json({ success: true, orbitals });
-    });
-    router.get("/:orbital", (req, res) => {
-      const orbitalName = req.params.orbital;
-      const registered = this.orbitals.get(orbitalName);
-      if (!registered) {
-        res.status(404).json({ success: false, error: "Orbital not found" });
-        return;
-      }
-      const states = {};
-      for (const [name, state] of registered.manager.getAllStates()) {
-        states[name] = state.currentState;
+  seed(seedData) {
+    const entries = Symbol.iterator in Object(seedData) ? seedData : Object.entries(seedData);
+    for (const [entityType, rows] of entries) {
+      if (!this.data.has(entityType)) {
+        this.data.set(entityType, /* @__PURE__ */ new Map());
       }
-      res.json({
-        success: true,
-        orbital: {
-          name: orbitalName,
-          entity: registered.entity,
-          traits: registered.traits.map((t) => ({
-            name: t.name,
-            currentState: states[t.name],
-            states: (t.stateMachine?.states || []).map((s) => s.name),
-            events: [...new Set((t.stateMachine?.transitions || []).map((tr) => tr.event))]
-          }))
-        }
-      });
-    });
-    router.post(
-      "/:orbital/events",
-      async (req, res, next) => {
-        try {
-          const orbitalName = req.params.orbital;
-          const firebaseUser = req.firebaseUser;
-          const user = firebaseUser ? {
-            ...firebaseUser,
-            displayName: firebaseUser.name ?? firebaseUser.displayName
-          } : void 0;
-          const result = await this.processOrbitalEvent(orbitalName, {
-            ...req.body,
-            user
-          });
-          res.json(result);
-        } catch (error) {
-          next(error);
-        }
+      const collection = this.data.get(entityType);
+      for (const row of rows) {
+        const id = row.id || `${entityType}-${++this.idCounter}`;
+        collection.set(id, { ...row, id });
       }
-    );
-    return router;
-  }
-  // ==========================================================================
-  // Direct API (for programmatic use)
-  // ==========================================================================
-  /**
-   * Get the event bus for manual event emission
-   */
-  getEventBus() {
-    return this.eventBus;
+    }
   }
-  /**
-   * Get state for a specific orbital/trait
-   */
-  getState(orbitalName, traitName) {
-    const registered = this.orbitals.get(orbitalName);
-    if (!registered) return void 0;
-    if (traitName) {
-      return registered.manager.getState(traitName);
+  async create(entityType, data) {
+    const id = data.id || `${entityType}-${++this.idCounter}`;
+    if (!this.data.has(entityType)) {
+      this.data.set(entityType, /* @__PURE__ */ new Map());
     }
-    const states = {};
-    for (const [name, state] of registered.manager.getAllStates()) {
-      states[name] = state;
+    this.data.get(entityType).set(id, { ...data, id });
+    return { id };
+  }
+  async update(entityType, id, data) {
+    const collection = this.data.get(entityType);
+    if (collection?.has(id)) {
+      const existing = collection.get(id);
+      collection.set(id, { ...existing, ...data });
     }
-    return states;
   }
-  /**
-   * List registered orbitals
-   */
-  listOrbitals() {
-    return Array.from(this.orbitals.keys());
+  async delete(entityType, id) {
+    this.data.get(entityType)?.delete(id);
   }
-  /**
-   * Check if an orbital is registered
-   */
-  hasOrbital(name) {
-    return this.orbitals.has(name);
+  async getById(entityType, id) {
+    return this.data.get(entityType)?.get(id) || null;
+  }
+  async list(entityType) {
+    const collection = this.data.get(entityType);
+    return collection ? Array.from(collection.values()) : [];
   }
   /**
-   * Get information about active ticks
+   * Snapshot the entire store as a plain object (entityType → rows).
+   * Useful for feeding a fresh render-time binding layer with the
+   * current persistence view.
    */
-  getActiveTicks() {
-    return this.tickBindings.map((binding) => ({
-      orbital: binding.orbitalName,
-      trait: binding.traitName,
-      tick: binding.tick.name,
-      interval: binding.tick.interval,
-      hasGuard: !!binding.tick.guard
-    }));
-  }
-};
-function createOrbitalServerRuntime(config) {
-  return new OrbitalServerRuntime(config);
-}
-function parseListenSource(listener, listenerOrbital) {
-  const explicit = listener.source;
-  if (explicit && typeof explicit === "object") {
-    return {
-      bareEvent: listener.event,
-      matcher: buildMatcher(explicit, listenerOrbital)
-    };
-  }
-  const key = listener.event;
-  const parts = key.split(".");
-  if (parts.length === 1) {
-    return { bareEvent: key, matcher: () => true };
-  }
-  if (parts.length === 2) {
-    const [sourceOrStar, eventName] = parts;
-    if (sourceOrStar === "*") {
-      return { bareEvent: eventName, matcher: () => true };
+  snapshot() {
+    const out = {};
+    for (const [entityType, collection] of this.data) {
+      out[entityType] = Array.from(collection.values());
     }
-    return {
-      bareEvent: eventName,
-      matcher: buildMatcher(
-        { kind: "trait", trait: sourceOrStar },
-        listenerOrbital
-      )
-    };
-  }
-  if (parts.length >= 3) {
-    const eventName = parts[parts.length - 1];
-    const trait = parts[parts.length - 2];
-    const orbital = parts.slice(0, parts.length - 2).join(".");
-    return {
-      bareEvent: eventName,
-      matcher: buildMatcher({ kind: "orbital", orbital, trait }, listenerOrbital)
-    };
+    return out;
   }
-  return { bareEvent: key, matcher: () => true };
-}
-function buildMatcher(src, listenerOrbital) {
-  if (src.kind === "any") return () => true;
-  if (src.kind === "trait") {
-    const wantedTrait2 = src.trait;
-    return (source) => !!source && source.orbital === listenerOrbital && source.trait === wantedTrait2;
-  }
-  const wantedOrbital = src.orbital;
-  const wantedTrait = src.trait;
-  return (source) => !!source && source.orbital === wantedOrbital && source.trait === wantedTrait;
-}
+};
 
-export { EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, OrbitalServerRuntime, StateMachineManager, buildEmitsFromTraits, collectDeclaredConfigDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createOrbitalServerRuntime, createTestExecutor, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, normalizeEventKey, parseNamespacedEvent, preprocessSchema, processEvent, validateEventPayload, validatePayloadShapes };
-//# sourceMappingURL=chunk-VUXJJPIQ.js.map
-//# sourceMappingURL=chunk-VUXJJPIQ.js.map
+export { EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, buildEmitsFromTraits, collectDeclaredConfigDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createTestExecutor, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, normalizeEventKey, parseNamespacedEvent, preprocessSchema, processEvent, validateEventPayload, validatePayloadShapes };
+//# sourceMappingURL=chunk-R6Y4IJ7I.js.map
+//# sourceMappingURL=chunk-R6Y4IJ7I.js.map