@almadar/shell-web 0.1.0 → 1.0.0

package/dist/chunk-GAR5TQ5B.js

@@ -1,199 +0,0 @@
-import { getStateRole } from './chunk-DFNZUYX4.js';
-import { useState, useLayoutEffect } from 'react';
-
-function useContainerWidth(ref) {
-  const [width, setWidth] = useState(null);
-  useLayoutEffect(() => {
-    const el = ref.current;
-    if (!el) return;
-    setWidth(el.clientWidth);
-    if (typeof ResizeObserver === "undefined") return;
-    const ro = new ResizeObserver(([entry]) => setWidth(entry.contentRect.width));
-    ro.observe(el);
-    return () => ro.disconnect();
-  }, [ref]);
-  return width;
-}
-
-// src/lib/avl-elk-layout.ts
-function stateWidth(transitionCount) {
-  if (transitionCount >= 5) return 160;
-  if (transitionCount >= 3) return 130;
-  return 110;
-}
-var STATE_H = 40;
-var elk;
-function loadElk() {
-  elk ??= import('elkjs/lib/elk.bundled.js').then(({ default: Elk }) => new Elk());
-  return elk;
-}
-function flowOrder(data) {
-  const byName = new Map(data.states.map((s) => [s.name, s]));
-  const seen = /* @__PURE__ */ new Set();
-  const queue = data.states.filter((s) => s.isInitial).map((s) => s.name);
-  const out = [];
-  while (queue.length > 0) {
-    const name = queue.shift();
-    if (seen.has(name)) continue;
-    const state = byName.get(name);
-    if (!state) continue;
-    seen.add(name);
-    out.push(state);
-    for (const t of data.transitions) if (t.from === name && !seen.has(t.to)) queue.push(t.to);
-  }
-  for (const s of data.states) if (!seen.has(s.name)) out.push(s);
-  return out;
-}
-async function computeTraitLayout(data, metrics) {
-  const transitionCounts = {};
-  for (const s of data.states) transitionCounts[s.name] = 0;
-  for (const t of data.transitions) {
-    transitionCounts[t.from] = (transitionCounts[t.from] ?? 0) + 1;
-    transitionCounts[t.to] = (transitionCounts[t.to] ?? 0) + 1;
-  }
-  const maxTC = Math.max(...Object.values(transitionCounts), 0);
-  const LABEL_BASE_W = 100;
-  const LABEL_H = 44;
-  const states = metrics ? flowOrder(data) : data.states;
-  const elkGraph = {
-    id: "root",
-    layoutOptions: {
-      "elk.algorithm": "layered",
-      "elk.direction": metrics?.direction === "rtl" ? "LEFT" : "RIGHT",
-      "elk.spacing.nodeNode": String(metrics?.nodeSpacing ?? 80),
-      "elk.spacing.edgeNode": "30",
-      "elk.spacing.edgeEdge": "24",
-      "elk.spacing.edgeLabel": "10",
-      "elk.spacing.labelLabel": "8",
-      "elk.layered.spacing.nodeNodeBetweenLayers": String(metrics?.layerSpacing ?? 100),
-      ...metrics?.orthogonal ? { "elk.edgeRouting": "ORTHOGONAL" } : {},
-      ...metrics ? { "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES", "elk.layered.cycleBreaking.strategy": "MODEL_ORDER" } : {},
-      "elk.edgeLabels.placement": "CENTER",
-      "elk.layered.mergeEdges": "false",
-      "elk.layered.nodePlacement.strategy": "NETWORK_SIMPLEX"
-    },
-    children: states.map((s) => {
-      const tc = transitionCounts[s.name] ?? 0;
-      const size = metrics ? metrics.nodeSize(s.name) : { width: stateWidth(tc), height: STATE_H };
-      return {
-        id: s.name,
-        width: size.width,
-        height: size.height,
-        labels: [{ text: s.name, width: size.width - 10, height: 14 }],
-        ...metrics && s.isInitial ? { layoutOptions: { "elk.layered.layering.layerConstraint": "FIRST" } } : {}
-      };
-    }),
-    edges: data.transitions.map((t, i) => {
-      const textW = Math.max(t.event.length * 8, 60);
-      const iconsW = Math.min(t.effects.length, 6) * 28 + 20;
-      const label = metrics ? metrics.labelSize(t) : { width: Math.max(textW, iconsW, LABEL_BASE_W), height: LABEL_H };
-      return {
-        id: `e${i}`,
-        sources: [t.from],
-        targets: [t.to],
-        labels: [{
-          text: t.event,
-          width: label.width,
-          height: label.height,
-          ...metrics ? { layoutOptions: { "elk.edgeLabels.inline": "true" } } : {}
-        }]
-      };
-    })
-  };
-  const layout = await (await loadElk()).layout(elkGraph);
-  const layoutChildren = layout.children ?? [];
-  const layoutEdges = layout.edges ?? [];
-  const nodeXMap = {};
-  for (const n of layoutChildren) {
-    nodeXMap[n.id] = n.x ?? 0;
-  }
-  const nodes = layoutChildren.map((n) => {
-    const name = n.id;
-    const stateInfo = data.states.find((s) => s.name === name);
-    const tc = transitionCounts[name] ?? 0;
-    return {
-      id: name,
-      x: n.x ?? 0,
-      y: n.y ?? 0,
-      width: n.width ?? 110,
-      height: n.height ?? STATE_H,
-      isInitial: stateInfo?.isInitial ?? void 0,
-      isTerminal: stateInfo?.isTerminal ?? void 0,
-      role: getStateRole(stateInfo?.isInitial ?? void 0, stateInfo?.isTerminal ?? void 0, tc, maxTC),
-      transitionCount: tc
-    };
-  });
-  const edges = layoutEdges.map((e, i) => {
-    const t = data.transitions[i];
-    const labels = e.labels ?? [];
-    const label = labels[0];
-    const sections = e.sections ?? [];
-    const points = [];
-    for (const section of sections) {
-      const bendPoints = section.bendPoints ?? [];
-      points.push({ x: section.startPoint.x, y: section.startPoint.y });
-      for (const bp of bendPoints) points.push({ x: bp.x, y: bp.y });
-      points.push({ x: section.endPoint.x, y: section.endPoint.y });
-    }
-    const isSelf = t.from === t.to;
-    const toX = nodeXMap[t.to] ?? 0;
-    const fromX = nodeXMap[t.from] ?? 0;
-    const isBackward = !isSelf && (metrics?.direction === "rtl" ? toX >= fromX : toX <= fromX);
-    const lw = label?.width ?? LABEL_BASE_W;
-    const lh = label?.height ?? LABEL_H;
-    return {
-      id: e.id,
-      from: t.from,
-      to: t.to,
-      event: t.event,
-      effects: t.effects,
-      guard: !!t.guard,
-      guardExpr: typeof t.guard === "string" ? t.guard : void 0,
-      index: t.index,
-      labelX: label?.x ?? 0,
-      labelY: label?.y ?? 0,
-      labelW: lw,
-      labelH: lh,
-      points,
-      isSelf,
-      isBackward
-    };
-  });
-  return {
-    nodes,
-    edges,
-    width: layout.width ?? 600,
-    height: layout.height ?? 400
-  };
-}
-function roundedEdgePath(points, radius) {
-  if (points.length < 3) return edgePath(points);
-  let d = `M ${points[0].x},${points[0].y}`;
-  for (let i = 1; i < points.length - 1; i++) {
-    const prev = points[i - 1];
-    const cur = points[i];
-    const next = points[i + 1];
-    const inLen = Math.hypot(cur.x - prev.x, cur.y - prev.y);
-    const outLen = Math.hypot(next.x - cur.x, next.y - cur.y);
-    const r = Math.min(radius, inLen / 2, outLen / 2);
-    if (r <= 0) {
-      d += ` L ${cur.x},${cur.y}`;
-      continue;
-    }
-    const ax = cur.x - (cur.x - prev.x) / inLen * r;
-    const ay = cur.y - (cur.y - prev.y) / inLen * r;
-    const bx = cur.x + (next.x - cur.x) / outLen * r;
-    const by = cur.y + (next.y - cur.y) / outLen * r;
-    d += ` L ${ax},${ay} Q ${cur.x},${cur.y} ${bx},${by}`;
-  }
-  const last = points[points.length - 1];
-  return `${d} L ${last.x},${last.y}`;
-}
-function edgePath(points) {
-  if (points.length === 0) return "";
-  let d = `M ${points[0].x},${points[0].y}`;
-  for (let i = 1; i < points.length; i++) d += ` L ${points[i].x},${points[i].y}`;
-  return d;
-}
-
-export { computeTraitLayout, edgePath, roundedEdgePath, useContainerWidth };

package/dist/chunk-ZO6MXAS3.js

@@ -1,69 +0,0 @@
-import { createContext, useMemo, useContext } from 'react';
-import { createLogger } from '@almadar/logger';
-import { jsx } from 'react/jsx-runtime';
-
-var log = createLogger("almadar:ui:trait-provider");
-var TraitContext = createContext(null);
-function TraitProvider({
-  traits: traitBindings,
-  children
-}) {
-  const traitInstances = useMemo(() => {
-    const map = /* @__PURE__ */ new Map();
-    for (const binding of traitBindings) {
-      const trait = binding.trait;
-      const initialState = trait.states.find((s) => s.isInitial);
-      const stateName = initialState?.name || trait.states[0]?.name || "idle";
-      const instance = {
-        name: trait.name,
-        currentState: stateName,
-        availableEvents: trait.transitions.filter((t) => t.from === stateName).map((t) => t.event),
-        dispatch: (eventKey, payload) => {
-          log.debug("Dispatch", () => ({
-            trait: trait.name,
-            event: eventKey,
-            payloadKeys: payload ? Object.keys(payload) : []
-          }));
-        },
-        canDispatch: (eventKey) => {
-          return trait.transitions.some(
-            (t) => t.from === stateName && t.event === eventKey
-          );
-        },
-        trait
-      };
-      map.set(trait.name, instance);
-    }
-    return map;
-  }, [traitBindings]);
-  const contextValue = useMemo(() => {
-    return {
-      traits: traitInstances,
-      getTrait: (name) => traitInstances.get(name),
-      dispatchToTrait: (traitName, eventKey, payload) => {
-        const instance = traitInstances.get(traitName);
-        if (instance) {
-          instance.dispatch(eventKey, payload);
-        }
-      },
-      canDispatch: (traitName, eventKey) => {
-        const instance = traitInstances.get(traitName);
-        return instance?.canDispatch(eventKey) || false;
-      }
-    };
-  }, [traitInstances]);
-  return /* @__PURE__ */ jsx(TraitContext.Provider, { value: contextValue, children });
-}
-function useTraitContext() {
-  const context = useContext(TraitContext);
-  if (!context) {
-    throw new Error("useTraitContext must be used within a TraitProvider");
-  }
-  return context;
-}
-function useTrait(traitName) {
-  const context = useTraitContext();
-  return context.getTrait(traitName);
-}
-
-export { TraitContext, TraitProvider, useTrait, useTraitContext };

package/dist/kernel-client-ZH4PSMCN.js

@@ -1,367 +0,0 @@
-import { createLocalFold, src_exports, createTickDriver, runTickFrame, mirrorResponse, traceResponse } from './chunk-6P3MWXYE.js';
-import './chunk-DYEKAA4L.js';
-import { presenceGroup, getTraitPresence } from './chunk-MBQAMMSE.js';
-import './chunk-G7DCAZ22.js';
-import { TraitMountError } from '@almadar/shell-runtime/client/trait-mount-error';
-import { createLogger } from '@almadar/logger';
-
-var log = createLogger("almadar:ui:kernel-client");
-var defaultFrameScheduler = (callback) => {
-  if (typeof requestAnimationFrame === "function") {
-    const handle = requestAnimationFrame(callback);
-    return () => cancelAnimationFrame(handle);
-  }
-  const timer = setTimeout(() => callback(performance.now()), 16);
-  return () => clearTimeout(timer);
-};
-function parse(text) {
-  return JSON.parse(text);
-}
-function payloadJson(payload) {
-  return payload === void 0 ? void 0 : JSON.stringify(payload);
-}
-function createKernelClient(opts) {
-  const { store, traitIndex, transport } = opts;
-  let loaded;
-  const configs = /* @__PURE__ */ new Map();
-  const ready = opts.instance.then((k) => {
-    loaded = k;
-    return k;
-  });
-  ready.catch(() => void 0);
-  const visibleGroups = [...traitIndex.byName].filter(([, entry]) => (entry.irTrait.ticks ?? []).some((tick) => tick.whileVisible === true)).map(([name]) => [name, presenceGroup(traitIndex, name)]);
-  let queueTail = Promise.resolve();
-  const enqueue = (run) => {
-    const result = queueTail.then(run);
-    queueTail = result.then(() => void 0, () => void 0);
-    return result;
-  };
-  let progressTail = Promise.resolve();
-  let scopeTail = Promise.resolve();
-  const declareScope = (apply) => {
-    const applied = scopeTail.then(() => ready).then(apply);
-    scopeTail = applied.then(() => void 0, () => void 0);
-    return applied;
-  };
-  const frameKeyOf = (trait) => traitIndex.byName.get(trait)?.frameKey;
-  const mirror = (response) => mirrorResponse(store, frameKeyOf, response);
-  const trace = (response) => traceResponse(opts.observer, response);
-  const localFold = createLocalFold({ store, frameKeyOf, ...opts.observer !== void 0 ? { observer: opts.observer } : {} });
-  const lane = new src_exports.DispatchLane();
-  const syncStates = (k, traits) => {
-    for (const trait of traits) {
-      const state = k.getState(trait);
-      if (state !== "" && store.states.getState(trait)?.currentState !== state) store.states.seedState(trait, state);
-    }
-  };
-  const restore = (k, wire, entityId) => {
-    const snapshot = wire.snapshot;
-    if (snapshot === null) return { clientEffects: [], clientEffectsByTrait: [] };
-    const trait = wire.seed.trait;
-    const repaint = parse(k.restore(trait, entityId, JSON.stringify(snapshot)));
-    const frameKey = traitIndex.byName.get(trait)?.frameKey ?? trait;
-    if (snapshot.state !== "") store.states.rollbackState(trait, snapshot.state, entityId, "server-rejected");
-    const entity = snapshot.entity;
-    if (entity !== null && typeof entity === "object" && !Array.isArray(entity)) store.frames.set(frameKey, { ...entity });
-    else store.frames.delete(frameKey);
-    mirror(repaint);
-    store.notify();
-    return { clientEffects: repaint.clientEffects ?? [], clientEffectsByTrait: repaint.clientEffectsByTrait ?? [] };
-  };
-  const planDispatch = (wire, carriesCircuitState) => {
-    if (wire.serverLegs.length > 0) {
-      return {
-        awaiting: wire.awaiting,
-        legs: wire.serverLegs.map(({ orbital, leg }) => ({
-          orbital,
-          leg,
-          keepsState: carriesCircuitState || wire.mode === "hybridClientOnly",
-          alreadyDelivered: wire.alreadyDelivered,
-          foldSeeded: wire.foldSeeded,
-          wires: [wire]
-        }))
-      };
-    }
-    if (!carriesCircuitState && wire.statefulLeg !== null) {
-      return {
-        awaiting: wire.statefulLeg.awaiting,
-        legs: [{ orbital: wire.statefulLeg.orbital, leg: wire.statefulLeg.leg, keepsState: true, alreadyDelivered: wire.alreadyDelivered, foldSeeded: [], wires: [wire] }]
-      };
-    }
-    return { legs: [], awaiting: [] };
-  };
-  const sendLegs = async (k, legs, request, flags, initial) => {
-    const out = {
-      response: initial,
-      serverEffects: { clientEffects: [], clientEffectsByTrait: [] },
-      success: true,
-      rejections: [],
-      foldedEmits: []
-    };
-    if (transport === void 0) return out;
-    const queue = [...legs];
-    for (let planned = queue.shift(); planned !== void 0; planned = queue.shift()) {
-      const shaped = planned.keepsState ? planned.leg : JSON.parse(k.statefulLeg(JSON.stringify(planned.leg)));
-      const sent = request.locale !== void 0 ? { ...shaped, locale: request.locale } : shaped;
-      const base = k.foldBase(sent.entityByTrait !== void 0 ? JSON.stringify(sent.entityByTrait) : void 0, JSON.stringify(planned.foldSeeded), sent.entityId);
-      let posted;
-      try {
-        posted = await transport.send(planned.orbital, sent);
-      } catch (err) {
-        if (flags.rollback || flags.mount) for (const wire of planned.wires) restore(k, wire, request.entityId);
-        throw err instanceof Error ? err : new Error(String(err));
-      }
-      if (!posted.success) {
-        const optimistic = planned.wires.filter((wire) => wire.mode === "runtimeOptimistic");
-        if (flags.rollback && optimistic.length > 0) {
-          return { ...out, response: posted, success: false, rolledBack: restore(k, optimistic[0], request.entityId) };
-        }
-        if (flags.mount) for (const wire of optimistic) restore(k, wire, request.entityId);
-      }
-      const applied = parse(k.applyServerResponse(JSON.stringify(posted), JSON.stringify(planned.alreadyDelivered), base));
-      log.debug("fold", { orbital: planned.orbital, event: sent.event, posted: { success: posted.success, states: posted.states, emitted: posted.emittedEvents.map((e) => e.event) }, applied: applied.applied, cascadeEmitted: applied.response.emittedEvents.map((e) => e.event) });
-      trace(applied.response);
-      for (const routed of applied.serverLegs) {
-        queue.push({ orbital: routed.orbital, leg: routed.leg, keepsState: true, alreadyDelivered: [], foldSeeded: [], wires: [] });
-      }
-      mirror(posted);
-      mirror(applied.response);
-      syncStates(k, [...Object.keys(posted.states), ...applied.applied.map(([trait]) => trait)]);
-      store.notify();
-      const fold = applied.response;
-      const delivered = new Set(planned.alreadyDelivered.map(([trait, event]) => `${trait}\0${event}`));
-      const serverEmits = posted.emittedEvents.filter((e) => !delivered.has(`${e.source?.trait ?? ""}\0${e.event}`));
-      const effects = [...posted.clientEffects ?? [], ...fold.clientEffects ?? []];
-      const byTrait = [...posted.clientEffectsByTrait ?? [], ...fold.clientEffectsByTrait ?? []];
-      out.serverEffects.clientEffects?.push(...effects);
-      out.serverEffects.clientEffectsByTrait?.push(...byTrait);
-      out.foldedEmits.push(...serverEmits, ...fold.emittedEvents);
-      out.response = {
-        ...out.response,
-        emittedEvents: [...out.response.emittedEvents, ...serverEmits, ...fold.emittedEvents],
-        clientEffects: [...out.response.clientEffects ?? [], ...effects],
-        clientEffectsByTrait: [...out.response.clientEffectsByTrait ?? [], ...byTrait],
-        effectResults: [...out.response.effectResults ?? [], ...fold.effectResults ?? []]
-      };
-      out.success = out.success && posted.success;
-      if (posted.error !== void 0) out.error = posted.error;
-      out.rejections.push(...(fold.rejections ?? []).filter((r) => r.code === "effect-failed"));
-    }
-    return out;
-  };
-  const post = async (k, wire, request, flags) => {
-    const topology = await opts.topology;
-    const plan = planDispatch(wire, topology.carriesCircuitState);
-    const awaiting = flags.awaiting ? plan.awaiting : [];
-    store.awaiting.begin(awaiting);
-    try {
-      return await sendLegs(k, plan.legs, request, { rollback: flags.rollback, mount: false }, wire.response);
-    } finally {
-      store.awaiting.end(awaiting.map((a) => a.trait));
-    }
-  };
-  const framePost = (k) => {
-    if (transport === void 0) return void 0;
-    return {
-      postDispatch: async (wire) => (await post(k, wire, {}, { rollback: false, awaiting: false })).serverEffects,
-      sendBrowserLeg: async (routed, frameResponse) => {
-        const planned = { orbital: routed.orbital, leg: routed.leg, keepsState: true, alreadyDelivered: [], foldSeeded: [], wires: [] };
-        return (await sendLegs(k, [planned], {}, { rollback: false, mount: false }, frameResponse)).serverEffects;
-      }
-    };
-  };
-  const tickPorts = (k) => ({
-    kernel: {
-      frame: (nowMs) => {
-        const presence = getTraitPresence();
-        for (const [traitName, group] of visibleGroups) k.setTraitOnScreen(traitName, presence.state(group) !== "off-screen");
-        return k.frame(nowMs);
-      },
-      framePause: () => k.framePause(),
-      frameResume: () => k.frameResume(),
-      tickCount: () => k.tickCount()
-    },
-    lane,
-    client: localFold,
-    post: framePost(k)
-  });
-  const dispatchOne = async (request, hooks, progress) => {
-    const traitName = request.targetTrait;
-    if (traitName === void 0) throw new Error("dispatch requires request.targetTrait (the seed trait)");
-    const k = await ready;
-    if (request.runTick !== void 0) {
-      const response = parse(k.tick(request.runTick.trait, request.runTick.tick, request.entityId));
-      mirror(response);
-      store.notify();
-      return { response, mode: parse(k.dispatchMode(request.runTick.trait)) };
-    }
-    const wire = parse(k.dispatch(traitName, request.entityId, request.event, payloadJson(request.payload)));
-    log.debug("dispatch", { trait: traitName, event: request.event, mode: wire.mode, legs: wire.serverLegs.length, success: wire.response.success, states: wire.response.states, effects: (wire.response.clientEffectsByTrait ?? []).map((e) => `${e.traitName}:${e.effect[0]}:${e.effect[1] ?? ""}`), emitted: wire.response.emittedEvents.map((e) => e.event) });
-    trace(wire.response);
-    mirror(wire.response);
-    store.notify();
-    if (transport === void 0 || wire.serverLegs.length === 0 && wire.statefulLeg === null) return { response: wire.response, mode: wire.mode };
-    const painters = hooks.filter((h) => h.onLocal !== void 0);
-    for (const h of painters) h.onLocal?.(wire.response);
-    const posted = await post(k, wire, request, { rollback: true, awaiting: !progress });
-    const localPainted = painters.length > 0;
-    if (posted.rolledBack !== void 0) {
-      return { response: posted.response, mode: wire.mode, ...localPainted ? { localPainted, serverEffects: posted.rolledBack } : {} };
-    }
-    return localPainted ? { response: posted.response, mode: wire.mode, localPainted, serverEffects: posted.serverEffects } : { response: posted.response, mode: wire.mode };
-  };
-  const client = {
-    store,
-    dispatch: (request, hooks) => enqueue(() => dispatchOne(request, hooks !== void 0 ? [hooks] : [], false)),
-    dispatchProgress: (request) => {
-      const outcome = progressTail.then(() => dispatchOne(request, [], true));
-      progressTail = outcome.then(() => void 0, () => void 0);
-      return outcome;
-    },
-    foldHostDispatch: (request, response) => enqueue(async () => {
-      const k = await ready;
-      if (request.targetTrait === void 0) throw new Error("foldHostDispatch requires request.targetTrait (the seed trait)");
-      const mode = parse(k.dispatchMode(request.targetTrait));
-      if (!response.success) return { response: { ...response, clientEffects: [], clientEffectsByTrait: [] }, mode };
-      const applied = parse(k.applyServerResponse(JSON.stringify(response), "[]"));
-      trace(applied.response);
-      mirror(response);
-      mirror(applied.response);
-      syncStates(k, [...Object.keys(response.states), ...applied.applied.map(([trait]) => trait)]);
-      store.notify();
-      return {
-        response: {
-          ...response,
-          clientEffects: [...response.clientEffects ?? [], ...applied.response.clientEffects ?? []],
-          clientEffectsByTrait: [...response.clientEffectsByTrait ?? [], ...applied.response.clientEffectsByTrait ?? []]
-        },
-        mode
-      };
-    }),
-    dispatchMount: (seeds, hooks, base) => enqueue(async () => {
-      const k = await ready;
-      await scopeTail;
-      const baseRequest = base ?? {};
-      k.mount(JSON.stringify(seeds.map((s) => s.trait)));
-      const mount = parse(k.dispatchMount(JSON.stringify(seeds), baseRequest.entityId, payloadJson(baseRequest.payload)));
-      if (mount.failed !== null) {
-        const failed = mount.failed;
-        throw new TraitMountError(failed.trait, failed.event, new Error(failed.message));
-      }
-      const wires = mount.seeds;
-      for (const wire of wires) {
-        log.debug("mount", { trait: wire.seed.trait, event: wire.seed.event, mode: wire.mode, legs: wire.serverLegs.length, success: wire.response.success });
-        trace(wire.response);
-        mirror(wire.response);
-      }
-      store.notify();
-      for (const wire of wires) hooks?.onLocal?.(wire.seed.trait, wire.response);
-      const outcome = {
-        seeds: wires.map((w) => ({ trait: w.seed.trait, event: w.seed.event, mode: w.mode, local: w.response })),
-        posted: false,
-        success: true,
-        rejections: [],
-        serverEffects: { clientEffects: [], clientEffectsByTrait: [] },
-        emittedEvents: []
-      };
-      if (transport === void 0) return outcome;
-      const topology = await opts.topology;
-      for (const group of topology.carriesCircuitState ? mount.legs : mount.statefulLegs) {
-        const answered = wires.filter((w) => group.seeds.some((s) => s.trait === w.seed.trait && s.event === w.seed.event));
-        const planned = { orbital: group.orbital, leg: group.leg, keepsState: true, alreadyDelivered: group.alreadyDelivered, foldSeeded: group.foldSeeded, wires: answered };
-        store.awaiting.begin(group.awaiting);
-        let posted;
-        try {
-          posted = await sendLegs(k, [planned], baseRequest, { rollback: false, mount: true }, answered[0]?.response ?? outcome.seeds[0].local);
-        } finally {
-          store.awaiting.end(group.awaiting.map((a) => a.trait));
-        }
-        outcome.posted = true;
-        outcome.success = outcome.success && posted.success;
-        if (posted.error !== void 0) outcome.error = posted.error;
-        outcome.rejections.push(...posted.rejections);
-        outcome.serverEffects.clientEffects?.push(...posted.serverEffects.clientEffects ?? []);
-        outcome.serverEffects.clientEffectsByTrait?.push(...posted.serverEffects.clientEffectsByTrait ?? []);
-        outcome.emittedEvents.push(...posted.foldedEmits);
-      }
-      return outcome;
-    }),
-    routeMounts: async (routePath) => parse((await ready).routeMounts(routePath)),
-    remount: (traits) => declareScope((k) => k.remount(JSON.stringify(traits))),
-    mount: (traits) => declareScope((k) => k.mount(JSON.stringify(traits))),
-    unmount: (traits) => declareScope((k) => k.unmount(JSON.stringify(traits))),
-    frame: async (nowMs) => {
-      const k = await ready;
-      await scopeTail;
-      return (await runTickFrame(tickPorts(k), () => nowMs)).outcomes;
-    },
-    framePause: () => loaded?.framePause(),
-    frameResume: () => loaded?.frameResume(),
-    startFrames: (onFrame, schedule = defaultFrameScheduler) => {
-      const presence = getTraitPresence();
-      const releases = visibleGroups.map(([, group]) => presence.watch(group));
-      let stopped = false;
-      let latestMs = 0;
-      let nextHandle = 0;
-      const cancels = /* @__PURE__ */ new Map();
-      const visibility = {
-        hidden: () => document.visibilityState === "hidden",
-        onChange: (listener) => {
-          document.addEventListener("visibilitychange", listener);
-          return () => document.removeEventListener("visibilitychange", listener);
-        }
-      };
-      let driver;
-      ready.then(async (k) => {
-        await scopeTail;
-        if (stopped) return;
-        driver = createTickDriver({
-          ...tickPorts(k),
-          now: () => latestMs,
-          requestFrame: (callback) => {
-            nextHandle += 1;
-            const handle = nextHandle;
-            cancels.set(handle, schedule((nowMs) => {
-              cancels.delete(handle);
-              latestMs = nowMs;
-              callback(nowMs);
-            }));
-            return handle;
-          },
-          cancelFrame: (handle) => {
-            cancels.get(handle)?.();
-            cancels.delete(handle);
-          },
-          visibility,
-          onApplied: (applied) => {
-            if (!stopped && applied.outcomes.length > 0) onFrame(applied.outcomes);
-          },
-          onError: (error) => log.error("kernel-frame-failed", { error: error.message })
-        });
-        driver.start();
-      }).catch((error) => log.error("kernel-frame-failed", { error: error.message }));
-      return () => {
-        stopped = true;
-        driver?.stop();
-        releases.forEach((release) => release());
-      };
-    },
-    traitState: (traitName) => loaded?.getState(traitName),
-    traitConfig: (traitName) => {
-      if (loaded === void 0) return void 0;
-      const held = configs.get(traitName);
-      if (held !== void 0) return held;
-      const config = parse(loaded.traitConfig(traitName));
-      configs.set(traitName, config);
-      return config;
-    },
-    setViewer: async (user) => {
-      const k = await ready;
-      k.setCurrentUser(JSON.stringify(user));
-      configs.clear();
-    }
-  };
-  return client;
-}
-
-export { createKernelClient };