effect-cf 0.26.0 → 0.28.0

package/src/QueueDefinition.ts

@@ -29,7 +29,7 @@ export type Handler<ROut, Self extends Definition.Any> = (
 >;
 
 export interface Options<ROut, Self extends Definition.Any> extends Omit<
-  WorkerEntrypoint.WorkerOptions<ROut, Record<never, never>>,
+  WorkerEntrypoint.WorkerOptions<ROut, never, never, Record<never, never>>,
   "queue" | "rpc"
 > {
   readonly queue: Handler<ROut, Self>;
@@ -75,7 +75,11 @@ export interface TagClass<
     QueueBinding.QueueOperationError,
     Self
   >;
-  readonly rawUnsafe: Effect.Effect<globalThis.Queue<S.Codec.Encoded<Message>>, never, Self>;
+  readonly rawUnsafe: Effect.Effect<
+    QueueBinding.QueueProducer<S.Codec.Encoded<Message>>,
+    never,
+    Self
+  >;
 }
 
 const makeDefinition = <Id extends string, Message extends RpcDefinition.ServiceFreeSchema>(
@@ -148,6 +152,7 @@ export const Tag =
 
     const rawUnsafe = Effect.flatMap(tag, (queue) => queue.rawUnsafe);
 
+    // SAFETY: the assigned definition helpers exactly implement TagClass for this queue schema.
     return Object.assign(tag, {
       id: queueDefinition.id,
       message: queueDefinition.message,

package/src/R2.ts

@@ -12,7 +12,7 @@ import type {
   R2UploadPartOptions as CloudflareR2UploadPartOptions,
   R2UploadedPart as CloudflareR2UploadedPart,
 } from "@cloudflare/workers-types";
-import { Context, Data, Effect, Option, type Layer } from "effect";
+import { Context, Data, Effect, Option, Predicate, Schema, type Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -190,11 +190,11 @@ const isR2ObjectBody = (
   value: CloudflareR2ObjectBody | CloudflareR2Object,
 ): value is CloudflareR2ObjectBody =>
   "body" in value &&
-  typeof (value as CloudflareR2ObjectBody).arrayBuffer === "function" &&
-  typeof (value as CloudflareR2ObjectBody).bytes === "function" &&
-  typeof (value as CloudflareR2ObjectBody).text === "function" &&
-  typeof (value as CloudflareR2ObjectBody).json === "function" &&
-  typeof (value as CloudflareR2ObjectBody).blob === "function";
+  Predicate.isFunction(value.arrayBuffer) &&
+  Predicate.isFunction(value.bytes) &&
+  Predicate.isFunction(value.text) &&
+  Predicate.isFunction(value.json) &&
+  Predicate.isFunction(value.blob);
 
 const wrapObjectBody = (binding: string, object: CloudflareR2ObjectBody): R2ObjectBodyClient => ({
   key: object.key,
@@ -244,23 +244,29 @@ const wrapGetResult = (
   return wrapObjectBody(binding, object);
 };
 
-export const isR2Bucket = (value: unknown): value is CloudflareR2Bucket => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const resource = value as Record<string, unknown>;
-
-  return (
-    typeof resource.head === "function" &&
-    typeof resource.get === "function" &&
-    typeof resource.put === "function" &&
-    typeof resource.createMultipartUpload === "function" &&
-    typeof resource.resumeMultipartUpload === "function" &&
-    typeof resource.delete === "function" &&
-    typeof resource.list === "function"
-  );
-};
+type R2BindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
+
+const R2BucketSchema = Schema.declare(
+  (value: R2BindingValue): value is CloudflareR2Bucket =>
+    Predicate.hasProperty(value, "head") &&
+    Predicate.isFunction(value.head) &&
+    Predicate.hasProperty(value, "get") &&
+    Predicate.isFunction(value.get) &&
+    Predicate.hasProperty(value, "put") &&
+    Predicate.isFunction(value.put) &&
+    Predicate.hasProperty(value, "createMultipartUpload") &&
+    Predicate.isFunction(value.createMultipartUpload) &&
+    Predicate.hasProperty(value, "resumeMultipartUpload") &&
+    Predicate.isFunction(value.resumeMultipartUpload) &&
+    Predicate.hasProperty(value, "delete") &&
+    Predicate.isFunction(value.delete) &&
+    Predicate.hasProperty(value, "list") &&
+    Predicate.isFunction(value.list),
+);
+const decodeR2Bucket = Schema.decodeUnknownOption(R2BucketSchema);
+
+export const isR2Bucket = (value: R2BindingValue): value is CloudflareR2Bucket =>
+  Option.isSome(decodeR2Bucket(value));
 
 export const makeClient = (
   definition: R2Definition,
@@ -294,6 +300,7 @@ export const makeClient = (
   });
 
   return (bucket) => {
+    // SAFETY: the implementation preserves Cloudflare's get overload distinction for onlyIf options.
     const get = Effect.fn(
       "R2.get",
       spanOptions(definition.binding, "get"),
@@ -314,6 +321,7 @@ export const makeClient = (
         ),
       ),
       get,
+      // SAFETY: the implementation preserves Cloudflare's put overload distinction for onlyIf options.
       put: Effect.fn(
         "R2.put",
         spanOptions(definition.binding, "put"),
@@ -352,7 +360,7 @@ export const makeClient = (
         "R2.delete",
         spanOptions(definition.binding, "delete"),
       )((keys: string | ReadonlyArray<string>) => {
-        const nativeKeys = typeof keys === "string" ? keys : [...keys];
+        const nativeKeys = Predicate.isString(keys) ? keys : [...keys];
 
         return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
       }),
@@ -381,6 +389,7 @@ export const Tag =
 
     const makeLayer = (definition: LayerOptions) => layer(tag, definition);
 
+    // SAFETY: Object.assign attaches exactly the static id/layer members declared by TagClass.
     return Object.assign(tag, {
       id,
       layer: makeLayer,

package/src/Rpc.ts

@@ -1,5 +1,5 @@
 import { RpcStub, RpcTarget } from "cloudflare:workers";
-import { Effect, type Scope } from "effect";
+import { Effect, Predicate, Schema, type Scope } from "effect";
 
 import { decodeWireError } from "./RpcDefinition";
 
@@ -57,9 +57,7 @@ export type Stubify<T> = T extends Stubable
           ? ReadonlyArray<Stubify<Value>>
           : T extends BaseType
             ? T
-            : T extends {
-                  [key: string | number]: unknown;
-                }
+            : T extends Record<string | number, infer _Value>
               ? {
                   [Key in keyof T]: Stubify<T[Key]>;
                 }
@@ -76,7 +74,7 @@ export type Result<T> = T extends Stubable
 
 export type MethodKey<Api> = {
   [Key in keyof Api]-?: Key extends string
-    ? Api[Key] extends (...args: Array<any>) => unknown
+    ? Api[Key] extends (...args: Array<any>) => any
       ? Key
       : never
     : never;
@@ -84,7 +82,7 @@ export type MethodKey<Api> = {
 
 export type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends (
   ...args: infer Args
-) => unknown
+) => any
   ? Args
   : never;
 
@@ -98,13 +96,12 @@ export type DisposableValue = {
   [Symbol.dispose](): void;
 };
 
-export const isDisposable = (value: unknown): value is DisposableValue =>
-  (typeof value === "object" || typeof value === "function") &&
-  value !== null &&
-  Symbol.dispose in value &&
-  typeof (value as { readonly [Symbol.dispose]?: unknown })[Symbol.dispose] === "function";
+type RpcBoundaryValue = Schema.Schema.Type<typeof Schema.Unknown>;
+
+export const isDisposable = (value: RpcBoundaryValue): value is DisposableValue =>
+  Predicate.hasProperty(value, Symbol.dispose) && Predicate.isFunction(value[Symbol.dispose]);
 
-export const dispose = (value: unknown): Effect.Effect<void> =>
+export const dispose = (value: RpcBoundaryValue): Effect.Effect<void> =>
   Effect.sync(() => {
     if (isDisposable(value)) {
       value[Symbol.dispose]();
@@ -112,18 +109,15 @@ export const dispose = (value: unknown): Effect.Effect<void> =>
   });
 
 export const resolve = <A>(value: A): Effect.Effect<Awaited<A>, unknown> =>
-  isPromiseLike(value)
+  Predicate.isPromiseLike(value)
     ? Effect.tryPromise({
-        try: () => value,
+        try: () => Promise.resolve(value),
         catch: (cause) => decodeWireError(cause),
       })
-    : Effect.sync(() => value as Awaited<A>);
+    : Effect.sync(() => {
+        // SAFETY: the predicate excluded PromiseLike values, so Awaited<A> is represented by A here.
+        return value as Awaited<A>;
+      });
 
 export const scoped = <A>(value: A): Effect.Effect<Awaited<A>, unknown, Scope.Scope> =>
   Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
-
-const isPromiseLike = <A>(value: A): value is A & PromiseLike<Awaited<A>> =>
-  (typeof value === "object" || typeof value === "function") &&
-  value !== null &&
-  "then" in value &&
-  typeof (value as { readonly then?: unknown }).then === "function";

package/src/RpcDefinition.ts

@@ -83,7 +83,9 @@ const WireErrorSchema = S.Union([
 
 const wireErrorKey = "effect-cf/RpcDefinition/wireError";
 
-export const isWireError = (error: unknown): error is WireError =>
+type WireValue = S.Schema.Type<typeof S.Unknown>;
+
+export const isWireError = (error: WireValue): error is WireError =>
   error instanceof RpcArgumentCountError ||
   error instanceof RpcArgumentDecodeError ||
   error instanceof RpcSuccessEncodeError;
@@ -92,7 +94,7 @@ export const isWireError = (error: unknown): error is WireError =>
  * Encodes package RPC errors into a plain `Error` envelope so their tags
  * survive Cloudflare RPC serialization, which drops custom error properties.
  */
-export const encodeWireError = (error: unknown): unknown => {
+export const encodeWireError = (error: WireValue): WireValue => {
   if (!isWireError(error)) {
     return error;
   }
@@ -105,13 +107,13 @@ export const encodeWireError = (error: unknown): unknown => {
 };
 
 /** Restores package RPC errors from the {@link encodeWireError} envelope. */
-export const decodeWireError = (cause: unknown): unknown => {
+export const decodeWireError = (cause: WireValue): WireValue => {
   if (!(cause instanceof Error)) {
     return cause;
   }
 
   try {
-    const parsed: unknown = JSON.parse(cause.message);
+    const parsed: WireValue = S.decodeUnknownSync(S.Unknown)(JSON.parse(cause.message));
 
     if (!Predicate.hasProperty(parsed, wireErrorKey)) {
       return cause;
@@ -193,19 +195,22 @@ export namespace Method {
 
   export type Success<Self extends Any> = S.Schema.Type<Self["success"]>;
 
-  export type EncodedSuccess<Self extends Any> = S.Json;
+  export type EncodedSuccess<_Self extends Any> = S.Json;
 }
 
 export type Methods = Record<string, Method.Any>;
 
 export type NoReservedMethods<
-  MethodsShape extends Methods,
+  MethodDefinitions extends Methods,
   Reserved extends string = ReservedMethodName,
-> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
+> = Extract<keyof MethodDefinitions, Reserved> extends never ? MethodDefinitions : never;
 
-export interface Definition<Id extends string = string, MethodsShape extends Methods = Methods> {
+export interface Definition<
+  Id extends string = string,
+  MethodDefinitions extends Methods = Methods,
+> {
   readonly id: Id;
-  readonly methods: MethodsShape;
+  readonly methods: MethodDefinitions;
 }
 
 export namespace Definition {
@@ -225,9 +230,13 @@ export namespace Definition {
   export type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
 }
 
-export const assertNoReservedMethods = (
+type ReservedMethodValue = S.Schema.Type<typeof S.Unknown>;
+
+export const assertNoReservedMethods = <
+  MethodDefinitions extends Readonly<Record<string, ReservedMethodValue>>,
+>(
   target: string,
-  methods: Record<string, unknown>,
+  methods: MethodDefinitions,
   reserved: ReadonlySet<string>,
 ) => {
   for (const method of Object.keys(methods)) {
@@ -276,11 +285,8 @@ export const decodeArgs = Effect.fnUntraced(function* <
     });
   }
 
-  const decoded = yield* (
-    S.decodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(args) as Effect.Effect<
-      unknown,
-      unknown
-    >
+  const decoded = yield* S.decodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(
+    args,
   ).pipe(
     Effect.mapError(
       (cause) =>
@@ -292,6 +298,7 @@ export const decodeArgs = Effect.fnUntraced(function* <
     ),
   );
 
+  // SAFETY: the tuple codec is constructed from this exact method's argument schemas.
   return decoded as Method.Args<Self["methods"][MethodName]>;
 });
 
@@ -317,11 +324,8 @@ export const encodeArgs = Effect.fnUntraced(function* <
     });
   }
 
-  const encoded = yield* (
-    S.encodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(args) as Effect.Effect<
-      unknown,
-      unknown
-    >
+  const encoded = yield* S.encodeUnknownEffect(wireCodec(S.Tuple(methodDefinition.args)))(
+    args,
   ).pipe(
     Effect.mapError(
       (cause) =>
@@ -333,6 +337,7 @@ export const encodeArgs = Effect.fnUntraced(function* <
     ),
   );
 
+  // SAFETY: the tuple codec is constructed from this exact method's argument schemas.
   return encoded as Method.EncodedArgs<Self["methods"][MethodName]>;
 });
 
@@ -346,12 +351,7 @@ export const encodeSuccess = <
 ): Effect.Effect<Method.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError> => {
   const methodDefinition = definition.methods[methodName];
 
-  return (
-    S.encodeUnknownEffect(wireCodec(methodDefinition.success))(value) as Effect.Effect<
-      Method.EncodedSuccess<Self["methods"][MethodName]>,
-      unknown
-    >
-  ).pipe(
+  return S.encodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(
     Effect.mapError(
       (cause) =>
         new RpcSuccessEncodeError({
@@ -369,16 +369,11 @@ export const decodeSuccess = <
 >(
   definition: Self,
   methodName: MethodName,
-  value: unknown,
+  value: WireValue,
 ): Effect.Effect<Method.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError> => {
   const methodDefinition = definition.methods[methodName];
 
-  return (
-    S.decodeUnknownEffect(wireCodec(methodDefinition.success))(value) as Effect.Effect<
-      Method.Success<Self["methods"][MethodName]>,
-      unknown
-    >
-  ).pipe(
+  return S.decodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(
     Effect.mapError(
       (cause) =>
         new RpcSuccessDecodeError({
@@ -390,11 +385,11 @@ export const decodeSuccess = <
   );
 };
 
-export const make = <Id extends string, const MethodsShape extends Methods>(
+export const make = <Id extends string, const MethodDefinitions extends Methods>(
   id: Id,
-  methods: MethodsShape,
-): Definition<Id, MethodsShape> => {
+  methods: MethodDefinitions,
+): Definition<Id, MethodDefinitions> => {
   assertNoReservedMethods(id, methods, reservedMethodNames);
 
-  return { id, methods } as Definition<Id, MethodsShape>;
+  return { id, methods };
 };

package/src/ServiceBinding.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, type Context, type Scope } from "effect";
+import { Data, Effect, Option, Predicate, Schema, type Context, type Scope } from "effect";
 
 import * as Binding from "./Binding";
 import * as CloudflareRpc from "./Rpc";
@@ -19,7 +19,7 @@ export interface ServiceFetcher {
 
 type RpcClient<Api> = {
   readonly [Key in keyof Api as Key extends string
-    ? Api[Key] extends (...args: Array<any>) => unknown
+    ? Api[Key] extends (...args: Array<any>) => any
       ? Key
       : never
     : never]: Api[Key];
@@ -232,10 +232,17 @@ export type ServiceBindingStaticClient<
   ) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
 };
 
+type ServiceBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
+
+const ServiceBindingSchema = Schema.declare(
+  (value: ServiceBindingValue): value is ServiceFetcher =>
+    Predicate.hasProperty(value, "fetch") && Predicate.isFunction(value.fetch),
+);
+const decodeServiceBinding = Schema.decodeUnknownOption(ServiceBindingSchema);
+
 export const isServiceBindingClient = <Api extends object>(
-  value: unknown,
-): value is ServiceBindingClient<Api> =>
-  typeof value === "object" && value !== null && typeof Reflect.get(value, "fetch") === "function";
+  value: ServiceBindingValue,
+): value is ServiceBindingClient<Api> => Option.isSome(decodeServiceBinding(value));
 
 export const makeClient = <
   Api extends object,
@@ -259,6 +266,7 @@ export const makeClient = <
       ...args: ServiceMethodArgs<Api, Method>
     ) {
       const methodName = String(method);
+      // SAFETY: definition-backed clients derive Method and Args from this exact RPC definition.
       const encodedArgs =
         definition.definition === undefined
           ? args
@@ -277,6 +285,7 @@ export const makeClient = <
               ),
             );
 
+      // SAFETY: encoding preserves the selected API method's positional argument contract.
       return yield* RpcInvocation.invokeRpcMethod(
         service,
         method,
@@ -295,9 +304,11 @@ export const makeClient = <
       value: Awaited<ServiceMethodCloudflareReturn<Api, Method>>,
     ) {
       if (definition.definition === undefined) {
+        // SAFETY: without a definition the resolved native RPC value is the API method's declared success.
         return value as ServiceMethodSuccess<Api, Method>;
       }
 
+      // SAFETY: definition-backed clients derive the method name from this exact RPC definition.
       const decoded = yield* RpcDefinition.decodeSuccess(
         definition.definition,
         methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
@@ -313,6 +324,7 @@ export const makeClient = <
         ),
       );
 
+      // SAFETY: decodeSuccess validates against the selected method's declared success schema.
       return decoded as ServiceMethodSuccess<Api, Method>;
     });
 
@@ -347,6 +359,7 @@ export const makeClient = <
 
     const directMethods = makeDirectMethods<never, Api, Definition>(definition.definition, call);
 
+    // SAFETY: Object.assign attaches the four client operations required by ServiceBindingEffectClient.
     return Object.assign(directMethods, {
       fetch,
       rpc,
@@ -457,6 +470,7 @@ export const Service =
       call,
     );
 
+    // SAFETY: Object.assign attaches the definition-derived service metadata and static operations.
     return Object.assign(tag, directMethods, {
       [TypeId]: TypeId,
       definition,
@@ -483,14 +497,18 @@ export const makeDirectMethods = <
   rpcDefinition: Definition | undefined,
   call: ServiceCall<R, Api>,
 ): DirectMethods<R, Definition> => {
-  const methods = {} as Record<string, unknown>;
+  type DynamicMethod = (...args: Array<any>) => Effect.Effect<any, ServiceBindingRpcError, R>;
+  const methods: Record<string, DynamicMethod> = {};
 
   if (rpcDefinition !== undefined) {
+    // SAFETY: rpcDefinition limits these names and tuples to the same definition used to construct call.
+    const invoke = call as (method: string, ...args: Array<any>) => ReturnType<DynamicMethod>;
+
     for (const methodName of Object.keys(rpcDefinition.methods)) {
-      methods[methodName] = (...args: Array<unknown>) =>
-        (call as (method: string, ...args: Array<unknown>) => unknown)(methodName, ...args);
+      methods[methodName] = (...args: Array<any>) => invoke(methodName, ...args);
     }
   }
 
+  // SAFETY: every declared definition method is populated above with a forwarding Effect function.
   return methods as DirectMethods<R, Definition>;
 };

package/src/Vectorize.ts

@@ -1,4 +1,4 @@
-import { Context, Data, Effect, type Layer } from "effect";
+import { Context, Data, Effect, Option, Predicate, Schema, type Layer } from "effect";
 import type {
   Vectorize as CloudflareVectorize,
   VectorizeAsyncMutation as CloudflareVectorizeAsyncMutation,
@@ -157,22 +157,43 @@ const spanOptions = (binding: string, operation: VectorizeOperation) => ({
   attributes: { binding, operation },
 });
 
-const hasFunction = (value: object, key: string): boolean =>
-  typeof Reflect.get(value, key) === "function";
+type VectorizeBindingValue = Schema.Schema.Type<typeof Schema.Unknown>;
 
-export const isVectorizeBinding = (value: unknown): value is VectorizeBinding =>
-  typeof value === "object" &&
-  value !== null &&
-  hasFunction(value, "describe") &&
-  hasFunction(value, "query") &&
-  hasFunction(value, "insert") &&
-  hasFunction(value, "upsert") &&
-  hasFunction(value, "deleteByIds") &&
-  hasFunction(value, "getByIds");
+const invokeVectorizeMethod = <Args extends Array<any>, Return>(
+  method: (...args: Args) => Return,
+  receiver: VectorizeRuntimeBinding,
+  args: Args,
+): Return => {
+  const result: VectorizeBindingValue = Function.prototype.apply.call(method, receiver, args);
+
+  // SAFETY: the native apply intrinsic returns method's declared Return without reading proxy properties.
+  return result as Return;
+};
+
+const VectorizeBindingSchema = Schema.declare(
+  (value: VectorizeBindingValue): value is VectorizeBinding =>
+    Predicate.hasProperty(value, "describe") &&
+    Predicate.isFunction(value.describe) &&
+    Predicate.hasProperty(value, "query") &&
+    Predicate.isFunction(value.query) &&
+    Predicate.hasProperty(value, "insert") &&
+    Predicate.isFunction(value.insert) &&
+    Predicate.hasProperty(value, "upsert") &&
+    Predicate.isFunction(value.upsert) &&
+    Predicate.hasProperty(value, "deleteByIds") &&
+    Predicate.isFunction(value.deleteByIds) &&
+    Predicate.hasProperty(value, "getByIds") &&
+    Predicate.isFunction(value.getByIds),
+);
+const decodeVectorizeBinding = Schema.decodeUnknownOption(VectorizeBindingSchema);
+
+export const isVectorizeBinding = (value: VectorizeBindingValue): value is VectorizeBinding =>
+  Option.isSome(decodeVectorizeBinding(value));
 
 export const makeClient =
   (definition: VectorizeDefinition) =>
   (index: VectorizeBinding): VectorizeClient => {
+    // SAFETY: isVectorizeBinding validates every required runtime method before makeClient is called.
     const runtime = index as VectorizeRuntimeBinding;
     const deleteByIds = Effect.fn(
       "Vectorize.deleteByIds",
@@ -190,18 +211,23 @@ export const makeClient =
         "Vectorize.query",
         spanOptions(definition.binding, "query"),
       )((vector: VectorizeValues, options?: VectorizeQueryOptions) =>
-        tryVectorizePromise(definition.binding, "query", () =>
-          runtime.query(vector as Float32Array | Float64Array | number[], options),
-        ),
+        tryVectorizePromise(definition.binding, "query", () => {
+          // SAFETY: Cloudflare accepts these vector containers without mutating the readonly array variant.
+          return runtime.query(vector as Float32Array | Float64Array | number[], options);
+        }),
       ),
       queryById: Effect.fn(
         "Vectorize.queryById",
         spanOptions(definition.binding, "queryById"),
       )((vectorId: string, options?: VectorizeQueryOptions) =>
         runtime.queryById !== undefined
-          ? tryVectorizePromise(definition.binding, "queryById", () =>
-              runtime.queryById!(vectorId, options),
-            )
+          ? tryVectorizePromise(definition.binding, "queryById", () => {
+              const queryById = runtime.queryById;
+
+              return queryById === undefined
+                ? Promise.reject(new TypeError("Vectorize binding does not expose queryById()"))
+                : invokeVectorizeMethod(queryById, runtime, [vectorId, options]);
+            })
           : Effect.fail(
               vectorizeError(
                 definition.binding,
@@ -251,6 +277,7 @@ export const Tag =
 
     const makeLayer = (definition: LayerOptions) => layer(tag, definition);
 
+    // SAFETY: Object.assign attaches exactly the static id/layer members declared by TagClass.
     return Object.assign(tag, {
       id,
       layer: makeLayer,

package/src/Vitest.ts

@@ -24,7 +24,7 @@ import {
   runInDurableObject as runInDurableObjectPromise,
   waitOnExecutionContext,
 } from "cloudflare:test";
-import { ConfigProvider, Effect, Exit, Layer } from "effect";
+import { ConfigProvider, Effect, Exit, Layer, Schema } from "effect";
 
 import {
   DurableObjectState,
@@ -148,6 +148,7 @@ export const pages = Effect.fn("effect-cf/vitest/pages")(function* <
 >(handler: Function, init: PagesEventContextInit<Function>) {
   return yield* Effect.acquireUseRelease(
     Effect.sync(() =>
+      // SAFETY: PagesEventContextInit computes the same conditional initializer accepted by this Function.
       createPagesEventContext<Function>(
         init as Parameters<typeof createPagesEventContext<Function>>[0],
       ),
@@ -362,7 +363,10 @@ export interface WorkflowMockEvent {
 export interface WorkflowInstanceModifier {
   readonly disableSleeps: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
   readonly disableRetryDelays: (steps?: ReadonlyArray<WorkflowStepTarget>) => Effect.Effect<void>;
-  readonly mockStepResult: (step: WorkflowStepTarget, result: unknown) => Effect.Effect<void>;
+  readonly mockStepResult: (
+    step: WorkflowStepTarget,
+    result: WorkflowMockResult,
+  ) => Effect.Effect<void>;
   readonly mockStepError: (
     step: WorkflowStepTarget,
     error: Error,
@@ -373,6 +377,8 @@ export interface WorkflowInstanceModifier {
   readonly forceEventTimeout: (step: WorkflowStepTarget) => Effect.Effect<void>;
 }
 
+type WorkflowMockResult = Schema.Schema.Type<typeof Schema.Unknown>;
+
 /** Effect-native introspector for one Workflow instance. */
 export interface WorkflowInstanceIntrospector {
   readonly raw: NativeWorkflowInstanceIntrospector;
@@ -413,7 +419,7 @@ const wrapWorkflowModifier = (
 });
 
 const runWorkflowModifier = Effect.fnUntraced(function* <A, E, R>(
-  register: (use: (modifier: NativeWorkflowInstanceModifier) => Promise<void>) => Promise<unknown>,
+  register: (use: (modifier: NativeWorkflowInstanceModifier) => Promise<void>) => Promise<any>,
   use: (modifier: WorkflowInstanceModifier) => Effect.Effect<A, E, R>,
 ): Effect.fn.Return<A, E, R> {
   const context = yield* Effect.context<R>();

package/src/WebTransport.ts

@@ -30,7 +30,7 @@
  * the edge does provide.
  */
 import type { Request as CloudflareRequest } from "@cloudflare/workers-types";
-import { Data, Effect, Option, Result, Schema as S } from "effect";
+import { Data, Effect, Option, Predicate, Result, Schema as S } from "effect";
 
 /**
  * Metadata Cloudflare's edge reports about the inbound client connection.
@@ -92,10 +92,16 @@ export interface Capabilities {
 }
 
 /** Feature-detects the WebTransport capabilities of the current runtime. */
-export const capabilities: Effect.Effect<Capabilities> = Effect.sync(() => ({
-  inboundSessions: false,
-  outboundSessions: typeof (globalThis as Record<string, unknown>)["WebTransport"] === "function",
-}));
+export const capabilities: Effect.Effect<Capabilities> = Effect.sync(() => {
+  const runtime = globalThis;
+
+  return {
+    inboundSessions: false,
+    outboundSessions:
+      Predicate.hasProperty(runtime, "WebTransport") &&
+      Predicate.isFunction(runtime["WebTransport"]),
+  };
+});
 
 /** WebTransport capability missing from the current Workers runtime. */
 export type WebTransportCapability = "inbound-sessions" | "outbound-sessions";