effect-cf 0.27.0 → 0.28.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # effect-cf
 
+## 0.28.1
+
+### Patch Changes
+
+- [#105](https://github.com/danieljvdm/effect-cf/pull/105) [`f5dfd5e`](https://github.com/danieljvdm/effect-cf/commit/f5dfd5e2c79b257cc760dc0b2cdf5a2901b0b295) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Bound internally scheduled telemetry flushes so exporter retries cannot extend Worker or Durable Object event lifetimes indefinitely.
+
+- [#106](https://github.com/danieljvdm/effect-cf/pull/106) [`c0fbb85`](https://github.com/danieljvdm/effect-cf/commit/c0fbb8535479262741e6844935e9ff9d508f6b56) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Silently absorb failures raised while scheduling automatic OTLP telemetry flushes so platform boundary defects cannot feed back into the configured exporter. Document the two-second best-effort boundary and keep explicit queue flush policy application-owned.
+
+## 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

package/README.md

@@ -357,6 +357,12 @@ Producers should usually use `const queue = yield* AvatarQueue` and then call `q
 
 Queue handlers run inline failures through Cloudflare's normal retry path. If background work scheduled with `WorkerContext.waitUntil(...)` should also make the batch retry, use `WorkerContext.waitUntilPropagating(...)` or `waitUntil(..., { mode: "propagate" })`; the default `waitUntil` mode observes and logs failures without rejecting the native `waitUntil` promise.
 
+effect-cf automatically schedules best-effort OTLP flushes only for Worker
+fetch/RPC and Durable Object alarm/RPC handlers. Those internal flushes are
+capped at two seconds. Queue handlers do not flush telemetry automatically;
+applications that explicitly flush in a queue handler own that flush's timeout
+and failure policy.
+
 ## Cache Example
 
 `Cache.layer` exposes Cloudflare's global Cache API as an Effect service. Cache misses are represented by `Option.none()`, and named caches are available through `open(...)`.

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-BhWrdyqX.mjs → Artifacts-rq3hUKQE.mjs}

@@ -1,6 +1,6 @@
 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";
+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,
@@ -16,18 +16,18 @@ 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 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 typeof value;
+			return Predicate.isFunction(value) ? "function" : "object";
 		}
 	})();
 	const constructorName = (() => {
 		try {
-			return "constructor" in value && typeof value.constructor === "function" && typeof value.constructor.name === "string" ? value.constructor.name : void 0;
+			return "constructor" in value && Predicate.isFunction(value.constructor) && Predicate.isString(value.constructor.name) ? value.constructor.name : void 0;
 		} catch {
 			return;
 		}
@@ -50,14 +50,21 @@ const propertyNames = (value) => {
 };
 const isMethod = (value, name) => {
 	try {
-		return typeof Reflect.get(value, name) === "function";
+		return Predicate.hasProperty(value, name) && Predicate.isFunction(value[name]);
 	} catch {
 		return false;
 	}
 };
 const describeActual = (value) => {
 	if (value === null) return "null";
-	if (typeof value !== "object" && typeof value !== "function") return typeof value;
+	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));
@@ -75,7 +82,7 @@ const getBinding = (env, binding, isResource, options) => Effect.gen(function* (
 			message: `Cloudflare binding "${binding}" failed validation. Expected WorkerEnvironment object; got ${actual}`
 		}));
 	}
-	const resource = Reflect.get(env, binding);
+	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`
@@ -171,13 +178,13 @@ var ArtifactsOperationError = class extends Data.TaggedError("ArtifactsOperation
 	}
 };
 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 } : {}
-	};
+	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,
@@ -193,22 +200,31 @@ const spanOptions = (binding, operation) => ({ attributes: {
 	binding,
 	operation
 } });
-const hasFunction = (value, key) => typeof Reflect.get(value, key) === "function";
+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) => 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");
+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) => 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,
+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))),
@@ -221,7 +237,7 @@ const wrapRepo = (binding, 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}`)))))),
+	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))),

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

@@ -1,4 +1,4 @@
-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 { 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

package/dist/ComputerArtifacts.mjs

@@ -1,14 +1,14 @@
-import { t as ArtifactsOperationError } from "./Artifacts-BhWrdyqX.mjs";
-import { Effect } from "effect";
+import { t as ArtifactsOperationError } from "./Artifacts-rq3hUKQE.mjs";
+import { Effect, Predicate } 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 } : {}
-	};
+	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,

package/dist/ComputerWorkspace.d.mts

@@ -1,5 +1,5 @@
 import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
-import { t as DurableObjectState } from "./DurableObjectState-biHrHwrh.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-OupNMMUl.mjs";
 import { Context, Effect, Layer, Schema, Scope, Stream } from "effect";
 import { CommitView, GitClient, GitCloneOptions, GitCommitOptions, GitDiffOptions, GitFetchOptions, GitLogOptions, GitUpdateRefOptions } from "@cloudflare/computer/git";
 import { ExecSyncResult, RuntimeExecOptions, RuntimeGetOptions, RuntimeKillOptions, ShellValue, SkippedEntry, ThinkWorkspaceCompatibility, WorkspaceClient, WorkspaceRuntimeResult, WorkspaceRuntimeValue as WorkspaceRuntimeValue$1 } from "@cloudflare/computer";
@@ -229,7 +229,7 @@ type EffectThinkMethod<Method> = Method extends ((...args: infer Args) => Promis
 /** Effect wrapper of the optional Think compatibility surface. */
 type ComputerWorkspaceThink = { readonly [Name in keyof ThinkWorkspaceCompatibility]: EffectThinkMethod<ThinkWorkspaceCompatibility[Name]>; };
 /** Effect service over every client surface exposed by Cloudflare Computer. */
-interface ComputerWorkspaceShape {
+interface ComputerWorkspaceService {
   readonly fs: ComputerWorkspaceFilesystem;
   readonly git: ComputerWorkspaceGit;
   readonly runtime: ComputerWorkspaceRuntime;
@@ -265,8 +265,8 @@ interface ComputerWorkspaceShape {
  * {@link ComputerWorkspace.layer} in Durable Objects so the parent client and
  * every runtime handle are disposed by Effect `Scope`.
  */
-declare const fromWorkspaceClient: (client: WorkspaceClient) => ComputerWorkspaceShape;
-declare const ComputerWorkspace_base: Context.ServiceClass<ComputerWorkspace, "effect-cf/ComputerWorkspace", ComputerWorkspaceShape>;
+declare const fromWorkspaceClient: (client: WorkspaceClient) => ComputerWorkspaceService;
+declare const ComputerWorkspace_base: Context.ServiceClass<ComputerWorkspace, "effect-cf/ComputerWorkspace", ComputerWorkspaceService>;
 /** Effect service for the workspace owned by the enclosing Durable Object. */
 declare class ComputerWorkspace extends ComputerWorkspace_base {
   /**
@@ -276,4 +276,4 @@ declare class ComputerWorkspace extends ComputerWorkspace_base {
   static readonly layer: Layer.Layer<ComputerWorkspace, never, DurableObjectState>;
 }
 //#endregion
-export { ComputerWorkspace, ComputerWorkspaceAssets, ComputerWorkspaceFilesystem, ComputerWorkspaceGit, ComputerWorkspaceRuntime, ComputerWorkspaceShape, ComputerWorkspaceThink, ListDirectoryOptions, ReadTextFileOptions, RemovePathOptions, WorkspaceAssetsError, WorkspaceDirectoryEntry, WorkspaceEntryStat, WorkspaceExec, WorkspaceExecChunk, WorkspaceExecCollect, WorkspaceExecEncoding, WorkspaceExecError, WorkspaceExecEvent, WorkspaceExecOptions, WorkspaceExecResult, WorkspaceExecRun, WorkspaceExecSignal, WorkspaceExecSkippedEntry, WorkspaceExecSyncResult, WorkspaceFindOptions, WorkspaceFoundEntry, WorkspaceFsError, WorkspaceGetExec, WorkspaceGetExecOptions, WorkspaceGitCheckoutOptions, WorkspaceGitCloneOptions, WorkspaceGitCommit, WorkspaceGitCommitOptions, WorkspaceGitDiffOptions, WorkspaceGitError, WorkspaceGitFetchOptions, WorkspaceGitFetchResult, WorkspaceGitLogOptions, WorkspaceGitPerson, WorkspaceGitUpdateRefOptions, WorkspaceGrepMatch, WorkspaceGrepOptions, WorkspaceMkdirOptions, WorkspaceReadEncoding, WorkspaceReadFile, WorkspaceReadFileOptions, WorkspaceRuntimeValue, WorkspaceWriteFileContent, WorkspaceWriteFileOptions, fromWorkspaceClient };
+export { ComputerWorkspace, ComputerWorkspaceAssets, ComputerWorkspaceFilesystem, ComputerWorkspaceGit, ComputerWorkspaceRuntime, ComputerWorkspaceService, type ComputerWorkspaceService as ComputerWorkspaceShape, ComputerWorkspaceThink, ListDirectoryOptions, ReadTextFileOptions, RemovePathOptions, WorkspaceAssetsError, WorkspaceDirectoryEntry, WorkspaceEntryStat, WorkspaceExec, WorkspaceExecChunk, WorkspaceExecCollect, WorkspaceExecEncoding, WorkspaceExecError, WorkspaceExecEvent, WorkspaceExecOptions, WorkspaceExecResult, WorkspaceExecRun, WorkspaceExecSignal, WorkspaceExecSkippedEntry, WorkspaceExecSyncResult, WorkspaceFindOptions, WorkspaceFoundEntry, WorkspaceFsError, WorkspaceGetExec, WorkspaceGetExecOptions, WorkspaceGitCheckoutOptions, WorkspaceGitCloneOptions, WorkspaceGitCommit, WorkspaceGitCommitOptions, WorkspaceGitDiffOptions, WorkspaceGitError, WorkspaceGitFetchOptions, WorkspaceGitFetchResult, WorkspaceGitLogOptions, WorkspaceGitPerson, WorkspaceGitUpdateRefOptions, WorkspaceGrepMatch, WorkspaceGrepOptions, WorkspaceMkdirOptions, WorkspaceReadEncoding, WorkspaceReadFile, WorkspaceReadFileOptions, WorkspaceRuntimeValue, WorkspaceWriteFileContent, WorkspaceWriteFileOptions, fromWorkspaceClient };