@almadar/runtime 5.8.2 → 5.8.3

package/dist/{chunk-6XUD4OHN.js → chunk-JO2SIC3Q.js}

@@ -1,8 +1,9 @@
 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 { faker } from '@faker-js/faker';
-import { OrbitalSchemaSchema, isEntityCall, isEntityReference, parseEntityRef, parseImportedTraitRef, isPageReference, isPageReferenceString, isPageReferenceObject, parsePageRef } from '@almadar/core';
 
 // src/EventBus.ts
 var EventBus = class {
@@ -175,6 +176,8 @@ function createLogger(namespace) {
     error: (msg, data) => log("ERROR", msg, data)
   };
 }
+
+// src/BindingResolver.ts
 var bindLog = createLogger("almadar:runtime:bindings");
 var renderLog = createLogger("almadar:runtime:render-ui");
 var CLIENT_ONLY_BINDING_ROOTS = /* @__PURE__ */ new Set(["trait"]);
@@ -1984,509 +1987,822 @@ var MockPersistenceAdapter = class {
 function createMockPersistence(config) {
   return new MockPersistenceAdapter(config);
 }
-
-// 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 {
-  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(" -> ")}`;
-    }
-    this.chain.push(absolutePath);
-    return null;
+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));
   }
-  /**
-   * Remove the last path from the chain.
-   */
-  pop() {
-    this.chain.pop();
+  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);
   }
-  /**
-   * Clone the chain for nested loading.
-   */
-  clone() {
-    const newChain = new _HttpImportChain();
-    newChain.chain = [...this.chain];
-    return newChain;
+  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 effect;
+  });
+}
+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));
   }
-};
-var HttpLoaderCache = class {
-  cache = /* @__PURE__ */ new Map();
-  get(url) {
-    return this.cache.get(url);
+  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;
+    }
+    next[key] = renameEntityInRenderUiConfig(value, oldName, newName);
   }
-  set(url, schema) {
-    this.cache.set(url, schema);
+  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];
   }
-  has(url) {
-    return this.cache.has(url);
+  if (op === "persist" && effect.length >= 3 && effect[2] === oldName) {
+    return [op, effect[1], newName, ...effect.slice(3)];
   }
-  clear() {
-    this.cache.clear();
+  if (ENTITY_AT_POS_1.has(op) && effect[1] === oldName) {
+    return [op, newName, ...effect.slice(2)];
   }
-  get size() {
-    return this.cache.size;
+  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;
+    });
   }
-};
-var HttpLoader = class {
+  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;
   options;
-  cache;
+  localTraits;
+  loaderInitialized = false;
   constructor(options) {
-    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();
+    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-UHZQPCKW.js');
+      this.loader = new ExternalOrbitalLoader(this.options);
+    } catch {
+    }
   }
   /**
-   * Load a schema from an import path.
+   * Resolve all references in an orbital.
    */
-  async load(importPath, fromPath, chain) {
-    const importChain = chain ?? new HttpImportChain();
-    const resolveResult = this.resolvePath(importPath, fromPath);
-    if (!resolveResult.success) {
-      return resolveResult;
-    }
-    const absoluteUrl = resolveResult.data;
-    const circularError = importChain.push(absoluteUrl);
-    if (circularError) {
-      return { success: false, error: circularError };
+  async resolve(orbital, sourcePath, chain) {
+    const errors = [];
+    const warnings = [];
+    const importChain = chain ?? { push: () => null, pop: () => {
+    }, clone() {
+      return this;
+    } };
+    const importsResult = await this.resolveImports(
+      orbital.uses ?? [],
+      sourcePath,
+      importChain
+    );
+    if (!importsResult.success) {
+      return { success: false, errors: importsResult.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();
+    const imports = importsResult.data;
+    const entityResult = this.resolveEntity(orbital.entity, imports);
+    if (!entityResult.success) {
+      errors.push(...entityResult.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;
+    const traitsResult = this.resolveTraits(orbital.traits, imports);
+    if (!traitsResult.success) {
+      errors.push(...traitsResult.errors);
     }
-    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];
+    const pagesResult = this.resolvePages(orbital.pages, imports);
+    if (!pagesResult.success) {
+      errors.push(...pagesResult.errors);
+    }
+    if (errors.length > 0) {
+      return { success: false, errors };
+    }
+    if (!entityResult.success || !traitsResult.success || !pagesResult.success) {
+      return { success: false, errors: ["Internal error: unexpected failure state"] };
     }
     return {
       success: true,
       data: {
-        orbital,
-        sourcePath: schemaResult.data.sourcePath,
-        importPath
-      }
+        name: orbital.name,
+        entity: entityResult.data.entity,
+        entitySource: entityResult.data.source,
+        traits: traitsResult.data,
+        pages: pagesResult.data,
+        imports,
+        original: orbital
+      },
+      warnings
     };
   }
   /**
-   * Resolve an import path to an absolute URL.
+   * Resolve `uses` declarations to loaded orbitals.
    */
-  resolvePath(importPath, fromPath) {
-    if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
-      return { success: true, data: importPath };
-    }
-    if (importPath.startsWith("std/")) {
-      return this.resolveStdPath(importPath);
+  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"]
+      };
     }
-    if (importPath.startsWith("@")) {
-      return this.resolveScopedPath(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("./") || importPath.startsWith("../")) {
-      return this.resolveRelativePath(importPath, fromPath);
+    if (errors.length > 0) {
+      return { success: false, errors };
     }
-    return this.resolveRelativePath(`./${importPath}`, fromPath);
+    return { success: true, data: { orbitals }, warnings: [] };
   }
   /**
-   * Resolve a standard library path.
+   * Resolve entity reference.
    */
-  resolveStdPath(importPath) {
-    if (!this.options.stdLibPath) {
+  resolveEntity(entityRef, imports) {
+    if (isEntityCall(entityRef)) {
+      const fallbackName = entityRef.name ?? entityRef.extends.replace(/\.entity$/, "");
       return {
-        success: false,
-        error: `Standard library URL not configured. Cannot load: ${importPath}`
+        success: true,
+        data: {
+          entity: {
+            name: fallbackName,
+            fields: entityRef.fields ?? [],
+            ...entityRef.persistence ? { persistence: entityRef.persistence } : {},
+            ...entityRef.collection ? { collection: entityRef.collection } : {}
+          }
+        },
+        warnings: []
       };
     }
-    const relativePath = importPath.slice(4);
-    let absoluteUrl = this.joinUrl(this.options.stdLibPath, relativePath);
-    if (!absoluteUrl.endsWith(".orb")) {
-      absoluteUrl += ".orb";
+    if (!isEntityReference(entityRef)) {
+      return {
+        success: true,
+        data: { entity: entityRef },
+        warnings: []
+      };
     }
-    return { success: true, data: absoluteUrl };
-  }
-  /**
-   * Resolve a scoped package path.
-   */
-  resolveScopedPath(importPath) {
-    const match = importPath.match(/^(@[^/]+)/);
-    if (!match) {
+    const parsed = parseEntityRef(entityRef);
+    if (!parsed) {
       return {
         success: false,
-        error: `Invalid scoped package path: ${importPath}`
+        errors: [`Invalid entity reference format: ${entityRef}. Expected "Alias.entity"`]
       };
     }
-    const scope = match[1];
-    const scopeRoot = this.options.scopedPaths[scope];
-    if (!scopeRoot) {
+    const imported = imports.orbitals.get(parsed.alias);
+    if (!imported) {
       return {
         success: false,
-        error: `Scoped package "${scope}" not configured. Available: ${Object.keys(this.options.scopedPaths).join(", ") || "none"}`
+        errors: [
+          `Unknown import alias in entity reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
+        ]
       };
     }
-    const relativePath = importPath.slice(scope.length + 1);
-    let absoluteUrl = this.joinUrl(scopeRoot, relativePath);
-    if (!absoluteUrl.endsWith(".orb")) {
-      absoluteUrl += ".orb";
+    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.`
+        ]
+      };
     }
-    return { success: true, data: absoluteUrl };
+    const persistence = importedEntity.persistence ?? "persistent";
+    return {
+      success: true,
+      data: {
+        entity: importedEntity,
+        source: {
+          alias: parsed.alias,
+          persistence
+        }
+      },
+      warnings: []
+    };
   }
   /**
-   * Resolve a relative path.
+   * Get the entity from an orbital (handling EntityRef).
    */
-  resolveRelativePath(importPath, fromPath) {
-    const baseUrl = fromPath ? this.getParentUrl(fromPath) : this.options.basePath;
-    let absoluteUrl = this.joinUrl(baseUrl, importPath);
-    if (!absoluteUrl.endsWith(".orb")) {
-      absoluteUrl += ".orb";
+  getEntityFromOrbital(orbital) {
+    const entityRef = orbital.entity;
+    if (typeof entityRef === "string") {
+      return null;
     }
-    return { success: true, data: absoluteUrl };
+    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 } : {}
+      };
+    }
+    return entityRef;
   }
   /**
-   * Fetch and parse an OrbitalSchema from a URL.
+   * Resolve trait references.
    */
-  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);
+  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);
       }
-    } catch (e) {
-      if (e instanceof Error && e.name === "AbortError") {
+    }
+    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
+      );
+    }
+    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,
-          error: `Request timeout for ${url} (${this.options.timeout}ms)`
+          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: false,
-        error: `Failed to fetch ${url}: ${e instanceof Error ? e.message : String(e)}`
+        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"}`
+      ]
+    };
   }
   /**
-   * Join URL parts, handling relative paths and trailing slashes.
+   * Find a trait in an orbital by name.
    */
-  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 {
+  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) ;
       }
     }
-    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 null;
+  }
+  /**
+   * List trait names in an orbital.
+   */
+  listTraitsInOrbital(orbital) {
+    const names = [];
+    for (const traitRef of orbital.traits) {
+      if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
+        names.push(traitRef.name);
+      }
     }
-    return normalizedBase + normalizedPath;
+    return names;
   }
   /**
-   * Get parent URL (directory) from a URL.
+   * Resolve page references.
    */
-  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 {
+  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);
       }
     }
-    const lastSlash = url.lastIndexOf("/");
-    if (lastSlash !== -1) {
-      return url.slice(0, lastSlash);
+    if (errors.length > 0) {
+      return { success: false, errors };
     }
-    return url;
+    return { success: true, data: resolved, warnings: [] };
   }
   /**
-   * Clear the cache.
+   * Resolve a single page reference.
    */
-  clearCache() {
-    this.cache.clear();
+  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)}`]
+    };
   }
   /**
-   * Get cache statistics.
+   * Resolve a page reference string.
    */
-  getCacheStats() {
-    return { size: this.cache.size };
-  }
-};
-
-// src/loader/unified-loader.ts
-var externalLoaderModule = null;
-async function getExternalLoaderModule() {
-  if (externalLoaderModule) {
-    return externalLoaderModule;
+  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: []
+    };
   }
-  if (isBrowser()) {
-    return null;
+  /**
+   * 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
+    };
   }
-  try {
-    externalLoaderModule = await import('./external-loader-UHZQPCKW.js');
-    return externalLoaderModule;
-  } catch {
+  /**
+   * 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();
+  }
+};
+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}`));
+    }
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  return { success: true, data: resolved, warnings };
 }
-var UnifiedImportChain = class _UnifiedImportChain {
+
+// 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 {
   chain = [];
-  push(path) {
-    const normalized = this.normalizePath(path);
-    if (this.chain.includes(normalized)) {
+  /**
+   * 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(normalized)),
-        normalized
+        ...this.chain.slice(this.chain.indexOf(absolutePath)),
+        absolutePath
       ];
       return `Circular import detected: ${cycle.join(" -> ")}`;
     }
-    this.chain.push(normalized);
+    this.chain.push(absolutePath);
     return null;
   }
+  /**
+   * Remove the last path from the chain.
+   */
   pop() {
     this.chain.pop();
   }
+  /**
+   * Clone the chain for nested loading.
+   */
   clone() {
-    const newChain = new _UnifiedImportChain();
+    const newChain = new _HttpImportChain();
     newChain.chain = [...this.chain];
     return newChain;
   }
-  normalizePath(path) {
-    if (path.startsWith("http://") || path.startsWith("https://")) {
-      return path;
-    }
-    return path.replace(/\\/g, "/");
+};
+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;
   }
 };
-var UnifiedLoader = class {
+var HttpLoader = class {
   options;
-  httpLoader = null;
-  fsLoader = null;
-  fsLoaderInitialized = false;
-  cache = /* @__PURE__ */ new Map();
+  cache;
   constructor(options) {
-    this.options = options;
-    this.httpLoader = new HttpLoader({
+    this.options = {
       basePath: options.basePath,
-      stdLibPath: options.stdLibPath,
-      scopedPaths: options.scopedPaths,
-      ...options.http
-    });
-  }
-  /**
-   * 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
-      });
-    }
+      stdLibPath: options.stdLibPath ?? "",
+      scopedPaths: options.scopedPaths ?? {},
+      fetchOptions: options.fetchOptions,
+      timeout: options.timeout ?? 3e4,
+      credentials: options.credentials ?? "same-origin"
+    };
+    this.cache = new HttpLoaderCache();
   }
   /**
-   * Determine which loader to use for an import path.
+   * Load a schema from an import path.
    */
-  getLoaderForPath(importPath) {
-    if (this.options.forceLoader) {
-      return this.options.forceLoader;
+  async load(importPath, fromPath, chain) {
+    const importChain = chain ?? new HttpImportChain();
+    const resolveResult = this.resolvePath(importPath, fromPath);
+    if (!resolveResult.success) {
+      return resolveResult;
     }
-    if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
-      return "http";
+    const absoluteUrl = resolveResult.data;
+    const circularError = importChain.push(absoluteUrl);
+    if (circularError) {
+      return { success: false, error: circularError };
     }
-    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"
-        };
+    try {
+      const cached = this.cache.get(absoluteUrl);
+      if (cached) {
+        return { success: true, data: cached };
       }
-      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);
+      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 (result.success) {
-      this.cache.set(absolutePath, result.data);
-    }
-    return result;
   }
   /**
    * Load a specific orbital from a schema by name.
@@ -2497,988 +2813,2444 @@ var UnifiedLoader = 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(", ")}`
         };
       }
-      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}`
-      };
+      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: schema.orbitals[0],
+        orbital,
         sourcePath: schemaResult.data.sourcePath,
         importPath
       }
     };
   }
   /**
-   * Resolve an import path to an absolute path/URL.
+   * Resolve an import path to an absolute URL.
    */
   resolvePath(importPath, fromPath) {
-    const loaderType = this.getLoaderForPath(importPath);
-    if (loaderType === "http" && this.httpLoader) {
-      return this.httpLoader.resolvePath(importPath, fromPath);
+    if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
+      return { success: true, data: importPath };
     }
-    if (this.fsLoader) {
-      return this.fsLoader.resolvePath(importPath, fromPath);
+    if (importPath.startsWith("std/")) {
+      return this.resolveStdPath(importPath);
     }
-    if (this.httpLoader) {
-      return this.httpLoader.resolvePath(importPath, fromPath);
+    if (importPath.startsWith("@")) {
+      return this.resolveScopedPath(importPath);
     }
-    return {
-      success: false,
-      error: "No loader available for path resolution"
-    };
+    if (importPath.startsWith("./") || importPath.startsWith("../")) {
+      return this.resolveRelativePath(importPath, fromPath);
+    }
+    return this.resolveRelativePath(`./${importPath}`, fromPath);
   }
   /**
-   * Clear all caches.
+   * Resolve a standard library path.
    */
-  clearCache() {
-    this.cache.clear();
-    this.httpLoader?.clearCache();
-    this.fsLoader?.clearCache();
+  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 };
   }
   /**
-   * Get combined cache statistics.
+   * Resolve a scoped package path.
    */
-  getCacheStats() {
-    let size = this.cache.size;
-    if (this.httpLoader) {
-      size += this.httpLoader.getCacheStats().size;
+  resolveScopedPath(importPath) {
+    const match = importPath.match(/^(@[^/]+)/);
+    if (!match) {
+      return {
+        success: false,
+        error: `Invalid scoped package path: ${importPath}`
+      };
     }
-    if (this.fsLoader) {
-      size += this.fsLoader.getCacheStats().size;
+    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"}`
+      };
     }
-    return { size };
+    const relativePath = importPath.slice(scope.length + 1);
+    let absoluteUrl = this.joinUrl(scopeRoot, relativePath);
+    if (!absoluteUrl.endsWith(".orb")) {
+      absoluteUrl += ".orb";
+    }
+    return { success: true, data: absoluteUrl };
   }
   /**
-   * Check if filesystem loading is available.
+   * Resolve a relative path.
    */
-  async hasFilesystemAccess() {
-    await this.initFsLoader();
-    return this.fsLoader !== null;
+  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 };
   }
   /**
-   * Get current environment info.
+   * Fetch and parse an OrbitalSchema from a URL.
    */
-  getEnvironmentInfo() {
-    return {
-      isElectron: isElectron(),
-      isBrowser: isBrowser(),
-      isNode: isNode(),
-      hasFilesystem: this.fsLoader !== null
-    };
-  }
-};
-function createUnifiedLoader(options) {
-  return new UnifiedLoader(options);
-}
-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;
-}
-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;
-  });
+  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)}`
+      };
+    }
+  }
+  /**
+   * Join URL parts, handling relative paths and trailing slashes.
+   */
+  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 {
+      }
+    }
+    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;
+  }
+  /**
+   * 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 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-UHZQPCKW.js');
+    return externalLoaderModule;
+  } catch {
+    return null;
+  }
 }
-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));
+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(" -> ")}`;
+    }
+    this.chain.push(normalized);
+    return null;
   }
-  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;
+  pop() {
+    this.chain.pop();
+  }
+  clone() {
+    const newChain = new _UnifiedImportChain();
+    newChain.chain = [...this.chain];
+    return newChain;
+  }
+  normalizePath(path) {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path;
+    }
+    return path.replace(/\\/g, "/");
+  }
+};
+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
+    });
+  }
+  /**
+   * 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;
     }
-    next[key] = renameEntityInRenderUiConfig(value, oldName, newName);
+    if (this.fsLoader) {
+      size += this.fsLoader.getCacheStats().size;
+    }
+    return { size };
   }
-  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];
+  /**
+   * Check if filesystem loading is available.
+   */
+  async hasFilesystemAccess() {
+    await this.initFsLoader();
+    return this.fsLoader !== null;
   }
-  if (op === "persist" && effect.length >= 3 && effect[2] === oldName) {
-    return [op, effect[1], newName, ...effect.slice(3)];
+  /**
+   * Get current environment info.
+   */
+  getEnvironmentInfo() {
+    return {
+      isElectron: isElectron(),
+      isBrowser: isBrowser(),
+      isNode: isNode(),
+      hasFilesystem: this.fsLoader !== null
+    };
   }
-  if (ENTITY_AT_POS_1.has(op) && effect[1] === oldName) {
-    return [op, newName, ...effect.slice(2)];
+};
+function createUnifiedLoader(options) {
+  return new UnifiedLoader(options);
+}
+
+// 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 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);
+  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;
+        }
       }
-      return arg;
-    });
+      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
+    };
+    preprocessedOrbitals.push(preprocessedOrbital);
   }
-  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 }
+  const preprocessedSchema = {
+    ...schema,
+    orbitals: preprocessedOrbitals
   };
-}
-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
+    success: true,
+    data: {
+      schema: preprocessedSchema,
+      entitySharing,
+      eventNamespaces,
+      warnings
+    }
   };
 }
-var ReferenceResolver = class {
-  loader;
-  options;
-  localTraits;
-  loaderInitialized = false;
-  constructor(options) {
-    this.options = options;
-    this.loader = options.loader;
-    this.localTraits = options.localTraits ?? /* @__PURE__ */ new Map();
+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 ensureLoader() {
-    if (this.loader || this.loaderInitialized) return;
-    this.loaderInitialized = true;
-    try {
-      const { ExternalOrbitalLoader } = await import('./external-loader-UHZQPCKW.js');
-      this.loader = new ExternalOrbitalLoader(this.options);
-    } catch {
+  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 };
+  }
+  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 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()) : [];
+  }
   /**
-   * Resolve all references in an orbital.
+   * Snapshot the entire store as a plain object (entityType → rows).
+   * Useful for feeding a fresh render-time binding layer with the
+   * current persistence view.
    */
-  async resolve(orbital, sourcePath, chain) {
-    const errors = [];
-    const warnings = [];
-    const importChain = chain ?? { push: () => null, pop: () => {
-    }, clone() {
-      return this;
-    } };
-    const importsResult = await this.resolveImports(
-      orbital.uses ?? [],
-      sourcePath,
-      importChain
-    );
-    if (!importsResult.success) {
-      return { success: false, errors: importsResult.errors };
+  snapshot() {
+    const out = {};
+    for (const [entityType, collection] of this.data) {
+      out[entityType] = Array.from(collection.values());
     }
-    const imports = importsResult.data;
-    const entityResult = this.resolveEntity(orbital.entity, imports);
-    if (!entityResult.success) {
-      errors.push(...entityResult.errors);
+    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);
     }
-    const traitsResult = this.resolveTraits(orbital.traits, imports);
-    if (!traitsResult.success) {
-      errors.push(...traitsResult.errors);
+  }
+  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");
+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;
+      }
     }
-    const pagesResult = this.resolvePages(orbital.pages, imports);
-    if (!pagesResult.success) {
-      errors.push(...pagesResult.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;
+      }
     }
-    if (errors.length > 0) {
-      return { success: false, 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
+      });
     }
-    if (!entityResult.success || !traitsResult.success || !pagesResult.success) {
-      return { success: false, errors: ["Internal error: unexpected failure state"] };
+    if (this.config.mode === "mock" && !config.persistence) {
+      this.persistence = new MockPersistenceAdapter({
+        seed: config.mockSeed,
+        defaultSeedCount: config.mockSeedCount ?? 6,
+        debug: config.debug
+      });
+      if (config.debug) {
+        console.log("[OrbitalRuntime] Using mock persistence with faker data");
+      }
+    } else {
+      this.persistence = config.persistence || new InMemoryPersistence();
     }
-    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
+    if (config.localStorageRoot && isNodeEnv()) {
+      const { LocalPersistenceAdapter } = nodeRequire(`./LocalPersistenceAdapter${_nodeRequireExt}`);
+      this.localPersistence = new LocalPersistenceAdapter(config.localStorageRoot);
+    }
+    if (isNodeEnv()) {
+      const { createOsHandlers } = nodeRequire(`./createOsHandlers${_nodeRequireExt}`);
+      this.osHandlers = createOsHandlers({
+        emitEvent: (type, payload) => this.eventBus.emit(type, payload)
+      });
+    } else {
+      this.osHandlers = { handlers: {}, cleanup: () => {
+      } };
+    }
+    this.config.effectHandlers = {
+      ...this.osHandlers.handlers,
+      ...this.config.effectHandlers
     };
   }
   /**
-   * Resolve `uses` declarations to loaded orbitals.
+   * Lazily construct a default loader when the caller didn't provide one
+   * but `register()` needs to preprocess. Looks for `@almadar/std` in the
+   * nearest `node_modules` so cross-orbital `std/behaviors/<name>` imports
+   * resolve to the tiered registry on disk.
+   *
+   * Node only — browsers should receive already-preprocessed schemas from
+   * their server.
    */
-  async resolveImports(uses, sourcePath, chain) {
-    const errors = [];
-    const orbitals = /* @__PURE__ */ new Map();
-    if (this.options.skipExternalLoading) {
-      return {
-        success: true,
-        data: { orbitals },
-        warnings: ["External loading skipped"]
-      };
+  async ensureLoader() {
+    if (this.loader) return;
+    if (typeof process === "undefined" || !process.versions?.node) {
+      return;
     }
-    for (const use of uses) {
-      if (orbitals.has(use.as)) {
-        errors.push(`Duplicate import alias: ${use.as}`);
-        continue;
+    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);
       }
-      await this.ensureLoader();
-      if (!this.loader) {
-        errors.push(`No loader available to resolve import: ${use.from}`);
-        continue;
+      const basePath = this.config.loaderConfig?.basePath ?? process.cwd();
+      this.loader = createUnifiedLoader({
+        basePath,
+        stdLibPath,
+        scopedPaths: this.config.loaderConfig?.scopedPaths
+      });
+      if (this.config.debug) {
+        console.log(
+          `[OrbitalRuntime] Default loader constructed: basePath=${basePath} stdLibPath=${stdLibPath}`
+        );
       }
-      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;
+    } catch (err) {
+      if (this.config.debug) {
+        console.warn(
+          `[OrbitalRuntime] Could not auto-construct loader: ${err instanceof Error ? err.message : String(err)}`
+        );
       }
-      orbitals.set(use.as, {
-        alias: use.as,
-        from: use.from,
-        orbital: loadResult.data.orbital,
-        sourcePath: loadResult.data.sourcePath
-      });
     }
-    if (errors.length > 0) {
-      return { success: false, errors };
+  }
+  // ==========================================================================
+  // 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) {
+      console.log(`[OrbitalRuntime] Registering schema: ${schema.name}`);
     }
-    return { success: true, data: { orbitals }, warnings: [] };
+    if (needsPreprocessing(schema)) {
+      await this.ensureLoader();
+      if (this.loader) {
+        if (this.config.debug) {
+          console.log(`[OrbitalRuntime] Schema has uses/refs \u2014 auto-preprocessing`);
+        }
+        const result = await preprocessSchema(schema, {
+          basePath: this.config.loaderConfig?.basePath || process.cwd(),
+          stdLibPath: this.config.loaderConfig?.stdLibPath,
+          scopedPaths: this.config.loaderConfig?.scopedPaths,
+          loader: this.loader,
+          namespaceEvents: this.config.namespaceEvents
+        });
+        if (!result.success) {
+          throw new Error(
+            `Schema preprocessing failed: ${result.errors.join("; ")}`
+          );
+        }
+        schema = result.data.schema;
+        this.entitySharingMap = {
+          ...this.entitySharingMap,
+          ...result.data.entitySharing
+        };
+        this.eventNamespaceMap = {
+          ...this.eventNamespaceMap,
+          ...result.data.eventNamespaces
+        };
+      } else if (this.config.debug) {
+        console.warn(
+          `[OrbitalRuntime] Schema has uses/refs but no loader available \u2014 proceeding without preprocessing. Cross-orbital trait refs will be empty.`
+        );
+      }
+    }
+    for (const orbital of schema.orbitals) {
+      await this.registerOrbitalAsync(orbital);
+    }
+    this.setupEventListeners();
+    this.setupTicks();
+    this.resolvedSchema = schema;
   }
   /**
-   * Resolve entity reference.
+   * 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.
    */
-  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: []
-      };
+  registerSync(schema) {
+    if (this.config.debug) {
+      console.log(`[OrbitalRuntime] Registering schema (sync): ${schema.name}`);
     }
-    if (!isEntityReference(entityRef)) {
-      return {
-        success: true,
-        data: { entity: entityRef },
-        warnings: []
-      };
+    for (const orbital of schema.orbitals) {
+      this.registerOrbital(orbital);
     }
-    const parsed = parseEntityRef(entityRef);
-    if (!parsed) {
+    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;
+  }
+  /**
+   * 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()`).
+   */
+  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."
+      );
+    }
+    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}`);
+    }
+    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) {
       return {
         success: false,
-        errors: [`Invalid entity reference format: ${entityRef}. Expected "Alias.entity"`]
+        errors: ["Loader not configured. Set loaderConfig in OrbitalServerRuntimeConfig."]
       };
     }
-    const imported = imports.orbitals.get(parsed.alias);
-    if (!imported) {
+    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) {
+        console.log(`[OrbitalRuntime] Using cached preprocessed schema: ${schema.name}`);
+      }
+      this.register(cached.schema);
+      this.entitySharingMap = { ...this.entitySharingMap, ...cached.entitySharing };
+      this.eventNamespaceMap = { ...this.eventNamespaceMap, ...cached.eventNamespaces };
       return {
-        success: false,
-        errors: [
-          `Unknown import alias in entity reference: ${parsed.alias}. Available aliases: ${Array.from(imports.orbitals.keys()).join(", ") || "none"}`
-        ]
+        success: true,
+        entitySharing: cached.entitySharing,
+        eventNamespaces: cached.eventNamespaces,
+        warnings: cached.warnings
       };
     }
-    const importedEntity = this.getEntityFromOrbital(imported.orbital);
-    if (!importedEntity) {
+    if (this.config.debug) {
+      console.log(`[OrbitalRuntime] Preprocessing schema: ${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) {
       return {
-        success: false,
-        errors: [
-          `Imported orbital "${parsed.alias}" does not have an inline entity. Entity references cannot be chained.`
-        ]
+        success: false,
+        errors: result.errors
       };
     }
-    const persistence = importedEntity.persistence ?? "persistent";
+    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);
     return {
       success: true,
-      data: {
-        entity: importedEntity,
-        source: {
-          alias: parsed.alias,
-          persistence
-        }
-      },
-      warnings: []
+      entitySharing: result.data.entitySharing,
+      eventNamespaces: result.data.eventNamespaces,
+      warnings: result.data.warnings
     };
   }
   /**
-   * Get the entity from an orbital (handling EntityRef).
+   * Get entity sharing information for registered orbitals.
+   * Useful for determining entity isolation and collection names.
    */
-  getEntityFromOrbital(orbital) {
+  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
+   */
+  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);
+    }
     const entityRef = orbital.entity;
+    let entity;
     if (typeof entityRef === "string") {
-      return null;
-    }
-    if (isEntityCall(entityRef)) {
+      entity = { name: entityRef, fields: [] };
+    } else if (isEntityCall(entityRef)) {
       const fallbackName = entityRef.name ?? entityRef.extends.replace(/\.entity$/, "");
-      return {
+      entity = {
         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()
+    });
+    if (entity?.name && entity.instances && Array.isArray(entity.instances)) {
+      const instances = entity.instances;
+      if (instances.length > 0) {
+        console.log(`[OrbitalRuntime] Seeding ${instances.length} instances for ${entity.name} from schema`);
+        const results = await Promise.all(
+          instances.map(async (instance) => {
+            try {
+              const result = await this.persistence.create(entity.name, instance);
+              console.log(`[OrbitalRuntime] Seeded instance: ${instance.id || "no-id"}`);
+              return result;
+            } catch (err) {
+              console.error(`[OrbitalRuntime] Failed to seed instance ${instance.id}:`, err);
+              return null;
+            }
+          })
+        );
+        const successCount = results.filter((r) => r !== null).length;
+        console.log(`[OrbitalRuntime] Seeded ${successCount}/${instances.length} ${entity.name} instances from schema`);
+      }
+    } else if (this.config.mode === "mock" && this.persistence instanceof MockPersistenceAdapter) {
+      if (this.config.debug) {
+        console.log(`[OrbitalRuntime] No instances in schema, generating mock data for ${entity?.name}`);
+      }
+      if (entity?.name && entity.fields) {
+        const fields = entity.fields.filter(
+          (f) => typeof f.name === "string" && f.name.length > 0
+        ).map((f) => ({
+          name: f.name,
+          type: f.type,
+          required: f.required,
+          values: f.values,
+          default: f.default
+        }));
+        this.persistence.registerEntity({ name: entity.name, fields });
+        if (this.config.debug) {
+          console.log(`[OrbitalRuntime] Seeded mock data for entity: ${entity.name}, count: ${this.persistence.count(entity.name)}`);
+        }
+      }
+    }
+    if (this.config.debug) {
+      console.log(
+        `[OrbitalRuntime] Registered orbital: ${orbital.name} with ${(orbital.traits || []).length} trait(s)`
+      );
     }
-    return entityRef;
   }
   /**
-   * Resolve trait references.
+   * Register a single orbital (sync wrapper for backward compatibility)
    */
-  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);
+  registerOrbital(orbital) {
+    this.registerOrbitalAsync(orbital).catch((err) => {
+      console.error(`[OrbitalRuntime] Failed to register orbital:`, 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) {
+              console.log(
+                `[OrbitalRuntime] ${orbitalName}.${trait.name} received: ${listener.event} (from ${event.source?.orbital ?? "?"}.${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);
+        }
       }
     }
-    if (errors.length > 0) {
-      return { success: false, errors };
-    }
-    return { success: true, data: resolved, warnings: [] };
   }
   /**
-   * Resolve a single trait reference.
+   * Set up scheduled ticks for all traits
    */
-  resolveTraitRef(traitRef, imports) {
-    if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
-      return {
-        success: true,
-        data: {
-          trait: traitRef,
-          source: { type: "inline" }
-        },
-        warnings: []
-      };
+  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);
+        }
+      }
     }
-    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
+    if (this.config.debug && this.tickBindings.length > 0) {
+      console.log(
+        `[OrbitalRuntime] Registered ${this.tickBindings.length} tick(s)`
       );
     }
-    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.
+   * Register a single tick
    */
-  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: []
-      };
+  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;
     }
-    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: []
-      };
+    if (this.config.debug) {
+      console.log(
+        `[OrbitalRuntime] Registering tick: ${orbitalName}.${traitName}.${tick.name} (${intervalMs}ms)`
+      );
     }
-    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"}`
-      ]
-    };
+    const timerId = setInterval(async () => {
+      await this.executeTick(orbitalName, traitName, tick, registered);
+    }, intervalMs);
+    this.tickBindings.push({
+      orbitalName,
+      traitName,
+      tick,
+      timerId
+    });
   }
   /**
-   * Find a trait in an orbital by name.
+   * Parse interval string to milliseconds
+   * Supports: '5s', '1m', '1h', '30000' (ms)
    */
-  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) ;
-      }
+  parseIntervalString(interval) {
+    const match = interval.match(/^(\d+)(ms|s|m|h)?$/);
+    if (!match) {
+      console.warn(
+        `[OrbitalRuntime] Invalid interval format: ${interval}, defaulting to 1000ms`
+      );
+      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;
     }
-    return null;
   }
   /**
-   * List trait names in an orbital.
+   * Execute a tick for all applicable entities
    */
-  listTraitsInOrbital(orbital) {
-    const names = [];
-    for (const traitRef of orbital.traits) {
-      if (typeof traitRef !== "string" && "stateMachine" in traitRef) {
-        names.push(traitRef.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) {
+        console.log(
+          `[OrbitalRuntime] Tick ${orbitalName}.${traitName}.${tick.name}: processing ${entities.length} entities`
+        );
+      }
+      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) {
+                console.log(
+                  `[OrbitalRuntime] Tick ${tick.name}: guard failed for entity ${entity.id}`
+                );
+              }
+              continue;
+            }
+          } catch (error) {
+            console.error(
+              `[OrbitalRuntime] Tick ${tick.name}: guard evaluation error for entity ${entity.id}:`,
+              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) {
+            console.log(
+              `[OrbitalRuntime] Tick ${tick.name}: executed effects for entity ${entity.id}`
+            );
+          }
+        }
       }
+    } catch (error) {
+      console.error(
+        `[OrbitalRuntime] Tick ${tick.name} execution error:`,
+        error
+      );
     }
-    return names;
   }
   /**
-   * Resolve page references.
+   * Clean up all active ticks
    */
-  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 };
+  cleanupTicks() {
+    for (const binding of this.tickBindings) {
+      clearInterval(binding.timerId);
     }
-    return { success: true, data: resolved, warnings: [] };
+    this.tickBindings = [];
   }
   /**
-   * Resolve a single page reference.
+   * Unregister all orbitals and clean up
    */
-  resolvePageRef(pageRef, imports) {
-    if (!isPageReference(pageRef)) {
-      return {
-        success: true,
-        data: {
-          page: pageRef,
-          source: { type: "inline" },
-          pathOverridden: false
-        },
-        warnings: []
-      };
+  unregisterAll() {
+    this.cleanupTicks();
+    for (const cleanup of this.listenerCleanups) {
+      cleanup();
     }
-    if (isPageReferenceString(pageRef)) {
-      return this.resolvePageRefString(pageRef, imports);
+    this.listenerCleanups = [];
+    this.orbitals.clear();
+    this.eventBus.clear();
+    if (this.persistence instanceof MockPersistenceAdapter) {
+      this.persistence.clearAll();
     }
-    if (isPageReferenceObject(pageRef)) {
-      return this.resolvePageRefObject(pageRef, imports);
+    if (this.osHandlers) {
+      this.osHandlers.cleanup();
+      this.osHandlers = null;
+    }
+  }
+  /**
+   * 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.
+   */
+  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
+        ).map((f) => ({
+          name: f.name,
+          type: f.type,
+          required: f.required,
+          values: f.values,
+          default: f.default
+        }));
+        this.persistence.registerEntity({ name: entity.name, fields });
+      }
     }
-    return {
-      success: false,
-      errors: [`Unknown page reference format: ${JSON.stringify(pageRef)}`]
-    };
   }
+  // ==========================================================================
+  // Event Processing
+  // ==========================================================================
   /**
-   * Resolve a page reference string.
+   * Process an event for an orbital
    */
-  resolvePageRefString(ref, imports) {
-    const parsed = parsePageRef(ref);
-    if (!parsed) {
+  async processOrbitalEvent(orbitalName, request) {
+    const registered = this.orbitals.get(orbitalName);
+    if (!registered) {
       return {
         success: false,
-        errors: [`Invalid page reference format: ${ref}. Expected "Alias.pages.PageName"`]
+        transitioned: false,
+        states: {},
+        emittedEvents: [],
+        error: `Orbital not found: ${orbitalName}`
       };
     }
-    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 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)
+        );
+      }
     }
-    const page = this.findPageInOrbital(imported.orbital, parsed.pageName);
-    if (!page) {
+    if (validationFailures.length > 0) {
       return {
         success: false,
-        errors: [
-          `Page "${parsed.pageName}" not found in imported orbital "${parsed.alias}". Available pages: ${this.listPagesInOrbital(imported.orbital).join(", ") || "none"}`
-        ]
+        transitioned: false,
+        states: {},
+        emittedEvents: [],
+        error: formatPayloadValidationError(validationFailures)
       };
     }
-    return {
+    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;
+      }
+    } else if (registered.entity?.name) {
+      try {
+        const all = await this.persistence.list(registered.entity.name);
+        if (Array.isArray(all) && all.length > 0 && all[0]) {
+          entityData = all[0];
+        }
+      } catch {
+      }
+    }
+    const results = registered.manager.sendEvent(event, cleanPayload, entityData);
+    const filteredResults = activeTraits && activeTraits.length > 0 ? results.filter(({ traitName }) => activeTraits.includes(traitName)) : results;
+    if (this.config.debug && activeTraits) {
+      console.log(`[OrbitalRuntime] Filtering traits: ${results.length} total, ${filteredResults.length} active (${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 response = {
       success: true,
-      data: {
-        page,
-        source: { type: "imported", alias: parsed.alias, pageName: parsed.pageName },
-        pathOverridden: false
+      transitioned: results.length > 0,
+      states,
+      emittedEvents
+    };
+    if (clientEffects.length > 0) {
+      response.clientEffects = clientEffects;
+    }
+    if (clientEffectsByTrait.length > 0) {
+      response.clientEffectsByTrait = clientEffectsByTrait;
+    }
+    if (effectResults.length > 0) {
+      response.effectResults = effectResults;
+    }
+    return response;
+  }
+  /**
+   * Execute effects from a transition
+   */
+  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) {
+          console.log(`[OrbitalRuntime] Emitting: ${event}`, eventPayload, source);
+        }
+        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
+        });
       },
-      warnings: []
+      set: async (targetId, field, value) => {
+        const id = targetId || entityId;
+        if (id) {
+          try {
+            await this.persistence.update(entityType, id, { [field]: value });
+            effectResults.push({
+              effect: "set",
+              entityType,
+              data: { id, field, value },
+              success: true
+            });
+          } catch (err) {
+            effectResults.push({
+              effect: "set",
+              entityType,
+              data: { id, field, value },
+              success: false,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+      },
+      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 {
+            console.warn(
+              `[OrbitalRuntime] 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 {
+          let result = null;
+          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;
+            }
+          } else {
+            let entities = await this.persistence.list(fetchEntityType);
+            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;
+          }
+          if (bindingsRef && result) {
+            const records = Array.isArray(result) ? result : [result];
+            if (records.length > 0) {
+              const merged = Object.assign([...records], records[0]);
+              bindingsRef[fetchEntityType] = merged;
+              if (fetchEntityType === entityType) {
+                bindingsRef.entity = merged;
+              }
+            }
+          }
+          return result;
+        } catch (error) {
+          console.error(`[OrbitalRuntime] Fetch error for ${fetchEntityType}:`, error);
+          return null;
+        }
+      },
+      // Resource operators: ref, deref, swap, watch, atomic
+      ref: async (refEntityType, options) => {
+        try {
+          return await handlers.fetch(refEntityType, options);
+        } catch (error) {
+          console.error(`[OrbitalRuntime] ref error for ${refEntityType}:`, error);
+          return null;
+        }
+      },
+      deref: async (derefEntityType, options) => {
+        try {
+          let result = null;
+          if (options?.id) {
+            const entity = await this.persistence.getById(derefEntityType, options.id);
+            if (entity) {
+              fetchedData[derefEntityType] = [entity];
+              result = entity;
+            }
+          } else {
+            const entities = await this.persistence.list(derefEntityType);
+            fetchedData[derefEntityType] = entities;
+            result = entities;
+          }
+          if (bindingsRef && result) {
+            const records = Array.isArray(result) ? result : [result];
+            if (records.length > 0) {
+              const merged = Object.assign([...records], records[0]);
+              bindingsRef[derefEntityType] = merged;
+              if (derefEntityType === entityType) {
+                bindingsRef.entity = merged;
+              }
+            }
+          }
+          effectResults.push({
+            effect: "deref",
+            entityType: derefEntityType,
+            success: true
+          });
+          return result;
+        } 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) {
+          console.log(`[OrbitalRuntime] watch is a no-op on server: ${_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) {
+          console.log(`[OrbitalRuntime] Notification (${type}): ${message}`);
+        }
+        pushClientEffect(["notify", message, { type }]);
+      },
+      log: (message, level) => {
+        const logFn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+        logFn(`[OrbitalRuntime] ${message}`);
+      },
+      // 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 declaredDefaults = collectDeclaredConfigDefaults(
+      registered.traits.find((t) => t.name === traitName)
+    );
+    const callSiteOverride = registered.configByTrait.get(traitName);
+    if (declaredDefaults || callSiteOverride) {
+      bindings.config = { ...declaredDefaults ?? {}, ...callSiteOverride ?? {} };
+    }
+    if (entityType) {
+      bindings[entityType] = 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);
   }
+  // ==========================================================================
+  // Relation Population
+  // ==========================================================================
   /**
-   * Resolve a page reference object with optional path override.
+   * 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
    */
-  resolvePageRefObject(refObj, imports) {
-    const baseResult = this.resolvePageRefString(refObj.ref, imports);
-    if (!baseResult.success) {
-      return baseResult;
+  /**
+   * Validate that relation field values match their declared cardinality.
+   * Called before create/update to ensure data integrity.
+   */
+  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;
     }
-    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;
+  }
+  /**
+   * 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) {
+              console.log(`[OrbitalRuntime] Cascade deleted ${affectedRecords.length} ${referringEntityType} records`);
+            }
+            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) {
+              console.log(`[OrbitalRuntime] Nullified ${field.name} on ${affectedRecords.length} ${referringEntityType} records`);
+            }
+            break;
+        }
+      }
+    }
+  }
+  async populateRelations(entities, entityType, include, depth = 0, visited = /* @__PURE__ */ new Set()) {
+    const maxDepth = 2;
+    if (depth >= maxDepth || visited.has(entityType)) {
+      if (this.config.debug) {
+        console.log(`[OrbitalRuntime] Skipping populateRelations for ${entityType}: depth=${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) {
+        console.warn(`[OrbitalRuntime] No entity definition found for ${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) {
+          console.warn(`[OrbitalRuntime] No relation field found for '${includeField}' on ${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);
+            }
+          }
+        }
+      }
+      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) {
+            console.error(`[OrbitalRuntime] Error fetching related ${relatedEntityType}:`, error);
+          }
+        }
+      }
+      const populatedFieldName = includeField.endsWith("Id") ? includeField.slice(0, -2) : includeField;
+      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: relatedEntities.get(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((id) => relatedEntities.get(id)).filter(Boolean),
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
+          } else if (typeof fkValue === "string" && relatedEntities.has(fkValue)) {
+            Object.defineProperty(entity, populatedFieldName, {
+              value: [relatedEntities.get(fkValue)],
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
+          }
+        }
+      }
+      if (this.config.debug) {
+        console.log(`[OrbitalRuntime] Populated '${populatedFieldName}' on ${entities.length} ${entityType} entities`);
+      }
     }
-    return {
-      success: true,
-      data: resolved,
-      warnings: baseResult.warnings
-    };
   }
+  // ==========================================================================
+  // Express Router
+  // ==========================================================================
   /**
-   * Find a page in an orbital by name.
+   * 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.
+   *
+   * 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)
    */
-  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 };
+  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;
+      }
+      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);
         }
       }
-    }
-    return null;
+    );
+    return router;
   }
+  // ==========================================================================
+  // Direct API (for programmatic use)
+  // ==========================================================================
   /**
-   * List page names in an orbital.
+   * Get the event bus for manual event emission
    */
-  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;
+  getEventBus() {
+    return this.eventBus;
   }
   /**
-   * Add local traits for resolution.
+   * Get state for a specific orbital/trait
    */
-  addLocalTraits(traits) {
-    for (const trait of traits) {
-      this.localTraits.set(trait.name, trait);
+  getState(orbitalName, traitName) {
+    const registered = this.orbitals.get(orbitalName);
+    if (!registered) return void 0;
+    if (traitName) {
+      return registered.manager.getState(traitName);
+    }
+    const states = {};
+    for (const [name, state] of registered.manager.getAllStates()) {
+      states[name] = state;
     }
+    return states;
   }
   /**
-   * Clear loader cache.
+   * List registered orbitals
    */
-  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);
+  listOrbitals() {
+    return Array.from(this.orbitals.keys());
   }
-  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}`));
-    }
+  /**
+   * Check if an orbital is registered
+   */
+  hasOrbital(name) {
+    return this.orbitals.has(name);
   }
-  if (errors.length > 0) {
-    return { success: false, errors };
+  /**
+   * Get information about active ticks
+   */
+  getActiveTicks() {
+    return this.tickBindings.map((binding) => ({
+      orbital: binding.orbitalName,
+      trait: binding.traitName,
+      tick: binding.tick.name,
+      interval: binding.tick.interval,
+      hasGuard: !!binding.tick.guard
+    }));
   }
-  return { success: true, data: resolved, warnings };
+};
+function createOrbitalServerRuntime(config) {
+  return new OrbitalServerRuntime(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
+function parseListenSource(listener, listenerOrbital) {
+  const explicit = listener.source;
+  if (explicit && typeof explicit === "object") {
+    return {
+      bareEvent: listener.event,
+      matcher: buildMatcher(explicit, listenerOrbital)
     };
-    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}`);
-  }
-  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] };
+  const key = listener.event;
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    return { bareEvent: key, matcher: () => true };
   }
   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 };
-  }
-  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 });
+    const [sourceOrStar, eventName] = parts;
+    if (sourceOrStar === "*") {
+      return { bareEvent: eventName, matcher: () => true };
     }
+    return {
+      bareEvent: eventName,
+      matcher: buildMatcher(
+        { kind: "trait", trait: sourceOrStar },
+        listenerOrbital
+      )
+    };
   }
-  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.
-   */
-  snapshot() {
-    const out = {};
-    for (const [entityType, collection] of this.data) {
-      out[entityType] = Array.from(collection.values());
-    }
-    return out;
+  if (parts.length >= 3) {
+    const eventName = parts[parts.length - 1];
+    const trait = parts[parts.length - 2];
+    const orbital = parts.slice(0, parts.length - 2).join(".");
+    return {
+      bareEvent: eventName,
+      matcher: buildMatcher({ kind: "orbital", orbital, trait }, listenerOrbital)
+    };
   }
-};
+  return { bareEvent: key, matcher: () => true };
+}
+function buildMatcher(src, listenerOrbital) {
+  if (src.kind === "any") return () => true;
+  if (src.kind === "trait") {
+    const wantedTrait2 = src.trait;
+    return (source) => !!source && source.orbital === listenerOrbital && source.trait === wantedTrait2;
+  }
+  const wantedOrbital = src.orbital;
+  const wantedTrait = src.trait;
+  return (source) => !!source && source.orbital === wantedOrbital && source.trait === wantedTrait;
+}
 
-export { EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, buildEmitsFromTraits, containsBindings, createContextFromBindings, createInitialTraitState, createLogger, createMockPersistence, createTestExecutor, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, normalizeEventKey, parseNamespacedEvent, preprocessSchema, processEvent, validateEventPayload, validatePayloadShapes };
-//# sourceMappingURL=chunk-6XUD4OHN.js.map
-//# sourceMappingURL=chunk-6XUD4OHN.js.map
+export { EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, OrbitalServerRuntime, StateMachineManager, buildEmitsFromTraits, collectDeclaredConfigDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createLogger, createMockPersistence, createOrbitalServerRuntime, createTestExecutor, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, normalizeEventKey, parseNamespacedEvent, preprocessSchema, processEvent, validateEventPayload, validatePayloadShapes };
+//# sourceMappingURL=chunk-JO2SIC3Q.js.map
+//# sourceMappingURL=chunk-JO2SIC3Q.js.map