effect-cf 0.41.1 → 0.42.1

package/src/ServiceBinding.ts

@@ -13,6 +13,8 @@ import * as ErrorMessage from "./internal/ErrorMessage";
 import * as RpcInvocation from "./internal/RpcInvocation";
 import * as RpcTracing from "./RpcTracing";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const TypeId = "effect-cf/ServiceBinding" as const;
 const expectedServiceBinding = "Worker service binding with fetch()";
 
@@ -91,11 +93,25 @@ type ServiceMethodCloudflareReturn<
   Method extends keyof Api,
 > = RpcInvocation.AsyncMethodCloudflareReturn<Api, Method>;
 
-type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(
+export type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(
   method: Method,
   ...args: ServiceMethodArgs<Api, Method>
 ) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
 
+export type ServiceRpc<R, Api> = <Method extends ServiceMethodKey<Api>>(
+  method: Method,
+  ...args: ServiceMethodArgs<Api, Method>
+) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
+
+export 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 extends WorkerDefinition.Definition.Any> = {
   readonly [Method in RpcDefinition.Definition.MethodNames<Definition>]: (
     ...args: RpcDefinition.Method.Args<Definition["methods"][Method]>
@@ -127,20 +143,14 @@ export type ServiceBindingEffectClient<
    *
    * 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
@@ -149,14 +159,7 @@ export type ServiceBindingEffectClient<
    * 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>;
 };
 
 export type ServiceBindingStaticClient<
@@ -168,24 +171,26 @@ export type ServiceBindingStaticClient<
     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>;
 };
 
+export type ServiceClass<
+  Self,
+  Id extends string,
+  Api extends object = never,
+  Definition extends WorkerDefinition.Definition.Any | undefined = undefined,
+> = Binding.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.Schema.Type<typeof Schema.Unknown>;
 
 const ServiceBindingSchema = Schema.declare(
@@ -384,7 +389,7 @@ export const Service =
   >(
     id: Id,
     definition: ServiceBindingDefinition<Definition>,
-  ) => {
+  ): ServiceClass<Self, Id, Api, Definition> => {
     type ServiceApi = ApiOrDefinition<Api, Definition>;
 
     const tag = Binding.Service<Self>()(

package/src/Vectorize.ts

@@ -25,6 +25,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedVectorizeBinding =
   "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
 

package/src/Worker.ts

@@ -20,6 +20,15 @@ import * as Runtime from "./internal/Runtime";
 import * as Telemetry from "./internal/Telemetry";
 import { fromExecutionContext } from "./internal/WorkerContext";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  ServiceBindingFetchError,
+  ServiceBindingRpcError,
+  ServiceCall,
+  ServiceRpc,
+  ServiceScopedCall,
+} from "./ServiceBinding";
+
 export class ExecutionContext extends Context.Service<
   ExecutionContext,
   globalThis.ExecutionContext
@@ -579,14 +588,16 @@ export type {
   LayerOptions,
   Method,
   Methods,
+  NativeSchema,
   NoReservedMethods,
   Options,
+  RpcSchema,
   ServerApi,
   ServiceFreeSchema,
   TagClass,
 } from "./WorkerDefinition";
 
-export { implement, method, Tag } from "./WorkerDefinition";
+export { implement, method, native, Tag } from "./WorkerDefinition";
 
 /** @deprecated Use {@link WorkerRpcContract}. */
 export { type WorkerRpcContract as "WorkerRpcShape" };

package/src/WorkerDefinition.ts

@@ -11,6 +11,15 @@ import * as RpcDefinition from "./RpcDefinition";
 import { recordDecodedArgs } from "./internal/RpcInvocation";
 import * as ServiceBinding from "./ServiceBinding";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  ServiceBindingFetchError,
+  ServiceBindingRpcError,
+  ServiceCall,
+  ServiceRpc,
+  ServiceScopedCall,
+} from "./ServiceBinding";
+
 /**
  * The client tuple types are re-established by the final `TagClass` cast, so
  * these internal invocations erase the binding client's generic argument
@@ -19,38 +28,41 @@ import * as ServiceBinding from "./ServiceBinding";
 type UnsafeInvoke<E> = (...args: ReadonlyArray<unknown>) => Effect.Effect<unknown, E>;
 
 export type ServiceFreeSchema = S.Codec<any, any, never, never>;
+export type NativeSchema<Schema extends ServiceFreeSchema = ServiceFreeSchema> =
+  RpcDefinition.NativeSchema<Schema>;
+export type RpcSchema = RpcDefinition.RpcSchema;
 
 export interface Method<
-  Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>,
-  Success extends ServiceFreeSchema = ServiceFreeSchema,
+  Args extends ReadonlyArray<RpcSchema> = ReadonlyArray<RpcSchema>,
+  Success extends RpcSchema = RpcSchema,
 > {
   readonly args: Args;
   readonly success: Success;
 }
 
 export namespace Method {
-  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  export type Any = Method<ReadonlyArray<RpcSchema>, RpcSchema>;
 
-  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly []
+  type ArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = Args extends readonly []
     ? []
     : Args extends readonly [
-          infer Head extends ServiceFreeSchema,
-          ...infer Tail extends ReadonlyArray<ServiceFreeSchema>,
+          infer Head extends RpcSchema,
+          ...infer Tail extends ReadonlyArray<RpcSchema>,
         ]
-      ? [S.Schema.Type<Head>, ...ArgsFromSchemas<Tail>]
-      : Array<S.Schema.Type<Args[number]>>;
+      ? [RpcDefinition.SchemaType<Head>, ...ArgsFromSchemas<Tail>]
+      : Array<RpcDefinition.SchemaType<Args[number]>>;
 
-  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = {
-    [Index in keyof Args]: S.Json;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<RpcSchema>> = {
+    [Index in keyof Args]: RpcDefinition.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> = S.Schema.Type<Self["success"]>;
+  export type Success<Self extends Any> = RpcDefinition.SchemaType<Self["success"]>;
 
-  export type EncodedSuccess<_Self extends Any> = S.Json;
+  export type EncodedSuccess<Self extends Any> = RpcDefinition.WireEncoded<Self["success"]>;
 }
 
 export type Methods = Record<string, Method.Any>;
@@ -227,18 +239,17 @@ const assumeTagClass = <Self, Id extends string, MethodDefinitions extends Metho
  * Defines a single RPC method schema in a worker definition.
  */
 export 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>;
 } = RpcDefinition.method;
 
+export const native = RpcDefinition.native;
+
 const makeDefinition = <Id extends string, const MethodDefinitions extends Methods>(
   id: Id,
   methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>,

package/src/WorkersAi.ts

@@ -22,6 +22,8 @@ import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+
 const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
 
 export class WorkersAiOperationError extends Data.TaggedError("WorkersAiOperationError")<{

package/src/Workflow.ts

@@ -27,6 +27,14 @@ import * as ErrorMessage from "./internal/ErrorMessage";
 import * as Runtime from "./internal/Runtime";
 import { fromExecutionContext } from "./internal/WorkerContext";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  WorkflowInstance,
+  WorkflowInstanceCreateOptions,
+  WorkflowInstanceCreateBatchOptions,
+  WorkflowOperationError,
+} from "./WorkflowBinding";
+
 export interface WorkflowEventService<Payload = unknown> {
   readonly raw: CloudflareWorkflowEvent<unknown>;
   readonly payload: Payload;
@@ -316,14 +324,7 @@ export namespace Definition {
 
 export type LayerOptions = WorkflowDefinition.LayerOptions;
 
-export type TagClass<
-  Self,
-  Id extends string,
-  Payload extends WorkflowDefinition.Definition.Any["payload"],
-  Result extends WorkflowDefinition.Definition.Any["result"],
-> = WorkflowDefinition.TagClass<Self, Id, Payload, Result>;
-
-export { implement, Tag } from "./WorkflowDefinition";
+export { implement, Tag, type TagClass } from "./WorkflowDefinition";
 
 export type Handler<
   ROut,

package/src/WorkflowDefinition.ts

@@ -10,6 +10,14 @@ import type * as RpcDefinition from "./RpcDefinition";
 import * as WorkflowBinding from "./WorkflowBinding";
 import * as WorkflowEntrypoint from "./Workflow";
 
+export type { BindingNotFoundError, BindingValidationError } from "./Binding";
+export type {
+  WorkflowInstance,
+  WorkflowInstanceCreateOptions,
+  WorkflowInstanceCreateBatchOptions,
+  WorkflowOperationError,
+} from "./WorkflowBinding";
+
 export interface Definition<
   Id extends string = string,
   Payload extends RpcDefinition.ServiceFreeSchema = RpcDefinition.ServiceFreeSchema,
@@ -44,16 +52,16 @@ export type LayerOptions = {
   readonly binding: string;
 };
 
-export interface TagClass<
+export type TagClass<
   Self,
   Id extends string,
   Payload extends RpcDefinition.ServiceFreeSchema,
   Result extends RpcDefinition.ServiceFreeSchema,
-> extends Context.ServiceClass<
+> = Context.ServiceClass<
   Self,
   `effect-cf/Workflow/${Id}`,
   WorkflowBinding.WorkflowBindingClient<Payload, Result>
-> {
+> & {
   readonly id: Id;
   readonly payload: Payload;
   readonly result: Result;
@@ -94,7 +102,7 @@ export interface TagClass<
     Self
   >;
   readonly rawUnsafe: Effect.Effect<globalThis.Workflow<S.Codec.Encoded<Payload>>, never, Self>;
-}
+};
 
 const makeDefinition = <
   Id extends string,

package/src/internal/NativeCallback.ts

@@ -1,9 +1,13 @@
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as FiberSet from "effect/FiberSet";
+import * as Scheduler from "effect/Scheduler";
 
 type RunCallback<A, E, R> = (effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>>;
 
+const callbackScheduler = new Scheduler.MixedScheduler("sync");
+
 /**
  * Runs an Effect callback owned by a native Promise operation.
  *
@@ -14,7 +18,14 @@ type RunCallback<A, E, R> = (effect: Effect.Effect<A, E, R>) => Promise<Exit.Exi
 export const runNativeCallback = Effect.fnUntraced(function* <A, E, R, B>(
   operation: (run: RunCallback<A, E, R>) => Promise<B>,
 ): Effect.fn.Return<B, unknown, R> {
-  const callerContext = yield* Effect.context<R>();
+  // An older timer in the blocked parent input gate prevents later timers in
+  // this owner from running. Yield through microtasks while the native gate is
+  // held, including when the caller explicitly provided its own scheduler.
+  const callbackContext = Context.add(
+    yield* Effect.context<R>(),
+    Scheduler.Scheduler,
+    callbackScheduler,
+  );
 
   return yield* Effect.scoped(
     Effect.gen(function* () {
@@ -39,7 +50,7 @@ export const runNativeCallback = Effect.fnUntraced(function* <A, E, R, B>(
       return yield* Effect.callback<B, unknown>((resume) => {
         try {
           nativePromise = operation((effect) =>
-            runPromise(Effect.provideContext(Effect.exit(effect), callerContext)),
+            runPromise(Effect.provideContext(Effect.exit(effect), callbackContext)),
           );
         } catch (cause) {
           resume(Effect.fail(cause));