@open-wa/runtime-core 5.0.0

package/dist/index.d.mts

@@ -0,0 +1,341 @@
+import { Context, Effect, Layer, Schema, Stream } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Rpc } from "effect/unstable/rpc";
+//#region src/errors.d.ts
+declare const RuntimeCapabilityError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RuntimeCapabilityError";
+} & Readonly<A>;
+export declare class RuntimeCapabilityError extends RuntimeCapabilityError_base<{
+  readonly capability: RuntimeCapability;
+  readonly runtime: RuntimeKind;
+  readonly detail: string;
+}> {}
+declare const QueueOverloadedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "QueueOverloadedError";
+} & Readonly<A>;
+export declare class QueueOverloadedError extends QueueOverloadedError_base<{
+  readonly queue: string;
+  readonly capacity: number;
+}> {}
+declare const QueueClosedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "QueueClosedError";
+} & Readonly<A>;
+export declare class QueueClosedError extends QueueClosedError_base<{
+  readonly queue: string;
+}> {}
+declare const TaskTimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "TaskTimeoutError";
+} & Readonly<A>;
+export declare class TaskTimeoutError extends TaskTimeoutError_base<{
+  readonly queue: string;
+  readonly timeoutMs: number;
+}> {}
+declare const TaskExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "TaskExecutionError";
+} & Readonly<A>;
+export declare class TaskExecutionError extends TaskExecutionError_base<{
+  readonly queue: string;
+  readonly cause: unknown;
+}> {}
+declare const StartupGraphError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "StartupGraphError";
+} & Readonly<A>;
+export declare class StartupGraphError extends StartupGraphError_base<{
+  readonly detail: string;
+  readonly nodes: ReadonlyArray<string>;
+}> {}
+declare const SandboxPolicyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SandboxPolicyError";
+} & Readonly<A>;
+export declare class SandboxPolicyError extends SandboxPolicyError_base<{
+  readonly detail: string;
+  readonly field?: string;
+}> {}
+declare const SandboxExecutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SandboxExecutionError";
+} & Readonly<A>;
+export declare class SandboxExecutionError extends SandboxExecutionError_base<{
+  readonly chatId: string;
+  readonly isolation: string;
+  readonly cause: unknown;
+}> {}
+declare const SessionAdmissionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SessionAdmissionError";
+} & Readonly<A>;
+export declare class SessionAdmissionError extends SessionAdmissionError_base<{
+  readonly requestedMemoryMb: number;
+  readonly availableMemoryMb: number;
+}> {}
+export type RuntimeKind = 'node' | 'bun' | 'browser' | 'edge' | 'test';
+export type RuntimeCapability = 'browser-client' | 'chromium-launch' | 'filesystem' | 'process' | 'web-fetch' | 'worker-bindings';
+//#endregion
+//#region src/effect-spikes.d.ts
+export declare const RuntimeHealthSchema: Schema.Struct<{
+  readonly sessionId: Schema.String;
+  readonly state: Schema.Literals<readonly ["STARTING", "AUTHENTICATING", "READY", "DISCONNECTED", "STOPPED"]>;
+  readonly ready: Schema.Boolean;
+}>;
+export declare const RuntimeEventSchema: Schema.Struct<{
+  readonly event: Schema.String;
+  readonly sessionId: Schema.String;
+  readonly timestamp: Schema.Number;
+  readonly payload: Schema.Unknown;
+}>;
+export declare const OpenWaHttpApi: HttpApi.HttpApi<"openwa", HttpApiGroup.HttpApiGroup<"runtime", HttpApiEndpoint.HttpApiEndpoint<"health", "GET", "/health", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly sessionId: Schema.String;
+  readonly state: Schema.Literals<readonly ["STARTING", "AUTHENTICATING", "READY", "DISCONNECTED", "STOPPED"]>;
+  readonly ready: Schema.Boolean;
+}>>, never, never, never>, false>>;
+export declare const OpenWaAskRpc: Rpc.Rpc<"openwa.ask", Schema.Struct<{
+  method: Schema.String;
+  args: Schema.$Array<Schema.Unknown>;
+}>, Schema.Unknown, Schema.Never, never, never>;
+export declare const decodeRuntimeEvent: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<Schema.Struct.ReadonlySide<{
+  readonly event: Schema.String;
+  readonly sessionId: Schema.String;
+  readonly timestamp: Schema.Number;
+  readonly payload: Schema.Unknown;
+}, "Type">, Schema.SchemaError, never>;
+export declare const makeBoundedEventPipeline: <A>(capacity: number) => Effect.Effect<{
+  readonly publish: (event: A) => Effect.Effect<boolean, never, never>;
+  readonly events: Stream.Stream<A, never, never>;
+  readonly shutdown: Effect.Effect<void, never, never>;
+}, never, never>;
+//#endregion
+//#region src/services.d.ts
+export interface RuntimeCapabilitiesShape {
+  readonly runtime: RuntimeKind;
+  readonly supported: ReadonlySet<RuntimeCapability>;
+  readonly has: (capability: RuntimeCapability) => boolean;
+  readonly require: (capability: RuntimeCapability) => Effect.Effect<void, RuntimeCapabilityError>;
+}
+export declare const RuntimeCapabilities: Context.Service<RuntimeCapabilitiesShape, RuntimeCapabilitiesShape>;
+export interface BrowserDriverShape {
+  readonly launch: (options?: unknown) => Effect.Effect<unknown, unknown>;
+}
+export declare const BrowserDriver: Context.Service<BrowserDriverShape, BrowserDriverShape>;
+export interface BrowserSessionShape {
+  readonly page: unknown;
+  readonly close: Effect.Effect<void>;
+}
+export declare const BrowserSession: Context.Service<BrowserSessionShape, BrowserSessionShape>;
+export interface PatchSourceShape<Artifact = unknown> {
+  readonly preload: Effect.Effect<Artifact, unknown>;
+}
+export declare const PatchSource: Context.Service<PatchSourceShape<unknown>, PatchSourceShape<unknown>>;
+export interface LicenseServiceShape<Artifact = unknown, Identity = unknown> {
+  readonly preflight: Effect.Effect<Artifact | null, unknown>;
+  readonly validate: (identity: Identity, artifact: Artifact | null) => Effect.Effect<Artifact | null, unknown>;
+}
+export declare const LicenseService: Context.Service<LicenseServiceShape<unknown, unknown>, LicenseServiceShape<unknown, unknown>>;
+export interface SessionStoreShape {
+  readonly get: (key: string) => Effect.Effect<unknown, unknown>;
+  readonly set: (key: string, value: unknown) => Effect.Effect<void, unknown>;
+  readonly remove: (key: string) => Effect.Effect<void, unknown>;
+}
+export declare const SessionStore: Context.Service<SessionStoreShape, SessionStoreShape>;
+export interface PluginRegistryShape {
+  readonly names: Effect.Effect<ReadonlyArray<string>>;
+  readonly close: Effect.Effect<void>;
+}
+export declare const PluginRegistry: Context.Service<PluginRegistryShape, PluginRegistryShape>;
+export interface ChatExecutorShape {
+  readonly execute: (chatId: string, source: string, input?: unknown) => Effect.Effect<unknown, unknown>;
+  readonly closeChat: (chatId: string) => Effect.Effect<void>;
+}
+export declare const ChatExecutor: Context.Service<ChatExecutorShape, ChatExecutorShape>;
+export interface SessionAdmissionLease {
+  readonly memoryMb: number;
+  readonly release: Effect.Effect<void>;
+}
+export interface SessionAdmissionShape {
+  readonly acquire: (memoryMb: number) => Effect.Effect<SessionAdmissionLease, SessionAdmissionError>;
+  readonly snapshot: Effect.Effect<{
+    readonly capacityMemoryMb: number;
+    readonly availableMemoryMb: number;
+    readonly activeSessions: number;
+  }>;
+}
+export declare const SessionAdmission: Context.Service<SessionAdmissionShape, SessionAdmissionShape>;
+export interface RuntimeObservabilityShape {
+  readonly increment: (metric: RuntimeMetric, value?: number, attributes?: Readonly<Record<string, string | number | boolean>>) => Effect.Effect<void>;
+  readonly gauge: (metric: RuntimeMetric, value: number, attributes?: Readonly<Record<string, string | number | boolean>>) => Effect.Effect<void>;
+  readonly snapshot: Effect.Effect<Readonly<Record<string, number>>>;
+  readonly recordCause: (scope: string, cause: unknown, attributes?: Readonly<Record<string, string | number | boolean>>) => Effect.Effect<void>;
+  readonly causes: Effect.Effect<ReadonlyArray<RuntimeCauseRecord>>;
+}
+export interface SerializedRuntimeCause {
+  readonly name: string;
+  readonly message: string;
+  readonly stack?: string;
+  readonly cause?: SerializedRuntimeCause;
+  readonly errors?: ReadonlyArray<SerializedRuntimeCause>;
+}
+export interface RuntimeCauseRecord {
+  readonly scope: string;
+  readonly recordedAt: number;
+  readonly attributes?: Readonly<Record<string, string | number | boolean>>;
+  readonly cause: SerializedRuntimeCause;
+}
+export type RuntimeMetric = 'active_fibers' | 'cause_failures' | 'queue_active' | 'queue_depth' | 'queue_drops' | 'queue_failures' | 'rate_decisions' | 'retry_decisions' | 'session_browser_memory_mb' | 'startup_phase_ms' | 'startup_critical_path_ms';
+export declare const RuntimeObservability: Context.Service<RuntimeObservabilityShape, RuntimeObservabilityShape>;
+export declare const serviceLayer: <I, S>(key: Context.Key<I, S>, service: S) => Layer.Layer<I, never, never>;
+//#endregion
+//#region src/observability.d.ts
+export declare const makeInMemoryObservability: () => RuntimeObservabilityShape;
+export declare const InMemoryObservabilityLayer: Layer.Layer<RuntimeObservabilityShape, never, never>;
+export declare const queueMetricsObserver: (observability: RuntimeObservabilityShape) => (metrics: {
+  readonly name: string;
+  readonly depth: number;
+  readonly active: number;
+  readonly dropped: number;
+  readonly failed: number;
+  readonly rateLimited: number;
+}) => void;
+//#endregion
+//#region src/runtime-capabilities.d.ts
+export declare const makeRuntimeCapabilities: (runtime: RuntimeKind, capabilities: Iterable<RuntimeCapability>) => RuntimeCapabilitiesShape;
+export declare const runtimeCapabilitiesLayer: (runtime: RuntimeKind, capabilities: Iterable<RuntimeCapability>) => Layer.Layer<RuntimeCapabilitiesShape, never, never>;
+//#endregion
+//#region src/sandbox.d.ts
+export type SandboxIsolation = 'worker' | 'process' | 'container';
+export interface ChatSandboxPolicy {
+  readonly chats: boolean;
+  readonly isolation: SandboxIsolation;
+  readonly timeoutMs: number;
+  readonly idleTimeoutMs: number;
+  readonly memoryMb: number;
+  readonly concurrency: number;
+  readonly filesystem: 'none' | 'read-only' | 'workspace';
+  readonly network: 'none' | 'allowlist';
+  readonly networkAllowlist: ReadonlyArray<string>;
+  readonly env: 'none' | ReadonlyArray<string>;
+  readonly capabilities: ReadonlyArray<string>;
+}
+export declare const defaultChatSandboxPolicy: ChatSandboxPolicy;
+export type SandboxCapabilityHandler = (...args: ReadonlyArray<unknown>) => unknown | Promise<unknown>;
+export type SandboxCapabilityHandlers = Readonly<Record<string, SandboxCapabilityHandler>>;
+export interface SandboxRequest {
+  readonly chatId: string;
+  readonly source: string;
+  readonly input?: unknown;
+  readonly policy: ChatSandboxPolicy;
+  /** Parent-owned capability implementations. Functions never enter the sandbox. */
+  readonly capabilityHandlers?: SandboxCapabilityHandlers;
+}
+export interface ExecutionSandboxShape {
+  readonly execute: (request: SandboxRequest) => Effect.Effect<unknown, SandboxExecutionError>;
+  readonly closeChat: (chatId: string) => Effect.Effect<void>;
+  readonly close: Effect.Effect<void>;
+}
+export declare const ExecutionSandbox: Context.Service<ExecutionSandboxShape, ExecutionSandboxShape>;
+/** Cause capture only. This function does not provide a security boundary. */
+export declare const captureSandboxCause: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, import("effect/Cause").Cause<E>, R>;
+//#endregion
+//#region src/scoped-task-queue.d.ts
+export type QueueOverloadStrategy = 'backpressure' | 'dropping';
+export interface QueueRateLimit {
+  readonly limit: number;
+  readonly intervalMs: number;
+}
+export interface TaskQueuePolicy {
+  readonly name: string;
+  readonly capacity: number;
+  readonly concurrency: number;
+  readonly overload: QueueOverloadStrategy;
+  readonly ordering: 'fifo';
+  readonly timeoutMs?: number;
+  readonly rate?: QueueRateLimit;
+  readonly observe?: (metrics: TaskQueueMetrics) => void;
+}
+export interface TaskQueueMetrics {
+  readonly name: string;
+  readonly capacity: number;
+  readonly depth: number;
+  readonly active: number;
+  readonly completed: number;
+  readonly failed: number;
+  readonly dropped: number;
+  readonly rateLimited: number;
+  readonly closed: boolean;
+}
+export declare class ScopedTaskQueue {
+  readonly policy: TaskQueuePolicy;
+  private readonly queue;
+  private readonly scope;
+  private readonly activeTasks;
+  private readonly metricsState;
+  private rateWindowStartedAt;
+  private rateWindowCount;
+  private constructor();
+  static make(policy: Omit<TaskQueuePolicy, 'ordering'> & {
+    readonly ordering?: 'fifo';
+  }): Promise<ScopedTaskQueue>;
+  submit<A>(operation: () => Promise<A> | A, label?: string): Promise<A>;
+  metrics(): TaskQueueMetrics;
+  close(): Promise<void>;
+  waitForIdle(): Promise<void>;
+  private worker;
+  private reserveRatePermit;
+  private notifyObserver;
+}
+//#endregion
+//#region src/session-admission.d.ts
+export interface SessionAdmissionOptions {
+  readonly memoryCapacityMb: number;
+  readonly maxConcurrentLaunches: number;
+  readonly observability?: RuntimeObservabilityShape;
+}
+export declare const makeSessionAdmission: (options: SessionAdmissionOptions) => Effect.Effect<SessionAdmissionShape>;
+export declare const sessionAdmissionLayer: (options: SessionAdmissionOptions) => Layer.Layer<SessionAdmissionShape, never, never>;
+//#endregion
+//#region src/session-scope.d.ts
+export type SessionFinalizerReason = 'auth-timeout' | 'browser-crash' | 'failure' | 'interruption' | 'normal-stop' | 'plugin-failure' | 'signal' | 'startup-failure';
+export declare class SessionScope {
+  private readonly scope;
+  private readonly observability?;
+  private readonly metricAttributes;
+  private readonly finalizerNames;
+  private closed;
+  private activeFibers;
+  private constructor();
+  static make(options?: {
+    readonly observability?: RuntimeObservabilityShape;
+    readonly metricAttributes?: Readonly<Record<string, string | number | boolean>>;
+  }): Promise<SessionScope>;
+  addFinalizer(name: string, finalizer: () => void | Promise<void>): Promise<() => void>;
+  snapshot(): {
+    readonly closed: boolean;
+    readonly finalizers: readonly string[];
+  };
+  fork<A, E>(effect: Effect.Effect<A, E>): Promise<void>;
+  close(reason?: SessionFinalizerReason): Promise<void>;
+  private publishActiveFibers;
+}
+//#endregion
+//#region src/startup-graph.d.ts
+export interface StartupNode<A = unknown> {
+  readonly id: string;
+  readonly dependsOn?: ReadonlyArray<string>;
+  readonly optional?: boolean;
+  readonly run: (completed: ReadonlyMap<string, unknown>) => Effect.Effect<A, unknown>;
+}
+export interface StartupNodeResult {
+  readonly id: string;
+  readonly durationMs: number;
+  readonly optional: boolean;
+  readonly result: unknown;
+}
+export interface StartupGraphResult {
+  readonly values: ReadonlyMap<string, unknown>;
+  readonly phases: ReadonlyArray<StartupNodeResult>;
+  readonly criticalPathMs: number;
+}
+export declare const validateStartupGraph: (nodes: ReadonlyArray<StartupNode>) => Effect.Effect<void, StartupGraphError>;
+export declare const runStartupGraph: (nodes: ReadonlyArray<StartupNode>, options?: {
+  readonly concurrency?: number;
+  readonly onPhase?: (phase: StartupNodeResult) => void;
+  readonly onComplete?: (result: StartupGraphResult) => void;
+}) => Effect.Effect<StartupGraphResult, unknown>;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/effect-spikes.ts","../src/services.ts","../src/observability.ts","../src/runtime-capabilities.ts","../src/sandbox.ts","../src/scoped-task-queue.ts","../src/session-admission.ts","../src/session-scope.ts","../src/startup-graph.ts"],"mappings":"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"}