effect-cf 0.26.0 → 0.27.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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

package/README.md

@@ -19,8 +19,8 @@ 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`:
+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"
@@ -51,8 +51,8 @@ Runtime creation belongs at Cloudflare entrypoints, not inside binding helpers.
 - `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` - 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
@@ -473,7 +473,8 @@ 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 { DurableObjectDefinition } from "effect-cf";
+import * as ComputerWorkspace from "effect-cf/computer-workspace";
 import { withComputerWorkspace, WorkspaceServiceProxy } from "effect-cf/computer-workspace-host";
 
 export { WorkspaceServiceProxy };
@@ -561,7 +562,8 @@ Workers can use that session isolation without a Durable Object or workspace:
 
 ```ts
 import { Effect } from "effect";
-import { Artifacts, ComputerArtifacts } from "effect-cf";
+import { Artifacts } from "effect-cf";
+import * as ComputerArtifacts from "effect-cf/computer-artifacts";
 
 export const createSessionRepo = (binding: Artifacts.ArtifactsBinding, sessionId: string) =>
   Effect.gen(function* () {

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 };

package/dist/ComputerArtifacts.d.mts

@@ -0,0 +1,55 @@
+import { a as ArtifactsOperationError, c as ArtifactsTokenListResult, i as ArtifactsCreateTokenResult, n as ArtifactsCreateOptions, o as ArtifactsRepoInfo, r as ArtifactsCreateRepoResult, s as ArtifactsTokenInfo, t as ArtifactsBinding, u as RepoName } from "./Artifacts-DcoXcRP5.mjs";
+import { Effect } from "effect";
+import { ArtifactClient, ArtifactImportOptions, ArtifactImportSource, ArtifactRepoSummary, ArtifactScope, ArtifactsCLIInput, ArtifactsCLIResult, RemoteAddFn } from "@cloudflare/computer/artifacts";
+//#region src/ComputerArtifacts.d.ts
+/** External Git source accepted by a session-scoped repository import. */
+type ComputerArtifactImportSource = Readonly<ArtifactImportSource>;
+/** Target options accepted by a session-scoped repository import. */
+type ComputerArtifactImportOptions = Readonly<ArtifactImportOptions>;
+/** Repository metadata returned by a session-scoped list operation. */
+type ComputerArtifactRepoSummary = Readonly<ArtifactRepoSummary>;
+/** Token scope accepted by the upstream session facade. */
+type ComputerArtifactScope = ArtifactScope;
+/** Optional Git remote-registration seam accepted by the argv API. */
+type ComputerArtifactsRemoteAdd = RemoteAddFn;
+/** Input to the session-scoped `artifacts` argv API. */
+type ComputerArtifactsCliInput = ArtifactsCLIInput;
+/** Result from the session-scoped `artifacts` argv API. */
+type ComputerArtifactsCliResult = Readonly<ArtifactsCLIResult>;
+/** Options used when wrapping a session-scoped Artifacts client. */
+interface ComputerArtifactsClientOptions {
+  /** Binding name attached to errors and tracing spans. Defaults to `ARTIFACTS`. */
+  readonly binding?: string;
+}
+/**
+ * Effect-native facade over `@cloudflare/computer/artifacts`.
+ *
+ * Repository names are local to {@link sessionId}. Prefixing and filtering are
+ * intentionally delegated to the upstream `createArtifact` implementation so
+ * this client and the worker-shell `artifacts` command always use the same
+ * namespace convention.
+ */
+interface ComputerArtifactsClient {
+  readonly sessionId: string;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoInfo, ArtifactsOperationError>;
+  readonly list: Effect.Effect<ReadonlyArray<ComputerArtifactRepoSummary>, ArtifactsOperationError>;
+  readonly import: (name: RepoName, source: ComputerArtifactImportSource, options?: ComputerArtifactImportOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly createToken: (name: RepoName, scope?: ComputerArtifactScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult, ArtifactsOperationError>;
+  readonly listTokens: (name: RepoName) => Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
+  readonly getToken: (name: RepoName, id: string) => Effect.Effect<ArtifactsTokenInfo, ArtifactsOperationError>;
+  readonly revokeToken: (name: RepoName, tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
+  readonly cli: (input: ComputerArtifactsCliInput) => Effect.Effect<ComputerArtifactsCliResult, ArtifactsOperationError>;
+  readonly rawUnsafe: Effect.Effect<ArtifactClient>;
+}
+/** Wraps an already-created upstream session client. */
+declare const fromClient: (client: ArtifactClient, options?: ComputerArtifactsClientOptions) => ComputerArtifactsClient;
+/**
+ * Creates an Effect-native session client directly from a Worker Artifacts
+ * binding. `@cloudflare/computer` is loaded only when this Effect runs, keeping
+ * the optional peer out of applications that do not use this integration.
+ */
+declare const makeClient: (bindingValue: ArtifactsBinding, sessionId: string, options?: ComputerArtifactsClientOptions | undefined) => Effect.Effect<ComputerArtifactsClient, ArtifactsOperationError, never>;
+//#endregion
+export { ComputerArtifactImportOptions, ComputerArtifactImportSource, ComputerArtifactRepoSummary, ComputerArtifactScope, ComputerArtifactsCliInput, ComputerArtifactsCliResult, ComputerArtifactsClient, ComputerArtifactsClientOptions, ComputerArtifactsRemoteAdd, fromClient, makeClient };

package/dist/ComputerArtifacts.mjs

@@ -0,0 +1,95 @@
+import { t as ArtifactsOperationError } from "./Artifacts-BhWrdyqX.mjs";
+import { Effect } from "effect";
+//#region src/ComputerArtifacts.ts
+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 operationError = (binding, operation, cause) => new ArtifactsOperationError({
+	binding,
+	operation,
+	cause,
+	...artifactsErrorDetails(cause)
+});
+const tryOperation = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => operationError(binding, operation, cause)
+});
+const spanOptions = (binding, sessionId, operation) => ({ attributes: {
+	binding,
+	sessionId,
+	operation
+} });
+/** Wraps an already-created upstream session client. */
+const fromClient = (client, options = {}) => {
+	const binding = options.binding ?? "ARTIFACTS";
+	const { sessionId } = client;
+	return {
+		sessionId,
+		create: Effect.fn("ComputerArtifacts.create", spanOptions(binding, sessionId, "create"))(function* (name, createOptions) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "create", () => client.create(name, createOptions));
+		}),
+		get: Effect.fn("ComputerArtifacts.get", spanOptions(binding, sessionId, "get"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "get", () => client.get(name));
+		}),
+		list: tryOperation(binding, "list", () => client.list()).pipe(Effect.withSpan("ComputerArtifacts.list", spanOptions(binding, sessionId, "list"))),
+		import: Effect.fn("ComputerArtifacts.import", spanOptions(binding, sessionId, "import"))(function* (name, source, importOptions) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "import", () => client.import(name, source, importOptions));
+		}),
+		delete: Effect.fn("ComputerArtifacts.delete", spanOptions(binding, sessionId, "delete"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "delete", () => client.delete(name));
+		}),
+		createToken: Effect.fn("ComputerArtifacts.createToken", spanOptions(binding, sessionId, "createToken"))(function* (name, scope, ttl) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "createToken", () => client.createToken(name, scope, ttl));
+		}),
+		listTokens: Effect.fn("ComputerArtifacts.listTokens", spanOptions(binding, sessionId, "listTokens"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "listTokens", () => client.listTokens(name));
+		}),
+		getToken: Effect.fn("ComputerArtifacts.getToken", spanOptions(binding, sessionId, "getToken"))(function* (name, id) {
+			yield* Effect.annotateCurrentSpan({
+				repo: name,
+				tokenId: id
+			});
+			return yield* tryOperation(binding, "getToken", () => client.getToken(name, id));
+		}),
+		revokeToken: Effect.fn("ComputerArtifacts.revokeToken", spanOptions(binding, sessionId, "revokeToken"))(function* (name, tokenOrId) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "revokeToken", () => client.revokeToken(name, tokenOrId));
+		}),
+		cli: Effect.fn("ComputerArtifacts.cli", spanOptions(binding, sessionId, "cli"))(function* (input) {
+			yield* Effect.annotateCurrentSpan("argv", input.argv.join(" "));
+			return yield* tryOperation(binding, "cli", () => client.cli(input));
+		}),
+		rawUnsafe: Effect.succeed(client)
+	};
+};
+/**
+* Creates an Effect-native session client directly from a Worker Artifacts
+* binding. `@cloudflare/computer` is loaded only when this Effect runs, keeping
+* the optional peer out of applications that do not use this integration.
+*/
+const makeClient = Effect.fn("ComputerArtifacts.makeClient")(function* (bindingValue, sessionId, options = {}) {
+	const binding = options.binding ?? "ARTIFACTS";
+	const computerArtifacts = yield* Effect.tryPromise({
+		try: () => import("@cloudflare/computer/artifacts"),
+		catch: (cause) => operationError(binding, "createClient", cause)
+	});
+	const client = yield* Effect.try({
+		try: () => computerArtifacts.createArtifact(bindingValue, sessionId),
+		catch: (cause) => operationError(binding, "createClient", cause)
+	});
+	return fromClient(client, { binding });
+});
+//#endregion
+export { fromClient, makeClient };