@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/chunk-ILZ7ORX7.js

@@ -0,0 +1,432 @@
+import { createLogger } from '@almadar/logger';
+
+// src/lib/keyMapEvent.ts
+function isEditableTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  const tag = target.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  if (target.isContentEditable || target.contentEditable === "true") return true;
+  const attr = target.getAttribute("contenteditable");
+  return attr === "" || attr === "true" || attr === "plaintext-only";
+}
+function keyMapCode(e) {
+  let code = e.code;
+  if (e.altKey) code = `Alt+${code}`;
+  if (e.shiftKey) code = `Shift+${code}`;
+  if (e.metaKey || e.ctrlKey) code = `Mod+${code}`;
+  return code;
+}
+function resolveKeyMapEvent(map, e) {
+  if (!map || isEditableTarget(e.target)) return void 0;
+  return map[keyMapCode(e)] ?? map[e.code];
+}
+var log = createLogger("almadar:bridge");
+var MAX_TRANSITIONS = 500;
+function getState() {
+  if (typeof window !== "undefined") {
+    const w = window;
+    if (!w.__verificationRegistryState) {
+      w.__verificationRegistryState = {
+        checks: /* @__PURE__ */ new Map(),
+        transitions: [],
+        bridgeHealth: null,
+        listeners: /* @__PURE__ */ new Set(),
+        traitSnapshots: /* @__PURE__ */ new Map()
+      };
+    }
+    return w.__verificationRegistryState;
+  }
+  return {
+    checks: /* @__PURE__ */ new Map(),
+    transitions: [],
+    bridgeHealth: null,
+    listeners: /* @__PURE__ */ new Set(),
+    traitSnapshots: /* @__PURE__ */ new Map()
+  };
+}
+function notifyListeners() {
+  getState().listeners.forEach((l) => l());
+  exposeOnWindow();
+}
+function registerCheck(id, label, status = "pending", details) {
+  getState().checks.set(id, { id, label, status, details, updatedAt: Date.now() });
+  notifyListeners();
+}
+function updateCheck(id, status, details) {
+  const check = getState().checks.get(id);
+  if (check) {
+    check.status = status;
+    if (details !== void 0) check.details = details;
+    check.updatedAt = Date.now();
+  } else {
+    getState().checks.set(id, { id, label: id, status, details, updatedAt: Date.now() });
+  }
+  notifyListeners();
+}
+function getAllChecks() {
+  return Array.from(getState().checks.values());
+}
+function recordTransition(trace) {
+  const entry = {
+    ...trace,
+    id: `t-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  };
+  log.debug("transition:recorded", { trait: trace.traitName, from: trace.from, to: trace.to, event: trace.event, effectCount: trace.effects.length });
+  getState().transitions.push(entry);
+  if (getState().transitions.length > MAX_TRANSITIONS) {
+    getState().transitions.shift();
+  }
+  if (entry.event === "INIT") {
+    const hasFetch = entry.effects.some((e) => e.type === "fetch");
+    const hasEntitySeed = entry.effects.some(
+      (e) => e.type === "set" && typeof e.args[0] === "string" && e.args[0].startsWith("@entity.")
+    );
+    const checkId = `init-fetch-${entry.traitName}`;
+    if (hasFetch || hasEntitySeed) {
+      registerCheck(
+        checkId,
+        `INIT transition for "${entry.traitName}" has fetch or entity-seed effect`,
+        "pass"
+      );
+    } else {
+      const rendersEntityData = entry.effects.some(
+        (e) => e.type === "render-ui" && JSON.stringify(e.args).includes("@entity.")
+      );
+      if (rendersEntityData) {
+        const siblingSeeds = getState().transitions.some(
+          (t) => t.event === "INIT" && t.effects.some(
+            (e) => e.type === "fetch" || e.type === "set" && typeof e.args[0] === "string" && e.args[0].startsWith("@entity.")
+          )
+        );
+        if (siblingSeeds) {
+          registerCheck(
+            checkId,
+            `INIT transition for "${entry.traitName}" has sibling entity-seed (shared entity)`,
+            "pass"
+          );
+        } else {
+          registerCheck(
+            checkId,
+            `INIT transition for "${entry.traitName}" missing fetch effect`,
+            "fail",
+            "Entity-bound render-ui without a fetch effect will show empty data"
+          );
+        }
+      }
+    }
+  }
+  const failedEffects = entry.effects.filter((e) => e.status === "failed");
+  if (failedEffects.length > 0) {
+    registerCheck(
+      `effects-${entry.id}`,
+      `Effects failed in ${entry.traitName}: ${entry.from} -> ${entry.to}`,
+      "fail",
+      failedEffects.map((e) => `${e.type}: ${e.error}`).join("; ")
+    );
+  }
+  notifyListeners();
+}
+function getTransitions() {
+  return [...getState().transitions];
+}
+function getTransitionsForTrait(traitName) {
+  return getState().transitions.filter((t) => t.traitName === traitName);
+}
+function recordServerResponse(orbitalName, event, response) {
+  const { effectResults, ...responseFields } = response;
+  const serverResponse = {
+    ...responseFields,
+    orbitalName,
+    timestamp: Date.now()
+  };
+  const entry = {
+    id: `srv-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    traitName: `server:${orbitalName}`,
+    from: "server",
+    to: "server",
+    event,
+    effects: effectResults ?? [],
+    serverResponse,
+    timestamp: Date.now()
+  };
+  getState().transitions.push(entry);
+  if (getState().transitions.length > MAX_TRANSITIONS) {
+    getState().transitions.shift();
+  }
+  if (!response.success && response.error) {
+    registerCheck(
+      `server-error-${entry.id}`,
+      `Server error for ${orbitalName}:${event}`,
+      "fail",
+      response.error
+    );
+  }
+  notifyListeners();
+}
+function serverEffectTraces(results) {
+  if (!results) return [];
+  return results.map((r) => {
+    const resultId = typeof r.data === "object" && r.data !== null && !Array.isArray(r.data) && "id" in r.data && typeof r.data.id === "string" ? r.data.id : void 0;
+    const outcome = r.denied ? "denied" : r.success ? "success" : "failed";
+    return {
+      type: r.effect,
+      ...r.entityType !== void 0 ? { entityName: r.entityType } : {},
+      ...r.action === "create" || r.action === "update" || r.action === "delete" || r.action === "batch" ? { action: r.action } : {},
+      ...resultId !== void 0 ? { resultId } : {},
+      outcome,
+      args: [],
+      status: outcome === "success" ? "executed" : "failed",
+      ...r.error !== void 0 ? { error: r.error } : {},
+      ...r.target !== void 0 ? { target: r.target } : {},
+      ...r.routed !== void 0 ? { routed: r.routed } : {}
+    };
+  });
+}
+function recordOrbitalResponse(orbitalName, request, response) {
+  recordServerResponse(orbitalName, request.event, {
+    success: response.success,
+    transitioned: response.transitioned,
+    emitted: response.emittedEvents.map((e) => ({ event: e.event, ...e.payload !== void 0 ? { payload: e.payload } : {} })),
+    emittedEvents: response.emittedEvents.map((e) => e.event),
+    clientEffects: response.clientEffectsByTrait?.length ?? 0,
+    dataEntities: Object.fromEntries(Object.entries(response.data ?? {}).map(([name, rows]) => [name, rows.length])),
+    ...response.error !== void 0 ? { error: response.error } : {},
+    effectResults: serverEffectTraces(response.effectResults)
+  });
+}
+function recordingTransport(transport) {
+  const subscribe = transport.subscribe?.bind(transport);
+  const subscribeHostDispatches = transport.subscribeHostDispatches?.bind(transport);
+  return {
+    ...transport.hostsBrowserStore !== void 0 ? { hostsBrowserStore: transport.hostsBrowserStore } : {},
+    register: (schema) => transport.register(schema),
+    unregister: () => transport.unregister(),
+    send: async (orbitalName, request) => {
+      const response = await transport.send(orbitalName, request);
+      recordOrbitalResponse(orbitalName, request, response);
+      return response;
+    },
+    ...subscribe !== void 0 ? { subscribe } : {},
+    ...subscribeHostDispatches !== void 0 ? { subscribeHostDispatches } : {}
+  };
+}
+function updateBridgeHealth(health) {
+  getState().bridgeHealth = { ...health };
+  const checkId = "server-bridge";
+  if (health.connected) {
+    registerCheck(checkId, "Server bridge connected", "pass");
+  } else {
+    registerCheck(
+      checkId,
+      "Server bridge disconnected",
+      "fail",
+      health.lastError || "Bridge is not connected"
+    );
+  }
+  notifyListeners();
+}
+function getBridgeHealth() {
+  const bh = getState().bridgeHealth;
+  return bh ? { ...bh } : null;
+}
+function getSummary() {
+  const allChecks = getAllChecks();
+  return {
+    totalChecks: allChecks.length,
+    passed: allChecks.filter((c) => c.status === "pass").length,
+    failed: allChecks.filter((c) => c.status === "fail").length,
+    warnings: allChecks.filter((c) => c.status === "warn").length,
+    pending: allChecks.filter((c) => c.status === "pending").length
+  };
+}
+function getSnapshot() {
+  return {
+    checks: getAllChecks(),
+    transitions: getTransitions(),
+    bridge: getBridgeHealth(),
+    summary: getSummary(),
+    traits: getTraitSnapshots()
+  };
+}
+function getTraitSnapshots() {
+  const snapshots = [];
+  for (const [traitName, getter] of getState().traitSnapshots.entries()) {
+    try {
+      snapshots.push(getter());
+    } catch (err) {
+      log.error("traitSnapshot getter failed", { trait: traitName, err: String(err) });
+    }
+  }
+  return snapshots;
+}
+function subscribeToVerification(listener) {
+  getState().listeners.add(listener);
+  return () => getState().listeners.delete(listener);
+}
+function defaultGetTraitState(traitName) {
+  const getter = getState().traitSnapshots.get(traitName);
+  if (getter === void 0) return void 0;
+  try {
+    return getter().currentState;
+  } catch {
+    return void 0;
+  }
+}
+function verifierAttached() {
+  return typeof window !== "undefined" && window.__ALMADAR_VERIFY__ === true;
+}
+function exposeOnWindow() {
+  if (typeof window === "undefined") return;
+  if (!window.__orbitalVerification) {
+    window.__orbitalVerification = {
+      getSnapshot,
+      getChecks: getAllChecks,
+      getTransitions,
+      getBridge: getBridgeHealth,
+      getSummary,
+      waitForTransition,
+      getTraitSnapshots,
+      getTraitState: defaultGetTraitState
+    };
+  } else {
+    if (!window.__orbitalVerification.getTraitSnapshots) {
+      window.__orbitalVerification.getTraitSnapshots = getTraitSnapshots;
+    }
+    if (!window.__orbitalVerification.getTraitState) {
+      window.__orbitalVerification.getTraitState = defaultGetTraitState;
+    }
+  }
+}
+function waitForTransition(event, timeoutMs = 1e4) {
+  return new Promise((resolve) => {
+    const existing = getState().transitions.find((t) => t.event === event);
+    if (existing) {
+      resolve(existing);
+      return;
+    }
+    const timeout = setTimeout(() => {
+      unsub();
+      resolve(null);
+    }, timeoutMs);
+    const unsub = subscribeToVerification(() => {
+      const found = getState().transitions.find((t) => t.event === event);
+      if (found) {
+        clearTimeout(timeout);
+        unsub();
+        resolve(found);
+      }
+    });
+  });
+}
+function bindEventBus(eventBus) {
+  if (typeof window === "undefined") return;
+  log.info("bindEventBus", { hasOnAny: !!eventBus.onAny });
+  exposeOnWindow();
+  if (window.__orbitalVerification) {
+    window.__orbitalVerification.sendEvent = (event, payload, traitScope) => {
+      const prefixed = event.startsWith("UI:") ? event : traitScope ? `UI:${traitScope}.${event}` : `UI:${event}`;
+      log.debug("sendEvent", { event: prefixed, traitScope, payloadKeys: payload ? Object.keys(payload) : [] });
+      eventBus.emit(prefixed, payload);
+    };
+    const MAX_EVENT_LOG = 5e3;
+    const eventLog = [];
+    let eventLogDropped = 0;
+    const bumpEpoch = () => {
+      window.__orbitalVerification.eventLogEpoch = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    };
+    window.__orbitalVerification.eventLog = eventLog;
+    window.__orbitalVerification.eventLogDropped = 0;
+    bumpEpoch();
+    window.__orbitalVerification.clearEventLog = () => {
+      eventLog.length = 0;
+      eventLogDropped = 0;
+      window.__orbitalVerification.eventLogDropped = 0;
+      bumpEpoch();
+    };
+    if (eventBus.onAny) {
+      const verificationRegistryEventLogger = (event) => {
+        eventLog.push({
+          type: event.type,
+          payload: event.payload,
+          ...event.source === void 0 ? {} : { source: event.source },
+          timestamp: Date.now()
+        });
+        if (eventLog.length > MAX_EVENT_LOG) {
+          eventLog.shift();
+          eventLogDropped += 1;
+          window.__orbitalVerification.eventLogDropped = eventLogDropped;
+        }
+      };
+      Object.defineProperty(verificationRegistryEventLogger, "name", {
+        value: "verificationRegistry:eventLog"
+      });
+      eventBus.onAny(verificationRegistryEventLogger);
+    }
+  }
+}
+function bindConfigApplier(applyConfig) {
+  if (typeof window === "undefined") return () => {
+  };
+  exposeOnWindow();
+  const bridge = window.__orbitalVerification;
+  if (!bridge) return () => {
+  };
+  bridge.applyConfig = applyConfig;
+  return () => {
+    if (bridge.applyConfig === applyConfig) delete bridge.applyConfig;
+  };
+}
+function bindTraitStateGetter(getter) {
+  if (typeof window === "undefined") return;
+  exposeOnWindow();
+  if (window.__orbitalVerification) {
+    window.__orbitalVerification.getTraitState = getter;
+  }
+}
+function registerTraitSnapshot(traitName, getter) {
+  if (typeof window === "undefined") return () => {
+  };
+  getState().traitSnapshots.set(traitName, getter);
+  exposeOnWindow();
+  notifyListeners();
+  return () => {
+    const s = getState();
+    if (s.traitSnapshots.get(traitName) === getter) {
+      s.traitSnapshots.delete(traitName);
+      notifyListeners();
+    }
+  };
+}
+function bindCanvasCapture(captureFn) {
+  if (typeof window === "undefined") return;
+  exposeOnWindow();
+  if (window.__orbitalVerification) {
+    window.__orbitalVerification.captureFrame = captureFn;
+  }
+}
+function bindLastDrawables(getDrawables) {
+  if (typeof window === "undefined") return;
+  exposeOnWindow();
+  if (window.__orbitalVerification) {
+    window.__orbitalVerification.getLastDrawables = getDrawables;
+  }
+}
+function updateAssetStatus(url, status) {
+  if (typeof window === "undefined") return;
+  exposeOnWindow();
+  if (window.__orbitalVerification) {
+    if (!window.__orbitalVerification.assetStatus) {
+      window.__orbitalVerification.assetStatus = {};
+    }
+    window.__orbitalVerification.assetStatus[url] = status;
+  }
+}
+function clearVerification() {
+  getState().checks.clear();
+  getState().transitions.length = 0;
+  getState().bridgeHealth = null;
+  notifyListeners();
+}
+exposeOnWindow();
+
+export { bindCanvasCapture, bindConfigApplier, bindEventBus, bindLastDrawables, bindTraitStateGetter, clearVerification, getAllChecks, getBridgeHealth, getSnapshot, getSummary, getTraitSnapshots, getTransitions, getTransitionsForTrait, isEditableTarget, keyMapCode, recordOrbitalResponse, recordServerResponse, recordTransition, recordingTransport, registerCheck, registerTraitSnapshot, resolveKeyMapEvent, serverEffectTraces, subscribeToVerification, updateAssetStatus, updateBridgeHealth, updateCheck, verifierAttached, waitForTransition };