effect-cf 0.5.0 → 0.6.0

package/src/DurableObjectNamespace.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from "effect";
+import { Data, Effect, type Scope } from "effect";
 
 import * as Binding from "./Binding";
 import * as CloudflareRpc from "./Rpc";
@@ -110,21 +110,21 @@ type StubMethodSuccess<Api, Method extends keyof Api> = RpcInvocation.AsyncMetho
   Method
 >;
 
-type StubCall<Api extends object> = <Method extends StubMethodKey<Api>>(
+type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(
   stub: DurableObjectStubClient<Api>,
   method: Method,
   ...args: StubMethodArgs<Api, Method>
-) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
 
-type DurableObjectDirectClient<Self, Api extends object> = {
+type DurableObjectDirectClient<R, Api extends object> = {
   readonly fetch: (
     input: RequestInfo | URL,
     init?: RequestInit,
-  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, Self>;
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
 } & {
   readonly [Method in StubMethodKey<Api>]: (
     ...args: StubMethodArgs<Api, Method>
-  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, Self>;
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
 };
 
 type DefinitionNamespaceDirectMethods<
@@ -141,46 +141,89 @@ type DefinitionNamespaceDirectMethods<
 };
 
 type DefinitionDurableObjectDirectClient<
-  Self,
+  R,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
   readonly fetch: (
     input: RequestInfo | URL,
     init?: RequestInit,
-  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, Self>;
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
 } & {
   readonly [Method in RpcDefinition.Definition.MethodNames<Definition>]: (
     ...args: RpcDefinition.Method.Args<Definition["methods"][Method]>
   ) => Effect.Effect<
     RpcDefinition.Method.Success<Definition["methods"][Method]>,
     DurableObjectRpcError,
-    Self
+    R
   >;
 };
 
 type DefinitionNamespaceDirectClientMethods<
-  Self,
+  R,
   Definition extends DurableObjectDefinition.Definition.Any,
 > = {
   readonly byName: (
     name: string,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-  ) => DefinitionDurableObjectDirectClient<Self, Definition>;
+  ) => DefinitionDurableObjectDirectClient<R, Definition>;
   readonly byId: (
     id: globalThis.DurableObjectId,
     options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-  ) => DefinitionDurableObjectDirectClient<Self, Definition>;
+  ) => DefinitionDurableObjectDirectClient<R, Definition>;
 };
 
 type DirectMethods<
-  Self,
+  R,
   Api extends object,
   Definition,
 > = Definition extends DurableObjectDefinition.Definition.Any
   ? DefinitionNamespaceDirectMethods<Api, Definition> &
-      DefinitionNamespaceDirectClientMethods<Self, Definition>
+      DefinitionNamespaceDirectClientMethods<R, Definition>
   : {};
 
+export type DurableObjectNamespaceEffectClient<
+  Api extends object,
+  Definition extends DurableObjectDefinition.Definition.Any | undefined = undefined,
+> = DirectMethods<never, Api, Definition> & {
+  readonly newUniqueId: (
+    options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
+  ) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId>;
+  readonly get: (
+    id: globalThis.DurableObjectId,
+    options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+  ) => Effect.Effect<DurableObjectStubClient<Api>>;
+  readonly getByName: (
+    name: string,
+    options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+  ) => Effect.Effect<DurableObjectStubClient<Api>>;
+  readonly jurisdiction: (
+    jurisdiction: globalThis.DurableObjectJurisdiction,
+  ) => Effect.Effect<DurableObjectNamespaceClient<Api>>;
+  readonly fetch: (
+    stub: DurableObjectStubClient<Api>,
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
+  readonly rpc: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  readonly call: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
+  readonly scopedCall: <Method extends StubMethodKey<Api>>(
+    stub: DurableObjectStubClient<Api>,
+    method: Method,
+    ...args: StubMethodArgs<Api, Method>
+  ) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
+  readonly unsafeRaw: Effect.Effect<DurableObjectNamespaceClient<Api>>;
+};
+
 /**
  * Creates a typed Effect service for a Durable Object namespace binding.
  *
@@ -230,25 +273,170 @@ export const Service =
       hasFunction(value, "newUniqueId") &&
       hasFunction(value, "jurisdiction");
 
-    const tag = Binding.Service<Self>()(id, definition.binding, (value): value is NamespaceClient =>
-      isDurableObjectNamespaceClient(value),
+    const makeClient = (
+      namespace: NamespaceClient,
+    ): DurableObjectNamespaceEffectClient<NamespaceApi, Definition> => {
+      const newUniqueId = (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) =>
+        Effect.sync(() => namespace.newUniqueId(options));
+
+      const idFromName = (name: string) => Effect.sync(() => namespace.idFromName(name));
+
+      const idFromString = (id: string) => Effect.sync(() => namespace.idFromString(id));
+
+      const get = (
+        id: globalThis.DurableObjectId,
+        options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+      ) => Effect.sync(() => namespace.get(id, options));
+
+      const getByName = (
+        name: string,
+        options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
+      ) => Effect.sync(() => namespace.getByName(name, options));
+
+      const jurisdiction = (value: globalThis.DurableObjectJurisdiction) =>
+        Effect.sync(() => namespace.jurisdiction(value));
+
+      const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
+        Effect.tryPromise({
+          try: () => stub.fetch(input, init),
+          catch: (cause) => new DurableObjectFetchError({ binding: definition.binding, cause }),
+        });
+
+      const rpc = <Method extends StubMethodKey<NamespaceApi>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<NamespaceApi, Method>
+      ) =>
+        Effect.gen(function* () {
+          const methodName = String(method);
+          const encodedArgs =
+            definition.definition === undefined
+              ? args
+              : yield* RpcDefinition.encodeArgs(
+                  definition.definition,
+                  methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+                  args as never,
+                ).pipe(
+                  Effect.mapError(
+                    (cause) =>
+                      new DurableObjectRpcError({
+                        binding: definition.binding,
+                        method: methodName,
+                        cause,
+                      }),
+                  ),
+                );
+
+          return yield* RpcInvocation.invokeRpcMethod(
+            stub,
+            method,
+            encodedArgs as StubMethodArgs<NamespaceApi, Method>,
+            (cause) =>
+              new DurableObjectRpcError({
+                binding: definition.binding,
+                method: methodName,
+                cause,
+              }),
+          );
+        });
+
+      const call = <Method extends StubMethodKey<NamespaceApi>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<NamespaceApi, Method>
+      ) =>
+        Effect.gen(function* () {
+          const methodName = String(method);
+          const value = yield* CloudflareRpc.resolve(yield* rpc(stub, method, ...args)).pipe(
+            Effect.mapError(
+              (cause) =>
+                new DurableObjectRpcError({
+                  binding: definition.binding,
+                  method: methodName,
+                  cause,
+                }),
+            ),
+          );
+
+          if (definition.definition === undefined) {
+            return value as StubMethodSuccess<NamespaceApi, Method>;
+          }
+
+          const decoded = yield* RpcDefinition.decodeSuccess(
+            definition.definition,
+            methodName as RpcDefinition.Definition.MethodNames<NonNullable<Definition>>,
+            value,
+          ).pipe(
+            Effect.mapError(
+              (cause) =>
+                new DurableObjectRpcError({
+                  binding: definition.binding,
+                  method: methodName,
+                  cause,
+                }),
+            ),
+          );
+
+          return decoded as StubMethodSuccess<NamespaceApi, Method>;
+        });
+
+      const scopedCall = <Method extends StubMethodKey<NamespaceApi>>(
+        stub: StubClient,
+        method: Method,
+        ...args: StubMethodArgs<NamespaceApi, Method>
+      ) =>
+        Effect.gen(function* () {
+          const result = yield* rpc(stub, method, ...args);
+          return yield* CloudflareRpc.scoped(result);
+        });
+
+      const directMethods = makeDirectMethods<never, NamespaceApi, Definition>(
+        definition.definition,
+        {
+          call,
+          fetch,
+          get,
+          getByName,
+        },
+      );
+
+      return Object.assign(directMethods, {
+        newUniqueId,
+        idFromName,
+        idFromString,
+        get,
+        getByName,
+        jurisdiction,
+        fetch,
+        rpc,
+        call,
+        scopedCall,
+        unsafeRaw: Effect.succeed(namespace),
+      }) as DurableObjectNamespaceEffectClient<NamespaceApi, Definition>;
+    };
+
+    const tag = Binding.Service<Self>()(
+      id,
+      definition.binding,
+      (value): value is NamespaceClient => isDurableObjectNamespaceClient(value),
+      makeClient,
     );
 
     const newUniqueId = Effect.fnUntraced(function* (
       options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions,
     ) {
       const namespace = yield* tag;
-      return namespace.newUniqueId(options);
+      return yield* namespace.newUniqueId(options);
     });
 
     const idFromName = Effect.fnUntraced(function* (name: string) {
       const namespace = yield* tag;
-      return namespace.idFromName(name);
+      return yield* namespace.idFromName(name);
     });
 
     const idFromString = Effect.fnUntraced(function* (id: string) {
       const namespace = yield* tag;
-      return namespace.idFromString(id);
+      return yield* namespace.idFromString(id);
     });
 
     const get = Effect.fnUntraced(function* (
@@ -256,7 +444,7 @@ export const Service =
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
       const namespace = yield* tag;
-      return namespace.get(id, options);
+      return yield* namespace.get(id, options);
     });
 
     const getByName = Effect.fnUntraced(function* (
@@ -264,12 +452,12 @@ export const Service =
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
     ) {
       const namespace = yield* tag;
-      return namespace.getByName(name, options);
+      return yield* namespace.getByName(name, options);
     });
 
     const jurisdiction = Effect.fnUntraced(function* (value: globalThis.DurableObjectJurisdiction) {
       const namespace = yield* tag;
-      return namespace.jurisdiction(value);
+      return yield* namespace.jurisdiction(value);
     });
 
     const fetch = (stub: StubClient, input: RequestInfo | URL, init?: RequestInit) =>
@@ -366,6 +554,11 @@ export const Service =
         return yield* CloudflareRpc.scoped(result);
       });
 
+    const unsafeRaw = Effect.fnUntraced(function* () {
+      const namespace = yield* tag;
+      return yield* namespace.unsafeRaw;
+    });
+
     const directMethods = makeDirectMethods<Self, NamespaceApi, Definition>(definition.definition, {
       call,
       fetch,
@@ -386,6 +579,7 @@ export const Service =
       rpc,
       call,
       scopedCall,
+      unsafeRaw,
     }) as typeof tag &
       DirectMethods<Self, NamespaceApi, Definition> & {
         readonly [TypeId]: typeof TypeId;
@@ -400,32 +594,33 @@ export const Service =
         readonly rpc: typeof rpc;
         readonly call: typeof call;
         readonly scopedCall: typeof scopedCall;
+        readonly unsafeRaw: typeof unsafeRaw;
       };
   };
 
 const makeDirectMethods = <
-  Self,
+  R,
   Api extends object,
   Definition extends DurableObjectDefinition.Definition.Any | undefined,
 >(
   rpcDefinition: Definition | undefined,
   helpers: {
-    readonly call: StubCall<Api>;
+    readonly call: StubCall<R, Api>;
     readonly fetch: (
       stub: DurableObjectStubClient<Api>,
       input: RequestInfo | URL,
       init?: RequestInit,
-    ) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
+    ) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
     readonly get: (
       id: globalThis.DurableObjectId,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.Effect<DurableObjectStubClient<Api>, never, Self>;
+    ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
     readonly getByName: (
       name: string,
       options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions,
-    ) => Effect.Effect<DurableObjectStubClient<Api>, never, Self>;
+    ) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
   },
-): DirectMethods<Self, Api, Definition> => {
+): DirectMethods<R, Api, Definition> => {
   const methods = {} as Record<string, unknown>;
 
   if (rpcDefinition !== undefined) {
@@ -441,8 +636,8 @@ const makeDirectMethods = <
     }
 
     const makeClient = (
-      getStub: () => Effect.Effect<DurableObjectStubClient<Api>, never, Self>,
-    ): DurableObjectDirectClient<Self, Api> => {
+      getStub: () => Effect.Effect<DurableObjectStubClient<Api>, never, R>,
+    ): DurableObjectDirectClient<R, Api> => {
       const client = {
         fetch: (input: RequestInfo | URL, init?: RequestInit) =>
           Effect.gen(function* () {
@@ -465,7 +660,7 @@ const makeDirectMethods = <
           });
       }
 
-      return client as DurableObjectDirectClient<Self, Api>;
+      return client as DurableObjectDirectClient<R, Api>;
     };
 
     methods.byName = (
@@ -479,5 +674,5 @@ const makeDirectMethods = <
     ) => makeClient(() => helpers.get(id, options));
   }
 
-  return methods as DirectMethods<Self, Api, Definition>;
+  return methods as DirectMethods<R, Api, Definition>;
 };

package/src/Kv.ts

@@ -84,6 +84,28 @@ export interface KvService<Id extends string, Key, Value, EncodedValue> {
   };
 }
 
+export interface KvClient<Key, Value, EncodedValue> {
+  readonly put: (
+    key: Key,
+    value: Value,
+    options?: KvPutOptions,
+  ) => Effect.Effect<void, KvOperationError | S.SchemaError>;
+  readonly get: (key: Key) => Effect.Effect<Option.Option<Value>, KvOperationError | S.SchemaError>;
+  readonly getWithMetadata: <Metadata>(
+    key: Key,
+    metadataSchema: S.Codec<Metadata, unknown>,
+  ) => Effect.Effect<
+    Option.Option<KvWithMetadata<Value, Metadata>>,
+    KvOperationError | S.SchemaError
+  >;
+  readonly list: <Metadata = unknown>(
+    options?: KvListOptions<Metadata>,
+  ) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | S.SchemaError>;
+  readonly remove: (key: Key) => Effect.Effect<void, KvOperationError | S.SchemaError>;
+  readonly unsafeRaw: Effect.Effect<KVNamespace>;
+  readonly definition: KvDefinition<Key, Value, EncodedValue>;
+}
+
 declare const BindingServiceTypeId: unique symbol;
 
 /** Nominal service marker for KV bindings created from a reusable {@link Definition}. */
@@ -208,46 +230,123 @@ export const Service =
     id: Id,
     definition: KvDefinition<Key, Value, EncodedValue>,
   ) => {
-    const tag = Binding.Service<Self>()(id, definition.binding, (value): 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"
-      );
-    });
-
     const encodeKey = S.encodeEffect(definition.key);
     const decodeKey = S.decodeUnknownEffect(definition.key);
     const encodeValue = S.encodeEffect(S.fromJsonString(S.toCodecJson(definition.value)));
     const decodeValue = S.decodeUnknownEffect(S.fromJsonString(S.toCodecJson(definition.value)));
 
+    const makeClient = (kv: KVNamespace): KvClient<Key, Value, EncodedValue> => ({
+      definition,
+      put: Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
+        const keyEncoded = yield* encodeKey(key);
+        const valueEncoded = yield* encodeValue(value);
+        yield* tryKvPromise(definition.binding, "put", () =>
+          kv.put(keyEncoded, valueEncoded, options),
+        );
+      }),
+      get: Effect.fnUntraced(function* (key: Key) {
+        const keyEncoded = yield* encodeKey(key);
+        const valueEncoded = yield* tryKvPromise(definition.binding, "get", () =>
+          kv.get(keyEncoded),
+        );
+
+        if (valueEncoded === null) {
+          return Option.none();
+        }
+
+        return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+      }),
+      getWithMetadata: Effect.fnUntraced(function* <Metadata>(
+        key: Key,
+        metadataSchema: S.Codec<Metadata, unknown>,
+      ) {
+        const keyEncoded = yield* encodeKey(key);
+        const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () =>
+          kv.getWithMetadata<Metadata>(keyEncoded),
+        );
+
+        if (result.value === null) {
+          return Option.none();
+        }
+
+        const value = yield* decodeValue(result.value);
+        const metadata =
+          result.metadata === null
+            ? Option.none<Metadata>()
+            : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(result.metadata));
+
+        return Option.some({
+          value,
+          metadata,
+          cacheStatus: maybeString(result.cacheStatus),
+        });
+      }),
+      list: Effect.fnUntraced(function* <Metadata = unknown>(options?: KvListOptions<Metadata>) {
+        const { metadataSchema, ...kvOptions } = options ?? {};
+        const result = yield* tryKvPromise(definition.binding, "list", () =>
+          kv.list<Metadata>(kvOptions),
+        );
+        const keys: Array<KvListKey<Key, Metadata>> = [];
+
+        for (const key of result.keys) {
+          const decodedName = yield* decodeKey(key.name);
+          const decodedMetadata =
+            key.metadata === undefined
+              ? Option.none<Metadata>()
+              : metadataSchema === undefined
+                ? Option.some(key.metadata as Metadata)
+                : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(key.metadata));
+
+          keys.push({
+            name: decodedName,
+            expiration: maybeNumber(key.expiration),
+            metadata: decodedMetadata,
+          });
+        }
+
+        return {
+          keys,
+          listComplete: result.list_complete,
+          cursor: maybeString("cursor" in result ? result.cursor : undefined),
+          cacheStatus: maybeString(result.cacheStatus),
+        };
+      }),
+      remove: Effect.fnUntraced(function* (key: Key) {
+        const keyEncoded = yield* encodeKey(key);
+        yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+      }),
+      unsafeRaw: Effect.succeed(kv),
+    });
+
+    const tag = Binding.Service<Self>()(
+      id,
+      definition.binding,
+      (value): 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"
+        );
+      },
+      makeClient,
+    );
+
     const put = Effect.fnUntraced(function* (key: Key, value: Value, options?: KvPutOptions) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      const valueEncoded = yield* encodeValue(value);
-      yield* tryKvPromise(definition.binding, "put", () =>
-        kv.put(keyEncoded, valueEncoded, options),
-      );
+      yield* kv.put(key, value, options);
     });
 
     const get = Effect.fnUntraced(function* (key: Key) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
-
-      if (valueEncoded === null) {
-        return Option.none();
-      }
-
-      return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
+      return yield* kv.get(key);
     });
 
     const getWithMetadata = Effect.fnUntraced(function* <Metadata>(
@@ -255,70 +354,24 @@ export const Service =
       metadataSchema: S.Codec<Metadata, unknown>,
     ) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () =>
-        kv.getWithMetadata<Metadata>(keyEncoded),
-      );
-
-      if (result.value === null) {
-        return Option.none();
-      }
-
-      const value = yield* decodeValue(result.value);
-      const metadata =
-        result.metadata === null
-          ? Option.none<Metadata>()
-          : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(result.metadata));
-
-      return Option.some({
-        value,
-        metadata,
-        cacheStatus: maybeString(result.cacheStatus),
-      });
+      return yield* kv.getWithMetadata(key, metadataSchema);
     });
 
     const list = Effect.fnUntraced(function* <Metadata = unknown>(
       options?: KvListOptions<Metadata>,
     ) {
       const kv = yield* tag;
-      const { metadataSchema, ...kvOptions } = options ?? {};
-      const result = yield* tryKvPromise(definition.binding, "list", () =>
-        kv.list<Metadata>(kvOptions),
-      );
-      const keys: Array<KvListKey<Key, Metadata>> = [];
-
-      for (const key of result.keys) {
-        const decodedName = yield* decodeKey(key.name);
-        const decodedMetadata =
-          key.metadata === undefined
-            ? Option.none<Metadata>()
-            : metadataSchema === undefined
-              ? Option.some(key.metadata as Metadata)
-              : Option.some(yield* S.decodeUnknownEffect(metadataSchema)(key.metadata));
-
-        keys.push({
-          name: decodedName,
-          expiration: maybeNumber(key.expiration),
-          metadata: decodedMetadata,
-        });
-      }
-
-      return {
-        keys,
-        listComplete: result.list_complete,
-        cursor: maybeString("cursor" in result ? result.cursor : undefined),
-        cacheStatus: maybeString(result.cacheStatus),
-      };
+      return yield* kv.list(options);
     });
 
     const remove = Effect.fnUntraced(function* (key: Key) {
       const kv = yield* tag;
-      const keyEncoded = yield* encodeKey(key);
-      yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
+      yield* kv.remove(key);
     });
 
     const unsafeRaw = Effect.fnUntraced(function* () {
-      return yield* tag;
+      const kv = yield* tag;
+      return yield* kv.unsafeRaw;
     });
 
     return Object.assign(tag, {