@effect-agent/platform-cloudflare 0.1.0-beta.39 → 0.1.0-beta.41

package/dist/index.d.mts

@@ -1,10 +1,11 @@
-import { a as ThreadObjectRpc, i as ThreadObjectNamespace, n as DurableObjectContext, o as threadNamespaceFromEnv, r as ThreadObjectIdentity, s as threadNamespaceLayer, t as CloudflareBindingError } from "./bindings-C00ZfjsX.mjs";
+import { CloudflareBrowser, CloudflareBrowserOptions } from "./browser-quick-action.mjs";
+import { a as ThreadObjectRpc, i as ThreadObjectNamespace, n as DurableObjectContext, o as threadNamespaceFromEnv, r as ThreadObjectIdentity, s as threadNamespaceLayer, t as CloudflareBindingError } from "./bindings-BrVEOkfe.mjs";
 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";
@@ -348,7 +349,18 @@ 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>;
 //#endregion
 //#region src/client.d.ts
 /** Truncate a diagnostic string to the host protocol's bounded length. */
@@ -792,6 +804,29 @@ 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;
@@ -831,6 +866,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;
@@ -925,6 +961,11 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
     readonly threadId: string;
     readonly actualEpoch: number;
     readonly attemptedEpoch: 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";
@@ -932,28 +973,15 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
     readonly threadId?: string | undefined;
     readonly submissionId?: string | undefined;
   } | {
-    readonly _tag: "AgentInputError";
+    readonly _tag: "HostProtocolError";
     readonly message: string;
   } | {
-    readonly _tag: "DigestError";
+    readonly _tag: "AgentInputError";
     readonly message: string;
-    readonly cause?: Schema.Json | undefined;
-  } | {
-    readonly _tag: "DurableRuntimeFailpointError";
-    readonly location: "abort:after-intent" | "approval:after-request-append" | "approval:after-suspend" | "claim:after-claim" | "compaction:after-canonical-append" | "input:after-canonical-append" | "join:after-canonical-append" | "join:after-claim" | "policy:after-reservation-append" | "policy:before-reservation-append" | "resolve:after-intent" | "run:after-start-append" | "run:before-start-append" | "step:after-step-append" | "subagent:after-admit" | "subagent:after-child-abort-intent" | "subagent:after-child-ready" | "subagent:after-join-append" | "subagent:after-release" | "subagent:after-release-pending" | "subagent:after-request-append" | "subagent:after-reserve" | "subagent:after-sibling-settle" | "subagent:after-start-append" | "subagent:after-suspend" | "submit:after-admit" | "submit:after-materialize" | "terminalize:after-canonical-append" | "terminalize:after-reserve" | "tools:after-prepared-append" | "tools:before-prepared-append" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
-  } | {
-    readonly _tag: "AdmissionLimitExceeded";
-    readonly limit: "database-bytes" | "input-bytes" | "queue-depth";
-    readonly actual: number;
-    readonly maximum: number;
   } | {
-    readonly _tag: "DurableAlarmError";
-    readonly operation: string;
+    readonly _tag: "DigestError";
     readonly message: string;
     readonly cause?: Schema.Json | undefined;
-  } | {
-    readonly _tag: "HostProtocolError";
-    readonly message: string;
   } | {
     readonly _tag: "ApprovalConflict";
     readonly submissionId: string;
@@ -963,6 +991,14 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
     readonly _tag: "UnknownResolutionConflict";
     readonly submissionId: string;
     readonly toolCallId: string;
+  } | {
+    readonly _tag: "DurableRuntimeFailpointError";
+    readonly location: "abort:after-intent" | "approval:after-request-append" | "approval:after-suspend" | "claim:after-claim" | "compaction:after-canonical-append" | "input:after-canonical-append" | "join:after-canonical-append" | "join:after-claim" | "policy:after-reservation-append" | "policy:before-reservation-append" | "resolve:after-intent" | "run:after-start-append" | "run:before-start-append" | "step:after-step-append" | "subagent:after-admit" | "subagent:after-child-abort-intent" | "subagent:after-child-ready" | "subagent:after-join-append" | "subagent:after-release" | "subagent:after-release-pending" | "subagent:after-request-append" | "subagent:after-reserve" | "subagent:after-sibling-settle" | "subagent:after-start-append" | "subagent:after-suspend" | "submit:after-admit" | "submit:after-materialize" | "terminalize:after-canonical-append" | "terminalize:after-reserve" | "tools:after-prepared-append" | "tools:before-prepared-append" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
+  } | {
+    readonly _tag: "AdmissionLimitExceeded";
+    readonly limit: "database-bytes" | "input-bytes" | "queue-depth";
+    readonly actual: number;
+    readonly maximum: number;
   };
 }, Schema.SchemaError, never>;
 declare const decodeHostResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | SubmitSucceeded | UnknownResolutionRecorded, Schema.SchemaError, never>;
@@ -1012,6 +1048,15 @@ declare const CloudflareThreadClient_base: Context.ServiceClass<CloudflareThread
 }>;
 /** Worker-side client over the Thread Object namespace (DEPLOY-010). */
 declare class CloudflareThreadClient extends CloudflareThreadClient_base {
+  /**
+   * Assemble the client from a resolved namespace and the platform Crypto implementation.
+   * rpcTracing is the binding name and remains opt-in. Caller authentication, principals,
+   * idempotency keys, and definition digests are still explicit submission inputs.
+   */
+  static layerFromBinding(options: {
+    readonly namespace: DurableObjectNamespace<ThreadObjectRpc>;
+    readonly rpcTracing?: string;
+  }): Layer.Layer<CloudflareThreadClient>;
   static readonly layer: Layer.Layer<CloudflareThreadClient, never, ThreadObjectNamespace | Crypto.Crypto>;
 }
 declare namespace thread_object_d_exports {
@@ -1626,6 +1671,143 @@ interface DynamicWorkerCodeExecutorOptions {
 }
 /** Layer building the Dynamic Worker `CodeExecutor` from resolved bindings. */
 declare const dynamicWorkerCodeExecutorLayer: (options: DynamicWorkerCodeExecutorOptions) => Layer.Layer<CodeExecutor>;
+/** Assemble Code Mode handlers with the isolated Dynamic Worker executor. */
+declare const CloudflareCodeMode: {
+  /**
+   * Provide the selected tool handlers at construction, where Code Mode captures them.
+   * Their errors and remaining dependencies stay visible. The definition still owns the
+   * allowlist and limits; the runtime supplies the live Tool broker for each scoped pass.
+   */
+  layer: <A, E, R, Handlers, HandlerError, HandlerRequirements>(definition: {
+    readonly handlers: Layer.Layer<A, E, R>;
+  }, options: DynamicWorkerCodeExecutorOptions & {
+    readonly handlers: Layer.Layer<Handlers, HandlerError, HandlerRequirements>;
+  }) => Layer.Layer<A, E | HandlerError, Exclude<HandlerRequirements, CodeExecutor> | Exclude<Exclude<R, Handlers>, CodeExecutor>>;
+};
+//#endregion
+//#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, 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 };
+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, makeScheduleOwnerObjectClass, makeSubscriptionPartitionObjectClass, memoryObjectName, sourcePartitionName, threadNamespaceFromEnv, threadNamespaceLayer, threadPortTransportLayer, validateCloudflareSubscriptionLimits };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,11 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { $ as CloudflarePlatformConfigError, A as decodeUnknownResolutionCommand, B as DurableAlarmError, C as decodeApprovalDecisionCommand, D as decodeObservePageRequest, E as decodeHostResponse, F as encodeHostResponse, G as safeCauseDiagnostic, H as MaintenancePassReport, I as encodeObservePageRequest, J as CLOUDFLARE_DATABASE_CAP_BYTES, K as safeCauseMessage, L as encodeReceipt, M as encodeApprovalDecisionCommand, N as encodeAwaitProgressRequest, O as decodeReceipt, P as encodeCancelProgressRequest, Q as CloudflareDurableRuntimeConfigValue, R as encodeSubmitRequest, S as decodeAbortCommand, T as decodeCancelProgressRequest, U as ThreadMaintenance, V as DurableAlarmService, W as ThreadMaintenanceFailpoint, X as CloudflareAdmissionLimitsValue, Y as CLOUDFLARE_RUNTIME_DEFAULTS, Z as CloudflareDurableRuntimeConfig, _ as SubmitRequest, a as AwaitProgressRequest, at as threadNamespaceFromEnv, b as UnknownResolutionRecorded, c as HostFailed, d as HostResponse, et as DEFAULT_MAX_DATABASE_BYTES, f as ObservePageRequest, g as SettlementReached, h as ProgressObserved, i as ApprovalRecorded, it as ThreadObjectNamespace, j as encodeAbortCommand, k as decodeSubmitRequest, l as HostFailure, m as ProgressCancelled, n as cloudflareScheduledInputAdmissionLayer, nt as DurableObjectContext, o as CancelProgressRequest, ot as threadNamespaceLayer, p as ObservedPage, q as AdmissionLimitExceeded, r as AbortRecorded, rt as ThreadObjectIdentity, s as CloudflareThreadClient, t as cloudflarePreparedInputAdmissionLayer, tt as CloudflareBindingError, u as HostProtocolError, v as SubmitSucceeded, w as decodeAwaitProgressRequest, x as boundHostDiagnostic, y as ThreadClientError, z as encodeUnknownResolutionCommand } from "./prepared-admission-D5hQ-ofV.mjs";
+import { $ as CloudflarePlatformConfigError, A as decodeUnknownResolutionCommand, B as DurableAlarmError, C as decodeApprovalDecisionCommand, D as decodeObservePageRequest, E as decodeHostResponse, F as encodeHostResponse, G as safeCauseDiagnostic, H as MaintenancePassReport, I as encodeObservePageRequest, J as CLOUDFLARE_DATABASE_CAP_BYTES, K as safeCauseMessage, L as encodeReceipt, M as encodeApprovalDecisionCommand, N as encodeAwaitProgressRequest, O as decodeReceipt, P as encodeCancelProgressRequest, Q as CloudflareDurableRuntimeConfigValue, R as encodeSubmitRequest, S as decodeAbortCommand, T as decodeCancelProgressRequest, U as ThreadMaintenance, V as DurableAlarmService, W as ThreadMaintenanceFailpoint, X as CloudflareAdmissionLimitsValue, Y as CLOUDFLARE_RUNTIME_DEFAULTS, Z as CloudflareDurableRuntimeConfig, _ as SubmitRequest, a as AwaitProgressRequest, at as threadNamespaceFromEnv, b as UnknownResolutionRecorded, c as HostFailed, d as HostResponse, et as DEFAULT_MAX_DATABASE_BYTES, f as ObservePageRequest, g as SettlementReached, h as ProgressObserved, i as ApprovalRecorded, it as ThreadObjectNamespace, j as encodeAbortCommand, k as decodeSubmitRequest, l as HostFailure, m as ProgressCancelled, n as cloudflareScheduledInputAdmissionLayer, nt as DurableObjectContext, o as CancelProgressRequest, ot as threadNamespaceLayer, p as ObservedPage, q as AdmissionLimitExceeded, r as AbortRecorded, rt as ThreadObjectIdentity, s as CloudflareThreadClient, t as cloudflarePreparedInputAdmissionLayer, tt as CloudflareBindingError, u as HostProtocolError, v as SubmitSucceeded, w as decodeAwaitProgressRequest, x as boundHostDiagnostic, y as ThreadClientError, z as encodeUnknownResolutionCommand } from "./prepared-admission-BKp_Upw2.mjs";
 import { CloudflareSchedulingClient, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerProtocolError, makeScheduleOwnerObjectClass } from "./scheduling.mjs";
 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";
@@ -539,7 +540,8 @@ const effectCfPlatformLayer = (namespaceBinding, rpcTracing = false) => {
 		});
 	}));
 	const namespace = Layer.effect(ThreadObjectNamespace)(Effect.gen(function* () {
-		const binding = yield* threadNamespaceFromEnv(yield* WorkerEnvironment, namespaceBinding);
+		const env = yield* WorkerEnvironment;
+		const binding = yield* threadNamespaceFromEnv(env, namespaceBinding);
 		return ThreadObjectNamespace.of({
 			namespace: binding,
 			...rpcTracing === true ? { rpcTracing: namespaceBinding } : {}
@@ -781,7 +783,7 @@ export default class CodeModeHarness extends WorkerEntrypoint {
   }
 }
 `;
-const BoundedLogs = Schema.Array(Schema.String.check(Schema.isMaxLength(16 * 1024))).check(Schema.isMaxLength(4096));
+const BoundedLogs = Schema.Array(Schema.String.check(Schema.isMaxLength(16384))).check(Schema.isMaxLength(4096));
 const HarnessCompleted = Schema.TaggedStruct("completed", {
 	value: Schema.Json,
 	logs: BoundedLogs,
@@ -1192,7 +1194,159 @@ const dynamicWorkerCodeExecutorLayer = (options) => Layer.effect(CodeExecutor, E
 	const clock = yield* Clock.Clock;
 	return CodeExecutor.of({ execute: makeExecute(options, clock) });
 }));
+/** Assemble Code Mode handlers with the isolated Dynamic Worker executor. */
+const CloudflareCodeMode = { 
+/**
+* Provide the selected tool handlers at construction, where Code Mode captures them.
+* Their errors and remaining dependencies stay visible. The definition still owns the
+* allowlist and limits; the runtime supplies the live Tool broker for each scoped pass.
+*/
+layer: (definition, options) => definition.handlers.pipe(Layer.provide(options.handlers), Layer.provide(dynamicWorkerCodeExecutorLayer(options))) };
+//#endregion
+//#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, 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 };
+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, makeScheduleOwnerObjectClass, makeSubscriptionPartitionObjectClass, memoryObjectName, sourcePartitionName, threadNamespaceFromEnv, threadNamespaceLayer, threadPortTransportLayer, validateCloudflareSubscriptionLimits };
 
 //# sourceMappingURL=index.mjs.map