effect-cf 0.41.0 → 0.42.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # effect-cf
 
+## 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
+
+- [#161](https://github.com/danieljvdm/effect-cf/pull/161) [`a627f80`](https://github.com/danieljvdm/effect-cf/commit/a627f80449bf40227bddf917640aae9574faa563) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Retain Sandbox and Container RPC channels for each invocation so repeated lookups after callbacks do not exhaust Cloudflare's subrequest depth. Sandbox configuration continues to apply on each lookup, and failed channels are replaced on subsequent acquisition.
+
 ## 0.41.0
 
 ### Minor 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/ContainerNamespace.mjs

@@ -1,6 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { get, invalidate } from "./RpcTargets.mjs";
 import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -37,7 +38,7 @@ var ContainerOperationError = class extends Data.TaggedError("ContainerOperation
 		return `Container ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
 	}
 };
-const tryContainerPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+const tryContainerPromise = (definition, instance, operation, evaluate, target) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => new ContainerOperationError({
 		binding: definition.binding,
@@ -45,43 +46,44 @@ const tryContainerPromise = (definition, instance, operation, evaluate) => Effec
 		operation,
 		cause
 	})
-});
+}).pipe(Effect.tapCause(() => invalidate(target)));
 const makeInstanceClient = (definition, instance, stub) => {
+	const attempt = (operation, evaluate) => tryContainerPromise(definition, instance, operation, evaluate, stub);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
 		operation
 	} });
 	const hostListOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hosts) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation]([...hosts]));
+		return yield* attempt(operation, () => stub[operation]([...hosts]));
 	});
 	const hostnameOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hostname) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation](hostname));
+		return yield* attempt(operation, () => stub[operation](hostname));
 	});
 	return {
 		rawUnsafe: Effect.succeed(stub),
-		state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(Effect.flatMap(S.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
+		state: attempt("state", () => stub.getState()).pipe(Effect.flatMap(S.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
 			binding: definition.binding,
 			instance,
 			operation: "state",
 			cause
 		})), Effect.withSpan("ContainerNamespace.state", spanOptions("state"))),
 		fetch: Effect.fn("ContainerNamespace.fetch", spanOptions("fetch"))(function* (input, init) {
-			return yield* tryContainerPromise(definition, instance, "fetch", () => stub.fetch(input, init));
+			return yield* attempt("fetch", () => stub.fetch(input, init));
 		}),
 		start: Effect.fn("ContainerNamespace.start", spanOptions("start"))(function* (options, waitOptions) {
-			return yield* tryContainerPromise(definition, instance, "start", () => stub.start(options, waitOptions));
+			return yield* attempt("start", () => stub.start(options, waitOptions));
 		}),
 		startAndWaitForPorts: Effect.fn("ContainerNamespace.startAndWaitForPorts", spanOptions("startAndWaitForPorts"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
+			return yield* attempt("startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
 		}),
 		waitForPort: Effect.fn("ContainerNamespace.waitForPort", spanOptions("waitForPort"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "waitForPort", () => stub.waitForPort(options));
+			return yield* attempt("waitForPort", () => stub.waitForPort(options));
 		}),
 		stop: Effect.fn("ContainerNamespace.stop", spanOptions("stop"))(function* (signal) {
-			return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
+			return yield* attempt("stop", () => stub.stop(signal));
 		}),
-		destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
+		destroy: attempt("destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
 		setAllowedHosts: hostListOperation("setAllowedHosts"),
 		setDeniedHosts: hostListOperation("setDeniedHosts"),
 		allowHost: hostnameOperation("allowHost"),
@@ -92,15 +94,16 @@ const makeInstanceClient = (definition, instance, stub) => {
 };
 const isContainerNamespaceResource = (value) => Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
 const makeClient = (definition) => (namespace) => {
-	const getByName = (name, options) => Effect.try({
-		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
-		catch: (cause) => new ContainerOperationError({
-			binding: definition.binding,
-			instance: name,
-			operation: "getByName",
-			cause
-		})
-	});
+	const getByName = (name, options) => get(namespace, JSON.stringify([
+		"container",
+		name,
+		options
+	]), () => namespace.getByName(name, options)).pipe(Effect.map((stub) => makeInstanceClient(definition, name, stub)), Effect.mapError((error) => new ContainerOperationError({
+		binding: definition.binding,
+		instance: name,
+		operation: "getByName",
+		cause: error.cause
+	})));
 	const byName = (name, options) => {
 		const instance = getByName(name, options);
 		return {

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;
@@ -100,4 +102,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,7 +7,7 @@ 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 { DurableObject } from "cloudflare:workers";
@@ -18,7 +18,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]. */
@@ -74,4 +75,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/DurableObjectNamespace.mjs

@@ -1,8 +1,8 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
-import { decodeSuccess, encodeArgs } from "./RpcDefinition.mjs";
 import { get, invalidate } from "./RpcTargets.mjs";
+import { decodeSuccess, encodeArgs } from "./RpcDefinition.mjs";
 import { withRpcClientSpan, withRpcTraceContext } from "./RpcTracing.mjs";
 import { invokeRpcMethod } from "./internal/RpcInvocation.mjs";
 import { resolve, scoped } from "./Rpc.mjs";

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 };