@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-FIW6WN23.js

@@ -0,0 +1,508 @@
+import { LoadingState, ErrorState, UISlotComponent, useKernelEngine, useClientTicks, KernelLoaderMissingError, LanguageLoaderMissingError, SeedProgramLoaderMissingError, kernelOrbitals, getTabClientId, createLazyKernelClient } from './chunk-GYTPOFVC.js';
+import { nativeMemoryPersistence, openLocalKernel, withForkedSeeder, mockStoreSeed_exports, local_store_transport_exports, trait_index_exports } from './chunk-DYEKAA4L.js';
+import { UISlotProvider, useUISlots } from './chunk-AILY3XPS.js';
+import { useEventBus, useRootEventBus, useTraitScopeChain, useTranslate } from './chunk-MBQAMMSE.js';
+import { createContext, useMemo, useState, useRef, useCallback, useEffect, useContext } from 'react';
+import { createMemoryCircuitStore } from '@almadar/shell-runtime/client/circuit-store';
+import { UI_SLOTS } from '@almadar/core';
+import { createLogger } from '@almadar/logger';
+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 toTraitState(trait, stateName, lastEvent) {
+  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 paintClientEffects(id, effects, handlers) {
+  for (const effect of effects) {
+    switch (effect[0]) {
+      case "render-ui":
+        void handlers.renderUI?.(effect[1], effect[2]);
+        break;
+      case "navigate":
+        handlers.navigate?.(effect[1], effect[2] ?? void 0, effect[3]?.crumb);
+        break;
+      case "navigate-back":
+        if (handlers.navigateBack !== void 0) handlers.navigateBack();
+        else log.warn("navigate-back:unhandled", { pluginId: id });
+        break;
+    }
+  }
+}
+function buildMockEffectHandlers(opts) {
+  const { pluginId, denySet, slotsRef, renderedSlotsRef, navigateRef } = opts;
+  const handlers = {
+    renderUI: (slot, pattern) => {
+      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,
+        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);
+  }
+  return handlers;
+}
+function writeDeniedStore(pluginId, store) {
+  return {
+    create: async (entityType, _data) => {
+      log.warn("persist:denied", { pluginId, action: "create", entityType });
+      return { id: "" };
+    },
+    update: async (entityType, id) => {
+      log.warn("persist:denied", { pluginId, action: "update", entityType, id });
+    },
+    delete: async (entityType, id) => {
+      log.warn("persist:denied", { pluginId, action: "delete", entityType, id });
+    },
+    getById: (entityType, id) => store.getById(entityType, id),
+    list: (entityType) => store.list(entityType)
+  };
+}
+function openPluginKernel(plugin, engine, denySet) {
+  if (engine === null) throw new KernelLoaderMissingError();
+  const language = engine.loadLanguage !== void 0 ? engine.loadLanguage() : Promise.reject(new LanguageLoaderMissingError());
+  const loadSeedProgram = engine.loadSeedProgram;
+  const schema = plugin.schema;
+  const opened = Promise.all([engine.loadModule(), language]).then(async ([kernel, bundle]) => {
+    const rows = nativeMemoryPersistence(kernel);
+    const persistence = denySet.has("persist") ? writeDeniedStore(plugin.id, rows) : rows;
+    const server = openLocalKernel({
+      kernel,
+      language: bundle,
+      schema,
+      persistence,
+      ...denySet.has("call-service") ? {
+        callService: async (service, action) => {
+          log.warn("call-service:denied", { pluginId: plugin.id, service, action });
+          return null;
+        }
+      } : {}
+    });
+    if (loadSeedProgram === void 0) throw new SeedProgramLoaderMissingError();
+    const { viewer } = await withForkedSeeder(
+      server,
+      schema,
+      loadSeedProgram,
+      rows,
+      void 0,
+      (host) => (0, mockStoreSeed_exports.seedMockStore)(host, schema, { namedByHost: false, current: () => void 0, seedIdentity: true })
+    );
+    server.seedRuntimeMock(viewer?.id);
+    return { kernel, server, viewer };
+  });
+  opened.catch(() => void 0);
+  const kernelEngine = opened.then((o) => o.server);
+  kernelEngine.catch(() => void 0);
+  const transport = (0, local_store_transport_exports.createLocalStoreTransport)({ kernelEngine, user: opened.then((o) => o.viewer) });
+  const instance = opened.then(({ kernel, viewer }) => {
+    const k = new kernel.Kernel(JSON.stringify({ name: schema.name, orbitals: kernelOrbitals(schema.orbitals), ...schema._metadata !== void 0 ? { _metadata: schema._metadata } : {} }), getTabClientId());
+    k.setHostFansOut(true);
+    if (viewer !== void 0) k.setCurrentUser(JSON.stringify(viewer));
+    return k;
+  });
+  instance.catch(() => void 0);
+  const traitIndex = (0, trait_index_exports.buildTraitIndex)(schema.orbitals);
+  const client = createLazyKernelClient({
+    instance,
+    store: createMemoryCircuitStore(Array.from(traitIndex.byName.values(), (entry) => entry.traitDef)),
+    traitIndex,
+    transport,
+    topology: Promise.resolve({ carriesCircuitState: false })
+  });
+  return { kernelEngine, client, instance, transport };
+}
+var HOST_TICKS = { startFrames: () => () => void 0 };
+function PluginRuntimeMount({
+  plugin,
+  mode,
+  transport,
+  deny,
+  navigate,
+  onTransition,
+  onDispatched,
+  onError
+}) {
+  const bus = useEventBus();
+  const rootBus = useRootEventBus();
+  const chain = useTraitScopeChain();
+  const relay = useCallback(
+    (type, payload, source) => {
+      const physical = { ...source };
+      for (const key of /* @__PURE__ */ new Set([`UI:${type}`, ...chain.map((sc) => `UI:${sc.orbital}.${sc.trait}.${type}`)])) {
+        rootBus.emit(key, payload, physical);
+      }
+    },
+    [rootBus, chain]
+  );
+  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 kernelEngineValue = useKernelEngine();
+  const [mockHandlers] = useState(() => mode !== "mock" ? void 0 : buildMockEffectHandlers({
+    pluginId: plugin.id,
+    denySet: new Set(deny ?? []),
+    slotsRef,
+    renderedSlotsRef,
+    navigateRef
+  }));
+  const denyRef = useRef(deny);
+  const local = useMemo(
+    () => mode !== "mock" ? void 0 : openPluginKernel(plugin, kernelEngineValue, new Set(denyRef.current ?? [])),
+    // The kernel is the plugin's program: a new schema opens a new one.
+    [mode, plugin.id, plugin.schema, kernelEngineValue]
+  );
+  const activeTransport = local?.transport ?? (mode === "server" ? transport : void 0);
+  const engineRef = useRef(void 0);
+  const registrationReady = useMemo(async () => {
+    if (activeTransport === void 0) return;
+    await activeTransport.register(plugin.schema);
+    if (local !== void 0) engineRef.current = await local.instance;
+  }, [activeTransport, local, plugin.schema]);
+  useEffect(() => {
+    if (mode === "server" && !transport) {
+      onError(plugin.id, 'OrbitalPluginHost: mode "server" requires a transport');
+    }
+  }, [mode, transport, plugin.id, onError]);
+  const teardownRef = useRef(null);
+  useEffect(() => {
+    if (teardownRef.current !== null && teardownRef.current.transport === activeTransport) {
+      clearTimeout(teardownRef.current.timer);
+      teardownRef.current = null;
+    }
+    return () => {
+      const timer = setTimeout(() => {
+        if (teardownRef.current?.timer === timer) teardownRef.current = null;
+        if (activeTransport !== void 0) void activeTransport.unregister();
+        void local?.kernelEngine.then((engine) => engine.dispose(), () => void 0);
+        void local?.instance.then((instance) => {
+          if (engineRef.current === instance) engineRef.current = void 0;
+          instance.free();
+        }, () => void 0);
+        for (const slot of renderedSlotsRef.current) {
+          slotsRef.current.clearBySource(slot, plugin.id);
+        }
+      }, 0);
+      teardownRef.current = { transport: activeTransport, timer };
+    };
+  }, [activeTransport, local, plugin.id]);
+  const ownOrbitals = useMemo(
+    () => new Set(plugin.schema.orbitals.map((o) => o.name)),
+    [plugin.schema]
+  );
+  const inboundVocabulary = useMemo(
+    () => new Set(plugin.inbound.flatMap((row) => [row.busEvent, row.trigger])),
+    [plugin.inbound]
+  );
+  const snapshotAllStates = useCallback((lastEvent) => {
+    const engine = engineRef.current;
+    const states = [];
+    if (engine === void 0) return states;
+    for (const orbital of plugin.schema.orbitals) {
+      for (const traitName of traitNamesOf(orbital)) {
+        const current = engine.getState(traitName);
+        if (current !== "") states.push([orbital.name, traitName, toTraitState(traitName, current, lastEvent)]);
+      }
+    }
+    return states;
+  }, [plugin.schema]);
+  useEffect(() => {
+    let cancelled = false;
+    void registrationReady.then(() => {
+      if (cancelled) return;
+      const states = snapshotAllStates(null);
+      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, plugin.id, onDispatched, onError, snapshotAllStates]);
+  const orbitalOfTrait = useMemo(
+    () => new Map(plugin.schema.orbitals.flatMap((orbital) => traitNamesOf(orbital).map((trait) => [trait, orbital.name]))),
+    [plugin.schema]
+  );
+  const settle = useCallback(
+    (trigger, response, orbital) => {
+      if (!response.success) {
+        onError(plugin.id, response.error ?? `${plugin.id}: ${trigger ?? "tick"} failed`);
+      }
+      if (mockHandlers !== void 0) paintClientEffects(plugin.id, response.clientEffects ?? [], mockHandlers);
+      for (const entry of response.emittedEvents ?? []) {
+        if (inboundVocabulary.has(entry.event)) continue;
+        if (plugin.outbound !== void 0 && !plugin.outbound.includes(entry.event)) continue;
+        const sourceOrbital = entry.source?.orbital;
+        if (sourceOrbital === void 0 || !ownOrbitals.has(sourceOrbital)) continue;
+        relay(entry.event, entry.payload, entry.source);
+      }
+      const transitions = Object.entries(response.states).flatMap(([traitName, stateName]) => {
+        const owner = orbital ?? orbitalOfTrait.get(traitName);
+        return owner === void 0 ? [] : [[owner, traitName, stateName]];
+      });
+      const states = local !== void 0 ? snapshotAllStates(trigger) : transitions.map(([owner, traitName, stateName]) => [owner, traitName, toTraitState(traitName, stateName, trigger)]);
+      for (const [owner, traitName, stateName] of transitions) onTransition?.(plugin.id, owner, traitName, stateName);
+      onDispatched(plugin.id, trigger, states);
+    },
+    [local, mockHandlers, plugin, ownOrbitals, orbitalOfTrait, inboundVocabulary, relay, snapshotAllStates, onError, onTransition, onDispatched]
+  );
+  const dispatch = useCallback(
+    async (row, payload) => {
+      await registrationReady;
+      const request = { event: row.trigger, payload, targetTrait: row.trait, locale };
+      if (local !== void 0) {
+        settle(row.trigger, (await local.client.dispatch(request)).response, row.orbital);
+        return;
+      }
+      if (activeTransport === void 0) return;
+      settle(row.trigger, await activeTransport.send(row.orbital, request), row.orbital);
+    },
+    [registrationReady, activeTransport, local, locale, settle]
+  );
+  const onKernelFrame = useCallback(
+    (outcomes) => {
+      for (const outcome of outcomes) {
+        settle(null, outcome.response, void 0);
+        void outcome.tickSettled?.then((added) => {
+          if (added !== void 0 && mockHandlers !== void 0) paintClientEffects(plugin.id, added.clientEffects ?? [], mockHandlers);
+        });
+      }
+    },
+    [settle, mockHandlers, plugin.id]
+  );
+  useClientTicks({
+    kernelClient: local?.client ?? HOST_TICKS,
+    onKernelFrame,
+    ...kernelEngineValue?.scheduleFrame !== void 0 ? { scheduleFrame: kernelEngineValue.scheduleFrame } : {},
+    hostRunsProgram: local === void 0
+  });
+  useEffect(() => {
+    const unsubs = plugin.inbound.flatMap((row) => {
+      const keys = /* @__PURE__ */ new Set([`UI:${row.busEvent}`, ...chain.map((sc) => `UI:${sc.orbital}.${sc.trait}.${row.busEvent}`)]);
+      const delivered = /* @__PURE__ */ new WeakSet();
+      return Array.from(
+        keys,
+        (key) => bus.on(key, (event) => {
+          if (event.source) {
+            if (delivered.has(event.source)) return;
+            delivered.add(event.source);
+          }
+          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, chain]);
+  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 { MountedInit, OrbitalPluginHost, TraitValueFrame, TraitValueFrame_default, TraitValueMountContext, TraitValueMountProvider, useDeclaredCaptureTable, useOrbitalPluginHost };