@almadar/shell-web 0.1.0 → 1.1.0

package/dist/{chunk-DYEKAA4L.js → chunk-ZDRDJKYB.js}

@@ -3,24 +3,13 @@ import { NativeMemoryPersistenceAdapter } from '@almadar/shell-runtime/persisten
 import * as local_store_transport_star from '@almadar/shell-runtime/runtime/evaluation/local-store-transport';
 import { openLocalKernel as openLocalKernel$1 } from '@almadar/shell-runtime/runtime/evaluation/local-store-transport';
 import { readPageFacts } from '@almadar/shell-browser/page-facts';
-import * as std_mock_seed_star from '@almadar/shell-runtime/runtime/entities/std-mock-seed';
-import { orbitalInlineEntities, storesRowsInBrowser, parseOrbitalSchema, isRoutePage, applyRowAccess, readableEntitiesOf, externalInputsOf, tickEventKey } from '@almadar/core';
-import { entityAccessPolicies } from '@almadar/core/mock';
+import { instancesForLocale, orbitalInlineEntities, storesRowsInBrowser, isRoutePage, tickEventKey, isJsonObject } from '@almadar/core';
+import { createLogger, isLogLevelEnabled } from '@almadar/logger';
+import { HostAskError, consentFromRedirect, performHostAnswer, hostAskReturn } from '@almadar/shell-runtime/kernel/host';
 import { dispatchDeclaredInput } from '@almadar/shell-runtime/client/declared-input-dispatch';
 import { IndexedDbPersistence } from '@almadar/shell-browser/storage';
-import * as seedBrowserStore_star from '@almadar/shell-runtime/runtime/entities/seedBrowserStore';
-import * as trait_index_star from '@almadar/shell-runtime/runtime/traits/trait-index';
-import * as TickScheduler_star from '@almadar/shell-runtime/runtime/time/TickScheduler';
-import { createLogger, isLogLevelEnabled } from '@almadar/logger';
-import * as cron_star from '@almadar/shell-runtime/runtime/time/cron';
-import * as duration_star from '@almadar/shell-runtime/runtime/time/duration';
-import * as composition_star from '@almadar/shell-runtime/runtime/effects/composition/index';
-import * as types_star from '@almadar/shell-runtime/runtime/types';
-import * as routing_star from '@almadar/shell-runtime/runtime/events/identity/routing';
-import * as listen_targets_star from '@almadar/shell-runtime/runtime/traits/listen-targets';
-import * as OrbitalTraitParsing_star from '@almadar/shell-runtime/runtime/traits/OrbitalTraitParsing';
-import * as mockStoreSeed_star from '@almadar/shell-runtime/runtime/entities/mockStoreSeed';
-import * as residence_transport_star from '@almadar/shell-runtime/runtime/evaluation/residence-transport';
+export { eventRouteKey } from '@almadar/shell-runtime/runtime/events/identity/routing';
+export { createResidenceTransport } from '@almadar/shell-runtime/runtime/evaluation/residence-transport';
 
 function hasMemoryStore(kernel) {
   return "MemoryStore" in kernel;
@@ -36,281 +25,334 @@ __export(local_store_transport_exports, {
   openLocalKernel: () => openLocalKernel
 });
 __reExport(local_store_transport_exports, local_store_transport_star);
-function openLocalKernel(options) {
-  return openLocalKernel$1({ ...options, pageFacts: options.pageFacts ?? readPageFacts });
+var POLL_MS = 250;
+function consentByPopup(env) {
+  return async (request) => {
+    const popup = env.open(request.authorizeUrl);
+    if (popup === null) throw new HostAskError("unavailable", "the browser blocked the consent window");
+    for (; ; ) {
+      if (popup.closed) throw new HostAskError("cancelled", "the viewer closed the consent window");
+      let href;
+      try {
+        href = popup.location.href;
+      } catch {
+        href = void 0;
+      }
+      if (href !== void 0 && href !== "about:blank" && new URL(href).origin === env.origin) {
+        popup.close();
+        return consentFromRedirect(href);
+      }
+      await env.wait(POLL_MS);
+    }
+  };
+}
+function browserConsentEnv(win) {
+  return {
+    origin: win.location.origin,
+    open: (url) => win.open(url, "almadar-consent", "popup,width=520,height=720"),
+    wait: (ms) => new Promise((resolve) => win.setTimeout(resolve, ms))
+  };
 }
 
-// src/runtime/entities/std-mock-seed.ts
-var std_mock_seed_exports = {};
-__reExport(std_mock_seed_exports, std_mock_seed_star);
-
-// src/runtime/entities/seed-host.ts
-async function withBrowserSeeder(seeding, use) {
-  const program = await seeding.loadSeedProgram();
-  let opened;
-  const engine = {
-    evaluate: async (orbital, request, scope) => {
-      opened ??= openLocalKernel({
-        kernel: seeding.kernel,
-        language: seeding.language,
-        schema: program,
-        persistence: nativeMemoryPersistence(seeding.kernel)
-      });
-      return opened.evaluate(orbital, request, scope);
-    }
+// src/lib/host-actions.ts
+var log = createLogger("almadar:ui:host-actions");
+var audioHost;
+var signOutHost;
+var signInHost;
+var consentHost;
+function registerHostAudio(host) {
+  audioHost = host;
+  return () => {
+    if (audioHost === host) audioHost = void 0;
   };
-  try {
-    return await use({ seeder: new std_mock_seed_exports.StdMockSeed(engine, (0, std_mock_seed_exports.declaredSeedConfig)(program, seeding.app)), nowMs: Date.now() });
-  } finally {
-    opened?.dispose();
+}
+function registerHostSignOut(host) {
+  signOutHost = host;
+  return () => {
+    if (signOutHost === host) signOutHost = void 0;
+  };
+}
+function registerHostSignIn(host) {
+  signInHost = host;
+  return () => {
+    if (signInHost === host) signInHost = void 0;
+  };
+}
+function registerHostConsent(host) {
+  consentHost = host;
+  return () => {
+    if (consentHost === host) consentHost = void 0;
+  };
+}
+var webHostActions = {
+  get audio() {
+    return audioHost;
+  },
+  get signOut() {
+    return signOutHost;
+  },
+  get signIn() {
+    return signInHost;
+  },
+  get consent() {
+    return consentHost ?? (typeof window === "undefined" ? void 0 : consentByPopup(browserConsentEnv(window)));
   }
+};
+var traceStreams = /* @__PURE__ */ new Map();
+function streamTrace(args, completion, dispatch, source) {
+  const { key, onMessage, failure, trait } = completion;
+  if (key === void 0 || onMessage === void 0) return;
+  const refuse = (error) => {
+    log.error("trace stream refused", { trait, key, error });
+    if (failure !== void 0 && dispatch !== void 0) void dispatch(trait, failure, { error, key, ...completion.entityId !== void 0 ? { entityId: completion.entityId } : {} });
+  };
+  const options = args[0];
+  const named = options !== void 0 && options !== null && isJsonObject(options) ? options["traits"] : void 0;
+  const traits = Array.isArray(named) ? named.flatMap((t) => typeof t === "string" ? [t] : []) : [];
+  if (traits.length === 0) return refuse("program/live trace: name the traits it observes in `traits`");
+  if (source === void 0 || dispatch === void 0) return refuse("program/live trace: this host has no kernel trace to stream");
+  if (traceStreams.has(key)) return refuse(`key ${key} already has a stream open`);
+  traceStreams.set(key, source(traits, (item) => {
+    void dispatch(trait, onMessage, { ...item, key, ...completion.entityId !== void 0 ? { entityId: completion.entityId } : {} }).catch((error) => log.error("trace item return failed", { trait, key, error: error.message }));
+  }));
 }
-async function withForkedSeeder(app, appSchema, loadSeedProgram, persistence, user, use) {
-  const program = await loadSeedProgram();
-  const fork = app.forkProgram(program);
-  try {
-    return await use({ seeder: new std_mock_seed_exports.StdMockSeed(fork, (0, std_mock_seed_exports.declaredSeedConfig)(program, appSchema), user), persistence, nowMs: Date.now() });
-  } finally {
-    fork.dispose();
+function cancelStreams(args) {
+  const named = args[0];
+  const keys = typeof named === "string" ? [named] : Array.isArray(named) ? named.flatMap((k) => typeof k === "string" ? [k] : []) : [];
+  for (const key of keys) {
+    traceStreams.get(key)?.();
+    traceStreams.delete(key);
+  }
+}
+async function answerHostAsk(op, args, completion, dispatch, trace) {
+  if (op === "cancel-call") return cancelStreams(args);
+  if (op === "program/live" && completion?.onMessage !== void 0) return streamTrace(args, completion, dispatch, trace);
+  const outcome = await performHostAnswer(webHostActions, op, args);
+  if ("error" in outcome) log.error("host-ask refused", { op, error: outcome.error, kind: outcome.kind });
+  if (completion === void 0) return;
+  const returned = hostAskReturn(completion, outcome);
+  if (returned === void 0) return;
+  if (dispatch === void 0) {
+    log.error("host-ask has no dispatch to return its answer to", { op, trait: returned.trait, event: returned.event });
+    return;
   }
+  await dispatch(returned.trait, returned.event, returned.entityId !== void 0 ? { ...returned.payload, entityId: returned.entityId } : returned.payload);
 }
 
-// src/runtime/entities/seedBrowserStore.ts
-var seedBrowserStore_exports = {};
-__reExport(seedBrowserStore_exports, seedBrowserStore_star);
-
-// src/runtime/traits/trait-index.ts
-var trait_index_exports = {};
-__reExport(trait_index_exports, trait_index_star);
-
-// src/runtime/time/TickScheduler.ts
-var TickScheduler_exports = {};
-__reExport(TickScheduler_exports, TickScheduler_star);
-
-// src/runtime/time/cron.ts
-var cron_exports = {};
-__reExport(cron_exports, cron_star);
-
-// src/runtime/time/duration.ts
-var duration_exports = {};
-__reExport(duration_exports, duration_star);
-
-// src/runtime/evaluation/browser-store-transport.ts
+// src/runtime/evaluation/local-store-transport.ts
+function openLocalKernel(options) {
+  return openLocalKernel$1({ ...options, pageFacts: options.pageFacts ?? readPageFacts, hostActions: options.hostActions ?? webHostActions });
+}
+async function persistedMemory(kernel, database, entities, locale) {
+  const memory = nativeMemoryPersistence(kernel);
+  const firstVisit = (await database.changes()).length === 0;
+  for (const entity of entities) {
+    if (firstVisit) {
+      for (const row of instancesForLocale(entity, locale)) await database.create(entity.name, row);
+    }
+    for (const row of await database.list(entity.name)) {
+      await memory.writeWhere({ kind: "upsert", entityType: entity.name, data: row });
+    }
+  }
+  const keep = async (entityType, row) => {
+    await database.create(entityType, row);
+  };
+  const mirror = async (op, outcome) => {
+    if (outcome.kind === "created") await keep(op.entityType, outcome.row);
+    else if (outcome.kind === "updated") {
+      if (op.kind === "rekey") await database.delete(op.entityType, op.id);
+      await keep(op.entityType, outcome.row);
+    } else if (outcome.kind === "deleted" && op.kind !== "create" && op.kind !== "upsert") await database.delete(op.entityType, op.id);
+  };
+  return {
+    getById: (entityType, id) => memory.getById(entityType, id),
+    list: (entityType) => memory.list(entityType),
+    queryPage: (entityType, query) => memory.queryPage(entityType, query),
+    queryIds: (entityType, query) => memory.queryIds(entityType, query),
+    queryCapabilities: (entityType) => memory.queryCapabilities(entityType),
+    writeCapabilities: (entityType) => memory.writeCapabilities(entityType),
+    bindCollection: (entityType, collection) => memory.bindCollection(entityType, collection),
+    async create(entityType, data) {
+      const { id } = await memory.create(entityType, data);
+      const row = await memory.getById(entityType, id);
+      if (row !== null) await keep(entityType, row);
+      return { id };
+    },
+    async update(entityType, id, data) {
+      await memory.update(entityType, id, data);
+      const row = await memory.getById(entityType, id);
+      if (row !== null) await keep(entityType, row);
+    },
+    async delete(entityType, id) {
+      await memory.delete(entityType, id);
+      await database.delete(entityType, id);
+    },
+    async writeWhere(op) {
+      const outcome = await memory.writeWhere(op);
+      await mirror(op, outcome);
+      return outcome;
+    },
+    async writeBatch(batch) {
+      const outcomes = await memory.writeBatch(batch);
+      for (const [index, op] of batch.ops.entries()) {
+        const outcome = outcomes[index];
+        if (outcome !== void 0) await mirror(op, outcome);
+      }
+      return outcomes;
+    }
+  };
+}
 function browserStoreName(appName, locale) {
   return locale !== void 0 ? `almadar:${appName}:${locale}` : `almadar:${appName}`;
 }
-async function openBrowserStore(databaseName, orbitals, seeding, factory, locale) {
+async function openBrowserStore(databaseName, orbitals, factory) {
   const entities = orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser);
   if (entities.length === 0) return null;
-  const store = await IndexedDbPersistence.open({
+  return IndexedDbPersistence.open({
     databaseName,
     entityTypes: entities.map((e) => e.name),
     ...factory !== void 0 ? { factory } : {}
   });
-  await withBrowserSeeder(seeding, (host) => (0, seedBrowserStore_exports.seedBrowserStore)(store, entities, locale, host));
-  return store;
+}
+function browserEntities(orbitals) {
+  return orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser);
 }
 async function openBrowserStoreTransport(options) {
-  const stored = await openBrowserStore(options.databaseName, options.schema.orbitals, { kernel: options.kernel, language: options.language, loadSeedProgram: options.loadSeedProgram, app: options.schema }, options.factory, options.locale);
+  const stored = await openBrowserStore(options.databaseName, options.schema.orbitals, options.factory);
   if (stored === null && options.callService === void 0) {
     throw new Error(`openBrowserStoreTransport: schema "${options.schema.name}" declares no browser-stored entity`);
   }
   const memory = nativeMemoryPersistence(options.kernel);
-  const persistence = (0, local_store_transport_exports.localStorePersistence)(options.schema, stored ?? memory, memory);
+  const persistence = (0, local_store_transport_exports.localStorePersistence)(options.schema, stored === null ? memory : await persistedMemory(options.kernel, stored, browserEntities(options.schema.orbitals), options.locale), memory);
   return (0, local_store_transport_exports.createLocalStoreTransport)({
     kernelEngine: openLocalKernel({
       kernel: options.kernel,
-      language: options.language,
       schema: options.schema,
       persistence,
       ...options.callService !== void 0 ? { callService: options.callService } : {},
-      ...options.http !== void 0 ? { http: options.http } : {},
-      ...options.messages !== void 0 ? { messages: options.messages } : {}
-    })
+      ...options.secretPorts !== void 0 ? { secretPorts: options.secretPorts } : {},
+      ...options.os !== void 0 ? { os: options.os } : {},
+      ...options.gpu !== void 0 ? { gpu: options.gpu } : {}
+    }),
+    ...options.locale !== void 0 ? { locale: () => options.locale } : {}
   });
 }
-function openBundledBrowserStore(bundled, kernel, language, loadSeedProgram, locale, callService, messages, http) {
-  const schema = parseOrbitalSchema(bundled);
+function openBundledBrowserStore(schema, kernel, locale, callService, secretPorts, os) {
   return openBrowserStoreTransport({
     databaseName: browserStoreName(schema.name, locale),
     schema,
-    kernel,
-    language,
-    loadSeedProgram,
     ...locale !== void 0 ? { locale } : {},
+    kernel,
     ...callService !== void 0 ? { callService } : {},
-    ...http !== void 0 ? { http } : {},
-    ...messages !== void 0 ? { messages } : {}
+    ...secretPorts !== void 0 ? { secretPorts } : {},
+    ...os !== void 0 ? { os } : {}
   });
 }
 var tickLog = createLogger("almadar:runtime:browser-host:ticks");
 var queueLog = createLogger("almadar:runtime:browser-host:queue");
-function refuseUnhostedTicks(traitIndex) {
-  for (const entry of traitIndex.byName.values()) {
-    for (const tick of entry.irTrait.ticks ?? []) {
-      if (tick.interval === "frame") {
-        throw new Error(`openBrowserHost has no frame clock; ${entry.orbitalName}.${entry.traitDef.name} tick '${tick.name}' runs every frame`);
-      }
-    }
-  }
-}
+var TICK_PASS_MS = 16;
 async function openBrowserHost(options) {
-  const browserStore = await openBrowserStore(options.databaseName, options.schema.orbitals, { kernel: options.kernel, language: options.language, loadSeedProgram: options.loadSeedProgram, app: options.schema }, options.factory, options.locale);
+  const browserStore = await openBrowserStore(options.databaseName, options.schema.orbitals, options.factory);
   const memory = nativeMemoryPersistence(options.kernel);
-  const persistence = (0, local_store_transport_exports.localStorePersistence)(options.schema, browserStore ?? memory, memory);
-  const traitIndex = (0, trait_index_exports.buildTraitIndex)(options.schema.orbitals);
-  refuseUnhostedTicks(traitIndex);
+  const persistence = (0, local_store_transport_exports.localStorePersistence)(options.schema, browserStore === null ? memory : await persistedMemory(options.kernel, browserStore, browserEntities(options.schema.orbitals), options.locale), memory);
   const { schema } = options;
   let transport;
   const listeners = /* @__PURE__ */ new Set();
-  let turns = 0;
-  const lane = [];
-  let pumping = false;
-  let running;
-  const pump = async () => {
-    if (pumping) return;
-    pumping = true;
-    for (let grant = lane.shift(); grant !== void 0; grant = lane.shift()) {
-      await new Promise(grant);
-    }
-    pumping = false;
-  };
-  const take = (turn) => new Promise((taken) => {
-    queueLog.debug("queue:wait", { turn: turn.id, running: running?.id });
-    turn.lane.push((free) => {
-      turn.held = true;
-      running = turn;
-      queueLog.debug("queue:take", { turn: turn.id });
-      turn.release = () => {
-        queueLog.debug("queue:release", { turn: turn.id });
-        turn.held = false;
-        if (running === turn) running = void 0;
-        free();
-      };
-      taken();
-    });
-    void pump();
-  });
-  const enqueue = async (lane2, work) => {
-    const turn = { id: ++turns, lane: lane2, held: false, done: false, release: () => void 0 };
-    await take(turn);
-    try {
-      return await work();
-    } finally {
-      turn.done = true;
-      if (turn.held) turn.release();
-    }
-  };
-  const serially = (work) => enqueue(lane, work);
-  const outsideEventQueue = async (work) => {
-    const turn = running;
-    queueLog.debug("queue:outside", { turn: turn?.id, held: turn?.held });
-    if (turn === void 0 || !turn.held) return work();
-    turn.release();
-    try {
-      return await work();
-    } finally {
-      await take(turn);
-    }
-  };
-  const servicePorts = (caller, user, message) => {
-    const lentBy = running;
+  const servicePorts = (caller, user, message, assertReentry) => {
     return {
       caller,
-      inputs: () => externalInputsOf(schema),
-      readableEntities: () => readableEntitiesOf(schema),
+      inputs: () => kernelEngine.externalInputs(),
+      readableEntities: () => kernelEngine.readableEntities(),
       dispatchInput: (orbital, request) => {
         const host = transport;
         if (!host) return Promise.reject(new Error("openBrowserHost: the host is not open yet"));
-        const send = (o, r) => lentBy !== void 0 && lentBy.held && !lentBy.done ? host.send(o, r) : serially(() => host.send(o, r));
-        return dispatchDeclaredInput(schema, orbital, { ...request, ...user !== void 0 ? { user } : {} }, async (o, r) => {
-          const response = await send(o, r);
+        assertReentry?.();
+        return dispatchDeclaredInput(kernelEngine, orbital, request, async (o, r) => {
+          const response = await host.send(o, r);
           for (const listener of listeners) listener(o, r, response);
           return response;
         });
       },
-      read: async (entity) => applyRowAccess(await persistence.list(entity), entityAccessPolicies(schema, entity)?.read, void 0, { user }, entity),
+      read: async (entity) => kernelEngine.readRows(entity, await persistence.list(entity), user),
       message
     };
   };
   let deferred;
   const kernelEngine = openLocalKernel({
     kernel: options.kernel,
-    language: options.language,
     schema,
     persistence,
     callService: options.callService,
     servicePorts,
     deferCallOutcome: () => deferred,
-    ...options.http !== void 0 ? { http: options.http } : {},
+    ...options.secretPorts !== void 0 ? { secretPorts: options.secretPorts } : {},
     ...options.onDevice !== void 0 ? { onDevice: options.onDevice } : {},
-    ...options.tabs !== void 0 ? { tabs: options.tabs } : {}
+    ...options.tabs !== void 0 ? { tabs: options.tabs } : {},
+    ...options.os !== void 0 ? { os: options.os } : {},
+    ...options.gpu !== void 0 ? { gpu: options.gpu } : {}
   });
-  const local = (0, local_store_transport_exports.createLocalStoreTransport)({ kernelEngine, outsideEventQueue });
+  const local = (0, local_store_transport_exports.createLocalStoreTransport)({ kernelEngine });
   transport = local;
   deferred = (call) => {
     const request = {
       event: call.event,
       ...call.payload !== void 0 ? { payload: call.payload } : {},
+      ...call.heldPayload !== void 0 ? { heldPayload: call.heldPayload } : {},
       targetTrait: call.traitName,
       ...call.entityId !== void 0 ? { entityId: call.entityId } : {},
       ...call.originClientId !== void 0 ? { clientId: call.originClientId } : {},
-      ...call.user !== void 0 ? { user: call.user } : {},
       ...call.locale !== void 0 ? { locale: call.locale } : {}
     };
-    void serially(async () => {
-      const response = await local.send(call.orbital, request);
+    void local.send(call.orbital, request).then((response) => {
       for (const listener of listeners) listener(call.orbital, request, response);
     }).catch((error) => {
       queueLog.error("deferred-outcome:failed", { orbital: call.orbital, event: call.event, trait: call.traitName, error: error.message });
     });
   };
-  const scheduler = (0, TickScheduler_exports.createTickScheduler)();
-  const tickHandles = [];
-  for (const entry of traitIndex.byName.values()) {
-    for (const tick of entry.irTrait.ticks ?? []) {
-      let firing = false;
-      const fire = () => {
-        if (firing) return;
-        firing = true;
-        const request = {
-          event: tickEventKey(tick.name),
-          runTick: { trait: entry.traitDef.name, tick: tick.name },
-          targetTrait: entry.traitDef.name,
-          tick: tick.name
-        };
-        void serially(async () => {
-          const response = await local.send(entry.orbitalName, request);
-          if (response.transitioned) for (const listener of listeners) listener(entry.orbitalName, request, response);
-        }).catch((error) => {
-          tickLog.error("tick:failed", { orbital: entry.orbitalName, trait: entry.traitDef.name, tick: tick.name, error: error.message });
-        }).finally(() => {
-          firing = false;
-        });
-      };
-      tickHandles.push(
-        typeof tick.interval === "string" && (0, cron_exports.isValidCronExpression)(tick.interval) ? scheduler.addCron(tick.interval, fire) : scheduler.add(typeof tick.interval === "number" ? tick.interval : (0, duration_exports.parseDurationString)(tick.interval), fire)
-      );
+  const runnable = /* @__PURE__ */ new Map();
+  for (const trait of kernelEngine.programSurface().traits) {
+    for (const tick of trait.ticks) {
+      runnable.set(`${trait.name}::${tick.name}`, { orbitalName: trait.orbital, traitName: trait.name, tickName: tick.name });
     }
   }
+  const firing = /* @__PURE__ */ new Set();
+  const fire = (key, tick) => {
+    if (firing.has(key)) return;
+    firing.add(key);
+    const request = {
+      event: tickEventKey(tick.tickName),
+      runTick: { trait: tick.traitName, tick: tick.tickName },
+      targetTrait: tick.traitName,
+      tick: tick.tickName
+    };
+    void local.send(tick.orbitalName, request).then((response) => {
+      if (response.transitioned) for (const listener of listeners) listener(tick.orbitalName, request, response);
+    }).catch((error) => {
+      tickLog.error("tick:failed", { orbital: tick.orbitalName, trait: tick.traitName, tick: tick.tickName, error: error.message });
+    }).finally(() => {
+      firing.delete(key);
+    });
+  };
+  const timer = runnable.size === 0 ? void 0 : setInterval(() => {
+    for (const due of Object.values(kernelEngine.tickPass(performance.now())).flat()) {
+      const key = `${due.trait}::${due.tick}`;
+      const tick = runnable.get(key);
+      if (tick !== void 0) fire(key, tick);
+    }
+  }, TICK_PASS_MS);
   return {
     ...local,
-    send: (orbitalName, request) => serially(() => local.send(orbitalName, request)),
     onInputDispatched(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
     routeMounts: (routePath) => kernelEngine.routeMounts(routePath),
     close() {
-      for (const handle of tickHandles) handle.stop();
+      if (timer !== void 0) clearInterval(timer);
     }
   };
 }
 
-// src/runtime/effects/composition/index.ts
-var composition_exports = {};
-__reExport(composition_exports, composition_star);
-
 // src/runtime/ui/contract-errors.ts
 var RendererContractViolationError = class extends Error {
   constructor(message) {
@@ -447,20 +489,6 @@ function buildOrbitalsByTrait(schema, resolvedPages = []) {
   return map;
 }
 
-// src/runtime/ui/traitLinkedEntities.ts
-function buildTraitLinkedEntities(ir) {
-  const map = /* @__PURE__ */ new Map();
-  for (const page of ir.pages.values()) {
-    for (const binding of page.traits) {
-      if (binding.linkedEntity) map.set(binding.trait.name, binding.linkedEntity);
-    }
-  }
-  for (const trait of ir.traits.values()) {
-    if (trait.linkedEntity && !map.has(trait.name)) map.set(trait.name, trait.linkedEntity);
-  }
-  return map;
-}
-
 // src/runtime/ui/embedded-traits.ts
 var TRAIT_BINDING_PREFIX = "@trait.";
 function collectTraitRefsFromValue(value, into) {
@@ -499,19 +527,6 @@ function collectTraitRefsFromEffects(effects, into) {
     }
   }
 }
-function collectTraitRefsFromResolvedTrait(trait) {
-  const out = /* @__PURE__ */ new Set();
-  for (const transition of trait.transitions ?? []) {
-    collectTraitRefsFromEffects(transition.effects, out);
-  }
-  for (const tick of trait.ticks ?? []) {
-    collectTraitRefsFromEffects(tick.effects, out);
-  }
-  for (const field of Object.values(trait.config ?? {})) {
-    if (field.default !== void 0) collectTraitRefsFromValue(field.default, out);
-  }
-  return out;
-}
 function collectEmbeddedTraits(schema) {
   const out = /* @__PURE__ */ new Set();
   if (!schema?.orbitals) return out;
@@ -545,7 +560,7 @@ function collectEmbeddedTraits(schema) {
   return out;
 }
 var PERF_NAMESPACE = "almadar:perf:canvas";
-var log = createLogger(PERF_NAMESPACE);
+var log2 = createLogger(PERF_NAMESPACE);
 var RING_SIZE = 50;
 var ring = [];
 var writeIdx = 0;
@@ -604,7 +619,7 @@ function perfEnd(name, startToken, detail) {
   }
   push({ name, durationMs, ts: endTs, detail });
   aggregate(name, durationMs);
-  if (isVerbose()) log.debug(name, () => ({ durationMs, ...detail ?? {} }));
+  if (isVerbose()) log2.debug(name, () => ({ durationMs, ...detail ?? {} }));
 }
 function perfTime(name, fn, detail) {
   const t = perfStart(name);
@@ -651,7 +666,7 @@ function dumpSummary() {
     avgMs: Math.round(b.totalMs / b.count * 100) / 100,
     maxMs: Math.round(b.maxMs * 10) / 10
   })).sort((a, b) => b.totalMs - a.totalMs);
-  log.warn("[PROFILE] summary", { phases: JSON.stringify(rows) });
+  log2.warn("[PROFILE] summary", { phases: JSON.stringify(rows) });
   buckets.clear();
 }
 function getPerfSnapshot() {
@@ -684,7 +699,7 @@ var perfStore = {
   subscribe,
   getSnapshot
 };
-var log2 = createLogger("almadar:runtime:verify");
+var log3 = createLogger("almadar:runtime:verify");
 var MAX_EVENT_LOG = 200;
 var EMPTY_SUMMARY = {
   totalChecks: 0,
@@ -726,7 +741,7 @@ function bindEventBus(eventBus) {
   if (!api) return;
   api.sendEvent = (event, payload, traitScope) => {
     const prefixed = event.startsWith("UI:") ? event : traitScope ? `UI:${traitScope}.${event}` : `UI:${event}`;
-    log2.debug("sendEvent", {
+    log3.debug("sendEvent", {
       event: prefixed,
       traitScope,
       payloadKeys: payload ? Object.keys(payload) : []
@@ -760,28 +775,4 @@ function bindTraitStateGetter(getter) {
   api.getTraitState = getter;
 }
 
-// src/runtime/types.ts
-var types_exports = {};
-__reExport(types_exports, types_star);
-
-// src/runtime/events/identity/routing.ts
-var routing_exports = {};
-__reExport(routing_exports, routing_star);
-
-// src/runtime/traits/listen-targets.ts
-var listen_targets_exports = {};
-__reExport(listen_targets_exports, listen_targets_star);
-
-// src/runtime/traits/OrbitalTraitParsing.ts
-var OrbitalTraitParsing_exports = {};
-__reExport(OrbitalTraitParsing_exports, OrbitalTraitParsing_star);
-
-// src/runtime/entities/mockStoreSeed.ts
-var mockStoreSeed_exports = {};
-__reExport(mockStoreSeed_exports, mockStoreSeed_star);
-
-// src/runtime/evaluation/residence-transport.ts
-var residence_transport_exports = {};
-__reExport(residence_transport_exports, residence_transport_star);
-
-export { OrbitalTraitParsing_exports, PERF_NAMESPACE, RendererContractViolationError, TickScheduler_exports, aggregateSlotContent, assertIsMultiSourceSlotManager, assertIsSlotManager, bindEventBus, bindTraitStateGetter, browserStoreName, buildOrbitalsByTrait, buildTraitLinkedEntities, clearPerf, collectEmbeddedTraits, collectTraitRefsFromResolvedTrait, composition_exports, createSlotSetter, cron_exports, duration_exports, ensureVerificationApi, getOrbitalVerification, listen_targets_exports, local_store_transport_exports, mockStoreSeed_exports, nativeMemoryPersistence, openBrowserHost, openBrowserStore, openBrowserStoreTransport, openBundledBrowserStore, openLocalKernel, perfEnd, perfGauge, perfStart, perfStore, perfTime, perfTimeAsync, pushPerfEntry, residence_transport_exports, routing_exports, seedBrowserStore_exports, std_mock_seed_exports, trait_index_exports, types_exports, validateSlotContent, withBrowserSeeder, withForkedSeeder, wrapCallbackForEvent };
+export { PERF_NAMESPACE, RendererContractViolationError, aggregateSlotContent, answerHostAsk, assertIsMultiSourceSlotManager, assertIsSlotManager, bindEventBus, bindTraitStateGetter, browserStoreName, buildOrbitalsByTrait, clearPerf, collectEmbeddedTraits, createSlotSetter, ensureVerificationApi, getOrbitalVerification, local_store_transport_exports, nativeMemoryPersistence, openBrowserHost, openBrowserStore, openBrowserStoreTransport, openBundledBrowserStore, openLocalKernel, perfEnd, perfGauge, perfStart, perfStore, perfTime, perfTimeAsync, persistedMemory, pushPerfEntry, registerHostAudio, registerHostConsent, registerHostSignIn, registerHostSignOut, validateSlotContent, webHostActions, wrapCallbackForEvent };