@almadar/shell-runtime 0.0.0-stage → 0.1.0

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,2 @@
+export { InFlightCalls, untilAborted } from '../chunk-MZKIL5IN.js';
+import '../chunk-MLKGABMK.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,2 @@
+export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice } from '../chunk-FWA5K7Q2.js';
+import '../chunk-MLKGABMK.js';

package/dist/events/EventBus.d.ts

@@ -0,0 +1,90 @@
+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 '../runtime/effects/composition/compose-behaviors.js';
+import '../runtime/effects/composition/event-wiring.js';
+import '../runtime/effects/composition/layout-strategy.js';
+import '../runtime/effects/composition/pipe.js';
+
+/**
+ * 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,2 @@
+export { EventBus, createEventBus } from '../chunk-SOQDEPME.js';
+import '../chunk-MLKGABMK.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,2 @@
+export { stampEmitSource } from '../chunk-64IH2SMY.js';
+import '../chunk-MLKGABMK.js';

package/dist/index-hT1xCdTq.d.ts

@@ -0,0 +1,46 @@
+import { ComposeBehaviorsInput, ComposeBehaviorsResult, composeBehaviors } from './runtime/effects/composition/compose-behaviors.js';
+import { EventWiringEntry, applyEventWiring } from './runtime/effects/composition/event-wiring.js';
+import { LayoutStrategy, detectLayoutStrategy } from './runtime/effects/composition/layout-strategy.js';
+import { PipeStep, pipeBehaviors } from './runtime/effects/composition/pipe.js';
+
+/**
+ * Composition Module
+ *
+ * Runtime-side TypeScript composition layer for behavior/* operators.
+ *
+ * Composition is normally a compile-time concept, evaluated by the Rust
+ * compiler pass before code generation. The runtime ships an equivalent
+ * TypeScript implementation so dev-mode hot reload, agent-driven dynamic
+ * composition, and the legacy `composeBehaviors()` callers all have a
+ * usable in-process implementation. The handlers are wired into
+ * `EffectExecutor` as optional handlers (`composeBehaviors`,
+ * `applyEventWiring`, `detectLayoutStrategy`, `pipeBehaviors`) so
+ * consumers that do not need composition pay no cost.
+ *
+ * @packageDocumentation
+ */
+
+declare const index_ComposeBehaviorsInput: typeof ComposeBehaviorsInput;
+declare const index_ComposeBehaviorsResult: typeof ComposeBehaviorsResult;
+declare const index_EventWiringEntry: typeof EventWiringEntry;
+declare const index_LayoutStrategy: typeof LayoutStrategy;
+declare const index_PipeStep: typeof PipeStep;
+declare const index_applyEventWiring: typeof applyEventWiring;
+declare const index_composeBehaviors: typeof composeBehaviors;
+declare const index_detectLayoutStrategy: typeof detectLayoutStrategy;
+declare const index_pipeBehaviors: typeof pipeBehaviors;
+declare namespace index {
+  export {
+    index_ComposeBehaviorsInput as ComposeBehaviorsInput,
+    index_ComposeBehaviorsResult as ComposeBehaviorsResult,
+    index_EventWiringEntry as EventWiringEntry,
+    index_LayoutStrategy as LayoutStrategy,
+    index_PipeStep as PipeStep,
+    index_applyEventWiring as applyEventWiring,
+    index_composeBehaviors as composeBehaviors,
+    index_detectLayoutStrategy as detectLayoutStrategy,
+    index_pipeBehaviors as pipeBehaviors,
+  };
+}
+
+export { index as i };

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+export { AccessTokenProvider, COMPRESSED_BODY_MIN_BYTES, EventTransport, EventTransportRegisterResult, HostDispatchListener, HttpTransportOptions, InProcessTransportOptions, OrbitalEvaluator, PushTarget, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody } from './client/EventTransport.js';
+export { ServerBridge, ServerBridgeConfig, ServerBridgeState, createServerBridge } from './client/ServerBridge.js';
+export { AwaitingRegistry } from './client/awaiting.js';
+export { ChannelMessage, ChannelTransportOptions, ServedChannel, TransportChannel, createChannelTransport, holdUntilServed, serveChannel } from './client/channel-transport.js';
+export { CircuitStore, TraitSnapshot, createMemoryCircuitStore } from './client/circuit-store.js';
+export { ClientDispatchHooks, ClientKernel, ClientKernelOutcome, ClientMountHooks, ClientMountOutcome, LocalFoldKernel } from './client/client-kernel.js';
+export { dispatchDeclaredInput } from './client/declared-input-dispatch.js';
+export { dispatchInbound } from './client/inbound-dispatch.js';
+export { LocalFoldOptions, createLocalFold, mirrorResponse, traceResponse } from './client/local-fold.js';
+export { DEFAULT_THEME_KEY, appNavItems, inlineNavItems, sigilThemeKey } from './client/render-sigils.js';
+export { StateBook, createInitialTraitState, findInitialState, findMatchingTransitions, findTransition } from './client/state-book.js';
+export { TraitMountError } from './client/trait-mount-error.js';
+export { RollbackCause, TraitState, TransitionObserver } from './client/trait-types.js';
+export { 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 { CredentialSeedKernel, DeclaredCredential, seedCredentialStore } from './credentials/seed.js';
+export { CREDENTIAL_ENTITY_TYPE, CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV, CredentialEntry, CredentialPersistence, CredentialStore, DERIVED_ENTITY_TYPE, DerivedPersistence } from './credentials/store.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 { BeaconDelivery, BeaconDeliveryPorts, BeaconFetchInit, deliverBeacon } from './kernel/beacon.js';
+export { decodeHttpBody, decodeHttpRequest, decodeHttpResponse, decodeOAuthAsk, decodeProgress, decodeRequest, decodeResolveProgress } from './kernel/decode.js';
+export { KernelEngine, KernelEvaluation, evaluateOnKernel, kernelRequest } from './kernel/engine.js';
+export { FrameApplied, FrameDispatch, FramePostPort, TickEffects, applyFrame, decodeFrame, isFrameWire } from './kernel/frame-applier.js';
+export { DeferredCallOutcome, KernelAnswerScope, KernelCallService, KernelHostPorts, SubstrateStreamSource, answerRequest, declareCapabilities, writeRows } from './kernel/host.js';
+export { BeaconSettled, BrowserHttpPortsOptions, CredentialAdminPort, Exchange, HttpEffectFailure, HttpKernel, HttpOutcome, HttpPorts, HttpPortsOptions, HttpRunOptions, HttpSecrets, HttpSecretsHost, HttpUnavailableError, NetPort, OAuthAuthorizeKernel, OAuthPort, PinnedFetch, PinnedInit, PinnedResponse, RANDOM_BYTES_MAX, RandomSource, ResolvedHost, StreamFrame, StreamFramingWire, base64Standard, base64Url, checkOAuthReply, createBrowserHttpPorts, createCredentialAdminPort, createHttpPorts, createHttpSecrets, credentialForgetPayload, credentialStatusPayload, installNetPort, isOAuthCode, isOAuthReason, randomBytesPayload, runHttpCall, sendBeaconRequest, sendHttp, streamHttp, systemRandom, unavailableFailure, userCredentialKey } from './kernel/http.js';
+export { DispatchLane, LaneGuard, LaneHeldByParkedDispatch, LaneTurn } from './kernel/lane.js';
+export { OAuthEffectFailure, oauthAuthorizePayload, oauthConnectionPayload } from './kernel/oauth-effects.js';
+export { OAuthConsentRequest, OAuthPortOptions, PENDING_GRACE_MS, createOAuthPort } from './kernel/oauth-port.js';
+export { AnchoredPath, OsAnchorProblem, OsAnchors, OsCompletionEvent, OsCompletionMatchers, OsCompletionPort, OsDesktopKind, OsFsMode, OsGrantKernel, OsGrantMatchers, OsGrantPort, OsHostPort, OsNetKind, OsRequirement, OsStdioKind, OsSysKind, anchoredGrants, expandAnchor, kernelOsCompletions, kernelOsGrants } from './kernel/os-port.js';
+export { CascadeOutcome, PROGRAM_EFFECTS, PlayedStep, ProgramEffectName, ProgramEffectOutcome, ProgramValidationReport, StepRequest, isProgramEffect } from './kernel/program-effects.js';
+export { KernelModule, KernelServerClass, KernelServerHandle } from './kernel/wire.js';
+export { HttpImportChain, HttpLoader, createHttpLoader } from './loader/http-loader.js';
+export { loadLazyPage } from './loader/lazy-page.js';
+export { BaseLoaderOptions, HttpLoaderOptions, ImportChainLike, LoadResult, LoadedOrbital, LoadedSchema, SchemaLoader } from './loader/schema-loader.js';
+export { ComposeBehaviorsInput, ComposeBehaviorsResult, composeBehaviors } from './runtime/effects/composition/compose-behaviors.js';
+export { EventWiringEntry, applyEventWiring } from './runtime/effects/composition/event-wiring.js';
+export { i as composition } from './index-hT1xCdTq.js';
+export { LayoutStrategy, detectLayoutStrategy } from './runtime/effects/composition/layout-strategy.js';
+export { PipeStep, pipeBehaviors } from './runtime/effects/composition/pipe.js';
+export { MockSeedHost, MockSeedViewer, MockSeeded, bindDeclaredCollections, restampMockOwner, seedMockStore } from './runtime/entities/mockStoreSeed.js';
+export { MockSeedEngine, MockSeedRun, SeedConfig, SeedOwnerCell, SeedOwnerChange, SeedOwnerJournal, SeedRestamp, SeededDataset, StdMockSeed, declaredSeedConfig, readSeededStores } from './runtime/entities/std-mock-seed.js';
+export { BrowserSeedHost, seedBrowserStore } from './runtime/entities/seedBrowserStore.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 { ListenSourceDescriptor, RouteSourceMeta, buildSourceMatcher, eventRouteKey, parseListenSource } from './runtime/events/identity/routing.js';
+export { TickHandle, TickScheduler, createTickScheduler } from './runtime/time/TickScheduler.js';
+export { CronFields, cronMatches, cronMinuteKey, isValidCronExpression, parseCron, parseCronField } from './runtime/time/cron.js';
+export { isValidDurationString, parseDurationString } from './runtime/time/duration.js';
+export { ParsedOrbitalTraits, parseOrbitalTraits } from './runtime/traits/OrbitalTraitParsing.js';
+export { CollectedListenerTarget, collectListenerTargets } from './runtime/traits/listen-targets.js';
+export { buildTraitIndex } from './runtime/traits/trait-index.js';
+export { BindingContext, BrowserFileMeta, BrowserFilePickerOptions, BrowserGeolocationOptions, BrowserGeolocationPosition, ConfigContext, Effect, EffectContext, EffectHandlers, EffectResult, EvaluationContextExtensions, EventListener, ExecutionEnvironment, HANDLER_MANIFEST, HttpEffectReport, IEventBus, PatternProps, PersistBatchSummary, RuntimeConfig, RuntimeEvent, RuntimePatternValue, RuntimeRenderPattern, TransitionResult, Unsubscribe, isEffectTuple } 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, HttpBody, HttpFailureWire, HttpRequestWire, HttpResponseWire, IoAnswerWire, IoReplyWire, IoRequestWire, PendingRequestWire, ResolveProgressWire, ServerProgressWire, Settled, SubstrateFailureWire } from '@almadar/core/kernel-wire';
+export { EntityRow, EventPayload, FetchResult, HttpCall, ServiceParams } from '@almadar/core';

package/dist/index.js

@@ -0,0 +1,59 @@
+export { HANDLER_MANIFEST, isEffectTuple } from './chunk-WNPNNYXY.js';
+export { TickScheduler, createTickScheduler } from './chunk-CQP5XAX6.js';
+export { cronMatches, cronMinuteKey, isValidCronExpression, parseCron, parseCronField } from './chunk-CROS2GEX.js';
+export { isValidDurationString, parseDurationString } from './chunk-46RWK2B5.js';
+export { collectListenerTargets } from './chunk-XB5GYODW.js';
+export { buildSourceMatcher, eventRouteKey, parseListenSource } from './chunk-IHQLE5M7.js';
+export { composition_exports as composition } from './chunk-5D63EMO5.js';
+export { pipeBehaviors } from './chunk-FQ6IZMIU.js';
+export { bindDeclaredCollections, restampMockOwner, seedMockStore } from './chunk-JFWFDUTR.js';
+export { seedBrowserStore } from './chunk-T775TUCD.js';
+export { StdMockSeed, declaredSeedConfig, readSeededStores } from './chunk-HMK6YMQS.js';
+export { createLocalStoreTransport, localStorePersistence, openLocalKernel, resolveLocalRows } from './chunk-VNMG7NKY.js';
+export { defaultCallService } from './chunk-4SEK5ER2.js';
+export { ServiceCallError, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider } from './chunk-UBN5JJKZ.js';
+export { routeByEntity } from './chunk-O57GKTYU.js';
+export { buildTraitIndex } from './chunk-CPSQXEJ6.js';
+export { parseOrbitalTraits } from './chunk-SAS5KKCR.js';
+export { createResidenceTransport } from './chunk-UJHOUZAL.js';
+import './chunk-EZZYLTWY.js';
+export { HttpImportChain, HttpLoader, createHttpLoader } from './chunk-YL2SO5TP.js';
+export { loadLazyPage } from './chunk-XXWNMJI6.js';
+import './chunk-ELBLT2HZ.js';
+export { NativeMemoryPersistenceAdapter, NativeMemoryWriteError } from './chunk-7SDV3QWR.js';
+export { composeBehaviors } from './chunk-ZCQUUJIF.js';
+export { detectLayoutStrategy } from './chunk-EV56K4GB.js';
+export { applyEventWiring } from './chunk-MHYSHSRG.js';
+export { KernelEngine, evaluateOnKernel, kernelRequest } from './chunk-D4XJTBLB.js';
+export { applyFrame, decodeFrame, isFrameWire } from './chunk-4J2QEIUV.js';
+export { answerRequest, declareCapabilities, writeRows } from './chunk-NATGCIVM.js';
+export { PROGRAM_EFFECTS, isProgramEffect } from './chunk-HNOAZWFH.js';
+export { DispatchLane, LaneHeldByParkedDispatch } from './chunk-53IPZXDP.js';
+export { OAuthEffectFailure, oauthAuthorizePayload, oauthConnectionPayload } from './chunk-ZAQSS47X.js';
+export { HttpEffectFailure, HttpUnavailableError, RANDOM_BYTES_MAX, base64Standard, base64Url, checkOAuthReply, createBrowserHttpPorts, createCredentialAdminPort, createHttpPorts, createHttpSecrets, credentialForgetPayload, credentialStatusPayload, installNetPort, isOAuthCode, isOAuthReason, randomBytesPayload, runHttpCall, sendBeaconRequest, sendHttp, streamHttp, systemRandom, unavailableFailure, userCredentialKey } from './chunk-YO4LWS3I.js';
+export { PENDING_GRACE_MS, createOAuthPort } from './chunk-4ZICQ5PM.js';
+export { anchoredGrants, expandAnchor, kernelOsCompletions, kernelOsGrants } from './chunk-REPX5QPI.js';
+export { InFlightCalls, untilAborted } from './chunk-MZKIL5IN.js';
+export { NO_ON_DEVICE_EMBEDDER, NO_ON_DEVICE_MODEL, OnDeviceModelFailure, embedOnDevice, promptOnDevice } from './chunk-FWA5K7Q2.js';
+export { EventBus, createEventBus } from './chunk-SOQDEPME.js';
+export { stampEmitSource } from './chunk-64IH2SMY.js';
+export { deliverBeacon } from './chunk-VMOBW7RK.js';
+export { decodeHttpBody, decodeHttpRequest, decodeHttpResponse, decodeOAuthAsk, decodeProgress, decodeRequest, decodeResolveProgress } from './chunk-RBUMDYFS.js';
+export { createLocalFold, mirrorResponse, traceResponse } from './chunk-QQRDUMB2.js';
+export { DEFAULT_THEME_KEY, appNavItems, inlineNavItems, sigilThemeKey } from './chunk-UP6GGGAN.js';
+export { TraitMountError } from './chunk-IOPUS6Q5.js';
+import './chunk-P53CKOME.js';
+export { STORE_BOOTSTRAP_ENV_VARS, allCredentialEnvVars } from './chunk-Q7JK4KY7.js';
+export { CREDENTIAL_ENTITY_TYPE, CREDENTIAL_MASTER_KEY_ENV, CREDENTIAL_PREVIOUS_MASTER_KEY_ENV, CredentialStore, DERIVED_ENTITY_TYPE } from './chunk-NAECVIAR.js';
+export { CREDENTIALS_SOURCE_ENV, credentialModeFromEnv, credentialsFromStoreOnly, getEffectiveCredentialStore, getInstalledCredentialStore, getModeControl, installCredentialScopeStorage, installCredentialStore, installModeControl, resolveCredentialRef, runWithCredentialScope, uninstallCredentialStore } from './chunk-HLOUDLPI.js';
+export { seedCredentialStore } from './chunk-SWPDU752.js';
+export { ServerBridge, createServerBridge } from './chunk-D5USD2EX.js';
+export { COMPRESSED_BODY_MIN_BYTES, createHttpTransport, createInProcessTransport, deriveCarriesCircuitState, encodeJsonBody } from './chunk-QELZ6TEJ.js';
+export { createChannelTransport, holdUntilServed, serveChannel } from './chunk-SKLMWHQD.js';
+export { createMemoryCircuitStore } from './chunk-ODJCZ27I.js';
+export { StateBook, createInitialTraitState, findInitialState, findMatchingTransitions, findTransition } from './chunk-Q2H75UYT.js';
+export { AwaitingRegistry } from './chunk-HC6ERSAH.js';
+import './chunk-LZIOTBFX.js';
+export { dispatchDeclaredInput } from './chunk-DYOJGLIX.js';
+export { dispatchInbound } from './chunk-2JU7Y4KU.js';
+import './chunk-MLKGABMK.js';

package/dist/kernel/beacon.d.ts

@@ -0,0 +1,32 @@
+/** The keepalive fetch a beacon falls back to: always the same method, mode and `text/plain` header. */
+interface BeaconFetchInit {
+    method: 'POST';
+    body: string;
+    keepalive: true;
+    mode: 'cors';
+    headers: {
+        'Content-Type': 'text/plain';
+    };
+}
+/** What a host offers a beacon: a queue that may accept the text (true) or decline, and a status-only fetch. */
+interface BeaconDeliveryPorts {
+    queue?: (url: string, text: string) => boolean;
+    fetch: (url: string, init: BeaconFetchInit) => Promise<{
+        status: number;
+    }>;
+}
+/** How a beacon was taken: the queue accepted it, or one fetch answered `status` (null when the fetch threw). */
+type BeaconDelivery = {
+    via: 'queue';
+} | {
+    via: 'fetch';
+    status: number | null;
+};
+/**
+ * The queue-first, fetch-fallback decision, once. text/plain keeps the request CORS "simple": no preflight,
+ * adblocker-friendly when proxied. A declined, throwing or absent queue falls back; the fetch body is never read.
+ */
+declare function deliverBeacon(url: string, text: string, ports: BeaconDeliveryPorts): Promise<BeaconDelivery>;
+
+export { deliverBeacon };
+export type { BeaconDelivery, BeaconDeliveryPorts, BeaconFetchInit };

package/dist/kernel/beacon.js

@@ -0,0 +1,2 @@
+export { deliverBeacon } from '../chunk-VMOBW7RK.js';
+import '../chunk-MLKGABMK.js';

package/dist/kernel/decode.d.ts

@@ -0,0 +1,15 @@
+import { HttpBody, HttpRequestWire, HttpResponseWire, OAuthAsk, ServerProgressWire, IoRequestWire, ResolveProgressWire } from '@almadar/core/kernel-wire';
+import { JsonValue } from '@almadar/core';
+
+/** Decoders for what the kernel hands back as JSON: narrowed by checks, never cast. */
+
+declare function decodeHttpBody(value: JsonValue): HttpBody;
+declare function decodeHttpRequest(value: JsonValue): HttpRequestWire;
+declare function decodeHttpResponse(value: JsonValue): HttpResponseWire;
+declare function decodeRequest(value: JsonValue): IoRequestWire;
+declare function decodeProgress(json: string): ServerProgressWire;
+declare function decodeResolveProgress(json: string): ResolveProgressWire;
+/** The driver's `oauth` ask, decoded against the closed ask set before it reaches the host's store. */
+declare function decodeOAuthAsk(value: JsonValue | undefined): OAuthAsk;
+
+export { decodeHttpBody, decodeHttpRequest, decodeHttpResponse, decodeOAuthAsk, decodeProgress, decodeRequest, decodeResolveProgress };

package/dist/kernel/decode.js

@@ -0,0 +1,2 @@
+export { decodeHttpBody, decodeHttpRequest, decodeHttpResponse, decodeOAuthAsk, decodeProgress, decodeRequest, decodeResolveProgress } from '../chunk-RBUMDYFS.js';
+import '../chunk-MLKGABMK.js';

package/dist/kernel/engine.d.ts

@@ -0,0 +1,94 @@
+import { OrbitalSchema, MessageCatalogs, MountSeed, RowSetRef, RowQueryPage, OrbitalEventRequest, OrbitalEventResponse, EventStreamItem, UserContext } from '@almadar/core';
+import { KernelHostPorts, KernelAnswerScope } from './host.js';
+import { KernelModule, KernelServerHandle } from './wire.js';
+import '../effects/in-flight-calls.js';
+import '../service/service-provider.js';
+import './program-effects.js';
+import './http.js';
+import './beacon.js';
+import '../credentials/store.js';
+import './decode.js';
+import '@almadar/core/kernel-wire';
+import './os-port.js';
+
+/**
+ * The kernel-backed implementation of `evaluateOrbitalEvent` / `OrbitalServerRuntime`: the Rust kernel
+ * (`@almadar/kernel`, WebAssembly) decides every execution step; this host answers the I/O it asks for
+ * and nothing else. The continuation of a stopped dispatch never leaves the wasm instance.
+ */
+
+declare class KernelEngine {
+    private readonly kernel;
+    private readonly schemaJson;
+    private readonly ports;
+    private readonly entityTypes;
+    private readonly preserveProgramContext;
+    private handle;
+    private readonly lane;
+    private tickMount;
+    private messages;
+    constructor(kernel: KernelModule, schemaJson: string, ports: KernelHostPorts, entityTypes?: readonly string[], forkedFrom?: KernelServerHandle, providedHandle?: KernelServerHandle, preserveProgramContext?: boolean);
+    /**
+     * A kernel on the same program, registered once, holding none of this one's session: every trait at its initial
+     * state, no rows the kernel held, its locales and mounted ticks kept. A stateless host serves each request a
+     * fork (EXEC-DIST-5), `ports` answering it.
+     */
+    fork(ports?: KernelHostPorts): KernelEngine;
+    forkProgram(program: OrbitalSchema, ports?: KernelHostPorts): KernelEngine;
+    /** A server over the host's ports. */
+    private openServer;
+    private declare;
+    static open(kernel: KernelModule, schema: OrbitalSchema, ports: KernelHostPorts): KernelEngine;
+    /** A fresh kernel on the same program: every trait back at its initial state. */
+    reset(): void;
+    private managedProgram;
+    /** The program whose declared credentials this kernel's credential effects manage beside its own (a console's app). */
+    setManagedProgram(program: OrbitalSchema): void;
+    /** The program's declared locales and merged catalogs (a lazy page's behavior contributes its namespaced keys). */
+    setMessages(locales: readonly string[], catalogs: MessageCatalogs): void;
+    /** The traits some client has mounted: a tick that is not `[background]` fires only for these. */
+    setTickMount(traits: string[]): void;
+    /** What this host mounts when it starts: the kernel's boot mounts for the side it serves (EXEC-ENDPOINT-3). */
+    bootMounts(side: 'server' | 'process'): MountSeed[];
+    /** What mounts when a client opens `routePath` (EXEC-ENDPOINT-3). */
+    routeMounts(routePath: string): MountSeed[];
+    /** Mock-seed the `[runtime]` entities the kernel holds itself, owner columns stamped with `viewerId`. */
+    seedRuntimeMock(viewerId: string | undefined): void;
+    dispose(): void;
+    liveItemDelivered(item: object, viewer: object | null, clientId?: string): boolean;
+    /** `OsGrants::allows` over the grants of the program this kernel runs. */
+    osAllows(requirementJson: string): boolean;
+    /** Place the program's anchored grants and arguments under the host's anchors. */
+    setOsAnchors(anchorsJson: string): string;
+    /** An `os/` call's arguments with its anchored parts resolved under the host's anchors. */
+    osResolveArgs(op: string, argsJson: string): string;
+    /** The current state of a trait instance, `''` when it has none. */
+    stateOf(traitName: string, entityId?: string): string;
+    /**
+     * `reference` resolved for `scope.user` against the host-answered store (EXEC-RENDER-3): the rows that still
+     * match its query and the viewer's `@read` in the reference's order, a missing or hidden row omitted, and `total`
+     * re-counted (a `total: none` reference is not re-counted: the total is the resolved window). Each read the
+     * kernel makes is answered here, as in `evaluate`.
+     */
+    resolveRows(reference: RowSetRef, scope: KernelAnswerScope): Promise<RowQueryPage>;
+    /** Run `request` against `orbital`: start it, answer every request the kernel asks for, resume until done. */
+    evaluate(orbital: string, request: OrbitalEventRequest, scope: KernelAnswerScope): Promise<OrbitalEventResponse>;
+}
+/** What `evaluateOrbitalEvent` needs to run a request on the kernel instead of the JS composition. */
+interface KernelEvaluation {
+    engine: KernelEngine;
+    /** The orbital the request is addressed to. */
+    orbital: string;
+    outsideEventQueue?: <T>(work: () => Promise<T>) => Promise<T>;
+    onStream?: (item: EventStreamItem) => void;
+}
+/**
+ * The request as the kernel takes it: the viewer and locale the host resolved, the `_targetTrait` sidecar
+ * promoted to `targetTrait`, and the `_activeTraits` sidecar dropped (the kernel's mounted set is explicit,
+ * not carried per request).
+ */
+declare function kernelRequest(request: OrbitalEventRequest, user: UserContext | undefined, locale: string | undefined): OrbitalEventRequest;
+declare function evaluateOnKernel(kernel: KernelEvaluation, request: OrbitalEventRequest, user: UserContext | undefined, locale: string | undefined): Promise<OrbitalEventResponse>;
+
+export { KernelEngine, evaluateOnKernel, kernelRequest };
+export type { KernelEvaluation };

package/dist/kernel/engine.js

@@ -0,0 +1,11 @@
+export { KernelEngine, evaluateOnKernel, kernelRequest } from '../chunk-D4XJTBLB.js';
+import '../chunk-NATGCIVM.js';
+import '../chunk-HNOAZWFH.js';
+import '../chunk-53IPZXDP.js';
+import '../chunk-YO4LWS3I.js';
+import '../chunk-MZKIL5IN.js';
+import '../chunk-FWA5K7Q2.js';
+import '../chunk-VMOBW7RK.js';
+import '../chunk-RBUMDYFS.js';
+import '../chunk-HLOUDLPI.js';
+import '../chunk-MLKGABMK.js';

package/dist/kernel/frame-applier.d.ts

@@ -0,0 +1,43 @@
+import { FiredTick, FrameWire, RoutedLeg } from '@almadar/core/kernel-wire';
+import { OrbitalEventResponse, JsonValue } from '@almadar/core';
+import { ClientKernelOutcome, LocalFoldKernel } from '../client/client-kernel.js';
+import '../client/circuit-store.js';
+import '../client/awaiting.js';
+import '../client/state-book.js';
+import '../client/trait-types.js';
+
+/**
+ * Applies one host frame of the tick clock (`Kernel.frame`'s `FrameWire`) to the view. The in-process
+ * kernel already ran the frame, so it folds locally (`LocalFoldKernel`), never through the server fold:
+ * the aggregate response first (embed.rs: "the host folds `response` before the dispatches"; it is built
+ * from the fired ticks' own outcomes, not from the dispatches, so the two are disjoint), then each tick
+ * dispatch. Every post a dispatch owes (its server legs or stateful leg) and every browser-store leg goes
+ * through the injected `FramePostPort`; the answers settle off the frame (`tickSettled`) so a tick round trip
+ * never delays the next frame.
+ */
+
+declare function isFrameWire(value: JsonValue): value is JsonValue & FrameWire;
+/** `frame()`'s JSON; `undefined` (no tick due) decodes to `undefined`. */
+declare function decodeFrame(json: string | undefined): FrameWire | undefined;
+type TickEffects = Pick<OrbitalEventResponse, 'clientEffects' | 'clientEffectsByTrait'>;
+type FrameDispatch = FrameWire['dispatches'][number];
+/** The host transport's side of a frame: posts what a fired tick owes and folds the answer back through the kernel. */
+interface FramePostPort {
+    /** Posts one dispatch's server legs (or stateful leg); resolves to what the server's fold added. */
+    postDispatch(dispatch: FrameDispatch): Promise<TickEffects>;
+    /** Sends a leg the kernel routed to the browser store; `frameResponse` is the frame's aggregate response. */
+    sendBrowserLeg(leg: RoutedLeg, frameResponse: OrbitalEventResponse): Promise<TickEffects>;
+}
+interface FrameApplied {
+    fired: FiredTick[];
+    folded: number;
+    browserLegs: number;
+    droppedServerEffects: number;
+    /** The head is the frame's aggregate response, then one outcome per browser leg, then one per dispatch. */
+    outcomes: ClientKernelOutcome[];
+    errors: string[];
+}
+declare function applyFrame(json: string | undefined, kernel: LocalFoldKernel, post: FramePostPort | undefined): Promise<FrameApplied>;
+
+export { applyFrame, decodeFrame, isFrameWire };
+export type { FrameApplied, FrameDispatch, FramePostPort, TickEffects };

package/dist/kernel/frame-applier.js

@@ -0,0 +1,2 @@
+export { applyFrame, decodeFrame, isFrameWire } from '../chunk-4J2QEIUV.js';
+import '../chunk-MLKGABMK.js';