@effect-agent/platform-cloudflare 0.1.0-beta.8 → 0.1.0-beta.80

package/dist/ThreadObject-3uDpKfB3.d.mts

@@ -0,0 +1,816 @@
+import { DurableObjectContext, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPlacement } from "./CloudflareBindings.mjs";
+import { c as CloudflarePlatformConfigError, o as CloudflareDurableRuntimeConfig, t as AdmissionLimitExceeded } from "./CloudflareConfig-f3CqTel1.mjs";
+import { DurableAlarmError, DurableAlarmService, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler, ThreadMutationGate, ThreadPublication } from "./Alarm.mjs";
+import { HostProtocolError, SubmitRequest } from "./CloudflareThreadClient.mjs";
+import { SubmissionId, ThreadId } from "@effect-agent/core/Identifiers";
+import { AgentRegistration } from "@effect-agent/thread/AgentRegistration";
+import { DurableAgentRuntime, DurableRuntimeConfig, RecoveryReport } from "@effect-agent/thread/DurableAgentRuntime";
+import { AdmissionPolicyError, LedgerError, OwnershipLost, SettlementConflict, SubmissionLedger, SubmissionSnapshot } from "@effect-agent/thread/SubmissionLedger";
+import { ThreadProjectionMaintenance } from "@effect-agent/thread/ThreadProjectionMaintenance";
+import { Context, Crypto, Effect, Layer, Option, 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 { PreparedInputAdmission } from "@effect-agent/thread/PreparedInputAdmission";
+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 { MessageDeliveryError, MessageDeliveryStore } from "@effect-agent/thread/MessageDelivery";
+import { ToolReconciler } from "@effect-agent/thread/ToolReconciler";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+//#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 every attempt and retain a bounded tombstone for later transport attempts. */
+  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 | ThreadObjectPlacement | DurableRuntimeConfig | Crypto.Crypto | DoStorageFailpoint | DurableRuntimeFailpoint | ThreadMaintenanceFailpoint | RunContextPreparation | RunToolAuthorization | ToolReconciler;
+/** Every construction failure of the assembled Cloudflare durable runtime stack. */
+type CloudflareDurableRuntimeInitializationError = CloudflarePlatformConfigError | DigestError | MessageDeliveryError | DoStorageInitializationError;
+/**
+ * The services `ThreadObject.layer` provides, including its single owner SQL client.
+ * Its Context also supplies ThreadMessageDelivery (a defaulted Reference, with no required R)
+ * so application-composed maintenance retains the same native message recovery capability.
+ */
+type CloudflareDurableRuntimeServices = DurableAgentRuntime | SubmissionLedger | ThreadStore | MessageDeliveryStore | WakeScheduler | DurableAlarmService | ThreadMaintenance | ThreadMutationGate | ThreadPublication | ThreadProjectionMaintenance | ThreadObjectPorts | ProgressWaitRegistry | SqlClient;
+declare const ThreadObjectPorts_base: Context.ServiceClass<ThreadObjectPorts, "@effect-agent/platform-cloudflare/ThreadObjectPorts", {
+  readonly handle: (request: PortRequest) => Effect.Effect<PortResponse>;
+  /** Local-only identity check before a bound RPC can read or mutate a Submission. */
+  readonly lookupSubmission: (submissionId: SubmissionId) => Effect.Effect<Option.Option<SubmissionSnapshot>, LedgerError>;
+}>;
+/**
+ * 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 {}
+/** Native one-Thread configuration; retains its existing producer and logical identities. */
+declare const layerConfig: (options: CloudflareDurableRuntimeOptions) => Layer.Layer<CloudflareBootstrapServices, CloudflarePlatformConfigError, DurableObjectContext>;
+/**
+ * Configuration for an application Object owning several logical Threads. The producer is
+ * the stable physical Object. No logical identity is installed globally: handleRpc binds and
+ * validates it per request using the placement guard and this actual runtime producer.
+ */
+declare const layerHostConfig: (options: CloudflareDurableRuntimeOptions, ownsThread: (threadId: ThreadId) => boolean) => Layer.Layer<Exclude<CloudflareBootstrapServices, ThreadObjectIdentity>, CloudflarePlatformConfigError, DurableObjectContext>;
+interface ThreadPublicationOptions<E = never, R = never, P = never> {
+  /**
+   * Optional host outbox consumer, built once per incarnation with RAW LOCAL ThreadStore and
+   * SubmissionLedger services. Yield DurableObjectContext and ThreadObjectIdentity for native
+   * bindings and identity. Initialization is local-only, inside the constructor gate; setup
+   * errors and additional requirements remain in the returned Layer. Layer.effect owns Scope.
+   * Canonical appends and durable approval, abort and unknown-resolution intents invalidate
+   * publication after commit. Custom host facts must use ThreadMaintenance.withMutation.
+   */
+  readonly publication?: Layer.Layer<ThreadPublication, E, R>;
+  /**
+   * Disposable index maintenance, built once with the raw local ThreadStore and owner
+   * SqlClient. Additional services P are exposed by the returned Layer, allowing Tool
+   * handlers and maintenance to share one index instance. Construction is local-only.
+   * Live committed batches run before append returns; bounded backfill uses the native
+   * alarm without delaying execution behind projection backlog.
+   */
+  readonly projection?: Layer.Layer<ThreadProjectionMaintenance | P, E, R>;
+}
+/**
+ * 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 registeredLayer: <const Entries extends ReadonlyArray<AgentRegistration>, E = never, R = never>(registrations: Entries, options?: ThreadPublicationOptions<E, R>) => Layer.Layer<CloudflareDurableRuntimeServices, E | DigestError | MessageDeliveryError | DoStorageInitializationError, DurableObjectContext | ThreadObjectNamespace | Exclude<R, SqlClient | SubmissionLedger | ThreadStore> | Exclude<[Entries[number]] extends [never] ? never : (Entries[number] extends (infer T_3) ? T_3 extends Entries[number] ? T_3 extends {
+  readonly attemptLayer: (context: import("@effect-agent/thread/AgentRegistration").AgentAttemptContext) => Layer.Layer<infer Provides, never, infer Requires>;
+} ? Requires | Exclude<T_3 extends (infer T_4) ? T_4 extends T_3 ? T_4 extends {
+  readonly agent: infer A extends import("@effect-agent/thread/AgentRegistration").ExecutableAgentBinding;
+} ? import("@effect-agent/thread/DurableAgentRuntime").DurableWorkerRequirements<A> : T_4 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_3 extends {
+  readonly agent: infer A extends import("@effect-agent/thread/AgentRegistration").ExecutableAgentBinding;
+} ? import("@effect-agent/thread/DurableAgentRuntime").DurableWorkerRequirements<A> : T_3 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) | (Entries[number] extends (infer T_5) ? T_5 extends Entries[number] ? T_5 extends {
+  readonly reporting: infer Reports extends ReadonlyArray<import("@effect-agent/engine/SubagentHost").WorkerReporting<unknown, unknown>>;
+} ? [Reports[number]] extends [never] ? never : Reports[number] extends import("@effect-agent/engine/SubagentHost").WorkerReporting<unknown, infer R_1> ? Exclude<R_1, import("effect/Scope").Scope> : never : never : never : never), import("effect/Scope").Scope> | CloudflareBootstrapServices>;
+/** Preserve additional index services only when a projection Layer is actually supplied. */
+declare function layer<const Entries extends ReadonlyArray<AgentRegistration>, E = never, R = never, P = never, PE = never, PR = never>(registrations: Entries, options: Omit<ThreadPublicationOptions<E, R>, "projection"> & {
+  readonly projection: Layer.Layer<ThreadProjectionMaintenance | P, PE, PR>;
+}): Layer.Layer<Layer.Success<ReturnType<typeof registeredLayer<Entries, E | PE, R | PR>>> | P, Layer.Error<ReturnType<typeof registeredLayer<Entries, E | PE, R | PR>>>, Layer.Services<ReturnType<typeof registeredLayer<Entries, E | PE, R | PR>>>>;
+declare function layer<const Entries extends ReadonlyArray<AgentRegistration>, E = never, R = never>(registrations: Entries, options?: ThreadPublicationOptions<E, R>): ReturnType<typeof registeredLayer<Entries, E, R>>;
+/**
+ * Build the application runtime over the existing owner SqlClient and native ports, then
+ * assemble its one maintenance coordinator. The application may acquire its Bindings from
+ * those ports and expose extra services, including ThreadHostMaintenance. It must not acquire
+ * another runtime stack or require ThreadMaintenance while constructing this Layer.
+ * Supply layerHostConfig and deterministic placement; dispatch addressed ingress with handleRpc.
+ */
+declare function layerInHost<A, E, R, P = never, PE = never, PR = never>(application: Layer.Layer<DurableAgentRuntime | A, E, R>, options: Omit<ThreadPublicationOptions<PE, PR>, "projection"> & {
+  readonly projection: Layer.Layer<ThreadProjectionMaintenance | P, PE, PR>;
+}): Layer.Layer<CloudflareDurableRuntimeServices | A | P, Layer.Error<ReturnType<typeof sharedLayer<A, E, R, PE, PR>>>, Layer.Services<ReturnType<typeof sharedLayer<A, E, Exclude<R, P>, PE, PR>>>>;
+declare function layerInHost<A, E, R, PE = never, PR = never>(application: Layer.Layer<DurableAgentRuntime | A, E, R>, options?: ThreadPublicationOptions<PE, PR>): ReturnType<typeof sharedLayer<A, E, R, PE, PR>>;
+type HostRuntimeServices = Exclude<CloudflareDurableRuntimeServices, DurableAgentRuntime | ThreadMaintenance>;
+declare const sharedLayer: <A, E, R, PE = never, PR = never>(application: Layer.Layer<DurableAgentRuntime | A, E, R>, options?: ThreadPublicationOptions<PE, PR>) => Layer.Layer<CloudflareDurableRuntimeServices | A, DoStorageInitializationError | MessageDeliveryError | E | PE, DurableObjectContext | ThreadObjectNamespace | Exclude<CloudflareBootstrapServices, ThreadObjectIdentity> | SqlClient | Exclude<R, HostRuntimeServices | PreparedInputAdmission> | Exclude<PR, ThreadStore | SubmissionLedger | SqlClient>>;
+declare namespace ThreadObject_d_exports {
+  export { AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, CloudflareBootstrapServices as BootstrapServices, Class, ExplainedRecovery, CloudflareDurableRuntimeInitializationError as InitializationError, Instance, ObligationsScanned, Options, ThreadPublicationOptions as PublicationOptions, RetryExecuted, CloudflareDurableRuntimeOptions as RuntimeOptions, CloudflareDurableRuntimeServices as Services, ThreadObjectPorts, ThreadRpcOperation, VerifiedIntegrity, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeObligationThresholds, decodeRetryCommand, encodeAdminResponse, handleRpc, layer, layerConfig, layerHostConfig, layerInHost, make, portCall, submit };
+}
+/**
+ * `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` + `processThreadHead` pass, and the persisted alarm
+ * (the single multiplexed slot, D-P6-2) finishes accepted work across evictions WITHOUT any
+ * incoming request.
+ * `Services` exposes the same owner `SqlClient` used by the Thread stores. Compose optional
+ * local repositories after `ThreadObject.layer`; never acquire another independently locked
+ * SQL client for the same Object. Exposing the client installs no additional storage schemas.
+ *
+ * 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;
+/**
+ * Admit an already Schema-decoded request to a logical Thread in this physical owner.
+ * Custom hosts validate local placement before calling this Effect and provide their same
+ * runtime/maintenance instances. The native endpoint uses this path too: queue limits,
+ * idempotent receipts and the pre-admission generation/alarm commit have one owner.
+ */
+declare const submit: (threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">, request: SubmitRequest) => Effect.Effect<import("@effect-agent/core/Receipt").Receipt, AdmissionLimitExceeded | DurableAlarmError | HostProtocolError | import("@effect-agent/thread/DurableAgentRuntime").DurableSubmitFailure, CloudflareDurableRuntimeConfig | DurableAgentRuntime | DurableObjectContext | SubmissionLedger | ThreadMutationGate | ThreadObjectPlacement | ThreadPublication>;
+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 AdmissionPolicyError, 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 AdmissionPolicyError, 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: "CompletedWithResult";
+          readonly result: Schema.Json;
+          readonly isFailure: boolean;
+        } | {
+          readonly _tag: "NeverHappened";
+        } | {
+          readonly _tag: "SafeToRetry";
+        } | {
+          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: "HostProtocolError";
+    readonly message: string;
+  } | {
+    readonly _tag: "LedgerError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "AdmissionPolicyError";
+    readonly reason: "occupied" | "refused" | "unavailable";
+    readonly code: 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: "DigestError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "DurableRuntimeFailpointError";
+    readonly location: "abort:after-intent" | "approval:after-request-append" | "approval:after-suspend" | "checkpoint:after-save" | "checkpoint:before-save" | "claim:after-claim" | "compaction:after-canonical-append" | "compaction:before-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" | "subagent:before-join-append" | "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" | "worker:after-completion-append" | "worker:after-origin-append" | "worker:after-report-append" | "worker:after-report-delivery" | "worker:after-source-append" | "worker:after-subtree-append" | "worker:before-completion-append" | "worker:before-origin-append" | "worker:before-report-append" | "worker:before-report-delivery" | "worker:before-source-append" | "worker:before-subtree-append";
+  } | {
+    readonly _tag: "FenceRejected";
+    readonly threadId: string;
+    readonly actualEpoch: number;
+    readonly attemptedEpoch: number;
+  } | {
+    readonly _tag: "ThreadNotMaterialized";
+    readonly threadId: string;
+  } | {
+    readonly _tag: "ThreadStoreError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    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: "SettlementConflict";
+    readonly submissionId: string;
+    readonly existingOutcome: "aborted" | "completed" | "failed";
+  } | {
+    readonly _tag: "OwnershipLost";
+    readonly submissionId: string;
+    readonly actualEpoch: number;
+  } | {
+    readonly _tag: "RunJournalError";
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "RetryRefused";
+    readonly submissionId: string;
+    readonly refusal: "await-approval-decision" | "await-unknown-resolution" | "settled";
+    readonly decisionTag: string;
+    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>;
+declare const portCall: (encoded: unknown) => Effect.Effect<unknown, never, ThreadObjectPorts | ThreadMaintenance | DurableAlarmService | ThreadObjectIdentity>;
+/** The per-Thread wire operations supported by native and application-owned endpoints. */
+declare const ThreadRpcOperation: Schema.Literals<readonly ["submitEncoded", "submissionStatusEncoded", "awaitSettlementEncoded", "awaitProgressEncoded", "cancelProgressEncoded", "observePage", "abortEncoded", "resolveApprovalEncoded", "resolveUnknownEncoded", "portCall", "wake"]>;
+type ThreadRpcOperation = typeof ThreadRpcOperation.Type;
+/**
+ * Bind an addressed request to its logical Thread while sharing one physical runtime. This
+ * validates local placement before invoking the same native handlers. Receipts, Submission
+ * commands and port envelopes must match this identity; progress cancellation is Thread-scoped.
+ * The producer comes from the actual runtime configuration, never from caller input. These
+ * guards supplement the existing current model/Tool and operation authorization policies.
+ */
+declare const handleRpc: (threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">, operation: "abortEncoded" | "awaitProgressEncoded" | "awaitSettlementEncoded" | "cancelProgressEncoded" | "observePage" | "portCall" | "resolveApprovalEncoded" | "resolveUnknownEncoded" | "submissionStatusEncoded" | "submitEncoded" | "wake", encoded: unknown) => Effect.Effect<unknown, HostProtocolError, CloudflareDurableRuntimeConfig | import("effect/Crypto").Crypto | import("@effect-agent/storage-cloudflare/DoStorageFailpoint").DoStorageFailpoint | DurableObjectContext | DurableRuntimeConfig | import("@effect-agent/thread/DurableFailpoint").DurableRuntimeFailpoint | import("@effect-agent/engine/RunOptions").RunContextPreparation | import("@effect-agent/engine/RunOptions").RunToolAuthorization | ThreadMaintenanceFailpoint | ThreadObjectPlacement | import("@effect-agent/thread/ToolReconciler").ToolReconciler | CloudflareDurableRuntimeServices>;
+/** 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>;
+  submissionStatusEncoded(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.
+ * Effect Config reads scalar Worker vars and secrets through effect-cf's environment provider;
+ * WorkerEnvironment exposes resource bindings without a separate config Layer.
+ * 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 { ThreadPublicationOptions as A, portCall as C, CloudflareDurableRuntimeOptions as D, CloudflareDurableRuntimeInitializationError as E, layerConfig as M, layerHostConfig as N, CloudflareDurableRuntimeServices as O, layerInHost as P, make as S, CloudflareBootstrapServices as T, decodeAdminVerifyRequest as _, AdminVerifyRequest as a, encodeAdminResponse as b, Instance as c, RetryExecuted as d, ThreadObject_d_exports as f, decodeAdminResponse as g, decodeAdminExplainRequest as h, AdminResponse as i, layer as j, ThreadObjectPorts as k, ObligationsScanned as l, VerifiedIntegrity as m, AdminFailed as n, Class as o, ThreadRpcOperation as p, AdminFailure as r, ExplainedRecovery as s, AdminExplainRequest as t, Options as u, decodeObligationThresholds as v, submit as w, handleRpc as x, decodeRetryCommand as y };
+//# sourceMappingURL=ThreadObject-3uDpKfB3.d.mts.map