effect-cf 0.25.3 → 0.27.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # effect-cf
 
+## 0.27.0
+
+### Minor Changes
+
+- [#99](https://github.com/danieljvdm/effect-cf/pull/99) [`5195812`](https://github.com/danieljvdm/effect-cf/commit/519581205c3d3b63e977515f2a33db989a5c9875) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Keep the optional `@cloudflare/computer` integration out of the root bundle so Durable Object and other unrelated consumers can bundle `effect-cf` without installing or externalizing that peer. The synchronous root namespaces could not be preserved without making esbuild resolve the optional dependency before tree-shaking, so update `ComputerWorkspace` imports to `effect-cf/computer-workspace` and `ComputerArtifacts` imports to `effect-cf/computer-artifacts`; `effect-cf/computer-workspace-host` remains unchanged.
+
+## 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

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 `effect-cf/computer-workspace`,
+`effect-cf/computer-artifacts`, 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
+- `effect-cf/computer-workspace` - scoped Effect wrappers for the complete Cloudflare Computer filesystem, Git, runtime, Assets, Artifacts, and Think-compatible client surfaces
+- `effect-cf/computer-artifacts` - 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,168 @@ 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 { DurableObjectDefinition } from "effect-cf";
+import * as ComputerWorkspace from "effect-cf/computer-workspace";
+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 } from "effect-cf";
+import * as ComputerArtifacts from "effect-cf/computer-artifacts";
+
+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 +880,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-BhWrdyqX.mjs

@@ -0,0 +1,241 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as WorkerEnvironment, t as causeMessage } from "./ErrorMessage-_lg53p3W.mjs";
+import { Context, Data, Effect, Layer } from "effect";
+//#region src/Binding.ts
+var Binding_exports = /* @__PURE__ */ __exportAll({
+	BindingNotFoundError: () => BindingNotFoundError,
+	BindingValidationError: () => BindingValidationError,
+	Service: () => Service,
+	TypeId: () => TypeId,
+	layer: () => layer$1
+});
+/** Internal type id marker used by binding helper services. */
+const TypeId = "~effect-cf/Binding";
+/** Error raised when a configured binding does not exist on `env`. */
+var BindingNotFoundError = class extends Data.TaggedError("BindingNotFoundError") {};
+/** Error raised when a binding exists but does not match the expected shape. */
+var BindingValidationError = class extends Data.TaggedError("BindingValidationError") {};
+const defaultExpected = "Cloudflare binding resource";
+const isPropertyTarget = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+const getObjectName = (value) => {
+	const tag = (() => {
+		try {
+			return Object.prototype.toString.call(value).slice(8, -1);
+		} catch {
+			return typeof value;
+		}
+	})();
+	const constructorName = (() => {
+		try {
+			return "constructor" in value && typeof value.constructor === "function" && typeof value.constructor.name === "string" ? value.constructor.name : void 0;
+		} catch {
+			return;
+		}
+	})();
+	if (tag !== "Object") return tag;
+	if (constructorName !== void 0 && constructorName !== "" && constructorName !== "Object") return constructorName;
+	return tag;
+};
+const propertyNames = (value) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const target of [value, Object.getPrototypeOf(value)]) {
+		if (target === null || target === Object.prototype || target === Function.prototype) continue;
+		try {
+			for (const name of Object.getOwnPropertyNames(target)) names.add(name);
+		} catch {
+			continue;
+		}
+	}
+	return [...names].filter((name) => name !== "constructor").sort();
+};
+const isMethod = (value, name) => {
+	try {
+		return typeof Reflect.get(value, name) === "function";
+	} catch {
+		return false;
+	}
+};
+const describeActual = (value) => {
+	if (value === null) return "null";
+	if (typeof value !== "object" && typeof value !== "function") return typeof value;
+	const names = propertyNames(value);
+	const methods = names.filter((name) => isMethod(value, name));
+	const properties = names.filter((name) => !methods.includes(name));
+	const details = [methods.length > 0 ? `methods ${methods.join(", ")}` : void 0, properties.length > 0 ? `properties ${properties.join(", ")}` : void 0].filter((detail) => detail !== void 0);
+	if (details.length === 0) return getObjectName(value);
+	return `${getObjectName(value)} with ${details.join("; ")}`;
+};
+const getBinding = (env, binding, isResource, options) => Effect.gen(function* () {
+	if (!isPropertyTarget(env)) {
+		const actual = describeActual(env);
+		return yield* Effect.fail(new BindingValidationError({
+			binding,
+			expected: "WorkerEnvironment object",
+			actual,
+			message: `Cloudflare binding "${binding}" failed validation. Expected WorkerEnvironment object; got ${actual}`
+		}));
+	}
+	const resource = Reflect.get(env, binding);
+	if (resource === void 0) return yield* Effect.fail(new BindingNotFoundError({
+		binding,
+		message: `Cloudflare binding "${binding}" was not found in WorkerEnvironment`
+	}));
+	if (!isResource(resource)) {
+		const expected = options?.expected ?? defaultExpected;
+		const actual = describeActual(resource);
+		return yield* Effect.fail(new BindingValidationError({
+			binding,
+			expected,
+			actual,
+			message: `Cloudflare binding "${binding}" failed validation. Expected ${expected}; got ${actual}`
+		}));
+	}
+	return resource;
+});
+/**
+* The overloads on {@link layer} and {@link Service} guarantee that
+* `Service = Resource` whenever `wrap` is absent, making the fallback cast
+* safe.
+*/
+const makeBindingLayer = (tag, binding, isResource, wrap, options) => Layer.effect(tag, Effect.gen(function* () {
+	const env = yield* WorkerEnvironment;
+	const resource = yield* getBinding(env, binding, isResource, options);
+	return wrap === void 0 ? resource : wrap(resource);
+}));
+function layer$1(tag, binding, isResource, wrap, options) {
+	return makeBindingLayer(tag, binding, isResource, wrap, options);
+}
+const Service = () => {
+	function makeService(id, binding, isResource, wrap, options) {
+		const tag = Context.Service()(`effect-cf/Binding/${id}`);
+		const serviceLayer = makeBindingLayer(tag, binding, isResource, wrap, options);
+		return Object.assign(tag, {
+			[TypeId]: TypeId,
+			id,
+			binding,
+			layer: serviceLayer
+		});
+	}
+	return makeService;
+};
+//#endregion
+//#region src/Artifacts.ts
+var Artifacts_exports = /* @__PURE__ */ __exportAll({
+	ArtifactsOperationError: () => ArtifactsOperationError,
+	Tag: () => Tag,
+	artifactsErrorCodes: () => artifactsErrorCodes,
+	artifactsErrorNumericCodes: () => artifactsErrorNumericCodes,
+	isArtifactsBinding: () => isArtifactsBinding,
+	isArtifactsRepoBinding: () => isArtifactsRepoBinding,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient
+});
+const expectedArtifactsBinding = "Artifacts binding with create(), get(), import(), list(), and delete()";
+const expectedArtifactsRepo = "Artifacts repo handle with createToken(), listTokens(), revokeToken(), fork(), log(), readCommit(), and readTree()";
+/** Documented string error codes returned by Cloudflare Artifacts. */
+const artifactsErrorCodes = [
+	"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. */
+const artifactsErrorNumericCodes = {
+	ALREADY_EXISTS: 10201,
+	NOT_FOUND: 10200,
+	IMPORT_IN_PROGRESS: 10302,
+	FORK_IN_PROGRESS: 10303,
+	INVALID_INPUT: 10100,
+	INVALID_REPO_NAME: 10101,
+	INVALID_TTL: 10103,
+	INVALID_URL: 10104,
+	REMOTE_AUTH_REQUIRED: 10106,
+	UPSTREAM_UNAVAILABLE: 10401,
+	MEMORY_LIMIT: 10402,
+	INTERNAL_ERROR: 10400
+};
+/** Error raised when a Cloudflare Artifacts operation fails. */
+var ArtifactsOperationError = class extends Data.TaggedError("ArtifactsOperationError") {
+	get message() {
+		const code = this.code === void 0 ? "" : ` (${this.code})`;
+		return `Artifacts ${this.operation} failed for binding "${this.binding}"${code}: ${causeMessage(this.cause)}`;
+	}
+};
+const artifactsErrorDetails = (cause) => {
+	if (typeof cause !== "object" || cause === null) return {};
+	const code = Reflect.get(cause, "code");
+	const numericCode = Reflect.get(cause, "numericCode");
+	return {
+		...typeof code === "string" ? { code } : {},
+		...typeof numericCode === "number" ? { numericCode } : {}
+	};
+};
+const artifactsError = (binding, operation, cause) => new ArtifactsOperationError({
+	binding,
+	operation,
+	cause,
+	...artifactsErrorDetails(cause)
+});
+const tryArtifactsPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => artifactsError(binding, operation, cause)
+});
+const spanOptions = (binding, operation) => ({ attributes: {
+	binding,
+	operation
+} });
+const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
+/** Tests whether a value exposes the complete documented Artifacts repo handle API. */
+const isArtifactsRepoBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "createToken") && hasFunction(value, "listTokens") && hasFunction(value, "revokeToken") && hasFunction(value, "fork") && hasFunction(value, "log") && hasFunction(value, "readCommit") && hasFunction(value, "readTree");
+/** Tests whether a value exposes the complete documented Artifacts namespace API. */
+const isArtifactsBinding = (value) => typeof value === "object" && value !== null && hasFunction(value, "create") && hasFunction(value, "get") && hasFunction(value, "import") && hasFunction(value, "list") && hasFunction(value, "delete");
+const wrapRepo = (binding, repo) => ({
+	id: repo.id,
+	name: repo.name,
+	description: repo.description,
+	defaultBranch: repo.defaultBranch,
+	createdAt: repo.createdAt,
+	updatedAt: repo.updatedAt,
+	lastPushAt: repo.lastPushAt,
+	source: repo.source,
+	readOnly: repo.readOnly,
+	remote: repo.remote,
+	createToken: Effect.fn("Artifacts.createToken", spanOptions(binding, "createToken"))((scope, ttl) => tryArtifactsPromise(binding, "createToken", () => repo.createToken(scope, ttl))),
+	listTokens: tryArtifactsPromise(binding, "listTokens", () => repo.listTokens()).pipe(Effect.withSpan("Artifacts.listTokens", spanOptions(binding, "listTokens"))),
+	revokeToken: Effect.fn("Artifacts.revokeToken", spanOptions(binding, "revokeToken"))((tokenOrId) => tryArtifactsPromise(binding, "revokeToken", () => repo.revokeToken(tokenOrId))),
+	fork: Effect.fn("Artifacts.fork", spanOptions(binding, "fork"))((name, options) => tryArtifactsPromise(binding, "fork", () => repo.fork(name, options))),
+	log: Effect.fn("Artifacts.log", spanOptions(binding, "log"))((options) => tryArtifactsPromise(binding, "log", () => repo.log(options))),
+	readCommit: Effect.fn("Artifacts.readCommit", spanOptions(binding, "readCommit"))((hash) => tryArtifactsPromise(binding, "readCommit", () => repo.readCommit(hash))),
+	readTree: Effect.fn("Artifacts.readTree", spanOptions(binding, "readTree"))((hash) => tryArtifactsPromise(binding, "readTree", () => repo.readTree(hash))),
+	raw: repo
+});
+const makeClient = (definition) => (artifacts) => ({
+	definition,
+	create: Effect.fn("Artifacts.create", spanOptions(definition.binding, "create"))((name, options) => tryArtifactsPromise(definition.binding, "create", () => artifacts.create(name, options))),
+	get: Effect.fn("Artifacts.get", spanOptions(definition.binding, "get"))((name) => tryArtifactsPromise(definition.binding, "get", () => artifacts.get(name)).pipe(Effect.flatMap((repo) => isArtifactsRepoBinding(repo) ? Effect.succeed(wrapRepo(definition.binding, repo)) : Effect.fail(artifactsError(definition.binding, "get", /* @__PURE__ */ new TypeError(`Expected ${expectedArtifactsRepo}`)))))),
+	import: Effect.fn("Artifacts.import", spanOptions(definition.binding, "import"))((params) => tryArtifactsPromise(definition.binding, "import", () => artifacts.import(params))),
+	list: Effect.fn("Artifacts.list", spanOptions(definition.binding, "list"))((options) => tryArtifactsPromise(definition.binding, "list", () => artifacts.list(options))),
+	delete: Effect.fn("Artifacts.delete", spanOptions(definition.binding, "delete"))((name) => tryArtifactsPromise(definition.binding, "delete", () => artifacts.delete(name))),
+	rawUnsafe: Effect.succeed(artifacts)
+});
+const layer = (tag, definition) => layer$1(tag, definition.binding, isArtifactsBinding, makeClient(definition), { expected: expectedArtifactsBinding });
+const make = (id) => Tag()(id);
+const Tag = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
+export { layer$1 as a, Service as i, Artifacts_exports as n, Binding_exports as r, ArtifactsOperationError as t };