@effect-agent/platform-cloudflare 0.1.0-beta.40 → 0.1.0-beta.42

package/dist/index.d.mts

@@ -3,9 +3,9 @@ import { a as ThreadObjectRpc, i as ThreadObjectNamespace, n as DurableObjectCon
 import { CloudflareSchedulingClient, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerObjectClass, ScheduleOwnerObjectInstance, ScheduleOwnerObjectRpc, ScheduleOwnerProtocolError, makeScheduleOwnerObjectClass } from "./scheduling.mjs";
 import { CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionObjectClass, SubscriptionPartitionObjectInstance, SubscriptionPartitionObjectRpc, SubscriptionPartitionProtocolError, makeSubscriptionPartitionObjectClass, sourcePartitionName, validateCloudflareSubscriptionLimits } from "./subscriptions.mjs";
 import { Context, Crypto, Effect, Layer, Option, Schema, Scope } from "effect";
-import { DoStorageFailpoint, DoStorageFailpointHandler, DoStorageInitializationError, PortRequest, PortResponse, ThreadPortTransport } from "@effect-agent/storage-cloudflare";
-import { AbortCommand, AbortIntent, AdmissionConflict, AgentRegistration, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, DefinitionDigests, DigestError, DurableAgentRuntime, DurableBindingFailure, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableSubmitAgent, DurableSubmitOptions, DurableWorkerFailure, FenceRejected, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizerService, OperationDenied, OwnershipLost, PreparedInputAdmission, Receipt, RecoveryExplanation, RecoveryReport, ResolvedBinding, RetryCommand, RetryRefused, RunJournalError, ScheduledInputAdmission, Settlement, SettlementConflict, SubmissionLedger, ThreadNotMaterialized, ThreadStore, ThreadStoreError, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler } from "@effect-agent/thread";
-import { AgentInputError, ThreadId } from "@effect-agent/core";
+import { DoMemoryStorageLimits, DoStorageFailpoint, DoStorageFailpointHandler, DoStorageInitializationError, MemoryOwnerAuthorizer, MemoryOwnerIdentity, MemoryRpcError, MemoryRpcLimits, PortRequest, PortResponse, ThreadPortTransport } from "@effect-agent/storage-cloudflare";
+import { AbortCommand, AbortIntent, AdmissionConflict, AgentRegistration, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, DefinitionDigests, DigestError, DurableAgentRuntime, DurableBindingFailure, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableSubmitAgent, DurableSubmitOptions, DurableWorkerFailure, FenceRejected, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizerService, OperationDenied, OwnershipLost, PreparedInputAdmission, Principal, Receipt, RecoveryExplanation, RecoveryReport, ResolvedBinding, RetryCommand, RetryRefused, RunJournalError, ScheduledInputAdmission, Settlement, SettlementConflict, SubmissionLedger, ThreadNotMaterialized, ThreadStore, ThreadStoreError, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler } from "@effect-agent/thread";
+import { AgentInputError, MemoryAccess, MemoryDocument, MemoryIndexSearch, MemoryMutationFailpoint, MemoryNamespace, MemoryReader, MemoryRecallLimits, MemoryStorageError, MemoryWrite, MemoryWriter, SemanticCandidateLimits, SemanticMemoryProfile, ThreadId } from "@effect-agent/core";
 import { RunContextPreparation, RunCostEstimator, RunToolAuthorization, RunToolFailureObserver } from "@effect-agent/engine";
 import { DurableObject, DurableObjectState as DurableObjectState$1, WorkerEnvironment } from "effect-cf";
 import { CodeExecutor, SandboxImplementation } from "@effect-agent/sandbox";
@@ -349,7 +349,25 @@ declare const layerConfig: (options: CloudflareDurableRuntimeOptions) => Layer.L
  * 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 AgentRegistration<infer A extends import("@effect-agent/thread").ExecutableAgentBinding> ? import("@effect-agent/thread").DurableWorkerRequirements<A> : never : never : never, import("effect/Scope").Scope> | CloudflareBootstrapServices>;
+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 agent: infer A extends import("@effect-agent/thread").ExecutableAgentBinding;
+} ? import("@effect-agent/thread").DurableWorkerRequirements<A> : T extends {
+  readonly agent: infer D extends import("@effect-agent/core").Definition<Schema.Top, Schema.Top, unknown, import("effect/unstable/ai/Toolkit").Any, import("@effect-agent/core").RunDispositionDeclaration<never, Schema.Top> | undefined, unknown> & {
+    readonly instructions: import("@effect-agent/core").InstructionSource<never, unknown, unknown>;
+    readonly inputPrompt?: import("@effect-agent/core").InputPromptSource<never, unknown, unknown> | undefined;
+  };
+  readonly model: infer M extends import("@effect-agent/thread").ExecutableAgentBinding["model"];
+} ? import("@effect-agent/thread").DurableWorkerRequirements<{
+  readonly definition: D;
+  readonly model: M;
+}> : never : never : never, import("effect/Scope").Scope> | CloudflareBootstrapServices>;
+/**
+ * Assemble the durable runtime from already-resolved Agent Bindings.
+ * Use `ThreadObject.layer` to compile typed Agent registrations instead.
+ * Supply host services through `ThreadObject.make` or `ThreadObject.layerConfig` and
+ * the Durable Object context and namespace Layers when composing a custom host.
+ */
+declare const layerFromBindings: (bindings: ReadonlyArray<ResolvedBinding>) => Layer.Layer<CloudflareDurableRuntimeServices, DoStorageInitializationError, DurableObjectContext | ThreadObjectNamespace | CloudflareBootstrapServices>;
 //#endregion
 //#region src/client.d.ts
 /** Truncate a diagnostic string to the host protocol's bounded length. */
@@ -503,13 +521,13 @@ declare const encodeUnknownResolutionCommand: (input: UnknownResolutionCommand,
   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: "SafeToRetry";
   } | {
     readonly _tag: "AbortSubmission";
   };
@@ -584,14 +602,6 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
       readonly createdAt: string;
       readonly deploymentId: string;
       readonly payload: {
-        readonly _tag: "SubagentStarted";
-        readonly runId: string;
-        readonly toolCallId: string;
-        readonly childThreadId: string;
-        readonly childSubmissionId: string;
-        readonly childReceiptId: string;
-        readonly childRunId: string;
-      } | {
         readonly _tag: "AbortRequested";
         readonly submissionId: string;
         readonly author: string;
@@ -801,6 +811,37 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly childPrincipal: string;
         readonly childIdempotencyKey: string;
         readonly toolCallAllowance?: number | undefined;
+        readonly policy?: Schema.Json | undefined;
+        readonly budget?: {
+          readonly caps: {
+            readonly maxTotalChildInvocations?: number | undefined;
+            readonly maxConcurrentChildren?: number | undefined;
+            readonly maxTurns?: number | undefined;
+            readonly maxToolCalls?: number | undefined;
+            readonly maxDurationMillis?: number | undefined;
+            readonly maxInputTokens?: number | undefined;
+            readonly maxOutputTokens?: number | undefined;
+            readonly maxCostMicrousd?: number | undefined;
+            readonly maxResultBytes?: number | undefined;
+          };
+          readonly allocation: {
+            readonly turns: number;
+            readonly toolCalls: number;
+            readonly durationMillis: number;
+            readonly inputTokens: number;
+            readonly outputTokens: number;
+            readonly costMicrousd: number;
+            readonly resultBytes: number;
+          };
+        } | undefined;
+      } | {
+        readonly _tag: "SubagentStarted";
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly childThreadId: string;
+        readonly childSubmissionId: string;
+        readonly childReceiptId: string;
+        readonly childRunId: string;
       } | {
         readonly _tag: "SubagentJoined";
         readonly runId: string;
@@ -832,6 +873,7 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly childInputDigest: string;
         readonly grantDigest: string;
         readonly toolCallAllowance?: number | undefined;
+        readonly policy?: Schema.Json | undefined;
       } | {
         readonly _tag: "RepairAnnotated";
         readonly reason: string;
@@ -871,13 +913,13 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
     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: "SafeToRetry";
     } | {
       readonly _tag: "AbortSubmission";
     };
@@ -887,6 +929,11 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
 } | {
   readonly _tag: "HostFailed";
   readonly failure: {
+    readonly _tag: "DurableAlarmError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
+  } | {
     readonly _tag: "AdmissionConflict";
     readonly threadId: string;
     readonly principal: string;
@@ -953,11 +1000,6 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
     readonly limit: "database-bytes" | "input-bytes" | "queue-depth";
     readonly actual: number;
     readonly maximum: number;
-  } | {
-    readonly _tag: "DurableAlarmError";
-    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";
@@ -1508,14 +1550,38 @@ declare const encodeAdminResponse: (input: AdminFailed | ExplainedRecovery | Obl
 } | {
   readonly _tag: "AdminFailed";
   readonly failure: {
-    readonly _tag: "SettlementConflict";
+    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 existingOutcome: "aborted" | "completed" | "failed";
+    readonly refusal: "await-approval-decision" | "await-unknown-resolution" | "settled";
+    readonly decisionTag: string;
+    readonly message: string;
   } | {
     readonly _tag: "LedgerError";
     readonly operation: string;
     readonly message: string;
     readonly cause?: Schema.Json | undefined;
+  } | {
+    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: "SettlementConflict";
+    readonly submissionId: string;
+    readonly existingOutcome: "aborted" | "completed" | "failed";
   } | {
     readonly _tag: "ThreadStoreError";
     readonly operation: string;
@@ -1536,30 +1602,6 @@ declare const encodeAdminResponse: (input: AdminFailed | ExplainedRecovery | Obl
     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";
@@ -1650,5 +1692,129 @@ declare const CloudflareCodeMode: {
   }) => Layer.Layer<A, E | HandlerError, Exclude<HandlerRequirements, CodeExecutor> | Exclude<Exclude<R, Handlers>, CodeExecutor>>;
 };
 //#endregion
-export { AbortRecorded, AdmissionLimitExceeded, ApprovalRecorded, AwaitProgressRequest, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CancelProgressRequest, ClientAbortFailure, ClientApprovalFailure, ClientAwaitFailure, ClientObserveFailure, ClientProgressFailure, ClientSubmitFailure, ClientUnknownFailure, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareBrowser, type CloudflareBrowserOptions, CloudflareCodeMode, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError, CloudflareSchedulingClient, CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, CloudflareThreadClient, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, DynamicWorkerCodeExecutorOptions, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassFailure, MaintenancePassReport, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, ProgressWaitRegistry, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerObjectClass, ScheduleOwnerObjectInstance, ScheduleOwnerObjectRpc, ScheduleOwnerProtocolError, SettlementReached, SubmitRequest, SubmitSucceeded, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionObjectClass, SubscriptionPartitionObjectInstance, SubscriptionPartitionObjectRpc, SubscriptionPartitionProtocolError, ThreadClientError, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler, ThreadMaintenanceFailpointLocation, thread_object_d_exports as ThreadObject, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPorts, ThreadObjectRpc, UnknownResolutionRecorded, boundHostDiagnostic, cloudflarePreparedInputAdmissionLayer, cloudflareScheduledInputAdmissionLayer, cloudflareWakeSchedulerLayer, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, disposeRpcHandle, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeScheduleOwnerObjectClass, makeSubscriptionPartitionObjectClass, sourcePartitionName, threadNamespaceFromEnv, threadNamespaceLayer, threadPortTransportLayer, validateCloudflareSubscriptionLimits };
+//#region src/memory.d.ts
+interface MemoryObjectRpc extends Rpc.DurableObjectBranded {
+  memory(encoded: string): Promise<string>;
+}
+declare const MemoryObjectNamespace_base: Context.ServiceClass<MemoryObjectNamespace, "@effect-agent/platform-cloudflare/MemoryObjectNamespace", {
+  readonly namespace: DurableObjectNamespace<MemoryObjectRpc>;
+}>;
+declare class MemoryObjectNamespace extends MemoryObjectNamespace_base {}
+/** Namespace version and identity are already canonicalized by MemoryNamespace. */
+declare const memoryObjectName: (namespace: MemoryNamespace.Any) => string;
+declare const CloudflareMemoryClient: {
+  /** Bind access and principal using the MemoryObjectNamespace supplied by the application. */
+  make: <Namespace extends MemoryNamespace.Any>(access: MemoryAccess<Namespace>, principal: string & import("effect/Brand").Brand<"@effect-agent/thread/Principal">, rpcLimits?: MemoryRpcLimits | undefined) => Effect.Effect<{
+    recall: (lookup: {
+      readonly _tag: "Found";
+      readonly passages: readonly import("@effect-agent/core").MemoryPassage[];
+    } | {
+      readonly _tag: "NoMatch";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    } | {
+      readonly _tag: "InsufficientFreshness";
+      readonly message: string;
+    }, limits: MemoryRecallLimits, estimateTokens?: ((text: string) => number) | undefined) => Effect.Effect<import("@effect-agent/core").RecalledMemory, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+    revalidate: (lookup: {
+      readonly _tag: "Found";
+      readonly passages: readonly import("@effect-agent/core").MemoryPassage[];
+    } | {
+      readonly _tag: "NoMatch";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    } | {
+      readonly _tag: "InsufficientFreshness";
+      readonly message: string;
+    }, limits: MemoryRecallLimits) => Effect.Effect<{
+      readonly _tag: "Found";
+      readonly passages: readonly import("@effect-agent/core").MemoryPassage[];
+    } | {
+      readonly _tag: "NoMatch";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    } | {
+      readonly _tag: "InsufficientFreshness";
+      readonly message: string;
+    }, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+    revalidateSemantic: (found: MemoryIndexSearch<Namespace>, profile: SemanticMemoryProfile, limits: SemanticCandidateLimits) => Effect.Effect<import("@effect-agent/core").SemanticCandidateResult, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+    change: (write: MemoryWrite<Namespace>) => Effect.Effect<MemoryDocument<Namespace>, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+  }, MemoryRpcError, MemoryObjectNamespace>;
+  /** Use a resolved Worker or Durable Object binding without manual service provisioning. */
+  fromBinding: <Namespace extends MemoryNamespace.Any>(binding: DurableObjectNamespace<MemoryObjectRpc>, options: {
+    readonly access: MemoryAccess<Namespace>;
+    readonly principal: Principal;
+    readonly rpcLimits?: MemoryRpcLimits;
+  }) => Effect.Effect<{
+    recall: (lookup: {
+      readonly _tag: "Found";
+      readonly passages: readonly import("@effect-agent/core").MemoryPassage[];
+    } | {
+      readonly _tag: "NoMatch";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    } | {
+      readonly _tag: "InsufficientFreshness";
+      readonly message: string;
+    }, limits: MemoryRecallLimits, estimateTokens?: ((text: string) => number) | undefined) => Effect.Effect<import("@effect-agent/core").RecalledMemory, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+    revalidate: (lookup: {
+      readonly _tag: "Found";
+      readonly passages: readonly import("@effect-agent/core").MemoryPassage[];
+    } | {
+      readonly _tag: "NoMatch";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    } | {
+      readonly _tag: "InsufficientFreshness";
+      readonly message: string;
+    }, limits: MemoryRecallLimits) => Effect.Effect<{
+      readonly _tag: "Found";
+      readonly passages: readonly import("@effect-agent/core").MemoryPassage[];
+    } | {
+      readonly _tag: "NoMatch";
+    } | {
+      readonly _tag: "Unavailable";
+      readonly message: string;
+    } | {
+      readonly _tag: "InsufficientFreshness";
+      readonly message: string;
+    }, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+    revalidateSemantic: (found: MemoryIndexSearch<Namespace>, profile: SemanticMemoryProfile, limits: SemanticCandidateLimits) => Effect.Effect<import("@effect-agent/core").SemanticCandidateResult, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+    change: (write: MemoryWrite<Namespace>) => Effect.Effect<MemoryDocument<Namespace>, import("@effect-agent/core").MemoryConflict | import("@effect-agent/core").MemoryIndexError | import("@effect-agent/core").MemoryMutationFailure | import("@effect-agent/core").MemoryOperationConflict | import("@effect-agent/core").MemoryRecallError | MemoryRpcError | MemoryStorageError | import("@effect-agent/core").MemoryWithdrawn | import("@effect-agent/core").SemanticMemoryError, never>;
+  }, MemoryRpcError, never>;
+};
+/**
+ * Optional activity-processor destination. Keeps domain write errors intact; transport,
+ * authorization and deadline failures become the existing MemoryStorageError contract.
+ * Receipts remain authoritative, including after caller interruption or lost replies.
+ */
+declare const cloudflareMemoryWriterLayer: (access: MemoryAccess, principal: Principal, limits?: MemoryRpcLimits) => Layer.Layer<MemoryWriter, MemoryRpcError, MemoryObjectNamespace>;
+type OwnerServices = MemoryReader | MemoryWriter | MemoryOwnerAuthorizer | MemoryOwnerIdentity;
+interface MemoryObjectInstance extends InstanceType<DurableObject.DurableObjectClass<Record<never, never>, OwnerServices>> {
+  memory(encoded: string): Promise<string>;
+}
+interface MemoryObjectClass {
+  new (ctx: globalThis.DurableObjectState, env: Cloudflare.Env): MemoryObjectInstance;
+}
+/**
+ * Dedicated SQLite owner, independent of Thread lifetimes. The host binds authorization
+ * after restoring its namespace definition from MemoryOwnerIdentity. Do not retain
+ * cleanup-scoped resources in the host Layer; it lives for the DO incarnation.
+ */
+declare const makeMemoryObject: <E>(host: Layer.Layer<MemoryOwnerAuthorizer, E, MemoryOwnerIdentity | DurableObjectState$1.DurableObjectState | WorkerEnvironment>, options?: {
+  readonly storageLimits?: DoMemoryStorageLimits;
+  readonly rpcLimits?: MemoryRpcLimits;
+  readonly failpoints?: Layer.Layer<MemoryMutationFailpoint, never, DurableObjectState$1.DurableObjectState>;
+}) => MemoryObjectClass;
+declare const MemoryObject: {
+  /** Build the SQLite Durable Object class with the application's owner authorization Layer. */
+  make: typeof makeMemoryObject;
+};
+//#endregion
+export { AbortRecorded, AdmissionLimitExceeded, ApprovalRecorded, AwaitProgressRequest, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CancelProgressRequest, ClientAbortFailure, ClientApprovalFailure, ClientAwaitFailure, ClientObserveFailure, ClientProgressFailure, ClientSubmitFailure, ClientUnknownFailure, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareBrowser, type CloudflareBrowserOptions, CloudflareCodeMode, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflareMemoryClient, CloudflarePlatformConfigError, CloudflareSchedulingClient, CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, CloudflareThreadClient, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, DynamicWorkerCodeExecutorOptions, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassFailure, MaintenancePassReport, MemoryObject, MemoryObjectClass, MemoryObjectInstance, MemoryObjectNamespace, MemoryObjectRpc, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, ProgressWaitRegistry, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerObjectClass, ScheduleOwnerObjectInstance, ScheduleOwnerObjectRpc, ScheduleOwnerProtocolError, SettlementReached, SubmitRequest, SubmitSucceeded, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionObjectClass, SubscriptionPartitionObjectInstance, SubscriptionPartitionObjectRpc, SubscriptionPartitionProtocolError, ThreadClientError, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMaintenanceFailpointHandler, ThreadMaintenanceFailpointLocation, thread_object_d_exports as ThreadObject, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPorts, ThreadObjectRpc, UnknownResolutionRecorded, boundHostDiagnostic, cloudflareMemoryWriterLayer, cloudflarePreparedInputAdmissionLayer, cloudflareScheduledInputAdmissionLayer, cloudflareWakeSchedulerLayer, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, disposeRpcHandle, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, layerFromBindings, makeScheduleOwnerObjectClass, makeSubscriptionPartitionObjectClass, memoryObjectName, sourcePartitionName, threadNamespaceFromEnv, threadNamespaceLayer, threadPortTransportLayer, validateCloudflareSubscriptionLimits };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -4,9 +4,9 @@ import { CloudflareSchedulingClient, ScheduleAlarmProtocolError, ScheduleOwnerId
 import { CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionProtocolError, makeSubscriptionPartitionObjectClass, sourcePartitionName, validateCloudflareSubscriptionLimits } from "./subscriptions.mjs";
 import { CloudflareBrowser } from "./browser-quick-action.mjs";
 import { Clock, Context, Deferred, Duration, Effect, Exit, Fiber, Layer, Option, PubSub, Queue, Ref, Schema, Stream } from "effect";
-import { ThreadPortTransport, decodePortRequest, encodePortResponse, executePortRequest, portTransportFailure, routedSubmissionLedgerLayer, routedThreadStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer, threadStoreLayer } from "@effect-agent/storage-cloudflare";
-import { AppendConflict, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IntegrityReport, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, ProducerId, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ThreadNotMaterialized, ThreadRead, ThreadStore, ThreadStoreError, ToolReconciler, WakeScheduler, compileRegistrations, makeWakeSubscriptionHub, operationAuthorizerLayer } from "@effect-agent/thread";
-import { SubmissionId, ThreadId } from "@effect-agent/core";
+import { MemoryOwnerIdentity, MemoryOwnerRequest, MemoryOwnerResponse, MemoryRpcError, MemoryRpcLimits, ThreadPortTransport, decodeMemoryWire, decodePortRequest, defaultDoMemoryStorageLimits, defaultMemoryRpcLimits, doMemoryStoreLayerWithFailpoints, encodeMemoryWire, encodePortResponse, executePortRequest, handleMemoryOwnerRequest, portTransportFailure, routedSubmissionLedgerLayer, routedThreadStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer, threadStoreLayer } from "@effect-agent/storage-cloudflare";
+import { AppendConflict, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IntegrityReport, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, Principal, ProducerId, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ThreadNotMaterialized, ThreadRead, ThreadStore, ThreadStoreError, ToolReconciler, WakeScheduler, compileRegistrations, makeWakeSubscriptionHub, operationAuthorizerLayer } from "@effect-agent/thread";
+import { Memory, MemoryAccess, MemoryDocument, MemoryMutationFailpoint, MemoryNamespace, MemoryNamespaceAddress, MemoryRecallLimits, MemoryStorageError, MemoryWriter, SubmissionId, ThreadId } from "@effect-agent/core";
 import { CurrentToolFailureObserver, RunContextPreparationPassthrough, RunToolAuthorization, toolFailureObserverLayer } from "@effect-agent/engine";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
@@ -226,7 +226,12 @@ const layerConfig = (options) => Layer.unwrap(Effect.gen(function* () {
 * Use Layer.unwrap for registration values that need effectful application setup.
 */
 const layer = (registrations) => Layer.unwrap(Effect.map(compileRegistrations(registrations), layerFromBindings));
-/** Internal assembly shared by registration compilation and low-level adapter fixtures. */
+/**
+* Assemble the durable runtime from already-resolved Agent Bindings.
+* Use `ThreadObject.layer` to compile typed Agent registrations instead.
+* Supply host services through `ThreadObject.make` or `ThreadObject.layerConfig` and
+* the Durable Object context and namespace Layers when composing a custom host.
+*/
 const layerFromBindings = (bindings) => Layer.unwrap(Effect.gen(function* () {
 	const { ctx } = yield* DurableObjectContext;
 	const config = yield* CloudflareDurableRuntimeConfig;
@@ -1203,6 +1208,150 @@ const CloudflareCodeMode = {
 */
 layer: (definition, options) => definition.handlers.pipe(Layer.provide(options.handlers), Layer.provide(dynamicWorkerCodeExecutorLayer(options))) };
 //#endregion
-export { AbortRecorded, AdmissionLimitExceeded, ApprovalRecorded, AwaitProgressRequest, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CancelProgressRequest, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareBrowser, CloudflareCodeMode, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError, CloudflareSchedulingClient, CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, CloudflareThreadClient, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassReport, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, ProgressWaitRegistry, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerProtocolError, SettlementReached, SubmitRequest, SubmitSucceeded, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionProtocolError, ThreadClientError, ThreadMaintenance, ThreadMaintenanceFailpoint, thread_object_exports as ThreadObject, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPorts, UnknownResolutionRecorded, boundHostDiagnostic, cloudflarePreparedInputAdmissionLayer, cloudflareScheduledInputAdmissionLayer, cloudflareWakeSchedulerLayer, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, disposeRpcHandle, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeScheduleOwnerObjectClass, makeSubscriptionPartitionObjectClass, sourcePartitionName, threadNamespaceFromEnv, threadNamespaceLayer, threadPortTransportLayer, validateCloudflareSubscriptionLimits };
+//#region src/memory.ts
+var MemoryObjectNamespace = class extends Context.Service()("@effect-agent/platform-cloudflare/MemoryObjectNamespace") {};
+/** Namespace version and identity are already canonicalized by MemoryNamespace. */
+const memoryObjectName = (namespace) => namespace.address;
+/**
+* Effect-native, host-bound memory client. Recall revalidates the entire admitted lookup
+* in one RPC and renders it locally. No retries or per-source splitting occur here.
+* Interrupted callers stop waiting; the owner has its own deadline. A timed-out write
+* may have committed: reconcile by sending the identical operation ID and command.
+*/
+const makeMemoryClient = Effect.fn("CloudflareMemoryClient.make")(function* (access, principal, rpcLimits = defaultMemoryRpcLimits) {
+	const validated = yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(rpcLimits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+	const bound = yield* Schema.decodeUnknownEffect(MemoryAccess.Wire)(access).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+	principal = yield* Schema.decodeUnknownEffect(Principal)(principal).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+	const { namespace } = yield* MemoryObjectNamespace;
+	const call = Effect.fn("CloudflareMemoryClient.call")(function* (request) {
+		const decoded = yield* Schema.decodeUnknownEffect(MemoryOwnerRequest)(request).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		const encoded = yield* encodeMemoryWire(MemoryOwnerRequest, decoded, validated.maxRequestBytes);
+		const raw = yield* Effect.tryPromise({
+			try: () => namespace.get(namespace.idFromName(memoryObjectName(bound.namespace))).memory(encoded),
+			catch: () => MemoryRpcError.make({ reason: "unavailable" })
+		});
+		const response = yield* decodeMemoryWire(MemoryOwnerResponse, raw, validated.maxResponseBytes);
+		if (response._tag === "Failed") return yield* response.failure;
+		if (!MemoryNamespace.equals(response.access.namespace, bound.namespace) || response.access.scope !== bound.scope) return yield* MemoryRpcError.make({ reason: "protocol" });
+		return response;
+	});
+	const withinDeadline = (effect, timeoutMillis) => effect.pipe(Effect.timeoutOrElse({
+		duration: timeoutMillis,
+		orElse: () => Effect.fail(MemoryRpcError.make({ reason: "timeout" }))
+	}));
+	const revalidate = Effect.fn("CloudflareMemoryClient.revalidate")(function* (lookup, limits) {
+		limits = yield* Schema.decodeUnknownEffect(MemoryRecallLimits)(limits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		const timeoutMillis = Math.min(validated.timeoutMillis, limits.timeoutMillis);
+		return yield* Effect.gen(function* () {
+			const response = yield* call({
+				_tag: "Revalidate",
+				version: 1,
+				access: bound,
+				principal,
+				lookup,
+				limits,
+				deadlineMillis: (yield* Clock.currentTimeMillis) + timeoutMillis
+			});
+			if (response._tag !== "Lookup") return yield* MemoryRpcError.make({ reason: "protocol" });
+			return response.lookup;
+		}).pipe((effect) => withinDeadline(effect, timeoutMillis));
+	});
+	const change = Effect.fn("CloudflareMemoryClient.change")(function* (write) {
+		if (!MemoryNamespace.equals(write.key.namespace, bound.namespace)) return yield* MemoryRpcError.make({ reason: "denied" });
+		return yield* Effect.gen(function* () {
+			const response = yield* call({
+				_tag: "Change",
+				version: 1,
+				access: bound,
+				principal,
+				write,
+				deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis
+			});
+			if (response._tag !== "Changed" || response.document.key.id !== write.key.id) return yield* MemoryRpcError.make({ reason: "protocol" });
+			return yield* MemoryDocument.restore(access.namespace, response.document);
+		}).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));
+	});
+	const revalidateSemantic = Effect.fn("CloudflareMemoryClient.revalidateSemantic")(function* (found, profile, limits) {
+		return yield* Effect.gen(function* () {
+			const response = yield* call({
+				_tag: "RevalidateSemantic",
+				version: 1,
+				access: bound,
+				principal,
+				found,
+				profile,
+				limits,
+				deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis
+			});
+			if (response._tag !== "Semantic") return yield* MemoryRpcError.make({ reason: "protocol" });
+			return response.result;
+		}).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));
+	});
+	return {
+		recall: Effect.fn("CloudflareMemoryClient.recall")(function* (lookup, limits, estimateTokens) {
+			return yield* Memory.recall([{
+				id: "memory",
+				essential: true,
+				read: revalidate(lookup, limits)
+			}], limits, estimateTokens);
+		}),
+		revalidate,
+		revalidateSemantic,
+		change
+	};
+});
+const CloudflareMemoryClient = {
+	/** Bind access and principal using the MemoryObjectNamespace supplied by the application. */
+	make: makeMemoryClient,
+	/** Use a resolved Worker or Durable Object binding without manual service provisioning. */
+	fromBinding: Effect.fn("CloudflareMemoryClient.fromBinding")(function* (binding, options) {
+		return yield* makeMemoryClient(options.access, options.principal, options.rpcLimits).pipe(Effect.provideService(MemoryObjectNamespace, { namespace: binding }));
+	})
+};
+/**
+* Optional activity-processor destination. Keeps domain write errors intact; transport,
+* authorization and deadline failures become the existing MemoryStorageError contract.
+* Receipts remain authoritative, including after caller interruption or lost replies.
+*/
+const cloudflareMemoryWriterLayer = (access, principal, limits = defaultMemoryRpcLimits) => Layer.effect(MemoryWriter, Effect.gen(function* () {
+	const client = yield* CloudflareMemoryClient.make(access, principal, limits);
+	return MemoryWriter.fromAdapter({ change: (write) => client.change(write).pipe(Effect.catchTag("MemoryRpcError", (error) => Effect.fail(MemoryStorageError.make({
+		operation: `memory RPC ${error.reason}`,
+		reason: error.reason === "unavailable" || error.reason === "timeout" ? "unavailable" : "invalid-input"
+	}))), Effect.catchTag([
+		"MemoryRecallError",
+		"MemoryIndexError",
+		"SemanticMemoryError"
+	], () => Effect.fail(MemoryStorageError.make({
+		operation: "memory RPC response",
+		reason: "corrupt"
+	})))) });
+}));
+/**
+* Dedicated SQLite owner, independent of Thread lifetimes. The host binds authorization
+* after restoring its namespace definition from MemoryOwnerIdentity. Do not retain
+* cleanup-scoped resources in the host Layer; it lives for the DO incarnation.
+*/
+const makeMemoryObject = (host, options = {}) => {
+	const identity = Layer.effect(MemoryOwnerIdentity, Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		const address = yield* Schema.decodeUnknownEffect(MemoryNamespaceAddress)(state.raw.id.name).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "denied" })));
+		return { namespace: MemoryNamespace.Any.make({ address }) };
+	}));
+	const store = Layer.unwrap(Effect.map(DurableObjectState.DurableObjectState, (state) => doMemoryStoreLayerWithFailpoints(state.raw.storage, options.storageLimits ?? defaultDoMemoryStorageLimits))).pipe(Layer.provide(options.failpoints ?? MemoryMutationFailpoint.layer));
+	const application = Layer.merge(store, host).pipe(Layer.provideMerge(identity));
+	const runtime = Layer.effectContext(Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		const scope = yield* Effect.scope;
+		yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(options.rpcLimits ?? defaultMemoryRpcLimits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
+		return yield* state.blockConcurrencyWhile(Layer.buildWithScope(application, scope));
+	}));
+	return DurableObject.make(runtime, { rpc: { memory: (encoded) => handleMemoryOwnerRequest(encoded, options.rpcLimits) } });
+};
+const MemoryObject = { 
+/** Build the SQLite Durable Object class with the application's owner authorization Layer. */
+make: makeMemoryObject };
+//#endregion
+export { AbortRecorded, AdmissionLimitExceeded, ApprovalRecorded, AwaitProgressRequest, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CancelProgressRequest, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareBrowser, CloudflareCodeMode, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflareMemoryClient, CloudflarePlatformConfigError, CloudflareSchedulingClient, CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, CloudflareThreadClient, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassReport, MemoryObject, MemoryObjectNamespace, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, ProgressWaitRegistry, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerProtocolError, SettlementReached, SubmitRequest, SubmitSucceeded, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionProtocolError, ThreadClientError, ThreadMaintenance, ThreadMaintenanceFailpoint, thread_object_exports as ThreadObject, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPorts, UnknownResolutionRecorded, boundHostDiagnostic, cloudflareMemoryWriterLayer, cloudflarePreparedInputAdmissionLayer, cloudflareScheduledInputAdmissionLayer, cloudflareWakeSchedulerLayer, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, disposeRpcHandle, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, layerFromBindings, makeScheduleOwnerObjectClass, makeSubscriptionPartitionObjectClass, memoryObjectName, sourcePartitionName, threadNamespaceFromEnv, threadNamespaceLayer, threadPortTransportLayer, validateCloudflareSubscriptionLimits };
 
 //# sourceMappingURL=index.mjs.map