@almadar/shell-runtime 0.0.0-stage → 1.0.0

package/dist/chunk-NTFQ36UN.js

@@ -0,0 +1,52 @@
+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 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: {}, firedCount: 0, folded: 0, browserLegs: 0, droppedServerEffects: 0, outcomes: [], errors: [] };
+var settle = (posted, failure, trait) => posted.then(
+  (effects) => effects,
+  (err) => {
+    log.warn(failure, { trait, error: String(err) });
+    return void 0;
+  }
+);
+async function applyFrame(json, kernel, post) {
+  const frame = decodeFrame(json);
+  if (frame === void 0) return NOTHING;
+  for (const message of frame.errors) log.warn("frame-tick-failed", { error: message });
+  const last = frame.dispatches.length - 1;
+  await kernel.foldLocalResponse(frame.response, false, last < 0);
+  for (const [i, dispatch] of frame.dispatches.entries()) await kernel.foldLocalResponse(dispatch.response, true, i === last);
+  const outcomes = [{ response: frame.response, mode: "hybridClientOnly" }];
+  if (post !== void 0) {
+    for (const leg of frame.browserLegs) {
+      const tickSettled = settle(post.sendBrowserLeg(leg, frame.response), "tick-browser-leg-failed", leg.leg.targetTrait ?? "");
+      outcomes.push({ response: { success: true, transitioned: false, states: {}, emittedEvents: [] }, mode: "hybridClientOnly", tickSettled });
+    }
+  }
+  for (const dispatch of frame.dispatches) {
+    if (post === void 0 || dispatch.serverLegs.length === 0 && dispatch.statefulLeg === null) {
+      outcomes.push({ response: dispatch.response, mode: dispatch.mode });
+      continue;
+    }
+    outcomes.push({ response: dispatch.response, mode: dispatch.mode, tickSettled: settle(post.postDispatch(dispatch), "tick-post-failed", dispatch.trait) });
+  }
+  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,
+    outcomes,
+    errors: frame.errors
+  };
+}
+
+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-O57GKTYU.js

@@ -0,0 +1,30 @@
+// src/runtime/evaluation/routed-persistence.ts
+function pushedDown(method, name, entityType) {
+  if (method === void 0) throw new Error(`${name} is not supported by the store that holds ${entityType}`);
+  return method;
+}
+function routeByEntity(storedEntities, stored, other) {
+  const of = (entityType) => storedEntities.has(entityType) ? stored : other;
+  return {
+    create: (entityType, data) => of(entityType).create(entityType, data),
+    update: (entityType, id, data) => of(entityType).update(entityType, id, data),
+    delete: (entityType, id) => of(entityType).delete(entityType, id),
+    getById: (entityType, id) => of(entityType).getById(entityType, id),
+    list: (entityType) => of(entityType).list(entityType),
+    bindCollection: (entityType, collection) => of(entityType).bindCollection?.(entityType, collection),
+    queryPage: (entityType, query) => pushedDown(of(entityType).queryPage, "queryPage", entityType).call(of(entityType), entityType, query),
+    queryIds: (entityType, query) => pushedDown(of(entityType).queryIds, "queryIds", entityType).call(of(entityType), entityType, query),
+    queryCapabilities: (entityType) => pushedDown(of(entityType).queryCapabilities, "queryCapabilities", entityType).call(of(entityType), entityType),
+    writeCapabilities: (entityType) => pushedDown(of(entityType).writeCapabilities, "writeCapabilities", entityType).call(of(entityType), entityType),
+    writeWhere: (op) => pushedDown(of(op.entityType).writeWhere, "writeWhere", op.entityType).call(of(op.entityType), op),
+    writeBatch: async (batch) => {
+      const homes = new Set(batch.ops.map((op) => of(op.entityType)));
+      if (homes.size > 1) throw new Error("A batch spans the browser store and the in-memory rows; a batch runs in one store");
+      const [home] = homes;
+      if (home === void 0) return [];
+      return pushedDown(home.writeBatch, "writeBatch", batch.ops[0]?.entityType ?? "").call(home, batch);
+    }
+  };
+}
+
+export { routeByEntity };

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-P53CKOME.js

@@ -0,0 +1 @@
+

package/dist/chunk-QCJWPXLH.js

@@ -0,0 +1,40 @@
+// src/client/local-fold.ts
+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);
+  }
+}
+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;
+  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);
+      paintResponse(opts.store, opts.framesSince, response);
+      if (notify) opts.store.notify();
+    }
+  };
+}
+
+export { createLocalFold, paintFrames, paintResponse, paintStates, traceResponse };

package/dist/chunk-SKLMWHQD.js

@@ -0,0 +1,109 @@
+// src/client/channel-transport.ts
+var CLOSED = "The host closed the channel before answering";
+function createChannelTransport(channel, options = {}) {
+  let next = 1;
+  const pending = /* @__PURE__ */ new Map();
+  channel.onMessage((message) => {
+    if (message.almadarChannel !== "registered" && message.almadarChannel !== "reply") return;
+    const settle = pending.get(message.id);
+    if (!settle) return;
+    pending.delete(message.id);
+    settle(message);
+  });
+  let closed = false;
+  const closedReply = (id) => ({
+    almadarChannel: "reply",
+    id,
+    response: { success: false, transitioned: false, states: {}, emittedEvents: [], error: CLOSED }
+  });
+  channel.onClose?.(() => {
+    closed = true;
+    for (const [id, settle] of pending) settle(closedReply(id));
+    pending.clear();
+  });
+  const request = (build) => new Promise((resolve) => {
+    const id = next++;
+    if (closed) {
+      resolve(closedReply(id));
+      return;
+    }
+    pending.set(id, resolve);
+    channel.post(build(id));
+  });
+  return {
+    hostsBrowserStore: options.hostsBrowserStore === true,
+    async register(schema) {
+      const reply = await request((id) => ({ almadarChannel: "register", id, schemaName: schema.name }));
+      const held = reply.almadarChannel === "registered" && reply.held;
+      return { success: held, carriesCircuitState: false };
+    },
+    async unregister() {
+      pending.clear();
+    },
+    async send(orbitalName, req) {
+      const reply = await request((id) => ({ almadarChannel: "send", id, orbitalName, request: req }));
+      if (reply.almadarChannel !== "reply") {
+        return { success: false, transitioned: false, states: {}, emittedEvents: [], error: "The host answered out of protocol" };
+      }
+      return reply.response;
+    },
+    subscribe(onPush) {
+      return channel.onMessage((message) => {
+        if (message.almadarChannel === "push") onPush(message.emitted, message.target);
+      });
+    },
+    subscribeHostDispatches(onDispatch) {
+      return channel.onMessage((message) => {
+        if (message.almadarChannel === "dispatched") onDispatch(message.orbitalName, message.request, message.response);
+      });
+    }
+  };
+}
+function serveChannel(channel, transport, options) {
+  const stop = channel.onMessage((message) => {
+    if (message.almadarChannel === "register") {
+      channel.post({ almadarChannel: "registered", id: message.id, held: message.schemaName === options.schemaName });
+      return;
+    }
+    if (message.almadarChannel !== "send") return;
+    transport.send(message.orbitalName, message.request).then(
+      (response) => channel.post({ almadarChannel: "reply", id: message.id, response }),
+      (err) => channel.post({
+        almadarChannel: "reply",
+        id: message.id,
+        response: { success: false, transitioned: false, states: {}, emittedEvents: [], error: err.message }
+      })
+    );
+  });
+  return {
+    push: (emitted, target) => channel.post({ almadarChannel: "push", emitted, target }),
+    pushDispatch: (orbitalName, request, response) => channel.post({ almadarChannel: "dispatched", orbitalName, request, response }),
+    stop
+  };
+}
+function holdUntilServed(channel) {
+  let held = [];
+  const listeners = [];
+  channel.onMessage((message) => {
+    if (held !== void 0) held.push(message);
+    else listeners.forEach((l) => l(message));
+  });
+  return {
+    post: (message) => channel.post(message),
+    onMessage(listener) {
+      listeners.push(listener);
+      if (held !== void 0) {
+        const early = held;
+        held = void 0;
+        early.forEach((m) => listeners.forEach((l) => l(m)));
+      }
+      return () => {
+        const i = listeners.indexOf(listener);
+        if (i >= 0) listeners.splice(i, 1);
+      };
+    },
+    ...channel.onClose !== void 0 ? { onClose: channel.onClose.bind(channel) } : {}
+  };
+}
+
+export { createChannelTransport, holdUntilServed, serveChannel };

package/dist/chunk-SOQDEPME.js

@@ -0,0 +1,131 @@
+import { createLogger } from '@almadar/logger';
+
+// src/events/EventBus.ts
+var log = createLogger("almadar:runtime:eventbus");
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  /** Maximum recursion depth before circuit breaker activates (RCG-05) */
+  maxDepth;
+  /** Current emission depth for circular loop detection */
+  depth = 0;
+  constructor(options = {}) {
+    void options.debug;
+    this.maxDepth = options.maxDepth ?? 10;
+  }
+  /**
+   * Emit an event to all registered listeners.
+   *
+   * Includes circuit breaker (RCG-05): if emit is called recursively
+   * beyond `maxDepth`, the event is dropped and an error is logged.
+   * This prevents infinite loops from circular emit/listen chains.
+   */
+  emit(type, payload, source, routingKey) {
+    if (this.depth >= this.maxDepth) {
+      log.error("circular event loop dropped", { type, depth: this.depth, maxDepth: this.maxDepth });
+      return;
+    }
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now(),
+      source
+    };
+    const deliveryKey = routingKey ?? type;
+    const primary = this.listeners.get(deliveryKey);
+    const secondary = routingKey !== void 0 && routingKey !== type ? this.listeners.get(type) : void 0;
+    const listenerCount = (primary?.size ?? 0) + (secondary?.size ?? 0);
+    if (listenerCount > 0) {
+      log.debug("emit", { type, listenerCount, depth: this.depth });
+    } else {
+      log.debug("emit no listeners", { type });
+    }
+    this.depth++;
+    try {
+      const delivered = /* @__PURE__ */ new Set();
+      const deliverTo = (set) => {
+        if (!set) return;
+        for (const listener of Array.from(set)) {
+          if (delivered.has(listener)) continue;
+          delivered.add(listener);
+          try {
+            listener(event);
+          } catch (error) {
+            log.error("listener threw", { type, error: error instanceof Error ? error : String(error) });
+          }
+        }
+      };
+      deliverTo(primary);
+      deliverTo(secondary);
+      if (type !== "*") {
+        const wildcardListeners = this.listeners.get("*");
+        if (wildcardListeners) {
+          for (const listener of Array.from(wildcardListeners)) {
+            try {
+              listener(event);
+            } catch (error) {
+              log.error("wildcard listener threw", { error: error instanceof Error ? error : String(error) });
+            }
+          }
+        }
+      }
+    } finally {
+      this.depth--;
+    }
+  }
+  /**
+   * Subscribe to an event type
+   */
+  on(type, listener) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.listeners.get(type);
+    listeners.add(listener);
+    log.debug("subscribe", { type, total: listeners.size });
+    return () => {
+      listeners.delete(listener);
+      log.debug("unsubscribe", { type, remaining: listeners.size });
+      if (listeners.size === 0) {
+        this.listeners.delete(type);
+      }
+    };
+  }
+  /**
+   * Subscribe to ALL events (wildcard listener)
+   * Useful for event tracking, logging, debugging
+   */
+  onAny(listener) {
+    return this.on("*", listener);
+  }
+  /**
+   * Check if there are listeners for an event type
+   */
+  hasListeners(type) {
+    const listeners = this.listeners.get(type);
+    return listeners !== void 0 && listeners.size > 0;
+  }
+  /**
+   * Get all registered event types
+   */
+  getRegisteredEvents() {
+    return Array.from(this.listeners.keys());
+  }
+  /**
+   * Clear all listeners
+   */
+  clear() {
+    log.debug("clear", { eventTypeCount: this.listeners.size });
+    this.listeners.clear();
+  }
+  /**
+   * Get listener count for an event type (for testing)
+   */
+  getListenerCount(type) {
+    return this.listeners.get(type)?.size ?? 0;
+  }
+};
+function createEventBus(options) {
+  return new EventBus(options);
+}
+
+export { EventBus, createEventBus };

package/dist/chunk-UBN5JJKZ.js

@@ -0,0 +1,26 @@
+// src/service/service-provider.ts
+var ServiceCallError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ServiceCallError";
+  }
+  code;
+};
+var providers = /* @__PURE__ */ new Map();
+function registerServiceProvider(service, provider) {
+  providers.set(service, provider);
+}
+function unregisterServiceProvider(service) {
+  providers.delete(service);
+}
+function registeredServices() {
+  return [...providers.keys()];
+}
+async function callRegisteredService(service, action, params, context) {
+  const provider = providers.get(service);
+  if (provider === void 0) throw new Error(`Unknown integration: ${service}`);
+  return provider(action, params ?? {}, context);
+}
+
+export { ServiceCallError, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider };

package/dist/chunk-UD2CXYSJ.js

@@ -0,0 +1,244 @@
+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 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);
+  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 mintUrl = params["clientId"] !== void 0 ? `${eventsUrl}/ticket?${new URLSearchParams({ clientId: params["clientId"] }).toString()}` : `${eventsUrl}/ticket`;
+    const resolveUrl = async () => {
+      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");
+      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
+      );
+      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);
+      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, SessionEndedError, TransportStatusError, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody };