effect-cf 0.26.0 → 0.28.0

package/src/DurableObjectNamespace.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, type Context, type Layer, type Scope } from "effect";
+import { Data, Effect, Predicate, type Context, type Layer, type Scope } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -17,13 +17,18 @@ interface DurableObjectFetcher {
 
 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];
 };
 
 type ReservedMethodName = DurableObjectDefinition.ReservedMethodName | "fetch";
+type DynamicMethod = (...args: Array<any>) => any;
+interface DynamicMethods {
+  [method: string]: DynamicMethod;
+}
+type NamespaceCandidate = Parameters<typeof Predicate.isUnknown>[0];
 
 /**
  * Cloudflare Durable Object stub, optionally enriched with RPC methods.
@@ -373,14 +378,12 @@ export type DurableObjectNamespaceStaticClient<
   readonly rawUnsafe: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
 };
 
-const hasFunction = (value: object, key: string): boolean =>
-  typeof Reflect.get(value, key) === "function";
+const hasFunction = <Candidate>(value: Candidate, key: string): boolean =>
+  Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
 
 export const isDurableObjectNamespaceClient = <Api extends object>(
-  value: unknown,
+  value: NamespaceCandidate,
 ): value is DurableObjectNamespaceClient<Api> =>
-  typeof value === "object" &&
-  value !== null &&
   hasFunction(value, "getByName") &&
   hasFunction(value, "get") &&
   hasFunction(value, "idFromName") &&
@@ -430,6 +433,7 @@ export const makeClient = <
       Method extends StubMethodKey<Api>,
     >(stub: StubClient, method: Method, ...args: StubMethodArgs<Api, Method>) {
       const methodName = String(method);
+      // SAFETY: the runtime definition and method name select the same method schemas as Method.
       const encodedArgs =
         definition.definition === undefined
           ? args
@@ -448,6 +452,7 @@ export const makeClient = <
               ),
             );
 
+      // SAFETY: encodedArgs preserves the selected method's positional argument contract.
       return yield* RpcInvocation.invokeRpcMethod(
         stub,
         method,
@@ -465,9 +470,11 @@ export const makeClient = <
       Method extends StubMethodKey<Api>,
     >(methodName: string, value: Awaited<StubMethodCloudflareReturn<Api, Method>>) {
       if (definition.definition === undefined) {
+        // SAFETY: without a schema codec, the native RPC result is already the declared success type.
         return value as StubMethodSuccess<Api, Method>;
       }
 
+      // SAFETY: methodName identifies Method in the same definition used to decode the result.
       const decoded = yield* RpcDefinition.decodeSuccess(
         definition.definition,
         methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
@@ -483,6 +490,7 @@ export const makeClient = <
         ),
       );
 
+      // SAFETY: the selected method's success schema decodes to its declared API success type.
       return decoded as StubMethodSuccess<Api, Method>;
     });
 
@@ -521,6 +529,7 @@ export const makeClient = <
       getByName,
     });
 
+    // SAFETY: the common namespace operations and generated direct methods implement the client contract.
     return Object.assign(directMethods, {
       newUniqueId,
       idFromName,
@@ -581,47 +590,51 @@ export const makeDirectMethods = <
     ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
   },
 ): DirectMethods<R, Api, Definition> => {
-  const methods = {} as Record<string, unknown>;
+  const methods: DynamicMethods = {};
 
   if (rpcDefinition !== undefined) {
     for (const methodName of Object.keys(rpcDefinition.methods)) {
+      // SAFETY: methodName comes from rpcDefinition.methods and helpers.call dispatches that same key.
       methods[methodName] = (stub: DurableObjectStubClient<Api>, ...args: Array<unknown>) =>
         (
           helpers.call as (
             stub: DurableObjectStubClient<Api>,
             method: string,
             ...args: Array<unknown>
-          ) => unknown
+          ) => any
         )(stub, methodName, ...args);
     }
 
     const makeClient = (
       getStub: () => Effect.Effect<DurableObjectStubClient<Api>, never, R>,
     ): DurableObjectDirectClient<R, Api> => {
-      const client = {
+      const client: DynamicMethods = {
         fetch: (input: RequestInfo | URL, init?: RequestInit) =>
           Effect.gen(function* () {
             const stub = yield* getStub();
 
             return yield* helpers.fetch(stub, input, init);
           }),
-      } as Record<string, unknown>;
+      };
 
       for (const methodName of Object.keys(rpcDefinition.methods)) {
+        // SAFETY: methodName comes from rpcDefinition.methods and helpers.call dispatches that same key.
         client[methodName] = (...args: Array<unknown>) =>
           Effect.gen(function* () {
             const stub = yield* getStub();
 
+            // SAFETY: methodName and arguments come from the same generated RPC method entry.
             return yield* (
               helpers.call as (
                 stub: DurableObjectStubClient<Api>,
                 method: string,
                 ...args: Array<unknown>
-              ) => Effect.Effect<unknown, DurableObjectRpcError, R>
+              ) => Effect.Effect<any, DurableObjectRpcError, R>
             )(stub, methodName, ...args);
           });
       }
 
+      // SAFETY: client contains fetch plus every RPC method enumerated by rpcDefinition.
       return client as DurableObjectDirectClient<R, Api>;
     };
 
@@ -636,5 +649,6 @@ export const makeDirectMethods = <
     ) => makeClient(() => helpers.get(id, options));
   }
 
+  // SAFETY: methods is populated from the exact rpcDefinition keys, including its by-name/id clients.
   return methods as DirectMethods<R, Api, Definition>;
 };

package/src/DurableObjectRpcWebSocket.ts

@@ -32,7 +32,7 @@ export interface DurableObjectRpcWebSocketService {
     message: NativeWebSocketMessage,
   ) => Effect.Effect<void>;
   readonly close: (socket: DurableWebSocket) => Effect.Effect<void>;
-  readonly error: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void>;
+  readonly error: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void>;
 }
 
 interface RpcConnection {
@@ -192,6 +192,7 @@ export const layer = (
             }
 
             for (const current of decoded) {
+              // SAFETY: this parser was created by the configured RPC serialization service.
               yield* run(connection.id, current as RpcMessage.FromClientEncoded);
             }
           }).pipe(
@@ -204,9 +205,9 @@ export const layer = (
             }),
           ),
         close: unregister,
-        error: (socket, error) =>
+        error: (socket, cause) =>
           Effect.gen(function* () {
-            yield* Effect.logDebug("Durable Object RPC websocket error", error);
+            yield* Effect.logDebug("Durable Object RPC websocket error", cause);
             yield* unregister(socket);
           }),
       });
@@ -219,16 +220,15 @@ export const layer = (
   );
 
 const normalizeMessage = (message: NativeWebSocketMessage) =>
-  typeof message === "string" ? message : new Uint8Array(message);
+  Predicate.isString(message) ? message : new Uint8Array(message);
 
 const readAttachment = (socket: WebSocket, key: string): number | undefined => {
   const value = socket.deserializeAttachment();
 
   if (
-    value !== null &&
-    typeof value === "object" &&
-    key in value &&
-    typeof value[key] === "number"
+    Predicate.isObjectOrArray(value) &&
+    Predicate.hasProperty(value, key) &&
+    Predicate.isNumber(value[key])
   ) {
     return value[key];
   }
@@ -238,8 +238,7 @@ const readAttachment = (socket: WebSocket, key: string): number | undefined => {
 
 const writeAttachment = (socket: WebSocket, key: string, clientId: number) => {
   const current = socket.deserializeAttachment();
-  const attachment =
-    current !== null && typeof current === "object" && !Array.isArray(current) ? current : {};
+  const attachment = Predicate.isObject(current) ? current : {};
 
   socket.serializeAttachment({
     ...attachment,

package/src/DurableObjectState.ts

@@ -88,6 +88,7 @@ export const fromDurableObjectState = (
   const scheduleWaitUntil = makeWaitUntilScheduler("DurableObjectState.waitUntil", (promise) =>
     state.waitUntil(promise),
   );
+  // SAFETY: the runtime Effect.isEffect branch implements both overloads of the service method.
   const waitUntil = (<A, E, R, R2 = never>(
     input: Promise<unknown> | Effect.Effect<A, E, R>,
     options?: WorkerContextWaitUntilOptions<E, R2>,

package/src/DurableObjectStorage.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, Exit, Option, Schema as S } from "effect";
+import { Data, Effect, Exit, Option, Predicate, Schema as S } from "effect";
 
 import * as ErrorMessage from "./internal/ErrorMessage";
 
@@ -260,6 +260,7 @@ const fromSyncKvStorage = (kv: globalThis.SyncKvStorage): SyncKvStorage => ({
     schemaBackedSyncKvStorage(kv, definition),
 });
 
+// SAFETY: every overload is dispatched by the native key form and wrapped with the same Effect error contract.
 const fromDurableObjectTransaction = (
   txn: globalThis.DurableObjectTransaction,
 ): DurableObjectTransaction =>
@@ -279,7 +280,7 @@ const fromDurableObjectTransaction = (
       maybeOptions?: globalThis.DurableObjectPutOptions,
     ) =>
       tryStoragePromise("transaction.put", () =>
-        typeof keyOrEntries === "string"
+        Predicate.isString(keyOrEntries)
           ? txn.put(keyOrEntries, valueOrOptions as T, maybeOptions)
           : txn.put(keyOrEntries, valueOrOptions as globalThis.DurableObjectPutOptions | undefined),
       ),
@@ -334,6 +335,7 @@ export const fromDurableObjectStorage = (
             );
           } catch (cause) {
             if (Exit.isExit(cause) && Exit.isFailure(cause)) {
+              // SAFETY: Exit.isFailure proves this cause carries the closure's typed E failure.
               return Effect.failCause(cause.cause) as Effect.Effect<
                 A,
                 E | StorageOperationError,
@@ -366,6 +368,7 @@ export const fromDurableObjectStorage = (
               (value) => resume(Effect.succeed(value)),
               (cause) => {
                 if (Exit.isExit(cause) && Exit.isFailure(cause)) {
+                  // SAFETY: Exit.isFailure proves this cause carries the closure's typed E failure.
                   resume(
                     Effect.failCause(cause.cause) as Effect.Effect<A, E | StorageOperationError>,
                   );

package/src/DurableObjectWebSocket.ts

@@ -61,6 +61,7 @@ export const fromWebSocket = <Attachment = unknown>(
   const existing = wrappers.get(raw);
 
   if (existing !== undefined) {
+    // SAFETY: Attachment is phantom; a wrapper's runtime behavior is independent of that type.
     return existing as DurableWebSocket<Attachment>;
   }
 
@@ -89,6 +90,7 @@ export const fromWebSocket = <Attachment = unknown>(
 
   wrappers.set(raw, socket);
 
+  // SAFETY: Attachment is phantom; the newly created wrapper supports values through its generic serializer.
   return socket as DurableWebSocket<Attachment>;
 };
 
@@ -200,6 +202,7 @@ export const attachment = <const AttachmentSchema extends S.Codec<any, any, neve
       Effect.mapError(
         (cause) => new DurableWebSocketAttachmentError({ operation: "serialize", cause }),
       ),
+      // SAFETY: S.encodeEffect returns this codec's declared Encoded representation.
       Effect.flatMap((encoded) => socket.serializeAttachment(encoded as Encoded)),
     );
 
@@ -261,7 +264,7 @@ export interface DurableWebSocketHandlers<R = never, E = unknown> {
     reason: string,
     wasClean: boolean,
   ) => Effect.Effect<void, E, R>;
-  readonly error?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>;
+  readonly error?: (socket: DurableWebSocket, cause: unknown) => Effect.Effect<void, E, R>;
 }
 
 /** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */

package/src/Email.ts

@@ -4,7 +4,7 @@ import type {
   EmailSendResult as CloudflareEmailSendResult,
   SendEmail as CloudflareSendEmail,
 } from "@cloudflare/workers-types";
-import { Context, Data, Effect, type Layer } from "effect";
+import { Context, Data, Effect, type Layer, Predicate } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -114,6 +114,7 @@ export type EmailSendResult = CloudflareEmailSendResult;
 export type EmailBinding = CloudflareSendEmail;
 export type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
 export type EmailSendError = EmailOperationError | EmailValidationError;
+type EmailFieldCandidate = Parameters<typeof Predicate.isUnknown>[0];
 
 export interface EmailSendOptions {
   /** Validates builder messages against documented limits. Defaults to `true`. */
@@ -166,13 +167,13 @@ export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
  * error and strips non-standard properties.
  */
 const emailErrorCode = (cause: unknown): EmailOperationError["code"] => {
-  if (typeof cause !== "object" || cause === null) {
+  if (!Predicate.isObject(cause)) {
     return undefined;
   }
 
-  const code = Reflect.get(cause, "code");
+  const code = Predicate.hasProperty(cause, "code") ? cause.code : undefined;
 
-  return typeof code === "string" ? code : undefined;
+  return Predicate.isString(code) ? code : undefined;
 };
 
 const emailError = (binding: string, operation: string, cause: unknown) =>
@@ -213,21 +214,25 @@ const addressList = (value: EmailRecipients | undefined): ReadonlyArray<string |
     return [];
   }
 
+  // SAFETY: the non-array branch is exactly the scalar member of EmailRecipients.
   return Array.isArray(value) ? value : [value as string | EmailAddress];
 };
 
-const addressViolations = (path: string, value: unknown): ReadonlyArray<EmailViolation> => {
-  if (typeof value === "string") {
+const addressViolations = (
+  path: string,
+  value: EmailFieldCandidate,
+): ReadonlyArray<EmailViolation> => {
+  if (Predicate.isString(value)) {
     return value.includes("@") ? [] : [{ path, message: "Email address must contain an @ symbol" }];
   }
 
-  if (typeof value !== "object" || value === null) {
+  if (!Predicate.isObject(value)) {
     return [{ path, message: "Email address must be a string or { name, email } object" }];
   }
 
-  const email = Reflect.get(value, "email");
+  const email = Predicate.hasProperty(value, "email") ? value.email : undefined;
 
-  if (typeof email !== "string" || !email.includes("@")) {
+  if (!Predicate.isString(email) || !email.includes("@")) {
     return [{ path: `${path}.email`, message: "Email address must contain an @ symbol" }];
   }
 
@@ -255,16 +260,16 @@ const attachmentViolations = (
     const attachment = attachments[index];
     const path = `attachments[${index}]`;
 
-    if (typeof attachment !== "object" || attachment === null) {
+    if (!Predicate.isObject(attachment)) {
       violations.push({ path, message: "Attachment must be an object" });
       continue;
     }
 
-    if (typeof attachment.filename !== "string" || attachment.filename === "") {
+    if (!Predicate.isString(attachment.filename) || attachment.filename === "") {
       violations.push({ path: `${path}.filename`, message: "Attachment filename is required" });
     }
 
-    if (typeof attachment.type !== "string" || attachment.type === "") {
+    if (!Predicate.isString(attachment.type) || attachment.type === "") {
       violations.push({ path: `${path}.type`, message: "Attachment MIME type is required" });
     }
 
@@ -272,7 +277,7 @@ const attachmentViolations = (
       violations.push({ path: `${path}.content`, message: "Attachment content is required" });
     }
 
-    if (attachment.disposition === "inline" && typeof attachment.contentId !== "string") {
+    if (attachment.disposition === "inline" && !Predicate.isString(attachment.contentId)) {
       violations.push({
         path: `${path}.contentId`,
         message: "Inline attachments require a contentId",
@@ -299,7 +304,7 @@ const headerViolations = (headers: Record<string, string>): ReadonlyArray<EmailV
       );
     }
 
-    if (typeof value !== "string") {
+    if (!Predicate.isString(value)) {
       violations.push({ path, message: "Header value must be a string" });
       continue;
     }
@@ -346,6 +351,7 @@ const headerViolations = (headers: Record<string, string>): ReadonlyArray<EmailV
  */
 export const validateMessage = (message: EmailMessageBuilder): ReadonlyArray<EmailViolation> => {
   const violations: Array<EmailViolation> = [];
+  // SAFETY: this wider view exists solely to validate runtime callers that bypass TypeScript.
   const fields = message as {
     readonly to?: EmailRecipients;
     readonly cc?: EmailRecipients;
@@ -369,11 +375,11 @@ export const validateMessage = (message: EmailMessageBuilder): ReadonlyArray<Ema
     violations.push(...addressViolations("replyTo", fields.replyTo));
   }
 
-  if (typeof fields.subject !== "string" || fields.subject === "") {
+  if (!Predicate.isString(fields.subject) || fields.subject === "") {
     violations.push({ path: "subject", message: "A subject is required" });
   }
 
-  if (typeof fields.text !== "string" && typeof fields.html !== "string") {
+  if (!Predicate.isString(fields.text) && !Predicate.isString(fields.html)) {
     violations.push({ path: "$", message: "A message requires either text or html content" });
   }
 
@@ -425,19 +431,13 @@ const validateSendInput = (
     : Effect.succeed(message);
 };
 
-export const isEmailBinding = (value: unknown): value is EmailBinding => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const resource = value as Record<string, unknown>;
-
-  return typeof resource.send === "function";
-};
+export const isEmailBinding = <Candidate>(value: Candidate): value is Candidate & EmailBinding =>
+  Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
 
 export const makeClient =
   (definition: EmailDefinition, options?: EmailSendOptions) =>
   (email: EmailBinding): EmailClient => {
+    // SAFETY: EmailBinding.send is the native promise API represented by EmailRuntimeBinding.
     const runtime = email as EmailRuntimeBinding;
     const validate = options?.validate ?? true;
     const send = Effect.fn("Email.send")(function* (message: EmailMessageBuilder) {
@@ -469,6 +469,7 @@ export const Tag =
 
     const makeLayer = (definition: LayerOptions) => layer(tag, definition);
 
+    // SAFETY: these are exactly the members required by TagClass, attached to the matching service tag.
     return Object.assign(tag, {
       id,
       layer: makeLayer,

package/src/Hyperdrive.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, type Layer } from "effect";
+import { Context, Effect, type Layer, Predicate } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -45,15 +45,8 @@ export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
   >;
 }
 
-export const isHyperdrive = (value: unknown): value is Hyperdrive => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const resource = value as Record<string, unknown>;
-
-  return typeof resource.connectionString === "string";
-};
+export const isHyperdrive = <Candidate>(value: Candidate): value is Candidate & Hyperdrive =>
+  Predicate.hasProperty(value, "connectionString") && Predicate.isString(value.connectionString);
 
 export const makeClient =
   (definition: HyperdriveDefinition) =>
@@ -80,6 +73,7 @@ export const Tag =
 
     const makeLayer = (definition: LayerOptions) => layer(tag, definition);
 
+    // SAFETY: these are exactly the members required by TagClass, attached to the matching service tag.
     return Object.assign(tag, {
       id,
       layer: makeLayer,

package/src/Images.ts

@@ -16,7 +16,7 @@ import type {
   ImageUploadOptions as CloudflareImageUploadOptions,
   Response as CloudflareResponse,
 } from "@cloudflare/workers-types";
-import { Context, Data, Effect, Function, Option, type Layer } from "effect";
+import { Context, Data, Effect, Function, Option, Predicate, type Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -224,21 +224,18 @@ const tryImagesSync = <A>(
 const maybe = <A>(value: A | null): Option.Option<A> =>
   value === null ? Option.none() : Option.some(value);
 
-const hasFunction = (value: object, key: string): boolean =>
-  typeof Reflect.get(value, key) === "function";
+const hasFunction = <Candidate>(value: Candidate, key: string): boolean =>
+  Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
 
-const isHostedImagesBinding = (value: unknown): value is CloudflareHostedImagesBinding =>
-  typeof value === "object" &&
-  value !== null &&
-  hasFunction(value, "image") &&
-  hasFunction(value, "upload") &&
-  hasFunction(value, "list");
+const isHostedImagesBinding = <Candidate>(
+  value: Candidate,
+): value is Candidate & CloudflareHostedImagesBinding =>
+  hasFunction(value, "image") && hasFunction(value, "upload") && hasFunction(value, "list");
 
-export const isImagesBinding = (value: unknown): value is ImagesRuntimeBinding =>
-  typeof value === "object" &&
-  value !== null &&
-  hasFunction(value, "info") &&
-  hasFunction(value, "input");
+export const isImagesBinding = <Candidate>(
+  value: Candidate,
+): value is Candidate & ImagesRuntimeBinding =>
+  hasFunction(value, "info") && hasFunction(value, "input");
 
 const wrapResult = (
   binding: string,
@@ -342,6 +339,7 @@ export const Tag =
 
     const makeLayer = (definition: LayerOptions) => layer(tag, definition);
 
+    // SAFETY: these are exactly the members required by TagClass, attached to the matching service tag.
     return Object.assign(tag, {
       id,
       layer: makeLayer,

package/src/Kv.ts

@@ -2,7 +2,7 @@ import type {
   KVNamespaceListOptions as CloudflareKVNamespaceListOptions,
   KVNamespacePutOptions as CloudflareKVNamespacePutOptions,
 } from "@cloudflare/workers-types";
-import { Context, Data, Effect, Option, Schema as S, type Layer } from "effect";
+import { Context, Data, Effect, Option, Predicate, Schema as S, type Layer } from "effect";
 
 import * as Binding from "./Binding";
 import type { WorkerEnvironment } from "./Environment";
@@ -144,21 +144,17 @@ const tryKvPromise = <A>(
     catch: (cause) => kvError(binding, operation, cause),
   });
 
-export const isKvNamespace = (value: unknown): value is KVNamespace => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const resource = value as Record<string, unknown>;
-
-  return (
-    typeof resource.get === "function" &&
-    typeof resource.put === "function" &&
-    typeof resource.delete === "function" &&
-    typeof resource.getWithMetadata === "function" &&
-    typeof resource.list === "function"
-  );
-};
+export const isKvNamespace = <Candidate>(value: Candidate): value is Candidate & KVNamespace =>
+  Predicate.hasProperty(value, "get") &&
+  Predicate.isFunction(value.get) &&
+  Predicate.hasProperty(value, "put") &&
+  Predicate.isFunction(value.put) &&
+  Predicate.hasProperty(value, "delete") &&
+  Predicate.isFunction(value.delete) &&
+  Predicate.hasProperty(value, "getWithMetadata") &&
+  Predicate.isFunction(value.getWithMetadata) &&
+  Predicate.hasProperty(value, "list") &&
+  Predicate.isFunction(value.list);
 
 export const makeClient = <Key, Value, EncodedValue>(
   definition: KvDefinition<Key, Value, EncodedValue>,
@@ -232,7 +228,8 @@ export const makeClient = <Key, Value, EncodedValue>(
           key.metadata === undefined
             ? Option.none<Metadata>()
             : metadataSchema === undefined
-              ? Option.some(key.metadata as Metadata)
+              ? // SAFETY: without a metadata schema, KV's generic Metadata contract is passed through.
+                Option.some(key.metadata as Metadata)
               : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(key.metadata));
 
         keys.push({
@@ -310,6 +307,7 @@ export const Tag =
 
     const makeLayer = (binding: LayerOptions) => kvDefinition.layer(tag, binding);
 
+    // SAFETY: the assigned schemas and layer exactly implement TagClass for this KV definition.
     return Object.assign(tag, {
       id: kvDefinition.id,
       keySchema: kvDefinition.key,

package/src/Queue.ts

@@ -38,6 +38,7 @@ export class QueueMessageDecodeError extends Data.TaggedError("QueueMessageDecod
 type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
 
 type QueueHandlerContext<ROut> = RuntimeContext<ROut> | Scope.Scope;
+type EncodedQueueBody = globalThis.Message<unknown>["body"];
 
 export type QueueHandler<ROut, Body = unknown> = (
   batch: QueueBatch<Body>,
@@ -71,7 +72,7 @@ export const fromMessageBatch = <Body>(
 
 export const decodeBatch = <Body>(
   batch: globalThis.MessageBatch<unknown>,
-  decodeBody: (body: unknown) => Effect.Effect<Body, unknown>,
+  decodeBody: (body: EncodedQueueBody) => Effect.Effect<Body, unknown>,
 ): Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError> =>
   Effect.gen(function* () {
     const messages: Array<QueueMessage<Body>> = [];

package/src/QueueBinding.ts

@@ -7,7 +7,7 @@ import type {
   QueueSendOptions as CloudflareQueueSendOptions,
   QueueSendResponse as CloudflareQueueSendResponse,
 } from "@cloudflare/workers-types";
-import { type Context, Data, Effect, Schema as S } from "effect";
+import { type Context, Data, Effect, Predicate, Schema as S } from "effect";
 
 import * as Binding from "./Binding";
 import type * as RpcDefinition from "./RpcDefinition";
@@ -24,6 +24,8 @@ export type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> &
 
 const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
 
+type QueueCandidate = Parameters<typeof Predicate.isUnknown>[0];
+
 export interface QueueBindingDefinition<Message extends RpcDefinition.ServiceFreeSchema> {
   /** Binding name as configured in `wrangler.jsonc`. */
   readonly binding: string;
@@ -41,7 +43,7 @@ export interface QueueBindingClient<Message extends RpcDefinition.ServiceFreeSch
     options?: QueueSendBatchOptions,
   ) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
   readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareQueue<S.Codec.Encoded<Message>>>;
+  readonly rawUnsafe: Effect.Effect<QueueProducer<S.Codec.Encoded<Message>>>;
 }
 
 export class QueueOperationError extends Data.TaggedError("QueueOperationError")<{
@@ -67,15 +69,8 @@ const tryQueuePromise = <A>(
       }),
   });
 
-export const isQueue = <Body>(value: unknown): value is QueueProducer<Body> => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const resource = value as Record<string, unknown>;
-
-  return typeof resource.send === "function";
-};
+export const isQueue = <Body>(value: QueueCandidate): value is QueueProducer<Body> =>
+  Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
 
 export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
   definition: QueueBindingDefinition<Message>,
@@ -136,7 +131,7 @@ export const makeClient = <Message extends RpcDefinition.ServiceFreeSchema>(
 
       return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
     },
-    rawUnsafe: Effect.succeed(queue as CloudflareQueue<EncodedBody>),
+    rawUnsafe: Effect.succeed(queue),
   });
 };