@almadar/shell-runtime 0.0.0-stage → 0.1.0

package/dist/chunk-Q2H75UYT.js

@@ -0,0 +1,92 @@
+import { normalizeEventKey, LIFECYCLE_EVENTS } from '@almadar/core';
+
+// src/client/state-book.ts
+function findInitialState(trait) {
+  const markedInitial = trait.states?.find((s) => s.isInitial)?.name;
+  return markedInitial ?? trait.states?.[0]?.name ?? "unknown";
+}
+function createInitialTraitState(trait) {
+  return {
+    traitName: trait.name,
+    currentState: findInitialState(trait),
+    previousState: null,
+    lastEvent: null,
+    context: {}
+  };
+}
+function findMatchingTransitions(trait, currentState, eventKey, eventId) {
+  return (trait.transitions ?? []).filter((t) => {
+    const fromMatches = Array.isArray(t.from) ? t.from.includes(currentState) : t.from === currentState;
+    if (!fromMatches) return false;
+    if (eventId && t.eventId) return t.eventId === eventId;
+    return t.event === eventKey;
+  });
+}
+function findTransition(trait, currentState, eventKey, eventId) {
+  return findMatchingTransitions(trait, currentState, eventKey, eventId)[0];
+}
+var SINGLETON_SCOPE = "__singleton__";
+var key = (traitName, entityId) => `${traitName}::${entityId ?? SINGLETON_SCOPE}`;
+var StateBook = class {
+  constructor(traits = [], observer) {
+    this.observer = observer;
+    for (const trait of traits) this.traits.set(trait.name, trait);
+  }
+  observer;
+  traits = /* @__PURE__ */ new Map();
+  states = /* @__PURE__ */ new Map();
+  /** The trait's state, its initial state until the kernel reports one; `undefined` for a trait not on the page. */
+  getState(traitName, entityId) {
+    const recorded = this.states.get(key(traitName, entityId));
+    if (recorded !== void 0) return recorded;
+    const trait = this.traits.get(traitName);
+    return trait === void 0 ? void 0 : createInitialTraitState(trait);
+  }
+  /** Each trait's singleton-scope state. */
+  getAllStates() {
+    const out = /* @__PURE__ */ new Map();
+    for (const name of this.traits.keys()) {
+      const state = this.getState(name);
+      if (state !== void 0) out.set(name, state);
+    }
+    return out;
+  }
+  /** Whether the trait has an arm on the event from its current state. */
+  canHandleEvent(traitName, eventKey, entityId, eventId) {
+    const trait = this.traits.get(traitName);
+    const state = this.getState(traitName, entityId);
+    if (trait === void 0 || state === void 0) return false;
+    return findTransition(trait, state.currentState, normalizeEventKey(eventKey), eventId) !== void 0;
+  }
+  /**
+   * The lifecycle event an embedded child can be repainted with: the one it handles from its current state,
+   * provided every matching arm stays in that state and only renders.
+   */
+  repaintLifecycleEvent(traitName, entityId) {
+    const trait = this.traits.get(traitName);
+    const state = this.getState(traitName, entityId);
+    if (trait === void 0 || state === void 0) return void 0;
+    for (const event of LIFECYCLE_EVENTS) {
+      const arms = findMatchingTransitions(trait, state.currentState, event);
+      if (arms.length === 0) continue;
+      const repaints = arms.every((t) => t.to === state.currentState && (t.effects ?? []).every((effect) => Array.isArray(effect) && effect[0] === "render-ui"));
+      return repaints ? event : void 0;
+    }
+    return void 0;
+  }
+  /** Record the state the kernel reports. No-op for a trait not on the page. */
+  seedState(traitName, currentState, entityId) {
+    const trait = this.traits.get(traitName);
+    if (trait === void 0) return;
+    const existing = this.states.get(key(traitName, entityId)) ?? createInitialTraitState(trait);
+    this.states.set(key(traitName, entityId), { ...existing, currentState, previousState: existing.currentState });
+  }
+  /** Undo an optimistic commit, reporting the hop back to the observer. */
+  rollbackState(traitName, toState, entityId, cause) {
+    const from = this.getState(traitName, entityId)?.currentState;
+    this.seedState(traitName, toState, entityId);
+    if (from !== void 0 && from !== toState) this.observer?.onRollback?.({ traitName, from, to: toState, cause });
+  }
+};
+
+export { StateBook, createInitialTraitState, findInitialState, findMatchingTransitions, findTransition };

package/dist/chunk-Q7JK4KY7.js

@@ -0,0 +1,9 @@
+import { CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV } from './chunk-NAECVIAR.js';
+
+// src/credentials/env-vars.ts
+var STORE_BOOTSTRAP_ENV_VARS = /* @__PURE__ */ new Set([CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV]);
+function allCredentialEnvVars() {
+  return new Set(STORE_BOOTSTRAP_ENV_VARS);
+}
+
+export { STORE_BOOTSTRAP_ENV_VARS, allCredentialEnvVars };

package/dist/chunk-QELZ6TEJ.js

@@ -0,0 +1,208 @@
+import { createLogger } from '@almadar/logger';
+import { RowQueryPageSchema, OrbitalRegisterResponseSchema } from '@almadar/core';
+
+// src/client/EventTransport.ts
+var log = createLogger("almadar:runtime:event-transport");
+function deriveCarriesCircuitState(topology) {
+  return topology !== "stateful";
+}
+async function authHeaders(getAccessToken) {
+  const headers = { "Content-Type": "application/json" };
+  const token = getAccessToken ? await getAccessToken() : void 0;
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return headers;
+}
+function deriveEventsUrl(serverUrl) {
+  const trimmed = serverUrl.replace(/\/+$/, "");
+  const apiRoot = trimmed.replace(/\/[^/]*$/, "");
+  return `${apiRoot}/events`;
+}
+function isBusPushEnvelope(value) {
+  return value.type === "bus" && typeof value.event === "string";
+}
+function isDispatchPushEnvelope(value) {
+  return value.type === "dispatch" && typeof value.orbitalName === "string" && value.request !== void 0 && value.response !== void 0;
+}
+var EVENT_SOURCE_CLOSED = 2;
+var REOPEN_DELAY_MS = 1e3;
+var pushChannels = /* @__PURE__ */ new Map();
+function parseFrameNumber(id) {
+  const dash = id.lastIndexOf("-");
+  if (dash <= 0) return void 0;
+  const n = Number(id.slice(dash + 1));
+  return Number.isInteger(n) ? { boot: id.slice(0, dash), n } : void 0;
+}
+var lastFrameByClient = /* @__PURE__ */ new Map();
+function acquirePushChannel(key, resolveUrl, resumeKey, subscriber) {
+  let channel = pushChannels.get(key);
+  if (channel === void 0) {
+    const created = { source: void 0, subscribers: /* @__PURE__ */ new Set(), closed: false };
+    const open = async () => {
+      let url;
+      try {
+        url = await resolveUrl();
+      } catch (err) {
+        log.error("push:open-failed", { error: err instanceof Error ? err.message : String(err) });
+        return;
+      }
+      if (created.closed) return;
+      const source = new EventSource(url);
+      created.source = source;
+      source.onmessage = (ev) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(ev.data);
+        } catch (err) {
+          log.warn("push:parse-failed", { error: err instanceof Error ? err.message : String(err) });
+          return;
+        }
+        const number = ev.lastEventId ? parseFrameNumber(ev.lastEventId) : void 0;
+        if (number !== void 0 && resumeKey !== void 0) {
+          const seen = lastFrameByClient.get(resumeKey);
+          if (seen !== void 0 && seen.boot === number.boot && number.n <= seen.n) return;
+          lastFrameByClient.set(resumeKey, number);
+        }
+        for (const sub of created.subscribers) sub(parsed);
+      };
+      source.onerror = () => {
+        log.warn("push:connection-error", { channel: key });
+        if (source.readyState === EVENT_SOURCE_CLOSED && !created.closed) {
+          created.source = void 0;
+          setTimeout(() => {
+            if (!created.closed) void open();
+          }, REOPEN_DELAY_MS);
+        }
+      };
+    };
+    pushChannels.set(key, created);
+    void open();
+    channel = created;
+  }
+  channel.subscribers.add(subscriber);
+  return () => {
+    channel.subscribers.delete(subscriber);
+    if (channel.subscribers.size === 0) {
+      channel.closed = true;
+      channel.source?.close();
+      pushChannels.delete(key);
+    }
+  };
+}
+var COMPRESSED_BODY_MIN_BYTES = 32 * 1024;
+async function encodeJsonBody(value, compress) {
+  const text = JSON.stringify(value);
+  if (!compress || text.length < COMPRESSED_BODY_MIN_BYTES || typeof CompressionStream === "undefined") return { body: text };
+  const bytes = new TextEncoder().encode(text);
+  const source = new ReadableStream({ start(controller) {
+    controller.enqueue(bytes);
+    controller.close();
+  } });
+  const gzipped = source.pipeThrough(new CompressionStream("gzip"));
+  return { body: new Uint8Array(await new Response(gzipped).arrayBuffer()), encoding: "gzip" };
+}
+async function jsonPost(fetchFn, url, value, getAccessToken, compress) {
+  const headers = await authHeaders(getAccessToken);
+  const { body, encoding } = await encodeJsonBody(value, compress);
+  if (encoding) headers["Content-Encoding"] = encoding;
+  return fetchFn(url, { method: "POST", headers, body });
+}
+function createHttpTransport(options) {
+  const { serverUrl, getAccessToken } = options;
+  const fetchFn = options.fetch ?? fetch.bind(globalThis);
+  const compress = options.compressRequests === true;
+  let behavior;
+  const openPushChannel = (params, subscriber) => {
+    if (typeof EventSource === "undefined") return () => {
+    };
+    const eventsUrl = deriveEventsUrl(serverUrl);
+    const resumeKey = params["clientId"] !== void 0 ? `${eventsUrl}|${params["clientId"]}` : void 0;
+    const withResume = (search) => {
+      const seen = resumeKey !== void 0 ? lastFrameByClient.get(resumeKey) : void 0;
+      if (seen !== void 0) search.set("since", `${seen.boot}-${seen.n}`);
+      return `${eventsUrl}?${search.toString()}`;
+    };
+    const key = `${eventsUrl}?${new URLSearchParams(params).toString()}`;
+    const resolveUrl = async () => {
+      const reply = await fetchFn(`${eventsUrl}/ticket`, { method: "POST", headers: await authHeaders(getAccessToken) });
+      if (!reply.ok) throw new Error(`the server refused a stream ticket: ${reply.status}`);
+      const body = await reply.json();
+      if (typeof body.ticket !== "string" || body.ticket.length === 0) throw new Error("the server sent no stream ticket");
+      return withResume(new URLSearchParams({ ...params, ticket: body.ticket }));
+    };
+    return acquirePushChannel(key, resolveUrl, resumeKey, subscriber);
+  };
+  return {
+    async register(schema) {
+      behavior = schema.name;
+      try {
+        const res = await jsonPost(fetchFn, `${serverUrl}/register`, { schema }, getAccessToken, compress);
+        const parsed = OrbitalRegisterResponseSchema.safeParse(await res.json());
+        if (!parsed.success) {
+          log.error("register:malformed-response", { issues: JSON.stringify(parsed.error.issues) });
+          return { success: false, carriesCircuitState: deriveCarriesCircuitState(void 0) };
+        }
+        return {
+          success: parsed.data.success,
+          carriesCircuitState: deriveCarriesCircuitState(parsed.data.topology)
+        };
+      } catch (err) {
+        if (err instanceof TypeError) {
+          log.warn("register:failed", { error: err.message });
+        } else {
+          log.error("register:failed", { error: err instanceof Error ? err : String(err) });
+        }
+        return { success: false, carriesCircuitState: true };
+      }
+    },
+    async unregister() {
+      try {
+        await fetchFn(`${serverUrl}/unregister`, { method: "DELETE", headers: await authHeaders(getAccessToken) });
+      } catch (error) {
+        log.warn("unregister-failed", { error: error instanceof Error ? error.message : String(error) });
+      }
+    },
+    async send(orbitalName, request) {
+      const res = await jsonPost(
+        fetchFn,
+        `${serverUrl}/${orbitalName}/events`,
+        request.behavior === void 0 && behavior !== void 0 ? { ...request, behavior } : request,
+        getAccessToken,
+        compress
+      );
+      return await res.json();
+    },
+    async resolveRows(reference) {
+      const res = await jsonPost(fetchFn, `${serverUrl}/resolve-rows`, { ref: reference }, getAccessToken, compress);
+      if (!res.ok) throw new Error(`resolve-rows: the server answered ${res.status}`);
+      return RowQueryPageSchema.parse(await res.json());
+    },
+    subscribe(onPush, params = {}) {
+      return openPushChannel(params, (envelope) => {
+        if (isBusPushEnvelope(envelope)) onPush({ event: envelope.event, payload: envelope.payload, source: envelope.source }, envelope.target ?? "peers");
+      });
+    },
+    subscribeHostDispatches(onDispatch, params = {}) {
+      return openPushChannel(params, (envelope) => {
+        if (isDispatchPushEnvelope(envelope)) onDispatch(envelope.orbitalName, envelope.request, envelope.response);
+      });
+    }
+  };
+}
+function createInProcessTransport(evaluate, options = {}) {
+  return {
+    async register(schema) {
+      await options.onRegister?.(schema);
+      return { success: true, carriesCircuitState: options.carriesCircuitState ?? false };
+    },
+    async unregister() {
+      await options.onUnregister?.();
+    },
+    async send(orbitalName, request) {
+      return evaluate(orbitalName, request);
+    },
+    ...options.resolveRows !== void 0 ? { resolveRows: options.resolveRows } : {}
+    // No `subscribe` — an in-process transport has no server to push from.
+  };
+}
+
+export { COMPRESSED_BODY_MIN_BYTES, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody };

package/dist/chunk-QQRDUMB2.js

@@ -0,0 +1,40 @@
+// src/client/local-fold.ts
+function mirrorResponse(store, frameKeyOf, response) {
+  for (const [trait, state] of Object.entries(response.states)) {
+    if (store.states.getState(trait)?.currentState !== state) store.states.seedState(trait, state);
+  }
+  for (const [trait, row] of Object.entries(response.entityByTrait ?? {})) {
+    const frameKey = frameKeyOf(trait);
+    if (frameKey === void 0) continue;
+    store.frames.set(frameKey, { ...store.frames.get(frameKey) ?? {}, ...row });
+  }
+  for (const effect of response.clientEffectsByTrait ?? []) {
+    if (effect.callsitePayload !== void 0) store.callsitePayloads.set(effect.traitName, effect.callsitePayload);
+  }
+}
+function traceResponse(observer, response) {
+  if (observer === void 0) return;
+  for (const hop of response.transitions ?? []) {
+    observer.onTransition({
+      traitName: hop.trait,
+      from: hop.from,
+      to: hop.to,
+      event: hop.event,
+      ...hop.firedArm !== void 0 ? { firedArm: hop.firedArm } : {},
+      ...hop.guardResult !== void 0 ? { guardResult: hop.guardResult } : {},
+      effects: hop.effects,
+      ...hop.observed !== void 0 ? { observed: hop.observed } : {}
+    });
+  }
+}
+function createLocalFold(opts) {
+  return {
+    foldLocalResponse: async (response, traceHops, notify) => {
+      if (traceHops) traceResponse(opts.observer, response);
+      mirrorResponse(opts.store, opts.frameKeyOf, response);
+      if (notify) opts.store.notify();
+    }
+  };
+}
+
+export { createLocalFold, mirrorResponse, traceResponse };