@almadar/ui 6.59.0 → 6.61.0

package/dist/{chunk-723MJUU3.js → chunk-6ZCU3BQN.js}

@@ -1,4 +1,4 @@
-import { en_default } from './chunk-LZRW6GXG.js';
+import { en_default } from './chunk-FYX64CDL.js';
 
 // lib/format.ts
 var { $meta: _meta, ...coreMessages } = en_default;

package/dist/{chunk-7CVXM2KS.js → chunk-7NIU5GDC.js}

@@ -1,5 +1,5 @@
-import { avlBlend, AVL_INK, EFFECT_CATEGORY_COLORS, OPERATOR_CATEGORY_COLORS, avlTint, Box, VStack, effectCategoryOf } from './chunk-J755QADM.js';
-import { Typography } from './chunk-4ZGXIW3B.js';
+import { avlBlend, AVL_INK, EFFECT_CATEGORY_COLORS, OPERATOR_CATEGORY_COLORS, avlTint, Box, VStack, effectCategoryOf } from './chunk-MGN6B6OQ.js';
+import { Typography } from './chunk-KZRAMPM6.js';
 import { Vector3, QuadraticBezierCurve3, MathUtils, Quaternion } from 'three';
 import { EntityPersistenceSchema } from '@almadar/core';
 import { getStdOperatorMeta } from '@almadar/std/registry';

package/dist/{chunk-YYYHH5BA.js → chunk-CB64IOYD.js}

@@ -130,7 +130,6 @@ var ar_default = {
   "aria.upvote": "\u062A\u0635\u0648\u064A\u062A \u0625\u064A\u062C\u0627\u0628\u064A",
   "aria.downvote": "\u062A\u0635\u0648\u064A\u062A \u0633\u0644\u0628\u064A",
   "aria.qrScanner": "\u0645\u0627\u0633\u062D QR",
-  "aria.mockScanDev": "\u0645\u0633\u062D \u062A\u062C\u0631\u064A\u0628\u064A (\u062A\u0637\u0648\u064A\u0631)",
   "aria.openMenu": "\u0641\u062A\u062D \u0627\u0644\u0642\u0627\u0626\u0645\u0629",
   "aria.closeMenu": "\u0625\u063A\u0644\u0627\u0642 \u0627\u0644\u0642\u0627\u0626\u0645\u0629",
   "aria.openSidebar": "\u0641\u062A\u062D \u0627\u0644\u0634\u0631\u064A\u0637 \u0627\u0644\u062C\u0627\u0646\u0628\u064A",
@@ -328,7 +327,6 @@ var ar_default = {
   "qrScanner.pauseScanning": "\u0625\u064A\u0642\u0627\u0641 \u0627\u0644\u0645\u0633\u062D \u0645\u0624\u0642\u062A\u064B\u0627",
   "qrScanner.switchToFrontCamera": "\u0627\u0644\u062A\u0628\u062F\u064A\u0644 \u0625\u0644\u0649 \u0627\u0644\u0643\u0627\u0645\u064A\u0631\u0627 \u0627\u0644\u0623\u0645\u0627\u0645\u064A\u0629",
   "qrScanner.switchToRearCamera": "\u0627\u0644\u062A\u0628\u062F\u064A\u0644 \u0625\u0644\u0649 \u0627\u0644\u0643\u0627\u0645\u064A\u0631\u0627 \u0627\u0644\u062E\u0644\u0641\u064A\u0629",
-  "qrScanner.mockScan": "\u0645\u0633\u062D \u062A\u062C\u0631\u064A\u0628\u064A",
   "docSearch.placeholder": "\u0627\u0644\u0628\u062D\u062B \u0641\u064A \u0627\u0644\u0648\u062B\u0627\u0626\u0642...",
   "stateMachine.loading": "\u062C\u0627\u0631\u064D \u062A\u062D\u0645\u064A\u0644 \u0622\u0644\u0629 \u0627\u0644\u062D\u0627\u0644\u0629\u2026",
   "stateMachine.noStateMachine": "\u0644\u0627 \u062A\u0648\u062C\u062F \u0622\u0644\u0629 \u062D\u0627\u0644\u0629 \u0644\u0639\u0631\u0636\u0647\u0627",
@@ -1389,7 +1387,6 @@ var sl_default = {
   "aria.upvote": "Glasuj za",
   "aria.downvote": "Glasuj proti",
   "aria.qrScanner": "QR skener",
-  "aria.mockScanDev": "Simuliraj skeniranje (dev)",
   "aria.openMenu": "Odpri meni",
   "aria.closeMenu": "Zapri meni",
   "aria.openSidebar": "Odpri stransko vrstico",
@@ -1587,7 +1584,6 @@ var sl_default = {
   "qrScanner.pauseScanning": "Za\u010Dasno ustavi skeniranje",
   "qrScanner.switchToFrontCamera": "Preklopi na sprednjo kamero",
   "qrScanner.switchToRearCamera": "Preklopi na zadnjo kamero",
-  "qrScanner.mockScan": "Preizkusno skeniranje",
   "docSearch.placeholder": "Iskanje po dokumentaciji...",
   "stateMachine.loading": "Nalaganje stanjskega stroja\u2026",
   "stateMachine.noStateMachine": "Ni stanjskega stroja za prikaz",

package/dist/{chunk-MZIDOJMD.js → chunk-EIIQGOZW.js}

@@ -1,4 +1,4 @@
-import { beginPending, endPending } from './chunk-I5QOYW2Z.js';
+import { claimDelivery, beginPending, endPending } from './chunk-UTSDPJUP.js';
 import { useEventBus } from './chunk-CHNC4UYE.js';
 import { useState, useCallback, useEffect, useMemo, useRef } from 'react';
 import { createLogger } from '@almadar/logger';
@@ -857,6 +857,7 @@ function useUIEvents(dispatch, traitName, validEvents, eventBusInstance) {
         if (event.source && event.source.dispatched) {
           return;
         }
+        if (!claimDelivery(event.source, traitName, smEvent)) return;
         const pendingKey = event.source?.pendingKey;
         const settled = dispatch(smEvent, event.payload);
         if (pendingKey !== void 0 && settled instanceof Promise) {

package/dist/chunk-F7NZ3KZQ.js

@@ -0,0 +1,434 @@
+import { LoadingState, ErrorState, UISlotComponent } from './chunk-6PV4LASE.js';
+import { useEventBus } from './chunk-CHNC4UYE.js';
+import { createContext, useMemo, useState, useRef, useCallback, useContext, useEffect } from 'react';
+import { UISlotProvider, useUISlots } from '@almadar/ui/context';
+import { OrbitalServerRuntime } from '@almadar/runtime/OrbitalServerRuntime';
+import { UI_SLOTS } from '@almadar/core';
+import { createLogger } from '@almadar/logger';
+import { useTranslate } from '@almadar/ui/hooks';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var log = createLogger("almadar:ui:plugin-host");
+var UI_SLOT_SET = new Set(UI_SLOTS);
+function isUISlot(value) {
+  return UI_SLOT_SET.has(value);
+}
+var OrbitalPluginHostContext = createContext(null);
+function useOrbitalPluginHostContext(caller) {
+  const ctx = useContext(OrbitalPluginHostContext);
+  if (!ctx) {
+    throw new Error(`${caller} must be used within an <OrbitalPluginHost>.`);
+  }
+  return ctx;
+}
+function isTraitState(value) {
+  return value !== void 0 && typeof value.currentState === "string";
+}
+function toTraitState(runtime, orbital, trait, stateName, lastEvent) {
+  if (runtime) {
+    const raw = runtime.getState(orbital, trait);
+    if (isTraitState(raw)) return raw;
+  }
+  return { traitName: trait, currentState: stateName, previousState: null, lastEvent, context: {} };
+}
+function isKeymapValue(value) {
+  if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every((entry) => Array.isArray(entry) && entry.every((k) => typeof k === "string"));
+}
+function findInlineTrait(schema, orbitalName, traitName) {
+  const orbital = schema.orbitals.find((o) => o.name === orbitalName);
+  if (!orbital) return void 0;
+  for (const ref of orbital.traits) {
+    if (typeof ref === "string") continue;
+    if ("ref" in ref) continue;
+    if (ref.name === traitName) return ref;
+  }
+  return void 0;
+}
+function readKeymapConfig(trait, knob) {
+  const declared = trait?.config?.[knob]?.default;
+  return isKeymapValue(declared) ? declared : {};
+}
+function traitNamesOf(orbital) {
+  const names = [];
+  for (const ref of orbital.traits) {
+    if (typeof ref === "string") {
+      names.push(ref);
+    } else if ("ref" in ref) {
+      if (ref.name) names.push(ref.name);
+    } else {
+      names.push(ref.name);
+    }
+  }
+  return names;
+}
+function useDeclaredCaptureTable(opts) {
+  const { pluginId, orbital, trait, keymapKnob = "keymap", target = "shell" } = opts;
+  const ctx = useOrbitalPluginHostContext("useDeclaredCaptureTable");
+  return useMemo(() => {
+    const schema = ctx.getPluginSchema(pluginId);
+    const inlineTrait = schema ? findInlineTrait(schema, orbital, trait) : void 0;
+    const keymap = readKeymapConfig(inlineTrait, keymapKnob);
+    const currentState = ctx.getState(pluginId, orbital, trait)?.currentState;
+    const keys = currentState !== void 0 ? keymap[currentState] ?? [] : [];
+    const entry = { mode: currentState ?? "unknown", keys: new Set(keys) };
+    const targets = Array.isArray(target) ? target : [target];
+    const table = {};
+    for (const t of targets) table[t] = entry;
+    return table;
+  }, [ctx, pluginId, orbital, trait, keymapKnob, target]);
+}
+function useOrbitalPluginHost() {
+  const ctx = useOrbitalPluginHostContext("useOrbitalPluginHost");
+  return { getState: ctx.getState, lastEvent: ctx.lastEvent, errors: ctx.errors };
+}
+function buildMockEffectHandlers(opts) {
+  const { pluginId, denySet, slotsRef, renderedSlotsRef, navigateRef } = opts;
+  const handlers = {
+    renderUI: (slot, pattern, props, priority) => {
+      if (!isUISlot(slot)) {
+        log.warn("renderUI:unknown-slot", { pluginId, slot });
+        return;
+      }
+      if (pattern === null) {
+        slotsRef.current.clearBySource(slot, pluginId);
+        return;
+      }
+      renderedSlotsRef.current.add(slot);
+      const { type, ...inline } = pattern;
+      slotsRef.current.render({
+        target: slot,
+        pattern: type,
+        props: { ...inline, ...props ?? {} },
+        priority,
+        sourceTrait: pluginId
+      });
+    }
+  };
+  if (denySet.has("navigate")) {
+    handlers.navigate = (path) => log.warn("navigate:denied", { pluginId, path });
+  } else if (navigateRef.current) {
+    handlers.navigate = (path) => navigateRef.current?.(path);
+  }
+  if (denySet.has("persist")) {
+    handlers.persist = async (action, entityType) => {
+      log.warn("persist:denied", { pluginId, action, entityType });
+      return void 0;
+    };
+  }
+  if (denySet.has("call-service")) {
+    handlers.callService = async (service, action) => {
+      log.warn("call-service:denied", { pluginId, service, action });
+      return null;
+    };
+  }
+  return handlers;
+}
+function PluginRuntimeMount({
+  plugin,
+  mode,
+  transport,
+  deny,
+  navigate,
+  onTransition,
+  onDispatched,
+  onError
+}) {
+  const bus = useEventBus();
+  const { locale } = useTranslate();
+  const slots = useUISlots();
+  const slotsRef = useRef(slots);
+  slotsRef.current = slots;
+  const renderedSlotsRef = useRef(/* @__PURE__ */ new Set());
+  const navigateRef = useRef(navigate);
+  navigateRef.current = navigate;
+  const [mockRuntime] = useState(() => {
+    if (mode !== "mock") return void 0;
+    return new OrbitalServerRuntime({
+      mode: "mock",
+      debug: false,
+      effectHandlers: buildMockEffectHandlers({
+        pluginId: plugin.id,
+        denySet: new Set(deny ?? []),
+        slotsRef,
+        renderedSlotsRef,
+        navigateRef
+      })
+    });
+  });
+  const registrationReady = useMemo(() => {
+    if (mockRuntime) return mockRuntime.register(plugin.schema);
+    if (mode === "server" && transport) return transport.register(plugin.schema);
+    return Promise.resolve();
+  }, [mockRuntime, transport, mode, plugin.schema]);
+  useEffect(() => {
+    if (mode === "server" && !transport) {
+      onError(plugin.id, 'OrbitalPluginHost: mode "server" requires a transport');
+    }
+  }, [mode, transport, plugin.id, onError]);
+  const teardownTimerRef = useRef(null);
+  useEffect(() => {
+    if (teardownTimerRef.current !== null) {
+      clearTimeout(teardownTimerRef.current);
+      teardownTimerRef.current = null;
+    }
+    return () => {
+      teardownTimerRef.current = setTimeout(() => {
+        teardownTimerRef.current = null;
+        if (mockRuntime) {
+          mockRuntime.unregisterAll();
+        } else if (mode === "server" && transport) {
+          void transport.unregister();
+        }
+        for (const slot of renderedSlotsRef.current) {
+          slotsRef.current.clearBySource(slot, plugin.id);
+        }
+      }, 0);
+    };
+  }, [mockRuntime, transport, mode, plugin.id]);
+  const ownOrbitals = useMemo(
+    () => new Set(plugin.schema.orbitals.map((o) => o.name)),
+    [plugin.schema]
+  );
+  const inboundBusEvents = useMemo(
+    () => new Set(plugin.inbound.map((row) => row.busEvent)),
+    [plugin.inbound]
+  );
+  const inboundTriggerNames = useMemo(
+    () => new Set(plugin.inbound.map((row) => row.trigger)),
+    [plugin.inbound]
+  );
+  const snapshotAllStates = useCallback(() => {
+    const states = [];
+    if (!mockRuntime) return states;
+    for (const orbital of plugin.schema.orbitals) {
+      for (const traitName of traitNamesOf(orbital)) {
+        const raw = mockRuntime.getState(orbital.name, traitName);
+        if (isTraitState(raw)) states.push([orbital.name, traitName, raw]);
+      }
+    }
+    return states;
+  }, [mockRuntime, plugin.schema]);
+  useEffect(() => {
+    let cancelled = false;
+    void registrationReady.then(() => {
+      if (cancelled || !mockRuntime) return;
+      const states = snapshotAllStates();
+      if (states.length > 0) onDispatched(plugin.id, null, states);
+    }).catch((err) => {
+      if (!cancelled) onError(plugin.id, err instanceof Error ? err.message : String(err));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [registrationReady, mockRuntime, plugin, onDispatched, onError, snapshotAllStates]);
+  useEffect(() => {
+    if (!mockRuntime) return;
+    let timer = null;
+    const scheduleResync = () => {
+      if (timer !== null) return;
+      timer = setTimeout(() => {
+        timer = null;
+        const states = snapshotAllStates();
+        if (states.length > 0) onDispatched(plugin.id, null, states);
+      }, 0);
+    };
+    const unsub = mockRuntime.getEventBus().onAny(scheduleResync);
+    return () => {
+      unsub();
+      if (timer !== null) clearTimeout(timer);
+    };
+  }, [mockRuntime, plugin.id, onDispatched, snapshotAllStates]);
+  useEffect(() => {
+    if (!mockRuntime) return;
+    const rebroadcast = /* @__PURE__ */ new WeakSet();
+    const unsub = mockRuntime.getEventBus().onAny((event) => {
+      if (rebroadcast.has(event)) return;
+      if (inboundBusEvents.has(event.type) || inboundTriggerNames.has(event.type)) return;
+      const sourceOrbital = event.source?.orbital;
+      if (sourceOrbital === void 0 || !ownOrbitals.has(sourceOrbital)) return;
+      rebroadcast.add(event);
+      bus.emit(`UI:${event.type}`, event.payload, event.source);
+    });
+    return () => {
+      unsub();
+    };
+  }, [mockRuntime, bus, ownOrbitals, inboundBusEvents, inboundTriggerNames]);
+  const dispatch = useCallback(
+    async (row, payload) => {
+      await registrationReady;
+      let response;
+      if (mockRuntime) {
+        response = await mockRuntime.processOrbitalEvent(row.orbital, {
+          event: row.trigger,
+          payload,
+          targetTrait: row.trait,
+          locale
+        });
+      } else if (mode === "server" && transport) {
+        response = await transport.send(row.orbital, { event: row.trigger, payload, locale });
+      } else {
+        return;
+      }
+      if (!response.success) {
+        onError(plugin.id, response.error ?? `${plugin.id}: ${row.trigger} failed`);
+      }
+      if (!mockRuntime) {
+        for (const entry of response.emittedEvents ?? []) {
+          if (entry.event === row.trigger) continue;
+          if (inboundBusEvents.has(entry.event)) continue;
+          const sourceOrbital = entry.source?.orbital;
+          if (sourceOrbital !== void 0 && ownOrbitals.has(sourceOrbital)) {
+            bus.emit(`UI:${entry.event}`, entry.payload, entry.source);
+          }
+        }
+      }
+      const states = [];
+      for (const [traitName, stateName] of Object.entries(response.states)) {
+        states.push([row.orbital, traitName, toTraitState(mockRuntime, row.orbital, traitName, stateName, row.trigger)]);
+        onTransition?.(plugin.id, row.orbital, traitName, stateName);
+      }
+      onDispatched(plugin.id, row.trigger, states);
+    },
+    [registrationReady, mockRuntime, mode, transport, locale, plugin, bus, ownOrbitals, inboundBusEvents, onError, onTransition, onDispatched]
+  );
+  useEffect(() => {
+    const unsubs = plugin.inbound.map(
+      (row) => bus.on(`UI:${row.busEvent}`, (event) => {
+        void dispatch(row, event.payload).catch((err) => {
+          onError(plugin.id, err instanceof Error ? err.message : String(err));
+        });
+      })
+    );
+    return () => {
+      for (const unsub of unsubs) unsub();
+    };
+  }, [bus, plugin, dispatch, onError]);
+  return null;
+}
+function OrbitalPluginHost({
+  plugins,
+  mode = "mock",
+  transport,
+  deny,
+  navigate,
+  onTransition,
+  children
+}) {
+  const [tick, setTick] = useState(0);
+  const [errors, setErrors] = useState({});
+  const statesRef = useRef(/* @__PURE__ */ new Map());
+  const lastEventRef = useRef(/* @__PURE__ */ new Map());
+  const pluginSchemas = useMemo(
+    () => new Map(plugins.map((plugin) => [plugin.id, plugin.schema])),
+    [plugins]
+  );
+  const handleDispatched = useCallback(
+    (pluginId, trigger, states) => {
+      if (trigger !== null) {
+        lastEventRef.current.set(pluginId, trigger);
+      }
+      let byKey = statesRef.current.get(pluginId);
+      if (!byKey) {
+        byKey = /* @__PURE__ */ new Map();
+        statesRef.current.set(pluginId, byKey);
+      }
+      for (const [orbital, trait, state] of states) {
+        byKey.set(`${orbital}.${trait}`, state);
+      }
+      setTick((t) => t + 1);
+    },
+    []
+  );
+  const handleError = useCallback((pluginId, message) => {
+    setErrors((prev) => prev[pluginId] === message ? prev : { ...prev, [pluginId]: message });
+  }, []);
+  const contextValue = useMemo(
+    () => ({
+      getState: (pluginId, orbital, trait) => statesRef.current.get(pluginId)?.get(`${orbital}.${trait}`),
+      lastEvent: (pluginId) => lastEventRef.current.get(pluginId),
+      errors,
+      tick,
+      getPluginSchema: (pluginId) => pluginSchemas.get(pluginId)
+    }),
+    [errors, tick, pluginSchemas]
+  );
+  return /* @__PURE__ */ jsxs(OrbitalPluginHostContext.Provider, { value: contextValue, children: [
+    plugins.map((plugin) => /* @__PURE__ */ jsx(
+      PluginRuntimeMount,
+      {
+        plugin,
+        mode,
+        transport,
+        deny,
+        navigate,
+        onTransition,
+        onDispatched: handleDispatched,
+        onError: handleError
+      },
+      plugin.id
+    )),
+    children ?? null
+  ] });
+}
+var TraitValueMountContext = createContext(null);
+function TraitValueMountProvider({ host, children }) {
+  return /* @__PURE__ */ jsx(TraitValueMountContext.Provider, { value: host, children });
+}
+function initEventOf(key) {
+  return `TRAIT_VALUE_MOUNTED:${key}`;
+}
+function MountedInit({ event }) {
+  const bus = useEventBus();
+  useEffect(() => {
+    bus.emit(`UI:${event}`, {});
+  }, [bus, event]);
+  return null;
+}
+function TraitValueFrame({ value }) {
+  const host = useContext(TraitValueMountContext);
+  const key = useMemo(() => JSON.stringify(value), [value]);
+  const latest = useRef(value);
+  latest.current = value;
+  const [state, setState] = useState({ status: "loading" });
+  useEffect(() => {
+    const current = latest.current;
+    if (host === null) {
+      setState({ status: "error", message: `No trait-value host is configured to mount ${current.behavior}.traits.${current.trait}` });
+      return;
+    }
+    let live = true;
+    setState({ status: "loading" });
+    void host.mount(current).then((result) => {
+      if (!live) return;
+      if (!result.ok) {
+        const detail = (result.errors ?? []).map((e) => `${e.code}: ${e.message}`).join("\n");
+        setState({ status: "error", message: detail.length > 0 ? `${result.error}
+${detail}` : result.error });
+        return;
+      }
+      const initEvent = initEventOf(key);
+      setState({
+        status: "ready",
+        initEvent,
+        plugin: {
+          id: key,
+          schema: result.mounted.schema,
+          inbound: [{ busEvent: initEvent, orbital: result.mounted.orbital, trait: result.mounted.trait, trigger: "INIT" }]
+        }
+      });
+    });
+    return () => {
+      live = false;
+    };
+  }, [host, key]);
+  if (state.status === "loading") return /* @__PURE__ */ jsx(LoadingState, {});
+  if (state.status === "error") return /* @__PURE__ */ jsx(ErrorState, { message: state.message });
+  return /* @__PURE__ */ jsx(UISlotProvider, { children: /* @__PURE__ */ jsxs(OrbitalPluginHost, { plugins: [state.plugin], mode: host?.mode ?? "mock", transport: host?.transport, children: [
+    /* @__PURE__ */ jsx(MountedInit, { event: state.initEvent }),
+    /* @__PURE__ */ jsx(UISlotComponent, { slot: "main" })
+  ] }) });
+}
+var TraitValueFrame_default = TraitValueFrame;
+
+export { OrbitalPluginHost, TraitValueFrame, TraitValueFrame_default, TraitValueMountContext, TraitValueMountProvider, useDeclaredCaptureTable, useOrbitalPluginHost };

package/dist/{chunk-LZRW6GXG.js → chunk-FYX64CDL.js}

@@ -134,7 +134,6 @@ var en_default = {
   "aria.upvote": "Upvote",
   "aria.downvote": "Downvote",
   "aria.qrScanner": "QR scanner",
-  "aria.mockScanDev": "Mock scan (dev)",
   "aria.openMenu": "Open menu",
   "aria.closeMenu": "Close menu",
   "aria.openSidebar": "Open sidebar",
@@ -332,7 +331,6 @@ var en_default = {
   "qrScanner.pauseScanning": "Pause scanning",
   "qrScanner.switchToFrontCamera": "Switch to front camera",
   "qrScanner.switchToRearCamera": "Switch to rear camera",
-  "qrScanner.mockScan": "Mock Scan",
   "docSearch.placeholder": "Search documentation...",
   "stateMachine.loading": "Loading state machine\u2026",
   "stateMachine.noStateMachine": "No state machine to visualize",

package/dist/{chunk-4ZGXIW3B.js → chunk-KZRAMPM6.js}

@@ -1,5 +1,5 @@
 import { cn, domPassthrough } from './chunk-64WACXM7.js';
-import { formatValue } from './chunk-723MJUU3.js';
+import { formatValue } from './chunk-6ZCU3BQN.js';
 import React from 'react';
 import { useFormatContext } from '@almadar/ui/hooks';
 

package/dist/chunk-LUREMDI3.js

@@ -0,0 +1,49 @@
+import { TraitValueMountContext } from './chunk-F7NZ3KZQ.js';
+import { LoadingState, ErrorState, OrbPreview } from './chunk-6PV4LASE.js';
+import { useContext, useMemo, useRef, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function BehaviorValueFrame({ value }) {
+  const host = useContext(TraitValueMountContext);
+  const key = useMemo(() => JSON.stringify(value), [value]);
+  const latest = useRef(value);
+  latest.current = value;
+  const [state, setState] = useState({ status: "loading" });
+  useEffect(() => {
+    const current = latest.current;
+    const mountBehavior = host?.mountBehavior;
+    if (mountBehavior === void 0) {
+      setState({ status: "error", message: `This host cannot run behavior ${current.behavior}` });
+      return;
+    }
+    let live = true;
+    setState({ status: "loading" });
+    void mountBehavior(current).then((result) => {
+      if (!live) return;
+      if (!result.ok) {
+        const detail = (result.errors ?? []).map((e) => `${e.code}: ${e.message}`).join("\n");
+        setState({ status: "error", message: detail.length > 0 ? `${result.error}
+${detail}` : result.error });
+        return;
+      }
+      setState({ status: "ready", mounted: result.mounted });
+    });
+    return () => {
+      live = false;
+    };
+  }, [host, key]);
+  if (state.status === "loading") return /* @__PURE__ */ jsx(LoadingState, {});
+  if (state.status === "error") return /* @__PURE__ */ jsx(ErrorState, { message: state.message });
+  return /* @__PURE__ */ jsx(
+    OrbPreview,
+    {
+      schema: state.mounted.schema,
+      initialPagePath: state.mounted.firstPage,
+      isolated: true,
+      ...host?.behaviorTransport !== void 0 ? { transport: host.behaviorTransport } : {}
+    }
+  );
+}
+var BehaviorValueFrame_default = BehaviorValueFrame;
+
+export { BehaviorValueFrame, BehaviorValueFrame_default };