@alchemy.run/modal 0.0.0-stage → 2.0.0-beta.86

package/src/ReadDictHttp.ts

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeModalBinding } from "./BindingHttp.ts";
+import type { Dict } from "./Dict.ts";
+import { DictOps, makeReadDictClient } from "./DictClient.ts";
+import { ReadDict } from "./ReadDict.ts";
+
+/**
+ * {@link ReadDict} over Modal's API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `viewer` role on the dict's environment.
+ *
+ * @layer
+ * @product Dict
+ * @provides Modal.ReadDict
+ */
+export const ReadDictHttp = Layer.effect(
+  ReadDict,
+  makeModalBinding({
+    tag: "Modal.ReadDict",
+    operations: DictOps,
+    role: "viewer",
+    make: Effect.fn(function* (dict: Dict, ops) {
+      const dictId = yield* dict.dictId;
+      return makeReadDictClient(dictId, ops);
+    }),
+  }),
+);

package/src/ReadFunction.ts

@@ -0,0 +1,107 @@
+import type * as functions from "@distilled.cloud/modal/functions";
+import * as Binding from "alchemy/Binding";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import type * as Effect from "effect/Effect";
+import type { FunctionLookupError } from "./FunctionTarget.ts";
+import type { OpError } from "./internal.ts";
+import type { FunctionTarget } from "./InvokeFunction.ts";
+import type { ReadFunctionOps } from "./ReadFunctionHttp.ts";
+import type { Server } from "./Server.ts";
+
+/** A time range: `Date`s, ISO strings, or epoch milliseconds. */
+export interface TimeRange {
+  readonly since: Date | string | number;
+  readonly until?: Date | string | number;
+}
+
+/** Observe a function: load, call counts and metrics. */
+export interface FunctionReader {
+  /** Inputs waiting and running, and the containers serving them, right now. */
+  stats(): Effect.Effect<
+    {
+      readonly backlog: number;
+      readonly runningInputs: number;
+      readonly containers: number;
+      readonly inputHeadroom: number;
+    },
+    FunctionLookupError | OpError<ReadFunctionOps, "currentStats">,
+    RuntimeContext
+  >;
+  /** Input outcomes, latency percentiles and container counts over a time range. */
+  timeRangeStats(
+    range: TimeRange & { readonly containerId?: string },
+  ): Effect.Effect<
+    functions.FunctionGetTimeRangeStatsResponse,
+    FunctionLookupError | OpError<ReadFunctionOps, "timeRangeStats">,
+    RuntimeContext
+  >;
+  /** Metric series (`containers`, `calls`) over a time range. */
+  metrics(
+    range: TimeRange & {
+      /** Seconds per bucket. @default 3600 */
+      readonly bucketSecs?: number;
+      readonly groups?: ReadonlyArray<string>;
+    },
+  ): Effect.Effect<
+    functions.FunctionGetMetricsResponse,
+    FunctionLookupError | OpError<ReadFunctionOps, "metrics">,
+    RuntimeContext
+  >;
+  /** Calls started per time bucket. */
+  callCount(
+    range: TimeRange & {
+      /** Seconds per bucket. @default 3600 */
+      readonly bucketSecs?: number;
+    },
+  ): Effect.Effect<
+    functions.FunctionCallCountResponse,
+    FunctionLookupError | OpError<ReadFunctionOps, "callCount">,
+    RuntimeContext
+  >;
+  /** The inputs of one call, by outcome. */
+  callInfo(call: {
+    readonly functionCallId: string;
+  }): Effect.Effect<
+    functions.FunctionCallGetInfoResponse,
+    FunctionLookupError | OpError<ReadFunctionOps, "callInfo">,
+    RuntimeContext
+  >;
+  /** The autoscaler settings in effect. */
+  autoscaler(): Effect.Effect<
+    functions.AutoscalerSettings | undefined,
+    FunctionLookupError | OpError<ReadFunctionOps, "schedulingParams">,
+    RuntimeContext
+  >;
+}
+
+/**
+ * Read a Modal Function's (or Server's) live state from any runtime:
+ * backlog and running inputs, call counts, outcome counts, latency
+ * percentiles and metric series. Bind a resource of the Stack, or a function
+ * deployed with `modal deploy` by name.
+ *
+ * ### Watch the backlog
+ * **Example:** Shed load when the queue is long
+ * ```typescript
+ * const embed = yield* Modal.ReadFunction(Embed);
+ * const { backlog } = yield* embed.stats();
+ * if (backlog > 100) return HttpServerResponse.text("busy", { status: 503 });
+ * ```
+ *
+ * ### History
+ * **Example:** Failures in the last hour
+ * ```typescript
+ * const stats = yield* embed.timeRangeStats({ since: new Date(Date.now() - 3_600_000) });
+ * yield* Effect.log(`${stats.inputFailureCount} failed of ${stats.inputSuccessCount}`);
+ * ```
+ *
+ * @binding
+ * @product Function
+ */
+export interface ReadFunction extends Binding.Service<
+  ReadFunction,
+  "Modal.ReadFunction",
+  (target: FunctionTarget | Server) => Effect.Effect<FunctionReader>
+> {}
+
+export const ReadFunction = Binding.Service<ReadFunction>("Modal.ReadFunction");

package/src/ReadFunctionHttp.ts

@@ -0,0 +1,91 @@
+import * as functions from "@distilled.cloud/modal/functions";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeFunctionBinding } from "./FunctionTarget.ts";
+import { operations, timestampOf } from "./internal.ts";
+import type { FunctionTarget } from "./InvokeFunction.ts";
+import { ReadFunction, type FunctionReader } from "./ReadFunction.ts";
+import type { Server } from "./Server.ts";
+
+/** Bucket width when a query doesn't set one: Modal requires a positive one. */
+const DEFAULT_BUCKET_SECS = 3600;
+
+/** The operations the client calls, resolved by `ModalBindings.withCredentials`. */
+const ReadFunctionOps = operations({
+  currentStats: functions.functionGetCurrentStats,
+  timeRangeStats: functions.functionGetTimeRangeStats,
+  metrics: functions.functionGetMetrics,
+  callCount: functions.functionCallCount,
+  callInfo: functions.functionCallGetInfo,
+  schedulingParams: functions.functionGetSchedulingParams,
+});
+
+export type ReadFunctionOps = Effect.Success<typeof ReadFunctionOps>;
+
+/**
+ * {@link ReadFunction} over Modal's API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `viewer` role on the function's environment.
+ *
+ * @layer
+ * @product Function
+ * @provides Modal.ReadFunction
+ */
+export const ReadFunctionHttp = Layer.effect(
+  ReadFunction,
+  makeFunctionBinding({
+    tag: "Modal.ReadFunction",
+    operations: ReadFunctionOps,
+    role: "viewer",
+    make: ({ functionId }, ops, _target: FunctionTarget | Server) =>
+      Effect.succeed({
+        stats: () =>
+          Effect.flatMap(functionId, (id) => ops.currentStats({ functionId: id })).pipe(
+            Effect.map((stats) => ({
+              backlog: stats.backlog ?? 0,
+              runningInputs: stats.numRunningInputs ?? 0,
+              containers: stats.numTotalTasks ?? 0,
+              inputHeadroom: stats.inputHeadroom ?? 0,
+            })),
+          ),
+        timeRangeStats: (range) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.timeRangeStats({
+              functionId: id,
+              since: timestampOf(range.since),
+              until: timestampOf(range.until ?? Date.now()),
+              containerId: range.containerId,
+            }),
+          ),
+        metrics: (range) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.metrics({
+              functionId: id,
+              since: timestampOf(range.since),
+              until: timestampOf(range.until ?? Date.now()),
+              bucketSecs: range.bucketSecs ?? DEFAULT_BUCKET_SECS,
+              groups: range.groups ? [...range.groups] : undefined,
+            }),
+          ),
+        callCount: (range) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.callCount({
+              functionId: id,
+              since: timestampOf(range.since),
+              until: timestampOf(range.until ?? Date.now()),
+              bucketSecs: range.bucketSecs ?? DEFAULT_BUCKET_SECS,
+            }),
+          ),
+        callInfo: (call) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.callInfo({
+              functionId: id,
+              functionCallId: call.functionCallId,
+            }),
+          ),
+        autoscaler: () =>
+          Effect.flatMap(functionId, (id) => ops.schedulingParams({ functionId: id })).pipe(
+            Effect.map((response) => response.autoscalerConfiguration?.settings),
+          ),
+      } satisfies FunctionReader),
+  }),
+);

package/src/ReadQueue.ts

@@ -0,0 +1,44 @@
+import * as Binding from "alchemy/Binding";
+import type * as Effect from "effect/Effect";
+import type { Queue } from "./Queue.ts";
+import type { ReadQueueClient } from "./QueueClient.ts";
+
+export type { ReadQueueClient } from "./QueueClient.ts";
+
+/**
+ * Take items from a Modal Queue from any runtime: take (removes), peek and len. Items are JSON.
+ *
+ * ### Bind a queue
+ * **Example:** From a Cloudflare Worker
+ * ```typescript
+ * import * as Cloudflare from "@alchemy.run/cloudflare";
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/http/HttpServerResponse";
+ * import { Jobs } from "./Storage.ts";
+ *
+ * export default class Api extends Cloudflare.Worker<Api>()(
+ *   "Api",
+ *   { main: import.meta.url },
+ *   Effect.gen(function* () {
+ *     const queue = yield* Modal.ReadQueue(Jobs);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const [job] = yield* queue.take({ timeout: "5 seconds" });
+ *         return yield* HttpServerResponse.json(job ?? null);
+ *       }).pipe(Effect.orDie),
+ *     };
+ *   }).pipe(Effect.provide(Modal.ReadQueueHttp)),
+ * ) {}
+ * ```
+ *
+ * @binding
+ * @product Queue
+ */
+export interface ReadQueue extends Binding.Service<
+  ReadQueue,
+  "Modal.ReadQueue",
+  (queue: Queue) => Effect.Effect<ReadQueueClient>
+> {}
+
+export const ReadQueue = Binding.Service<ReadQueue>("Modal.ReadQueue");

package/src/ReadQueueHttp.ts

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeModalBinding } from "./BindingHttp.ts";
+import type { Queue } from "./Queue.ts";
+import { QueueOps, makeReadQueueClient } from "./QueueClient.ts";
+import { ReadQueue } from "./ReadQueue.ts";
+
+/**
+ * {@link ReadQueue} over Modal's API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `contributor` role on the queue's environment.
+ *
+ * @layer
+ * @product Queue
+ * @provides Modal.ReadQueue
+ */
+export const ReadQueueHttp = Layer.effect(
+  ReadQueue,
+  makeModalBinding({
+    tag: "Modal.ReadQueue",
+    operations: QueueOps,
+    role: "contributor",
+    make: Effect.fn(function* (queue: Queue, ops) {
+      const queueId = yield* queue.queueId;
+      return makeReadQueueClient(queueId, ops);
+    }),
+  }),
+);

package/src/ReadServer.ts

@@ -0,0 +1,98 @@
+import type * as server from "@distilled.cloud/modal/server";
+import * as Binding from "alchemy/Binding";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import type * as Effect from "effect/Effect";
+import type { FunctionLookupError } from "./FunctionTarget.ts";
+import type { OpError } from "./internal.ts";
+import type { TimeRange } from "./ReadFunction.ts";
+import type { ReadServerOps } from "./ReadServerHttp.ts";
+import type { Server } from "./Server.ts";
+
+/** One request a Server handled. */
+export interface ServerRequest {
+  readonly route: string | undefined;
+  readonly timestamp: string | undefined;
+  readonly containerId: string | undefined;
+  readonly durationSeconds: number | undefined;
+  readonly status: number | undefined;
+}
+
+/** A container serving a Server's requests. */
+export interface ServerContainer {
+  readonly containerId: string;
+  readonly host: string | undefined;
+  readonly port: number | undefined;
+}
+
+/** Observe a Server: requests, status codes, latency and containers. */
+export interface ServerReader {
+  /** Request counts by status code, latency percentiles and inference stats over a time range. */
+  stats(
+    range: TimeRange & { readonly containerId?: string },
+  ): Effect.Effect<
+    server.ServerGetTimeRangeStatsResponse,
+    FunctionLookupError | OpError<ReadServerOps, "stats">,
+    RuntimeContext
+  >;
+  /**
+   * Requests the Server handled: the most recent `limit` (newest first, last
+   * seven days), or those in a time range (oldest first).
+   */
+  requests(
+    query: { readonly limit: number } | TimeRange,
+  ): Effect.Effect<
+    ReadonlyArray<ServerRequest>,
+    FunctionLookupError | OpError<ReadServerOps, "requests">,
+    RuntimeContext
+  >;
+  /** Requests per time bucket. */
+  requestCount(
+    range: TimeRange & { readonly bucketSecs?: number },
+  ): Effect.Effect<
+    server.ServerCountRequestsResponse,
+    FunctionLookupError | OpError<ReadServerOps, "requestCount">,
+    RuntimeContext
+  >;
+  /** Metric series (`containers`, `requests`) over a time range. */
+  metrics(
+    range: TimeRange & { readonly bucketSecs?: number; readonly groups?: ReadonlyArray<string> },
+  ): Effect.Effect<
+    server.ServerGetMetricsResponse,
+    FunctionLookupError | OpError<ReadServerOps, "metrics">,
+    RuntimeContext
+  >;
+  /** Containers registered to serve requests right now. */
+  containers(): Effect.Effect<
+    ReadonlyArray<ServerContainer>,
+    FunctionLookupError | OpError<ReadServerOps, "containers">,
+    RuntimeContext
+  >;
+}
+
+/**
+ * Read a `Modal.Server`'s traffic from any runtime: request log, status
+ * codes, latency percentiles, metric series and live containers.
+ *
+ * ### Error rate
+ * **Example:** 5xx responses in the last ten minutes
+ * ```typescript
+ * const api = yield* Modal.ReadServer(Api);
+ * const stats = yield* api.stats({ since: new Date(Date.now() - 600_000) });
+ * ```
+ *
+ * ### Recent requests
+ * **Example:** The last 20 requests
+ * ```typescript
+ * const recent = yield* api.requests({ limit: 20 });
+ * ```
+ *
+ * @binding
+ * @product Server
+ */
+export interface ReadServer extends Binding.Service<
+  ReadServer,
+  "Modal.ReadServer",
+  (server: Server) => Effect.Effect<ServerReader>
+> {}
+
+export const ReadServer = Binding.Service<ReadServer>("Modal.ReadServer");

package/src/ReadServerHttp.ts

@@ -0,0 +1,101 @@
+import * as flash from "@distilled.cloud/modal/flash";
+import * as server from "@distilled.cloud/modal/server";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeFunctionBinding } from "./FunctionTarget.ts";
+import { operations, timestampOf } from "./internal.ts";
+import { ReadServer, type ServerReader } from "./ReadServer.ts";
+import type { Server } from "./Server.ts";
+
+/** The operations the client calls, resolved by `ModalBindings.withCredentials`. */
+const ReadServerOps = operations({
+  stats: server.serverGetTimeRangeStats,
+  requests: server.fetchServerRequest,
+  requestCount: server.serverCountRequests,
+  metrics: server.serverGetMetrics,
+  containers: flash.listFlashContainer,
+});
+
+export type ReadServerOps = Effect.Success<typeof ReadServerOps>;
+
+/**
+ * {@link ReadServer} over Modal's API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `viewer` role on the server's environment.
+ *
+ * @layer
+ * @product Server
+ * @provides Modal.ReadServer
+ */
+export const ReadServerHttp = Layer.effect(
+  ReadServer,
+  makeFunctionBinding({
+    tag: "Modal.ReadServer",
+    operations: ReadServerOps,
+    role: "viewer",
+    make: ({ functionId }, ops, _server: Server) =>
+      Effect.succeed({
+        stats: (range) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.stats({
+              functionId: id,
+              since: timestampOf(range.since),
+              until: timestampOf(range.until ?? Date.now()),
+              containerId: range.containerId,
+            }),
+          ),
+        requests: (query) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.requests(
+              "limit" in query
+                ? { functionId: id, tail: { count: query.limit } }
+                : {
+                    functionId: id,
+                    range: {
+                      since: timestampOf(query.since),
+                      until: timestampOf(query.until ?? Date.now()),
+                    },
+                  },
+            ),
+          ).pipe(
+            Effect.map((response) =>
+              (response.requests ?? []).map((request) => ({
+                route: request.route,
+                timestamp: request.timestamp,
+                containerId: request.containerId,
+                durationSeconds: request.durationSeconds,
+                status: request.status,
+              })),
+            ),
+          ),
+        requestCount: (range) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.requestCount({
+              functionId: id,
+              since: timestampOf(range.since),
+              until: timestampOf(range.until ?? Date.now()),
+              bucketSecs: range.bucketSecs,
+            }),
+          ),
+        metrics: (range) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.metrics({
+              functionId: id,
+              since: timestampOf(range.since),
+              until: timestampOf(range.until ?? Date.now()),
+              bucketSecs: range.bucketSecs,
+              groups: range.groups ? [...range.groups] : undefined,
+            }),
+          ),
+        containers: () =>
+          Effect.flatMap(functionId, (id) => ops.containers({ functionId: id })).pipe(
+            Effect.map((response) =>
+              (response.containers ?? []).map((container) => ({
+                containerId: container.taskId ?? "",
+                host: container.host,
+                port: container.port,
+              })),
+            ),
+          ),
+      } satisfies ServerReader),
+  }),
+);

package/src/ReadVolume.ts

@@ -0,0 +1,45 @@
+import * as Binding from "alchemy/Binding";
+import type * as Effect from "effect/Effect";
+import type { Volume } from "./Volume.ts";
+import type { ReadVolumeClient } from "./VolumeClient.ts";
+
+export type { ReadVolumeClient } from "./VolumeClient.ts";
+
+/**
+ * Read a Modal Volume's files from any runtime (a Worker, a Lambda, a Modal sandbox) without mounting it: list directories and read files over Modal's volume API.
+ *
+ * ### Bind a volume
+ * **Example:** Read from a Cloudflare Worker
+ * ```typescript
+ * import * as Cloudflare from "@alchemy.run/cloudflare";
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/http/HttpServerResponse";
+ * import { Workspace } from "./Storage.ts";
+ *
+ * export default class Api extends Cloudflare.Worker<Api>()(
+ *   "Api",
+ *   { main: import.meta.url },
+ *   Effect.gen(function* () {
+ *     const volume = yield* Modal.ReadVolume(Workspace);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const files = yield* volume.listFiles("/");
+ *         const readme = yield* volume.readFileString("/README.md");
+ *         return yield* HttpServerResponse.json({ files, readme });
+ *       }).pipe(Effect.orDie),
+ *     };
+ *   }).pipe(Effect.provide(Modal.ReadVolumeHttp)),
+ * ) {}
+ * ```
+ *
+ * @binding
+ * @product Volume
+ */
+export interface ReadVolume extends Binding.Service<
+  ReadVolume,
+  "Modal.ReadVolume",
+  (volume: Volume) => Effect.Effect<ReadVolumeClient>
+> {}
+
+export const ReadVolume = Binding.Service<ReadVolume>("Modal.ReadVolume");

package/src/ReadVolumeHttp.ts

@@ -0,0 +1,28 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeModalBinding } from "./BindingHttp.ts";
+import { ReadVolume } from "./ReadVolume.ts";
+import type { Volume } from "./Volume.ts";
+import { makeReadVolumeClient } from "./VolumeClient.ts";
+import { VolumeFileOps } from "./VolumeFiles.ts";
+
+/**
+ * {@link ReadVolume} over Modal's volume API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `viewer` role on the volume's environment.
+ *
+ * @layer
+ * @product Volume
+ * @provides Modal.ReadVolume
+ */
+export const ReadVolumeHttp = Layer.effect(
+  ReadVolume,
+  makeModalBinding({
+    tag: "Modal.ReadVolume",
+    operations: VolumeFileOps,
+    role: "viewer",
+    make: Effect.fn(function* (volume: Volume, ops) {
+      const volumeId = yield* volume.volumeId;
+      return makeReadVolumeClient(volumeId, ops);
+    }),
+  }),
+);

package/src/ReadWriteDict.ts

@@ -0,0 +1,44 @@
+import * as Binding from "alchemy/Binding";
+import type * as Effect from "effect/Effect";
+import type { Dict } from "./Dict.ts";
+import type { ReadWriteDictClient } from "./DictClient.ts";
+
+export type { ReadWriteDictClient } from "./DictClient.ts";
+
+/**
+ * Read and write a Modal Dict from any runtime. Keys and values are JSON.
+ *
+ * ### Bind a dict
+ * **Example:** From a Cloudflare Worker
+ * ```typescript
+ * import * as Cloudflare from "@alchemy.run/cloudflare";
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/http/HttpServerResponse";
+ * import { Results } from "./Storage.ts";
+ *
+ * export default class Api extends Cloudflare.Worker<Api>()(
+ *   "Api",
+ *   { main: import.meta.url },
+ *   Effect.gen(function* () {
+ *     const dict = yield* Modal.ReadWriteDict(Results);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         yield* dict.put("hits", ((yield* dict.get<number>("hits")) ?? 0) + 1);
+ *         return yield* HttpServerResponse.json({ hits: yield* dict.get("hits") });
+ *       }).pipe(Effect.orDie),
+ *     };
+ *   }).pipe(Effect.provide(Modal.ReadWriteDictHttp)),
+ * ) {}
+ * ```
+ *
+ * @binding
+ * @product Dict
+ */
+export interface ReadWriteDict extends Binding.Service<
+  ReadWriteDict,
+  "Modal.ReadWriteDict",
+  (dict: Dict) => Effect.Effect<ReadWriteDictClient>
+> {}
+
+export const ReadWriteDict = Binding.Service<ReadWriteDict>("Modal.ReadWriteDict");

package/src/ReadWriteDictHttp.ts

@@ -0,0 +1,27 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeModalBinding } from "./BindingHttp.ts";
+import type { Dict } from "./Dict.ts";
+import { DictOps, makeReadWriteDictClient } from "./DictClient.ts";
+import { ReadWriteDict } from "./ReadWriteDict.ts";
+
+/**
+ * {@link ReadWriteDict} over Modal's API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `contributor` role on the dict's environment.
+ *
+ * @layer
+ * @product Dict
+ * @provides Modal.ReadWriteDict
+ */
+export const ReadWriteDictHttp = Layer.effect(
+  ReadWriteDict,
+  makeModalBinding({
+    tag: "Modal.ReadWriteDict",
+    operations: DictOps,
+    role: "contributor",
+    make: Effect.fn(function* (dict: Dict, ops) {
+      const dictId = yield* dict.dictId;
+      return makeReadWriteDictClient(dictId, ops);
+    }),
+  }),
+);