effect-cf 0.27.0 → 0.28.0

package/CHANGELOG.md

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

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

package/dist/ComputerWorkspace.mjs

@@ -1,7 +1,7 @@
-import { t as DurableObjectState } from "./DurableObjectState-Dux8KfjG.mjs";
+import { t as DurableObjectState } from "./DurableObjectState-BjkK2kwH.mjs";
 import { fromClient } from "./ComputerArtifacts.mjs";
 import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
-import { Context, Effect, Layer, Schema, Stream } from "effect";
+import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";
 //#region src/ComputerWorkspace.ts
 /**
 * Workspace errors use `Schema.TaggedError`, unlike most local binding errors,
@@ -39,36 +39,50 @@ var WorkspaceAssetsError = class extends Schema.TaggedError()("WorkspaceAssetsEr
 }) {};
 const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
 const errorCode = (cause) => {
-	if (typeof cause !== "object" || cause === null) return;
-	const code = Reflect.get(cause, "code");
-	return typeof code === "string" ? code : void 0;
+	if (Predicate.hasProperty(cause, "code") && Predicate.isString(cause.code)) return cause.code;
+};
+const fsError = (operation, path, cause) => {
+	const properties = {
+		operation,
+		path,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceFsError.make(properties);
+};
+const gitError = (operation, cause) => {
+	const properties = {
+		operation,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceGitError.make(properties);
+};
+const execError = (operation, cause) => {
+	const properties = {
+		operation,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceExecError.make(properties);
+};
+const assetsError = (operation, path, cause) => {
+	const properties = {
+		operation,
+		path,
+		message: errorMessage(cause),
+		cause
+	};
+	const code = errorCode(cause);
+	if (code !== void 0) properties.code = code;
+	return WorkspaceAssetsError.make(properties);
 };
-const fsError = (operation, path, cause) => WorkspaceFsError.make({
-	operation,
-	path,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
-const gitError = (operation, cause) => WorkspaceGitError.make({
-	operation,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
-const execError = (operation, cause) => WorkspaceExecError.make({
-	operation,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
-const assetsError = (operation, path, cause) => WorkspaceAssetsError.make({
-	operation,
-	path,
-	message: errorMessage(cause),
-	cause,
-	...errorCode(cause) === void 0 ? {} : { code: errorCode(cause) }
-});
 const tryFs = (operation, path, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => fsError(operation, path, cause)
@@ -223,11 +237,10 @@ const makeGit = (gitClient) => {
 		operation: "log"
 	} })(function* (options) {
 		const { maxCount, ...upstreamOptions } = options ?? {};
+		const logOptions = { ...upstreamOptions };
+		if (logOptions.depth === void 0 && maxCount !== void 0) logOptions.depth = maxCount;
 		return (yield* Effect.tryPromise({
-			try: () => gitClient.log({
-				...upstreamOptions,
-				...upstreamOptions.depth === void 0 && maxCount !== void 0 ? { depth: maxCount } : {}
-			}),
+			try: () => gitClient.log(logOptions),
 			catch: (cause) => gitError("log", cause)
 		})).map(gitCommit);
 	});
@@ -235,7 +248,7 @@ const makeGit = (gitClient) => {
 		family: "git",
 		operation: "revParse"
 	} })(function* (input) {
-		const options = typeof input === "string" ? { ref: input } : input;
+		const options = Predicate.isString(input) ? { ref: input } : input;
 		return yield* Effect.tryPromise({
 			try: () => gitClient.revParse(options),
 			catch: (cause) => gitError("revParse", cause)
@@ -286,35 +299,41 @@ const makeGit = (gitClient) => {
 };
 const runtimeExecOptions = (options) => {
 	const { encoding = "utf8", timeoutMillis, timeoutMs, ...rest } = options ?? {};
-	return {
-		...rest,
-		...encoding === "utf8" ? { encoding: "utf8" } : {},
-		...timeoutMs === void 0 && timeoutMillis === void 0 ? {} : { timeoutMs: timeoutMs ?? timeoutMillis }
-	};
+	const runtimeOptions = { ...rest };
+	if (encoding === "utf8") runtimeOptions.encoding = "utf8";
+	const selectedTimeout = timeoutMs ?? timeoutMillis;
+	if (selectedTimeout !== void 0) runtimeOptions.timeoutMs = selectedTimeout;
+	return runtimeOptions;
 };
 const runtimeGetOptions = (options) => {
 	const { encoding = "utf8", ...rest } = options ?? {};
-	return {
-		...rest,
-		...encoding === "utf8" ? { encoding: "utf8" } : {}
+	const runtimeOptions = { ...rest };
+	if (encoding === "utf8") runtimeOptions.encoding = "utf8";
+	return runtimeOptions;
+};
+const wrapRuntimeResult = (result) => {
+	const stdout = result.stdout;
+	const stderr = result.stderr;
+	const wrapped = {
+		status: result.status,
+		exitCode: result.exitCode,
+		stdout,
+		stderr,
+		pushed: result.pushed,
+		pulled: result.pulled,
+		skipped: result.skipped,
+		sync: result.sync
+	};
+	return result.value === void 0 ? wrapped : {
+		...wrapped,
+		value: result.value
 	};
 };
-const wrapRuntimeResult = (result) => ({
-	status: result.status,
-	exitCode: result.exitCode,
-	stdout: result.stdout,
-	stderr: result.stderr,
-	...result.value === void 0 ? {} : { value: result.value },
-	pushed: result.pushed,
-	pulled: result.pulled,
-	skipped: result.skipped,
-	sync: result.sync
-});
 const wrapRuntimeEvent = (event) => {
 	switch (event.name) {
 		case "stdout": {
 			const chunk = event.value;
-			return typeof chunk === "string" ? {
+			return Predicate.isString(chunk) ? {
 				_tag: "Stdout",
 				id: event.id,
 				sequence: event.seq,
@@ -330,7 +349,7 @@ const wrapRuntimeEvent = (event) => {
 		}
 		case "stderr": {
 			const chunk = event.value;
-			return typeof chunk === "string" ? {
+			return Predicate.isString(chunk) ? {
 				_tag: "Stderr",
 				id: event.id,
 				sequence: event.seq,
@@ -344,20 +363,25 @@ const wrapRuntimeEvent = (event) => {
 				bytes: chunk
 			};
 		}
-		case "exit": return {
-			_tag: "Exit",
-			id: event.id,
-			sequence: event.seq,
-			exitCode: event.code,
-			...event.result === void 0 ? {} : { value: event.result }
-		};
+		case "exit":
+			const exitEvent = {
+				_tag: "Exit",
+				id: event.id,
+				sequence: event.seq,
+				exitCode: event.code
+			};
+			return event.result === void 0 ? exitEvent : {
+				...exitEvent,
+				value: event.result
+			};
 	}
 };
 const wrapRun = (handle) => {
+	const mapRuntimeEvent = wrapRuntimeEvent;
 	const events = Stream.fromReadableStream({
 		evaluate: () => handle,
 		onError: (cause) => execError("events", cause)
-	}).pipe(Stream.map(wrapRuntimeEvent));
+	}).pipe(Stream.map(mapRuntimeEvent));
 	const result = Effect.tryPromise({
 		try: () => handle.result(),
 		catch: (cause) => execError("result", cause)
@@ -386,14 +410,14 @@ const makeRuntime = (client) => {
 		family: "runtime",
 		operation: "exec"
 	} })(function* (source, optionsOrValue, ...remainingValues) {
-		const options = typeof source === "string" ? optionsOrValue : void 0;
+		const options = Predicate.isString(source) ? optionsOrValue : void 0;
 		yield* Effect.annotateCurrentSpan({
 			backend: options?.backend,
 			runId: options?.id
 		});
 		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
 			try: () => {
-				if (typeof source === "string") return client.runtime.exec(source, runtimeExecOptions(options));
+				if (Predicate.isString(source)) return client.runtime.exec(source, runtimeExecOptions(options));
 				const values = optionsOrValue === void 0 ? remainingValues : [optionsOrValue, ...remainingValues];
 				return client.runtime.exec(source, ...values);
 			},
@@ -477,15 +501,23 @@ const makeThink = (client) => {
 		yield* Effect.annotateCurrentSpan("path", path);
 		return yield* tryFs(`think.${operation}`, path, () => evaluate(...args));
 	});
+	const readFile = client.readFile.bind(client);
+	const readFileBytes = client.readFileBytes.bind(client);
+	const writeFile = client.writeFile.bind(client);
+	const readDir = client.readDir.bind(client);
+	const rm = client.rm.bind(client);
+	const glob = client.glob.bind(client);
+	const mkdir = client.mkdir.bind(client);
+	const stat = client.stat.bind(client);
 	return {
-		readFile: method("readFile", (path) => path, (path) => client.readFile(path)),
-		readFileBytes: method("readFileBytes", (path) => path, (path) => client.readFileBytes(path)),
-		writeFile: method("writeFile", (path, _content) => path, (path, content) => client.writeFile(path, content)),
-		readDir: method("readDir", (path, _options) => path, (path, options) => client.readDir(path, options)),
-		rm: method("rm", (path, _options) => path, (path, options) => client.rm(path, options)),
-		glob: method("glob", (pattern) => pattern, (pattern) => client.glob(pattern)),
-		mkdir: method("mkdir", (path, _options) => path, (path, options) => client.mkdir(path, options)),
-		stat: method("stat", (path) => path, (path) => client.stat(path))
+		readFile: method("readFile", (path) => path, (path) => readFile(path)),
+		readFileBytes: method("readFileBytes", (path) => path, (path) => readFileBytes(path)),
+		writeFile: method("writeFile", (path, _content) => path, (path, content) => writeFile(path, content)),
+		readDir: method("readDir", (path, _options) => path, (path, options) => readDir(path, options)),
+		rm: method("rm", (path, _options) => path, (path, options) => rm(path, options)),
+		glob: method("glob", (pattern) => pattern, (pattern) => glob(pattern)),
+		mkdir: method("mkdir", (path, _options) => path, (path, options) => mkdir(path, options)),
+		stat: method("stat", (path) => path, (path) => stat(path))
 	};
 };
 /**