@almadar/shell-runtime 0.0.0-stage → 1.0.0

package/dist/chunk-UP6GGGAN.js

@@ -0,0 +1,34 @@
+import { isPageReference, isRoutePage, themeDataKey } from '@almadar/core';
+
+// src/client/render-sigils.ts
+var DEFAULT_THEME_KEY = "minimalist-light";
+function inlineNavItems(pages) {
+  const items = [];
+  for (const page of pages) {
+    if (isPageReference(page)) continue;
+    const p = page;
+    if (!isRoutePage(p) || typeof p.label !== "string" || p.path.includes(":")) continue;
+    const item = { href: p.path, label: p.label };
+    if (typeof p.icon === "string") item.icon = p.icon;
+    if (p.roles !== void 0) item.roles = [...p.roles];
+    items.push(item);
+  }
+  return items;
+}
+function appNavItems(orbitals) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const orbital of orbitals) {
+    for (const item of inlineNavItems(orbital.pages ?? [])) {
+      if (seen.has(item.href)) continue;
+      seen.add(item.href);
+      items.push(item);
+    }
+  }
+  return items;
+}
+function sigilThemeKey(orbitalTheme, appThemeKey) {
+  return themeDataKey(orbitalTheme) || appThemeKey || DEFAULT_THEME_KEY;
+}
+
+export { DEFAULT_THEME_KEY, appNavItems, inlineNavItems, sigilThemeKey };

package/dist/chunk-V4EMDPCO.js

@@ -0,0 +1,33 @@
+// src/runtime/evaluation/residence-transport.ts
+function createResidenceTransport(options) {
+  const { local, remote, browserEntities } = options;
+  const route = (orbitalName, request) => {
+    if (request.residence === "browser") return local;
+    if (request.residence === "server") {
+      if (remote === void 0) throw new Error(`residence: a ${orbitalName} ${request.event} leg needs server data, and this host has no server`);
+      return remote;
+    }
+    return remote ?? local;
+  };
+  return {
+    async register(schema) {
+      const result = await local.register(schema);
+      return remote ? remote.register(schema) : result;
+    },
+    async unregister() {
+      await local.unregister();
+      await remote?.unregister();
+    },
+    async send(orbitalName, request) {
+      return route(orbitalName, request).send(orbitalName, request);
+    },
+    async resolveRows(reference) {
+      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);
+    },
+    ...remote?.subscribe ? { subscribe: remote.subscribe.bind(remote) } : {}
+  };
+}
+
+export { createResidenceTransport };

package/dist/chunk-VNGXRYFF.js

@@ -0,0 +1,9 @@
+// src/credentials/env-vars.ts
+var CREDENTIAL_MASTER_KEY_ENV = "ALMADAR_CREDENTIAL_MASTER_KEY";
+var CREDENTIAL_PREVIOUS_MASTER_KEY_ENV = "ALMADAR_CREDENTIAL_MASTER_KEY_PREVIOUS";
+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 { CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV, STORE_BOOTSTRAP_ENV_VARS, allCredentialEnvVars };

package/dist/chunk-WGCWJOT2.js

@@ -0,0 +1,21 @@
+// src/kernel/program-effects.ts
+var PROGRAM_EFFECTS = [
+  "behavior/catalog",
+  "behavior/describe",
+  "behavior/source",
+  "behavior/resolve",
+  "behavior/dependencies",
+  "program/read",
+  "program/print",
+  "program/eval",
+  "program/validate",
+  "program/prove",
+  "program/os-grants",
+  "program/compose",
+  "program/step"
+];
+function isProgramEffect(name) {
+  return PROGRAM_EFFECTS.includes(name);
+}
+
+export { PROGRAM_EFFECTS, isProgramEffect };

package/dist/chunk-X6W44WHO.js

@@ -0,0 +1,26 @@
+import { decodeServerProgressWire, decodeNextWire, decodeResolveProgressWire, decodeFiredTick } from '@almadar/core/kernel-wire';
+export { decodeIoRequestWire } from '@almadar/core/kernel-wire';
+
+// src/kernel/decode.ts
+function decodeProgress(json) {
+  return decodeServerProgressWire(JSON.parse(json));
+}
+function decodeNext(json) {
+  const value = JSON.parse(json);
+  return value === null ? null : decodeNextWire(value);
+}
+function decodeResolveProgress(json) {
+  return decodeResolveProgressWire(JSON.parse(json));
+}
+function decodeDueTicks(json) {
+  const value = JSON.parse(json);
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("tickPass: the kernel answered a non-object");
+  const byOrbital = {};
+  for (const [orbital, ticks] of Object.entries(value)) {
+    if (!Array.isArray(ticks)) throw new Error(`tickPass: the kernel answered a non-list for orbital ${orbital}`);
+    byOrbital[orbital] = ticks.map(decodeFiredTick);
+  }
+  return byOrbital;
+}
+
+export { decodeDueTicks, decodeNext, decodeProgress, decodeResolveProgress };

package/dist/chunk-XXWNMJI6.js

@@ -0,0 +1,15 @@
+// src/loader/lazy-page.ts
+async function loadLazyPage(loader, page, importerPath) {
+  const loaded = await loader.load(page.orbRef, importerPath);
+  if (!loaded.success) return loaded;
+  const { schema, sourcePath } = loaded.data;
+  if (!schema.orbitals.some((o) => o.name === page.orbital)) {
+    return {
+      success: false,
+      error: `Lazy page ${page.path} expects orbital "${page.orbital}" in ${sourcePath}, found: ${schema.orbitals.map((o) => o.name).join(", ")}`
+    };
+  }
+  return { success: true, data: schema };
+}
+
+export { loadLazyPage };

package/dist/chunk-ZUSM4VW4.js

@@ -0,0 +1,197 @@
+import { resolveCredentialRef, getEffectiveCredentialStore, getModeControl } from './chunk-HLOUDLPI.js';
+import { credentialStorageKey, resolveCredentialStatusIdentity, credentialStatusConnected } from '@almadar/core';
+
+function userCredentialKey(principal, name) {
+  return credentialStorageKey({ name, principal });
+}
+function envTailsOf(env) {
+  return (names) => {
+    const tails = [];
+    for (const name of names) {
+      const value = env[name];
+      if (value === void 0 || value === "") continue;
+      const chars = Array.from(value);
+      tails.push(chars.length >= 8 ? { name, last4: chars.slice(-4).join("") } : { name });
+    }
+    return tails;
+  };
+}
+var installedSecretsHost = {
+  async store() {
+    return getEffectiveCredentialStore();
+  },
+  async resolve(name, principal) {
+    return resolveCredentialRef(name, void 0, principal);
+  }
+};
+function createSecretStore(now = Date.now, host = installedSecretsHost, tokenPost) {
+  const environmentMinted = /* @__PURE__ */ new Map();
+  const storeMinted = /* @__PURE__ */ new WeakMap();
+  const cacheFor = (store) => {
+    if (store === null) return environmentMinted;
+    const held = storeMinted.get(store);
+    if (held !== void 0) return held;
+    const cache = /* @__PURE__ */ new Map();
+    storeMinted.set(store, cache);
+    return cache;
+  };
+  const slot = (name, principal) => credentialStorageKey({ name, ...principal !== void 0 ? { principal } : {} });
+  return {
+    async get(name, principal) {
+      const store = await host.store();
+      const minted = cacheFor(store);
+      const key = slot(name, principal);
+      const held = minted.get(key);
+      if (held !== void 0) {
+        if (held.expiresAt > now()) return held.value;
+        minted.delete(key);
+      }
+      if (store !== null && store.enabled && tokenPost !== void 0) {
+        const fresh = await store.resolveFresh(name, principal, tokenPost);
+        if (fresh !== void 0) return fresh;
+      }
+      return host.resolve(name, principal);
+    },
+    async set(name, value, ttlMs, principal) {
+      const minted = cacheFor(await host.store());
+      const key = slot(name, principal);
+      if (ttlMs <= 0) minted.delete(key);
+      else minted.set(key, { value, expiresAt: now() + ttlMs });
+    },
+    async rotate(name, value, principal) {
+      const store = await host.store();
+      if (store === null) throw new Error("this host keeps no credential store to rotate into");
+      cacheFor(store).delete(slot(name, principal));
+      await store.replace(name, value, principal);
+    },
+    async persist(name, value, principal, label) {
+      const store = await host.store();
+      if (store === null || !store.enabled) throw new Error("this host keeps no credential store to persist into");
+      cacheFor(store).delete(slot(name, principal));
+      await store.persist(name, value, principal, label);
+    },
+    async label(name, principal) {
+      return (await host.store())?.label(name, principal);
+    },
+    async durable() {
+      const store = await host.store();
+      return store !== null && store.enabled;
+    },
+    async forget(name, principal) {
+      const store = await host.store();
+      const minted = cacheFor(store);
+      const key = slot(name, principal);
+      minted.delete(key);
+      await store?.remove(name, principal);
+    }
+  };
+}
+function createCredentialConnectPort(post) {
+  return async (grant) => {
+    const store = getEffectiveCredentialStore();
+    if (store === null || !store.enabled) return { error: { kind: "unavailable", message: "this host holds no credential store that can connect" } };
+    return store.connect(grant, post);
+  };
+}
+function createCredentialAdminPort() {
+  const installed = () => {
+    const store = getEffectiveCredentialStore();
+    if (store === null) throw new Error("this host keeps no credential store");
+    return store;
+  };
+  return {
+    async list() {
+      return getEffectiveCredentialStore()?.listing() ?? null;
+    },
+    async read(name) {
+      return getEffectiveCredentialStore()?.resolve(name) ?? null;
+    },
+    async write(service, name, value) {
+      await installed().set(service, name, value);
+    },
+    async remove(name) {
+      return installed().remove(name);
+    },
+    async rotate() {
+      return installed().rotate();
+    },
+    async mode() {
+      return getModeControl()?.mode ?? null;
+    },
+    async setMode(mode) {
+      const control = getModeControl();
+      if (control === null) throw new Error("No integration manager is installed on this host");
+      if (mode !== "mock" && mode !== "real") throw new Error(`mode must be "mock" or "real", got "${mode}"`);
+      control.setMode(mode);
+      return control.mode;
+    }
+  };
+}
+var systemRandom = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
+var RANDOM_BYTES_MAX = 1024;
+function binary(bytes) {
+  let text = "";
+  for (const byte of bytes) text += String.fromCharCode(byte);
+  return text;
+}
+function base64Standard(bytes) {
+  return btoa(binary(bytes));
+}
+function base64Url(bytes) {
+  return base64Standard(bytes).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function randomBytesPayload(ports, bytes, key) {
+  if (key !== void 0 && (typeof key !== "string" || key === "")) {
+    throw new Error(`call key must evaluate to a non-empty string, got ${String(key)}`);
+  }
+  if (typeof bytes !== "number" || !Number.isInteger(bytes) || bytes < 1 || bytes > RANDOM_BYTES_MAX) {
+    throw new Error(`random-bytes: the byte count must be an integer from 1 to ${RANDOM_BYTES_MAX}, got ${String(bytes)}`);
+  }
+  const value = base64Url(ports.random(bytes));
+  return key === void 0 ? { value } : { value, key };
+}
+function signedIn(head, principal) {
+  if (principal === void 0) throw new Error(`${head}: nobody is signed in`);
+  return principal;
+}
+function credentialName(head, credential) {
+  if (typeof credential !== "string") throw new Error(`${head}: the credential must be a secret knob's name`);
+  return credential;
+}
+async function credentialStatusPayload(ports, credential, principal) {
+  const identity = resolveCredentialStatusIdentity(credential, principal);
+  const connected = credentialStatusConnected(await ports.secrets.get(identity.name, identity.principal), identity.principal);
+  const label = connected ? await ports.secrets.label?.(identity.name, identity.principal) ?? "" : "";
+  return { connected, label };
+}
+async function credentialForgetPayload(ports, credential, principal) {
+  const who = signedIn("credential-forget", principal);
+  const name = credentialName("credential-forget", credential);
+  await ports.secrets.forget(name, who);
+  return { connected: false, label: "" };
+}
+function createSecretPorts(options = {}) {
+  return {
+    random: options.random ?? systemRandom,
+    secrets: options.secrets ?? createSecretStore(Date.now, installedSecretsHost, options.tokenPost),
+    credentials: options.credentials ?? createCredentialAdminPort(),
+    env: options.env ?? ((names) => envTailsOf(process.env)(names)),
+    ...options.tokenPost !== void 0 ? { connect: createCredentialConnectPort(options.tokenPost) } : {}
+  };
+}
+var browserSecrets = {
+  async get(name) {
+    throw new Error(`credential ${name} is not available in a browser`);
+  },
+  async set(name) {
+    throw new Error(`credential ${name} cannot be stored in a browser`);
+  },
+  async forget(name) {
+    throw new Error(`credential ${name} cannot be forgotten in a browser`);
+  }
+};
+function createBrowserSecretPorts() {
+  return { random: systemRandom, secrets: browserSecrets };
+}
+
+export { RANDOM_BYTES_MAX, base64Standard, base64Url, createBrowserSecretPorts, createCredentialAdminPort, createCredentialConnectPort, createSecretPorts, createSecretStore, credentialForgetPayload, credentialStatusPayload, envTailsOf, randomBytesPayload, systemRandom, userCredentialKey };

package/dist/client/EventTransport.d.ts

@@ -0,0 +1,147 @@
+import { OrbitalSchema, EventRequest, EventResponse, RowSetRef, RowQueryPage, EmittedEvent, ServerTopology } from '@almadar/core';
+
+/**
+ * EventTransport — the client → orbital event transport port (plan P5,
+ * `docs/Almadar_Runtime_Stateless_Stateful_PLAN.md` §4.2).
+ *
+ * Promotes `@almadar/ui`'s `ServerBridgeTransport` interface +
+ * `createHttpTransport` into `@almadar/runtime` so there is ONE owner of
+ * the HTTP request/response leg instead of two (this package's own
+ * `ServerBridge` class and the ui provider). `@almadar/ui`'s provider will
+ * be switched onto this port at the W5b build checkpoint (see the plan);
+ * until then this file has no consumers outside this package.
+ *
+ * The wire shapes are `@almadar/core`'s existing `EventRequest` /
+ * `EventResponse` — no shadow types.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * `true` = stateless topology: the server holds no circuit state between
+ * requests, so every `send()` request must carry `traits`/`entityByTrait`.
+ * `false` = the server (or an in-process evaluator) holds the state itself.
+ *
+ * Derivation mirrors `@almadar/ui`'s `ServerBridgeProvider` EXACTLY
+ * (`providers/ServerBridge.tsx`, both the initial-state fallback and the
+ * post-register `.then` callback — the same mapping was duplicated at two
+ * call sites there, which is the `stateSource` string-branching this port
+ * retires): `'stateful'` → false, `'stateless'` OR an absent/undeclared
+ * topology (older servers) → true. An absent topology defaulting to
+ * "stateless" is the ui's existing assumption, carried over unchanged, not
+ * a new judgment call made here.
+ */
+declare function deriveCarriesCircuitState(topology: ServerTopology | undefined): boolean;
+interface EventTransportRegisterResult {
+    success: boolean;
+    /** See `deriveCarriesCircuitState`. Computed once here, not re-derived by callers. */
+    carriesCircuitState: boolean;
+}
+/**
+ * Who a server push was addressed to: `peers` — another client's change
+ * (live push); `origin` — this client's own running request, live (a
+ * call-service's `emit.onMessage`).
+ */
+type PushTarget = 'peers' | 'origin';
+interface EventTransport {
+    /** Register a schema with the transport's target (server, or an in-process evaluator). */
+    register(schema: OrbitalSchema): Promise<EventTransportRegisterResult>;
+    unregister(): Promise<void>;
+    /** Play one event through the orbital named `orbitalName`. */
+    send(orbitalName: string, request: EventRequest): Promise<EventResponse>;
+    /**
+     * A row-set reference resolved by the host that holds the rows, for the viewer the transport is signed in as (the
+     * host applies `@read`): the rows that still match, in the reference's order. Absent when the transport has no
+     * such route (an in-process evaluator resolves against its own store).
+     */
+    resolveRows?(reference: RowSetRef): Promise<RowQueryPage>;
+    /**
+     * Subscribe to server-pushed cascade events (e.g. another client's
+     * persist-envelope emits, Almadar_Live_Push.md). Absent when the
+     * transport has no server to push from (in-process). `params` augments
+     * the push channel's query string (e.g. a caller-supplied per-tab
+     * `clientId` for the server's origin-exclusion) — the transport itself
+     * carries no notion of "tab identity", that is a client-role concern
+     * (plan P4).
+     */
+    subscribe?(onPush: (emitted: EmittedEvent, target: PushTarget) => void, params?: Record<string, string>): () => void;
+    /**
+     * The host runs the whole program, browser-stored entities included (an extension's worker): a
+     * view of it keeps no browser store of its own and sends every leg to the host.
+     */
+    readonly hostsBrowserStore?: boolean;
+    /**
+     * Hear the results of dispatches the host ran without any view asking (a declared input, a
+     * follow-on call's outcome), so an open view shows them. The view applies the result; it never
+     * runs the dispatch again. `params` addresses this view on a push channel, as for `subscribe`.
+     */
+    subscribeHostDispatches?(onDispatch: HostDispatchListener, params?: Record<string, string>): () => void;
+}
+/** A dispatch the host ran on its own, with its result. */
+type HostDispatchListener = (orbitalName: string, request: EventRequest, response: EventResponse) => void;
+/**
+ * Supplies the bearer token the hosting server authenticates with. Resolved
+ * per request (tokens expire); `undefined` sends the request unauthenticated
+ * (dev servers with an auth bypass, standalone playground). Moved verbatim
+ * from `@almadar/ui`'s `providers/ServerBridge.tsx`.
+ */
+type AccessTokenProvider = () => Promise<string | undefined>;
+/** The host freed this client's session after its live stream dropped: mount again with the frames the client holds (EXEC-DIST-9). */
+declare class SessionEndedError extends Error {
+    constructor(message: string);
+}
+/** The host answered a dispatch with a non-2xx status: a transport or auth failure, never an event response. */
+declare class TransportStatusError extends Error {
+    readonly status: number;
+    readonly bodyText: string;
+    /** The `{ error, code }` body when the answer carried one. */
+    readonly refusal: RefusalBody | undefined;
+    constructor(status: number, bodyText: string);
+}
+interface RefusalBody {
+    code?: string;
+    error?: string;
+}
+interface HttpTransportOptions {
+    serverUrl: string;
+    getAccessToken?: AccessTokenProvider;
+    /** Custom fetch function (for testing or custom auth). */
+    fetch?: typeof fetch;
+    /**
+     * Gzip JSON request bodies of at least `COMPRESSED_BODY_MIN_BYTES` (`Content-Encoding: gzip`).
+     * Browsers never compress request bodies, so a registered schema otherwise goes up raw. Only
+     * for servers that inflate request bodies (Express's JSON parser does).
+     */
+    compressRequests?: boolean;
+}
+/** Bodies below this stay plain: compressing them costs more than it saves. */
+declare const COMPRESSED_BODY_MIN_BYTES: number;
+/** A JSON request body, gzipped (`encoding: 'gzip'`) when `compress` is set and it is large enough to be worth it. */
+declare function encodeJsonBody(value: object, compress: boolean): Promise<{
+    body: string | Uint8Array<ArrayBuffer>;
+    encoding?: 'gzip';
+}>;
+/** HTTP transport — POSTs to a server speaking the canonical playground-runtime contract. */
+declare function createHttpTransport(options: HttpTransportOptions): EventTransport;
+/** Evaluates one event against an orbital with no wire in between — the unified `evaluateOrbitalEvent` (a separate, in-progress unit) is a valid `OrbitalEvaluator`. */
+type OrbitalEvaluator = (orbitalName: string, request: EventRequest) => Promise<EventResponse>;
+interface InProcessTransportOptions {
+    onRegister?: (schema: OrbitalSchema) => Promise<void> | void;
+    onUnregister?: () => Promise<void> | void;
+    /**
+     * In-process evaluation never crosses a wire, so nothing about circuit
+     * state is "carried" in the stateless-topology sense — `false` by
+     * default, mirroring `@almadar/ui`'s `BrowserPlayground` today: its
+     * in-process `register` never declares a `topology`, and the provider's
+     * fallback for a custom transport is `'in-process'` (not
+     * `'stateless-http'`).
+     */
+    carriesCircuitState?: boolean;
+    /** Resolves a row-set reference on the in-process kernel (`KernelEngine.resolveRows`), `@read` applied there. */
+    resolveRows?: (reference: RowSetRef) => Promise<RowQueryPage>;
+}
+/** In-process transport — the evaluator is INJECTED (e.g. the unified `evaluateOrbitalEvent`, owned elsewhere). */
+declare function createInProcessTransport(evaluate: OrbitalEvaluator, options?: InProcessTransportOptions): EventTransport;
+
+export { COMPRESSED_BODY_MIN_BYTES, SessionEndedError, TransportStatusError, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody };
+export type { AccessTokenProvider, EventTransport, EventTransportRegisterResult, HostDispatchListener, HttpTransportOptions, InProcessTransportOptions, OrbitalEvaluator, PushTarget };

package/dist/client/EventTransport.js

@@ -0,0 +1 @@
+export { COMPRESSED_BODY_MIN_BYTES, SessionEndedError, TransportStatusError, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody } from '../chunk-UD2CXYSJ.js';

package/dist/client/awaiting.d.ts

@@ -0,0 +1,28 @@
+import { AwaitingTrait } from '@almadar/core';
+
+/**
+ * Which traits are awaiting a server round trip right now — the kernel contract
+ * behind awaiting-server skeletons (`AwaitingTrait`, `@almadar/core`). The
+ * client kernel begins an entry right before a server leg's send and ends it
+ * when the leg folds or fails; local/hybrid traits and tick legs never enter.
+ * Subscriptions are per trait, so only the slots that trait owns re-render.
+ */
+
+declare class AwaitingRegistry {
+    private readonly entries;
+    private readonly listeners;
+    private readonly anyListeners;
+    private version;
+    begin(list: readonly AwaitingTrait[]): void;
+    end(traits: readonly string[]): void;
+    get(trait: string): AwaitingTrait | undefined;
+    list(): AwaitingTrait[];
+    subscribe(trait: string, listener: () => void): () => void;
+    /** Any trait's awaiting change (an empty slot does not know which trait will fill it). */
+    subscribeAll(listener: () => void): () => void;
+    /** Bumped on every change — a stable snapshot key for `useSyncExternalStore`. */
+    getVersion(): number;
+    private emit;
+}
+
+export { AwaitingRegistry };

package/dist/client/awaiting.js

@@ -0,0 +1 @@
+export { AwaitingRegistry } from '../chunk-HC6ERSAH.js';

package/dist/client/channel-transport.d.ts

@@ -0,0 +1,69 @@
+import { EventRequest, EventResponse, EmittedEvent } from '@almadar/core';
+import { PushTarget, EventTransport } from './EventTransport.js';
+
+/**
+ * An EventTransport over a message channel, for a program hosted in another browser context (an
+ * extension's service worker, a web worker, an iframe). The view half plays events and receives
+ * pushes; the host half serves any EventTransport on the channel and pushes to its views. The
+ * channel is two functions, so any postMessage-style port fits behind it.
+ */
+
+type ChannelMessage = {
+    almadarChannel: 'register';
+    id: number;
+    schemaName: string;
+} | {
+    almadarChannel: 'registered';
+    id: number;
+    held: boolean;
+} | {
+    almadarChannel: 'send';
+    id: number;
+    orbitalName: string;
+    request: EventRequest;
+} | {
+    almadarChannel: 'reply';
+    id: number;
+    response: EventResponse;
+} | {
+    almadarChannel: 'push';
+    emitted: EmittedEvent;
+    target: PushTarget;
+} | {
+    almadarChannel: 'dispatched';
+    orbitalName: string;
+    request: EventRequest;
+    response: EventResponse;
+};
+interface TransportChannel {
+    post(message: ChannelMessage): void;
+    onMessage(listener: (message: ChannelMessage) => void): () => void;
+    /** The other end went away for good (a stopped extension worker's port); absent for channels that cannot close. */
+    onClose?(listener: () => void): () => void;
+}
+interface ChannelTransportOptions {
+    /** The host on the other end keeps the program's browser-stored entities (see `EventTransport.hostsBrowserStore`). */
+    hostsBrowserStore?: boolean;
+}
+/** The view half: an EventTransport whose program lives on the other end of the channel. */
+declare function createChannelTransport(channel: TransportChannel, options?: ChannelTransportOptions): EventTransport;
+interface ServedChannel {
+    /** Push a host-side event to the view (e.g. one a declared input caused while no view was asking). */
+    push(emitted: EmittedEvent, target: PushTarget): void;
+    /** Send the view the result of a dispatch the host ran on its own. */
+    pushDispatch(orbitalName: string, request: EventRequest, response: EventResponse): void;
+    stop(): void;
+}
+/** The host half: serve `transport` on `channel` for the program named `schemaName`. */
+declare function serveChannel(channel: TransportChannel, transport: EventTransport, options: {
+    schemaName: string;
+}): ServedChannel;
+/**
+ * A channel that listens from the moment it is wrapped and keeps what arrives until something
+ * subscribes, then hands it over in order: a host that is still starting (an extension worker
+ * waking up) serves the channel late without losing the view's first messages.
+ */
+declare function holdUntilServed(channel: TransportChannel): TransportChannel;
+
+export { createChannelTransport, holdUntilServed, serveChannel };
+export type { ChannelMessage, ChannelTransportOptions, ServedChannel, TransportChannel };

package/dist/client/channel-transport.js

@@ -0,0 +1 @@
+export { createChannelTransport, holdUntilServed, serveChannel } from '../chunk-SKLMWHQD.js';