@almadar/shell-runtime 0.0.0-stage → 0.1.0

package/dist/chunk-REPX5QPI.js

@@ -0,0 +1,57 @@
+// src/kernel/os-port.ts
+function kernelOsCompletions(kernel) {
+  const deferring = JSON.parse(kernel.osDeferringOps());
+  const streaming = JSON.parse(kernel.osStreamOps());
+  return {
+    defers: (op) => deferring.includes(op),
+    streams: (op) => streaming.includes(op),
+    event: (site, key, outcome) => {
+      const fired = JSON.parse(kernel.osCompletionEvent(JSON.stringify(site), key, JSON.stringify(outcome)));
+      return fired;
+    }
+  };
+}
+function kernelOsGrants(matchers, server) {
+  return {
+    allows: (need) => server().osAllows(JSON.stringify(need)),
+    globMatches: (glob, path) => matchers.osGlobMatches(glob, path),
+    isPublicAddress: (ip) => matchers.isPublicAddress(ip),
+    anchor: (anchors) => {
+      const problems = JSON.parse(server().setOsAnchors(JSON.stringify(anchors)));
+      return problems;
+    },
+    resolveArgs: (op, args) => {
+      const resolved = JSON.parse(server().osResolveArgs(op, JSON.stringify(args)));
+      return resolved;
+    }
+  };
+}
+function expandAnchor(anchors, text) {
+  const home = text === "~" ? "" : text.startsWith("~/") ? text.slice(2) : void 0;
+  const start = text === "." ? "" : text.startsWith("./") ? text.slice(2) : void 0;
+  const rest = home ?? start;
+  if (rest === void 0) return { kind: "plain" };
+  const dir = home !== void 0 ? anchors.home : anchors.start;
+  if (dir === void 0) return { kind: "unknown", message: `${text}: this host has no ${home !== void 0 ? "home" : "start"} directory` };
+  return { kind: "anchored", path: rest === "" ? dir : `${dir.replace(/\/+$/, "")}/${rest}` };
+}
+function anchoredForms(anchors, path) {
+  const forms = [path];
+  const under = (dir, prefix) => {
+    if (dir === void 0) return;
+    const root = dir.replace(/\/+$/, "");
+    if (path === root) forms.push(prefix);
+    else if (path.startsWith(`${root}/`)) forms.push(`${prefix}${path.slice(root.length + 1)}`);
+  };
+  under(anchors.home, "~/");
+  under(anchors.start, "./");
+  return forms;
+}
+function anchoredGrants(grants, anchors) {
+  return {
+    ...grants,
+    allows: (need) => need.need === "fs" ? anchoredForms(anchors, need.path).some((path) => grants.allows({ ...need, path })) : grants.allows(need)
+  };
+}
+
+export { anchoredGrants, expandAnchor, kernelOsCompletions, kernelOsGrants };

package/dist/chunk-SAS5KKCR.js

@@ -0,0 +1,43 @@
+import { unwrapTraitRef, normalizeCallSiteConfigToValues, isInlineTrait, isEntityCall } from '@almadar/core';
+
+// src/runtime/traits/OrbitalTraitParsing.ts
+function parseOrbitalTraits(orbital) {
+  const configByTrait = /* @__PURE__ */ new Map();
+  const unwrapped = (orbital.traits || []).map((t) => {
+    const { trait, config } = unwrapTraitRef(t);
+    const normalizedConfig = normalizeCallSiteConfigToValues(config);
+    if (normalizedConfig && typeof trait !== "string" && isInlineTrait(trait) && trait.name) {
+      configByTrait.set(trait.name, normalizedConfig);
+    }
+    return trait;
+  });
+  const inlineTraits = unwrapped.filter(isInlineTrait);
+  const traits = inlineTraits.map((t) => {
+    const sm = t.stateMachine;
+    return {
+      ...t.id !== void 0 ? { id: t.id } : {},
+      name: t.name,
+      states: sm?.states || [],
+      transitions: sm?.transitions || [],
+      listens: t.listens
+    };
+  });
+  const entityRef = orbital.entity;
+  let entity;
+  if (typeof entityRef === "string") {
+    entity = { name: entityRef, fields: [] };
+  } else if (isEntityCall(entityRef)) {
+    const fallbackName = entityRef.name ?? entityRef.extends.replace(/\.entity$/, "");
+    entity = {
+      name: fallbackName,
+      fields: entityRef.fields ?? [],
+      ...entityRef.persistence ? { persistence: entityRef.persistence } : {},
+      ...entityRef.collection ? { collection: entityRef.collection } : {}
+    };
+  } else {
+    entity = entityRef;
+  }
+  return { traits, inlineTraits, configByTrait, entity };
+}
+
+export { parseOrbitalTraits };

package/dist/chunk-SKLMWHQD.js

@@ -0,0 +1,109 @@
+// src/client/channel-transport.ts
+var CLOSED = "The host closed the channel before answering";
+function createChannelTransport(channel, options = {}) {
+  let next = 1;
+  const pending = /* @__PURE__ */ new Map();
+  channel.onMessage((message) => {
+    if (message.almadarChannel !== "registered" && message.almadarChannel !== "reply") return;
+    const settle = pending.get(message.id);
+    if (!settle) return;
+    pending.delete(message.id);
+    settle(message);
+  });
+  let closed = false;
+  const closedReply = (id) => ({
+    almadarChannel: "reply",
+    id,
+    response: { success: false, transitioned: false, states: {}, emittedEvents: [], error: CLOSED }
+  });
+  channel.onClose?.(() => {
+    closed = true;
+    for (const [id, settle] of pending) settle(closedReply(id));
+    pending.clear();
+  });
+  const request = (build) => new Promise((resolve) => {
+    const id = next++;
+    if (closed) {
+      resolve(closedReply(id));
+      return;
+    }
+    pending.set(id, resolve);
+    channel.post(build(id));
+  });
+  return {
+    hostsBrowserStore: options.hostsBrowserStore === true,
+    async register(schema) {
+      const reply = await request((id) => ({ almadarChannel: "register", id, schemaName: schema.name }));
+      const held = reply.almadarChannel === "registered" && reply.held;
+      return { success: held, carriesCircuitState: false };
+    },
+    async unregister() {
+      pending.clear();
+    },
+    async send(orbitalName, req) {
+      const reply = await request((id) => ({ almadarChannel: "send", id, orbitalName, request: req }));
+      if (reply.almadarChannel !== "reply") {
+        return { success: false, transitioned: false, states: {}, emittedEvents: [], error: "The host answered out of protocol" };
+      }
+      return reply.response;
+    },
+    subscribe(onPush) {
+      return channel.onMessage((message) => {
+        if (message.almadarChannel === "push") onPush(message.emitted, message.target);
+      });
+    },
+    subscribeHostDispatches(onDispatch) {
+      return channel.onMessage((message) => {
+        if (message.almadarChannel === "dispatched") onDispatch(message.orbitalName, message.request, message.response);
+      });
+    }
+  };
+}
+function serveChannel(channel, transport, options) {
+  const stop = channel.onMessage((message) => {
+    if (message.almadarChannel === "register") {
+      channel.post({ almadarChannel: "registered", id: message.id, held: message.schemaName === options.schemaName });
+      return;
+    }
+    if (message.almadarChannel !== "send") return;
+    transport.send(message.orbitalName, message.request).then(
+      (response) => channel.post({ almadarChannel: "reply", id: message.id, response }),
+      (err) => channel.post({
+        almadarChannel: "reply",
+        id: message.id,
+        response: { success: false, transitioned: false, states: {}, emittedEvents: [], error: err.message }
+      })
+    );
+  });
+  return {
+    push: (emitted, target) => channel.post({ almadarChannel: "push", emitted, target }),
+    pushDispatch: (orbitalName, request, response) => channel.post({ almadarChannel: "dispatched", orbitalName, request, response }),
+    stop
+  };
+}
+function holdUntilServed(channel) {
+  let held = [];
+  const listeners = [];
+  channel.onMessage((message) => {
+    if (held !== void 0) held.push(message);
+    else listeners.forEach((l) => l(message));
+  });
+  return {
+    post: (message) => channel.post(message),
+    onMessage(listener) {
+      listeners.push(listener);
+      if (held !== void 0) {
+        const early = held;
+        held = void 0;
+        early.forEach((m) => listeners.forEach((l) => l(m)));
+      }
+      return () => {
+        const i = listeners.indexOf(listener);
+        if (i >= 0) listeners.splice(i, 1);
+      };
+    },
+    ...channel.onClose !== void 0 ? { onClose: channel.onClose.bind(channel) } : {}
+  };
+}
+
+export { createChannelTransport, holdUntilServed, serveChannel };

package/dist/chunk-SOQDEPME.js

@@ -0,0 +1,131 @@
+import { createLogger } from '@almadar/logger';
+
+// src/events/EventBus.ts
+var log = createLogger("almadar:runtime:eventbus");
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  /** Maximum recursion depth before circuit breaker activates (RCG-05) */
+  maxDepth;
+  /** Current emission depth for circular loop detection */
+  depth = 0;
+  constructor(options = {}) {
+    void options.debug;
+    this.maxDepth = options.maxDepth ?? 10;
+  }
+  /**
+   * Emit an event to all registered listeners.
+   *
+   * Includes circuit breaker (RCG-05): if emit is called recursively
+   * beyond `maxDepth`, the event is dropped and an error is logged.
+   * This prevents infinite loops from circular emit/listen chains.
+   */
+  emit(type, payload, source, routingKey) {
+    if (this.depth >= this.maxDepth) {
+      log.error("circular event loop dropped", { type, depth: this.depth, maxDepth: this.maxDepth });
+      return;
+    }
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now(),
+      source
+    };
+    const deliveryKey = routingKey ?? type;
+    const primary = this.listeners.get(deliveryKey);
+    const secondary = routingKey !== void 0 && routingKey !== type ? this.listeners.get(type) : void 0;
+    const listenerCount = (primary?.size ?? 0) + (secondary?.size ?? 0);
+    if (listenerCount > 0) {
+      log.debug("emit", { type, listenerCount, depth: this.depth });
+    } else {
+      log.debug("emit no listeners", { type });
+    }
+    this.depth++;
+    try {
+      const delivered = /* @__PURE__ */ new Set();
+      const deliverTo = (set) => {
+        if (!set) return;
+        for (const listener of Array.from(set)) {
+          if (delivered.has(listener)) continue;
+          delivered.add(listener);
+          try {
+            listener(event);
+          } catch (error) {
+            log.error("listener threw", { type, error: error instanceof Error ? error : String(error) });
+          }
+        }
+      };
+      deliverTo(primary);
+      deliverTo(secondary);
+      if (type !== "*") {
+        const wildcardListeners = this.listeners.get("*");
+        if (wildcardListeners) {
+          for (const listener of Array.from(wildcardListeners)) {
+            try {
+              listener(event);
+            } catch (error) {
+              log.error("wildcard listener threw", { error: error instanceof Error ? error : String(error) });
+            }
+          }
+        }
+      }
+    } finally {
+      this.depth--;
+    }
+  }
+  /**
+   * Subscribe to an event type
+   */
+  on(type, listener) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.listeners.get(type);
+    listeners.add(listener);
+    log.debug("subscribe", { type, total: listeners.size });
+    return () => {
+      listeners.delete(listener);
+      log.debug("unsubscribe", { type, remaining: listeners.size });
+      if (listeners.size === 0) {
+        this.listeners.delete(type);
+      }
+    };
+  }
+  /**
+   * Subscribe to ALL events (wildcard listener)
+   * Useful for event tracking, logging, debugging
+   */
+  onAny(listener) {
+    return this.on("*", listener);
+  }
+  /**
+   * Check if there are listeners for an event type
+   */
+  hasListeners(type) {
+    const listeners = this.listeners.get(type);
+    return listeners !== void 0 && listeners.size > 0;
+  }
+  /**
+   * Get all registered event types
+   */
+  getRegisteredEvents() {
+    return Array.from(this.listeners.keys());
+  }
+  /**
+   * Clear all listeners
+   */
+  clear() {
+    log.debug("clear", { eventTypeCount: this.listeners.size });
+    this.listeners.clear();
+  }
+  /**
+   * Get listener count for an event type (for testing)
+   */
+  getListenerCount(type) {
+    return this.listeners.get(type)?.size ?? 0;
+  }
+};
+function createEventBus(options) {
+  return new EventBus(options);
+}
+
+export { EventBus, createEventBus };

package/dist/chunk-SWPDU752.js

@@ -0,0 +1,28 @@
+import { isJsonObject } from '@almadar/core';
+
+// src/credentials/seed.ts
+function planRows(json) {
+  const rows = JSON.parse(json);
+  if (!Array.isArray(rows)) throw new Error("the kernel seed plan is not a list");
+  return rows.map((row) => {
+    if (!isJsonObject(row) || typeof row.service !== "string" || typeof row.envVar !== "string") {
+      throw new Error("the kernel seed plan holds a row that is not { service, envVar }");
+    }
+    return { service: row.service, envVar: row.envVar };
+  });
+}
+async function seedCredentialStore(store, declared, env, kernel) {
+  if (!store.enabled) return 0;
+  const names = [...new Set(declared.map((d) => d.envVar))];
+  const held = names.filter((name) => store.resolve(name) !== void 0);
+  const present = names.filter((name) => (env[name] ?? "") !== "");
+  const plan = planRows(kernel.credentialSeedPlan(JSON.stringify(declared), JSON.stringify(held), JSON.stringify(present)));
+  for (const { service, envVar } of plan) {
+    const value = env[envVar];
+    if (value === void 0) throw new Error(`the kernel seeded ${envVar}, which the env does not hold`);
+    await store.set(service, envVar, value);
+  }
+  return plan.length;
+}
+
+export { seedCredentialStore };

package/dist/chunk-T775TUCD.js

@@ -0,0 +1,18 @@
+// src/runtime/entities/seedBrowserStore.ts
+async function isEmpty(store, entityType) {
+  return store.countRows ? await store.countRows(entityType) === 0 : (await store.list(entityType)).length === 0;
+}
+async function seedBrowserStore(store, entities, locale, host) {
+  const empty = [];
+  for (const entity of entities) {
+    if (entity.browser === true && await isEmpty(store, entity.name)) empty.push(entity);
+  }
+  if (empty.length === 0) return;
+  const program = {
+    name: "BrowserStoreSeed",
+    orbitals: empty.map((entity, index) => ({ name: `BrowserStore${index}`, entity, traits: [], pages: [] }))
+  };
+  await host.seeder.dataset(program, { nowMs: host.nowMs, ...locale !== void 0 ? { locale } : {} });
+}
+
+export { seedBrowserStore };

package/dist/chunk-UBN5JJKZ.js

@@ -0,0 +1,26 @@
+// src/service/service-provider.ts
+var ServiceCallError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ServiceCallError";
+  }
+  code;
+};
+var providers = /* @__PURE__ */ new Map();
+function registerServiceProvider(service, provider) {
+  providers.set(service, provider);
+}
+function unregisterServiceProvider(service) {
+  providers.delete(service);
+}
+function registeredServices() {
+  return [...providers.keys()];
+}
+async function callRegisteredService(service, action, params, context) {
+  const provider = providers.get(service);
+  if (provider === void 0) throw new Error(`Unknown integration: ${service}`);
+  return provider(action, params ?? {}, context);
+}
+
+export { ServiceCallError, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider };

package/dist/chunk-UJHOUZAL.js

@@ -0,0 +1,36 @@
+import { storesRowsInBrowser } from '@almadar/core';
+
+// src/runtime/evaluation/residence-transport.ts
+function createResidenceTransport(options) {
+  const { local, remote, traitIndex } = options;
+  const browserStored = new Set(traitIndex.allEntities.filter(storesRowsInBrowser).map((e) => e.name));
+  const route = (orbitalName, request) => {
+    if (request.residence === "browser") return local;
+    if (request.residence === "server") {
+      if (remote === void 0) throw new Error(`residence: a ${orbitalName} ${request.event} leg needs server data, and this host has no server`);
+      return remote;
+    }
+    return remote ?? local;
+  };
+  return {
+    async register(schema) {
+      const result = await local.register(schema);
+      return remote ? remote.register(schema) : result;
+    },
+    async unregister() {
+      await local.unregister();
+      await remote?.unregister();
+    },
+    async send(orbitalName, request) {
+      return route(orbitalName, request).send(orbitalName, request);
+    },
+    async resolveRows(reference) {
+      const owner = browserStored.has(reference.entityType) ? local : remote;
+      if (owner?.resolveRows === void 0) throw new Error(`residence: no transport resolves ${reference.entityType} row sets`);
+      return owner.resolveRows(reference);
+    },
+    ...remote?.subscribe ? { subscribe: remote.subscribe.bind(remote) } : {}
+  };
+}
+
+export { createResidenceTransport };

package/dist/chunk-UP6GGGAN.js

@@ -0,0 +1,34 @@
+import { isPageReference, isRoutePage, themeDataKey } from '@almadar/core';
+
+// src/client/render-sigils.ts
+var DEFAULT_THEME_KEY = "minimalist-light";
+function inlineNavItems(pages) {
+  const items = [];
+  for (const page of pages) {
+    if (isPageReference(page)) continue;
+    const p = page;
+    if (!isRoutePage(p) || typeof p.label !== "string" || p.path.includes(":")) continue;
+    const item = { href: p.path, label: p.label };
+    if (typeof p.icon === "string") item.icon = p.icon;
+    if (p.roles !== void 0) item.roles = [...p.roles];
+    items.push(item);
+  }
+  return items;
+}
+function appNavItems(orbitals) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const orbital of orbitals) {
+    for (const item of inlineNavItems(orbital.pages ?? [])) {
+      if (seen.has(item.href)) continue;
+      seen.add(item.href);
+      items.push(item);
+    }
+  }
+  return items;
+}
+function sigilThemeKey(orbitalTheme, appThemeKey) {
+  return themeDataKey(orbitalTheme) || appThemeKey || DEFAULT_THEME_KEY;
+}
+
+export { DEFAULT_THEME_KEY, appNavItems, inlineNavItems, sigilThemeKey };

package/dist/chunk-VMOBW7RK.js

@@ -0,0 +1,21 @@
+// src/kernel/beacon.ts
+async function deliverBeacon(url, text, ports) {
+  try {
+    if (ports.queue !== void 0 && ports.queue(url, text)) return { via: "queue" };
+  } catch {
+  }
+  try {
+    const { status } = await ports.fetch(url, {
+      method: "POST",
+      body: text,
+      keepalive: true,
+      mode: "cors",
+      headers: { "Content-Type": "text/plain" }
+    });
+    return { via: "fetch", status };
+  } catch {
+    return { via: "fetch", status: null };
+  }
+}
+
+export { deliverBeacon };

package/dist/chunk-VNMG7NKY.js

@@ -0,0 +1,69 @@
+import { defaultCallService } from './chunk-4SEK5ER2.js';
+import { routeByEntity } from './chunk-O57GKTYU.js';
+import { buildTraitIndex } from './chunk-CPSQXEJ6.js';
+import { KernelEngine, evaluateOnKernel } from './chunk-D4XJTBLB.js';
+import { InFlightCalls } from './chunk-MZKIL5IN.js';
+import { createInProcessTransport } from './chunk-QELZ6TEJ.js';
+import { orbitalInlineEntities, storesRowsInBrowser, inlineTraitRefs, applyRowAccess, readableEntitiesOf, externalInputsOf, entityOwnerOrbital } from '@almadar/core';
+import { entityAccessPolicies } from '@almadar/core/mock';
+
+function localStorePersistence(schema, store, memory) {
+  const browserStored = new Set(schema.orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser).map((entity) => entity.name));
+  return routeByEntity(browserStored, store, memory);
+}
+function openLocalKernel(options) {
+  const { schema, persistence } = options;
+  options.kernel.installLanguage(options.language);
+  const callService = options.callService ?? defaultCallService;
+  const engine = KernelEngine.open(options.kernel, { ...schema, orbitals: inlineTraitRefs(schema.orbitals) }, {
+    persistence,
+    callService: (service, action, params, context) => callService(service, action, params, context),
+    programEffect: () => void 0,
+    inFlightCalls: new InFlightCalls(),
+    servicePorts: options.servicePorts ?? ((caller, user, message) => ({
+      caller,
+      message,
+      inputs: () => externalInputsOf(schema),
+      readableEntities: () => readableEntitiesOf(schema),
+      dispatchInput: () => Promise.reject(new Error("a local store host takes no input dispatch")),
+      read: async (entity) => applyRowAccess(await persistence.list(entity), entityAccessPolicies(schema, entity)?.read, void 0, { user }, entity)
+    })),
+    deliverLive: () => void 0,
+    deferCallOutcome: options.deferCallOutcome ?? (() => void 0),
+    ...options.pageFacts !== void 0 ? { pageFacts: options.pageFacts } : {},
+    ...options.http !== void 0 ? { http: options.http } : {},
+    ...options.onDevice !== void 0 ? { onDevice: options.onDevice } : {},
+    ...options.tabs !== void 0 ? { tabs: options.tabs } : {}
+  });
+  if (options.messages !== void 0) engine.setMessages(Object.keys(options.messages), options.messages);
+  engine.setTickMount([...buildTraitIndex(schema.orbitals).byName.keys()]);
+  return engine;
+}
+function createLocalStoreTransport(options) {
+  return createInProcessTransport(
+    async (orbital, request) => evaluateOnKernel(
+      {
+        engine: await options.kernelEngine,
+        orbital,
+        ...options.outsideEventQueue !== void 0 ? { outsideEventQueue: options.outsideEventQueue } : {}
+      },
+      request,
+      await options.user,
+      request.locale
+    ),
+    {
+      carriesCircuitState: false,
+      ...options.schema !== void 0 ? { resolveRows: resolveOn(options, options.schema) } : {}
+    }
+  );
+}
+function resolveOn(options, schema) {
+  return async (reference) => resolveLocalRows(await options.kernelEngine, schema, await options.user, reference);
+}
+function resolveLocalRows(engine, schema, user, reference) {
+  const owner = entityOwnerOrbital(schema, reference.entityType);
+  if (owner === void 0) return Promise.reject(new Error(`${reference.entityType}: no orbital of the local program declares this entity`));
+  return engine.resolveRows(reference, { orbital: owner.name, ...user !== void 0 ? { user } : {} });
+}
+
+export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows };

package/dist/chunk-WNPNNYXY.js

@@ -0,0 +1,22 @@
+import { getStdEffectOperators, getOperatorRunsOn } from '@almadar/std/registry';
+
+// src/runtime/types.ts
+function isEffectTuple(value) {
+  return Array.isArray(value) && typeof value[0] === "string";
+}
+var EFFECT_ALIASES = { render: "render-ui" };
+function withAliases(ops) {
+  const aliases = Object.keys(EFFECT_ALIASES).filter((alias) => ops.includes(EFFECT_ALIASES[alias]));
+  return [...ops, ...aliases].sort();
+}
+function effectsNotOn(site) {
+  return withAliases(getStdEffectOperators().filter((op) => getOperatorRunsOn(op) !== site));
+}
+var HANDLER_MANIFEST = {
+  client: effectsNotOn("server"),
+  server: effectsNotOn("client"),
+  test: withAliases(getStdEffectOperators()),
+  ssr: withAliases(["render-ui", "fetch", "emit", "set", "log", "ref", "deref"])
+};
+
+export { HANDLER_MANIFEST, isEffectTuple };

package/dist/chunk-XB5GYODW.js

@@ -0,0 +1,28 @@
+import { parseListenSource } from './chunk-IHQLE5M7.js';
+import { applyListenMapping, kernelEvaluator, toWireValue } from '@almadar/core';
+
+function listenGuardHolds(guard, payload) {
+  const outcome = kernelEvaluator().evaluateGuard({ payload: toWireValue(payload ?? {}) }, guard);
+  return outcome.kind === "value" && outcome.value;
+}
+function collectListenerTargets(traitIndex, sourceStamp, event, payload) {
+  const targets = [];
+  for (const [listenerName, listenerEntry] of traitIndex.byName) {
+    for (const listener of listenerEntry.traitDef.listens ?? []) {
+      const { bareEvent, matcher } = parseListenSource(listener, listenerEntry.orbitalName);
+      if (bareEvent !== event || !matcher(sourceStamp)) continue;
+      if (listener.guard !== void 0 && !listenGuardHolds(listener.guard, payload)) continue;
+      targets.push({
+        listenerTrait: listenerName,
+        entry: listenerEntry,
+        listener,
+        triggers: listener.triggers,
+        ...listener.triggersId !== void 0 ? { triggersId: listener.triggersId } : {},
+        payload: applyListenMapping(listener.payloadMapping, payload)
+      });
+    }
+  }
+  return targets;
+}
+
+export { collectListenerTargets };

package/dist/chunk-XXWNMJI6.js

@@ -0,0 +1,15 @@
+// src/loader/lazy-page.ts
+async function loadLazyPage(loader, page, importerPath) {
+  const loaded = await loader.load(page.orbRef, importerPath);
+  if (!loaded.success) return loaded;
+  const { schema, sourcePath } = loaded.data;
+  if (!schema.orbitals.some((o) => o.name === page.orbital)) {
+    return {
+      success: false,
+      error: `Lazy page ${page.path} expects orbital "${page.orbital}" in ${sourcePath}, found: ${schema.orbitals.map((o) => o.name).join(", ")}`
+    };
+  }
+  return { success: true, data: schema };
+}
+
+export { loadLazyPage };