@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/chunk-3VZ36ZKO.js

@@ -0,0 +1,775 @@
+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 { 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';
+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;
+}
+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);
+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/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;
+  };
+}
+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 }));
+  }));
+}
+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/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, factory) {
+  const entities = orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser);
+  if (entities.length === 0) return null;
+  return IndexedDbPersistence.open({
+    databaseName,
+    entityTypes: entities.map((e) => e.name),
+    ...factory !== void 0 ? { factory } : {}
+  });
+}
+function browserEntities(orbitals) {
+  return orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser);
+}
+async function openBrowserStoreTransport(options) {
+  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 === 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,
+      schema: options.schema,
+      persistence,
+      ...options.callService !== void 0 ? { callService: options.callService } : {},
+      ...options.secretPorts !== void 0 ? { secretPorts: options.secretPorts } : {},
+      ...options.os !== void 0 ? { os: options.os } : {}
+    }),
+    ...options.locale !== void 0 ? { locale: () => options.locale } : {}
+  });
+}
+function openBundledBrowserStore(schema, kernel, locale, callService, secretPorts, os) {
+  return openBrowserStoreTransport({
+    databaseName: browserStoreName(schema.name, locale),
+    schema,
+    ...locale !== void 0 ? { locale } : {},
+    kernel,
+    ...callService !== void 0 ? { callService } : {},
+    ...secretPorts !== void 0 ? { secretPorts } : {},
+    ...os !== void 0 ? { os } : {}
+  });
+}
+var tickLog = createLogger("almadar:runtime:browser-host:ticks");
+var queueLog = createLogger("almadar:runtime:browser-host:queue");
+var TICK_PASS_MS = 16;
+async function openBrowserHost(options) {
+  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 === null ? memory : await persistedMemory(options.kernel, browserStore, browserEntities(options.schema.orbitals), options.locale), memory);
+  const { schema } = options;
+  let transport;
+  const listeners = /* @__PURE__ */ new Set();
+  const servicePorts = (caller, user, message, assertReentry) => {
+    return {
+      caller,
+      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"));
+        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) => kernelEngine.readRows(entity, await persistence.list(entity), user),
+      message
+    };
+  };
+  let deferred;
+  const kernelEngine = openLocalKernel({
+    kernel: options.kernel,
+    schema,
+    persistence,
+    callService: options.callService,
+    servicePorts,
+    deferCallOutcome: () => deferred,
+    ...options.secretPorts !== void 0 ? { secretPorts: options.secretPorts } : {},
+    ...options.onDevice !== void 0 ? { onDevice: options.onDevice } : {},
+    ...options.tabs !== void 0 ? { tabs: options.tabs } : {},
+    ...options.os !== void 0 ? { os: options.os } : {}
+  });
+  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 } : {},
+      targetTrait: call.traitName,
+      ...call.entityId !== void 0 ? { entityId: call.entityId } : {},
+      ...call.originClientId !== void 0 ? { clientId: call.originClientId } : {},
+      ...call.locale !== void 0 ? { locale: call.locale } : {}
+    };
+    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 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,
+    onInputDispatched(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    routeMounts: (routePath) => kernelEngine.routeMounts(routePath),
+    close() {
+      if (timer !== void 0) clearInterval(timer);
+    }
+  };
+}
+
+// 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/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 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 log2 = 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()) log2.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);
+  log2.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 log3 = 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}`;
+    log3.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;
+}
+
+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 };