effect-cf 0.41.0 → 0.42.0

package/dist/Sandbox.mjs

@@ -1,6 +1,8 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { layer as layer$1 } from "./Binding.mjs";
 import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { CurrentTargets } from "./internal/RpcTargets.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";
@@ -14,7 +16,7 @@ var SandboxOperationError = class extends Data.TaggedError("SandboxOperationErro
 		return `Sandbox ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
 	}
 };
-const trySandboxPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
+const trySandboxPromise = (definition, instance, operation, evaluate, target) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => new SandboxOperationError({
 		binding: definition.binding,
@@ -22,8 +24,8 @@ const trySandboxPromise = (definition, instance, operation, evaluate) => Effect.
 		operation,
 		cause
 	})
-});
-const sandboxStream = (definition, instance, operation, acquire) => Stream.unwrap(Effect.map(trySandboxPromise(definition, instance, operation, acquire), (readable) => Stream.fromReadableStream({
+}).pipe(Effect.tapCause(() => target === void 0 ? Effect.void : invalidate(target)));
+const sandboxStream = (definition, instance, operation, acquire, target) => Stream.unwrap(Effect.map(trySandboxPromise(definition, instance, operation, acquire, target), (readable) => Stream.fromReadableStream({
 	evaluate: () => readable,
 	onError: (cause) => new SandboxOperationError({
 		binding: definition.binding,
@@ -31,7 +33,7 @@ const sandboxStream = (definition, instance, operation, acquire) => Stream.unwra
 		operation,
 		cause
 	})
-})));
+}))).pipe(Stream.tapCause(() => invalidate(target)));
 const decodeSseData = (payload) => {
 	if (payload === "[DONE]" || payload.trim() === "") return [];
 	try {
@@ -53,7 +55,9 @@ const decodeSseEvents = (bytes) => bytes.pipe(Stream.decodeText(), Stream.splitL
 	}
 	return [pending, []];
 }, { onHalt: (pending) => pending.length > 0 ? decodeSseData(pending.join("\n")) : [] }));
-const makeProcessHandle = (definition, instance, process) => {
+const makeProcessHandle = (definition, instance, process, target) => {
+	const attempt = (operation, evaluate) => trySandboxPromise(definition, instance, operation, evaluate, target);
+	const stream = (operation, acquire) => sandboxStream(definition, instance, operation, acquire, target);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
@@ -64,49 +68,51 @@ const makeProcessHandle = (definition, instance, process) => {
 		id: process.id,
 		pid: process.pid,
 		rawUnsafe: Effect.succeed(process),
-		status: trySandboxPromise(definition, instance, "process.status", () => process.status()).pipe(Effect.withSpan("Sandbox.process.status", spanOptions("process.status"))),
-		exitCode: trySandboxPromise(definition, instance, "process.exitCode", () => process.exitCode).pipe(Effect.withSpan("Sandbox.process.exitCode", spanOptions("process.exitCode"))),
-		logs: (options) => sandboxStream(definition, instance, "process.logs", (signal) => process.logs({
+		status: attempt("process.status", () => process.status()).pipe(Effect.withSpan("Sandbox.process.status", spanOptions("process.status"))),
+		exitCode: attempt("process.exitCode", () => process.exitCode).pipe(Effect.withSpan("Sandbox.process.exitCode", spanOptions("process.exitCode"))),
+		logs: (options) => stream("process.logs", (signal) => process.logs({
 			...options,
 			signal
 		})),
 		waitForLog: Effect.fn("Sandbox.process.waitForLog", spanOptions("process.waitForLog"))(function* (pattern, options) {
-			return yield* trySandboxPromise(definition, instance, "process.waitForLog", (signal) => process.waitForLog(pattern, {
+			return yield* attempt("process.waitForLog", (signal) => process.waitForLog(pattern, {
 				...options,
 				signal
 			}));
 		}),
 		waitForExit: Effect.fn("Sandbox.process.waitForExit", spanOptions("process.waitForExit"))(function* (options) {
-			return yield* trySandboxPromise(definition, instance, "process.waitForExit", (signal) => process.waitForExit({
+			return yield* attempt("process.waitForExit", (signal) => process.waitForExit({
 				...options,
 				signal
 			}));
 		}),
 		output: Effect.fn("Sandbox.process.output", spanOptions("process.output"))(function* (options) {
-			return yield* trySandboxPromise(definition, instance, "process.output", (signal) => process.output({
+			return yield* attempt("process.output", (signal) => process.output({
 				...options,
 				signal
 			}));
 		}),
 		outputText: Effect.fn("Sandbox.process.outputText", spanOptions("process.outputText"))(function* (options) {
-			return yield* trySandboxPromise(definition, instance, "process.outputText", (signal) => process.output({
+			return yield* attempt("process.outputText", (signal) => process.output({
 				...options,
 				encoding: "utf8",
 				signal
 			}));
 		}),
 		waitForPort: Effect.fn("Sandbox.process.waitForPort", spanOptions("process.waitForPort"))(function* (port, options) {
-			return yield* trySandboxPromise(definition, instance, "process.waitForPort", (signal) => process.waitForPort(port, {
+			return yield* attempt("process.waitForPort", (signal) => process.waitForPort(port, {
 				...options,
 				signal
 			}));
 		}),
 		kill: Effect.fn("Sandbox.process.kill", spanOptions("process.kill"))(function* (signal) {
-			return yield* trySandboxPromise(definition, instance, "process.kill", () => process.kill(signal));
+			return yield* attempt("process.kill", () => process.kill(signal));
 		})
 	};
 };
-const makeTerminalHandle = (definition, instance, terminal) => {
+const makeTerminalHandle = (definition, instance, terminal, target) => {
+	const attempt = (operation, evaluate) => trySandboxPromise(definition, instance, operation, evaluate, target);
+	const stream = (operation, acquire) => sandboxStream(definition, instance, operation, acquire, target);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
@@ -116,31 +122,34 @@ const makeTerminalHandle = (definition, instance, terminal) => {
 	return {
 		id: terminal.id,
 		rawUnsafe: Effect.succeed(terminal),
-		snapshot: trySandboxPromise(definition, instance, "terminal.snapshot", () => terminal.getSnapshot()).pipe(Effect.withSpan("Sandbox.terminal.snapshot", spanOptions("terminal.snapshot"))),
+		snapshot: attempt("terminal.snapshot", () => terminal.getSnapshot()).pipe(Effect.withSpan("Sandbox.terminal.snapshot", spanOptions("terminal.snapshot"))),
 		write: Effect.fn("Sandbox.terminal.write", spanOptions("terminal.write"))(function* (data) {
-			return yield* trySandboxPromise(definition, instance, "terminal.write", () => terminal.write(data));
+			return yield* attempt("terminal.write", () => terminal.write(data));
 		}),
 		resize: Effect.fn("Sandbox.terminal.resize", spanOptions("terminal.resize"))(function* (cols, rows) {
-			return yield* trySandboxPromise(definition, instance, "terminal.resize", () => terminal.resize(cols, rows));
+			return yield* attempt("terminal.resize", () => terminal.resize(cols, rows));
 		}),
-		output: (options) => sandboxStream(definition, instance, "terminal.output", (signal) => terminal.output({
+		output: (options) => stream("terminal.output", (signal) => terminal.output({
 			...options,
 			signal
 		})),
 		waitForExit: Effect.fn("Sandbox.terminal.waitForExit", spanOptions("terminal.waitForExit"))(function* (options) {
-			return yield* trySandboxPromise(definition, instance, "terminal.waitForExit", (signal) => terminal.waitForExit({
+			return yield* attempt("terminal.waitForExit", (signal) => terminal.waitForExit({
 				...options,
 				signal
 			}));
 		}),
-		interrupt: trySandboxPromise(definition, instance, "terminal.interrupt", () => terminal.interrupt()).pipe(Effect.withSpan("Sandbox.terminal.interrupt", spanOptions("terminal.interrupt"))),
-		terminate: trySandboxPromise(definition, instance, "terminal.terminate", () => terminal.terminate()).pipe(Effect.withSpan("Sandbox.terminal.terminate", spanOptions("terminal.terminate"))),
+		interrupt: attempt("terminal.interrupt", () => terminal.interrupt()).pipe(Effect.withSpan("Sandbox.terminal.interrupt", spanOptions("terminal.interrupt"))),
+		terminate: attempt("terminal.terminate", () => terminal.terminate()).pipe(Effect.withSpan("Sandbox.terminal.terminate", spanOptions("terminal.terminate"))),
 		connect: Effect.fn("Sandbox.terminal.connect", spanOptions("terminal.connect"))(function* (request, options) {
-			return yield* trySandboxPromise(definition, instance, "terminal.connect", () => terminal.connect(request, options));
+			return yield* attempt("terminal.connect", () => terminal.connect(request, options));
 		})
 	};
 };
-const fromSandboxClient = (client, definition, instance) => {
+const fromSandboxClient = (client, definition, instance) => makeSandboxClient(client, definition, instance, client);
+const makeSandboxClient = (client, definition, instance, target) => {
+	const attempt = (operation, evaluate) => trySandboxPromise(definition, instance, operation, evaluate, target);
+	const stream = (operation, acquire) => sandboxStream(definition, instance, operation, acquire, target);
 	const spanOptions = (operation) => ({ attributes: {
 		binding: definition.binding,
 		instance,
@@ -149,135 +158,135 @@ const fromSandboxClient = (client, definition, instance) => {
 	return {
 		rawUnsafe: Effect.succeed(client),
 		exec: Effect.fn("Sandbox.exec", spanOptions("exec"))(function* (command, options) {
-			const process = yield* trySandboxPromise(definition, instance, "exec", () => client.exec(command, options));
-			return makeProcessHandle(definition, instance, process);
+			const process = yield* attempt("exec", () => client.exec(command, options));
+			return makeProcessHandle(definition, instance, process, target);
 		}),
 		getProcess: Effect.fn("Sandbox.getProcess", spanOptions("getProcess"))(function* (id) {
-			const process = yield* trySandboxPromise(definition, instance, "getProcess", () => client.getProcess(id));
-			return Option.map(Option.fromNullishOr(process), (found) => makeProcessHandle(definition, instance, found));
+			const process = yield* attempt("getProcess", () => client.getProcess(id));
+			return Option.map(Option.fromNullishOr(process), (found) => makeProcessHandle(definition, instance, found, target));
 		}),
-		listProcesses: trySandboxPromise(definition, instance, "listProcesses", () => client.listProcesses()).pipe(Effect.withSpan("Sandbox.listProcesses", spanOptions("listProcesses"))),
+		listProcesses: attempt("listProcesses", () => client.listProcesses()).pipe(Effect.withSpan("Sandbox.listProcesses", spanOptions("listProcesses"))),
 		writeFile: Effect.fn("Sandbox.writeFile", spanOptions("writeFile"))(function* (path, content, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* trySandboxPromise(definition, instance, "writeFile", () => client.writeFile(path, content, options));
+			return yield* attempt("writeFile", () => client.writeFile(path, content, options));
 		}),
 		readFile: Effect.fn("Sandbox.readFile", spanOptions("readFile"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* trySandboxPromise(definition, instance, "readFile", () => client.readFile(path, options));
+			return yield* attempt("readFile", () => client.readFile(path, options));
 		}),
-		readFileStream: (path) => sandboxStream(definition, instance, "readFileStream", () => client.readFileStream(path)),
+		readFileStream: (path) => stream("readFileStream", () => client.readFileStream(path)),
 		mkdir: Effect.fn("Sandbox.mkdir", spanOptions("mkdir"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* trySandboxPromise(definition, instance, "mkdir", () => client.mkdir(path, options));
+			return yield* attempt("mkdir", () => client.mkdir(path, options));
 		}),
 		deleteFile: Effect.fn("Sandbox.deleteFile", spanOptions("deleteFile"))(function* (path) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* trySandboxPromise(definition, instance, "deleteFile", () => client.deleteFile(path));
+			return yield* attempt("deleteFile", () => client.deleteFile(path));
 		}),
 		renameFile: Effect.fn("Sandbox.renameFile", spanOptions("renameFile"))(function* (oldPath, newPath) {
 			yield* Effect.annotateCurrentSpan({
 				oldPath,
 				newPath
 			});
-			return yield* trySandboxPromise(definition, instance, "renameFile", () => client.renameFile(oldPath, newPath));
+			return yield* attempt("renameFile", () => client.renameFile(oldPath, newPath));
 		}),
 		moveFile: Effect.fn("Sandbox.moveFile", spanOptions("moveFile"))(function* (sourcePath, destinationPath) {
 			yield* Effect.annotateCurrentSpan({
 				sourcePath,
 				destinationPath
 			});
-			return yield* trySandboxPromise(definition, instance, "moveFile", () => client.moveFile(sourcePath, destinationPath));
+			return yield* attempt("moveFile", () => client.moveFile(sourcePath, destinationPath));
 		}),
 		listFiles: Effect.fn("Sandbox.listFiles", spanOptions("listFiles"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* trySandboxPromise(definition, instance, "listFiles", () => client.listFiles(path, options));
+			return yield* attempt("listFiles", () => client.listFiles(path, options));
 		}),
 		exists: Effect.fn("Sandbox.exists", spanOptions("exists"))(function* (path) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* trySandboxPromise(definition, instance, "exists", () => client.exists(path));
+			return yield* attempt("exists", () => client.exists(path));
 		}),
-		watch: (path, options) => decodeSseEvents(sandboxStream(definition, instance, "watch", () => client.watch(path, options))),
+		watch: (path, options) => decodeSseEvents(stream("watch", () => client.watch(path, options))),
 		checkChanges: Effect.fn("Sandbox.checkChanges", spanOptions("checkChanges"))(function* (path, options) {
 			yield* Effect.annotateCurrentSpan("path", path);
-			return yield* trySandboxPromise(definition, instance, "checkChanges", () => client.checkChanges(path, options));
+			return yield* attempt("checkChanges", () => client.checkChanges(path, options));
 		}),
 		setEnvVars: Effect.fn("Sandbox.setEnvVars", spanOptions("setEnvVars"))(function* (envVars) {
-			return yield* trySandboxPromise(definition, instance, "setEnvVars", () => client.setEnvVars(envVars));
+			return yield* attempt("setEnvVars", () => client.setEnvVars(envVars));
 		}),
 		exposePort: Effect.fn("Sandbox.exposePort", spanOptions("exposePort"))(function* (port, options) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* trySandboxPromise(definition, instance, "exposePort", () => client.exposePort(port, options));
+			return yield* attempt("exposePort", () => client.exposePort(port, options));
 		}),
 		unexposePort: Effect.fn("Sandbox.unexposePort", spanOptions("unexposePort"))(function* (port) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* trySandboxPromise(definition, instance, "unexposePort", () => client.unexposePort(port));
+			return yield* attempt("unexposePort", () => client.unexposePort(port));
 		}),
 		getExposedPorts: Effect.fn("Sandbox.getExposedPorts", spanOptions("getExposedPorts"))(function* (hostname) {
-			return yield* trySandboxPromise(definition, instance, "getExposedPorts", () => client.getExposedPorts(hostname));
+			return yield* attempt("getExposedPorts", () => client.getExposedPorts(hostname));
 		}),
 		isPortExposed: Effect.fn("Sandbox.isPortExposed", spanOptions("isPortExposed"))(function* (port) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* trySandboxPromise(definition, instance, "isPortExposed", () => client.isPortExposed(port));
+			return yield* attempt("isPortExposed", () => client.isPortExposed(port));
 		}),
 		validatePortToken: Effect.fn("Sandbox.validatePortToken", spanOptions("validatePortToken"))(function* (port, token) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* trySandboxPromise(definition, instance, "validatePortToken", () => client.validatePortToken(port, token));
+			return yield* attempt("validatePortToken", () => client.validatePortToken(port, token));
 		}),
 		containerFetch: Effect.fn("Sandbox.containerFetch", spanOptions("containerFetch"))(function* (requestOrUrl, port) {
-			return yield* trySandboxPromise(definition, instance, "containerFetch", () => client.containerFetch(requestOrUrl, port));
+			return yield* attempt("containerFetch", () => client.containerFetch(requestOrUrl, port));
 		}),
 		wsConnect: Effect.fn("Sandbox.wsConnect", spanOptions("wsConnect"))(function* (request, port) {
 			yield* Effect.annotateCurrentSpan("port", port);
-			return yield* trySandboxPromise(definition, instance, "wsConnect", () => client.wsConnect(request, port));
+			return yield* attempt("wsConnect", () => client.wsConnect(request, port));
 		}),
 		mountBucket: Effect.fn("Sandbox.mountBucket", spanOptions("mountBucket"))(function* (bucket, mountPath, options) {
 			yield* Effect.annotateCurrentSpan({
 				bucket,
 				mountPath
 			});
-			return yield* trySandboxPromise(definition, instance, "mountBucket", () => client.mountBucket(bucket, mountPath, options));
+			return yield* attempt("mountBucket", () => client.mountBucket(bucket, mountPath, options));
 		}),
 		unmountBucket: Effect.fn("Sandbox.unmountBucket", spanOptions("unmountBucket"))(function* (mountPath) {
 			yield* Effect.annotateCurrentSpan("mountPath", mountPath);
-			return yield* trySandboxPromise(definition, instance, "unmountBucket", () => client.unmountBucket(mountPath));
+			return yield* attempt("unmountBucket", () => client.unmountBucket(mountPath));
 		}),
 		createBackup: Effect.fn("Sandbox.createBackup", spanOptions("createBackup"))(function* (options) {
 			yield* Effect.annotateCurrentSpan("dir", options.dir);
-			return yield* trySandboxPromise(definition, instance, "createBackup", () => client.createBackup(options));
+			return yield* attempt("createBackup", () => client.createBackup(options));
 		}),
 		restoreBackup: Effect.fn("Sandbox.restoreBackup", spanOptions("restoreBackup"))(function* (backup) {
 			yield* Effect.annotateCurrentSpan({
 				backupId: backup.id,
 				dir: backup.dir
 			});
-			return yield* trySandboxPromise(definition, instance, "restoreBackup", () => client.restoreBackup(backup));
+			return yield* attempt("restoreBackup", () => client.restoreBackup(backup));
 		}),
 		createTerminal: Effect.fn("Sandbox.createTerminal", spanOptions("createTerminal"))(function* (options) {
-			const terminal = yield* trySandboxPromise(definition, instance, "createTerminal", () => client.createTerminal(options));
-			return makeTerminalHandle(definition, instance, terminal);
+			const terminal = yield* attempt("createTerminal", () => client.createTerminal(options));
+			return makeTerminalHandle(definition, instance, terminal, target);
 		}),
 		getTerminal: Effect.fn("Sandbox.getTerminal", spanOptions("getTerminal"))(function* (id) {
-			const terminal = yield* trySandboxPromise(definition, instance, "getTerminal", () => client.getTerminal(id));
-			return Option.map(Option.fromNullishOr(terminal), (found) => makeTerminalHandle(definition, instance, found));
+			const terminal = yield* attempt("getTerminal", () => client.getTerminal(id));
+			return Option.map(Option.fromNullishOr(terminal), (found) => makeTerminalHandle(definition, instance, found, target));
 		}),
-		listTerminals: trySandboxPromise(definition, instance, "listTerminals", () => client.listTerminals()).pipe(Effect.map((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal))), Effect.withSpan("Sandbox.listTerminals", spanOptions("listTerminals"))),
+		listTerminals: attempt("listTerminals", () => client.listTerminals()).pipe(Effect.map((terminals) => terminals.map((terminal) => makeTerminalHandle(definition, instance, terminal, target))), Effect.withSpan("Sandbox.listTerminals", spanOptions("listTerminals"))),
 		tunnels: {
 			get: Effect.fn("Sandbox.tunnels.get", spanOptions("tunnels.get"))(function* (port, options) {
 				yield* Effect.annotateCurrentSpan("port", port);
-				return yield* trySandboxPromise(definition, instance, "tunnels.get", () => client.tunnels.get(port, options));
+				return yield* attempt("tunnels.get", () => client.tunnels.get(port, options));
 			}),
-			list: trySandboxPromise(definition, instance, "tunnels.list", () => client.tunnels.list()).pipe(Effect.withSpan("Sandbox.tunnels.list", spanOptions("tunnels.list"))),
+			list: attempt("tunnels.list", () => client.tunnels.list()).pipe(Effect.withSpan("Sandbox.tunnels.list", spanOptions("tunnels.list"))),
 			destroy: Effect.fn("Sandbox.tunnels.destroy", spanOptions("tunnels.destroy"))(function* (portOrInfo) {
-				return yield* trySandboxPromise(definition, instance, "tunnels.destroy", () => client.tunnels.destroy(portOrInfo));
+				return yield* attempt("tunnels.destroy", () => client.tunnels.destroy(portOrInfo));
 			})
 		},
 		start: Effect.fn("Sandbox.start", spanOptions("start"))(function* (options) {
-			return yield* trySandboxPromise(definition, instance, "start", () => client.start(options));
+			return yield* attempt("start", () => client.start(options));
 		}),
 		stop: Effect.fn("Sandbox.stop", spanOptions("stop"))(function* (signal) {
-			return yield* trySandboxPromise(definition, instance, "stop", () => client.stop(signal));
+			return yield* attempt("stop", () => client.stop(signal));
 		}),
-		destroy: trySandboxPromise(definition, instance, "destroy", () => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
+		destroy: attempt("destroy", () => client.destroy()).pipe(Effect.withSpan("Sandbox.destroy", spanOptions("destroy")))
 	};
 };
 /**
@@ -306,7 +315,20 @@ const makeClient = (definition) => (namespace) => {
 		} })(function* (name, options) {
 			yield* Effect.annotateCurrentSpan("instance", name);
 			const sandboxModule = yield* importSandboxModule(definition, name);
-			const nativeNamespace = namespace;
+			const targets = yield* Effect.serviceOption(CurrentTargets);
+			const scopedNamespace = yield* get(namespace, "sandbox-namespace", () => {
+				const adapter = {
+					idFromName: (name) => namespace.idFromName(name),
+					get: (id, options) => Option.isSome(targets) ? targets.value.get(adapter, JSON.stringify([id.toString(), options]), () => namespace.get(id, options)) : namespace.get(id, options)
+				};
+				return adapter;
+			}).pipe(Effect.mapError((error) => new SandboxOperationError({
+				binding: definition.binding,
+				instance: name,
+				operation: "get",
+				cause: error.cause
+			})));
+			const nativeNamespace = scopedNamespace;
 			const client = yield* Effect.try({
 				try: () => sandboxModule.getSandbox(nativeNamespace, name, options),
 				catch: (cause) => new SandboxOperationError({
@@ -316,7 +338,7 @@ const makeClient = (definition) => (namespace) => {
 					cause
 				})
 			});
-			return fromSandboxClient(client, definition, name);
+			return makeSandboxClient(client, definition, name, scopedNamespace);
 		}),
 		rawUnsafe: Effect.succeed(namespace)
 	};

package/dist/ServiceBinding.d.mts

@@ -1,14 +1,14 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingService, BindingValidationError } from "./Binding.mjs";
-import { Provider, Result } from "./Rpc.mjs";
+import { Provider } from "./Rpc.mjs";
 import { Definition, Method as Method$1 } from "./RpcDefinition.mjs";
-import { AsyncMethodArgs, AsyncMethodCloudflareReturn, AsyncMethodKey, AsyncMethodSuccess } from "./internal/RpcInvocation.mjs";
 import { Definition as Definition$1, ReservedMethodName as ReservedMethodName$1, ServerApi } from "./WorkerDefinition.mjs";
+import { AsyncMethodArgs, AsyncMethodCloudflareReturn, AsyncMethodKey, AsyncMethodSuccess } from "./internal/RpcInvocation.mjs";
 import * as Effect from "effect/Effect";
 import * as Schema$1 from "effect/Schema";
 import { Context, Scope } from "effect";
 declare namespace ServiceBinding_d_exports {
-  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer, makeClient, makeDirectMethods };
+  export { BindingNotFoundError, BindingValidationError, Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceCall, ServiceClass, ServiceFetcher, ServiceRpc, ServiceScopedCall, isServiceBindingClient, layer, makeClient, makeDirectMethods };
 }
 declare const TypeId: "effect-cf/ServiceBinding";
 interface ServiceFetcher {
@@ -58,6 +58,8 @@ type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Met
 type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
 type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
 type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
+type ServiceRpc<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
+type ServiceScopedCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope | R>;
 type DefinitionDirectMethods<R, Definition$2 extends Definition$1.Any> = { readonly [Method in Definition.MethodNames<Definition$2>]: (...args: Method$1.Args<Definition$2["methods"][Method]>) => Effect.Effect<Method$1.Success<Definition$2["methods"][Method]>, ServiceBindingRpcError, R>; };
 type DirectMethods<R, Definition> = Definition extends Definition$1.Any ? DefinitionDirectMethods<R, Definition> : {};
 type ServiceBindingEffectClient<Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<never, Definition> & {
@@ -71,14 +73,14 @@ type ServiceBindingEffectClient<Api extends object, Definition extends Definitio
    *
    * Most application code should use {@link call} instead.
    */
-  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
+  readonly rpc: ServiceRpc<never, Api>;
   /**
    * Invokes a Worker RPC method, resolves Cloudflare's RPC result, and decodes
    * the success value when the binding was created from a definition.
    *
    * This is the normal choice when application code wants the final typed value.
    */
-  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
+  readonly call: ServiceCall<never, Api>;
   /**
    * Invokes a Worker RPC method in the current `Scope`, resolves Cloudflare's RPC
    * result, decodes definition-backed success values, and disposes the resolved
@@ -87,26 +89,23 @@ type ServiceBindingEffectClient<Api extends object, Definition extends Definitio
    * 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 ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope>;
+  readonly scopedCall: ServiceScopedCall<never, Api>;
 };
 type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$1.Any | undefined = undefined> = DirectMethods<R, Definition> & {
   readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError, R>;
-  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
-  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
-  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, ServiceBindingRpcError, Scope.Scope | R>;
+  readonly rpc: ServiceRpc<R, Api>;
+  readonly call: ServiceCall<R, Api>;
+  readonly scopedCall: ServiceScopedCall<R, Api>;
+};
+type ServiceClass<Self, Id extends string, Api extends object = never, Definition extends Definition$1.Any | undefined = undefined> = BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & ServiceBindingStaticClient<Self, ApiOrDefinition<Api, Definition>, Definition> & {
+  readonly [TypeId]: typeof TypeId;
+  readonly definition: ServiceBindingDefinition<Definition>;
 };
 type ServiceBindingValue = Schema$1.Schema.Type<typeof Schema$1.Unknown>;
 declare const isServiceBindingClient: <Api extends object>(value: ServiceBindingValue) => value is ServiceBindingClient<Api>;
 declare const makeClient: <Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
 declare const layer: <Self, Api extends object, const Definition extends Definition$1.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$1.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods<Self, Definition> & {
-  readonly [TypeId]: typeof TypeId;
-  readonly definition: ServiceBindingDefinition<Definition>;
-  readonly fetch: (input: URL | RequestInfo<unknown, CfProperties<unknown>>, init?: RequestInit<CfProperties<unknown>> | undefined) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
-  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
-  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
-  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: AsyncMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self | Scope.Scope>;
-};
+declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$1.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => ServiceClass<Self, Id, Api, Definition>;
 declare const makeDirectMethods: <R, Api, Definition extends Definition$1.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods<R, Definition>;
 //#endregion
-export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceBinding_d_exports, ServiceFetcher, isServiceBindingClient, layer, makeClient, makeDirectMethods };
+export { type BindingNotFoundError, type BindingValidationError, Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceBinding_d_exports, ServiceCall, ServiceClass, ServiceFetcher, ServiceRpc, ServiceScopedCall, isServiceBindingClient, layer, makeClient, makeDirectMethods };

package/dist/Vectorize.d.mts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
 import * as Schema$1 from "effect/Schema";
 import { Layer } from "effect";
 declare namespace Vectorize_d_exports {
-  export { LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
 }
 type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
 declare const VectorizeOperationError_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 & {
@@ -65,4 +65,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, VectorizeClient>, defin
 declare const make: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, Vectorize_d_exports, isVectorizeBinding, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, Vectorize_d_exports, isVectorizeBinding, layer, make, makeClient };

package/dist/Worker.d.mts

@@ -1,8 +1,10 @@
 import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { ReservedMethodName as ReservedMethodName$1 } from "./RpcDefinition.mjs";
 import { QueueHandler } from "./Queue.mjs";
 import { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing.mjs";
-import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method } from "./WorkerDefinition.mjs";
+import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, RpcSchema, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method, native } from "./WorkerDefinition.mjs";
+import { ServiceBindingFetchError, ServiceBindingRpcError, ServiceCall, ServiceRpc, ServiceScopedCall } from "./ServiceBinding.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer$1 from "effect/Layer";
@@ -11,7 +13,7 @@ import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import { Cause, Scope } from "effect";
 declare namespace Worker_d_exports {
-  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+  export { Api, BindingNotFoundError, BindingValidationError, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeRequest, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RpcSchema, RunOptions, RunSymbol, ServerApi, ServiceBindingFetchError, ServiceBindingRpcError, ServiceCall, ServiceFreeSchema, ServiceRpc, ServiceScopedCall, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method, native };
 }
 declare const ExecutionContext_base: Context$1.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
 declare class ExecutionContext extends ExecutionContext_base {}
@@ -136,4 +138,4 @@ declare function make<ROut, LayerError, REvent extends never = never, EventLayer
 declare function makeFetchHandler<ROut, LayerError, REvent, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptionsWithEventLayer<ROut, REvent, EventLayerError>): FetchHandler<Env>;
 declare function makeFetchHandler<ROut, LayerError, REvent extends never = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>): FetchHandler<Env>;
 //#endregion
-export { type Api, type Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, NativeRequest, type NoReservedMethods, type Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, type ServerApi, type ServiceFreeSchema, Tag, type TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, type WorkerRpcContract as WorkerRpcShape, WorkerRpcHandler, Worker_d_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+export { type Api, type BindingNotFoundError, type BindingValidationError, type Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, NativeRequest, type NativeSchema, type NoReservedMethods, type Options, ReservedMethodName, RpcHandlers, type RpcSchema, RunOptions, RunSymbol, type ServerApi, type ServiceBindingFetchError, type ServiceBindingRpcError, type ServiceCall, type ServiceFreeSchema, type ServiceRpc, type ServiceScopedCall, Tag, type TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, type WorkerRpcContract as WorkerRpcShape, WorkerRpcHandler, Worker_d_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method, native };

package/dist/Worker.mjs

@@ -1,12 +1,12 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
 import { fromExecutionContext } from "./internal/WorkerContext.mjs";
+import { withScope } from "./RpcTargets.mjs";
 import { fromMessage, fromMessageBatch } from "./Queue.mjs";
 import { reservedMethodNames as reservedMethodNames$1 } from "./RpcDefinition.mjs";
-import { withScope } from "./RpcTargets.mjs";
 import { assumeEntrypointClass, defineEntrypointRpcMethods } from "./internal/Entrypoint.mjs";
 import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
 import { scheduleTelemetryFlush as scheduleTelemetryFlush$1 } from "./internal/Telemetry.mjs";
-import { Tag, implement, method } from "./WorkerDefinition.mjs";
+import { Tag, implement, method, native } from "./WorkerDefinition.mjs";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -28,7 +28,8 @@ var Worker_exports = /* @__PURE__ */ __exportAll({
 	isWebSocketUpgrade: () => isWebSocketUpgrade,
 	make: () => make,
 	makeFetchHandler: () => makeFetchHandler,
-	method: () => method
+	method: () => method,
+	native: () => native
 });
 var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
 var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
@@ -139,4 +140,4 @@ function makeFetchHandler(layer, options) {
 	} };
 }
 //#endregion
-export { ExecutionContext, NativeRequest, RunSymbol, Tag, WorkerContext, Worker_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+export { ExecutionContext, NativeRequest, RunSymbol, Tag, WorkerContext, Worker_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method, native };

package/dist/WorkerDefinition.d.mts

@@ -1,26 +1,29 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import { Provider } from "./Rpc.mjs";
-import { ServiceBindingEffectClient, ServiceBindingStaticClient } from "./ServiceBinding.mjs";
+import { NativeSchema as NativeSchema$1, RpcSchema as RpcSchema$1, SchemaType, WireEncoded, native as native$1 } from "./RpcDefinition.mjs";
+import { ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceCall, ServiceRpc, ServiceScopedCall } from "./ServiceBinding.mjs";
 import { ExecutionContext, ReservedMethodName as ReservedMethodName$1, WorkerClass, WorkerContext, WorkerOptions, WorkerRpcHandler } from "./Worker.mjs";
 import * as Context$1 from "effect/Context";
 import { Layer, Schema } from "effect";
 declare namespace WorkerDefinition_d_exports {
-  export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, implement, make, method };
+  export { Api, BindingNotFoundError, BindingValidationError, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcSchema, ServerApi, ServiceBindingFetchError, ServiceBindingRpcError, ServiceCall, ServiceFreeSchema, ServiceRpc, ServiceScopedCall, Tag, TagClass, Worker, 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>;
@@ -77,14 +80,15 @@ type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Cont
  * Defines a single RPC method schema in a worker definition.
  */
 declare const method: {
-  <Success extends ServiceFreeSchema>(definition: {
+  <Success extends RpcSchema>(definition: {
     readonly success: Success;
   }): Method<readonly [], Success>;
-  <const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+  <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 Worker: typeof Tag;
@@ -97,4 +101,4 @@ declare const implement: <ROut, const Self extends Definition.Any>(_definition:
  */
 type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method.Success<Self["methods"][Key]>>;
 //#endregion
-export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, WorkerDefinition_d_exports, implement, make, method };
+export { Api, type BindingNotFoundError, type BindingValidationError, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeSchema, NoReservedMethods, Options, ReservedMethodName, RpcSchema, ServerApi, type ServiceBindingFetchError, type ServiceBindingRpcError, type ServiceCall, ServiceFreeSchema, type ServiceRpc, type ServiceScopedCall, Tag, TagClass, Worker, WorkerDefinition_d_exports, implement, make, method, native };