@effect-agent/platform-cloudflare 0.1.0-beta.45 → 0.1.0-beta.46

package/dist/ThreadObject-Ia94R_B1.d.mts

@@ -0,0 +1,735 @@
+import { DurableObjectContext, ThreadObjectIdentity, ThreadObjectNamespace } from "./CloudflareBindings.mjs";
+import { c as CloudflarePlatformConfigError, o as CloudflareDurableRuntimeConfig } from "./CloudflareConfig-f3CqTel1.mjs";
+import { DurableAlarmError, DurableAlarmService, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler } from "./Alarm.mjs";
+import { HostProtocolError } from "./CloudflareThreadClient.mjs";
+import { AgentRegistration } from "@effect-agent/thread/AgentRegistration";
+import { DurableAgentRuntime, DurableRuntimeConfig, RecoveryReport } from "@effect-agent/thread/DurableAgentRuntime";
+import { LedgerError, OwnershipLost, SettlementConflict, SubmissionLedger } from "@effect-agent/thread/SubmissionLedger";
+import { Context, Crypto, Effect, Layer, Schema, Scope } from "effect";
+import { DurableObject, DurableObjectState as DurableObjectState$1, WorkerEnvironment } from "effect-cf";
+import { DigestError } from "@effect-agent/thread/Digest";
+import { DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler } from "@effect-agent/thread/DurableFailpoint";
+import { OperationAuthorizerService, OperationDenied } from "@effect-agent/thread/OperationAuthorizer";
+import { AppendConflict, FenceRejected, ThreadNotMaterialized, ThreadStore, ThreadStoreError } from "@effect-agent/thread/ThreadStore";
+import { PortRequest, PortResponse } from "@effect-agent/storage-cloudflare/PortProtocol";
+import { IntegrityReport, ObligationReport, ObligationThresholds, RecoveryExplanation, RetryCommand, RetryRefused } from "@effect-agent/thread/Admin";
+import { RunJournalError } from "@effect-agent/thread/RunJournal";
+import { WakeScheduler } from "@effect-agent/thread/WakeScheduler";
+import { RunContextPreparation, RunCostEstimator, RunToolAuthorization, RunToolFailureObserver } from "@effect-agent/engine/RunOptions";
+import { DoStorageFailpoint, DoStorageFailpointHandler } from "@effect-agent/storage-cloudflare/DoStorageFailpoint";
+import { DoStorageInitializationError } from "@effect-agent/storage-cloudflare/DoThreadStore";
+import { ToolReconciler } from "@effect-agent/thread/ToolReconciler";
+//#region src/internal/progress-wait.d.ts
+declare const ProgressWaitRegistry_base: Context.ServiceClass<ProgressWaitRegistry, "@effect-agent/platform-cloudflare/ProgressWaitRegistry", {
+  /** Register a Scope-owned cancellation signal, observing any early cancel tombstone. */
+  readonly subscribe: (waiterId: string) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;
+  /** Cancel a registered waiter, or remember a bounded early cancellation. */
+  readonly cancel: (waiterId: string) => Effect.Effect<void>;
+}>;
+/**
+ * Per-incarnation cancellation registry for long-lived progress RPCs. The public runtime owns
+ * the actual wake registration; this host-only registry lets an interrupted Worker Effect ask
+ * the Object to interrupt its scoped wait before the Worker execution context itself ends.
+ */
+declare class ProgressWaitRegistry extends ProgressWaitRegistry_base {
+  static readonly layer: Layer.Layer<ProgressWaitRegistry>;
+}
+//#endregion
+//#region src/internal/layers.d.ts
+/**
+ * Raw (unvalidated) construction options for `ThreadObject.make`, mirroring
+ * `NodeDurableAgentRuntimeOptions`. Optional fields default to the documented production values
+ * (`CLOUDFLARE_RUNTIME_DEFAULTS`); everything is schema-decoded into
+ * `CloudflareDurableRuntimeConfigValue` before any resource opens (deployment §5 gate 1).
+ */
+interface CloudflareDurableRuntimeOptions {
+  readonly deploymentId: string;
+  /** Head of the minted producer identity `{producerPrefix}:{threadId}`. */
+  readonly producerPrefix: string;
+  /** Milliseconds; default 30s (D5). */
+  readonly ownershipLeaseDuration?: number | undefined;
+  /** Milliseconds; default 100. */
+  readonly alarmBackoffBase?: number | undefined;
+  /** Milliseconds; default 5000. */
+  readonly alarmBackoffCap?: number | undefined;
+  /** Milliseconds; default 1000. Bounds every alarm re-arm delay. */
+  readonly wakeScanInterval?: number | undefined;
+  /** Milliseconds; default 500. */
+  readonly settlementPollInterval?: number | undefined;
+  /** Milliseconds; default 10000. */
+  readonly leaseRenewalInterval?: number | undefined;
+  /** Milliseconds; default 500. */
+  readonly abortPollInterval?: number | undefined;
+  /** Deployment-owned pricing authority used by durable cost budgets and settlements. */
+  readonly estimateCostMicrousd?: RunCostEstimator | undefined;
+  /** Closed trusted Tool failure reporting. Omission masks ambient observers at construction. */
+  readonly toolFailureObserver?: RunToolFailureObserver | undefined;
+  /** Milliseconds; default 25. */
+  readonly observationPollInterval?: number | undefined;
+  /** Bytes; default just under the 2 MB platform value limit. */
+  readonly maxStoredValueBytes?: number | undefined;
+  /** Default false. */
+  readonly verifyOnOpen?: boolean | undefined;
+  /** Nonterminal Submissions per lane before admission refuses; default 256. */
+  readonly maxQueueDepthPerLane?: number | undefined;
+  /** Encoded input bytes per Submission; default = the stored-value bound. */
+  readonly maxInputBytes?: number | undefined;
+  /** `ctx.storage.sql.databaseSize` ceiling at admission; default 9 GB (10 GB platform cap). */
+  readonly maxDatabaseBytes?: number | undefined;
+  /**
+   * Durable Object storage fault injection (`ledger:*` / `append:*` locations). Handlers are
+   * constructed per incarnation WITH the live `DurableObjectState`, so eviction harnesses can
+   * map an armed hit to `ctx.abort()` — the platform's real failure mode. Default none.
+   */
+  readonly storageFailpoint?: ((ctx: DurableObjectState) => DoStorageFailpointHandler) | undefined;
+  /** Coordinator fault injection (`submit:*` / `terminalize:*` locations); default none. */
+  readonly runtimeFailpoint?: ((ctx: DurableObjectState) => DurableRuntimeFailpointHandler) | undefined;
+  /** Thread-maintenance generation/alarm fault injection; default none. */
+  readonly maintenanceFailpoint?: ((ctx: DurableObjectState) => ThreadMaintenanceFailpointHandler) | undefined;
+  /** Host-supplied fail-closed authorization policy; defaults to service possession. */
+  readonly operationAuthorizer?: OperationAuthorizerService | undefined;
+  /**
+   * Reconciliation policy consulted for open ordinary Tool Calls before an Unknown Outcome
+   * is recorded (durability §10, DUR-009). Defaults to the fail-closed
+   * `ToolReconciler.uncertain`.
+   */
+  readonly toolReconciler?: Layer.Layer<ToolReconciler> | undefined;
+}
+/** Services supplied before the application graph is built, including its dependencies. */
+type CloudflareBootstrapServices = CloudflareDurableRuntimeConfig | ThreadObjectIdentity | DurableRuntimeConfig | Crypto.Crypto | DoStorageFailpoint | DurableRuntimeFailpoint | ThreadMaintenanceFailpoint | RunContextPreparation | RunToolAuthorization | ToolReconciler;
+/** Every construction failure of the assembled Cloudflare durable runtime stack. */
+type CloudflareDurableRuntimeInitializationError = CloudflarePlatformConfigError | DigestError | DoStorageInitializationError;
+/** The services `ThreadObject.layer` provides. */
+type CloudflareDurableRuntimeServices = DurableAgentRuntime | SubmissionLedger | ThreadStore | WakeScheduler | DurableAlarmService | ThreadMaintenance | ThreadObjectPorts | ProgressWaitRegistry;
+declare const ThreadObjectPorts_base: Context.ServiceClass<ThreadObjectPorts, "@effect-agent/platform-cloudflare/ThreadObjectPorts", {
+  readonly handle: (request: PortRequest) => Effect.Effect<PortResponse>;
+}>;
+/**
+ * Owner-side execution port for a `portCall` request the wire endpoint has already decoded.
+ * It executes against THIS Object's LOCAL port facets — never the routed decorators, so a
+ * request cannot bounce between Objects — and returns the typed response for the endpoint to
+ * encode.
+ */
+declare class ThreadObjectPorts extends ThreadObjectPorts_base {}
+/**
+ * Validate deployment settings and derive services before building application dependencies.
+ * The native class factory builds this Layer inside its constructor gate. Custom Effect hosts
+ * can provide it around the complete application Layer with the native context already supplied.
+ */
+declare const layerConfig: (options: CloudflareDurableRuntimeOptions) => Layer.Layer<CloudflareBootstrapServices, CloudflarePlatformConfigError, DurableObjectContext>;
+/**
+ * Register typed Agents and version declarations. Hashing and dependency capture happen in
+ * this Layer's Scope, after application Layers have been provided. Every Agent's instruction,
+ * Tool, Schema, and model requirements remain visible until satisfied by Layer composition.
+ * Use Layer.unwrap for registration values that need effectful application setup.
+ */
+declare const layer: <const Entries extends ReadonlyArray<AgentRegistration>>(registrations: Entries) => Layer.Layer<CloudflareDurableRuntimeServices, DigestError | DoStorageInitializationError, DurableObjectContext | ThreadObjectNamespace | Exclude<[Entries[number]] extends [never] ? never : Entries[number] extends (infer T) ? T extends Entries[number] ? T extends {
+  readonly attemptLayer: (context: import("@effect-agent/thread/AgentRegistration").AgentAttemptContext) => Layer.Layer<infer Provides, never, infer Requires>;
+} ? Requires | Exclude<T extends (infer T_1) ? T_1 extends T ? T_1 extends {
+  readonly agent: infer A extends import("@effect-agent/thread/AgentRegistration").ExecutableAgentBinding;
+} ? import("@effect-agent/thread/DurableAgentRuntime").DurableWorkerRequirements<A> : T_1 extends {
+  readonly agent: infer D extends import("@effect-agent/core/Agent").Definition<Schema.Top, Schema.Top, unknown, import("effect/unstable/ai/Toolkit").Any, import("@effect-agent/core/Agent").RunDispositionDeclaration<never, Schema.Top> | undefined, unknown> & {
+    readonly instructions: import("@effect-agent/core/Agent").InstructionSource<never, unknown, unknown>;
+    readonly inputPrompt?: import("@effect-agent/core/Agent").InputPromptSource<never, unknown, unknown> | undefined;
+  };
+  readonly model: infer M extends import("@effect-agent/thread/AgentRegistration").ExecutableAgentBinding["model"];
+} ? import("@effect-agent/thread/DurableAgentRuntime").DurableWorkerRequirements<{
+  readonly definition: D;
+  readonly model: M;
+}> : never : never : never, Provides> : T extends {
+  readonly agent: infer A extends import("@effect-agent/thread/AgentRegistration").ExecutableAgentBinding;
+} ? import("@effect-agent/thread/DurableAgentRuntime").DurableWorkerRequirements<A> : T extends {
+  readonly agent: infer D extends import("@effect-agent/core/Agent").Definition<Schema.Top, Schema.Top, unknown, import("effect/unstable/ai/Toolkit").Any, import("@effect-agent/core/Agent").RunDispositionDeclaration<never, Schema.Top> | undefined, unknown> & {
+    readonly instructions: import("@effect-agent/core/Agent").InstructionSource<never, unknown, unknown>;
+    readonly inputPrompt?: import("@effect-agent/core/Agent").InputPromptSource<never, unknown, unknown> | undefined;
+  };
+  readonly model: infer M extends import("@effect-agent/thread/AgentRegistration").ExecutableAgentBinding["model"];
+} ? import("@effect-agent/thread/DurableAgentRuntime").DurableWorkerRequirements<{
+  readonly definition: D;
+  readonly model: M;
+}> : never : never : never, import("effect/Scope").Scope> | CloudflareBootstrapServices>;
+declare namespace ThreadObject_d_exports {
+  export { AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, CloudflareBootstrapServices as BootstrapServices, Class, ExplainedRecovery, CloudflareDurableRuntimeInitializationError as InitializationError, Instance, ObligationsScanned, Options, RetryExecuted, CloudflareDurableRuntimeOptions as RuntimeOptions, CloudflareDurableRuntimeServices as Services, VerifiedIntegrity, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeObligationThresholds, decodeRetryCommand, encodeAdminResponse, layer, layerConfig, make };
+}
+/**
+ * `ThreadObject.make(application, options)` — the Thread Durable Object
+ * (plan §1.4,
+ * D-P6-1): a factory returning a class that applications export from their Worker entry.
+ * One SQLite-backed Object per Thread is the serialized owner (durability §6); the
+ * Object never runs `runResolvedWorker`'s infinite loop — each ingress event or alarm runs
+ * ONE bounded `runRecovery` + `processThreadResolved` pass, and the persisted alarm
+ * (the single multiplexed slot, D-P6-2) finishes accepted work across evictions WITHOUT any
+ * incoming request.
+ *
+ * Constructor gate (`blockConcurrencyWhile`) is LOCAL-ONLY: schema migration and the
+ * exact-version check, configuration decode, and the defensive ensure-alarm half of the
+ * alarm invariant. It deliberately does NOT run the recovery pass: parent recovery can
+ * require child-Object reads and vice versa, and two Objects blocked in constructor gates
+ * awaiting each other's RPC would deadlock (plan §1.4). Instead every pass runs
+ * `runRecovery` BEFORE any claim, so reconciliation still strictly precedes new work.
+ */
+/** Construction options for one deployed Thread Object class. */
+interface Options<ApplicationServices = never, EventServices = never, EventLayerError = never> extends CloudflareDurableRuntimeOptions {
+  /** Accept transient native RPC tracing through effect-cf; disabled by default. */
+  readonly rpcTracing?: boolean;
+  /**
+   * Name of the Worker `env` binding carrying THIS class's `DurableObjectNamespace` — the
+   * Object's route back to sibling Thread Objects for the WP2 cross-Object port calls
+   * and remote wakes (DEPLOY-010: the binding enters through a Layer, never ambiently).
+   */
+  readonly namespaceBinding: string;
+  /** Acquired and finalized per native event, with access to the complete application runtime. */
+  readonly eventLayer?: Layer.Layer<EventServices, EventLayerError, RuntimeServices | ApplicationServices | DurableObjectState$1.DurableObjectState | WorkerEnvironment>;
+}
+type EndpointServices = CloudflareDurableRuntimeServices | CloudflareBootstrapServices | DurableObjectContext;
+type RuntimeServices = EndpointServices | ThreadObjectNamespace;
+declare const AdminExplainRequest_base: Schema.Class<AdminExplainRequest, Schema.Struct<{
+  readonly submissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+}>, {}>;
+/** Explain one Submission (`submissionId` present) or every nonterminal lane member. */
+declare class AdminExplainRequest extends AdminExplainRequest_base {}
+declare const AdminVerifyRequest_base: Schema.Class<AdminVerifyRequest, Schema.Struct<{}>, {}>;
+/** Verify carries no parameters — the addressed Object IS the lane. */
+declare class AdminVerifyRequest extends AdminVerifyRequest_base {}
+/** Every typed failure of the four admin entry points, plus the protocol's own errors. */
+declare const AdminFailure: Schema.Union<readonly [typeof OperationDenied, typeof RetryRefused, typeof LedgerError, typeof RunJournalError, typeof DigestError, typeof OwnershipLost, typeof SettlementConflict, typeof ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof FenceRejected, typeof DurableRuntimeFailpointError, typeof DurableAlarmError, typeof HostProtocolError]>;
+type AdminFailure = typeof AdminFailure.Type;
+declare const ExplainedRecovery_base: Schema.Class<ExplainedRecovery, Schema.TaggedStruct<"ExplainedRecovery", {
+  readonly explanations: Schema.$Array<typeof RecoveryExplanation>;
+}>, {}>;
+declare class ExplainedRecovery extends ExplainedRecovery_base {}
+declare const VerifiedIntegrity_base: Schema.Class<VerifiedIntegrity, Schema.TaggedStruct<"VerifiedIntegrity", {
+  readonly report: typeof IntegrityReport;
+}>, {}>;
+declare class VerifiedIntegrity extends VerifiedIntegrity_base {}
+declare const RetryExecuted_base: Schema.Class<RetryExecuted, Schema.TaggedStruct<"RetryExecuted", {
+  readonly report: typeof RecoveryReport;
+}>, {}>;
+declare class RetryExecuted extends RetryExecuted_base {}
+declare const ObligationsScanned_base: Schema.Class<ObligationsScanned, Schema.TaggedStruct<"ObligationsScanned", {
+  readonly report: typeof ObligationReport;
+}>, {}>;
+declare class ObligationsScanned extends ObligationsScanned_base {}
+declare const AdminFailed_base: Schema.Class<AdminFailed, Schema.TaggedStruct<"AdminFailed", {
+  readonly failure: Schema.Union<readonly [typeof OperationDenied, typeof RetryRefused, typeof LedgerError, typeof RunJournalError, typeof DigestError, typeof OwnershipLost, typeof SettlementConflict, typeof ThreadStoreError, typeof ThreadNotMaterialized, typeof AppendConflict, typeof FenceRejected, typeof DurableRuntimeFailpointError, typeof DurableAlarmError, typeof HostProtocolError]>;
+}>, {}>;
+/** The admin entry point failed TYPED on the Object; the failure re-decodes verbatim. */
+declare class AdminFailed extends AdminFailed_base {}
+/** The uniform answer of one admin entry point. Callers narrow by the tag their call implies. */
+declare const AdminResponse: Schema.Union<readonly [typeof ExplainedRecovery, typeof VerifiedIntegrity, typeof RetryExecuted, typeof ObligationsScanned, typeof AdminFailed]>;
+type AdminResponse = typeof AdminResponse.Type;
+declare const decodeAdminExplainRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AdminExplainRequest, Schema.SchemaError, never>;
+declare const decodeAdminVerifyRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AdminVerifyRequest, Schema.SchemaError, never>;
+declare const decodeRetryCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<RetryCommand, Schema.SchemaError, never>;
+declare const decodeObligationThresholds: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<ObligationThresholds, Schema.SchemaError, never>;
+declare const encodeAdminResponse: (input: AdminFailed | ExplainedRecovery | ObligationsScanned | RetryExecuted | VerifiedIntegrity, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly _tag: "ExplainedRecovery";
+  readonly explanations: readonly {
+    readonly submission: {
+      readonly submissionId: string;
+      readonly threadId: string;
+      readonly state: "admitted" | "input-applied" | "joined" | "joining" | "ready" | "running" | "settled" | "suspended" | "terminalizing" | "unknown";
+      readonly queueSequence: number;
+      readonly createdAt: string;
+      readonly readyAt?: string | undefined;
+      readonly ageSeconds: number;
+      readonly readyAgeSeconds?: number | undefined;
+      readonly parentLinkage?: {
+        readonly parentSubmissionId: string;
+        readonly parentToolCallId: string;
+      } | undefined;
+    };
+    readonly evidence: {
+      readonly threadMaterialized: boolean;
+      readonly inputRecorded: boolean;
+      readonly abortRecorded: boolean;
+      readonly recordedSettlementOutcome?: "aborted" | "completed" | "failed" | undefined;
+      readonly openToolCalls: readonly {
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly turn: number;
+      }[];
+      readonly openDelegationCalls: readonly {
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly turn: number;
+        readonly requested: boolean;
+        readonly started: boolean;
+        readonly joined: boolean;
+        readonly childThreadId?: string | undefined;
+        readonly childSubmissionId?: string | undefined;
+        readonly admission?: "admitted" | "indeterminate" | "not-admitted" | undefined;
+      }[];
+      readonly approvalsPending: readonly {
+        readonly toolCallId: string;
+        readonly turn: number;
+      }[];
+      readonly unknownCalls: readonly {
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly reason: string;
+        readonly recordedAt: string;
+        readonly resolved: boolean;
+      }[];
+      readonly approvalDecisions: readonly {
+        readonly submissionId: string;
+        readonly toolCallId: string;
+        readonly decision: "approved" | "denied";
+        readonly resolver: string;
+        readonly reason: string;
+        readonly decidedAt: string;
+        readonly canonicalRecordId?: string | undefined;
+      }[];
+      readonly unknownResolutions: readonly {
+        readonly submissionId: string;
+        readonly toolCallId: string;
+        readonly author: string;
+        readonly reason: string;
+        readonly resolution: {
+          readonly _tag: "SafeToRetry";
+        } | {
+          readonly _tag: "CompletedWithResult";
+          readonly result: Schema.Json;
+          readonly isFailure: boolean;
+        } | {
+          readonly _tag: "NeverHappened";
+        } | {
+          readonly _tag: "AbortSubmission";
+        };
+        readonly resolvedAt: string;
+        readonly canonicalRecordId?: string | undefined;
+      }[];
+      readonly childAttachments: readonly {
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+        readonly childState: "admitted" | "input-applied" | "joined" | "joining" | "ready" | "running" | "settled" | "suspended" | "terminalizing" | "unknown";
+        readonly childOutcome?: "aborted" | "completed" | "failed" | undefined;
+      }[];
+      readonly joins: readonly {
+        readonly submissionId: string;
+        readonly state: "admitted" | "input-applied" | "joined" | "joining" | "ready" | "running" | "settled" | "suspended" | "terminalizing" | "unknown";
+        readonly hostSubmissionId: string;
+      }[];
+      readonly hostSubmissionId?: string | undefined;
+      readonly suspension?: {
+        readonly reason: {
+          readonly _tag: "ApprovalPending";
+          readonly toolCallIds: readonly [string, ...string[]];
+        } | {
+          readonly _tag: "WaitingForChild";
+          readonly children: readonly [{
+            readonly toolCallId: string;
+            readonly childSubmissionId: string;
+          }, ...{
+            readonly toolCallId: string;
+            readonly childSubmissionId: string;
+          }[]];
+        };
+        readonly suspendedAt: string;
+      } | undefined;
+      readonly abortIntent?: {
+        readonly submissionId: string;
+        readonly author: string;
+        readonly reason: string;
+        readonly requestedAt: string;
+        readonly canonicalRecordId?: string | undefined;
+      } | undefined;
+    };
+    readonly decision: {
+      readonly _tag: "CompleteMaterialization";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RepairReadiness";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ApplyInput";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RepairInputMarker";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ResumeFromTurnBoundary";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "AppendReservedSettlement";
+      readonly submissionId: string;
+      readonly settlementId: string;
+      readonly outcome: "aborted" | "completed" | "failed";
+    } | {
+      readonly _tag: "FinalizeLedgerFromHistory";
+      readonly submissionId: string;
+      readonly settlementId: string;
+      readonly outcome: "aborted" | "completed" | "failed";
+    } | {
+      readonly _tag: "SettleAborted";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "MarkUnknown";
+      readonly submissionId: string;
+      readonly reason: string;
+      readonly openToolCallIds: readonly string[];
+    } | {
+      readonly _tag: "ResumePendingToolBatch";
+      readonly submissionId: string;
+      readonly turn: number;
+    } | {
+      readonly _tag: "AwaitApprovalDecision";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ResumeSuspended";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "AwaitUnknownResolution";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ApplyUnknownResolutions";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RevertJoining";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RepairJoinMarker";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "SettleJoinedWithHost";
+      readonly submissionId: string;
+      readonly outcome: "aborted" | "completed" | "failed";
+    } | {
+      readonly _tag: "AwaitHostSettlement";
+      readonly submissionId: string;
+      readonly hostSubmissionId?: string | undefined;
+    } | {
+      readonly _tag: "CompleteChildAdmission";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+    } | {
+      readonly _tag: "AwaitChildAdmissionResolution";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+    } | {
+      readonly _tag: "RepairSubagentStartLink";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+    } | {
+      readonly _tag: "EnsureWaitingForChild";
+      readonly submissionId: string;
+      readonly children: readonly [{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }, ...{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }[]];
+    } | {
+      readonly _tag: "AwaitChildSettlement";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ResumeWaitingParent";
+      readonly submissionId: string;
+      readonly children: readonly [{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }, ...{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }[]];
+    } | {
+      readonly _tag: "ApplyJoinAccounting";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+      readonly reservationId: string;
+    } | {
+      readonly _tag: "PropagateChildAbort";
+      readonly submissionId: string;
+      readonly children: readonly [{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }, ...{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }[]];
+    } | {
+      readonly _tag: "ReleaseOrphanChildReservation";
+      readonly submissionId: string;
+      readonly reservationIds: readonly [string, ...string[]];
+    } | {
+      readonly _tag: "AwaitParentEstablishment";
+      readonly submissionId: string;
+      readonly parentSubmissionId: string;
+      readonly parentToolCallId: string;
+    } | {
+      readonly _tag: "NoAction";
+      readonly submissionId: string;
+    };
+    readonly decisionMeaning: string;
+    readonly disposition: "deferred" | "none" | "repaired" | "unknown";
+    readonly explainedAt: string;
+  }[];
+} | {
+  readonly _tag: "VerifiedIntegrity";
+  readonly report: {
+    readonly threadId: string;
+    readonly tailSequence: number;
+    readonly recordCount: number;
+    readonly submissionCount: number;
+    readonly checks: readonly {
+      readonly name: "all-settled" | "checkpoint-binding" | "digest-chain" | "fifo-input-order" | "fifo-settlement-order" | "ledger-canonical-agreement" | "record-identity" | "schema-round-trip" | "sequence-contiguity" | "terminal-uniqueness";
+      readonly status: "failed" | "passed" | "skipped";
+      readonly detail?: string | undefined;
+    }[];
+    readonly ok: boolean;
+  };
+} | {
+  readonly _tag: "RetryExecuted";
+  readonly report: {
+    readonly submissionId: string;
+    readonly threadId: string;
+    readonly decision: {
+      readonly _tag: "CompleteMaterialization";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RepairReadiness";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ApplyInput";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RepairInputMarker";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ResumeFromTurnBoundary";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "AppendReservedSettlement";
+      readonly submissionId: string;
+      readonly settlementId: string;
+      readonly outcome: "aborted" | "completed" | "failed";
+    } | {
+      readonly _tag: "FinalizeLedgerFromHistory";
+      readonly submissionId: string;
+      readonly settlementId: string;
+      readonly outcome: "aborted" | "completed" | "failed";
+    } | {
+      readonly _tag: "SettleAborted";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "MarkUnknown";
+      readonly submissionId: string;
+      readonly reason: string;
+      readonly openToolCallIds: readonly string[];
+    } | {
+      readonly _tag: "ResumePendingToolBatch";
+      readonly submissionId: string;
+      readonly turn: number;
+    } | {
+      readonly _tag: "AwaitApprovalDecision";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ResumeSuspended";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "AwaitUnknownResolution";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ApplyUnknownResolutions";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RevertJoining";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "RepairJoinMarker";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "SettleJoinedWithHost";
+      readonly submissionId: string;
+      readonly outcome: "aborted" | "completed" | "failed";
+    } | {
+      readonly _tag: "AwaitHostSettlement";
+      readonly submissionId: string;
+      readonly hostSubmissionId?: string | undefined;
+    } | {
+      readonly _tag: "CompleteChildAdmission";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+    } | {
+      readonly _tag: "AwaitChildAdmissionResolution";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+    } | {
+      readonly _tag: "RepairSubagentStartLink";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+    } | {
+      readonly _tag: "EnsureWaitingForChild";
+      readonly submissionId: string;
+      readonly children: readonly [{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }, ...{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }[]];
+    } | {
+      readonly _tag: "AwaitChildSettlement";
+      readonly submissionId: string;
+    } | {
+      readonly _tag: "ResumeWaitingParent";
+      readonly submissionId: string;
+      readonly children: readonly [{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }, ...{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }[]];
+    } | {
+      readonly _tag: "ApplyJoinAccounting";
+      readonly submissionId: string;
+      readonly toolCallId: string;
+      readonly reservationId: string;
+    } | {
+      readonly _tag: "PropagateChildAbort";
+      readonly submissionId: string;
+      readonly children: readonly [{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }, ...{
+        readonly toolCallId: string;
+        readonly childSubmissionId: string;
+      }[]];
+    } | {
+      readonly _tag: "ReleaseOrphanChildReservation";
+      readonly submissionId: string;
+      readonly reservationIds: readonly [string, ...string[]];
+    } | {
+      readonly _tag: "AwaitParentEstablishment";
+      readonly submissionId: string;
+      readonly parentSubmissionId: string;
+      readonly parentToolCallId: string;
+    } | {
+      readonly _tag: "NoAction";
+      readonly submissionId: string;
+    };
+    readonly disposition: "deferred" | "none" | "repaired" | "unknown";
+  };
+} | {
+  readonly _tag: "ObligationsScanned";
+  readonly report: {
+    readonly thresholds: {
+      readonly agingSeconds: number;
+      readonly overdueSeconds: number;
+    };
+    readonly entries: readonly {
+      readonly submissionId: string;
+      readonly threadId: string;
+      readonly state: "admitted" | "input-applied" | "joined" | "joining" | "ready" | "running" | "settled" | "suspended" | "terminalizing" | "unknown";
+      readonly blockedOn: "approval" | "ready-aged" | "running-aged" | "unknown" | "waitingForChild";
+      readonly ageSeconds: number;
+      readonly severity: "aging" | "ok" | "overdue";
+    }[];
+    readonly generatedAt: string;
+  };
+} | {
+  readonly _tag: "AdminFailed";
+  readonly failure: {
+    readonly _tag: "DurableAlarmError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "SettlementConflict";
+    readonly submissionId: string;
+    readonly existingOutcome: "aborted" | "completed" | "failed";
+  } | {
+    readonly _tag: "LedgerError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "ThreadStoreError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "ThreadNotMaterialized";
+    readonly threadId: string;
+  } | {
+    readonly _tag: "AppendConflict";
+    readonly threadId: string;
+    readonly batchId: string;
+    readonly reason: "batch-digest" | "record-identity" | "tail";
+    readonly actualTailSequence?: number | undefined;
+    readonly actualTailDigest?: string | undefined;
+  } | {
+    readonly _tag: "FenceRejected";
+    readonly threadId: string;
+    readonly actualEpoch: number;
+    readonly attemptedEpoch: number;
+  } | {
+    readonly _tag: "OperationDenied";
+    readonly operation: "abort" | "awaitSettlement" | "explain" | "observe" | "resolveApproval" | "resolveUnknown" | "retry" | "scanObligations" | "verify" | "wake";
+    readonly reason: string;
+    readonly threadId?: string | undefined;
+    readonly submissionId?: string | undefined;
+  } | {
+    readonly _tag: "RetryRefused";
+    readonly submissionId: string;
+    readonly refusal: "await-approval-decision" | "await-unknown-resolution" | "settled";
+    readonly decisionTag: string;
+    readonly message: string;
+  } | {
+    readonly _tag: "RunJournalError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "DigestError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "OwnershipLost";
+    readonly submissionId: string;
+    readonly actualEpoch: number;
+  } | {
+    readonly _tag: "DurableRuntimeFailpointError";
+    readonly location: "abort:after-intent" | "approval:after-request-append" | "approval:after-suspend" | "claim:after-claim" | "compaction:after-canonical-append" | "input:after-canonical-append" | "join:after-canonical-append" | "join:after-claim" | "policy:after-reservation-append" | "policy:before-reservation-append" | "resolve:after-intent" | "run:after-start-append" | "run:before-start-append" | "step:after-step-append" | "subagent:after-admit" | "subagent:after-child-abort-intent" | "subagent:after-child-ready" | "subagent:after-join-append" | "subagent:after-release" | "subagent:after-release-pending" | "subagent:after-request-append" | "subagent:after-reserve" | "subagent:after-sibling-settle" | "subagent:after-start-append" | "subagent:after-suspend" | "submit:after-admit" | "submit:after-materialize" | "terminalize:after-canonical-append" | "terminalize:after-reserve" | "tools:after-prepared-append" | "tools:before-prepared-append" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
+  } | {
+    readonly _tag: "HostProtocolError";
+    readonly message: string;
+  };
+}, Schema.SchemaError, never>;
+declare const decodeAdminResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AdminFailed | ExplainedRecovery | ObligationsScanned | RetryExecuted | VerifiedIntegrity, Schema.SchemaError, never>;
+/** The public endpoints and effect-cf invocation hook of one Thread Object instance. */
+interface Instance<EventServices = never> extends InstanceType<DurableObject.DurableObjectClass<Record<never, never>, RuntimeServices | EventServices>> {
+  submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  awaitSettlementEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  awaitProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  cancelProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  observePage(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  abortEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  resolveApprovalEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  resolveUnknownEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;
+  explainEncoded(encoded: unknown): Promise<unknown>;
+  verifyEncoded(encoded: unknown): Promise<unknown>;
+  retryEncoded(encoded: unknown): Promise<unknown>;
+  obligationsEncoded(encoded: unknown): Promise<unknown>;
+  portCall(encoded: unknown): Promise<unknown>;
+  wake(): Promise<void>;
+  alarm(alarmInfo?: AlarmInvocationInfo): Promise<void> | void;
+}
+/** The constructor shape workerd instantiates for each Thread Object. */
+interface Class<EventServices = never> {
+  new (ctx: DurableObjectState, env: Cloudflare.Env): Instance<EventServices>;
+}
+/**
+ * Export a composed application Layer as a native Durable Object class.
+ * Bootstrap services are provided to the whole graph before it acquires, so application Layers
+ * can yield effect-cf's WorkerEnvironment and DurableObjectState, derived identity, and Crypto.
+ * Application dependencies remain visible until Layer.provide satisfies them. effect-cf owns the
+ * cached ManagedRuntime, native RPC methods, event scopes, and telemetry flushing.
+ * Initialization is local and bounded inside the constructor gate. Cloudflare eviction does not
+ * guarantee finalizers; put resources requiring timely release in scoped operations or eventLayer.
+ */
+declare const make: <ApplicationServices, ApplicationError, EventServices = never, EventLayerError = never>(applicationLayer: Layer.Layer<CloudflareDurableRuntimeServices | ApplicationServices, ApplicationError, CloudflareBootstrapServices | DurableObjectState$1.DurableObjectState | WorkerEnvironment | DurableObjectContext | ThreadObjectNamespace>, options: Options<ApplicationServices, EventServices, EventLayerError>) => Class<ApplicationServices | EventServices>;
+//#endregion
+export { CloudflareDurableRuntimeOptions as C, layerConfig as E, CloudflareDurableRuntimeInitializationError as S, layer as T, decodeObligationThresholds as _, AdminVerifyRequest as a, make as b, Instance as c, RetryExecuted as d, ThreadObject_d_exports as f, decodeAdminVerifyRequest as g, decodeAdminResponse as h, AdminResponse as i, ObligationsScanned as l, decodeAdminExplainRequest as m, AdminFailed as n, Class as o, VerifiedIntegrity as p, AdminFailure as r, ExplainedRecovery as s, AdminExplainRequest as t, Options as u, decodeRetryCommand as v, CloudflareDurableRuntimeServices as w, CloudflareBootstrapServices as x, encodeAdminResponse as y };
+//# sourceMappingURL=ThreadObject-Ia94R_B1.d.mts.map