effect-cf 0.25.2 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # effect-cf
 
+## 0.26.0
+
+### Minor Changes
+
+- [#97](https://github.com/danieljvdm/effect-cf/pull/97) [`b7bc27e`](https://github.com/danieljvdm/effect-cf/commit/b7bc27eb03130578e13a593d9efc45bb8d3d5269) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add first-class Cloudflare Artifacts binding support through the new `Artifacts` module. Namespace lifecycle operations, repository token and fork operations, and Git commit-history, commit, and tree reads are available as typed Effects with validated bindings, structured options and results, tracing spans, and Cloudflare error identifiers.
+
+- [#98](https://github.com/danieljvdm/effect-cf/pull/98) [`5b9a05e`](https://github.com/danieljvdm/effect-cf/commit/5b9a05e976f653eb9a9d2003fdd57379d906c871) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add Effect-native Cloudflare Computer workspaces, scoped execution handles, a Durable Object host mixin, and session-isolated Artifacts clients.
+
+- [#94](https://github.com/danieljvdm/effect-cf/pull/94) [`8a7ec63`](https://github.com/danieljvdm/effect-cf/commit/8a7ec630ecb2ddc2b55348cb6c701f5a9ce42d3b) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add the `WebTransport` module: a truthful WebTransport/HTTP-3 boundary for Workers. `inboundTransport` decodes the HTTP protocol metadata Cloudflare's edge attaches to requests (`httpProtocol`, `clientQuicRtt`, `clientTcpRtt`) with `isHttp3` on top; `capabilities` feature-detects what the runtime provides; and `inboundSessionsUnsupported` is an explicit typed boundary for the inbound WebTransport session API that workerd does not have (cloudflare/workerd#6451).
+
+## 0.25.3
+
+### Patch Changes
+
+- [#92](https://github.com/danieljvdm/effect-cf/pull/92) [`f174800`](https://github.com/danieljvdm/effect-cf/commit/f1748004e463d4e54c22e7c77fdea68ff8de7f82) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Flush configured OTLP telemetry after Durable Object alarm handlers, including failed alarms, so buffered telemetry is exported consistently with fetch and native RPC handlers.
+
 ## 0.25.2
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # effect-cf
 
-Effect-native Cloudflare primitives for Workers, Durable Objects, Containers, bindings, Cache, KV, D1, Queues, Email, Analytics Engine, Workflows, and Durable Object storage.
+Effect-native Cloudflare primitives for Workers, Durable Objects, Containers, bindings, Cache, KV, D1, R2, Artifacts, Queues, Email, Analytics Engine, Workflows, and Durable Object storage.
 
 ## Install
 
@@ -18,6 +18,21 @@ pnpm add effect-cf "effect@^4.0.0-beta.105"
 npm install effect-cf "effect@^4.0.0-beta.105"
 ```
 
+The Computer workspace integration is an optional peer. Install it only in
+applications that import `ComputerWorkspace`, `ComputerArtifacts`, or
+`effect-cf/computer-workspace-host`:
+
+```bash
+bun add "@cloudflare/computer@^0.2.0"
+```
+
+Workspace Git operations additionally require `@platformatic/vfs`,
+`@cloudflare/computer/git`'s own optional peer:
+
+```bash
+bun add "@platformatic/vfs@^0.4.0"
+```
+
 ## Goal
 
 Cloudflare APIs return promises and expose platform-specific bindings. `effect-cf` wraps those boundaries as `Context`, `Layer`, and `Effect` values so application code stays inside one managed Effect runtime.
@@ -35,6 +50,10 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `Kv` - typed KV namespace helper
 - `D1` - typed D1 database binding helper with an `@effect/sql-d1` backed SQL layer
 - `R2` - typed R2 bucket binding helper with Effect-wrapped object and multipart operations
+- `Artifacts` - typed Cloudflare Artifacts namespace and repository helpers, including repository lifecycle, tokens, and Git object reads
+- `ComputerWorkspace` - scoped Effect wrappers for the complete Cloudflare Computer filesystem, Git, runtime, Assets, Artifacts, and Think-compatible client surfaces
+- `ComputerArtifacts` - session-isolated Artifacts repositories backed by `@cloudflare/computer/artifacts`
+- `effect-cf/computer-workspace-host` - optional Durable Object host mixin, worker-shell backend wiring, and `WorkspaceServiceProxy`
 - `Hyperdrive` - typed Hyperdrive binding helper for connection strings and optional Postgres SQL integration
 - `Images` - typed Cloudflare Images binding helper with transformation APIs and optional hosted image operations
 - `Email` - typed Cloudflare Email Service binding helper for `send_email` bindings, with limit validation and typed error codes
@@ -42,6 +61,7 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `Queue` - typed Queue producer/consumer tags plus client and error types
 - `Workflow` - typed Workflow entrypoints, steps, starter clients, and instance types
 - `Rpc` - Cloudflare RPC type helpers and scoped disposal utilities
+- `WebTransport` - truthful WebTransport/HTTP-3 boundary: typed runtime capabilities and decoded inbound protocol metadata
 - `WorkerConfig` - Effect `Config` helpers backed by Cloudflare `env`
 - `effect-cf/vitest` - Effect-native runners and scoped test helpers for Cloudflare's Vitest Workers pool
 
@@ -399,6 +419,166 @@ export const readArtifact = (key: string) =>
 
 Use `createMultipartUpload(...)` or `resumeMultipartUpload(...)` for large objects; returned upload handles wrap `uploadPart`, `complete`, and `abort` in Effect.
 
+## Artifacts Example
+
+Artifacts tags expose every namespace and repository-handle binding operation as an Effect. Configure the binding under Wrangler's `artifacts` field:
+
+```jsonc
+{
+  "artifacts": [
+    {
+      "binding": "ARTIFACTS",
+      "namespace": "default",
+      // Optional in local development:
+      "remote": true,
+    },
+  ],
+}
+```
+
+```ts
+import { Effect } from "effect";
+import { Artifacts } from "effect-cf";
+
+class Repositories extends Artifacts.Tag<Repositories>()("Repositories") {}
+
+export const RepositoriesLayer = Repositories.layer({ binding: "ARTIFACTS" });
+
+export const createWorkspace = Effect.gen(function* () {
+  const artifacts = yield* Repositories;
+  const created = yield* artifacts.create("agent-workspace", {
+    description: "Versioned agent workspace",
+    setDefaultBranch: "main",
+  });
+  const repo = yield* artifacts.get(created.name);
+  const readToken = yield* repo.createToken("read", 3600);
+
+  return {
+    remote: created.remote,
+    token: readToken.plaintext,
+    history: yield* repo.log({ ref: "main", limit: 10 }),
+  };
+});
+```
+
+`create`, `import`, and `fork` return an initial plaintext token. Treat returned tokens as secrets and avoid logging or persisting them unnecessarily.
+
+## Computer Workspace Example
+
+`ComputerWorkspace` exposes the complete `@cloudflare/computer`
+`WorkspaceClient` as Effects. The workspace client and every runtime execution
+handle are owned by an Effect `Scope`, so RPC stubs are disposed when their
+scope closes. The host mixin is a separate optional-dependency entrypoint:
+
+```ts
+import shellCurl from "@cloudflare/computer/shell/curl";
+import { Effect, Schema as S } from "effect";
+import { ComputerWorkspace, DurableObjectDefinition } from "effect-cf";
+import { withComputerWorkspace, WorkspaceServiceProxy } from "effect-cf/computer-workspace-host";
+
+export { WorkspaceServiceProxy };
+
+const ResearchWorkspace = DurableObjectDefinition.make("ResearchWorkspace", {
+  inspect: DurableObjectDefinition.method({ success: S.String }),
+});
+
+const ResearchWorkspaceLive = ResearchWorkspace.make(ComputerWorkspace.ComputerWorkspace.layer, {
+  rpc: {
+    inspect: () =>
+      Effect.gen(function* () {
+        const workspace = yield* ComputerWorkspace.ComputerWorkspace;
+
+        // Keep reads bounded when returning their contents over RPC.
+        const readme = yield* workspace.readFile("/repo/README.md", {
+          byteLength: 256 * 1024,
+        });
+        const commits = yield* workspace.git.log({ maxCount: 20 });
+        const run = yield* workspace.execCollect("git status --short", {
+          cwd: "/repo",
+          timeoutMillis: 30_000,
+        });
+
+        return `${commits.length}:${run.exitCode}:${readme.length}`;
+      }),
+  },
+});
+
+const HostedResearchWorkspace = withComputerWorkspace(ResearchWorkspaceLive, (_, state, env) => ({
+  storage: state.storage,
+  sessionId: state.id.toString(),
+  gitIdentity: { name: "Research Agent", email: "agent@example.test" },
+  artifacts: { binding: env.ARTIFACTS },
+  shell: {
+    loader: env.WORKER_LOADER,
+    hostBinding: "RESEARCH_WORKSPACE",
+    hostId: state.id.toString(),
+    executionContext: state,
+    commands: [shellCurl],
+    egress: { mode: "none" },
+  },
+}));
+
+export class ResearchWorkspaceDurableObject extends HostedResearchWorkspace {}
+```
+
+Serialize checkout mutations such as `clone`, `fetch`, and reset/checkout
+sequences with an Effect `Semaphore` when several RPC methods can update the
+same working tree concurrently. Reads can remain concurrent.
+
+The corresponding Wrangler configuration needs SQLite-backed Durable Object
+storage. Worker-shell execution additionally requires the `experimental` flag,
+a Worker Loader binding, the loopback namespace binding named by `hostBinding`,
+and the exact `WorkspaceServiceProxy` export shown above:
+
+```jsonc
+{
+  "compatibility_flags": ["nodejs_compat", "experimental"],
+  "worker_loaders": [{ "binding": "WORKER_LOADER" }],
+  "artifacts": [{ "binding": "ARTIFACTS", "namespace": "default" }],
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "RESEARCH_WORKSPACE",
+        "class_name": "ResearchWorkspaceDurableObject",
+      },
+    ],
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": ["ResearchWorkspaceDurableObject"],
+    },
+  ],
+}
+```
+
+Omit `shell` and the Worker Loader configuration when only the SQLite
+filesystem and Git client are needed. Supplying `artifacts` also installs the
+session-scoped client at `workspace.artifacts` and makes the in-shell
+`artifacts` command use the same upstream repository-prefixing convention.
+
+Workers can use that session isolation without a Durable Object or workspace:
+
+```ts
+import { Effect } from "effect";
+import { Artifacts, ComputerArtifacts } from "effect-cf";
+
+export const createSessionRepo = (binding: Artifacts.ArtifactsBinding, sessionId: string) =>
+  Effect.gen(function* () {
+    const artifacts = yield* ComputerArtifacts.makeClient(binding, sessionId);
+    const created = yield* artifacts.create("build-cache", {
+      description: "CI artifacts",
+    });
+    const token = yield* artifacts.createToken("build-cache", "read", 3600);
+
+    return { remote: created.remote, token: token.plaintext };
+  });
+```
+
+Repository prefixing, list filtering, and the argv API are delegated directly
+to `@cloudflare/computer/artifacts`, keeping this API and the in-shell command
+in agreement.
+
 ## Hyperdrive Example
 
 Hyperdrive tags expose the binding `connectionString` directly on the yielded service.
@@ -698,6 +878,36 @@ if (Worker.isWebSocketUpgrade(request)) {
 
 Use `DurableObjectRpcWebSocket.layer(...)` for Effect RPC-over-WebSocket transports. It owns protocol parsing and RPC client bookkeeping; use `DurableWebSocket` for general application sockets, rooms, presence, and broadcast flows.
 
+## WebTransport and HTTP/3
+
+Cloudflare Workers cannot accept inbound WebTransport sessions today: workerd contains no QUIC/HTTP-3 stack, there is no `WebSocketPair`-style session API, and the maintainers state the feature "is not currently on our priority list" ([cloudflare/workerd#6451](https://github.com/cloudflare/workerd/issues/6451), [discussion #6454](https://github.com/cloudflare/workerd/discussions/6454)). Inbound HTTP/3 is a zone-level setting — the edge terminates QUIC and the Worker still receives an ordinary `fetch` Request. Workers and Durable Objects can accept inbound WebSocket connections; Durable Objects additionally support the hibernation WebSocket API.
+
+The `WebTransport` module gives that boundary a typed shape rather than pretending otherwise:
+
+```ts
+import { Effect, Option } from "effect";
+import { WebTransport } from "effect-cf";
+
+const fetch = Effect.fn("fetch")(function* (request: Request) {
+  // Decoded metadata about the browser→edge hop (HTTP/3 does not reach you).
+  const transport = WebTransport.inboundTransport(request);
+  const viaHttp3 = Option.match(transport, {
+    onNone: () => false,
+    onSome: WebTransport.isHttp3,
+  });
+
+  // Feature-detected runtime capabilities: { inboundSessions: false, ... }.
+  const capabilities = yield* WebTransport.capabilities;
+
+  // Explicit typed boundary where a future inbound session API would slot in.
+  // yield* WebTransport.inboundSessionsUnsupported;
+
+  return Response.json({ viaHttp3, capabilities });
+});
+```
+
+For clients that prefer WebTransport where it exists and fall back to Cloudflare-supported WebSockets, see the companion [`effect-webtransport`](../effect-webtransport) package's `Fallback` module — `examples/todo-rpc-ws` wires it up end to end.
+
 ## License
 
 MIT

package/dist/Artifacts-DcoXcRP5.d.mts

@@ -0,0 +1,231 @@
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
+import { Context, Effect, Layer } from "effect";
+declare namespace Artifacts_d_exports {
+  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+}
+/** Artifacts operation represented by {@link ArtifactsOperationError}. */
+type ArtifactsOperation = "createClient" | "create" | "get" | "import" | "list" | "delete" | "createToken" | "listTokens" | "getToken" | "revokeToken" | "fork" | "log" | "readCommit" | "readTree" | "cli";
+/** Documented string error codes returned by Cloudflare Artifacts. */
+declare const artifactsErrorCodes: readonly ["ALREADY_EXISTS", "NOT_FOUND", "IMPORT_IN_PROGRESS", "FORK_IN_PROGRESS", "INVALID_INPUT", "INVALID_REPO_NAME", "INVALID_TTL", "INVALID_URL", "REMOTE_AUTH_REQUIRED", "UPSTREAM_UNAVAILABLE", "MEMORY_LIMIT", "INTERNAL_ERROR"];
+/** Documented numeric error codes returned by Cloudflare Artifacts. */
+declare const artifactsErrorNumericCodes: {
+  readonly ALREADY_EXISTS: 10201;
+  readonly NOT_FOUND: 10200;
+  readonly IMPORT_IN_PROGRESS: 10302;
+  readonly FORK_IN_PROGRESS: 10303;
+  readonly INVALID_INPUT: 10100;
+  readonly INVALID_REPO_NAME: 10101;
+  readonly INVALID_TTL: 10103;
+  readonly INVALID_URL: 10104;
+  readonly REMOTE_AUTH_REQUIRED: 10106;
+  readonly UPSTREAM_UNAVAILABLE: 10401;
+  readonly MEMORY_LIMIT: 10402;
+  readonly INTERNAL_ERROR: 10400;
+};
+/** A documented Cloudflare Artifacts string error code. */
+type ArtifactsErrorCode = CloudflareArtifactsErrorCode;
+declare const ArtifactsOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ArtifactsOperationError";
+} & Readonly<A>;
+/** Error raised when a Cloudflare Artifacts operation fails. */
+declare class ArtifactsOperationError extends ArtifactsOperationError_base<{
+  readonly binding: string;
+  readonly operation: ArtifactsOperation;
+  readonly cause: unknown;
+  /** Cloudflare string error code, when retained by the runtime. */
+  readonly code?: ArtifactsErrorCode | (string & {});
+  /** Cloudflare REST-compatible numeric error code, when retained by the runtime. */
+  readonly numericCode?: number;
+}> {
+  get message(): string;
+}
+/** Typed Cloudflare Artifacts binding definition. */
+interface ArtifactsDefinition {
+  /** Binding name from an `artifacts` entry in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+/** Repository name containing alphanumeric characters, dots, hyphens, or underscores. */
+type RepoName = string;
+/** Cursor used by repository list pagination. */
+type Cursor = string;
+/** Scope granted to a repository token. */
+type ArtifactsTokenScope = "read" | "write";
+/** Lifecycle state of a repository token. */
+type ArtifactsTokenState = "active" | "expired" | "revoked";
+/** Lifecycle state included with repositories returned by `list()`. */
+type ArtifactsRepoStatus = "ready" | "importing" | "forking";
+/** Stable repository metadata returned by Cloudflare Artifacts. */
+type ArtifactsRepoInfo = CloudflareArtifactsRepoInfo;
+/** Result of creating, importing, or forking a repository. */
+type ArtifactsCreateRepoResult = Readonly<CloudflareArtifactsCreateRepoResult>;
+/** Repository metadata returned by `list()`. */
+interface ArtifactsRepoListEntry extends ArtifactsRepoInfo {
+  readonly status: ArtifactsRepoStatus;
+}
+/** Cursor-paginated repository list result. */
+interface ArtifactsRepoListResult {
+  readonly repos: ReadonlyArray<ArtifactsRepoListEntry>;
+  readonly total: number;
+  readonly cursor?: Cursor;
+}
+/** Result of creating a repository token. */
+type ArtifactsCreateTokenResult = CloudflareArtifactsCreateTokenResult;
+/** Repository token metadata, excluding its plaintext secret. */
+type ArtifactsTokenInfo = CloudflareArtifactsTokenInfo;
+/** Repository token list result. */
+type ArtifactsTokenListResult = CloudflareArtifactsTokenListResult;
+/**
+ * Commit history returned by `log()`.
+ *
+ * Cloudflare currently documents this generated type by name but does not
+ * publish its fields in the binding reference or Workers type declarations.
+ */
+interface ArtifactsLogResult {
+  readonly [field: string]: unknown;
+}
+/**
+ * Parsed Git commit returned by `readCommit()`.
+ *
+ * Cloudflare currently documents this generated type by name but does not
+ * publish its fields in the binding reference or Workers type declarations.
+ */
+interface ArtifactsCommit {
+  readonly [field: string]: unknown;
+}
+/**
+ * Parsed Git tree returned by `readTree()`.
+ *
+ * Cloudflare currently documents this generated type by name but does not
+ * publish its fields in the binding reference or Workers type declarations.
+ */
+interface ArtifactsTree {
+  readonly [field: string]: unknown;
+}
+/** Options for `Artifacts.create()`. */
+interface ArtifactsCreateOptions {
+  /** Prevent pushes to the repository. */
+  readonly readOnly?: boolean;
+  readonly description?: string;
+  /** Initial default branch name. */
+  readonly setDefaultBranch?: string;
+}
+/** Options for cursor-paginating `Artifacts.list()`. */
+interface ArtifactsListOptions {
+  /** Page size from 1 through 200. Defaults to 50. */
+  readonly limit?: number;
+  /** Cursor returned by a previous list result. */
+  readonly cursor?: Cursor;
+}
+/** External Git source used by `Artifacts.import()`. */
+interface ArtifactsImportSource {
+  /** Full HTTPS URL of the Git repository. */
+  readonly url: string;
+  /** Source branch. Defaults to the remote's default branch. */
+  readonly branch?: string;
+  /** Shallow clone depth. */
+  readonly depth?: number;
+}
+/** Options for the target of `Artifacts.import()`. */
+interface ArtifactsImportTargetOptions {
+  readonly description?: string;
+  readonly readOnly?: boolean;
+}
+/** Target repository used by `Artifacts.import()`. */
+interface ArtifactsImportTarget {
+  readonly name: RepoName;
+  readonly opts?: ArtifactsImportTargetOptions;
+}
+/** Parameters for `Artifacts.import()`. */
+interface ArtifactsImportParams {
+  readonly source: ArtifactsImportSource;
+  readonly target: ArtifactsImportTarget;
+}
+/** Options for `ArtifactsRepoClient.fork()`. */
+interface ArtifactsForkOptions {
+  readonly description?: string;
+  readonly readOnly?: boolean;
+  /** Only copy the default branch. Defaults to `true`. */
+  readonly defaultBranchOnly?: boolean;
+}
+/** Options for `ArtifactsRepoClient.log()`. */
+interface ArtifactsLogOptions {
+  /** Branch, tag, or commit hash. */
+  readonly ref?: string;
+  readonly limit?: number;
+  readonly offset?: number;
+}
+/** Runtime repository handle, including methods absent from current shipped Workers types. */
+interface ArtifactsRepoBinding extends ArtifactsRepoInfo {
+  /**
+   * Create a Git token for the repository.
+   *
+   * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
+   * 86,400, and must be between 60 and 31,536,000.
+   */
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Promise<ArtifactsCreateTokenResult>;
+  readonly listTokens: () => Promise<ArtifactsTokenListResult>;
+  readonly revokeToken: (tokenOrId: string) => Promise<boolean>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult>;
+  readonly log: (options?: ArtifactsLogOptions) => Promise<ArtifactsLogResult>;
+  readonly readCommit: (hash: string) => Promise<ArtifactsCommit>;
+  readonly readTree: (hash: string) => Promise<ArtifactsTree>;
+}
+/** Cloudflare Artifacts namespace binding. */
+interface ArtifactsBinding {
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Promise<ArtifactsCreateRepoResult>;
+  readonly get: (name: RepoName) => Promise<ArtifactsRepoBinding>;
+  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult>;
+  readonly list: (options?: ArtifactsListOptions) => Promise<ArtifactsRepoListResult>;
+  readonly delete: (name: RepoName) => Promise<boolean>;
+}
+/** Effect wrapper around a repository handle returned by `Artifacts.get()`. */
+interface ArtifactsRepoClient extends ArtifactsRepoInfo {
+  /**
+   * Create a Git token for the repository.
+   *
+   * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
+   * 86,400, and must be between 60 and 31,536,000.
+   */
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult, ArtifactsOperationError>;
+  readonly listTokens: Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
+  readonly revokeToken: (tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly log: (options?: ArtifactsLogOptions) => Effect.Effect<ArtifactsLogResult, ArtifactsOperationError>;
+  readonly readCommit: (hash: string) => Effect.Effect<ArtifactsCommit, ArtifactsOperationError>;
+  readonly readTree: (hash: string) => Effect.Effect<ArtifactsTree, ArtifactsOperationError>;
+  readonly raw: ArtifactsRepoBinding;
+}
+/** Effect wrapper around a Cloudflare Artifacts namespace binding. */
+interface ArtifactsClient {
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoClient, ArtifactsOperationError>;
+  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly list: (options?: ArtifactsListOptions) => Effect.Effect<ArtifactsRepoListResult, ArtifactsOperationError>;
+  readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly rawUnsafe: Effect.Effect<ArtifactsBinding>;
+  readonly definition: ArtifactsDefinition;
+}
+declare const ArtifactsServiceTypeId: unique symbol;
+/** Nominal service marker for Artifacts services created with {@link make}. */
+interface ArtifactsService<Id extends string> {
+  readonly [ArtifactsServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, ArtifactsClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+/** Tests whether a value exposes the complete documented Artifacts repo handle API. */
+declare const isArtifactsRepoBinding: (value: unknown) => value is ArtifactsRepoBinding;
+/** Tests whether a value exposes the complete documented Artifacts namespace API. */
+declare const isArtifactsBinding: (value: unknown) => value is ArtifactsBinding;
+declare const makeClient: (definition: ArtifactsDefinition) => (artifacts: ArtifactsBinding) => ArtifactsClient;
+declare const layer: <Self>(tag: Context.Service<Self, ArtifactsClient>, definition: ArtifactsDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<ArtifactsService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { ArtifactsOperationError as a, ArtifactsTokenListResult as c, ArtifactsCreateTokenResult as i, Artifacts_d_exports as l, ArtifactsCreateOptions as n, ArtifactsRepoInfo as o, ArtifactsCreateRepoResult as r, ArtifactsTokenInfo as s, ArtifactsBinding as t, RepoName as u };

package/dist/ComputerWorkspaceHost.d.mts

@@ -0,0 +1,71 @@
+import { t as ArtifactsBinding } from "./Artifacts-DcoXcRP5.mjs";
+import { GitClientFactory } from "@cloudflare/computer/git";
+import { DurableObjectStorageLike, SyncRetryIntent, SyncRetryOptions, SyncRetryScheduler, WithWorkspaceCtor, WorkspaceAttributeValue, WorkspaceAttributes, WorkspaceObserver, WorkspaceOptions, WorkspaceRegisteredBackend, WorkspaceRetryPendingSyncResult, WorkspaceServiceProxy, WorkspaceSpan } from "@cloudflare/computer";
+import { ShellModuleGroup, WorkerShellBackendOptions, WorkerShellLoader, WorkspaceEgressPolicy } from "@cloudflare/computer/backends/worker-shell";
+//#region src/ComputerWorkspaceHost.d.ts
+/** The value of a `worker_loaders` binding. */
+type DynamicWorkerLoader = WorkerShellLoader;
+/** Default author and committer identity for workspace Git operations. */
+interface ComputerWorkspaceGitIdentity {
+  readonly name: string;
+  readonly email: string;
+}
+/** Session-scoped Artifacts configuration passed through to `Workspace`. */
+interface ComputerWorkspaceArtifactsOptions {
+  readonly binding: ArtifactsBinding;
+  /**
+   * Session prefix for repository names. When omitted, `sessionId` from the
+   * enclosing host configuration is used.
+   */
+  readonly sessionId?: string;
+}
+/**
+ * Worker-shell backend options with the loopback workspace wiring named in
+ * Durable Object terms.
+ */
+interface ComputerWorkspaceShellOptions extends Omit<WorkerShellBackendOptions, "source" | "loader" | "workspace" | "ctx" | "egress"> {
+  readonly loader: DynamicWorkerLoader;
+  /** Durable Object namespace binding that points back to the wrapped class. */
+  readonly hostBinding: string;
+  /** Current Durable Object id, normally `ctx.id.toString()`. */
+  readonly hostId: string;
+  /** Current Durable Object execution context, normally `ctx`. */
+  readonly executionContext: unknown;
+  /** Dynamic Worker egress policy. Defaults to `{ mode: "none" }`. */
+  readonly egress?: WorkspaceEgressPolicy;
+}
+/** Configuration accepted by {@link withComputerWorkspace}. */
+interface ComputerWorkspaceHostConfig {
+  /** Native SQLite-backed Durable Object storage (`ctx.storage`). */
+  readonly storage: globalThis.DurableObjectStorage | DurableObjectStorageLike;
+  /** Stable workspace id used by mounts and as the default Artifacts session. */
+  readonly sessionId?: string;
+  readonly gitIdentity?: ComputerWorkspaceGitIdentity;
+  /** Override the default `createGitClient()` factory. */
+  readonly git?: GitClientFactory;
+  /** Additional container, Worker JavaScript, shell, or custom backends. */
+  readonly backends?: ReadonlyArray<WorkspaceRegisteredBackend>;
+  /** Convenience wiring for one Worker Shell backend. */
+  readonly shell?: ComputerWorkspaceShellOptions;
+  readonly mounts?: WorkspaceOptions["mounts"];
+  readonly observer?: WorkspaceOptions["observer"];
+  readonly retryScheduler?: WorkspaceOptions["retryScheduler"];
+  readonly retry?: WorkspaceOptions["retry"];
+  readonly assets?: WorkspaceOptions["assets"];
+  readonly artifacts?: ComputerWorkspaceArtifactsOptions;
+  readonly now?: WorkspaceOptions["now"];
+  readonly useThink?: WorkspaceOptions["useThink"];
+}
+type DurableObjectConstructor = new (...args: Array<any>) => object;
+/**
+ * Wraps a Durable Object class with one SQLite-backed Cloudflare Computer
+ * workspace and registers that local workspace for {@link ComputerWorkspace}
+ * to acquire through its Effect layer.
+ *
+ * The class must use a `new_sqlite_classes` migration. If `shell` is present,
+ * its Worker must also configure a `worker_loaders` binding, enable the
+ * `experimental` compatibility flag, and export `WorkspaceServiceProxy`.
+ */
+declare const withComputerWorkspace: <TBase extends DurableObjectConstructor>(Base: TBase, config: (self: InstanceType<TBase>, state: globalThis.DurableObjectState, env: ConstructorParameters<TBase>[1]) => ComputerWorkspaceHostConfig) => WithWorkspaceCtor<TBase>;
+//#endregion
+export { ComputerWorkspaceArtifactsOptions, ComputerWorkspaceGitIdentity, ComputerWorkspaceHostConfig, ComputerWorkspaceShellOptions, DynamicWorkerLoader, type ShellModuleGroup, type SyncRetryIntent, type SyncRetryOptions, type SyncRetryScheduler, type WorkspaceAttributeValue, type WorkspaceAttributes, type WorkspaceEgressPolicy, type WorkspaceObserver, type WorkspaceRetryPendingSyncResult, WorkspaceServiceProxy, type WorkspaceSpan, withComputerWorkspace };

package/dist/ComputerWorkspaceHost.mjs

@@ -0,0 +1,74 @@
+import { n as register } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
+import { createGitClient } from "@cloudflare/computer/git";
+import { WorkspaceServiceProxy, withWorkspace } from "@cloudflare/computer";
+import { WorkerShellBackend } from "@cloudflare/computer/backends/worker-shell";
+//#region src/ComputerWorkspaceHost.ts
+const toWorkspaceOptions = (config) => {
+	const backends = [...config.backends ?? []];
+	if (config.shell !== void 0) {
+		const { egress, executionContext, hostBinding, hostId, loader, ...shellOptions } = config.shell;
+		backends.push(new WorkerShellBackend({
+			...shellOptions,
+			loader,
+			workspace: {
+				binding: hostBinding,
+				id: hostId
+			},
+			ctx: executionContext,
+			egress: egress ?? { mode: "none" }
+		}));
+	}
+	return {
+		storage: config.storage,
+		git: config.git ?? createGitClient(),
+		...config.gitIdentity === void 0 ? {} : { defaultGitIdentity: config.gitIdentity },
+		...backends.length === 0 ? {} : { backends },
+		...config.sessionId === void 0 ? {} : { sessionId: config.sessionId },
+		...config.mounts === void 0 ? {} : { mounts: config.mounts },
+		...config.observer === void 0 ? {} : { observer: config.observer },
+		...config.retryScheduler === void 0 ? {} : { retryScheduler: config.retryScheduler },
+		...config.retry === void 0 ? {} : { retry: config.retry },
+		...config.assets === void 0 ? {} : { assets: config.assets },
+		...config.artifacts === void 0 ? {} : { artifacts: {
+			binding: config.artifacts.binding,
+			...config.artifacts.sessionId === void 0 ? {} : { sessionId: config.artifacts.sessionId }
+		} },
+		...config.now === void 0 ? {} : { now: config.now },
+		...config.useThink === void 0 ? {} : { useThink: config.useThink }
+	};
+};
+const HostArguments = Symbol("effect-cf/ComputerWorkspaceHost/arguments");
+/**
+* Wraps a Durable Object class with one SQLite-backed Cloudflare Computer
+* workspace and registers that local workspace for {@link ComputerWorkspace}
+* to acquire through its Effect layer.
+*
+* The class must use a `new_sqlite_classes` migration. If `shell` is present,
+* its Worker must also configure a `worker_loaders` binding, enable the
+* `experimental` compatibility flag, and export `WorkspaceServiceProxy`.
+*/
+const withComputerWorkspace = (Base, config) => {
+	const CapturedBase = class extends Base {
+		[HostArguments];
+		constructor(...args) {
+			super(...args);
+			this[HostArguments] = {
+				state: args[0],
+				env: args[1]
+			};
+		}
+	};
+	const WithWorkspace = withWorkspace(CapturedBase, (self) => {
+		const { env, state } = self[HostArguments];
+		return toWorkspaceOptions(config(self, state, env));
+	});
+	class WithComputerWorkspace extends WithWorkspace {
+		constructor(...args) {
+			super(...args);
+			register(args[0], this);
+		}
+	}
+	return WithComputerWorkspace;
+};
+//#endregion
+export { WorkspaceServiceProxy, withComputerWorkspace };

package/dist/ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs

@@ -0,0 +1,8 @@
+//#region src/internal/ComputerWorkspaceHostRegistry.ts
+const hosts = /* @__PURE__ */ new WeakMap();
+const register = (state, host) => {
+	hosts.set(state, host);
+};
+const lookup = (state) => hosts.get(state);
+//#endregion
+export { register as n, lookup as t };