@almadar/shell-runtime 0.1.0 → 1.1.0

package/dist/{chunk-DYOJGLIX.js → chunk-LKWYCYX5.js}

@@ -1,8 +1,6 @@
-import { findExternalInput } from '@almadar/core';
-
 // src/client/declared-input-dispatch.ts
-async function dispatchDeclaredInput(schema, orbitalName, request, send) {
-  const declared = schema ? findExternalInput(schema, orbitalName, request.targetTrait, request.event) : void 0;
+async function dispatchDeclaredInput(contract, orbitalName, request, send) {
+  const declared = contract.findExternalInput(orbitalName, request.targetTrait, request.event);
   if (!declared) {
     return {
       success: false,
@@ -17,7 +15,6 @@ async function dispatchDeclaredInput(schema, orbitalName, request, send) {
     event: request.event,
     payload: request.payload ?? {},
     targetTrait: request.targetTrait,
-    ...request.user !== void 0 ? { user: request.user } : {},
     ...request.entityId !== void 0 ? { entityId: request.entityId } : {}
   });
 }

package/dist/chunk-LYFIQPXX.js

@@ -0,0 +1 @@
+

package/dist/{chunk-ODJCZ27I.js → chunk-N7HYNKK6.js}

@@ -1,4 +1,4 @@
-import { StateBook } from './chunk-Q2H75UYT.js';
+import { StateBook } from './chunk-A2JJT4GA.js';
 import { AwaitingRegistry } from './chunk-HC6ERSAH.js';
 
 // src/client/circuit-store.ts
@@ -7,10 +7,43 @@ function createMemoryCircuitStore(traits = [], observer) {
   const frames = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set();
   let version = 0;
+  let frameVersion = 0;
+  let frameSession;
   return {
     states,
     frames,
-    callsitePayloads: /* @__PURE__ */ new Map(),
+    get frameVersion() {
+      return frameVersion;
+    },
+    applyFrames(delta) {
+      if (delta.session !== void 0) {
+        const snapshot = delta.from === 0 && delta.ops[0]?.[0] === "clear";
+        if (!snapshot) {
+          const current = (frameSession === void 0 || delta.session === frameSession) && delta.from === frameVersion;
+          if (delta.session === frameSession && delta.to <= frameVersion && !current) return "stale";
+          if (!current) return "gap";
+        }
+        frameSession = delta.session;
+        frameVersion = delta.to;
+      }
+      for (const op of delta.ops) {
+        switch (op[0]) {
+          case "clear":
+            frames.clear();
+            break;
+          case "del":
+            frames.delete(op[1]);
+            break;
+          case "put":
+            frames.set(op[1], { ...op[2] });
+            break;
+          case "set":
+            for (const [frame, fields] of Object.entries(op[1])) frames.set(frame, { ...frames.get(frame) ?? {}, ...fields });
+            break;
+        }
+      }
+      return "applied";
+    },
     awaiting: new AwaitingRegistry(),
     snapshot(trait, entityId, frameKey) {
       const key = frameKey ?? trait;

package/dist/{chunk-4J2QEIUV.js → chunk-NTFQ36UN.js}

@@ -1,42 +1,15 @@
-import { isEventResponse } from '@almadar/core/kernel-wire';
+import { isFrameWire } from '@almadar/core/kernel-wire';
 import { createLogger } from '@almadar/logger';
 
 // src/kernel/frame-applier.ts
 var log = createLogger("almadar:shell-web:frame");
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isList(value, item) {
-  return Array.isArray(value) && value.every(item);
-}
-function isSeed(value) {
-  return isRecord(value) && typeof value["trait"] === "string" && typeof value["event"] === "string";
-}
-function isRoutedLeg(value) {
-  if (!isRecord(value) || typeof value["orbital"] !== "string") return false;
-  const leg = value["leg"];
-  return isRecord(leg) && typeof leg["event"] === "string";
-}
-function isFiredTick(value) {
-  return isRecord(value) && typeof value["trait"] === "string" && typeof value["tick"] === "string";
-}
-function isFrameDispatch(value) {
-  if (!isRecord(value)) return false;
-  const response = value["response"];
-  return typeof value["trait"] === "string" && typeof value["orbital"] === "string" && isSeed(value["seed"]) && response !== void 0 && isEventResponse(response) && isList(value["serverLegs"], isRoutedLeg) && typeof value["mode"] === "string" && Array.isArray(value["awaiting"]) && Array.isArray(value["foldSeeded"]);
-}
-function isFrameWire(value) {
-  if (!isRecord(value)) return false;
-  const response = value["response"];
-  return isList(value["fired"], isFiredTick) && response !== void 0 && isEventResponse(response) && isList(value["dispatches"], isFrameDispatch) && isList(value["browserLegs"], isRoutedLeg) && typeof value["droppedServerEffects"] === "number" && isList(value["errors"], (entry) => typeof entry === "string");
-}
 function decodeFrame(json) {
   if (json === void 0) return void 0;
   const value = JSON.parse(json);
   if (!isFrameWire(value)) throw new Error("kernel wire: frame is not a FrameWire");
   return value;
 }
-var NOTHING = { fired: [], folded: 0, browserLegs: 0, droppedServerEffects: 0, outcomes: [], errors: [] };
+var NOTHING = { fired: {}, firedCount: 0, folded: 0, browserLegs: 0, droppedServerEffects: 0, outcomes: [], errors: [] };
 var settle = (posted, failure, trait) => posted.then(
   (effects) => effects,
   (err) => {
@@ -67,6 +40,7 @@ async function applyFrame(json, kernel, post) {
   }
   return {
     fired: frame.fired,
+    firedCount: Object.values(frame.fired).reduce((n, ticks) => n + ticks.length, 0),
     folded: frame.dispatches.length + 1,
     browserLegs: frame.browserLegs.length,
     droppedServerEffects: frame.droppedServerEffects,
@@ -75,4 +49,4 @@ async function applyFrame(json, kernel, post) {
   };
 }
 
-export { applyFrame, decodeFrame, isFrameWire };
+export { applyFrame, decodeFrame };

package/dist/chunk-NU6LVKGS.js

@@ -0,0 +1,15 @@
+// src/kernel/lane.ts
+var LaneHeldByParkedDispatch = class extends Error {
+  ticket;
+  event;
+  constructor(ticket, event) {
+    super(
+      `dispatch #${ticket} (${event}) is parked holding the dispatch lane on this thread; resume or drop it before starting another dispatch`
+    );
+    this.name = "LaneHeldByParkedDispatch";
+    this.ticket = ticket;
+    this.event = event;
+  }
+};
+
+export { LaneHeldByParkedDispatch };

package/dist/{chunk-VNMG7NKY.js → chunk-OQVSN7DP.js}

@@ -1,19 +1,17 @@
 import { defaultCallService } from './chunk-4SEK5ER2.js';
 import { routeByEntity } from './chunk-O57GKTYU.js';
-import { buildTraitIndex } from './chunk-CPSQXEJ6.js';
-import { KernelEngine, evaluateOnKernel } from './chunk-D4XJTBLB.js';
+import { KernelEngine, evaluateOnKernel } from './chunk-VKQA2DJX.js';
 import { InFlightCalls } from './chunk-MZKIL5IN.js';
-import { createInProcessTransport } from './chunk-QELZ6TEJ.js';
-import { orbitalInlineEntities, storesRowsInBrowser, inlineTraitRefs, applyRowAccess, readableEntitiesOf, externalInputsOf, entityOwnerOrbital } from '@almadar/core';
-import { entityAccessPolicies } from '@almadar/core/mock';
+import { createInProcessTransport } from './chunk-UD2CXYSJ.js';
+import { orbitalInlineEntities, storesRowsInBrowser, inlineTraitRefs } from '@almadar/core';
 
+var LOCAL_CLIENT = "local";
 function localStorePersistence(schema, store, memory) {
   const browserStored = new Set(schema.orbitals.flatMap(orbitalInlineEntities).filter(storesRowsInBrowser).map((entity) => entity.name));
   return routeByEntity(browserStored, store, memory);
 }
 function openLocalKernel(options) {
   const { schema, persistence } = options;
-  options.kernel.installLanguage(options.language);
   const callService = options.callService ?? defaultCallService;
   const engine = KernelEngine.open(options.kernel, { ...schema, orbitals: inlineTraitRefs(schema.orbitals) }, {
     persistence,
@@ -23,47 +21,44 @@ function openLocalKernel(options) {
     servicePorts: options.servicePorts ?? ((caller, user, message) => ({
       caller,
       message,
-      inputs: () => externalInputsOf(schema),
-      readableEntities: () => readableEntitiesOf(schema),
+      inputs: () => engine.externalInputs(),
+      readableEntities: () => engine.readableEntities(),
       dispatchInput: () => Promise.reject(new Error("a local store host takes no input dispatch")),
-      read: async (entity) => applyRowAccess(await persistence.list(entity), entityAccessPolicies(schema, entity)?.read, void 0, { user }, entity)
+      read: async (entity) => engine.readRows(entity, await persistence.list(entity), user)
     })),
     deliverLive: () => void 0,
     deferCallOutcome: options.deferCallOutcome ?? (() => void 0),
     ...options.pageFacts !== void 0 ? { pageFacts: options.pageFacts } : {},
-    ...options.http !== void 0 ? { http: options.http } : {},
+    ...options.hostActions !== void 0 ? { hostActions: options.hostActions } : {},
+    ...options.secretPorts !== void 0 ? { secretPorts: options.secretPorts } : {},
     ...options.onDevice !== void 0 ? { onDevice: options.onDevice } : {},
-    ...options.tabs !== void 0 ? { tabs: options.tabs } : {}
+    ...options.tabs !== void 0 ? { tabs: options.tabs } : {},
+    ...options.os !== void 0 ? { os: options.os } : {},
+    ...options.gpu !== void 0 ? { gpu: options.gpu } : {}
   });
-  if (options.messages !== void 0) engine.setMessages(Object.keys(options.messages), options.messages);
-  engine.setTickMount([...buildTraitIndex(schema.orbitals).byName.keys()]);
+  for (const trait of engine.programSurface().traits) engine.mountClient(LOCAL_CLIENT, trait.orbital, [trait.name]);
   return engine;
 }
 function createLocalStoreTransport(options) {
   return createInProcessTransport(
     async (orbital, request) => evaluateOnKernel(
-      {
-        engine: await options.kernelEngine,
-        orbital,
-        ...options.outsideEventQueue !== void 0 ? { outsideEventQueue: options.outsideEventQueue } : {}
-      },
+      { engine: await options.kernelEngine, orbital },
       request,
-      await options.user,
-      request.locale
+      request.locale ?? options.locale?.()
     ),
     {
       carriesCircuitState: false,
-      ...options.schema !== void 0 ? { resolveRows: resolveOn(options, options.schema) } : {}
+      ...options.schema !== void 0 ? { resolveRows: resolveOn(options) } : {}
     }
   );
 }
-function resolveOn(options, schema) {
-  return async (reference) => resolveLocalRows(await options.kernelEngine, schema, await options.user, reference);
+function resolveOn(options) {
+  return async (reference) => resolveLocalRows(await options.kernelEngine, reference);
 }
-function resolveLocalRows(engine, schema, user, reference) {
-  const owner = entityOwnerOrbital(schema, reference.entityType);
+function resolveLocalRows(engine, reference) {
+  const owner = engine.entityOwnerOrbital(reference.entityType);
   if (owner === void 0) return Promise.reject(new Error(`${reference.entityType}: no orbital of the local program declares this entity`));
-  return engine.resolveRows(reference, { orbital: owner.name, ...user !== void 0 ? { user } : {} });
+  return engine.resolveRows(reference, { orbital: owner });
 }
 
 export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows };

package/dist/chunk-P2N6K2IV.js

@@ -0,0 +1,20 @@
+// src/client/inbound-dispatch.ts
+async function dispatchInbound(contract, name, delivery, send, credential) {
+  const found = contract.findInbound(name);
+  if (!("route" in found)) return found.answer;
+  const { route } = found;
+  try {
+    const held = route.verifies !== void 0 ? await credential(route.verifies.credential) : void 0;
+    if (route.verifies !== void 0 && (held === void 0 || held === null || held === "")) return contract.credentialUnset(route.verifies.credential);
+    const response = await send(route.orbital, {
+      event: route.event,
+      payload: contract.inboundPayload(route, delivery, held),
+      targetTrait: route.trait
+    });
+    return contract.inboundAnswer(route, response.emittedEvents, response.error);
+  } catch (error) {
+    return contract.dispatchFailed(error instanceof Error ? error.message : String(error));
+  }
+}
+
+export { dispatchInbound };

package/dist/{chunk-QQRDUMB2.js → chunk-QCJWPXLH.js}

@@ -1,16 +1,16 @@
 // src/client/local-fold.ts
-function mirrorResponse(store, frameKeyOf, response) {
+function paintStates(store, 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 paintFrames(store, delta, framesSince) {
+  if (delta === void 0) return;
+  if (store.applyFrames(delta) === "gap") store.applyFrames(framesSince(store.frameVersion));
+}
+function paintResponse(store, framesSince, response) {
+  paintStates(store, response);
+  paintFrames(store, response.frames, framesSince);
 }
 function traceResponse(observer, response) {
   if (observer === void 0) return;
@@ -31,10 +31,10 @@ function createLocalFold(opts) {
   return {
     foldLocalResponse: async (response, traceHops, notify) => {
       if (traceHops) traceResponse(opts.observer, response);
-      mirrorResponse(opts.store, opts.frameKeyOf, response);
+      paintResponse(opts.store, opts.framesSince, response);
       if (notify) opts.store.notify();
     }
   };
 }
 
-export { createLocalFold, mirrorResponse, traceResponse };
+export { createLocalFold, paintFrames, paintResponse, paintStates, traceResponse };

package/dist/{chunk-QELZ6TEJ.js → chunk-UD2CXYSJ.js}

@@ -88,6 +88,34 @@ function acquirePushChannel(key, resolveUrl, resumeKey, subscriber) {
     }
   };
 }
+var SessionEndedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SessionEndedError";
+  }
+};
+var TransportStatusError = class extends Error {
+  constructor(status, bodyText) {
+    super(`the server answered ${status}${bodyText.length > 0 ? `: ${bodyText}` : " with no body"}`);
+    this.status = status;
+    this.bodyText = bodyText;
+    this.refusal = parseRefusal(bodyText);
+    this.name = "TransportStatusError";
+  }
+  status;
+  bodyText;
+  /** The `{ error, code }` body when the answer carried one. */
+  refusal;
+};
+function parseRefusal(text) {
+  if (text.length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 var COMPRESSED_BODY_MIN_BYTES = 32 * 1024;
 async function encodeJsonBody(value, compress) {
   const text = JSON.stringify(value);
@@ -122,8 +150,9 @@ function createHttpTransport(options) {
       return `${eventsUrl}?${search.toString()}`;
     };
     const key = `${eventsUrl}?${new URLSearchParams(params).toString()}`;
+    const mintUrl = params["clientId"] !== void 0 ? `${eventsUrl}/ticket?${new URLSearchParams({ clientId: params["clientId"] }).toString()}` : `${eventsUrl}/ticket`;
     const resolveUrl = async () => {
-      const reply = await fetchFn(`${eventsUrl}/ticket`, { method: "POST", headers: await authHeaders(getAccessToken) });
+      const reply = await fetchFn(mintUrl, { 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");
@@ -169,7 +198,14 @@ function createHttpTransport(options) {
         getAccessToken,
         compress
       );
-      return await res.json();
+      const text = await res.text();
+      if (res.status === 409) {
+        const refusal = parseRefusal(text);
+        if (refusal?.code === "SESSION_ENDED") throw new SessionEndedError(refusal.error ?? "the session ended");
+      }
+      if (!res.ok && res.status !== 403) throw new TransportStatusError(res.status, text);
+      const body = JSON.parse(text);
+      return body;
     },
     async resolveRows(reference) {
       const res = await jsonPost(fetchFn, `${serverUrl}/resolve-rows`, { ref: reference }, getAccessToken, compress);
@@ -205,4 +241,4 @@ function createInProcessTransport(evaluate, options = {}) {
   };
 }
 
-export { COMPRESSED_BODY_MIN_BYTES, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody };
+export { COMPRESSED_BODY_MIN_BYTES, SessionEndedError, TransportStatusError, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody };

package/dist/{chunk-UJHOUZAL.js → chunk-V4EMDPCO.js}

@@ -1,9 +1,6 @@
-import { storesRowsInBrowser } from '@almadar/core';
-
 // src/runtime/evaluation/residence-transport.ts
 function createResidenceTransport(options) {
-  const { local, remote, traitIndex } = options;
-  const browserStored = new Set(traitIndex.allEntities.filter(storesRowsInBrowser).map((e) => e.name));
+  const { local, remote, browserEntities } = options;
   const route = (orbitalName, request) => {
     if (request.residence === "browser") return local;
     if (request.residence === "server") {
@@ -25,7 +22,7 @@ function createResidenceTransport(options) {
       return route(orbitalName, request).send(orbitalName, request);
     },
     async resolveRows(reference) {
-      const owner = browserStored.has(reference.entityType) ? local : remote;
+      const owner = browserEntities.has(reference.entityType) ? local : remote;
       if (owner?.resolveRows === void 0) throw new Error(`residence: no transport resolves ${reference.entityType} row sets`);
       return owner.resolveRows(reference);
     },