@almadar/ui 6.58.0 → 6.61.0

package/dist/chunk-HB3D3HUJ.js

@@ -1,2265 +0,0 @@
-import { useTranslate, useRenderI18n, runTickFrame } from './chunk-N7JIG57B.js';
-import { ALL_SLOTS } from './chunk-VHTJRS2N.js';
-import { LoadingState, ErrorState, UISlotRenderer } from './chunk-I2ZNE5TD.js';
-import { Box } from './chunk-HA7CJWQX.js';
-import { Typography } from './chunk-4ZGXIW3B.js';
-import { beginPending, endPending } from './chunk-I5QOYW2Z.js';
-import { useEventBus } from './chunk-CHNC4UYE.js';
-import { registerTrait, unregisterTrait, perfTimeAsync } from './chunk-KJGVLXEN.js';
-import { bindTraitStateGetter, registerTraitSnapshot, recordTransition, recordingTransport, recordServerResponse } from './chunk-Q47ZN2DW.js';
-import { isNotificationSlot } from './chunk-PEST66PN.js';
-import React, { createContext, useState, useMemo, useEffect, useRef, useCallback, useSyncExternalStore, useContext } from 'react';
-import { schemaToIR, getPage, clearSchemaCache as clearSchemaCache$1, traitsEmbeddedByEvent, traitReferencesCallsitePayload, configReferencesCallsitePayload, TRAIT_MOUNT_ERROR_TESTID, traitsEmbeddedByEffects, applyListenPayloadMapping, buildResolvedTraitConfigs, collectCallsiteCaptureChildren, orbitalInlineEntities, storesRowsInBrowser, walkSExpr, isRenderBindingMarker, containsEntityBinding, isSExpr, isEventPayloadValue, RENDER_BINDING_MARKER } from '@almadar/core';
-import { createLogger } from '@almadar/logger';
-import { collectListenerTargets, LIFECYCLE_EVENTS, TraitMountError, loadLazyPage, createInProcessTransport, buildTraitIndex, createMemoryCircuitStore, createLocalStoreTransport, createResidenceTransport, createClientKernel, createTickScheduler, isValidCronExpression, parseDurationString, UNMOUNT_EVENT, createClientEffectHandlers, EffectExecutor, isSExpression, collectDeclaredConfigDefaults, createContextFromBindings, openBrowserStore, browserStoreName, normalizeCallSiteConfigToValues } from '@almadar/runtime';
-import { useUser, useArbitraryClassStyles, getAllPages, matchPathAmong, CurrentPagePathProvider, NavStackProvider, OrbitalProvider, ServerBridgeProvider, useNavStack, VerificationProvider, EntitySchemaProvider, OrbitalThemeProvider, useServerBridge, EntityBindingContext, AwaitingSkeletonContext } from '@almadar/ui/providers';
-import { evaluateListenPayloadExpr, evaluate, createMinimalContext, evaluateGuard, executeEffects } from '@almadar/evaluator';
-import { getPatternDefinition } from '@almadar/core/patterns';
-import { isKnownStdOperator } from '@almadar/std/registry';
-import { prepareSchemaForPreview, collectTraitRefsFromResolvedTrait, buildOrbitalsByTrait, collectEmbeddedTraits } from '@almadar/runtime/ui';
-export { adjustSchemaForMockData, buildMockData, collectEmbeddedTraits, prepareSchemaForPreview } from '@almadar/runtime/ui';
-import { useInRouterContext, useHref } from 'react-router-dom';
-import { UISlotProvider, useUISlots } from '@almadar/ui/context';
-import { useTranslate as useTranslate$1, createTranslate, I18nProvider } from '@almadar/ui/hooks';
-import { InMemoryPersistence } from '@almadar/db/mock';
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { OrbitalServerRuntime } from '@almadar/runtime/OrbitalServerRuntime';
-import { localeDirection } from '@almadar/core/i18n';
-
-var resolvedSchemaLog = createLogger("almadar:ui:resolved-schema");
-function useResolvedSchema(schema, pageName) {
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const ir = useMemo(() => {
-    if (!schema) return null;
-    try {
-      const resolved = schemaToIR(schema);
-      const callSiteListensByTrait = /* @__PURE__ */ new Map();
-      for (const orb of schema.orbitals) {
-        for (const traitRef of orb.traits ?? []) {
-          if (typeof traitRef === "string") continue;
-          const t = traitRef;
-          const inlineListens = t.listens?.length ? t.listens : void 0;
-          const resolvedListens = t._resolved?.listens?.length ? t._resolved.listens : void 0;
-          const listens = inlineListens ?? resolvedListens;
-          const traitName = t.name ?? t._resolved?.name;
-          if (typeof traitName !== "string" || !listens) continue;
-          callSiteListensByTrait.set(traitName, listens);
-        }
-      }
-      for (const [traitName, trait] of resolved.traits) {
-        const callSiteListens = callSiteListensByTrait.get(traitName);
-        if (!callSiteListens) continue;
-        const beforeCount = trait.listens.length;
-        trait.listens = callSiteListens.map((l) => ({
-          event: l.event,
-          triggers: l.triggers,
-          source: l.source,
-          guard: l.guard,
-          payloadMapping: l.payloadMapping
-        }));
-        resolvedSchemaLog.info("listens:restored", {
-          trait: traitName,
-          beforeCount,
-          afterCount: trait.listens.length,
-          listens: callSiteListens.map((l) => {
-            const src = l.source;
-            const label = !src ? "(no-source)" : src.kind === "any" ? "*" : src.trait;
-            return `${label}.${l.event}->${l.triggers}`;
-          }).join(",")
-        });
-      }
-      return resolved;
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Schema resolution failed");
-      return null;
-    }
-  }, [schema]);
-  useEffect(() => {
-    setLoading(false);
-  }, [ir]);
-  const result = useMemo(() => {
-    if (!ir) {
-      return {
-        page: void 0,
-        traits: [],
-        entities: /* @__PURE__ */ new Map(),
-        allEntities: /* @__PURE__ */ new Map(),
-        allTraits: /* @__PURE__ */ new Map(),
-        loading,
-        error: error || (schema ? null : "No schema provided"),
-        ir: null
-      };
-    }
-    const page = getPage(ir, pageName);
-    resolvedSchemaLog.debug("Resolved page", () => ({
-      name: page?.name,
-      path: page?.path,
-      traits: page?.traits.length
-    }));
-    const traits = page?.traits || [];
-    const entities = /* @__PURE__ */ new Map();
-    if (page) {
-      for (const binding of page.entityBindings) {
-        entities.set(binding.entity.name, binding.entity);
-      }
-    }
-    return {
-      page,
-      traits,
-      entities,
-      allEntities: ir.entities,
-      allTraits: ir.traits,
-      loading,
-      error,
-      ir
-    };
-  }, [ir, pageName, loading, error, schema]);
-  return result;
-}
-function clearSchemaCache() {
-  clearSchemaCache$1();
-}
-
-// lib/circuitVerificationObserver.ts
-function createCircuitVerificationObserver() {
-  return {
-    onTransition(trace) {
-      const effects = trace.effects.map((effect) => ({
-        type: effect.type,
-        args: effect.args,
-        status: effect.status,
-        ...effect.error !== void 0 ? { error: effect.error } : {},
-        ...effect.durationMs !== void 0 ? { durationMs: effect.durationMs } : {}
-      }));
-      recordTransition({
-        traitName: trace.traitName,
-        from: trace.from,
-        to: trace.to,
-        event: trace.event,
-        effects,
-        timestamp: Date.now(),
-        ...trace.guardResult !== void 0 ? { guardResult: trace.guardResult } : {}
-      });
-    }
-  };
-}
-function recordDispatchVerdict(orbitalName, event, verdict) {
-  if ("error" in verdict) {
-    recordServerResponse(orbitalName, event, {
-      success: false,
-      clientEffects: 0,
-      dataEntities: {},
-      emittedEvents: [],
-      error: verdict.error instanceof Error ? `${verdict.error.name}: ${verdict.error.message}` : verdict.error
-    });
-    return;
-  }
-  const { response } = verdict;
-  const dataEntities = {};
-  for (const [entity, rows] of Object.entries(response.data ?? {})) dataEntities[entity] = rows.length;
-  recordServerResponse(orbitalName, event, {
-    success: response.success,
-    transitioned: response.transitioned,
-    clientEffects: response.clientEffects?.length ?? 0,
-    dataEntities,
-    emittedEvents: response.emittedEvents.map((e) => e.event),
-    emitted: response.emittedEvents.map((e) => e.payload !== void 0 ? { event: e.event, payload: e.payload } : { event: e.event }),
-    ...response.error !== void 0 ? { error: response.error } : {}
-  });
-}
-var tabClientId;
-function getTabClientId() {
-  if (tabClientId === void 0) tabClientId = crypto.randomUUID();
-  return tabClientId;
-}
-var log = createLogger("almadar:ui:circuit-kernel");
-function postUnmounts(transport, traits, locale) {
-  for (const [traitName, orbitalName] of traits) {
-    transport.send(orbitalName, { event: UNMOUNT_EVENT, targetTrait: traitName, clientId: getTabClientId(), locale }).catch((err) => log.warn("unmount-post-failed", { trait: traitName, orbital: orbitalName, error: String(err) }));
-  }
-}
-function restrictTraitIndex(full, activeNames) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const [name, entry] of full.byName) {
-    if (activeNames.has(name)) byName.set(name, entry);
-  }
-  return { byName, allEntities: full.allEntities, orbitals: full.orbitals };
-}
-function useCircuitKernel(traitBindings, options) {
-  const hostRunsProgram = options.transport?.hostsBrowserStore === true;
-  const fullTraitIndex = useMemo(
-    () => buildTraitIndex(options.orbitals, options.traitConfigsByName, { hostRunsProgram }),
-    [options.orbitals, options.traitConfigsByName, hostRunsProgram]
-  );
-  const appTraitNames = useMemo(() => new Set(fullTraitIndex.byName.keys()), [fullTraitIndex]);
-  const activeTraitKey = traitBindings.map((b) => b.trait.name).filter((n) => !!n).sort().join("\0");
-  const traitIndex = useMemo(
-    () => restrictTraitIndex(fullTraitIndex, new Set(activeTraitKey === "" ? [] : activeTraitKey.split("\0"))),
-    [activeTraitKey, fullTraitIndex]
-  );
-  const mountedRef = useRef(/* @__PURE__ */ new Map());
-  const { locale } = useTranslate();
-  const i18n = useRenderI18n();
-  const localeRef = useRef(locale);
-  localeRef.current = locale;
-  const transport = options.transport;
-  const topologyPending = options.awaitTopology === true;
-  useEffect(() => {
-    if (transport === void 0 || topologyPending) return;
-    const mounted = mountedRef.current;
-    const dropped = [...mounted].filter(([name]) => !traitIndex.byName.has(name));
-    mounted.clear();
-    for (const [name, entry] of traitIndex.byName) mounted.set(name, entry.orbitalName);
-    postUnmounts(transport, dropped, localeRef.current);
-  }, [traitIndex, transport, topologyPending]);
-  useEffect(() => {
-    if (transport === void 0) return;
-    const mounted = mountedRef.current;
-    return () => postUnmounts(transport, [...mounted], localeRef.current);
-  }, [transport]);
-  const store = useMemo(() => {
-    const traitDefs = Array.from(traitIndex.byName.values(), (entry) => entry.traitDef);
-    const config = {
-      ...options.guardMode !== void 0 ? { guardMode: options.guardMode } : {},
-      ...options.strictBindings !== void 0 ? { strictBindings: options.strictBindings } : {},
-      ...options.contextExtensions !== void 0 ? { contextExtensions: options.contextExtensions } : {}
-    };
-    return createMemoryCircuitStore(traitDefs, config, options.observer);
-  }, [traitIndex, options.guardMode, options.strictBindings, options.contextExtensions, options.observer]);
-  const localTransportOptions = {
-    traitIndex,
-    store,
-    ...options.callService !== void 0 ? { callService: options.callService } : {},
-    ...options.user !== void 0 ? { user: options.user } : {},
-    ...options.guardMode !== void 0 ? { guardMode: options.guardMode } : {},
-    ...options.strictBindings !== void 0 ? { strictBindings: options.strictBindings } : {},
-    ...options.contextExtensions !== void 0 ? { contextExtensions: options.contextExtensions } : {},
-    ...options.debug !== void 0 ? { debug: options.debug } : {},
-    ...options.logContext !== void 0 ? { logContext: options.logContext } : {}
-  };
-  const offlineTransport = useMemo(
-    () => options.transport !== void 0 || options.persistence === void 0 ? void 0 : createLocalStoreTransport({ ...localTransportOptions, persistence: options.persistence }),
-    [
-      options.transport,
-      options.persistence,
-      traitIndex,
-      store,
-      options.callService,
-      options.user,
-      options.guardMode,
-      options.strictBindings,
-      options.contextExtensions,
-      options.debug,
-      options.logContext
-    ]
-  );
-  const routedTransport = useMemo(() => {
-    if (options.browserStore === void 0) return void 0;
-    const local = createLocalStoreTransport({ ...localTransportOptions, traitIndex: fullTraitIndex, persistence: options.browserStore, clientRelays: true });
-    const remote = options.transport ?? offlineTransport;
-    return createResidenceTransport({ local, ...remote !== void 0 ? { remote } : {}, traitIndex: fullTraitIndex });
-  }, [
-    options.browserStore,
-    options.transport,
-    offlineTransport,
-    fullTraitIndex,
-    store,
-    options.callService,
-    options.user,
-    options.guardMode,
-    options.strictBindings,
-    options.contextExtensions,
-    options.debug,
-    options.logContext
-  ]);
-  const baseTransport = routedTransport ?? options.transport ?? offlineTransport;
-  const effectiveTransport = useMemo(
-    () => baseTransport === void 0 ? void 0 : recordingTransport(baseTransport),
-    [baseTransport]
-  );
-  const orbitalName = options.orbitals[0]?.name ?? "";
-  const topology = useMemo(() => {
-    let resolve = () => void 0;
-    const promise = new Promise((r) => {
-      resolve = r;
-    });
-    return { promise, resolve };
-  }, [effectiveTransport]);
-  const awaitTopology = options.awaitTopology === true;
-  const confirmedCarries = options.carriesCircuitState ?? false;
-  useEffect(() => {
-    if (!awaitTopology) topology.resolve({ carriesCircuitState: confirmedCarries });
-  }, [awaitTopology, confirmedCarries, topology]);
-  const rawKernel = useMemo(() => createClientKernel({
-    orbitalName,
-    traitIndex,
-    fullTraitIndex,
-    store,
-    ...options.persistence !== void 0 ? { persistence: options.persistence } : {},
-    ...options.user !== void 0 ? { user: options.user } : {},
-    locale,
-    ...i18n !== void 0 ? { messages: { [i18n.locale]: i18n.messages } } : {},
-    ...options.guardMode !== void 0 ? { guardMode: options.guardMode } : {},
-    ...options.strictBindings !== void 0 ? { strictBindings: options.strictBindings } : {},
-    ...options.contextExtensions !== void 0 ? { contextExtensions: options.contextExtensions } : {},
-    ...options.debug !== void 0 ? { debug: options.debug } : {},
-    ...options.logContext !== void 0 ? { logContext: options.logContext } : {},
-    carriesCircuitState: false,
-    topology: topology.promise,
-    ...effectiveTransport !== void 0 ? { transport: effectiveTransport } : {}
-  }), [
-    orbitalName,
-    traitIndex,
-    fullTraitIndex,
-    store,
-    options.persistence,
-    options.user,
-    locale,
-    i18n,
-    options.guardMode,
-    options.strictBindings,
-    options.contextExtensions,
-    options.debug,
-    options.logContext,
-    topology,
-    effectiveTransport
-  ]);
-  const kernel = useMemo(() => {
-    const stamp = (request) => ({
-      ...request,
-      clientId: request.clientId ?? getTabClientId(),
-      locale: request.locale ?? locale
-    });
-    return {
-      store: rawKernel.store,
-      dispatch: (request, hooks) => rawKernel.dispatch(stamp(request), hooks),
-      dispatchMount: (seeds, hooks, base = {}) => rawKernel.dispatchMount(seeds, hooks, stamp(base)),
-      dispatchProgress: (request) => rawKernel.dispatchProgress(stamp(request)),
-      foldHostDispatch: (request, response) => rawKernel.foldHostDispatch(request, response)
-    };
-  }, [rawKernel, locale]);
-  return { kernel, store, traitIndex, appTraitNames, transport: effectiveTransport };
-}
-var log2 = createLogger("almadar:ui:circuit:bus-ingress");
-function useBusIngress(traitBindings, traitIndex, settle, eventBus, appTraitNames) {
-  useEffect(() => {
-    const unsubscribes = [];
-    const subscribedQualified = /* @__PURE__ */ new Set();
-    const subscribedBare = /* @__PURE__ */ new Set();
-    const deliveredHere = (source) => source?.dispatched === true && source.trait !== void 0 && (traitIndex.byName.has(source.trait) || appTraitNames.has(source.trait));
-    const claims = /* @__PURE__ */ new WeakMap();
-    const claim = (source, traitName, eventKey) => {
-      if (source === void 0) return true;
-      const key = `${traitName}\0${eventKey}`;
-      const seen = claims.get(source);
-      if (seen === void 0) {
-        claims.set(source, /* @__PURE__ */ new Set([key]));
-        return true;
-      }
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    };
-    const dispatch = (traitName, eventKey, payload, source) => {
-      if (!claim(source, traitName, eventKey)) return;
-      const tick = source?.tick;
-      const pendingKey = source?.pendingKey;
-      if (pendingKey !== void 0) beginPending(pendingKey);
-      void settle(traitName, eventKey, payload, tick).catch((err) => {
-        log2.error("dispatch:failed", { trait: traitName, event: eventKey, error: String(err) });
-      }).finally(() => {
-        if (pendingKey !== void 0) endPending(pendingKey);
-      });
-    };
-    for (const binding of traitBindings) {
-      const traitName = binding.trait.name;
-      const orbitalName = traitIndex.byName.get(traitName)?.orbitalName;
-      if (orbitalName === void 0) continue;
-      for (const transition of binding.trait.transitions) {
-        const eventKey = transition.event;
-        if (LIFECYCLE_EVENTS.includes(eventKey)) continue;
-        const qualifiedKey = `UI:${orbitalName}.${traitName}.${eventKey}`;
-        if (!subscribedQualified.has(qualifiedKey)) {
-          subscribedQualified.add(qualifiedKey);
-          const unsub = eventBus.on(qualifiedKey, (event) => {
-            if (deliveredHere(event.source)) return;
-            log2.debug("qualified:fire", { key: qualifiedKey });
-            dispatch(traitName, eventKey, event.payload, event.source);
-          });
-          unsubscribes.push(unsub);
-        }
-        const bareKey = `UI:${eventKey}`;
-        if (!subscribedBare.has(bareKey)) {
-          subscribedBare.add(bareKey);
-          const unsub = eventBus.on(bareKey, (event) => {
-            if (deliveredHere(event.source)) return;
-            const routed = event.source?.dispatched === true ? new Set(collectListenerTargets(traitIndex, event.source, eventKey, event.payload).map((t) => t.listenerTrait)) : void 0;
-            for (const [name, entry] of traitIndex.byName) {
-              if (!entry.traitDef.transitions.some((t) => t.event === eventKey)) continue;
-              if (routed?.has(name) === true) continue;
-              log2.debug("bare:fire", { key: bareKey, trait: name });
-              dispatch(name, eventKey, event.payload, event.source);
-            }
-          });
-          unsubscribes.push(unsub);
-        }
-      }
-    }
-    const listenRoutesByKey = /* @__PURE__ */ new Map();
-    for (const binding of traitBindings) {
-      const listenerName = binding.trait.name;
-      const ownOrbital = traitIndex.byName.get(listenerName)?.orbitalName;
-      if (ownOrbital === void 0) continue;
-      for (const listen of binding.trait.listens ?? []) {
-        const src = listen.source;
-        if (src === void 0 || src.kind === "any") continue;
-        const sourceOrbital = (src.kind === "orbital" ? src.orbital : void 0) ?? ownOrbital;
-        const sourceKey = `UI:${sourceOrbital}.${src.trait}.${listen.event}`;
-        const route = {
-          listenerTrait: listenerName,
-          triggers: listen.triggers,
-          payloadMapping: listen.payloadMapping
-        };
-        const routes = listenRoutesByKey.get(sourceKey);
-        if (routes) routes.push(route);
-        else listenRoutesByKey.set(sourceKey, [route]);
-      }
-    }
-    for (const [sourceKey, routes] of listenRoutesByKey) {
-      const unsub = eventBus.on(sourceKey, (event) => {
-        if (deliveredHere(event.source)) return;
-        for (const route of routes) {
-          log2.debug("listen-source:fire", { key: sourceKey, listener: route.listenerTrait, triggers: route.triggers });
-          dispatch(
-            route.listenerTrait,
-            route.triggers,
-            applyListenPayloadMapping(route.payloadMapping, event.payload, evaluateListenPayloadExpr),
-            event.source
-          );
-        }
-      });
-      unsubscribes.push(unsub);
-    }
-    const routedBareEvents = /* @__PURE__ */ new Set();
-    for (const binding of traitBindings) {
-      for (const listen of binding.trait.listens ?? []) {
-        if (listen.source !== void 0 && listen.source.kind !== "any") routedBareEvents.add(listen.event);
-      }
-    }
-    for (const eventKey of routedBareEvents) {
-      const unsub = eventBus.on(`UI:${eventKey}`, (event) => {
-        if (deliveredHere(event.source) || event.source?.trait === void 0) return;
-        for (const target of collectListenerTargets(traitIndex, event.source, eventKey, event.payload)) {
-          log2.debug("listen-bare:fire", { event: eventKey, source: event.source.trait, listener: target.listenerTrait, triggers: target.triggers });
-          dispatch(target.listenerTrait, target.triggers, target.payload, event.source);
-        }
-      });
-      unsubscribes.push(unsub);
-    }
-    return () => {
-      for (const unsub of unsubscribes) unsub();
-    };
-  }, [traitBindings, traitIndex, settle, eventBus, appTraitNames]);
-}
-var lambdaLog = createLogger("almadar:ui:fn-form-lambda");
-function patternPropsSchema(patternType) {
-  return typeof patternType === "string" ? getPatternDefinition(patternType)?.propsSchema : void 0;
-}
-function isDeclaredSExpr(def) {
-  return def?.types?.includes("sexpr") ?? false;
-}
-function isOperatorCall(value) {
-  const first = value[0];
-  if (typeof first !== "string") return false;
-  return isKnownStdOperator(first) || first.includes("/") || first === "lambda" || first === "let";
-}
-function isFnFormLambda(value) {
-  if (!Array.isArray(value)) return false;
-  const arr = value;
-  if (arr.length !== 3 || arr[0] !== "fn" || arr[2] === null || typeof arr[2] !== "object") {
-    return false;
-  }
-  const params = arr[1];
-  return typeof params === "string" || Array.isArray(params) && params.length > 0 && params.every((p) => typeof p === "string");
-}
-function fnFormParams(value) {
-  const p = value[1];
-  if (typeof p === "string") return [p];
-  if (Array.isArray(p)) return p.filter((x) => typeof x === "string");
-  return [];
-}
-function resolveLambdaBindings(body, params, item, index) {
-  const itemName = params[0];
-  const indexName = params[1];
-  const itemPrefix = itemName ? `@${itemName}.` : null;
-  const lookup = (path) => {
-    let cur = item;
-    for (const seg of path.split(".")) {
-      if (cur === null || cur === void 0) return void 0;
-      if (typeof cur !== "object" || Array.isArray(cur)) return void 0;
-      cur = cur[seg];
-    }
-    return cur;
-  };
-  const recur = (b) => resolveLambdaBindings(b, params, item, index);
-  if (typeof body === "string") {
-    if (indexName && body === `@${indexName}`) return index;
-    if (itemName && body === `@${itemName}`) return item;
-    if (itemPrefix && body.startsWith(itemPrefix)) {
-      const v = lookup(body.slice(itemPrefix.length));
-      return v === void 0 || v === null ? "" : v;
-    }
-    return body;
-  }
-  if (Array.isArray(body)) {
-    if (isFnFormLambda(body)) return body;
-    const arr = body;
-    const substituted = arr.map((b) => recur(b));
-    if (isOperatorCall(substituted) && isSExpr(substituted)) {
-      if (containsEntityBinding(substituted)) {
-        return substituted;
-      }
-      const evaluated = evaluate(substituted, createMinimalContext());
-      return isEventPayloadValue(evaluated) ? evaluated : String(evaluated);
-    }
-    return substituted;
-  }
-  if (body !== null && typeof body === "object" && !React.isValidElement(body) && !(body instanceof Date) && typeof body !== "function") {
-    const out = {};
-    for (const [k, v] of Object.entries(body)) {
-      out[k] = recur(v);
-    }
-    return out;
-  }
-  return body;
-}
-var LazySlotContentRenderer = React.lazy(
-  () => import('./UISlotRenderer-N5DFYE6K.js').then((m) => ({ default: m.SlotContentRenderer }))
-);
-function deferLambdaEntityExprs(value) {
-  if (typeof value === "string") {
-    if (containsEntityBinding(value)) {
-      const marker = { [RENDER_BINDING_MARKER]: true, expression: value };
-      return marker;
-    }
-    return value;
-  }
-  if (Array.isArray(value)) {
-    if (isFnFormLambda(value)) return value;
-    const arr = value;
-    if (isOperatorCall(arr) && isSExpr(arr) && containsEntityBinding(arr)) {
-      const marker = { [RENDER_BINDING_MARKER]: true, expression: arr };
-      return marker;
-    }
-    return arr.map((v) => deferLambdaEntityExprs(v));
-  }
-  if (value !== null && typeof value === "object" && !React.isValidElement(value) && !(value instanceof Date) && typeof value !== "function" && !isRenderBindingMarker(value)) {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = deferLambdaEntityExprs(v);
-    }
-    return out;
-  }
-  return value;
-}
-function makeLambdaFn(params, lambdaBody, callerKey) {
-  return (item, index) => {
-    const resolvedBody = deferLambdaEntityExprs(
-      resolveLambdaBindings(lambdaBody, params, item, index)
-    );
-    if (resolvedBody === null || typeof resolvedBody !== "object" || Array.isArray(resolvedBody) || typeof resolvedBody === "function" || React.isValidElement(resolvedBody) || resolvedBody instanceof Date) {
-      return null;
-    }
-    const record = resolvedBody;
-    if (typeof record.type !== "string") {
-      return null;
-    }
-    const rawChildProps = {};
-    for (const [k, v] of Object.entries(record)) {
-      if (k !== "type") rawChildProps[k] = v;
-    }
-    const childProps = convertObjectProps(rawChildProps, patternPropsSchema(record.type));
-    const childContent = {
-      id: `lambda-${callerKey}-${index}`,
-      pattern: record.type,
-      props: childProps,
-      priority: 0
-    };
-    return React.createElement(
-      React.Suspense,
-      { fallback: null },
-      React.createElement(LazySlotContentRenderer, { content: childContent, onDismiss: () => void 0 })
-    );
-  };
-}
-function convertNode(node, callerKey, def) {
-  if (node === null || node === void 0) return node;
-  if (isRenderBindingMarker(node)) return node;
-  if (Array.isArray(node)) {
-    if (isFnFormLambda(node)) {
-      const arr2 = node;
-      return makeLambdaFn(fnFormParams(arr2), arr2[2], callerKey);
-    }
-    const arr = node;
-    let anyChanged = false;
-    const mapped = arr.map((item, i) => {
-      const next = convertNode(item, `${callerKey}[${i}]`, def?.items);
-      if (next !== item) anyChanged = true;
-      return next;
-    });
-    return anyChanged ? mapped : node;
-  }
-  if (typeof node === "object" && !React.isValidElement(node) && !(node instanceof Date)) {
-    return convertObjectProps(node, def?.properties);
-  }
-  return node;
-}
-function convertObjectProps(props, inherited) {
-  let convertedAny = false;
-  const out = {};
-  const schema = patternPropsSchema(props.type) ?? inherited;
-  for (const [key, value] of Object.entries(props)) {
-    const def = schema?.[key];
-    if (isDeclaredSExpr(def)) {
-      out[key] = value;
-      continue;
-    }
-    if (isFnFormLambda(value)) {
-      convertedAny = true;
-      const arr = value;
-      const compiled = makeLambdaFn(fnFormParams(arr), arr[2], key);
-      out[key] = compiled;
-      if (key === "renderItem") out.children = compiled;
-      lambdaLog.debug(`convert key=${key}${key === "renderItem" ? " (+children)" : ""}`);
-      continue;
-    }
-    const next = convertNode(value, key, def);
-    if (next !== value) convertedAny = true;
-    out[key] = next;
-  }
-  return convertedAny ? out : props;
-}
-function convertFnFormLambdasInProps(props, patternType) {
-  if (props === null || typeof props !== "object") return props;
-  return convertObjectProps(props, patternType !== void 0 ? patternPropsSchema(patternType) : void 0);
-}
-
-// hooks/circuit/useSlotFlush.ts
-var flushLog = createLogger("almadar:ui:circuit:slot-flush");
-function unwrapPattern(record) {
-  if (typeof record === "string") return { bareTraitRef: record };
-  if (record === null) return {};
-  const { type, children, ...inlineProps } = record;
-  const props = { ...inlineProps, ...children !== void 0 ? { children } : {} };
-  return { patternType: type, props };
-}
-function useSlotFlush(uiSlots, embeddedTraits) {
-  const uiSlotsRef = useRef(uiSlots);
-  uiSlotsRef.current = uiSlots;
-  const embeddedTraitsRef = useRef(embeddedTraits);
-  embeddedTraitsRef.current = embeddedTraits;
-  const writtenRef = useRef(/* @__PURE__ */ new Map());
-  const keyOf = (slot, trait) => `${slot}\0${trait}`;
-  const flushSlot = useCallback((traitName, slot, patterns, source) => {
-    const slots = uiSlotsRef.current;
-    const embedded = embeddedTraitsRef.current;
-    if (patterns.length === 0) {
-      flushLog.debug("clear", { traitName, slot });
-      slots.clearBySource(slot, traitName);
-      writtenRef.current.set(keyOf(slot, traitName), { kind: "clear", slot, trait: traitName });
-      return;
-    }
-    const last = patterns[patterns.length - 1];
-    const { bareTraitRef, patternType, props: unwrapped } = unwrapPattern(last.pattern);
-    const rawProps = bareTraitRef !== void 0 ? bareTraitRef : { ...unwrapped ?? {}, ...last.props };
-    const props = convertFnFormLambdasInProps(rawProps, typeof patternType === "string" ? patternType : void 0);
-    const isEmbedded = (embedded?.has(traitName) ?? false) && !isNotificationSlot(slot);
-    if (isEmbedded) {
-      const content = {
-        pattern: patternType,
-        props,
-        slot,
-        priority: 0,
-        transitionEvent: source?.event,
-        fromState: source?.state,
-        entity: source?.entity
-      };
-      slots.updateTraitContent(traitName, content);
-      writtenRef.current.set(keyOf(slot, traitName), { kind: "trait", trait: traitName, content });
-      return;
-    }
-    const config = {
-      target: slot,
-      pattern: patternType,
-      props,
-      sourceTrait: traitName,
-      transitionEvent: source?.event,
-      fromState: source?.state,
-      entity: source?.entity
-    };
-    slots.render(config);
-    writtenRef.current.set(keyOf(slot, traitName), { kind: "render", config });
-  }, []);
-  const applyClientEffects = useCallback((clientEffects, clientEffectsByTrait, onNavigate, onNavigateBack, activeTraits) => {
-    const slots = uiSlotsRef.current;
-    const embedded = embeddedTraitsRef.current;
-    const tuples = clientEffectsByTrait ? [...clientEffectsByTrait] : clientEffects.map((effect) => ({ effect }));
-    for (const { effect, traitName, event, fromState } of tuples) {
-      if (traitName !== void 0 && activeTraits !== void 0 && !activeTraits.has(traitName)) continue;
-      const kind = effect[0];
-      if (kind === "render-ui") {
-        const [, slot, pattern, rawProps] = effect;
-        const sourceTrait = traitName ?? "kernel";
-        const { bareTraitRef, patternType, props: unwrapped } = unwrapPattern(pattern);
-        const isEmbedded = (embedded?.has(sourceTrait) ?? false) && !isNotificationSlot(slot);
-        const propsValue = bareTraitRef !== void 0 ? bareTraitRef : { ...unwrapped ?? {}, ...rawProps };
-        const props = convertFnFormLambdasInProps(propsValue, typeof patternType === "string" ? patternType : void 0);
-        if (pattern === null) {
-          slots.clearBySource(slot, sourceTrait);
-          writtenRef.current.set(keyOf(slot, sourceTrait), { kind: "clear", slot, trait: sourceTrait });
-        } else if (isEmbedded) {
-          const content = { pattern: patternType, props, slot, priority: 0, transitionEvent: event, fromState };
-          slots.updateTraitContent(sourceTrait, content);
-          writtenRef.current.set(keyOf(slot, sourceTrait), { kind: "trait", trait: sourceTrait, content });
-        } else {
-          const config = { target: slot, pattern: patternType, props, sourceTrait, transitionEvent: event, fromState };
-          slots.render(config);
-          writtenRef.current.set(keyOf(slot, sourceTrait), { kind: "render", config });
-        }
-      } else if (kind === "navigate") {
-        const [, route, params, options] = effect;
-        onNavigate?.(route, params, options?.crumb);
-      } else if (kind === "navigate-back") {
-        onNavigateBack?.();
-      }
-    }
-  }, []);
-  const checkpoint = useCallback(() => new Map(writtenRef.current), []);
-  const rollback = useCallback((cp) => {
-    const slots = uiSlotsRef.current;
-    for (const [key, now] of writtenRef.current) {
-      const then = cp.get(key);
-      if (then === now) continue;
-      if (then === void 0 || then.kind === "clear") {
-        if (now.kind === "render") slots.clearBySource(now.config.target, now.config.sourceTrait ?? "kernel");
-        else if (now.kind === "trait") {
-          flushLog.warn("rollback:embedded-frame-kept", { trait: now.trait });
-        }
-      } else if (then.kind === "render") {
-        slots.render(then.config);
-      } else {
-        slots.updateTraitContent(then.trait, then.content);
-      }
-    }
-    writtenRef.current = new Map(cp);
-  }, []);
-  return useMemo(() => ({ flushSlot, applyClientEffects, checkpoint, rollback }), [flushSlot, applyClientEffects, checkpoint, rollback]);
-}
-var log3 = createLogger("almadar:ui:circuit:effect-runner");
-async function runCircuitEffects(params) {
-  const { store, eventBus, traitName, frameKey, effects, payload, callsitePayload, config, user, tickName } = params;
-  if (effects.length === 0) return { emitted: [], didWrite: false };
-  let frame = store.frames.get(frameKey);
-  if (frame === void 0) {
-    frame = {};
-    store.frames.set(frameKey, frame);
-  }
-  const emitted = [];
-  let didWrite = false;
-  const handlers = createClientEffectHandlers({
-    eventBus: {
-      emit: (type, emitPayload, source) => {
-        const event = type.startsWith("UI:") ? type.slice(3) : type;
-        emitted.push(event);
-        eventBus.emit(type, emitPayload, tickName !== void 0 ? { ...source, tick: tickName } : source);
-      }
-    },
-    slotSetter: {
-      addPattern: (slot, pattern, props, priority) => params.onPattern(slot, pattern, props, priority),
-      clearSlot: (slot) => params.onPattern(slot, null)
-    },
-    navigate: params.navigate,
-    navigateBack: params.navigateBack,
-    liveEntity: frame,
-    // Ticks and callsite re-runs never carry a persistence adapter — the
-    // same bridge-mode placeholder the composition's client env delegates
-    // to a leg; here there is no leg to delegate to, so the write is a
-    // documented no-op (persist/call-service were never reachable from a
-    // tick's SYNC_TICK_OPERATORS filter or a lifecycle re-run's effects).
-    persistDelegated: true,
-    callServiceDelegated: true,
-    orbitalName: params.orbitalName
-  });
-  const baseSet = handlers.set;
-  const tracked = {
-    ...handlers,
-    set: async (targetId, field, value) => {
-      if (baseSet) await baseSet(targetId, field, value);
-      didWrite = true;
-    }
-  };
-  const bindingCtx = {
-    entity: frame,
-    payload: payload ?? {},
-    state: params.state,
-    ...user !== void 0 ? { user } : {},
-    ...config !== void 0 ? { config } : {},
-    ...callsitePayload !== void 0 ? { callsitePayload } : {}
-  };
-  const effectContext = {
-    traitName,
-    ...params.orbitalName !== void 0 ? { orbitalName: params.orbitalName } : {},
-    ...params.traitId !== void 0 ? { traitId: params.traitId } : {},
-    ...params.orbitalId !== void 0 ? { orbitalId: params.orbitalId } : {},
-    ...params.emits !== void 0 ? { emits: params.emits } : {},
-    state: params.state,
-    transition: params.transitionLabel
-  };
-  const executor = new EffectExecutor({ handlers: tracked, bindings: bindingCtx, context: effectContext, deferRenderBindings: true });
-  try {
-    await executor.executeAll(effects);
-  } catch (error) {
-    log3.error("effects:error", {
-      traitName,
-      transition: params.transitionLabel,
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
-  return { emitted, didWrite };
-}
-
-// hooks/circuit/useCallsiteCapture.ts
-var log4 = createLogger("almadar:ui:circuit:callsite-capture");
-function useCallsiteCapture(traitBindings, store, traitIndex, slotFlush, options) {
-  return useCallback(async function reRender(traitName, callsitePayload, entityByTrait, visited = /* @__PURE__ */ new Set(), serverComposed = /* @__PURE__ */ new Set(), keepComposed = false, composedBy) {
-    const children = options.callsiteCaptureChildrenByTrait?.get(traitName);
-    if (!children || children.size === 0) return;
-    const bindingMap = new Map(traitBindings.map((b) => [b.trait.name, b]));
-    for (const childName of children) {
-      if (composedBy !== void 0 && !composedBy.has(childName)) continue;
-      if (visited.has(childName)) continue;
-      visited.add(childName);
-      const childBinding = bindingMap.get(childName);
-      if (!childBinding) continue;
-      const composedWith = serverComposed.has(childName) || keepComposed ? store.callsitePayloads.get(childName) ?? callsitePayload : callsitePayload;
-      const lifecycleEvent = store.manager.repaintLifecycleEvent(childName);
-      const indexed = traitIndex.byName.get(childName);
-      const [entry] = lifecycleEvent === void 0 || indexed === void 0 ? [] : store.manager.sendEvent(lifecycleEvent, {}, void 0, entityByTrait, void 0, childName);
-      if (lifecycleEvent === void 0 || indexed === void 0 || !entry || !entry.result.executed) {
-        await reRender(childName, composedWith, entityByTrait, visited, serverComposed, true);
-        continue;
-      }
-      const frameKey = indexed.frameKey;
-      log4.debug("rerender", { referrer: traitName, child: childName, lifecycleEvent });
-      store.callsitePayloads.set(childName, composedWith);
-      const pendingSlots = /* @__PURE__ */ new Map();
-      await runCircuitEffects({
-        store,
-        eventBus: options.eventBus,
-        traitName: childName,
-        frameKey,
-        effects: entry.result.effects,
-        state: entry.result.previousState,
-        transitionLabel: `${entry.result.previousState}->${entry.result.newState}`,
-        payload: {},
-        callsitePayload: composedWith,
-        config: indexed.config,
-        user: options.user,
-        orbitalName: indexed.orbitalName,
-        orbitalId: indexed.orbitalId,
-        traitId: indexed.irTrait.id,
-        emits: indexed.irTrait.emits,
-        navigate: options.navigate,
-        navigateBack: options.navigateBack,
-        onPattern: (slot, pattern, props) => {
-          if (pattern === null) {
-            pendingSlots.set(slot, []);
-            return;
-          }
-          const existing = pendingSlots.get(slot) ?? [];
-          existing.push({ pattern, props });
-          pendingSlots.set(slot, existing);
-        }
-      });
-      store.notify();
-      for (const [slot, patterns] of pendingSlots) {
-        slotFlush.flushSlot(
-          childName,
-          slot,
-          patterns,
-          { event: lifecycleEvent, state: entry.result.previousState, entity: childBinding.linkedEntity }
-        );
-      }
-      await reRender(childName, composedWith, entityByTrait, visited, serverComposed, keepComposed, traitsEmbeddedByEffects(indexed.irTrait, entry.result.effects));
-    }
-  }, [traitBindings, store, traitIndex, slotFlush, options.callsiteCaptureChildrenByTrait, options.eventBus, options.navigate, options.navigateBack, options.user]);
-}
-var tickLog = createLogger("almadar:ui:circuit:tick-effects");
-var SHARED_ENTITY_WRITE_OPS = /* @__PURE__ */ new Set(["set"]);
-var SHARED_ENTITY_RENDER_OPS = /* @__PURE__ */ new Set(["render-ui", "render"]);
-function effectsCallOp(effects, ops) {
-  for (const effect of effects) {
-    let found = false;
-    walkSExpr(effect, (node) => {
-      if (!found && Array.isArray(node) && typeof node[0] === "string" && ops.has(node[0])) found = true;
-    });
-    if (found) return true;
-  }
-  return false;
-}
-function classifySharedTick(tick) {
-  const writes = effectsCallOp(tick.effects, SHARED_ENTITY_WRITE_OPS);
-  const renders = effectsCallOp(tick.effects, SHARED_ENTITY_RENDER_OPS);
-  if (writes && renders) return "both";
-  if (writes) return "writer";
-  if (renders) return "renderer";
-  return "neither";
-}
-function containsConfigForward(value) {
-  if (typeof value === "string") return value.startsWith("@config.");
-  if (Array.isArray(value)) return value.some(containsConfigForward);
-  if (value !== null && typeof value === "object") return Object.values(value).some(containsConfigForward);
-  return false;
-}
-function getBindingConfig(binding) {
-  return normalizeCallSiteConfigToValues(binding.config);
-}
-function evalFieldDefault(value) {
-  if (!Array.isArray(value) || !isSExpression(value)) return value;
-  return evaluate(value, createMinimalContext({}, {}, ""));
-}
-function createSharedEntityWriter(binding, tick, traitStatesRef, emit, traitConfigsByName, orbitalsByTrait, orbitalIdsByTrait) {
-  return (scratch) => {
-    const traitName = binding.trait.name;
-    const currentState = traitStatesRef.current.get(traitName)?.currentState ?? "";
-    if (tick.appliesTo.length > 0 && !tick.appliesTo.includes(currentState)) return [];
-    const scratchEntity = { ...scratch };
-    const writes = [];
-    const ctx = createMinimalContext(scratchEntity, {}, currentState);
-    const declaredDefaults = collectDeclaredConfigDefaults(binding.trait);
-    const resolvedByName = traitConfigsByName?.[traitName];
-    const callSiteRaw = getBindingConfig(binding);
-    const callSiteConfig = callSiteRaw ? Object.fromEntries(Object.entries(callSiteRaw).filter(([, v]) => !containsConfigForward(v))) : void 0;
-    if (declaredDefaults || resolvedByName || callSiteConfig) {
-      ctx.config = { ...declaredDefaults ?? {}, ...resolvedByName ?? {}, ...callSiteConfig ?? {} };
-    }
-    ctx.mutateEntity = (changes) => {
-      for (const [field, value] of Object.entries(changes)) {
-        const fieldValue = value;
-        scratchEntity[field] = fieldValue;
-        writes.push({ field, value: fieldValue });
-      }
-    };
-    ctx.emit = (event, payload) => {
-      emit(event, payload, {
-        orbital: orbitalsByTrait?.[traitName],
-        trait: traitName,
-        tick: tick.name,
-        orbitalId: orbitalIdsByTrait?.[traitName],
-        traitId: binding.trait.id
-      });
-    };
-    if (tick.guard !== void 0 && !evaluateGuard(tick.guard, ctx)) {
-      tickLog.debug("guard-blocked", { traitName, tick: tick.name, state: currentState });
-      return [];
-    }
-    executeEffects(tick.effects, ctx);
-    return writes;
-  };
-}
-function useClientTicks(traitBindings, store, traitIndex, options) {
-  useEffect(() => {
-    if (options.hostRunsProgram === true) return;
-    const scheduler = createTickScheduler();
-    const traitStatesRef = { current: store.manager.getAllStates() };
-    const refreshStates = () => {
-      traitStatesRef.current = store.manager.getAllStates();
-    };
-    const orbitalsByTrait = {};
-    const orbitalIdsByTrait = {};
-    for (const [name, entry] of traitIndex.byName) {
-      orbitalsByTrait[name] = entry.orbitalName;
-      if (entry.orbitalId !== void 0) orbitalIdsByTrait[name] = entry.orbitalId;
-    }
-    const emitFromWriter = (event, payload, source) => {
-      const prefixed = event.startsWith("UI:") ? event : `UI:${event}`;
-      options.eventBus.emit(prefixed, payload, source);
-    };
-    const frameAdapter = {
-      getSnapshot: (frameKey) => store.frames.get(frameKey) ?? {},
-      subscribe: (_frameKey, callback) => store.subscribe(callback),
-      commit: (frameKey, next) => {
-        store.frames.set(frameKey, next);
-        store.notify();
-      },
-      seed: (frameKey, initial) => {
-        if (!store.frames.has(frameKey)) store.frames.set(frameKey, initial);
-      }
-    };
-    const writerTicksByFrame = /* @__PURE__ */ new Map();
-    const pureWriterTickKeys = /* @__PURE__ */ new Set();
-    const seededFrames = /* @__PURE__ */ new Set();
-    for (const binding of traitBindings) {
-      const entry = traitIndex.byName.get(binding.trait.name);
-      if (!entry?.isSharedEntity) continue;
-      if (!seededFrames.has(entry.frameKey)) {
-        seededFrames.add(entry.frameKey);
-        let defaults;
-        for (const field of entry.entity.fields) {
-          if (field.name !== void 0 && field.default !== void 0 && field.default !== null) {
-            (defaults ?? (defaults = {}))[field.name] = evalFieldDefault(field.default);
-          }
-        }
-        if (defaults) frameAdapter.seed(entry.frameKey, defaults);
-      }
-      for (const tick of binding.trait.ticks ?? []) {
-        if (classifySharedTick(tick) !== "writer") continue;
-        pureWriterTickKeys.add(`${binding.trait.name}::${tick.name}`);
-        const list = writerTicksByFrame.get(entry.frameKey) ?? [];
-        list.push({ binding, tick });
-        writerTicksByFrame.set(entry.frameKey, list);
-      }
-    }
-    for (const [frameKey, entries] of writerTicksByFrame) {
-      const byInterval = /* @__PURE__ */ new Map();
-      for (const item of entries) {
-        const key = String(item.tick.interval);
-        const list = byInterval.get(key) ?? [];
-        list.push(item);
-        byInterval.set(key, list);
-      }
-      for (const group of byInterval.values()) {
-        const interval = group[0].tick.interval;
-        const onDue = () => perfTimeAsync(`tick:shared:${frameKey}@${String(interval)}`, () => {
-          const writers = group.map(
-            ({ binding, tick }) => createSharedEntityWriter(binding, tick, traitStatesRef, emitFromWriter, options.traitConfigsByName, orbitalsByTrait, orbitalIdsByTrait)
-          );
-          runTickFrame(frameKey, writers, frameAdapter);
-        });
-        if (interval === "frame") scheduler.add(0, onDue);
-        else if (typeof interval === "number") scheduler.add(interval, onDue);
-        else if (isValidCronExpression(interval)) scheduler.addCron(interval, onDue);
-        else scheduler.add(parseDurationString(interval), onDue);
-      }
-    }
-    const runNonWriterTick = (binding, tick) => {
-      refreshStates();
-      const traitName = binding.trait.name;
-      const currentState = traitStatesRef.current.get(traitName)?.currentState ?? "";
-      if (tick.appliesTo.length > 0 && !tick.appliesTo.includes(currentState)) return;
-      const entry = traitIndex.byName.get(traitName);
-      const frameKey = entry?.frameKey ?? traitName;
-      if (tick.guard !== void 0) {
-        const entity = store.frames.get(frameKey) ?? {};
-        const guardCtx = {
-          entity,
-          payload: {},
-          state: currentState,
-          ...options.user ? { user: options.user } : {},
-          ...entry?.config !== void 0 ? { config: entry.config } : {}
-        };
-        if (!evaluateGuard(tick.guard, createContextFromBindings(guardCtx))) {
-          tickLog.debug("guard-blocked", { traitName, tick: tick.name, state: currentState });
-          return;
-        }
-      }
-      const pendingSlots = /* @__PURE__ */ new Map();
-      void runCircuitEffects({
-        store,
-        eventBus: options.eventBus,
-        traitName,
-        frameKey,
-        effects: tick.effects,
-        state: currentState,
-        transitionLabel: `${currentState}->${currentState}`,
-        config: entry?.config,
-        user: options.user,
-        orbitalName: entry?.orbitalName,
-        orbitalId: entry?.orbitalId,
-        traitId: entry?.irTrait.id,
-        emits: entry?.irTrait.emits,
-        navigate: options.navigate,
-        navigateBack: options.navigateBack,
-        tickName: tick.name,
-        onPattern: (slot, pattern, props) => {
-          if (pattern === null) {
-            pendingSlots.set(slot, []);
-            return;
-          }
-          const existing = pendingSlots.get(slot) ?? [];
-          existing.push({ pattern, props });
-          pendingSlots.set(slot, existing);
-        }
-      }).then(() => {
-        store.notify();
-        for (const [slot, patterns] of pendingSlots) {
-          options.slotFlush.flushSlot(
-            traitName,
-            slot,
-            patterns,
-            { event: `tick:${tick.name}`, state: currentState, entity: binding.linkedEntity }
-          );
-        }
-      });
-    };
-    for (const binding of traitBindings) {
-      const entry = traitIndex.byName.get(binding.trait.name);
-      for (const tick of binding.trait.ticks ?? []) {
-        if (entry?.isSharedEntity && pureWriterTickKeys.has(`${binding.trait.name}::${tick.name}`)) continue;
-        const key = `tick:${binding.trait.name}::${tick.name}`;
-        const onDue = () => perfTimeAsync(key, () => runNonWriterTick(binding, tick));
-        if (tick.interval === "frame") scheduler.add(0, onDue);
-        else if (typeof tick.interval === "number") scheduler.add(tick.interval, onDue);
-        else if (isValidCronExpression(tick.interval)) scheduler.addCron(tick.interval, onDue);
-        else scheduler.add(parseDurationString(tick.interval), onDue);
-      }
-    }
-    return () => scheduler.stopAll();
-  }, [traitBindings, store, traitIndex, options.eventBus, options.slotFlush, options.traitConfigsByName, options.navigate, options.navigateBack, options.user, options.hostRunsProgram]);
-}
-var EMPTY_ENTITY = {};
-function useEntityBindingSource(store, traitIndex) {
-  useSyncExternalStore(store.subscribe, store.getVersion);
-  return useMemo(() => {
-    const snapshots = /* @__PURE__ */ new Map();
-    return {
-      getEntitySnapshot: (traitName) => {
-        const entry = traitIndex.byName.get(traitName);
-        const frameKey = entry?.frameKey ?? traitName;
-        const frame = store.frames.get(frameKey);
-        if (frame === void 0) return EMPTY_ENTITY;
-        const previous = snapshots.get(frameKey);
-        if (previous !== void 0 && sameFields(previous, frame)) return previous;
-        const next = { ...frame };
-        snapshots.set(frameKey, next);
-        return next;
-      },
-      getConfig: (traitName) => traitIndex.byName.get(traitName)?.config,
-      getState: (traitName) => store.manager.getState(traitName)?.currentState ?? "",
-      subscribe: (_traitName, callback) => store.subscribe(callback)
-    };
-  }, [store, traitIndex]);
-}
-function sameFields(a, b) {
-  const keys = Object.keys(b);
-  if (Object.keys(a).length !== keys.length) return false;
-  for (const key of keys) {
-    if (!Object.is(a[key], b[key])) return false;
-  }
-  return true;
-}
-function useAwaitingSkeletonSource(store, traitIndex, embeddedTraits) {
-  return useMemo(() => {
-    const activeRenders = () => {
-      const renders = [];
-      for (const awaiting of store.awaiting.list()) {
-        const transitions = traitIndex.byName.get(awaiting.trait)?.irTrait.stateMachine?.transitions ?? [];
-        const taken = transitions.find((t) => t.event === awaiting.event && t.from === awaiting.from);
-        if (taken?.awaitRender) renders.push(...taken.awaitRender);
-      }
-      return renders;
-    };
-    return {
-      forSlot: (slot) => activeRenders().find((r) => r.slot === slot && !(embeddedTraits?.has(r.trait) ?? false))?.skeleton,
-      forTrait: (traitName) => activeRenders().find((r) => r.trait === traitName)?.skeleton,
-      subscribe: (callback) => store.awaiting.subscribeAll(callback),
-      getVersion: () => store.awaiting.getVersion()
-    };
-  }, [store, traitIndex, embeddedTraits]);
-}
-
-// hooks/useTraitStateMachine.ts
-var MOUNT_ERROR_SOURCE = "$mount";
-var stateLog = createLogger("almadar:ui:state-transitions");
-function diffDroppedTraitNames(prev, next) {
-  const dropped = [];
-  for (const name of prev) {
-    if (!next.has(name)) dropped.push(name);
-  }
-  return dropped;
-}
-function normalizeEventKey(eventKey) {
-  return eventKey.startsWith("UI:") ? eventKey.slice(3) : eventKey;
-}
-function useTraitStateMachine(traitBindings, uiSlots, options) {
-  const eventBus = useEventBus();
-  const { user: contextViewer } = useUser();
-  const { t } = useTranslate();
-  const userContext = options.user ?? contextViewer ?? void 0;
-  const observer = useMemo(() => createCircuitVerificationObserver(), []);
-  const { kernel, store, traitIndex, appTraitNames, transport } = useCircuitKernel(traitBindings, {
-    orbitals: options.orbitals,
-    ...options.traitConfigsByName !== void 0 ? { traitConfigsByName: options.traitConfigsByName } : {},
-    ...options.transport !== void 0 ? { transport: options.transport } : {},
-    ...options.carriesCircuitState !== void 0 ? { carriesCircuitState: options.carriesCircuitState } : {},
-    ...options.awaitTopology !== void 0 ? { awaitTopology: options.awaitTopology } : {},
-    ...options.persistence !== void 0 ? { persistence: options.persistence } : {},
-    ...options.browserStore !== void 0 ? { browserStore: options.browserStore } : {},
-    ...options.callService !== void 0 ? { callService: options.callService } : {},
-    ...userContext !== void 0 ? { user: userContext } : {},
-    ...options.debug !== void 0 ? { debug: options.debug } : {},
-    ...options.logContext !== void 0 ? { logContext: options.logContext } : {},
-    observer
-  });
-  const slotFlush = useSlotFlush(uiSlots, options.embeddedTraits);
-  const reRenderCallsiteCaptureChildren = useCallsiteCapture(traitBindings, store, traitIndex, slotFlush, {
-    ...options.callsiteCaptureChildrenByTrait !== void 0 ? { callsiteCaptureChildrenByTrait: options.callsiteCaptureChildrenByTrait } : {},
-    eventBus,
-    ...options.navigate !== void 0 ? { navigate: options.navigate } : {},
-    ...options.navigateBack !== void 0 ? { navigateBack: options.navigateBack } : {},
-    ...userContext !== void 0 ? { user: userContext } : {}
-  });
-  useClientTicks(traitBindings, store, traitIndex, {
-    eventBus,
-    slotFlush,
-    hostRunsProgram: transport?.hostsBrowserStore === true,
-    ...options.traitConfigsByName !== void 0 ? { traitConfigsByName: options.traitConfigsByName } : {},
-    ...options.navigate !== void 0 ? { navigate: options.navigate } : {},
-    ...options.navigateBack !== void 0 ? { navigateBack: options.navigateBack } : {},
-    ...userContext !== void 0 ? { user: userContext } : {}
-  });
-  const entityBindingSource = useEntityBindingSource(store, traitIndex);
-  const awaitingSkeletonSource = useAwaitingSkeletonSource(store, traitIndex, options.embeddedTraits);
-  const activeTraitNamesRef = useRef(/* @__PURE__ */ new Set());
-  useEffect(() => {
-    activeTraitNamesRef.current = new Set(traitIndex.byName.keys());
-  }, [traitIndex]);
-  useEffect(() => {
-    const ids = [];
-    for (const binding of traitBindings) {
-      const trait = binding.trait;
-      const state = store.manager.getState(trait.name);
-      const info = {
-        id: trait.name,
-        name: trait.name,
-        currentState: state?.currentState ?? trait.states[0]?.name ?? "unknown",
-        states: trait.states.map((s) => s.name),
-        transitions: trait.transitions.flatMap((t2) => {
-          const froms = Array.isArray(t2.from) ? t2.from : [t2.from];
-          return froms.map((f) => ({ from: f, to: t2.to, event: t2.event, guard: t2.guard ? String(t2.guard) : void 0 }));
-        }),
-        guards: trait.transitions.filter((t2) => t2.guard).map((t2) => ({ name: String(t2.guard) })),
-        transitionCount: 0
-      };
-      registerTrait(info);
-      ids.push(trait.name);
-    }
-    bindTraitStateGetter((traitName) => store.manager.getState(traitName)?.currentState);
-    const snapshotData = (traitName) => {
-      const entry = traitIndex.byName.get(traitName);
-      const frame = entry !== void 0 ? store.frames.get(entry.frameKey) : void 0;
-      const entityName = entry?.entity.name;
-      return frame !== void 0 && entityName !== void 0 ? { [entityName]: [{ ...frame }] } : {};
-    };
-    const snapshotUnregs = traitBindings.map((binding) => registerTraitSnapshot(binding.trait.name, () => {
-      const currentState = store.manager.getState(binding.trait.name)?.currentState ?? binding.trait.states[0]?.name ?? "unknown";
-      return {
-        traitName: binding.trait.name,
-        currentState,
-        states: binding.trait.states.map((s) => s.name),
-        events: binding.trait.events.map((e) => e.key),
-        data: snapshotData(binding.trait.name),
-        cascadeReceived: []
-      };
-    }));
-    return () => {
-      for (const id of ids) unregisterTrait(id);
-      for (const unreg of snapshotUnregs) unreg();
-    };
-  }, [traitBindings, store, traitIndex]);
-  const afterSettle = useCallback(async (traitName, eventKey, payload, transitioned, repaints, composedBefore) => {
-    if (transitioned) {
-      const entityByTrait = {};
-      for (const [name, entry] of traitIndex.byName) {
-        const row = store.frames.get(entry.frameKey);
-        if (row !== void 0) entityByTrait[name] = row;
-      }
-      const repainted = new Set(repaints.map((e) => e.traitName));
-      const serverComposed = new Set([...store.callsitePayloads].filter(([child, composed]) => composedBefore.get(child) !== composed).map(([child]) => child));
-      const irTrait = traitIndex.byName.get(traitName)?.irTrait;
-      const composedBy = irTrait !== void 0 ? traitsEmbeddedByEvent(irTrait, eventKey) : void 0;
-      await reRenderCallsiteCaptureChildren(traitName, payload ?? {}, entityByTrait, repainted, serverComposed, false, composedBy);
-    }
-    options.onEventProcessed?.(eventKey, payload);
-  }, [traitIndex, store, reRenderCallsiteCaptureChildren, options.onEventProcessed]);
-  const settleOutcome = useCallback(async (traitName, eventKey, payload, outcome, composedBefore) => {
-    recordDispatchVerdict(traitIndex.byName.get(traitName)?.orbitalName ?? traitName, eventKey, { response: outcome.response });
-    const settledEffects = outcome.localPainted && outcome.serverEffects !== void 0 ? outcome.serverEffects : outcome.response;
-    slotFlush.applyClientEffects(
-      settledEffects.clientEffects ?? [],
-      settledEffects.clientEffectsByTrait,
-      options.navigate,
-      options.navigateBack,
-      activeTraitNamesRef.current
-    );
-    for (const emitted of outcome.response.emittedEvents) {
-      eventBus.emit(`UI:${emitted.event}`, emitted.payload, { ...emitted.source ?? {}, dispatched: true });
-    }
-    stateLog.debug("dispatch:settled", { traitName, eventKey, mode: outcome.mode, transitioned: outcome.response.transitioned });
-    await afterSettle(traitName, eventKey, payload, outcome.response.transitioned, outcome.response.clientEffectsByTrait ?? [], composedBefore);
-  }, [slotFlush, traitIndex, eventBus, options.navigate, options.navigateBack, afterSettle]);
-  const dispatchAndSettle = useCallback(async (traitName, eventKey, payload, tick) => {
-    const entityId = typeof payload?.entityId === "string" ? payload.entityId : void 0;
-    const orbitalName = traitIndex.byName.get(traitName)?.orbitalName ?? traitName;
-    let outcome;
-    const composedBefore = new Map(store.callsitePayloads);
-    let beforeLocalPaint;
-    try {
-      outcome = await kernel.dispatch({
-        event: eventKey,
-        ...payload !== void 0 ? { payload } : {},
-        ...entityId !== void 0 ? { entityId } : {},
-        ...tick !== void 0 ? { tick } : {},
-        targetTrait: traitName
-      }, {
-        onLocal: (local) => {
-          beforeLocalPaint = slotFlush.checkpoint();
-          slotFlush.applyClientEffects(
-            local.clientEffects ?? [],
-            local.clientEffectsByTrait,
-            options.navigate,
-            options.navigateBack,
-            activeTraitNamesRef.current
-          );
-        }
-      });
-    } catch (err) {
-      if (beforeLocalPaint !== void 0) slotFlush.rollback(beforeLocalPaint);
-      recordDispatchVerdict(orbitalName, eventKey, { error: err instanceof Error ? err : String(err) });
-      throw err;
-    }
-    if (outcome.localPainted && !outcome.response.success && beforeLocalPaint !== void 0) {
-      slotFlush.rollback(beforeLocalPaint);
-    }
-    await settleOutcome(traitName, eventKey, payload, outcome, composedBefore);
-  }, [kernel, slotFlush, traitIndex, store, options.navigate, options.navigateBack, settleOutcome]);
-  const progressAndSettle = useCallback(async (traitName, eventKey, payload) => {
-    const entityId = typeof payload?.entityId === "string" ? payload.entityId : void 0;
-    const composedBefore = new Map(store.callsitePayloads);
-    const outcome = await kernel.dispatchProgress({
-      event: eventKey,
-      ...payload !== void 0 ? { payload } : {},
-      ...entityId !== void 0 ? { entityId } : {},
-      targetTrait: traitName
-    });
-    await settleOutcome(traitName, eventKey, payload, outcome, composedBefore);
-  }, [kernel, store, settleOutcome]);
-  useEffect(() => {
-    if (!transport?.subscribe) return;
-    return transport.subscribe((emitted, target) => {
-      const listeners = collectListenerTargets(traitIndex, emitted.source, emitted.event, emitted.payload);
-      if (target !== "origin") {
-        for (const t2 of listeners) void dispatchAndSettle(t2.listenerTrait, t2.triggers, t2.payload);
-        return;
-      }
-      const caller = emitted.source?.trait;
-      if (caller !== void 0 && traitIndex.byName.has(caller) && !listeners.some((t2) => t2.listenerTrait === caller && t2.triggers === emitted.event)) {
-        void progressAndSettle(caller, emitted.event, emitted.payload);
-      }
-      for (const t2 of listeners) void progressAndSettle(t2.listenerTrait, t2.triggers, t2.payload);
-    }, { clientId: getTabClientId() });
-  }, [transport, traitIndex, progressAndSettle, dispatchAndSettle]);
-  useEffect(() => {
-    if (!transport?.subscribeHostDispatches) return;
-    return transport.subscribeHostDispatches((_orbitalName, request, response) => {
-      const traitName = request.targetTrait;
-      if (traitName === void 0 || !traitIndex.byName.has(traitName)) return;
-      const composedBefore = new Map(store.callsitePayloads);
-      void kernel.foldHostDispatch(request, response).then((outcome) => settleOutcome(traitName, request.event, request.payload, outcome, composedBefore));
-    }, { clientId: getTabClientId() });
-  }, [transport, traitIndex, kernel, store, settleOutcome]);
-  const mountAndSettle = useCallback(async (seeds, payload) => {
-    const composedBefore = new Map(store.callsitePayloads);
-    let beforeLocalPaint;
-    let outcome;
-    try {
-      outcome = await kernel.dispatchMount(seeds, {
-        onLocal: (_trait, local) => {
-          if (beforeLocalPaint === void 0) beforeLocalPaint = slotFlush.checkpoint();
-          slotFlush.applyClientEffects(local.clientEffects ?? [], local.clientEffectsByTrait, options.navigate, options.navigateBack, activeTraitNamesRef.current);
-        }
-      }, { payload });
-    } catch (err) {
-      if (beforeLocalPaint !== void 0) slotFlush.rollback(beforeLocalPaint);
-      for (const seed of seeds) {
-        recordDispatchVerdict(traitIndex.byName.get(seed.trait)?.orbitalName ?? seed.trait, seed.event, { error: err instanceof Error ? err : String(err) });
-      }
-      throw err;
-    }
-    if (!outcome.success && beforeLocalPaint !== void 0) slotFlush.rollback(beforeLocalPaint);
-    slotFlush.applyClientEffects(outcome.serverEffects.clientEffects ?? [], outcome.serverEffects.clientEffectsByTrait, options.navigate, options.navigateBack, activeTraitNamesRef.current);
-    const emitted = [...outcome.seeds.flatMap((seed) => seed.local.emittedEvents), ...outcome.emittedEvents];
-    for (const e of emitted) {
-      eventBus.emit(`UI:${e.event}`, e.payload, { ...e.source ?? {}, dispatched: true });
-    }
-    const serverRepaints = outcome.serverEffects.clientEffectsByTrait ?? [];
-    for (const seed of outcome.seeds) {
-      recordDispatchVerdict(traitIndex.byName.get(seed.trait)?.orbitalName ?? seed.trait, seed.event, {
-        response: { ...seed.local, success: outcome.success, ...outcome.error !== void 0 ? { error: outcome.error } : {} }
-      });
-      stateLog.debug("mount:settled", { traitName: seed.trait, eventKey: seed.event, mode: seed.mode, transitioned: seed.local.transitioned });
-      await afterSettle(seed.trait, seed.event, payload, seed.local.transitioned, [...seed.local.clientEffectsByTrait ?? [], ...serverRepaints], composedBefore);
-    }
-  }, [kernel, slotFlush, traitIndex, store, eventBus, options.navigate, options.navigateBack, afterSettle]);
-  useBusIngress(traitBindings, traitIndex, dispatchAndSettle, eventBus, appTraitNames);
-  const sendEvent = useCallback((eventKey, payload) => {
-    const normalized = normalizeEventKey(eventKey);
-    for (const [traitName] of traitIndex.byName) {
-      if (!store.manager.canHandleEvent(traitName, normalized)) continue;
-      void dispatchAndSettle(traitName, normalized, payload);
-    }
-  }, [traitIndex, store, dispatchAndSettle]);
-  const getTraitState = useCallback((traitName) => store.manager.getState(traitName), [store]);
-  const canHandleEvent = useCallback((traitName, eventKey) => store.manager.canHandleEvent(traitName, normalizeEventKey(eventKey)), [store]);
-  const prevActiveTraitNamesRef = useRef(/* @__PURE__ */ new Set());
-  useEffect(() => {
-    const nextActiveTraitNames = new Set(
-      traitBindings.map((b) => b.trait.name).filter((n) => !!n)
-    );
-    const dropped = diffDroppedTraitNames(prevActiveTraitNamesRef.current, nextActiveTraitNames);
-    if (dropped.length > 0) {
-      for (const traitName of dropped) {
-        for (const slot of ALL_SLOTS) {
-          uiSlots.clearBySource(slot, traitName);
-        }
-      }
-    }
-    prevActiveTraitNamesRef.current = nextActiveTraitNames;
-  }, [traitBindings, uiSlots]);
-  const mountedRef = useRef(null);
-  const aliveRef = useRef(true);
-  useEffect(() => {
-    aliveRef.current = true;
-    return () => {
-      aliveRef.current = false;
-    };
-  }, []);
-  const mountKey = `${options.mountKey ?? ""}\0${JSON.stringify(Object.entries(options.initPayload ?? {}).sort(([a], [b]) => a.localeCompare(b)))}`;
-  useEffect(() => {
-    const prev = mountedRef.current;
-    const mount = prev !== null && prev.key === mountKey && prev.store === store ? prev : { key: mountKey, store, initialized: /* @__PURE__ */ new Set() };
-    const active = new Set(traitBindings.map((b) => b.trait.name));
-    const left = [...mount.initialized].filter((traitName) => !active.has(traitName));
-    for (const traitName of left) mount.initialized.delete(traitName);
-    store.mount.unmounted(left);
-    const entering = [];
-    const embeddedChildren = new Set([...options.callsiteCaptureChildrenByTrait?.values() ?? []].flatMap((c) => [...c]));
-    for (const binding of traitBindings) {
-      const traitName = binding.trait.name;
-      if (mount.initialized.has(traitName)) continue;
-      mount.initialized.add(traitName);
-      const indexed = traitIndex.byName.get(traitName);
-      if (embeddedChildren.has(traitName) && indexed !== void 0 && (traitReferencesCallsitePayload(indexed.irTrait) || configReferencesCallsitePayload(indexed.config)) && store.manager.repaintLifecycleEvent(traitName) !== void 0 && !store.callsitePayloads.has(traitName)) {
-        continue;
-      }
-      const lifecycleEvent = LIFECYCLE_EVENTS.find((evt) => store.manager.canHandleEvent(traitName, evt));
-      if (lifecycleEvent !== void 0) entering.push({ trait: traitName, event: lifecycleEvent });
-    }
-    store.mount.mounting(entering.map((e) => e.trait));
-    if (entering.length > 0) {
-      uiSlots.clearBySource("main", MOUNT_ERROR_SOURCE);
-      void mountAndSettle(entering, { ...options.initPayload ?? {} }).catch((err) => {
-        const traits = entering.map((e) => e.trait);
-        const message = err instanceof Error ? err.message : String(err);
-        const failed = err instanceof TraitMountError ? err.trait : traits.join(", ");
-        const cause = err instanceof TraitMountError ? err.original : err;
-        stateLog.warn("mount:failed", { traits, failed, error: message, stack: cause instanceof Error ? cause.stack : void 0 });
-        if (!aliveRef.current) return;
-        uiSlots.render({
-          target: "main",
-          pattern: "error-state",
-          props: { title: t("error.traitMountFailed", { trait: failed }), message, "data-testid": TRAIT_MOUNT_ERROR_TESTID },
-          sourceTrait: MOUNT_ERROR_SOURCE
-        });
-      });
-    }
-    mountedRef.current = mount;
-  }, [traitBindings, store, mountAndSettle, mountKey, uiSlots, traitIndex, options.callsiteCaptureChildrenByTrait, t]);
-  useSyncExternalStore(store.subscribe, store.getVersion, store.getVersion);
-  const traitStates = useMemo(() => store.manager.getAllStates(), [store, store.getVersion()]);
-  return { traitStates, sendEvent, getTraitState, canHandleEvent, entityBindingSource, awaitingSkeletonSource };
-}
-function useBrowserStore(appName, orbitals, locale) {
-  const entities = useMemo(() => orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser), [orbitals]);
-  const [state, setState] = useState(() => entities.length === 0 ? { status: "none" } : { status: "opening" });
-  useEffect(() => {
-    if (entities.length === 0) {
-      setState({ status: "none" });
-      return;
-    }
-    let cancelled = false;
-    let opened;
-    setState({ status: "opening" });
-    const open = async () => {
-      try {
-        const store = await openBrowserStore(browserStoreName(appName, locale), orbitals, void 0, locale);
-        if (store === null) return;
-        opened = store;
-        if (!cancelled) setState({ status: "ready", store });
-      } catch (err) {
-        if (!cancelled) setState({ status: "failed", error: err instanceof Error ? err : new Error(String(err)) });
-      }
-    };
-    void open();
-    return () => {
-      cancelled = true;
-      opened?.close();
-    };
-  }, [appName, locale, entities, orbitals]);
-  return state;
-}
-
-// runtime/fitContent.ts
-var IDENTITY = { scale: 1, x: 0, y: 0 };
-function fitContentTransform(box, content) {
-  if (box.width <= 0 || box.height <= 0 || content.width <= 0 || content.height <= 0) return IDENTITY;
-  const scale = Math.min(1, box.width / content.width, box.height / content.height);
-  return {
-    scale,
-    x: box.width / 2 - (content.x + content.width / 2) * scale,
-    y: box.height / 2 - (content.y + content.height / 2) * scale
-  };
-}
-function slotContentRect(inner, scale) {
-  const origin = inner.getBoundingClientRect();
-  let left = Infinity;
-  let top = Infinity;
-  let right = -Infinity;
-  let bottom = -Infinity;
-  for (const slot of Array.from(inner.querySelectorAll("[data-orb-slot]"))) {
-    for (const child of Array.from(slot.querySelectorAll("*"))) {
-      const r = child.getBoundingClientRect();
-      if (r.width === 0 && r.height === 0) continue;
-      left = Math.min(left, r.left);
-      top = Math.min(top, r.top);
-      right = Math.max(right, r.right);
-      bottom = Math.max(bottom, r.bottom);
-    }
-  }
-  if (left === Infinity) return null;
-  return {
-    x: (left - origin.left) / scale,
-    y: (top - origin.top) / scale,
-    width: (right - left) / scale,
-    height: (bottom - top) / scale
-  };
-}
-var xOrbitalLog = createLogger("almadar:runtime:cross-orbital");
-var navLog = createLogger("almadar:runtime:navigation");
-function NavStackRefBridge({ apiRef }) {
-  const api = useNavStack();
-  useEffect(() => {
-    apiRef.current = api;
-    return () => {
-      apiRef.current = null;
-    };
-  }, [api, apiRef]);
-  return null;
-}
-function HostHrefBaseProbe({ onBase }) {
-  const base = useHref("/");
-  useEffect(() => onBase(base), [base, onBase]);
-  return null;
-}
-function appPathFromHref(href, hostHrefBase) {
-  const root = hostHrefBase.endsWith("/") ? hostHrefBase.slice(0, -1) : hostHrefBase;
-  if (href === root) return "/";
-  if (!href.startsWith(`${root}/`)) return null;
-  return href.slice(root.length);
-}
-function TraitInitializer({ traits, routeParams, mountKey, orbitals, onNavigate, onNavigateBack, onLocalFallback, localFallbackTimeoutMs, persistence, browserStore, traitConfigsByName, embeddedTraits, callsiteCaptureChildrenByTrait, hasBridge, children }) {
-  const bridge = useServerBridge();
-  const uiSlots = useUISlots();
-  useEffect(() => {
-    if (!hasBridge) return;
-    const timer = setTimeout(() => {
-      if (!bridge.connected) onLocalFallback?.();
-    }, localFallbackTimeoutMs ?? 5e3);
-    return () => clearTimeout(timer);
-  }, [hasBridge, bridge.connected, onLocalFallback, localFallbackTimeoutMs]);
-  const { entityBindingSource, awaitingSkeletonSource } = useTraitStateMachine(traits, uiSlots, {
-    orbitals,
-    ...onNavigate !== void 0 ? { navigate: onNavigate } : {},
-    ...onNavigateBack !== void 0 ? { navigateBack: onNavigateBack } : {},
-    ...traitConfigsByName !== void 0 ? { traitConfigsByName } : {},
-    ...embeddedTraits !== void 0 ? { embeddedTraits } : {},
-    ...callsiteCaptureChildrenByTrait !== void 0 ? { callsiteCaptureChildrenByTrait } : {},
-    initPayload: routeParams,
-    ...mountKey !== void 0 ? { mountKey } : {},
-    ...hasBridge ? { transport: bridge.transport, carriesCircuitState: bridge.carriesCircuitState, awaitTopology: !bridge.topologyKnown } : { persistence },
-    ...browserStore !== void 0 ? { browserStore } : {}
-  });
-  return /* @__PURE__ */ jsx(EntityBindingContext.Provider, { value: entityBindingSource, children: /* @__PURE__ */ jsx(AwaitingSkeletonContext.Provider, { value: awaitingSkeletonSource, children }) });
-}
-var CONTENT_STAGE_WIDTH = 480;
-var NO_ORBITALS = [];
-var LazyPageOfRegisteredProgram = createContext(false);
-function FitToBox({ children, mode = "box" }) {
-  const outerRef = useRef(null);
-  const innerRef = useRef(null);
-  const [fitted, setFitted] = useState({ scale: 1, x: 0, y: 0 });
-  const scaleRef = useRef(1);
-  useEffect(() => {
-    const outer = outerRef.current;
-    const inner = innerRef.current;
-    if (!outer || !inner) return;
-    const update = () => {
-      const cw = outer.clientWidth;
-      const ch = outer.clientHeight;
-      if (mode === "content") {
-        const rect = slotContentRect(inner, scaleRef.current);
-        if (!rect) return;
-        const next = fitContentTransform({ width: cw, height: ch }, rect);
-        scaleRef.current = next.scale;
-        setFitted(next);
-        return;
-      }
-      const sw = inner.scrollWidth;
-      const sh = inner.scrollHeight;
-      if (!sw || !sh || !cw || !ch) return;
-      setFitted({ scale: Math.min(1, cw / sw, ch / sh), x: 0, y: 0 });
-    };
-    update();
-    const cleanups = [];
-    if (typeof ResizeObserver !== "undefined") {
-      const ro = new ResizeObserver(update);
-      ro.observe(outer);
-      ro.observe(inner);
-      cleanups.push(() => ro.disconnect());
-    }
-    if (mode === "content" && typeof MutationObserver !== "undefined") {
-      let frame = 0;
-      const schedule = () => {
-        cancelAnimationFrame(frame);
-        frame = requestAnimationFrame(update);
-      };
-      const mo = new MutationObserver(schedule);
-      mo.observe(inner, { childList: true, subtree: true, attributes: true, characterData: true });
-      schedule();
-      cleanups.push(() => {
-        mo.disconnect();
-        cancelAnimationFrame(frame);
-      });
-    }
-    return () => cleanups.forEach((c) => c());
-  }, [mode]);
-  return /* @__PURE__ */ jsx("div", { ref: outerRef, className: "relative h-full w-full overflow-hidden", "data-fit-mode": mode, children: /* @__PURE__ */ jsx(
-    "div",
-    {
-      ref: innerRef,
-      style: {
-        transform: `translate(${fitted.x}px, ${fitted.y}px) scale(${fitted.scale})`,
-        transformOrigin: "top left",
-        width: mode === "content" ? CONTENT_STAGE_WIDTH : "fit-content"
-      },
-      children
-    }
-  ) });
-}
-function SchemaRunner({ schema, serverUrl, transport, getAccessToken, mockData, pageName, routeParams, onNavigate, onNavigateBack, onLocalFallback, localFallbackTimeoutMs, persistence, themeOverride }) {
-  const { traits, allEntities, allTraits, ir } = useResolvedSchema(schema, pageName);
-  const allPageTraits = useMemo(() => {
-    let base;
-    if (pageName && traits.length > 0) {
-      base = traits;
-    } else if (!ir?.pages || ir.pages.size <= 1) {
-      base = traits;
-    } else {
-      const firstPage = ir.pages.values().next().value;
-      if (!firstPage) {
-        base = traits;
-      } else {
-        const firstPageTraits = [];
-        const seen = /* @__PURE__ */ new Set();
-        for (const binding of firstPage.traits) {
-          const name = binding.trait.name;
-          if (name && !seen.has(name)) {
-            seen.add(name);
-            firstPageTraits.push(binding);
-          }
-        }
-        base = firstPageTraits.length > 0 ? firstPageTraits : traits;
-      }
-    }
-    const byName = new Set(base.map((b) => b.trait.name));
-    const extra = [];
-    const queue = [...base];
-    while (queue.length > 0) {
-      const binding = queue.shift();
-      if (!binding) continue;
-      for (const refName of collectTraitRefsFromResolvedTrait(binding.trait)) {
-        if (byName.has(refName)) continue;
-        const rt = allTraits.get(refName);
-        if (!rt) continue;
-        byName.add(refName);
-        const sibling = { trait: rt, linkedEntity: rt.linkedEntity };
-        extra.push(sibling);
-        queue.push(sibling);
-      }
-    }
-    return extra.length > 0 ? [...base, ...extra] : base;
-  }, [ir, traits, pageName, allTraits]);
-  const orbitalsByTrait = useMemo(
-    () => buildOrbitalsByTrait(
-      schema,
-      ir ? Array.from(ir.pages.values()).map((p) => ({
-        path: p.path,
-        traitNames: p.traits.map((b) => b.trait.name)
-      })) : []
-    ),
-    [schema, ir]
-  );
-  const traitLinkedEntitiesMap = useMemo(() => {
-    const map = /* @__PURE__ */ new Map();
-    if (ir) {
-      for (const page of ir.pages.values()) {
-        for (const binding of page.traits) {
-          if (binding.linkedEntity) {
-            map.set(binding.trait.name, binding.linkedEntity);
-          }
-        }
-      }
-    }
-    return map;
-  }, [ir]);
-  const orbitalsByTraitMap = useMemo(
-    () => new Map(Object.entries(orbitalsByTrait)),
-    [orbitalsByTrait]
-  );
-  const entitiesArray = useMemo(() => Array.from(allEntities.values()), [allEntities]);
-  const pageOrbitalNames = useMemo(() => {
-    const set = /* @__PURE__ */ new Set();
-    for (const binding of allPageTraits) {
-      const orb = orbitalsByTrait[binding.trait.name];
-      if (orb) set.add(orb);
-    }
-    return Array.from(set);
-  }, [allPageTraits, orbitalsByTrait]);
-  useEffect(() => {
-    const traitNames = allPageTraits.map((b) => b.trait.name);
-    const orbitalsByTraitForPage = {};
-    for (const name of traitNames) {
-      const orb = orbitalsByTrait[name];
-      if (orb) orbitalsByTraitForPage[name] = orb;
-    }
-    xOrbitalLog.info("SchemaRunner:mount", {
-      pageName,
-      traitNames: traitNames.join(","),
-      orbitalsByTraitForPage,
-      pageOrbitalNames: pageOrbitalNames.join(",")
-    });
-  }, [pageName, allPageTraits, orbitalsByTrait, pageOrbitalNames]);
-  const traitConfigsByName = useMemo(
-    () => buildResolvedTraitConfigs(schema),
-    [schema]
-  );
-  const callsiteCaptureChildrenByTrait = useMemo(() => {
-    const merged = /* @__PURE__ */ new Map();
-    const orbitals = schema?.orbitals;
-    if (orbitals) {
-      for (const orbital of orbitals) {
-        for (const [referrer, children] of collectCallsiteCaptureChildren(orbital)) {
-          merged.set(referrer, children);
-        }
-      }
-    }
-    return merged;
-  }, [schema]);
-  const embeddedTraits = useMemo(() => {
-    const set = collectEmbeddedTraits(schema);
-    xOrbitalLog.info("SchemaRunner:embeddedTraits", {
-      pageName,
-      embedded: Array.from(set),
-      embeddedCount: set.size
-    });
-    return set;
-  }, [schema, pageName]);
-  const activeOrbitalTheme = useMemo(() => resolvePreviewTheme(schema, pageName), [schema, pageName]);
-  const { locale } = useTranslate$1();
-  const browserStore = useBrowserStore(schema.name ?? "app", transport?.hostsBrowserStore === true ? NO_ORBITALS : schema.orbitals, locale);
-  const inner = /* @__PURE__ */ jsx(VerificationProvider, { enabled: true, children: /* @__PURE__ */ jsx(
-    EntitySchemaProvider,
-    {
-      entities: entitiesArray,
-      traitLinkedEntities: traitLinkedEntitiesMap,
-      orbitalsByTrait: orbitalsByTraitMap,
-      children: /* @__PURE__ */ jsx(
-        TraitInitializer,
-        {
-          traits: allPageTraits,
-          routeParams,
-          mountKey: pageName,
-          orbitals: schema.orbitals,
-          hasBridge: Boolean(serverUrl || transport),
-          traitConfigsByName,
-          embeddedTraits,
-          callsiteCaptureChildrenByTrait,
-          onNavigate,
-          onNavigateBack,
-          onLocalFallback,
-          localFallbackTimeoutMs,
-          persistence,
-          ...browserStore.status === "ready" ? { browserStore: browserStore.store } : {},
-          children: /* @__PURE__ */ jsx(OrbitalThemeProvider, { theme: activeOrbitalTheme, override: themeOverride, children: /* @__PURE__ */ jsx(Box, { className: "h-full min-h-full overflow-auto p-4", children: /* @__PURE__ */ jsx(UISlotRenderer, { includeHud: true, hudMode: "inline", includeFloating: true, pageKey: pageName }) }) })
-        }
-      )
-    }
-  ) });
-  if (browserStore.status === "opening") return /* @__PURE__ */ jsx(LoadingState, {});
-  if (browserStore.status === "failed") {
-    return /* @__PURE__ */ jsx(ErrorState, { "data-testid": "browser-store-error", message: browserStore.error.message });
-  }
-  return inner;
-}
-function resolvePreviewTheme(schema, pageName) {
-  if (!schema.orbitals?.length) return schema.theme;
-  if (pageName) {
-    for (const orb of schema.orbitals) {
-      for (const pageRef of orb.pages ?? []) {
-        const name = typeof pageRef === "object" && pageRef !== null && "name" in pageRef ? pageRef.name : void 0;
-        if (name === pageName) return orb.theme ?? schema.theme;
-      }
-    }
-  }
-  return schema.orbitals[0]?.theme ?? schema.theme;
-}
-function NavigateListener({ onNavigate }) {
-  const bus = useEventBus();
-  useEffect(
-    () => bus.on("UI:NAVIGATE", (event) => {
-      const url = event.payload?.url;
-      if (typeof url === "string" && url.length > 0) onNavigate(url);
-    }),
-    [bus, onNavigate]
-  );
-  return null;
-}
-function OrbPreview({
-  schema,
-  mockData,
-  autoMock = false,
-  height = "400px",
-  className,
-  serverUrl,
-  transport,
-  getAccessToken,
-  initialPagePath,
-  isolated = false,
-  fit = false,
-  onPageChange,
-  user = null,
-  localFallbackTimeoutMs,
-  themeOverride,
-  lazyLoader,
-  schemaPath,
-  onUnmatchedNavigate
-}) {
-  if (serverUrl && transport) {
-    throw new Error("OrbPreview accepts serverUrl OR transport, not both");
-  }
-  const { t } = useTranslate$1();
-  const [localFallback, setLocalFallback] = useState(false);
-  const inHostRouter = useInRouterContext();
-  const [hostHrefBase, setHostHrefBase] = useState("/");
-  const handleLocalFallback = useCallback(() => {
-    if (localFallback) return;
-    setLocalFallback(true);
-  }, [localFallback]);
-  const isLazyPageOfRegisteredProgram = useContext(LazyPageOfRegisteredProgram);
-  const parseResult = useMemo(() => {
-    let parsed;
-    if (typeof schema === "string") {
-      try {
-        parsed = JSON.parse(schema);
-      } catch (e) {
-        return { ok: false, error: String(e) };
-      }
-    } else {
-      parsed = schema;
-    }
-    if (autoMock && !serverUrl && !transport) {
-      const prepared = prepareSchemaForPreview(parsed);
-      return { ok: true, schema: prepared.schema, mockData: prepared.mockData };
-    }
-    return { ok: true, schema: parsed, mockData: mockData ?? {} };
-  }, [schema, autoMock, serverUrl, transport, mockData]);
-  const parsedSchema = parseResult.ok ? parseResult.schema : null;
-  useArbitraryClassStyles(parsedSchema);
-  const effectiveMockData = parseResult.ok ? parseResult.mockData : {};
-  const persistence = useMemo(() => {
-    if (!parsedSchema || serverUrl || transport) return void 0;
-    if (!autoMock) return void 0;
-    const adapter = new InMemoryPersistence();
-    adapter.seed(effectiveMockData);
-    return adapter;
-  }, [parsedSchema, serverUrl, transport, autoMock, effectiveMockData]);
-  const pages = useMemo(() => {
-    if (!parsedSchema) return [];
-    try {
-      return getAllPages(parsedSchema);
-    } catch {
-      return [];
-    }
-  }, [parsedSchema]);
-  const lazyPages = useMemo(() => parsedSchema?.lazyPages ?? [], [parsedSchema]);
-  const matchRoute = useCallback((path) => {
-    const candidates = [
-      ...pages.map((entry) => ({ kind: "page", entry, path: entry.page.path })),
-      ...lazyPages.map((page) => ({ kind: "lazy", page, path: page.path }))
-    ];
-    const hit = matchPathAmong(candidates, path, (c) => c.path);
-    if (!hit) return null;
-    return hit.candidate.kind === "page" ? { kind: "page", entry: hit.candidate.entry, params: hit.params } : { kind: "lazy", page: hit.candidate.page, params: hit.params };
-  }, [pages, lazyPages]);
-  const initialRoute = useMemo(
-    () => initialPagePath ? matchRoute(initialPagePath) : null,
-    [matchRoute, initialPagePath]
-  );
-  const initialPageMatch = useMemo(() => {
-    if (initialRoute?.kind !== "page" || !initialRoute.entry.page.name) return void 0;
-    return { name: initialRoute.entry.page.name, params: initialRoute.params };
-  }, [initialRoute]);
-  const [lazyRoute, setLazyRoute] = useState(
-    initialRoute?.kind === "lazy" && initialPagePath ? { page: initialRoute.page, path: initialPagePath } : null
-  );
-  const [lazyLoad, setLazyLoad] = useState({ status: "loading" });
-  useEffect(() => {
-    if (!lazyRoute) return;
-    if (!lazyLoader) {
-      setLazyLoad({ status: "error", error: `No loader for lazy page ${lazyRoute.page.path} (${lazyRoute.page.orbRef})` });
-      return;
-    }
-    let cancelled = false;
-    setLazyLoad({ status: "loading" });
-    void loadLazyPage(lazyLoader, lazyRoute.page, schemaPath).then((result) => {
-      if (cancelled) return;
-      setLazyLoad(result.success ? { status: "ready", schema: result.data } : { status: "error", error: result.error });
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [lazyRoute?.page, lazyLoader, schemaPath]);
-  const initialPageName = initialPageMatch?.name;
-  const [currentPage, setCurrentPage] = useState(initialPageName);
-  const [routeParams, setRouteParams] = useState(initialPageMatch?.params ?? {});
-  const prevInitialPagePathRef = useRef(initialPagePath);
-  useEffect(() => {
-    if (prevInitialPagePathRef.current !== initialPagePath) {
-      prevInitialPagePathRef.current = initialPagePath;
-      setCurrentPage(initialPageName);
-      setRouteParams(initialPageMatch?.params ?? {});
-      setLazyRoute(initialRoute?.kind === "lazy" && initialPagePath ? { page: initialRoute.page, path: initialPagePath } : null);
-    }
-  }, [initialPagePath, initialPageName, initialPageMatch, initialRoute]);
-  const currentPagePath = useMemo(() => {
-    const activePageName = currentPage ?? pages[0]?.page.name;
-    const resolved = pages.find((p) => p.page.name === activePageName)?.page.path;
-    return resolved ?? initialPagePath;
-  }, [pages, currentPage, initialPagePath]);
-  const navPages = useMemo(
-    () => pages.filter((p) => typeof p.page.path === "string" && p.page.path.length > 0).map((p) => ({ path: p.page.path, name: p.page.name, orbital: p.orbitalName, label: p.page.label })),
-    [pages]
-  );
-  const concreteCurrentPath = useMemo(() => {
-    const pattern = currentPagePath ?? "/";
-    return pattern.replace(/:([A-Za-z0-9_]+)/g, (whole, key) => routeParams[key] ?? whole);
-  }, [currentPagePath, routeParams]);
-  const navStackRef = useRef(null);
-  const announcePage = useCallback((path) => {
-    if (onPageChange) {
-      onPageChange(path);
-    } else if (!isolated && typeof window !== "undefined") {
-      const url = new URL(window.location.href);
-      url.searchParams.set("page", path);
-      window.history.pushState({}, "", url.toString());
-      window.dispatchEvent(new PopStateEvent("popstate"));
-    }
-  }, [isolated, onPageChange]);
-  const handleNavigate = useCallback((path, navState) => {
-    const route = matchRoute(path);
-    if (!route) {
-      onUnmatchedNavigate?.(path);
-      return;
-    }
-    if (route.kind === "lazy") {
-      setLazyRoute({ page: route.page, path });
-      announcePage(path);
-      return;
-    }
-    setLazyRoute(null);
-    const match = route.entry;
-    const params = { ...route.params, ...navState ?? {} };
-    navLog.debug("handleNavigate", () => ({
-      path,
-      matched: match?.page.name ?? null,
-      params,
-      navState: navState ? JSON.stringify(navState) : void 0,
-      availablePaths: pages.map((p) => p.page.path)
-    }));
-    if (match.page.name) {
-      setRouteParams(params);
-      setCurrentPage(match.page.name);
-      announcePage(path);
-    }
-  }, [pages, matchRoute, announcePage, onUnmatchedNavigate]);
-  const handleNavigateEffect = useCallback(
-    (path, params, crumb) => {
-      navStackRef.current?.beginNavigate(path, crumb);
-      handleNavigate(path, params);
-    },
-    [handleNavigate]
-  );
-  const handleNavigateBack = useCallback(() => {
-    navStackRef.current?.back();
-  }, []);
-  if (!parseResult.ok) {
-    return /* @__PURE__ */ jsx(Box, { className, style: { height }, children: /* @__PURE__ */ jsxs(Typography, { as: "pre", color: "error", variant: "small", className: "font-mono whitespace-pre-wrap break-all m-0 p-4", children: [
-      "Parse error: ",
-      parseResult.error
-    ] }) });
-  }
-  const containerRef = useRef(null);
-  useEffect(() => {
-    const el = containerRef.current;
-    if (!el) return;
-    if (pages.length <= 1 && !isolated) {
-      navLog.debug("interceptor:skipped", { reason: "single-page schema", pageCount: pages.length });
-      return;
-    }
-    const handler = (e) => {
-      const anchor = e.target.closest("a");
-      if (!anchor) return;
-      const href = anchor.getAttribute("href") ?? anchor.getAttribute("to") ?? "";
-      navLog.debug("click:intercepted", {
-        href,
-        anchorText: anchor.textContent?.trim().slice(0, 40)
-      });
-      const external = href.startsWith("http") || href.startsWith("mailto:");
-      const appPath = external ? null : appPathFromHref(href, hostHrefBase);
-      if (isolated && appPath === null) {
-        e.preventDefault();
-        e.stopPropagation();
-        e.stopImmediatePropagation();
-        if (external) window.open(href, "_blank", "noopener,noreferrer");
-        navLog.debug("click:sandboxed", { href, external });
-        return;
-      }
-      if (appPath === null) {
-        navLog.debug("click:skipped", { href, reason: "not an in-app href", hostHrefBase });
-        return;
-      }
-      e.preventDefault();
-      e.stopPropagation();
-      e.stopImmediatePropagation();
-      handleNavigate(appPath);
-    };
-    el.addEventListener("click", handler, true);
-    navLog.info("interceptor:installed", { pageCount: pages.length, paths: pages.map((p) => p.page.path) });
-    return () => el.removeEventListener("click", handler, true);
-  }, [pages, handleNavigate, isolated, hostHrefBase]);
-  const withBridge = (node) => (serverUrl || transport) && !isLazyPageOfRegisteredProgram ? /* @__PURE__ */ jsx(ServerBridgeProvider, { schema: parseResult.schema, serverUrl, transport, getAccessToken, children: node }) : node;
-  if (lazyRoute) {
-    return withBridge(
-      /* @__PURE__ */ jsxs(Box, { ref: containerRef, className: `overflow-auto ${className ?? ""}`, style: { height }, children: [
-        lazyLoad.status === "loading" && /* @__PURE__ */ jsx(LoadingState, {}),
-        lazyLoad.status === "error" && /* @__PURE__ */ jsx(ErrorState, { "data-testid": "lazy-page-error", message: lazyLoad.error }),
-        lazyLoad.status === "ready" && /* @__PURE__ */ jsx(LazyPageOfRegisteredProgram.Provider, { value: true, children: /* @__PURE__ */ jsx(
-          OrbPreview,
-          {
-            schema: lazyLoad.schema,
-            autoMock,
-            height: "100%",
-            className: "border-0",
-            serverUrl,
-            transport,
-            getAccessToken,
-            initialPagePath: lazyRoute.path,
-            user,
-            isolated,
-            fit,
-            onPageChange: announcePage,
-            themeOverride,
-            lazyLoader,
-            onUnmatchedNavigate: handleNavigate
-          },
-          lazyRoute.page.orbRef
-        ) })
-      ] })
-    );
-  }
-  return withBridge(
-    /* @__PURE__ */ jsxs(
-      Box,
-      {
-        ref: containerRef,
-        className: `${fit ? "overflow-hidden" : "overflow-auto"} border border-[var(--color-border)] rounded-[var(--radius-md)] ${className ?? ""}`,
-        style: { height },
-        children: [
-          localFallback && /* @__PURE__ */ jsx(Box, { className: "px-3 py-2 bg-[var(--color-warning)] bg-opacity-10 border-b border-[var(--color-warning)] flex items-center gap-2", children: /* @__PURE__ */ jsx(Typography, { variant: "caption", className: "text-[var(--color-warning-foreground)] flex-1", children: t("orbPreview.serverUnreachable") }) }),
-          inHostRouter ? /* @__PURE__ */ jsx(HostHrefBaseProbe, { onBase: setHostHrefBase }) : null,
-          /* @__PURE__ */ jsx(CurrentPagePathProvider, { value: currentPagePath, children: /* @__PURE__ */ jsxs(
-            NavStackProvider,
-            {
-              pages: navPages,
-              currentPath: concreteCurrentPath,
-              navigate: handleNavigate,
-              storageKey: `almadar:navstack:${parseResult.schema.name ?? "preview"}`,
-              children: [
-                /* @__PURE__ */ jsx(NavStackRefBridge, { apiRef: navStackRef }),
-                /* @__PURE__ */ jsxs(OrbitalProvider, { initialData: effectiveMockData, skipTheme: true, verification: true, isolated, user, children: [
-                  /* @__PURE__ */ jsx(NavigateListener, { onNavigate: handleNavigate }),
-                  /* @__PURE__ */ jsx(UISlotProvider, { children: fit ? /* @__PURE__ */ jsx(FitToBox, { mode: fit === "content" ? "content" : "box", children: /* @__PURE__ */ jsx(
-                    SchemaRunner,
-                    {
-                      schema: parseResult.schema,
-                      serverUrl,
-                      transport,
-                      getAccessToken,
-                      mockData: effectiveMockData,
-                      pageName: currentPage,
-                      routeParams,
-                      onNavigate: handleNavigateEffect,
-                      onNavigateBack: handleNavigateBack,
-                      onLocalFallback: handleLocalFallback,
-                      localFallbackTimeoutMs,
-                      persistence,
-                      themeOverride
-                    }
-                  ) }) : /* @__PURE__ */ jsx(
-                    SchemaRunner,
-                    {
-                      schema: parseResult.schema,
-                      serverUrl,
-                      transport,
-                      getAccessToken,
-                      mockData: effectiveMockData,
-                      pageName: currentPage,
-                      routeParams,
-                      onNavigate: handleNavigateEffect,
-                      onNavigateBack: handleNavigateBack,
-                      onLocalFallback: handleLocalFallback,
-                      localFallbackTimeoutMs,
-                      persistence,
-                      themeOverride
-                    }
-                  ) })
-                ] })
-              ]
-            }
-          ) })
-        ]
-      }
-    )
-  );
-}
-OrbPreview.displayName = "OrbPreview";
-var playgroundLog = createLogger("almadar:ui:browser-playground");
-function BrowserPlayground({
-  schema,
-  mode = "mock",
-  initialPagePath,
-  height,
-  className,
-  paused,
-  fit,
-  onPageChange,
-  viewer,
-  messages,
-  locale,
-  lazyLoader,
-  schemaPath
-}) {
-  const [runtime] = useState(
-    () => new OrbitalServerRuntime({ mode, debug: false, ...viewer !== void 0 ? { defaultUser: viewer } : {} })
-  );
-  useEffect(() => {
-    if (paused === void 0) return;
-    if (paused) {
-      runtime.pauseTicks();
-    } else {
-      runtime.resumeTicks();
-    }
-  }, [runtime, paused]);
-  const lazySchemas = useMemo(() => {
-    const lazyPages = schema.lazyPages ?? [];
-    if (lazyPages.length === 0 || lazyLoader === void 0) return Promise.resolve([]);
-    return Promise.all(lazyPages.map(async (page) => {
-      const loaded = await loadLazyPage(lazyLoader, page, schemaPath);
-      if (!loaded.success) throw new Error(loaded.error);
-      return loaded.data;
-    }));
-  }, [schema.lazyPages, lazyLoader, schemaPath]);
-  const registerProgram = useCallback((program) => {
-    const orbitalNames = program.orbitals.map((o) => o.name);
-    playgroundLog.debug("register:start", { schema: program.name, orbitalNames });
-    return lazySchemas.then((lazy) => runtime.register(program, { ...messages !== void 0 ? { messages } : {}, lazy })).then(() => {
-      playgroundLog.debug("register:done", { schema: program.name, orbitalNames });
-    });
-  }, [runtime, lazySchemas, messages]);
-  const latestRegistration = useRef(Promise.resolve());
-  const registrationReady = useMemo(() => {
-    const ready = registerProgram(schema);
-    latestRegistration.current = ready;
-    return ready;
-  }, [registerProgram, schema]);
-  const teardownTimerRef = useRef(null);
-  useEffect(() => {
-    if (teardownTimerRef.current !== null) {
-      clearTimeout(teardownTimerRef.current);
-      teardownTimerRef.current = null;
-    }
-    return () => {
-      teardownTimerRef.current = setTimeout(() => {
-        teardownTimerRef.current = null;
-        playgroundLog.debug("unregisterAll:unmount");
-        runtime.unregisterAll();
-      }, 0);
-    };
-  }, [runtime]);
-  const transport = useMemo(
-    () => createInProcessTransport(
-      async (orbitalName, request) => {
-        await latestRegistration.current;
-        return runtime.processOrbitalEvent(orbitalName, request);
-      },
-      {
-        // Registers what the bridge hands over (lazy behaviors included): a bridge that unregistered first gets it back.
-        onRegister: (program) => {
-          const ready = registerProgram(program);
-          latestRegistration.current = ready;
-          return ready;
-        },
-        onUnregister: () => {
-          runtime.unregisterAll();
-        }
-      }
-    ),
-    [runtime, registerProgram, registrationReady]
-  );
-  const viewerLocale = locale ?? schema.locales?.[0];
-  const i18n = useMemo(() => {
-    if (viewerLocale === void 0 || messages === void 0) return void 0;
-    const catalog = messages[viewerLocale] ?? {};
-    return { locale: viewerLocale, direction: localeDirection(viewerLocale), t: createTranslate(catalog, viewerLocale), messages: catalog };
-  }, [viewerLocale, messages]);
-  const preview = /* @__PURE__ */ jsx(
-    OrbPreview,
-    {
-      schema,
-      transport,
-      initialPagePath,
-      height,
-      className,
-      fit,
-      onPageChange,
-      user: viewer ?? null,
-      lazyLoader,
-      schemaPath,
-      isolated: true
-    }
-  );
-  return i18n !== void 0 ? /* @__PURE__ */ jsx(I18nProvider, { value: i18n, children: preview }) : preview;
-}
-
-export { BrowserPlayground, OrbPreview, clearSchemaCache, useResolvedSchema, useTraitStateMachine };