@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-DYEKAA4L.js

@@ -0,0 +1,787 @@
+import { __export, __reExport } from './chunk-G7DCAZ22.js';
+import { NativeMemoryPersistenceAdapter } from '@almadar/shell-runtime/persistence/native-memory';
+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 { 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';
+
+function hasMemoryStore(kernel) {
+  return "MemoryStore" in kernel;
+}
+function nativeMemoryPersistence(kernel) {
+  if (!hasMemoryStore(kernel)) throw new Error("nativeMemoryPersistence: this kernel module exports no MemoryStore; install a kernel build that carries it");
+  return new NativeMemoryPersistenceAdapter(new kernel.MemoryStore());
+}
+
+// src/runtime/evaluation/local-store-transport.ts
+var local_store_transport_exports = {};
+__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 });
+}
+
+// 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);
+    }
+  };
+  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();
+  }
+}
+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();
+  }
+}
+
+// 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
+function browserStoreName(appName, locale) {
+  return locale !== void 0 ? `almadar:${appName}:${locale}` : `almadar:${appName}`;
+}
+async function openBrowserStore(databaseName, orbitals, seeding, factory, locale) {
+  const entities = orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser);
+  if (entities.length === 0) return null;
+  const store = await 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;
+}
+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);
+  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);
+  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 } : {}
+    })
+  });
+}
+function openBundledBrowserStore(bundled, kernel, language, loadSeedProgram, locale, callService, messages, http) {
+  const schema = parseOrbitalSchema(bundled);
+  return openBrowserStoreTransport({
+    databaseName: browserStoreName(schema.name, locale),
+    schema,
+    kernel,
+    language,
+    loadSeedProgram,
+    ...locale !== void 0 ? { locale } : {},
+    ...callService !== void 0 ? { callService } : {},
+    ...http !== void 0 ? { http } : {},
+    ...messages !== void 0 ? { messages } : {}
+  });
+}
+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`);
+      }
+    }
+  }
+}
+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 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 { 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;
+    return {
+      caller,
+      inputs: () => externalInputsOf(schema),
+      readableEntities: () => readableEntitiesOf(schema),
+      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);
+          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),
+      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.onDevice !== void 0 ? { onDevice: options.onDevice } : {},
+    ...options.tabs !== void 0 ? { tabs: options.tabs } : {}
+  });
+  const local = (0, local_store_transport_exports.createLocalStoreTransport)({ kernelEngine, outsideEventQueue });
+  transport = local;
+  deferred = (call) => {
+    const request = {
+      event: call.event,
+      ...call.payload !== void 0 ? { payload: call.payload } : {},
+      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);
+      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)
+      );
+    }
+  }
+  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();
+    }
+  };
+}
+
+// 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) {
+    super(message);
+    this.name = "RendererContractViolationError";
+  }
+};
+
+// src/runtime/ui/slots.ts
+function aggregateSlotContent(slot, sources) {
+  const entries = Array.from(sources.values());
+  if (entries.length === 0) return void 0;
+  if (entries.length === 1) return entries[0];
+  Array.from(sources.keys());
+  const children = entries.map((entry) => ({
+    type: entry.pattern?.type ?? "box",
+    ...entry.props
+  }));
+  return {
+    slot,
+    pattern: { type: "stack", direction: "vertical", gap: "lg", children },
+    props: { direction: "vertical", gap: "lg", children },
+    source: entries[0].source
+  };
+}
+function isNonNullObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function assertHasFunctionMethods(label, value, methods) {
+  for (const method of methods) {
+    if (typeof value[method] !== "function") {
+      throw new RendererContractViolationError(`${label}.${method} must be a function`);
+    }
+  }
+}
+function assertIsSlotManager(value) {
+  if (!isNonNullObject(value)) {
+    throw new RendererContractViolationError("SlotManager must be a non-null object");
+  }
+  assertHasFunctionMethods("SlotManager", value, [
+    "getContent",
+    "setContent",
+    "clearSlot",
+    "getAllSlots",
+    "subscribe"
+  ]);
+}
+function assertIsMultiSourceSlotManager(value) {
+  if (!isNonNullObject(value)) {
+    throw new RendererContractViolationError("MultiSourceSlotManager must be a non-null object");
+  }
+  assertHasFunctionMethods("SlotManager", value, [
+    "getContent",
+    "setContent",
+    "clearSlot",
+    "getAllSlots",
+    "subscribe"
+  ]);
+  assertHasFunctionMethods("MultiSourceSlotManager", value, [
+    "getTraitContent",
+    "subscribeTrait",
+    "updateTraitContent"
+  ]);
+}
+function validateSlotContent(content) {
+  const errors = [];
+  if (content.slot === void 0 || content.slot === null) {
+    errors.push({ message: "SlotContent.slot is required", path: "slot" });
+  }
+  if (!("pattern" in content)) {
+    errors.push({ message: "SlotContent.pattern is required", path: "pattern" });
+  }
+  return errors;
+}
+function createSlotSetter(manager) {
+  return {
+    addPattern: (slot, pattern, props) => {
+      manager.setContent({
+        slot,
+        pattern,
+        props
+      });
+    },
+    clearSlot: (slot) => {
+      manager.clearSlot(slot);
+    }
+  };
+}
+
+// src/runtime/ui/wrapCallbackForEvent.ts
+function wrapCallbackForEvent(qualifiedEvent, callbackArgs, emit) {
+  const argNames = (callbackArgs ?? []).map((a) => a.name);
+  if (argNames.length === 0) {
+    return () => emit(qualifiedEvent);
+  }
+  return (...args) => {
+    const payload = {};
+    for (let i = 0; i < argNames.length; i += 1) {
+      payload[argNames[i]] = args[i];
+    }
+    emit(qualifiedEvent, payload);
+  };
+}
+function buildOrbitalsByTrait(schema, resolvedPages = []) {
+  const map = {};
+  if (!schema?.orbitals) return map;
+  const pagePathToOrbital = {};
+  for (const orb of schema.orbitals) {
+    for (const traitRef of orb.traits ?? []) {
+      let traitName;
+      if (typeof traitRef === "string") {
+        const parts = traitRef.split(".");
+        traitName = parts[parts.length - 1];
+      } else if ("ref" in traitRef && typeof traitRef.ref === "string") {
+        const parts = traitRef.ref.split(".");
+        traitName = traitRef.name ?? parts[parts.length - 1];
+      } else if ("name" in traitRef && typeof traitRef.name === "string") {
+        traitName = traitRef.name;
+      }
+      if (traitName) map[traitName] = orb.name;
+    }
+    for (const pg of orb.pages ?? []) {
+      const path = typeof pg === "string" ? pg : isRoutePage(pg) ? pg.path : void 0;
+      if (path) pagePathToOrbital[path] = orb.name;
+    }
+  }
+  for (const page of resolvedPages) {
+    const orbital = page.path ? pagePathToOrbital[page.path] : void 0;
+    if (!orbital) continue;
+    for (const traitName of page.traitNames) {
+      if (traitName && !(traitName in map)) map[traitName] = orbital;
+    }
+  }
+  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) {
+  if (value === null || value === void 0) return;
+  if (typeof value === "string") {
+    if (value.startsWith(TRAIT_BINDING_PREFIX)) {
+      const rest = value.slice(TRAIT_BINDING_PREFIX.length);
+      const dot = rest.indexOf(".");
+      const traitName = dot === -1 ? rest : rest.slice(0, dot);
+      if (traitName.length > 0) into.add(traitName);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectTraitRefsFromValue(item, into);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const v of Object.values(value)) {
+      collectTraitRefsFromValue(v, into);
+    }
+  }
+}
+function collectTraitRefsFromEffects(effects, into) {
+  if (!effects) return;
+  for (const effect of effects) {
+    if (!Array.isArray(effect)) continue;
+    if (effect[0] === "render-ui" && effect.length >= 3) {
+      collectTraitRefsFromValue(effect[2], into);
+      continue;
+    }
+    for (let i = 1; i < effect.length; i++) {
+      const arg = effect[i];
+      if (Array.isArray(arg)) collectTraitRefsFromEffects([arg], into);
+      else collectTraitRefsFromValue(arg, 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;
+  for (const orbital of schema.orbitals) {
+    const traits = orbital.traits;
+    if (!Array.isArray(traits)) continue;
+    for (const traitRef of traits) {
+      if (!traitRef || typeof traitRef !== "object") continue;
+      const resolved = traitRef._resolved;
+      const target = resolved && typeof resolved === "object" ? resolved : traitRef;
+      if (typeof traitRef !== "string" && "config" in traitRef && traitRef.config) {
+        collectTraitRefsFromValue(traitRef.config, out);
+      }
+      if (target.config) {
+        collectTraitRefsFromValue(target.config, out);
+      }
+      const transitions = target.stateMachine?.transitions;
+      if (!Array.isArray(transitions)) continue;
+      for (const t of transitions) {
+        collectTraitRefsFromEffects(t.effects, out);
+      }
+      collectTraitRefsFromEffects(target.initialEffects, out);
+      const ticks = target.ticks;
+      if (Array.isArray(ticks)) {
+        for (const tick of ticks) {
+          collectTraitRefsFromEffects(tick.effects, out);
+        }
+      }
+    }
+  }
+  return out;
+}
+var PERF_NAMESPACE = "almadar:perf:canvas";
+var log = createLogger(PERF_NAMESPACE);
+var RING_SIZE = 50;
+var ring = [];
+var writeIdx = 0;
+var subscribers = /* @__PURE__ */ new Set();
+var notifyScheduled = false;
+var revision = 0;
+var cachedSnapshot = [];
+var cachedRevision = -1;
+function scheduleNotify() {
+  if (notifyScheduled) return;
+  notifyScheduled = true;
+  queueMicrotask(() => {
+    notifyScheduled = false;
+    revision++;
+    for (const fn of subscribers) fn();
+  });
+}
+function push(entry) {
+  if (ring.length < RING_SIZE) {
+    ring.push(entry);
+  } else {
+    ring[writeIdx] = entry;
+  }
+  writeIdx = (writeIdx + 1) % RING_SIZE;
+  scheduleNotify();
+}
+function isEnabled() {
+  return isLogLevelEnabled("DEBUG", PERF_NAMESPACE) || globalThis.__ALMADAR_PERF__ === true;
+}
+function isVerbose() {
+  return isLogLevelEnabled("DEBUG", PERF_NAMESPACE);
+}
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function perfStart(name) {
+  if (!isEnabled()) return -1;
+  if (typeof performance !== "undefined" && typeof performance.mark === "function") {
+    try {
+      performance.mark(`${name}-start`);
+    } catch {
+    }
+  }
+  return now();
+}
+function perfEnd(name, startToken, detail) {
+  if (startToken < 0 || !isEnabled()) return;
+  const endTs = now();
+  const durationMs = endTs - startToken;
+  if (typeof performance !== "undefined" && typeof performance.measure === "function") {
+    try {
+      performance.mark(`${name}-end`);
+      performance.measure(name, `${name}-start`, `${name}-end`);
+    } catch {
+    }
+  }
+  push({ name, durationMs, ts: endTs, detail });
+  aggregate(name, durationMs);
+  if (isVerbose()) log.debug(name, () => ({ durationMs, ...detail ?? {} }));
+}
+function perfTime(name, fn, detail) {
+  const t = perfStart(name);
+  try {
+    return fn();
+  } finally {
+    perfEnd(name, t, detail);
+  }
+}
+async function perfTimeAsync(name, fn) {
+  const t = perfStart(name);
+  try {
+    return await fn();
+  } finally {
+    perfEnd(name, t);
+  }
+}
+function perfGauge(name, value) {
+  if (!isEnabled()) return;
+  aggregate(name, value);
+}
+var buckets = /* @__PURE__ */ new Map();
+var dumpTimer = null;
+function aggregate(name, ms) {
+  const b = buckets.get(name);
+  if (b) {
+    b.count++;
+    b.totalMs += ms;
+    if (ms > b.maxMs) b.maxMs = ms;
+  } else {
+    buckets.set(name, { count: 1, totalMs: ms, maxMs: ms });
+  }
+  if (dumpTimer === null) {
+    dumpTimer = setInterval(dumpSummary, 5e3);
+    if (typeof dumpTimer === "object" && "unref" in dumpTimer) dumpTimer.unref();
+  }
+}
+function dumpSummary() {
+  if (buckets.size === 0) return;
+  const rows = [...buckets.entries()].map(([name, b]) => ({
+    name,
+    count: b.count,
+    totalMs: Math.round(b.totalMs),
+    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) });
+  buckets.clear();
+}
+function getPerfSnapshot() {
+  if (ring.length < RING_SIZE) return ring.slice();
+  return [...ring.slice(writeIdx), ...ring.slice(0, writeIdx)];
+}
+function getSnapshot() {
+  if (cachedRevision !== revision) {
+    cachedSnapshot = getPerfSnapshot();
+    cachedRevision = revision;
+  }
+  return cachedSnapshot;
+}
+function subscribe(fn) {
+  subscribers.add(fn);
+  return () => {
+    subscribers.delete(fn);
+  };
+}
+function pushPerfEntry(entry) {
+  if (!isEnabled()) return;
+  push(entry);
+}
+function clearPerf() {
+  ring.length = 0;
+  writeIdx = 0;
+  scheduleNotify();
+}
+var perfStore = {
+  subscribe,
+  getSnapshot
+};
+var log2 = createLogger("almadar:runtime:verify");
+var MAX_EVENT_LOG = 200;
+var EMPTY_SUMMARY = {
+  totalChecks: 0,
+  passed: 0,
+  failed: 0,
+  warnings: 0,
+  pending: 0
+};
+function emptySnapshot() {
+  return {
+    checks: [],
+    transitions: [],
+    bridge: null,
+    summary: EMPTY_SUMMARY,
+    traits: []
+  };
+}
+function ensureVerificationApi() {
+  if (typeof window === "undefined") return void 0;
+  if (!window.__orbitalVerification) {
+    window.__orbitalVerification = {
+      getSnapshot: emptySnapshot,
+      getChecks: () => [],
+      getTransitions: () => [],
+      getBridge: () => null,
+      getSummary: () => EMPTY_SUMMARY,
+      waitForTransition: () => Promise.resolve(null),
+      getTraitSnapshots: () => []
+    };
+  }
+  return window.__orbitalVerification;
+}
+function getOrbitalVerification() {
+  if (typeof window === "undefined") return void 0;
+  return window.__orbitalVerification;
+}
+function bindEventBus(eventBus) {
+  const api = ensureVerificationApi();
+  if (!api) return;
+  api.sendEvent = (event, payload, traitScope) => {
+    const prefixed = event.startsWith("UI:") ? event : traitScope ? `UI:${traitScope}.${event}` : `UI:${event}`;
+    log2.debug("sendEvent", {
+      event: prefixed,
+      traitScope,
+      payloadKeys: payload ? Object.keys(payload) : []
+    });
+    eventBus.emit(prefixed, payload);
+  };
+  const eventLog = [];
+  api.eventLog = eventLog;
+  api.clearEventLog = () => {
+    eventLog.length = 0;
+  };
+  if (eventBus.onAny) {
+    const verificationEventLogger = (event) => {
+      if (eventLog.length < MAX_EVENT_LOG) {
+        eventLog.push({
+          type: event.type,
+          payload: event.payload,
+          timestamp: Date.now()
+        });
+      }
+    };
+    Object.defineProperty(verificationEventLogger, "name", {
+      value: "runtime-verify:eventLog"
+    });
+    eventBus.onAny(verificationEventLogger);
+  }
+}
+function bindTraitStateGetter(getter) {
+  const api = ensureVerificationApi();
+  if (!api) return;
+  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 };