effect-cf 0.26.0 → 0.28.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # effect-cf
 
+## 0.28.0
+
+### Minor Changes
+
+- [#104](https://github.com/danieljvdm/effect-cf/pull/104) [`4aadbd0`](https://github.com/danieljvdm/effect-cf/commit/4aadbd0b6e76449bac190dbc5abb4c20486c8761) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Allow workflow step Effects to fail terminally with `WorkflowStepNonRetryableError`, which is rethrown to Cloudflare as its native `NonRetryableError`.
+
+- [#104](https://github.com/danieljvdm/effect-cf/pull/104) [`4aadbd0`](https://github.com/danieljvdm/effect-cf/commit/4aadbd0b6e76449bac190dbc5abb4c20486c8761) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Support method-only remote Artifacts repository bindings with a typed `info()` client operation and live commit history shapes.
+
+- [#102](https://github.com/danieljvdm/effect-cf/pull/102) [`1b32c54`](https://github.com/danieljvdm/effect-cf/commit/1b32c54757bf404c2454389b0386e0996974cdc6) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Harden Cloudflare and WebTransport runtime boundaries with receiver-safe invocation, truthful return types, validated external data, and stricter event-layer requirements.
+
+## 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-DcoXcRP5.d.mts → Artifacts-DnHQA-Ax.d.mts}

@@ -1,10 +1,10 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-COCtoJXa.mjs";
+import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-xJJJPmiD.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 };
+  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, 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";
+type ArtifactsOperation = "createClient" | "create" | "get" | "import" | "list" | "delete" | "createToken" | "listTokens" | "getToken" | "revokeToken" | "fork" | "info" | "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. */
@@ -74,32 +74,34 @@ type ArtifactsCreateTokenResult = CloudflareArtifactsCreateTokenResult;
 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;
+/** Identity recorded for a Git commit author or committer. */
+interface ArtifactsCommitIdentity {
+  readonly name: string;
+  readonly email: string;
 }
-/**
- * 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.
- */
+/** Parsed Git commit returned by `readCommit()` and `log()`. */
 interface ArtifactsCommit {
-  readonly [field: string]: unknown;
-}
+  readonly hash: string;
+  readonly treeHash: string;
+  readonly message: string;
+  readonly author: ArtifactsCommitIdentity;
+  readonly committer: ArtifactsCommitIdentity;
+  readonly parents: ReadonlyArray<string>;
+  /** Unix timestamp in seconds. */
+  readonly authoredAt: number;
+  /** Unix timestamp in seconds. */
+  readonly committedAt: number;
+}
+/** Bare commit array returned by `log()`. */
+type ArtifactsLogResult = ReadonlyArray<ArtifactsCommit>;
 /**
  * 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;
+interface ArtifactsTree<Field = unknown> {
+  readonly [field: string]: Field;
 }
 /** Options for `Artifacts.create()`. */
 interface ArtifactsCreateOptions {
@@ -155,7 +157,15 @@ interface ArtifactsLogOptions {
   readonly offset?: number;
 }
 /** Runtime repository handle, including methods absent from current shipped Workers types. */
-interface ArtifactsRepoBinding extends ArtifactsRepoInfo {
+interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo> {
+  /**
+   * Read repository metadata.
+   *
+   * Remote bindings expose method-only RPC handles and provide metadata only
+   * through this method. It is optional solely for compatibility with older
+   * local handles that expose metadata as data properties.
+   */
+  readonly info?: () => Promise<ArtifactsRepoInfo>;
   /**
    * Create a Git token for the repository.
    *
@@ -178,8 +188,15 @@ interface ArtifactsBinding {
   readonly list: (options?: ArtifactsListOptions) => Promise<ArtifactsRepoListResult>;
   readonly delete: (name: RepoName) => Promise<boolean>;
 }
-/** Effect wrapper around a repository handle returned by `Artifacts.get()`. */
+/**
+ * Effect wrapper around a repository handle returned by `Artifacts.get()`.
+ *
+ * The inherited metadata is the snapshot read while resolving the client.
+ * Use `info()` to refresh it from the repository handle.
+ */
 interface ArtifactsRepoClient extends ArtifactsRepoInfo {
+  /** Read and validate the repository's current metadata. */
+  readonly info: () => Effect.Effect<ArtifactsRepoInfo, ArtifactsOperationError>;
   /**
    * Create a Git token for the repository.
    *
@@ -220,9 +237,9 @@ interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, I
   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;
+declare const isArtifactsRepoBinding: <Candidate>(value: Candidate) => value is Candidate & ArtifactsRepoBinding;
 /** Tests whether a value exposes the complete documented Artifacts namespace API. */
-declare const isArtifactsBinding: (value: unknown) => value is ArtifactsBinding;
+declare const isArtifactsBinding: <Candidate>(value: Candidate) => value is Candidate & 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>;

package/dist/Artifacts-rq3hUKQE.mjs

@@ -0,0 +1,257 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as WorkerEnvironment, t as causeMessage } from "./ErrorMessage-BM0K-Nik.mjs";
+import { Context, Data, Effect, Layer, Predicate, Schema } 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) => Predicate.isObjectOrArray(value) || Predicate.isFunction(value);
+const getObjectName = (value) => {
+	const tag = (() => {
+		try {
+			return Object.prototype.toString.call(value).slice(8, -1);
+		} catch {
+			return Predicate.isFunction(value) ? "function" : "object";
+		}
+	})();
+	const constructorName = (() => {
+		try {
+			return "constructor" in value && Predicate.isFunction(value.constructor) && Predicate.isString(value.constructor.name) ? 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 Predicate.hasProperty(value, name) && Predicate.isFunction(value[name]);
+	} catch {
+		return false;
+	}
+};
+const describeActual = (value) => {
+	if (value === null) return "null";
+	if (!isPropertyTarget(value)) {
+		if (Predicate.isString(value)) return "string";
+		if (Predicate.isNumber(value)) return "number";
+		if (Predicate.isBoolean(value)) return "boolean";
+		if (Predicate.isBigInt(value)) return "bigint";
+		if (Predicate.isSymbol(value)) return "symbol";
+		return "undefined";
+	}
+	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 = Predicate.hasProperty(env, binding) ? env[binding] : void 0;
+	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 (!Predicate.isObject(cause)) return {};
+	const code = Predicate.hasProperty(cause, "code") ? cause.code : void 0;
+	const numericCode = Predicate.hasProperty(cause, "numericCode") ? cause.numericCode : void 0;
+	const details = {};
+	if (Predicate.isString(code)) details.code = code;
+	if (Predicate.isNumber(numericCode)) details.numericCode = numericCode;
+	return details;
+};
+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) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
+const ArtifactsRepoInfoSchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	description: Schema.NullOr(Schema.String),
+	defaultBranch: Schema.String,
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	lastPushAt: Schema.NullOr(Schema.String),
+	source: Schema.NullOr(Schema.String),
+	readOnly: Schema.Boolean,
+	remote: Schema.String
+});
+const decodeRepoInfo = (binding, value) => Schema.decodeUnknownEffect(ArtifactsRepoInfoSchema)(value).pipe(Effect.mapError((cause) => artifactsError(binding, "info", cause)));
+const readRepoInfo = (binding, repo) => {
+	if (hasFunction(repo, "info")) return tryArtifactsPromise(binding, "info", () => repo.info()).pipe(Effect.flatMap((info) => decodeRepoInfo(binding, info)), Effect.withSpan("Artifacts.info", spanOptions(binding, "info")));
+	return decodeRepoInfo(binding, repo).pipe(Effect.withSpan("Artifacts.info", spanOptions(binding, "info")));
+};
+/** Tests whether a value exposes the complete documented Artifacts repo handle API. */
+const isArtifactsRepoBinding = (value) => 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) => hasFunction(value, "create") && hasFunction(value, "get") && hasFunction(value, "import") && hasFunction(value, "list") && hasFunction(value, "delete");
+const wrapRepo = (binding, repo, info) => ({
+	...info,
+	info: () => readRepoInfo(binding, repo),
+	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) ? readRepoInfo(definition.binding, repo).pipe(Effect.map((info) => wrapRepo(definition.binding, repo, info))) : 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/{Binding-COCtoJXa.d.mts → Binding-xJJJPmiD.d.mts}

@@ -1,4 +1,4 @@
-import { Config, ConfigProvider, Context, Effect, Layer } from "effect";
+import { Config, ConfigProvider, Context, Effect, Layer, Predicate } from "effect";
 declare namespace Environment_d_exports {
   export { WorkerConfig, WorkerEnv, WorkerEnvironment };
 }
@@ -116,6 +116,7 @@ declare class BindingValidationError extends BindingValidationError_base<{
 interface ValidationOptions {
   readonly expected?: string;
 }
+type BindingCandidate = Parameters<typeof Predicate.isUnknown>[0];
 /**
  * Creates a Context tag + layer for reading and validating a Cloudflare binding.
  *
@@ -128,11 +129,11 @@ interface BindingService<Self, Id extends string, Service> extends Context.Servi
   readonly binding: string;
   readonly layer: Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
-declare function layer<Self, Resource>(tag: Context.Service<Self, Resource>, binding: string, isResource: (value: unknown) => value is Resource, wrap?: undefined, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
-declare function layer<Self, Resource, Service>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: unknown) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare function layer<Self, Resource>(tag: Context.Service<Self, Resource>, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap?: undefined, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare function layer<Self, Resource, Service>(tag: Context.Service<Self, Service>, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const Service: <Self>() => {
-  <Id extends string, Resource>(id: Id, binding: string, isResource: (value: unknown) => value is Resource, wrap?: undefined, options?: ValidationOptions): BindingService<Self, Id, Resource>;
-  <Id extends string, Resource, Service>(id: Id, binding: string, isResource: (value: unknown) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): BindingService<Self, Id, Service>;
+  <Id extends string, Resource>(id: Id, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap?: undefined, options?: ValidationOptions): BindingService<Self, Id, Resource>;
+  <Id extends string, Resource, Service>(id: Id, binding: string, isResource: (value: BindingCandidate) => value is Resource, wrap: (resource: Resource) => Service, options?: ValidationOptions): BindingService<Self, Id, Service>;
 };
 //#endregion
 export { Environment_d_exports as a, WorkerEnvironment as c, Binding_d_exports as i, BindingService as n, WorkerConfig as o, BindingValidationError as r, WorkerEnv as s, BindingNotFoundError 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-DnHQA-Ax.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-rq3hUKQE.mjs";
+import { Effect, Predicate } from "effect";
+//#region src/ComputerArtifacts.ts
+const artifactsErrorDetails = (cause) => {
+	if (!Predicate.isObject(cause)) return {};
+	const code = Predicate.hasProperty(cause, "code") ? cause.code : void 0;
+	const numericCode = Predicate.hasProperty(cause, "numericCode") ? cause.numericCode : void 0;
+	const details = {};
+	if (Predicate.isString(code)) details.code = code;
+	if (Predicate.isNumber(numericCode)) details.numericCode = numericCode;
+	return details;
+};
+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 };