@almadar/shell-runtime 0.0.0-stage → 1.0.0

package/dist/credentials/vault.d.ts

@@ -0,0 +1,142 @@
+import { EntityRow } from '@almadar/core';
+import { CredentialGrantWire, CredentialStanding, ConnectFailure, ConnectFailureKind } from '@almadar/core/kernel-wire';
+
+/**
+ * The credential rows a host keeps over its medium (`chrome.storage`, files, Firestore). It answers four raw asks and
+ * decides nothing: encryption, row shape, identity and every failure rule are the kernel's (`CredentialVault`, wasm).
+ * `create` carries the id the kernel gave the row; `update` merges `data` over the row; `delete` answers whether this call
+ * removed the row, and must do so atomically against other takers of the same medium: it is the conditional delete a
+ * one-use value is taken with.
+ */
+interface CredentialRowsPort {
+    list(): Promise<EntityRow[]>;
+    create(row: EntityRow & {
+        id: string;
+    }): Promise<void>;
+    update(id: string, data: EntityRow): Promise<void>;
+    delete(id: string): Promise<boolean>;
+}
+/** The slice of the wasm `CredentialVault` class (`@almadar/kernel`) this handle uses; each result is JSON text. */
+interface CredentialVaultKernel {
+    readonly enabled: boolean;
+    load(rowsJson: string): number;
+    resolve(name: string, principal?: string): string | undefined;
+    label(name: string, principal?: string): string | undefined;
+    snapshotEnv(): string;
+    entries(principal?: string): string;
+    listing(): string;
+    set(service: string, name: string, value: string, principal?: string, label?: string): string;
+    replace(name: string, value: string, principal?: string): string;
+    persist(name: string, value: string, principal?: string, label?: string): string;
+    remove(name: string, principal?: string): boolean;
+    rotate(): string;
+    takeWrites(): string;
+    connectBegin(grantJson: string): string;
+    refreshBegin(name: string, principal?: string): string;
+    connectFinish(ticket: number, status: number, body: string): string;
+    connectAbandon(ticket: number): boolean;
+}
+/** What the kernel asks a host to POST to a token endpoint. The host decides nothing about it. */
+interface TokenRequest {
+    endpoint: string;
+    headers: Array<[string, string]>;
+    body: string;
+}
+interface TokenReply {
+    status: number;
+    body: string;
+}
+/** The host's one network capability the credential exchange needs: a form POST to an https token endpoint, no redirects followed. */
+type TokenEndpointPost = (request: TokenRequest) => Promise<TokenReply>;
+/** A token exchange the kernel's store refused or the host could not carry; `kind` is the kernel's `ConnectFailureKind`. */
+declare class CredentialExchangeError extends Error {
+    readonly kind: ConnectFailureKind;
+    constructor(kind: ConnectFailureKind, message: string);
+}
+/** A kernel module that carries the vault class: `import * as kernel from '@almadar/kernel/client'`. */
+interface CredentialVaultModule {
+    CredentialVault: new (masterKey?: string, previousKey?: string) => CredentialVaultKernel;
+}
+/** Masked view of one stored credential, safe to return to a settings page. */
+interface CredentialEntry {
+    service: string;
+    envVar: string;
+    last4: string;
+    updatedAt: number;
+    principal?: string;
+}
+interface CredentialRotation {
+    rotated: number;
+    alreadyCurrent: number;
+    unreadable: number;
+}
+interface CredentialListing {
+    enabled: boolean;
+    entries: Array<{
+        service: string;
+        name: string;
+        last4?: string;
+    }>;
+}
+/**
+ * The host's handle on the kernel's encrypted credential store. The kernel keeps the rows the host last listed, runs every
+ * operation (set, remove, rotate, resolution, masking) and records what changed; this handle lists the rows into
+ * it and applies the recorded writes to the host's medium, one operation at a time. A row the kernel cannot read fails
+ * `open` and every operation after it: nothing here reads a broken store as an empty one.
+ */
+declare class CredentialVault {
+    private readonly kernel;
+    private readonly rows;
+    private readonly listeners;
+    private queue;
+    private broken;
+    private constructor();
+    /** List the host's rows into the kernel and read them; rejects naming the rows it cannot read. */
+    static open(kernel: CredentialVaultKernel, rows: CredentialRowsPort): Promise<CredentialVault>;
+    /** True when a valid master key is present (writes and decryption enabled). */
+    get enabled(): boolean;
+    /** Subscribe to credential changes; returns an unsubscribe function. */
+    subscribe(listener: (principal?: string) => void): () => void;
+    private notify;
+    private reload;
+    private current;
+    private apply;
+    /** One operation at a time: the kernel runs it, then its writes reach the medium before the next begins. */
+    private serial;
+    private exclusive;
+    /** Resolve one credential by name (warmed values only). */
+    resolve(envVar: string, principal?: string): string | undefined;
+    /** The non-secret account label stored in the clear beside a credential's ciphertext; undefined when its row carries none. */
+    label(envVar: string, principal?: string): string | undefined;
+    /** All app-wide values as an env-shaped map, for merging over the process env. */
+    snapshotEnv(): Record<string, string>;
+    /** Masked entries for display — never includes plaintext. */
+    entries(principal?: string): CredentialEntry[];
+    /** Whether the store can encrypt and the service and name of every app-wide row. */
+    listing(): CredentialListing;
+    /** Upsert one credential; `label` is a non-secret account name kept in the clear beside it, left out it stays as it is. */
+    set(service: string, envVar: string, value: string, principal?: string, label?: string): Promise<CredentialEntry>;
+    /** Replace the value of a credential already stored, keeping its service (a rotated refresh token). */
+    replace(envVar: string, value: string, principal?: string): Promise<CredentialEntry>;
+    /** Keep `value` as the credential until it is forgotten, creating it when absent. */
+    persist(envVar: string, value: string, principal?: string, label?: string): Promise<CredentialEntry>;
+    /** Delete one credential row; whether one existed. */
+    remove(envVar: string, principal?: string): Promise<boolean>;
+    private readonly flights;
+    private readonly turns;
+    private post;
+    private finish;
+    /** Exchange `grant` at its token endpoint through `post` and keep the result as the credential: the kernel builds the request and settles the reply, the host only sends. */
+    connect(grant: CredentialGrantWire, post: TokenEndpointPost): Promise<{
+        ok: CredentialStanding;
+    } | {
+        error: ConnectFailure;
+    }>;
+    /** The credential `envVar` for `principal`, refreshed first through `post` when it is past its expiry; concurrent resolves share one refresh. Undefined when nothing is held, nothing can renew it, or the provider refused (which drops the row). */
+    resolveFresh(envVar: string, principal: string | undefined, post: TokenEndpointPost): Promise<string | undefined>;
+    /** Re-encrypt every row under the current master key; a row the kernel cannot read fails it before any row changes. */
+    rotate(): Promise<CredentialRotation>;
+}
+
+export { CredentialExchangeError, CredentialVault };
+export type { CredentialEntry, CredentialListing, CredentialRotation, CredentialRowsPort, CredentialVaultKernel, CredentialVaultModule, TokenEndpointPost, TokenReply, TokenRequest };

package/dist/credentials/vault.js

@@ -0,0 +1 @@
+export { CredentialExchangeError, CredentialVault } from '../chunk-DFDNHVDW.js';

package/dist/effects/in-flight-calls.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The in-flight `call-service` registry of ONE running app: a call declared
+ * with a `key` registers here for as long as it runs, and `cancel-call` aborts
+ * every call running under that key. One instance is shared by every transition of the app.
+ */
+type KeyedCallOutcome<T> = {
+    cancelled: true;
+} | {
+    cancelled: false;
+    value: T;
+};
+interface KeyedCallLease {
+    signal: AbortSignal;
+    release(): void;
+}
+declare class InFlightCalls {
+    private readonly calls;
+    /** Whether a call started with `key` is still running. */
+    inFlight(key: string): boolean;
+    /**
+     * Run `work` registered under `key`, handing it the abort signal; `work` must settle promptly once the
+     * signal aborts (see `untilAborted`). The call is cancelled when the signal was aborted by the time
+     * `work` settles, whatever it settled with.
+     */
+    run<T>(key: string, work: (signal: AbortSignal) => Promise<T>): Promise<KeyedCallOutcome<T>>;
+    reserve(key: string): KeyedCallLease | undefined;
+    private track;
+    cancelAll(): void;
+    /** Abort every call running under `key`; false (a no-op) when none is. */
+    cancel(key: string): boolean;
+}
+/** `promise`, or a rejection as soon as `signal` aborts: a provider that ignores the signal is not waited for. */
+declare function untilAborted<T>(signal: AbortSignal, promise: Promise<T>): Promise<T>;
+
+export { InFlightCalls, untilAborted };
+export type { KeyedCallLease, KeyedCallOutcome };

package/dist/effects/in-flight-calls.js

@@ -0,0 +1 @@
+export { InFlightCalls, untilAborted } from '../chunk-MZKIL5IN.js';

package/dist/effects/on-device-model.d.ts

@@ -0,0 +1,22 @@
+import { OnDeviceFailureKind, OnDeviceFailurePayload, OnDeviceModelPorts } from '@almadar/core';
+
+/**
+ * `browser/prompt` and `browser/embed`: the host's on-device model and embedder behind one contract, shared by the
+ * interpreter (`EffectExecutor`) and the kernel host (`answerRequest`). A host with no port fails `unconfigured`, a
+ * model that cannot answer now fails `unavailable`, and one that errors fails `failed`.
+ */
+
+declare const NO_ON_DEVICE_MODEL = "browser/prompt: no on-device model is wired into this host";
+declare const NO_ON_DEVICE_EMBEDDER = "browser/embed: no on-device embedder is wired into this host";
+/** An on-device call that gave no answer; `payload` is what the failure route receives. */
+declare class OnDeviceModelFailure extends Error {
+    readonly kind: OnDeviceFailureKind;
+    readonly payload: OnDeviceFailurePayload;
+    constructor(kind: OnDeviceFailureKind, message: string, key: string | null);
+}
+/** The reply text of one prompt; the schema text must be a JSON object. */
+declare function promptOnDevice(ports: OnDeviceModelPorts | undefined, text: string, schemaText: string, key: string | null, signal?: AbortSignal): Promise<string>;
+/** One vector per text, in input order; an empty list is answered without asking the embedder. */
+declare function embedOnDevice(ports: OnDeviceModelPorts | undefined, texts: readonly string[], key: string | null, signal?: AbortSignal): Promise<number[][]>;
+
+export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice };

package/dist/effects/on-device-model.js

@@ -0,0 +1 @@
+export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice } from '../chunk-FWA5K7Q2.js';

package/dist/events/EventBus.d.ts

@@ -0,0 +1,87 @@
+import { IEventBus, RuntimeEvent, EventListener, Unsubscribe } from '../runtime/types.js';
+import { EventPayload } from '@almadar/core';
+import '../service/default-call-service.js';
+import '../service/service-provider.js';
+import '../kernel/program-effects.js';
+import '@almadar/core/kernel-wire';
+
+/**
+ * EventBus - Platform-Agnostic Pub/Sub Implementation
+ *
+ * Pure TypeScript event bus for cross-trait communication.
+ * Works on both client (browser) and server (Node.js).
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * EventBus - Simple pub/sub event bus
+ *
+ * @example
+ * ```typescript
+ * const bus = new EventBus({ debug: true });
+ *
+ * // Subscribe
+ * const unsub = bus.on('ORDER_CONFIRMED', (event) => {
+ *   log.debug('order-confirmed', { orderId: event.payload?.orderId });
+ * });
+ *
+ * // Emit
+ * bus.emit('ORDER_CONFIRMED', { orderId: '123' });
+ *
+ * // Unsubscribe
+ * unsub();
+ * ```
+ */
+declare class EventBus implements IEventBus {
+    private listeners;
+    /** Maximum recursion depth before circuit breaker activates (RCG-05) */
+    private maxDepth;
+    /** Current emission depth for circular loop detection */
+    private depth;
+    constructor(options?: {
+        debug?: boolean;
+        maxDepth?: number;
+    });
+    /**
+     * 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: string, payload?: EventPayload, source?: RuntimeEvent['source'], routingKey?: string): void;
+    /**
+     * Subscribe to an event type
+     */
+    on(type: string, listener: EventListener): Unsubscribe;
+    /**
+     * Subscribe to ALL events (wildcard listener)
+     * Useful for event tracking, logging, debugging
+     */
+    onAny(listener: EventListener): Unsubscribe;
+    /**
+     * Check if there are listeners for an event type
+     */
+    hasListeners(type: string): boolean;
+    /**
+     * Get all registered event types
+     */
+    getRegisteredEvents(): string[];
+    /**
+     * Clear all listeners
+     */
+    clear(): void;
+    /**
+     * Get listener count for an event type (for testing)
+     */
+    getListenerCount(type: string): number;
+}
+/**
+ * Create a new EventBus instance
+ */
+declare function createEventBus(options?: {
+    debug?: boolean;
+}): IEventBus;
+
+export { EventBus, createEventBus };

package/dist/events/EventBus.js

@@ -0,0 +1 @@
+export { EventBus, createEventBus } from '../chunk-SOQDEPME.js';

package/dist/events/emit-stamp.d.ts

@@ -0,0 +1,47 @@
+import { OrbitalId, TraitId, EventId, BusEventSource } from '@almadar/core';
+
+/**
+ * emit-stamp — the ONE emit-source stamper.
+ *
+ * Extracted from `OrbitalServerRuntime.executeEffects`'s emit handler so
+ * every execution path (stateful server, stateless per-request, any future
+ * emitter) stamps emitted events identically. G-RUNTIME-030 was exactly
+ * this decision existing twice with different outcomes: a stamp missing
+ * the V4 `traitId`/`orbitalId`/`eventId` triple silently never matches an
+ * id-scoped `listens` matcher (`buildSourceMatcher`), and the fan-out dies
+ * without an error.
+ *
+ * All four ids are optional dual-carry: absent → name-only stamp (legacy,
+ * name-keyed routing), present → id-keyed routing via `eventRouteKey`.
+ *
+ * @packageDocumentation
+ */
+
+interface StampEmitIdentity {
+    /** The dispatching orbital's declared name (name-stamp fallback). */
+    orbitalName: string;
+    /** The emitting trait's declared name (name-stamp fallback). */
+    traitName: string;
+    /** V4 ids, when the schema carries them. */
+    orbitalId?: OrbitalId;
+    traitId?: TraitId;
+    /**
+     * The emitting trait's `emits[]` contract entry id for THIS event — the
+     * single canonical event id (mirrors `resolveSourceEmitEventId` on the
+     * listen side; the listener's own declared id can be stale, the emit
+     * contract's is what the emitter actually stamps).
+     */
+    emitContractEventId?: EventId;
+    /** The originating tab's client id, when this emit is client-driven. */
+    originClientId?: string;
+}
+/**
+ * Fill a bus-event source stamp with the V4 identity triple + origin.
+ * Mutates and returns `source` when given (handlers pass their closure
+ * source through); otherwise synthesizes one from the lexical identity.
+ * Never overwrites a field already set on the stamp.
+ */
+declare function stampEmitSource(source: BusEventSource | undefined, identity: StampEmitIdentity): BusEventSource;
+
+export { stampEmitSource };
+export type { StampEmitIdentity };

package/dist/events/emit-stamp.js

@@ -0,0 +1 @@
+export { stampEmitSource } from '../chunk-64IH2SMY.js';

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+export { AccessTokenProvider, COMPRESSED_BODY_MIN_BYTES, EventTransport, EventTransportRegisterResult, HostDispatchListener, HttpTransportOptions, InProcessTransportOptions, OrbitalEvaluator, PushTarget, SessionEndedError, TransportStatusError, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody } from './client/EventTransport.js';
+export { AwaitingRegistry } from './client/awaiting.js';
+export { ChannelMessage, ChannelTransportOptions, ServedChannel, TransportChannel, createChannelTransport, holdUntilServed, serveChannel } from './client/channel-transport.js';
+export { CircuitStore, FrameOutcome, TraitSnapshot, createMemoryCircuitStore } from './client/circuit-store.js';
+export { ClientDispatchHooks, ClientEmitOutcome, ClientKernel, ClientKernelOutcome, ClientMountHooks, ClientMountOutcome, LocalFoldKernel } from './client/client-kernel.js';
+export { dispatchDeclaredInput } from './client/declared-input-dispatch.js';
+export { InboundContract, dispatchInbound } from './client/inbound-dispatch.js';
+export { FramesSince, LocalFoldOptions, createLocalFold, paintFrames, paintResponse, paintStates, traceResponse } from './client/local-fold.js';
+export { DEFAULT_THEME_KEY, appNavItems, inlineNavItems, sigilThemeKey } from './client/render-sigils.js';
+export { StateBook, createInitialTraitState, findInitialState } from './client/state-book.js';
+export { TraitMountError } from './client/trait-mount-error.js';
+export { RollbackCause, TraitState, TransitionObserver } from './client/trait-types.js';
+export { CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV, STORE_BOOTSTRAP_ENV_VARS, allCredentialEnvVars } from './credentials/env-vars.js';
+export { CREDENTIALS_SOURCE_ENV, CredentialMode, CredentialModeControl, CredentialScopeStorage, credentialModeFromEnv, credentialsFromStoreOnly, getEffectiveCredentialStore, getInstalledCredentialStore, getModeControl, installCredentialScopeStorage, installCredentialStore, installModeControl, resolveCredentialRef, runWithCredentialScope, uninstallCredentialStore } from './credentials/scope.js';
+export { CredentialEntry, CredentialExchangeError, CredentialListing, CredentialRotation, CredentialRowsPort, CredentialVault, CredentialVaultKernel, CredentialVaultModule, TokenEndpointPost, TokenReply, TokenRequest } from './credentials/vault.js';
+export { InFlightCalls, KeyedCallLease, KeyedCallOutcome, untilAborted } from './effects/in-flight-calls.js';
+export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice } from './effects/on-device-model.js';
+export { EventBus, createEventBus } from './events/EventBus.js';
+export { StampEmitIdentity, stampEmitSource } from './events/emit-stamp.js';
+export { decodeDueTicks, decodeNext, decodeProgress, decodeResolveProgress } from './kernel/decode.js';
+export { KernelEngine, KernelEvaluation, ProgramlessContract, evaluateOnKernel, kernelRequest } from './kernel/engine.js';
+export { FrameApplied, FrameDispatch, FramePostPort, TickEffects, applyFrame, decodeFrame } from './kernel/frame-applier.js';
+export { DeferredCallOutcome, EventRequestParser, HostAskError, HostAskFailureKind, HostAskOutcome, HostAskReturn, HostAudioAsk, HostConsentAnswer, HostConsentRequest, HostSignInAnswer, HostSignInRequest, KernelAnswerScope, KernelCallService, KernelHostActions, KernelHostPorts, SubstrateStreamSource, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from './kernel/host.js';
+export { CredentialAdminPort, CredentialConnectPort, EnvTailsPort, RANDOM_BYTES_MAX, RandomSource, SecretPorts, SecretPortsOptions, SecretStore, SecretStoreHost, base64Standard, base64Url, createBrowserSecretPorts, createCredentialAdminPort, createCredentialConnectPort, createSecretPorts, createSecretStore, credentialForgetPayload, credentialStatusPayload, envTailsOf, randomBytesPayload, systemRandom, userCredentialKey } from './kernel/secret-ports.js';
+export { LaneHeldByParkedDispatch } from './kernel/lane.js';
+export { AnchoredPath, OsAnchorProblem, OsAnchors, OsCompletionEvent, OsCompletionMatchers, OsCompletionPort, OsDesktopKind, OsFsMode, OsGrantKernel, OsGrantMatchers, OsGrantPort, OsHostPort, OsNetKind, OsRequirement, OsStdioKind, OsSysKind, OsTlsKernel, OsTlsPort, OsTlsStep, anchoredGrants, expandAnchor, kernelOsCompletions, kernelOsGrants, kernelOsTls } from './kernel/os-port.js';
+export { createFetchOsHost } from './kernel/os-fetch-port.js';
+export { PROGRAM_EFFECTS, ProgramEffectName, ProgramEffectOutcome, ProgramValidationReport, StepRequest, isProgramEffect } from './kernel/program-effects.js';
+export { FiredByOrbital, KernelModule, KernelServerClass, KernelServerHandle } from './kernel/wire.js';
+export { loadLazyPage } from './loader/lazy-page.js';
+export { FetchSchemaLoader } from './loader/fetch-loader.js';
+export { BaseLoaderOptions, ImportChainLike, LoadResult, LoadedOrbital, LoadedSchema, SchemaLoader } from './loader/schema-loader.js';
+export { bindDeclaredCollections } from './runtime/entities/declaredCollections.js';
+export { LocalKernelOptions, LocalStoreTransportOptions, createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows } from './runtime/evaluation/local-store-transport.js';
+export { ResidenceTransportOptions, createResidenceTransport } from './runtime/evaluation/residence-transport.js';
+export { routeByEntity } from './runtime/evaluation/routed-persistence.js';
+export { eventRouteKey } from './runtime/events/identity/routing.js';
+export { BindingContext, Effect, EffectHandlers, EffectResult, EvaluationContextExtensions, EventListener, IEventBus, PatternProps, RuntimeEvent, Unsubscribe } from './runtime/types.js';
+export { CallServiceHandler, ServiceMessageRoute, defaultCallService } from './service/default-call-service.js';
+export { ServiceCallContext, ServiceCallError, ServiceCallErrorCode, ServiceProvider, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider } from './service/service-provider.js';
+export { NativeMemoryPersistenceAdapter, NativeMemoryWriteError } from './persistence/native-memory.js';
+export { CallRoutesWire, CallSiteWire, CallerWire, IoAnswerWire, IoReplyWire, IoRequestWire, NextWire, PendingRequestWire, PlayedStep, ResolveProgressWire, ServerProgressWire, Settled, SubstrateFailureWire, decodeIoRequestWire as decodeRequest } from '@almadar/core/kernel-wire';
+export { EntityRow, EventPayload, FetchResult, ServiceParams } from '@almadar/core';

package/dist/index.js

@@ -0,0 +1,41 @@
+import './chunk-ELBLT2HZ.js';
+export { NativeMemoryPersistenceAdapter, NativeMemoryWriteError } from './chunk-7SDV3QWR.js';
+export { bindDeclaredCollections } from './chunk-BAS26HBN.js';
+export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows } from './chunk-MU335ZA4.js';
+export { defaultCallService } from './chunk-4SEK5ER2.js';
+export { ServiceCallError, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider } from './chunk-UBN5JJKZ.js';
+export { createResidenceTransport } from './chunk-V4EMDPCO.js';
+export { routeByEntity } from './chunk-O57GKTYU.js';
+export { eventRouteKey } from './chunk-BY5G4225.js';
+import './chunk-LYFIQPXX.js';
+export { createFetchOsHost } from './chunk-625EP7W2.js';
+export { anchoredGrants, expandAnchor, kernelOsCompletions, kernelOsGrants, kernelOsTls } from './chunk-BOVU4TCQ.js';
+import './chunk-EZZYLTWY.js';
+export { FetchSchemaLoader } from './chunk-57SBCUSM.js';
+export { loadLazyPage } from './chunk-XXWNMJI6.js';
+export { EventBus, createEventBus } from './chunk-SOQDEPME.js';
+export { stampEmitSource } from './chunk-64IH2SMY.js';
+export { KernelEngine, evaluateOnKernel, kernelRequest } from './chunk-I3TKINSO.js';
+export { LaneHeldByParkedDispatch } from './chunk-NU6LVKGS.js';
+export { decodeDueTicks, decodeNext, decodeProgress, decodeIoRequestWire as decodeRequest, decodeResolveProgress } from './chunk-X6W44WHO.js';
+export { applyFrame, decodeFrame } from './chunk-NTFQ36UN.js';
+export { HostAskError, answerRequest, completeTls, consentFromRedirect, declareCapabilities, finishTls, hostAskReturn, kernelEventRequestParser, parseConsentRequest, parseSignInRequest, performHostAnswer, performHostAsk, writeRows } from './chunk-7WB6VWRK.js';
+export { PROGRAM_EFFECTS, isProgramEffect } from './chunk-WGCWJOT2.js';
+export { RANDOM_BYTES_MAX, base64Standard, base64Url, createBrowserSecretPorts, createCredentialAdminPort, createCredentialConnectPort, createSecretPorts, createSecretStore, credentialForgetPayload, credentialStatusPayload, envTailsOf, randomBytesPayload, systemRandom, userCredentialKey } from './chunk-ZUSM4VW4.js';
+export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice } from './chunk-FWA5K7Q2.js';
+export { DEFAULT_THEME_KEY, appNavItems, inlineNavItems, sigilThemeKey } from './chunk-UP6GGGAN.js';
+export { TraitMountError } from './chunk-IOPUS6Q5.js';
+import './chunk-P53CKOME.js';
+export { CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV, STORE_BOOTSTRAP_ENV_VARS, allCredentialEnvVars } from './chunk-VNGXRYFF.js';
+export { CREDENTIALS_SOURCE_ENV, credentialModeFromEnv, credentialsFromStoreOnly, getEffectiveCredentialStore, getInstalledCredentialStore, getModeControl, installCredentialScopeStorage, installCredentialStore, installModeControl, resolveCredentialRef, runWithCredentialScope, uninstallCredentialStore } from './chunk-HLOUDLPI.js';
+export { CredentialExchangeError, CredentialVault } from './chunk-DFDNHVDW.js';
+export { InFlightCalls, untilAborted } from './chunk-MZKIL5IN.js';
+export { COMPRESSED_BODY_MIN_BYTES, SessionEndedError, TransportStatusError, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody } from './chunk-UD2CXYSJ.js';
+export { createChannelTransport, holdUntilServed, serveChannel } from './chunk-SKLMWHQD.js';
+export { createMemoryCircuitStore } from './chunk-N7HYNKK6.js';
+export { StateBook, createInitialTraitState, findInitialState } from './chunk-A2JJT4GA.js';
+export { AwaitingRegistry } from './chunk-HC6ERSAH.js';
+import './chunk-LZIOTBFX.js';
+export { dispatchDeclaredInput } from './chunk-LKWYCYX5.js';
+export { dispatchInbound } from './chunk-P2N6K2IV.js';
+export { createLocalFold, paintFrames, paintResponse, paintStates, traceResponse } from './chunk-QCJWPXLH.js';

package/dist/kernel/decode.d.ts

@@ -0,0 +1,13 @@
+import { NextWire, ServerProgressWire, ResolveProgressWire } from '@almadar/core/kernel-wire';
+export { decodeIoRequestWire as decodeRequest } from '@almadar/core/kernel-wire';
+import { FiredByOrbital } from './wire.js';
+import '@almadar/core';
+
+/** Decoders for what the kernel hands back as JSON: the generated decoders of `@almadar/core/kernel-wire`, which throw naming the failing path. */
+
+declare function decodeProgress(json: string): ServerProgressWire;
+declare function decodeNext(json: string): NextWire | null;
+declare function decodeResolveProgress(json: string): ResolveProgressWire;
+declare function decodeDueTicks(json: string): FiredByOrbital;
+
+export { decodeDueTicks, decodeNext, decodeProgress, decodeResolveProgress };

package/dist/kernel/decode.js

@@ -0,0 +1 @@
+export { decodeDueTicks, decodeNext, decodeProgress, decodeIoRequestWire as decodeRequest, decodeResolveProgress } from '../chunk-X6W44WHO.js';