effect-cf 0.41.1 → 0.42.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # effect-cf
 
+## 0.42.1
+
+### Patch Changes
+
+- [#171](https://github.com/danieljvdm/effect-cf/pull/171) [`06a0bfc`](https://github.com/danieljvdm/effect-cf/commit/06a0bfc1f750f5042e13f97b212c63ced5caa5e5) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Prevent the first Durable Object event from overtaking an initialization hook's concurrency gate while its service layer is still building. Hooks that perform background setup without a concurrency gate continue to allow incoming events.
+
+- [#170](https://github.com/danieljvdm/effect-cf/pull/170) [`4c41e8d`](https://github.com/danieljvdm/effect-cf/commit/4c41e8d648f340dbf43c5e2c17a850d967b7fa09) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Prevent Durable Object storage transactions and concurrency-blocking callbacks from stalling when their Effect work yields while an earlier timer is blocked by the native input gate.
+
+## 0.42.0
+
+### Minor Changes
+
+- [#163](https://github.com/danieljvdm/effect-cf/pull/163) [`8817ade`](https://github.com/danieljvdm/effect-cf/commit/8817adeead3fcaaf3b199ad02de7f5f347af88a5) Thanks [@limwa](https://github.com/limwa)! - Add `Worker.native(schema)` and `DurableObject.native(schema)` for RPC arguments and results that Cloudflare must transport without JSON encoding, including byte streams, requests, and responses.
+
+### Patch Changes
+
+- [#169](https://github.com/danieljvdm/effect-cf/pull/169) [`7560c67`](https://github.com/danieljvdm/effect-cf/commit/7560c67e392c9906dd8019a0c951e6c08b4ac306) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Fix TS2883 in consumers that export binding layers, D1 and service-binding classes, or Queue, Workflow, Worker, and Durable Object operations with `declaration` or `composite` enabled. These exports now emit portable types without consumers importing additional namespaces or annotating otherwise inferred values.
+
+  `isolatedDeclarations` continues to require explicit type annotations and a named class base instead of a factory call in `extends`.
+
+- [#166](https://github.com/danieljvdm/effect-cf/pull/166) [`183c198`](https://github.com/danieljvdm/effect-cf/commit/183c19896cb1a27675dce9a462893fcc96b6e3d6) Thanks [@limwa](https://github.com/limwa)! - Fix TS2883 when extending `Queue.Tag(...)` in projects that emit declarations with `declaration` or `composite`. The inferred base type can now be named through the `Queue` namespace. With `isolatedDeclarations`, TypeScript still requires an explicitly typed base variable instead of a factory call in the `extends` clause.
+
+- [#165](https://github.com/danieljvdm/effect-cf/pull/165) [`1681cbb`](https://github.com/danieljvdm/effect-cf/commit/1681cbb767954a90aa0222fd44485abfb490b98a) Thanks [@limwa](https://github.com/limwa)! - Fix TS2883 when extending `Workflow.Tag(...)` in projects that emit declarations with `declaration` or `composite`. The inferred base type can now be named through the `Workflow` namespace. With `isolatedDeclarations`, TypeScript still requires an explicitly typed base variable instead of a factory call in the `extends` clause.
+
 ## 0.41.1
 
 ### Patch Changes

package/README.md

@@ -23,6 +23,34 @@ export default Worker.make(Layer.empty, {
 
 `Worker.make` owns the Effect runtime. Pass application services as its layer; use `Worker.NativeRequest` inside the handler to read the request.
 
+### Native RPC values
+
+Tagged Worker and Durable Object methods encode declared schemas through their canonical JSON codec by default. Wrap a method argument or success schema with `Worker.native(schema)` or `DurableObject.native(schema)` when its encoded value must instead pass directly through Cloudflare RPC.
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import { Worker } from "effect-cf";
+
+const ByteStream = Schema.declare(
+  (value): value is ReadableStream<Uint8Array> => value instanceof ReadableStream,
+);
+
+class Documents extends Worker.Tag<Documents>()("Documents", {
+  upload: Worker.method({
+    args: [Worker.native(ByteStream)],
+    success: Schema.Void,
+  }),
+}) {}
+
+export default Documents.make(Layer.empty, {
+  rpc: {
+    upload: (body) => Effect.tryPromise(() => new Response(body).arrayBuffer()).pipe(Effect.asVoid),
+  },
+});
+```
+
+The wrapped schema still validates and transforms values, but its encoded form must be supported by Cloudflare RPC. Native byte streams must be byte-oriented (`type: "bytes"`). Cloudflare transfers stream ownership to the recipient; use `ReadableStream.tee()` first if the sender must retain a copy.
+
 ## Bindings
 
 Define a service, connect it to a Wrangler binding, then yield it in your program.

package/dist/AiGateway.d.mts

@@ -5,7 +5,7 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import { Layer } from "effect";
 declare namespace AiGateway_d_exports {
-  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };
+  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };
 }
 declare const AiGatewayOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "AiGatewayOperationError";
@@ -83,4 +83,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, AiGatewayClient>, defin
 declare const make: <Id extends string>(id: Id) => TagClass<AiGatewayService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, AiGateway_d_exports, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };
+export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, AiGateway_d_exports, type BindingNotFoundError, type BindingValidationError, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };

package/dist/AnalyticsEngine.d.mts

@@ -10,7 +10,7 @@ import * as HttpClient from "effect/unstable/http/HttpClient";
 import { Redacted } from "effect";
 import { Headers, HttpClientResponse } from "effect/unstable/http";
 declare namespace AnalyticsEngine_d_exports {
-  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, BindingNotFoundError, BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -167,4 +167,4 @@ declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsE
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
 //#endregion
-export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, AnalyticsEngine_d_exports, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
+export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, AnalyticsEngine_d_exports, type BindingNotFoundError, type BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };

package/dist/Artifacts.d.mts

@@ -4,7 +4,7 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import { Layer } from "effect";
 declare namespace Artifacts_d_exports {
-  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, BindingNotFoundError, BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
 }
 type ArtifactsOperation = "createClient" | "create" | "get" | "import" | "list" | "delete" | "createToken" | "listTokens" | "getToken" | "revokeToken" | "fork" | "info" | "log" | "readCommit" | "readTree" | "cli";
 declare const artifactsErrorCodes: readonly ["ALREADY_EXISTS", "NOT_FOUND", "IMPORT_IN_PROGRESS", "FORK_IN_PROGRESS", "INVALID_INPUT", "INVALID_REPO_NAME", "INVALID_TTL", "INVALID_URL", "REMOTE_AUTH_REQUIRED", "UPSTREAM_UNAVAILABLE", "MEMORY_LIMIT", "INTERNAL_ERROR"];
@@ -201,4 +201,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, ArtifactsClient>, defin
 declare const make: <Id extends string>(id: Id) => TagClass<ArtifactsService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Artifacts_d_exports, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Artifacts_d_exports, type BindingNotFoundError, type BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };

package/dist/BrowserRendering.d.mts

@@ -4,7 +4,7 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import { Layer } from "effect";
 declare namespace BrowserRendering_d_exports {
-  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions, Tag, TagClass, isBrowserRenderingBinding, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions, Tag, TagClass, isBrowserRenderingBinding, layer, make, makeClient };
 }
 declare const BrowserRenderingOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "BrowserRenderingOperationError";
@@ -82,4 +82,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, BrowserRenderingClient>
 declare const make: <Id extends string>(id: Id) => TagClass<BrowserRenderingService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, BrowserRendering_d_exports, LayerOptions, Tag, TagClass, isBrowserRenderingBinding, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingExternalResult, BrowserRenderingLaunch, BrowserRenderingMethodOptions, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageFunction, BrowserRenderingPageLike, BrowserRenderingService, BrowserRendering_d_exports, LayerOptions, Tag, TagClass, isBrowserRenderingBinding, layer, make, makeClient };

package/dist/ContainerNamespace.d.mts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Layer } from "effect";
 declare namespace ContainerNamespace_d_exports {
-  export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };
 }
 type ContainerSignal = "SIGKILL" | "SIGINT" | "SIGTERM";
 type ContainerStopSignal = ContainerSignal | number;
@@ -143,4 +143,4 @@ interface ContainerNamespaceService<Id extends string> {
 declare const Tag: <Self, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource>() => <Id extends string>(id: Id) => TagClass<Self, Id, Namespace>;
 declare const ContainerNamespace: typeof Tag;
 //#endregion
-export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerNamespace_d_exports, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerNamespace_d_exports, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };

package/dist/D1.d.mts

@@ -5,7 +5,7 @@ import { D1Client } from "@effect/sql-d1";
 import { SqlClient } from "effect/unstable/sql";
 import { Config } from "effect";
 declare namespace D1_d_exports {
-  export { D1Definition, D1Service, D1SqlLayerOptions, Service, TypeId, make };
+  export { BindingNotFoundError, BindingValidationError, D1Definition, D1Service, D1SqlLayerOptions, Service, ServiceClass, TypeId, make };
 }
 declare const TypeId: "~effect-cf/D1";
 type TypeId = typeof TypeId;
@@ -13,21 +13,18 @@ interface D1Definition {
   readonly binding: string;
 }
 type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
+type ServiceClass<Self, Id extends string> = BindingService<Self, Id, D1Database> & {
+  [TypeId]: typeof TypeId;
+  definition: D1Definition;
+  sqlLayer: (options?: D1SqlLayerOptions) => Layer$1.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
 declare const D1ServiceTypeId: unique symbol;
 interface D1Service<Id extends string> {
   readonly [D1ServiceTypeId]: {
     readonly id: Id;
   };
 }
-declare const make: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
-  "~effect-cf/D1": "~effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer$1.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
-declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
-  "~effect-cf/D1": "~effect-cf/D1";
-  definition: D1Definition;
-  sqlLayer: (options?: D1SqlLayerOptions) => Layer$1.Layer<D1Client.D1Client | SqlClient.SqlClient, Config.ConfigError | BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-};
+declare const make: <Id extends string>(id: Id, definition: D1Definition) => ServiceClass<D1Service<Id>, Id>;
+declare const Service: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => ServiceClass<Self, Id>;
 //#endregion
-export { D1Definition, D1Service, D1SqlLayerOptions, D1_d_exports, Service, TypeId, make };
+export { type BindingNotFoundError, type BindingValidationError, D1Definition, D1Service, D1SqlLayerOptions, D1_d_exports, Service, ServiceClass, TypeId, make };

package/dist/DurableObject.d.mts

@@ -1,16 +1,18 @@
 import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { DurableWebSocket } from "./DurableObjectWebSocket.mjs";
 import { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing.mjs";
 import { NativeRequest } from "./Worker.mjs";
 import { DurableObjectState } from "./DurableObjectState.mjs";
 import { AlarmRegistration, AlarmService, DurableObjectAlarm } from "./DurableObjectAlarm.mjs";
-import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method } from "./DurableObjectDefinition.mjs";
+import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcSchema, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method, native } from "./DurableObjectDefinition.mjs";
+import { DurableObjectFetchError, DurableObjectNamespaceClient, DurableObjectRpcError, DurableObjectStubClient, StubCall, StubRpc, StubScopedCall } from "./DurableObjectNamespace.mjs";
 import * as Effect from "effect/Effect";
 import * as Layer$1 from "effect/Layer";
 import { DurableObject } from "cloudflare:workers";
 import { Scope } from "effect";
 declare namespace DurableObject_d_exports {
-  export { Api, Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcApi as DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, RuntimeContext, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, make, method };
+  export { Api, BindingNotFoundError, BindingValidationError, Definition, DurableObjectClass, DurableObjectFetchError, DurableObjectHandler, DurableObjectNamespaceClient, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, DurableObjectRpcError, DurableObjectRpcApi as DurableObjectRpcShape, DurableObjectStubClient, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RpcSchema, RunOptions, RunSymbol, RuntimeContext, ServerApi, ServiceFreeSchema, StubCall, StubRpc, StubScopedCall, Tag, TagClass, implement, make, method, native };
 }
 type RuntimeContext<ROut> = DurableObjectState | DurableObjectAlarm | WorkerEnvironment | ROut;
 type HandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
@@ -45,8 +47,10 @@ interface DurableObjectOptionsBase<RRuntime, REvent = never, EventLayerError = n
   /**
    * Effect run when Cloudflare loads this Durable Object instance into memory.
    *
-   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
-   * incoming events should wait for setup to finish. Cloudflare may construct
+   * The base layer is acquired before incoming events are admitted. The hook
+   * itself runs in the background; start it with
+   * `DurableObjectState.blockConcurrencyWhile` when incoming events should
+   * wait for setup to finish. Cloudflare may construct
    * the same Durable Object id again after eviction or restart; use Durable
    * Object storage if work must happen only once per id.
    */
@@ -100,4 +104,4 @@ type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state:
 declare function make<ROut, LayerError>(layer: Layer$1.Layer<ROut, LayerError, RuntimeContext<never>> & CheckAlarmRegistration<ROut, never>): DurableObjectClass<Record<never, never>, ROut>;
 declare function make<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<NoInfer<ROut> | REvent | NoInfer<RAlarm>> = Record<never, never>, RAlarm = never>(layer: Layer$1.Layer<ROut, LayerError, RuntimeContext<NoInfer<RAlarm>>>, options: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc, RAlarm>): DurableObjectClass<Rpc, ROut | REvent | RAlarm>;
 //#endregion
-export { type Api, type Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, type DurableObjectRpcApi as DurableObjectRpcShape, DurableObject_d_exports, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, type NoReservedMethods, type Options, type ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, RuntimeContext, type ServerApi, type ServiceFreeSchema, Tag, type TagClass, implement, make, method };
+export { type Api, type BindingNotFoundError, type BindingValidationError, type Definition, DurableObjectClass, type DurableObjectFetchError, DurableObjectHandler, type DurableObjectNamespaceClient, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcApi, type DurableObjectRpcApi as DurableObjectRpcShape, type DurableObjectRpcError, type DurableObjectStubClient, DurableObject_d_exports, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, type NativeSchema, type NoReservedMethods, type Options, type ReservedMethodName, RpcHandlers, type RpcSchema, RunOptions, RunSymbol, RuntimeContext, type ServerApi, type ServiceFreeSchema, type StubCall, type StubRpc, type StubScopedCall, Tag, type TagClass, implement, make, method, native };

package/dist/DurableObject.mjs

@@ -7,9 +7,10 @@ import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
 import { scheduleTelemetryFlush as scheduleTelemetryFlush$1 } from "./internal/Telemetry.mjs";
 import { NativeRequest } from "./Worker.mjs";
 import { DurableObjectAlarm } from "./DurableObjectAlarm.mjs";
-import { Tag, implement, method } from "./DurableObjectDefinition.mjs";
+import { Tag, implement, method, native } from "./DurableObjectDefinition.mjs";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Scheduler from "effect/Scheduler";
 import { DurableObject } from "cloudflare:workers";
 import * as Tracer from "effect/Tracer";
 //#region src/DurableObject.ts
@@ -18,7 +19,8 @@ var DurableObject_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag,
 	implement: () => implement,
 	make: () => make,
-	method: () => method
+	method: () => method,
+	native: () => native
 });
 const reservedMethodNames = reservedMethodNames$1;
 /** Override to instrument the whole event, then call super[RunSymbol]. */
@@ -35,7 +37,10 @@ function make(layer, options = {}) {
 			const services = (registration?.layer ?? Layer.empty).pipe(Layer.provideMerge(baseServices));
 			this.runtime = makeEntrypointRuntime(layer, env, services);
 			const initialize = options.initialize;
-			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+			if (initialize !== void 0) state.waitUntil(state.blockConcurrencyWhile(async () => {
+				await Effect.runPromise(this.runtime.contextEffect, { scheduler: new Scheduler.MixedScheduler("sync") });
+				state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
+			}));
 		}
 		[RunSymbol](effect, runOptions = {}) {
 			const eventLayer = runOptions.eventLayer === false ? void 0 : options.eventLayer;
@@ -74,4 +79,4 @@ function make(layer, options = {}) {
 	return assumeEntrypointClass(EffectDurableObject);
 }
 //#endregion
-export { DurableObject_exports, RunSymbol, Tag, implement, make, method };
+export { DurableObject_exports, RunSymbol, Tag, implement, make, method, native };

package/dist/DurableObjectDefinition.d.mts

@@ -1,27 +1,29 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { Provider } from "./Rpc.mjs";
-import { ReservedMethodName as ReservedMethodName$1 } from "./RpcDefinition.mjs";
-import { DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient } from "./DurableObjectNamespace.mjs";
+import { NativeSchema as NativeSchema$1, ReservedMethodName as ReservedMethodName$1, RpcSchema as RpcSchema$1, SchemaType, WireEncoded, native as native$1 } from "./RpcDefinition.mjs";
+import { DurableObjectFetchError, DurableObjectNamespaceClient, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, StubCall, StubRpc, StubScopedCall } from "./DurableObjectNamespace.mjs";
 import { DurableObjectClass, DurableObjectHandler, DurableObjectOptions, RuntimeContext } from "./DurableObject.mjs";
 import * as Context$1 from "effect/Context";
 import { Layer, Schema } from "effect";
 declare namespace DurableObjectDefinition_d_exports {
-  export { Api, Definition, DurableObject, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, make, method };
+  export { Api, BindingNotFoundError, BindingValidationError, Definition, DurableObject, DurableObjectFetchError, DurableObjectNamespaceClient, DurableObjectRpcError, DurableObjectStubClient, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcSchema, ServerApi, ServiceFreeSchema, StubCall, StubRpc, StubScopedCall, Tag, TagClass, implement, make, method, native };
 }
 type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
-interface Method<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
+type NativeSchema<Schema extends ServiceFreeSchema = ServiceFreeSchema> = NativeSchema$1<Schema>;
+type RpcSchema = RpcSchema$1;
+interface Method<Args extends ReadonlyArray<RpcSchema> = ReadonlyArray<RpcSchema>, Success extends RpcSchema = RpcSchema> {
   readonly args: Args;
   readonly success: Success;
 }
 declare namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
+  export type Any = Method<ReadonlyArray<RpcSchema>, RpcSchema>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends RpcSchema, ...infer Tail extends ReadonlyArray<RpcSchema>] ? [SchemaType<Head>, ...ArgsFromSchemas<Tail>] : Array<SchemaType<Args[number]>>;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = { [Index in keyof Args]: WireEncoded<Args[Index]>; };
   export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
   export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
-  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
-  export type EncodedSuccess<_Self extends Any> = Schema.Json;
+  export type Success<Self extends Any> = SchemaType<Self["success"]>;
+  export type EncodedSuccess<Self extends Any> = WireEncoded<Self["success"]>;
   export {};
 }
 type Methods = Record<string, Method.Any>;
@@ -65,13 +67,14 @@ type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Cont
 /**
  * Defines a single RPC method schema in a Durable Object definition.
  */
-declare function method<Success extends ServiceFreeSchema>(definition: {
+declare function method<Success extends RpcSchema>(definition: {
   readonly success: Success;
 }): Method<readonly [], Success>;
-declare function method<const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+declare function method<const Args extends ReadonlyArray<RpcSchema>, Success extends RpcSchema>(definition: {
   readonly args: Args;
   readonly success: Success;
 }): Method<Args, Success>;
+declare const native: typeof native$1;
 declare const make: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Definition<Id, MethodDefinitions>, Id, MethodDefinitions>;
 declare const Tag: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Self, Id, MethodDefinitions>;
 declare const DurableObject: typeof Tag;
@@ -84,4 +87,4 @@ declare const implement: <ROut, const Self extends Definition.Any>(_definition:
  */
 type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method.Success<Self["methods"][Key]>>;
 //#endregion
-export { Api, Definition, DurableObject, DurableObjectDefinition_d_exports, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, make, method };
+export { Api, type BindingNotFoundError, type BindingValidationError, Definition, DurableObject, DurableObjectDefinition_d_exports, type DurableObjectFetchError, type DurableObjectNamespaceClient, type DurableObjectRpcError, type DurableObjectStubClient, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcSchema, ServerApi, ServiceFreeSchema, type StubCall, type StubRpc, type StubScopedCall, Tag, TagClass, implement, make, method, native };

package/dist/DurableObjectDefinition.mjs

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1 } from "./RpcDefinition.mjs";
+import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1, native as native$1 } from "./RpcDefinition.mjs";
 import { recordDecodedArgs } from "./internal/RpcInvocation.mjs";
 import { layer, makeDirectMethods } from "./DurableObjectNamespace.mjs";
 import { make as make$2 } from "./DurableObject.mjs";
@@ -11,7 +11,8 @@ var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
 	Tag: () => Tag,
 	implement: () => implement,
 	make: () => make,
-	method: () => method
+	method: () => method,
+	native: () => native
 });
 const reservedMethodNames = /* @__PURE__ */ new Set([
 	"constructor",
@@ -25,6 +26,7 @@ const reservedMethodNames = /* @__PURE__ */ new Set([
 function method(definition) {
 	return method$1(definition);
 }
+const native = native$1;
 const makeDefinition = (id, methods) => {
 	assertNoReservedMethods("Durable Object", methods, reservedMethodNames);
 	const definition = make$1(id, methods);
@@ -122,4 +124,4 @@ const wrapHandlers = (definition, handlers) => {
 */
 const implement = (_definition, handlers) => handlers;
 //#endregion
-export { DurableObject, DurableObjectDefinition_exports, Tag, implement, make, method };
+export { DurableObject, DurableObjectDefinition_exports, Tag, implement, make, method, native };

package/dist/DurableObjectNamespace.d.mts

@@ -8,7 +8,7 @@ import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
 import { Context, Layer, Scope } from "effect";
 declare namespace DurableObjectNamespace_d_exports {
-  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer, makeClient, makeDirectMethods };
+  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, StubCall, StubRpc, StubScopedCall, isDurableObjectNamespaceClient, layer, makeClient, makeDirectMethods };
 }
 interface DurableObjectFetcher {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
@@ -76,6 +76,8 @@ type StubMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method
 type StubMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
 type StubMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
 type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
+type StubRpc<R, Api extends object> = <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
+type StubScopedCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope | R>;
 type DefinitionNamespaceDirectMethods<R, Api extends object, Definition$3 extends Definition$1.Any> = { readonly [Method in Definition.MethodNames<Definition$3>]: (stub: DurableObjectStubClient<Api>, ...args: Method$1.Args<Definition$3["methods"][Method]>) => Effect.Effect<Method$1.Success<Definition$3["methods"][Method]>, DurableObjectRpcError, R>; };
 type DefinitionDurableObjectDirectClient<R, Definition$2 extends Definition$1.Any> = {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
@@ -102,14 +104,14 @@ type DurableObjectNamespaceEffectClient<Api extends object, Definition extends D
    *
    * Most application code should use {@link call} instead.
    */
-  readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
+  readonly rpc: StubRpc<never, Api>;
   /**
    * Invokes a Durable Object RPC method, resolves Cloudflare's RPC result, and
    * decodes the success value when the namespace was created from a definition.
    *
    * This is the normal choice when application code wants the final typed value.
    */
-  readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  readonly call: StubCall<never, Api>;
   /**
    * Invokes a Durable Object RPC method in the current `Scope`, resolves
    * Cloudflare's RPC result, decodes definition-backed success values, and
@@ -119,7 +121,7 @@ type DurableObjectNamespaceEffectClient<Api extends object, Definition extends D
    * Use this for RPC methods that return Cloudflare RPC resources or other
    * disposable objects whose lifetime should be tied to an Effect scope.
    */
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope>;
+  readonly scopedCall: StubScopedCall<never, Api>;
   /**
    * Exposes the underlying native Durable Object namespace binding.
    *
@@ -136,9 +138,9 @@ type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extend
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
   readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
   readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
-  readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
-  readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
-  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, DurableObjectRpcError, Scope.Scope | R>;
+  readonly rpc: StubRpc<R, Api>;
+  readonly call: StubCall<R, Api>;
+  readonly scopedCall: StubScopedCall<R, Api>;
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 declare const isDurableObjectNamespaceClient: <Api extends object>(value: NamespaceCandidate) => value is DurableObjectNamespaceClient<Api>;
@@ -151,4 +153,4 @@ declare const makeDirectMethods: <R, Api extends object, Definition extends Defi
   readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
 }) => DirectMethods<R, Api, Definition>;
 //#endregion
-export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectNamespace_d_exports, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer, makeClient, makeDirectMethods };
+export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectNamespace_d_exports, DurableObjectRpcError, DurableObjectStubClient, StubCall, StubRpc, StubScopedCall, isDurableObjectNamespaceClient, layer, makeClient, makeDirectMethods };

package/dist/DurableObjectSqlite.mjs

@@ -3,8 +3,8 @@ import { DurableObjectState } from "./DurableObjectState.mjs";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { SqliteClient } from "@effect/sql-sqlite-do";
 import * as Scheduler from "effect/Scheduler";
+import { SqliteClient } from "@effect/sql-sqlite-do";
 import * as Reactivity from "effect/unstable/reactivity/Reactivity";
 import { SqlClient } from "effect/unstable/sql";
 //#region src/DurableObjectSqlite.ts

package/dist/Email.d.mts

@@ -4,7 +4,7 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import { Layer } from "effect";
 declare namespace Email_d_exports {
-  export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+  export { BindingNotFoundError, BindingValidationError, EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
 }
 declare const sendLimits: {
   readonly maxRecipients: 50;
@@ -103,4 +103,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, EmailClient>, definitio
 declare const make: <Id extends string>(id: Id) => TagClass<EmailService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, Email_d_exports, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+export { type BindingNotFoundError, type BindingValidationError, EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, Email_d_exports, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };

package/dist/Hyperdrive.d.mts

@@ -4,7 +4,7 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import { Layer } from "effect";
 declare namespace Hyperdrive_d_exports {
-  export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
 }
 interface HyperdriveDefinition {
   readonly binding: string;
@@ -33,4 +33,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, HyperdriveClient>, defi
 declare const make: <Id extends string>(id: Id) => TagClass<HyperdriveService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, Hyperdrive_d_exports, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, HyperdriveClient, HyperdriveDefinition, HyperdriveService, Hyperdrive_d_exports, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };

package/dist/Images.d.mts

@@ -6,7 +6,7 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { Layer } from "effect";
 declare namespace Images_d_exports {
-  export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };
+  export { BindingNotFoundError, BindingValidationError, DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };
 }
 declare const TypeId: "~effect-cf/Images/Steps";
 type TypeId = typeof TypeId;
@@ -188,4 +188,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, ImagesClient>, definiti
 declare const make: <Id extends string>(id: Id) => TagClass<ImagesService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, Images_d_exports, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };
+export { type BindingNotFoundError, type BindingValidationError, DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, Images_d_exports, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };

package/dist/Kv.d.mts

@@ -6,7 +6,7 @@ import * as S from "effect/Schema";
 import * as Option from "effect/Option";
 import { Layer } from "effect";
 declare namespace Kv_d_exports {
-  export { Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions, Tag, TagClass, isKvNamespace, layer, makeClient };
+  export { BindingNotFoundError, BindingValidationError, Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions, Tag, TagClass, isKvNamespace, layer, makeClient };
 }
 type KvOperation = "put" | "get" | "getWithMetadata" | "list" | "delete";
 declare const KvOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
@@ -81,4 +81,4 @@ declare const Tag: <Self>() => <Id extends string, Key, Value, EncodedValue>(id:
   readonly value: S.Codec<Value, EncodedValue>;
 }) => TagClass<Self, Id, Key, Value, EncodedValue>;
 //#endregion
-export { Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, Kv_d_exports, LayerOptions, Tag, TagClass, isKvNamespace, layer, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, Kv_d_exports, LayerOptions, Tag, TagClass, isKvNamespace, layer, makeClient };

package/dist/Queue.d.mts

@@ -1,10 +1,12 @@
 import { WorkerEnvironment } from "./Environment.mjs";
-import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass as TagClass$1, implement } from "./QueueDefinition.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { QueueOperationError, QueueProducer } from "./QueueBinding.mjs";
+import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass, implement } from "./QueueDefinition.mjs";
 import { ExecutionContext, WorkerContext } from "./Worker.mjs";
 import * as Effect from "effect/Effect";
 import { Scope } from "effect";
 declare namespace Queue_d_exports {
-  export { Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag, TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOperationError, QueueOptions, QueueProducer, Tag, TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };
 }
 interface QueueMessage<Body> {
   readonly raw: globalThis.Message<unknown>;
@@ -57,8 +59,7 @@ declare namespace Definition {
   type Any = Definition$1.Any;
 }
 type LayerOptions = LayerOptions$1;
-type TagClass<Self, Id extends string, Message extends Definition$1.Any["message"]> = TagClass$1<Self, Id, Message>;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
 //#endregion
-export { Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Queue_d_exports, Tag, TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, type QueueOperationError, QueueOptions, type QueueProducer, Queue_d_exports, Tag, type TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };

package/dist/QueueDefinition.d.mts

@@ -9,7 +9,7 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Layer, Scope } from "effect";
 declare namespace QueueDefinition_d_exports {
-  export { Definition, Handler, LayerOptions, Options, Queue, Tag, TagClass, implement, make };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, Queue, QueueOperationError, QueueProducer, Tag, TagClass, implement, make };
 }
 interface Definition<Id extends string = string, Message extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly id: Id;
@@ -26,7 +26,7 @@ interface Options<ROut, Self extends Definition.Any> extends Omit<WorkerOptions<
 type LayerOptions = {
   readonly binding: string;
 };
-interface TagClass<Self, Id extends string, Message extends ServiceFreeSchema> extends Context$1.ServiceClass<Self, `effect-cf/Queue/${Id}`, QueueBindingClient<Message>> {
+type TagClass<Self, Id extends string, Message extends ServiceFreeSchema> = Context$1.ServiceClass<Self, `effect-cf/Queue/${Id}`, QueueBindingClient<Message>> & {
   readonly id: Id;
   readonly message: Message;
   readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
@@ -35,7 +35,7 @@ interface TagClass<Self, Id extends string, Message extends ServiceFreeSchema> e
   readonly sendBatch: (messages: Iterable<MessageSendRequest<S.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | S.SchemaError, Self>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
   readonly rawUnsafe: Effect.Effect<QueueProducer<S.Codec.Encoded<Message>>, never, Self>;
-}
+};
 declare const make: <Id extends string, Message extends ServiceFreeSchema>(id: Id, definition: {
   readonly message: Message;
 }) => TagClass<Definition<Id, Message>, Id, Message>;
@@ -45,4 +45,4 @@ declare const Tag: <Self>() => <Id extends string, Message extends ServiceFreeSc
 declare const Queue: typeof Tag;
 declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handler: Handler<ROut, Self>) => Handler<ROut, Self>;
 //#endregion
-export { Definition, Handler, LayerOptions, Options, Queue, QueueDefinition_d_exports, Tag, TagClass, implement, make };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, Queue, QueueDefinition_d_exports, type QueueOperationError, type QueueProducer, Tag, TagClass, implement, make };