effect-cf 0.40.0 → 0.40.2

package/dist/Cache.mjs

@@ -0,0 +1,51 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+//#region src/Cache.ts
+var Cache_exports = /* @__PURE__ */ __exportAll({
+	CacheOperationError: () => CacheOperationError,
+	CacheStorage: () => CacheStorage,
+	layer: () => layer,
+	layerFrom: () => layerFrom,
+	makeCacheClient: () => makeCacheClient,
+	makeClient: () => makeClient
+});
+var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {
+	get message() {
+		return `Cache ${this.operation} failed for cache "${this.cache}": ${causeMessage(this.cause)}`;
+	}
+};
+var CacheStorage = class extends Context.Service()("effect-cf/CacheStorage") {};
+const cacheError = (cache, operation, cause) => new CacheOperationError({
+	cache,
+	operation,
+	cause
+});
+const tryCachePromise = (cache, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => cacheError(cache, operation, cause)
+});
+const spanOptions = (cache, operation) => ({ attributes: {
+	cache,
+	operation
+} });
+const makeCacheClient = (cache, name = "default") => ({
+	name,
+	match: Effect.fn("Cache.match", spanOptions(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
+	put: Effect.fn("Cache.put", spanOptions(name, "put"))((request, response) => tryCachePromise(name, "put", () => cache.put(request, response))),
+	delete: Effect.fn("Cache.delete", spanOptions(name, "delete"))((request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options))),
+	rawUnsafe: Effect.succeed(cache)
+});
+const makeClient = (storage) => ({
+	default: makeCacheClient(storage.default),
+	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name)), Effect.withSpan("Cache.open", spanOptions(name, "open"))),
+	rawUnsafe: Effect.succeed(storage)
+});
+const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient(storage));
+const layer = Layer.sync(CacheStorage, () => makeClient(caches));
+//#endregion
+export { CacheOperationError, CacheStorage, Cache_exports, layer, layerFrom, makeCacheClient, makeClient };

package/dist/CloudflareOtlp.d.mts

@@ -0,0 +1,95 @@
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Layer from "effect/Layer";
+import * as OtlpExporter from "effect/unstable/observability/OtlpExporter";
+import * as OtlpResource from "effect/unstable/observability/OtlpResource";
+import * as Tracer from "effect/Tracer";
+import { Headers } from "effect/unstable/http";
+declare namespace CloudflareOtlp_d_exports {
+  export { DurableObjectLayerOptions, LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };
+}
+type ResourceAttributes = NonNullable<Parameters<typeof OtlpResource.make>[0]["attributes"]>;
+/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
+type Signal = "logs" | "traces" | "metrics";
+/** OTLP payload serialization used by the Effect OTLP exporters. */
+type Serialization = "json" | "protobuf";
+/**
+ * Resource metadata shared by Worker and Durable Object OTLP layers.
+ *
+ * Precedence follows Effect's `OtlpResource.fromConfig`: explicit
+ * `serviceName`/`serviceVersion` win over matching explicit `attributes`, and
+ * explicit attributes win over `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and
+ * `OTEL_RESOURCE_ATTRIBUTES`. Omit an option to let operators set it from the
+ * environment.
+ */
+interface ResourceOptions {
+  /** Explicit service name. Takes precedence over OTEL environment variables. */
+  readonly serviceName?: string;
+  /** Explicit service version. Takes precedence over OTEL environment variables. */
+  readonly serviceVersion?: string;
+  /** Additional resource attributes attached to exported telemetry. */
+  readonly attributes?: ResourceAttributes;
+}
+/** Options shared by all Cloudflare OTLP telemetry layers. */
+interface LayerOptions {
+  /**
+   * Telemetry signals to export. Defaults to logs, traces, and metrics.
+   *
+   * Each selected signal is still controlled by standard OTEL exporter config,
+   * such as `OTEL_TRACES_EXPORTER=otlp`.
+   */
+  readonly signals?: ReadonlyArray<Signal>;
+  /** OTLP payload serialization. Defaults to protobuf. */
+  readonly serialization?: Serialization;
+  readonly resource?: ResourceOptions;
+  readonly headers?: Headers.Input;
+  readonly loggerExcludeLogSpans?: boolean;
+  readonly loggerMergeWithExisting?: boolean;
+  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
+}
+interface WorkerLayerOptions extends LayerOptions {
+  readonly workerName?: string;
+}
+interface DurableObjectLayerOptions extends LayerOptions {
+  readonly className?: string;
+  /**
+   * Include the Durable Object id as `cloudflare.durable_object.id`.
+   *
+   * This is disabled by default because object ids can be high-cardinality.
+   */
+  readonly includeObjectId?: boolean;
+}
+/**
+ * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
+ *
+ * Standard OpenTelemetry environment variables are resolved by Effect's OTLP
+ * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
+ * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
+ * Effect `ConfigProvider` remains the fallback.
+ *
+ * The layer provides {@link OtlpExporter.Flusher} for draining buffered
+ * telemetry before the isolate freezes.
+ */
+declare const layer: (options?: LayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
+/** Base OTLP telemetry layer forced to JSON serialization. */
+declare const layerJson: (options?: Omit<LayerOptions, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+declare const layerProtobuf: (options?: Omit<LayerOptions, "serialization">) => Layer.Layer<OtlpExporter.Flusher>;
+/**
+ * OTLP layer with Cloudflare Worker resource attributes.
+ *
+ * Provide this layer at runtime scope for long-lived metrics aggregation, or at
+ * handler scope when traces/logs should flush as the Cloudflare event finishes.
+ * A handler-scoped exporter can delay scope closure while its own finalizer
+ * flushes; the two-second background flush limit does not bound layer shutdown.
+ */
+declare const layerWorker: (options?: WorkerLayerOptions) => Layer.Layer<OtlpExporter.Flusher>;
+/**
+ * OTLP layer with Cloudflare Durable Object resource attributes.
+ *
+ * The layer reads {@link DurableObjectState} so it can optionally include the
+ * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
+ * backend can tolerate high-cardinality resource attributes.
+ */
+declare const layerDurableObject: (options?: DurableObjectLayerOptions) => Layer.Layer<OtlpExporter.Flusher, never, DurableObjectState>;
+//#endregion
+export { CloudflareOtlp_d_exports, DurableObjectLayerOptions, LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };

package/dist/CloudflareOtlp.mjs

@@ -0,0 +1,125 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { WorkerConfig, WorkerEnvironment } from "./Environment.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Option from "effect/Option";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as OtlpExporter from "effect/unstable/observability/OtlpExporter";
+import * as OtlpLogger from "effect/unstable/observability/OtlpLogger";
+import * as OtlpMetrics from "effect/unstable/observability/OtlpMetrics";
+import "effect/unstable/observability/OtlpResource";
+import * as OtlpSerialization from "effect/unstable/observability/OtlpSerialization";
+import * as OtlpTracer from "effect/unstable/observability/OtlpTracer";
+//#region src/CloudflareOtlp.ts
+/**
+* Worker fetch/queue/RPC and Durable Object alarm/RPC handlers schedule a
+* best-effort flusher. It settles within two seconds; other lifecycles must
+* flush explicitly. Scheduled flush failures cannot fail user events. Exporter
+* layer finalizers run separately and follow their configured shutdown timeout.
+*/
+var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	layerDurableObject: () => layerDurableObject,
+	layerJson: () => layerJson,
+	layerProtobuf: () => layerProtobuf,
+	layerWorker: () => layerWorker
+});
+const allSignals = [
+	"logs",
+	"traces",
+	"metrics"
+];
+const emptyConfigProvider = ConfigProvider.fromUnknown({});
+const cloudflareConfigProviderLayer = ConfigProvider.layerAdd(Effect.map(Effect.serviceOption(WorkerEnvironment), (env) => Option.isSome(env) ? WorkerConfig.providerFromEnv(env.value) : emptyConfigProvider), { asPrimary: true });
+const selectedSignals = (signals) => new Set(signals ?? allSignals);
+const withDefinedAttributes = (attributes) => {
+	const out = {};
+	for (const [key, value] of Object.entries(attributes)) if (value !== void 0) out[key] = value;
+	return out;
+};
+const makeResource = (options, runtimeAttributes) => ({
+	serviceName: options.resource?.serviceName,
+	serviceVersion: options.resource?.serviceVersion,
+	attributes: {
+		...withDefinedAttributes(runtimeAttributes),
+		...options.resource?.attributes
+	}
+});
+const serializationLayer = (serialization) => serialization === "json" ? OtlpSerialization.layerJson : OtlpSerialization.layerProtobuf;
+const mergeSignalLayers = (layers) => {
+	let merged = layers[0];
+	for (let index = 1; index < layers.length; index++) merged = Layer.mergeAll(merged, layers[index]);
+	return merged;
+};
+const makeLayer = (options = {}, runtimeAttributes = {}) => {
+	const signals = selectedSignals(options.signals);
+	const resource = makeResource(options, runtimeAttributes);
+	const layers = [];
+	if (signals.has("logs")) layers.push(OtlpLogger.layerFromConfig({
+		resource,
+		headers: options.headers,
+		excludeLogSpans: options.loggerExcludeLogSpans,
+		mergeWithExisting: options.loggerMergeWithExisting
+	}));
+	if (signals.has("traces")) layers.push(OtlpTracer.layerFromConfig({
+		resource,
+		headers: options.headers,
+		context: options.tracerContext
+	}));
+	if (signals.has("metrics")) layers.push(OtlpMetrics.layerFromConfig({
+		resource,
+		headers: options.headers
+	}));
+	if (layers.length === 0) return OtlpExporter.layerFlusher;
+	return mergeSignalLayers(layers).pipe(Layer.provide(cloudflareConfigProviderLayer), Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer));
+};
+/**
+* Base OTLP telemetry layer for Cloudflare-compatible runtimes.
+*
+* Standard OpenTelemetry environment variables are resolved by Effect's OTLP
+* layers. In Cloudflare Workers and Durable Objects, the current `env` object is
+* installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
+* Effect `ConfigProvider` remains the fallback.
+*
+* The layer provides {@link OtlpExporter.Flusher} for draining buffered
+* telemetry before the isolate freezes.
+*/
+const layer = (options = {}) => makeLayer(options);
+/** Base OTLP telemetry layer forced to JSON serialization. */
+const layerJson = (options = {}) => layer({
+	...options,
+	serialization: "json"
+});
+/** Base OTLP telemetry layer forced to protobuf serialization. */
+const layerProtobuf = (options = {}) => layer({
+	...options,
+	serialization: "protobuf"
+});
+/**
+* OTLP layer with Cloudflare Worker resource attributes.
+*
+* Provide this layer at runtime scope for long-lived metrics aggregation, or at
+* handler scope when traces/logs should flush as the Cloudflare event finishes.
+* A handler-scoped exporter can delay scope closure while its own finalizer
+* flushes; the two-second background flush limit does not bound layer shutdown.
+*/
+const layerWorker = (options = {}) => makeLayer(options, {
+	"cloudflare.resource_type": "worker",
+	"cloudflare.worker.name": options.workerName
+});
+/**
+* OTLP layer with Cloudflare Durable Object resource attributes.
+*
+* The layer reads {@link DurableObjectState} so it can optionally include the
+* Durable Object id. Prefer leaving `includeObjectId` disabled unless the
+* backend can tolerate high-cardinality resource attributes.
+*/
+const layerDurableObject = (options = {}) => Layer.unwrap(Effect.map(DurableObjectState, (state) => makeLayer(options, {
+	"cloudflare.resource_type": "durable_object",
+	"cloudflare.durable_object.class": options.className,
+	"cloudflare.durable_object.id": options.includeObjectId ? state.id.toString() : void 0
+})));
+//#endregion
+export { CloudflareOtlp_exports, layer, layerDurableObject, layerJson, layerProtobuf, layerWorker };

package/dist/CloudflareTracer.d.mts

@@ -0,0 +1,20 @@
+import * as Layer from "effect/Layer";
+declare namespace CloudflareTracer_d_exports {
+  export { layer };
+}
+/**
+ * Sends Effect spans to Cloudflare Workers Observability using the runtime's
+ * custom span API. Build this layer inside each invocation, for example with
+ * `Worker.make(Services, { eventLayer: CloudflareTracer.layer, fetch })`.
+ * It captures the invocation's async context and must not be cached across requests.
+ *
+ * Enable `observability.traces.enabled` in Wrangler. Cloudflare owns sampling
+ * and export; no OTLP exporter or flush is required. Scalar attributes are
+ * forwarded; other attributes, events, and links remain Effect-local. Completion
+ * is recorded as `effect.exit`, since Cloudflare has no outcome-setting API.
+ * Effect trace/span IDs remain independent of Cloudflare's opaque IDs. External
+ * parents and `root: true` cannot override the invocation's Cloudflare trace.
+ */
+declare const layer: Layer.Layer<never>;
+//#endregion
+export { CloudflareTracer_d_exports, layer };

package/dist/CloudflareTracer.mjs

@@ -0,0 +1,69 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { tracing } from "cloudflare:workers";
+import * as Tracer from "effect/Tracer";
+//#region src/CloudflareTracer.ts
+var CloudflareTracer_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+var Span = class extends Tracer.NativeSpan {
+	runInContext;
+	cloudflareSpan;
+	constructor(options, runInContext, cloudflareSpan) {
+		super({
+			...options,
+			sampled: options.sampled && (cloudflareSpan?.isTraced ?? false)
+		});
+		this.runInContext = runInContext;
+		this.cloudflareSpan = cloudflareSpan;
+	}
+	attribute(key, value) {
+		super.attribute(key, value);
+		if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) this.cloudflareSpan?.setAttribute(key, value);
+	}
+	end(endTime, exit) {
+		if (this.status._tag === "Ended") return;
+		super.end(endTime, exit);
+		this.cloudflareSpan?.setAttribute("effect.exit", Exit.isSuccess(exit) ? "success" : Cause.hasInterruptsOnly(exit.cause) ? "interrupted" : "failure");
+		this.cloudflareSpan?.end();
+	}
+};
+/**
+* Sends Effect spans to Cloudflare Workers Observability using the runtime's
+* custom span API. Build this layer inside each invocation, for example with
+* `Worker.make(Services, { eventLayer: CloudflareTracer.layer, fetch })`.
+* It captures the invocation's async context and must not be cached across requests.
+*
+* Enable `observability.traces.enabled` in Wrangler. Cloudflare owns sampling
+* and export; no OTLP exporter or flush is required. Scalar attributes are
+* forwarded; other attributes, events, and links remain Effect-local. Completion
+* is recorded as `effect.exit`, since Cloudflare has no outcome-setting API.
+* Effect trace/span IDs remain independent of Cloudflare's opaque IDs. External
+* parents and `root: true` cannot override the invocation's Cloudflare trace.
+*/
+const layer = Layer.effect(Tracer.Tracer, Effect.sync(() => {
+	const invocationContext = AsyncLocalStorage.snapshot();
+	const contextFor = (span) => {
+		while (span?._tag === "Span") {
+			if (span instanceof Span) return span.runInContext;
+			span = Option.getOrUndefined(span.parent);
+		}
+		return invocationContext;
+	};
+	return Tracer.make({
+		span(options) {
+			const parentContext = options.root ? invocationContext : contextFor(Option.getOrUndefined(options.parent));
+			if (!options.sampled) return new Span(options, parentContext);
+			return parentContext(() => tracing.startActiveSpan(options.name, (span) => new Span(options, AsyncLocalStorage.snapshot(), span)));
+		},
+		context(primitive, fiber) {
+			return contextFor(fiber.currentSpan)(() => primitive["~effect/Effect/evaluate"](fiber));
+		}
+	});
+}));
+//#endregion
+export { CloudflareTracer_exports, layer };

package/dist/ComputerArtifacts.d.mts

@@ -1,5 +1,5 @@
-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-B3r3RuTB.mjs";
-import { Effect } from "effect";
+import { ArtifactsBinding, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsOperationError, ArtifactsRepoInfo, ArtifactsTokenInfo, ArtifactsTokenListResult, RepoName } from "./Artifacts.mjs";
+import * as Effect from "effect/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. */

package/dist/ComputerArtifacts.mjs

@@ -1,5 +1,6 @@
-import { t as ArtifactsOperationError } from "./Artifacts-CBxWGeZB.mjs";
-import { Effect, Predicate } from "effect";
+import { ArtifactsOperationError } from "./Artifacts.mjs";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
 //#region src/ComputerArtifacts.ts
 const artifactsErrorDetails = (cause) => {
 	if (!Predicate.isObject(cause)) return {};

package/dist/ComputerWorkspace.d.mts

@@ -1,8 +1,13 @@
 import { ComputerArtifactsClient } from "./ComputerArtifacts.mjs";
-import { t as DurableObjectState } from "./DurableObjectState-DJ0K-zyd.mjs";
-import { Context, Effect, Layer, Schema, Scope, Stream } from "effect";
+import { DurableObjectState } from "./DurableObjectState.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema$1 from "effect/Schema";
+import * as Layer$1 from "effect/Layer";
+import * as Stream from "effect/Stream";
 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";
+import { Scope } from "effect";
 import { ShareOptions } from "@cloudflare/computer/assets";
 //#region src/ComputerWorkspace.d.ts
 type CloudflareWorkspaceFilesystem = WorkspaceClient["fs"];
@@ -18,12 +23,12 @@ type CloudflareWorkspaceDirentResult = Awaited<ReturnType<CloudflareWorkspaceFil
 type CloudflareWorkspaceStatResult = Awaited<ReturnType<CloudflareWorkspaceFilesystem["stat"]>>;
 type CloudflareWorkspaceFoundEntry = Awaited<ReturnType<CloudflareWorkspaceFilesystem["find"]>>[number];
 type CloudflareWorkspaceGrepMatch = Awaited<ReturnType<CloudflareWorkspaceFilesystem["grep"]>>[number];
-declare const WorkspaceFsError_base: Schema.Class<WorkspaceFsError, Schema.TaggedStruct<"WorkspaceFsError", {
-  readonly operation: Schema.String;
-  readonly path: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
+declare const WorkspaceFsError_base: Schema$1.Class<WorkspaceFsError, Schema$1.TaggedStruct<"WorkspaceFsError", {
+  readonly operation: Schema$1.String;
+  readonly path: Schema$1.String;
+  readonly message: Schema$1.String;
+  readonly code: Schema$1.optionalKey<Schema$1.String>;
+  readonly cause: Schema$1.optionalKey<Schema$1.Defect>;
 }>, import("effect/Cause").YieldableError>;
 /**
  * Workspace errors use `Schema.TaggedError`, unlike most local binding errors,
@@ -31,36 +36,36 @@ declare const WorkspaceFsError_base: Schema.Class<WorkspaceFsError, Schema.Tagge
  * The schema form preserves the operation-family tags across that boundary.
  */
 declare class WorkspaceFsError extends WorkspaceFsError_base {}
-declare const WorkspaceGitError_base: Schema.Class<WorkspaceGitError, Schema.TaggedStruct<"WorkspaceGitError", {
-  readonly operation: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
+declare const WorkspaceGitError_base: Schema$1.Class<WorkspaceGitError, Schema$1.TaggedStruct<"WorkspaceGitError", {
+  readonly operation: Schema$1.String;
+  readonly message: Schema$1.String;
+  readonly code: Schema$1.optionalKey<Schema$1.String>;
+  readonly cause: Schema$1.optionalKey<Schema$1.Defect>;
 }>, import("effect/Cause").YieldableError>;
 /** Schema-serializable error for a workspace Git operation. */
 declare class WorkspaceGitError extends WorkspaceGitError_base {}
-declare const WorkspaceExecError_base: Schema.Class<WorkspaceExecError, Schema.TaggedStruct<"WorkspaceExecError", {
-  readonly operation: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
+declare const WorkspaceExecError_base: Schema$1.Class<WorkspaceExecError, Schema$1.TaggedStruct<"WorkspaceExecError", {
+  readonly operation: Schema$1.String;
+  readonly message: Schema$1.String;
+  readonly code: Schema$1.optionalKey<Schema$1.String>;
+  readonly cause: Schema$1.optionalKey<Schema$1.Defect>;
 }>, import("effect/Cause").YieldableError>;
 /** Schema-serializable error for a workspace runtime operation. */
 declare class WorkspaceExecError extends WorkspaceExecError_base {}
-declare const WorkspaceAssetsError_base: Schema.Class<WorkspaceAssetsError, Schema.TaggedStruct<"WorkspaceAssetsError", {
-  readonly operation: Schema.String;
-  readonly path: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
+declare const WorkspaceAssetsError_base: Schema$1.Class<WorkspaceAssetsError, Schema$1.TaggedStruct<"WorkspaceAssetsError", {
+  readonly operation: Schema$1.String;
+  readonly path: Schema$1.String;
+  readonly message: Schema$1.String;
+  readonly code: Schema$1.optionalKey<Schema$1.String>;
+  readonly cause: Schema$1.optionalKey<Schema$1.Defect>;
 }>, import("effect/Cause").YieldableError>;
 /** Schema-serializable error for a workspace Assets operation. */
 declare class WorkspaceAssetsError extends WorkspaceAssetsError_base {}
-declare const WorkspaceAcquireError_base: Schema.Class<WorkspaceAcquireError, Schema.TaggedStruct<"WorkspaceAcquireError", {
-  readonly operation: Schema.String;
-  readonly message: Schema.String;
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly cause: Schema.optionalKey<Schema.Defect>;
+declare const WorkspaceAcquireError_base: Schema$1.Class<WorkspaceAcquireError, Schema$1.TaggedStruct<"WorkspaceAcquireError", {
+  readonly operation: Schema$1.String;
+  readonly message: Schema$1.String;
+  readonly code: Schema$1.optionalKey<Schema$1.String>;
+  readonly cause: Schema$1.optionalKey<Schema$1.Defect>;
 }>, import("effect/Cause").YieldableError>;
 /** Schema-serializable error while acquiring the Computer workspace client. */
 declare class WorkspaceAcquireError extends WorkspaceAcquireError_base {}
@@ -266,13 +271,13 @@ interface ComputerWorkspaceService {
  * every runtime handle are disposed by Effect `Scope`.
  */
 declare const fromWorkspaceClient: (client: WorkspaceClient) => ComputerWorkspaceService;
-declare const ComputerWorkspace_base: Context.ServiceClass<ComputerWorkspace, "effect-cf/ComputerWorkspace", ComputerWorkspaceService>;
+declare const ComputerWorkspace_base: Context$1.ServiceClass<ComputerWorkspace, "effect-cf/ComputerWorkspace", ComputerWorkspaceService>;
 declare class ComputerWorkspace extends ComputerWorkspace_base {
   /**
    * Acquires the single workspace registered by `withComputerWorkspace` and
    * releases its RPC client when the layer scope closes.
    */
-  static readonly layer: Layer.Layer<ComputerWorkspace, WorkspaceAcquireError, DurableObjectState>;
+  static readonly layer: Layer$1.Layer<ComputerWorkspace, WorkspaceAcquireError, DurableObjectState>;
 }
 //#endregion
 export { ComputerWorkspace, ComputerWorkspaceAssets, ComputerWorkspaceFilesystem, ComputerWorkspaceGit, ComputerWorkspaceRuntime, ComputerWorkspaceService, type ComputerWorkspaceService as ComputerWorkspaceShape, ComputerWorkspaceThink, ListDirectoryOptions, ReadTextFileOptions, RemovePathOptions, WorkspaceAcquireError, 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,12 @@
-import { t as DurableObjectState } from "./DurableObjectState-DLL0YgBd.mjs";
+import { DurableObjectState } from "./DurableObjectState.mjs";
 import { fromClient } from "./ComputerArtifacts.mjs";
-import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
-import { Context, Effect, Layer, Predicate, Schema, Stream } from "effect";
+import { lookup } from "./internal/ComputerWorkspaceHostRegistry.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Layer from "effect/Layer";
+import * as Predicate from "effect/Predicate";
+import * as Stream from "effect/Stream";
 //#region src/ComputerWorkspace.ts
 /**
 * Workspace errors use `Schema.TaggedError`, unlike most local binding errors,

package/dist/ComputerWorkspaceHost.d.mts

@@ -1,4 +1,4 @@
-import { t as ArtifactsBinding } from "./Artifacts-B3r3RuTB.mjs";
+import { ArtifactsBinding } from "./Artifacts.mjs";
 import { GitClientFactory } from "@cloudflare/computer/git";
 import { DurableObjectStorageLike, SyncRetryIntent, SyncRetryOptions, SyncRetryScheduler, WithWorkspaceCtor, WorkspaceAttributeValue, WorkspaceAttributes, WorkspaceObserver, WorkspaceOptions, WorkspaceRegisteredBackend, WorkspaceRetryPendingSyncResult, WorkspaceServiceProxy, WorkspaceSpan } from "@cloudflare/computer";
 import { ShellModuleGroup, WorkerShellBackendOptions, WorkerShellLoader, WorkspaceEgressPolicy } from "@cloudflare/computer/backends/worker-shell";

package/dist/ComputerWorkspaceHost.mjs

@@ -1,4 +1,4 @@
-import { n as register } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
+import { register } from "./internal/ComputerWorkspaceHostRegistry.mjs";
 import { createGitClient } from "@cloudflare/computer/git";
 import { WorkspaceServiceProxy, withWorkspace } from "@cloudflare/computer";
 import { WorkerShellBackend } from "@cloudflare/computer/backends/worker-shell";

package/dist/{ContainerNamespace-DbLaeFhN.d.mts → ContainerNamespace.d.mts}

@@ -1,5 +1,9 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { Context, Effect, Layer, Schema } from "effect";
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import { Layer } from "effect";
 declare namespace ContainerNamespace_d_exports {
   export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };
 }
@@ -29,13 +33,13 @@ interface ContainerStartAndWaitForPortsOptions {
   readonly cancellationOptions?: ContainerReadinessOptions;
 }
 /** Serializable state reported by a Cloudflare Container instance. */
-declare const ContainerState: Schema.Union<readonly [Schema.Struct<{
-  readonly lastChange: Schema.Finite;
-  readonly status: Schema.Literals<readonly ["running", "stopping", "stopped", "healthy"]>;
-}>, Schema.Struct<{
-  readonly lastChange: Schema.Finite;
-  readonly status: Schema.Literal<"stopped_with_code">;
-  readonly exitCode: Schema.optionalKey<Schema.Int>;
+declare const ContainerState: S.Union<readonly [S.Struct<{
+  readonly lastChange: S.Finite;
+  readonly status: S.Literals<readonly ["running", "stopping", "stopped", "healthy"]>;
+}>, S.Struct<{
+  readonly lastChange: S.Finite;
+  readonly status: S.Literal<"stopped_with_code">;
+  readonly exitCode: S.optionalKey<S.Int>;
 }>]>;
 type ContainerState = typeof ContainerState.Type;
 /**
@@ -122,13 +126,13 @@ type ContainerNamespaceStaticClient<R, Namespace extends ContainerNamespaceResou
 type LayerOptions = {
   readonly binding: string;
 };
-interface TagClass<Self, Id extends string, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> extends Context.ServiceClass<Self, `effect-cf/Container/${Id}`, ContainerNamespaceClient<Namespace>>, ContainerNamespaceStaticClient<Self, Namespace> {
+interface TagClass<Self, Id extends string, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource> extends Context$1.ServiceClass<Self, `effect-cf/Container/${Id}`, ContainerNamespaceClient<Namespace>>, ContainerNamespaceStaticClient<Self, Namespace> {
   readonly id: Id;
   readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isContainerNamespaceResource: <Candidate>(value: Candidate) => value is Candidate & ContainerNamespaceResource;
 declare const makeClient: (definition: ContainerNamespaceDefinition) => <Namespace extends ContainerNamespaceResource>(namespace: Namespace) => ContainerNamespaceClient<Namespace>;
-declare const layer: <Self, Namespace extends ContainerNamespaceResource>(tag: Context.Service<Self, ContainerNamespaceClient<Namespace>>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const layer: <Self, Namespace extends ContainerNamespaceResource>(tag: Context$1.Service<Self, ContainerNamespaceClient<Namespace>>, definition: ContainerNamespaceDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make: <Id extends string>(id: Id) => TagClass<ContainerNamespaceService<Id>, Id, ContainerNamespaceResource>;
 declare const ContainerNamespaceServiceTypeId: unique symbol;
 interface ContainerNamespaceService<Id extends string> {
@@ -139,4 +143,4 @@ interface ContainerNamespaceService<Id extends string> {
 declare const Tag: <Self, Namespace extends ContainerNamespaceResource = ContainerNamespaceResource>() => <Id extends string>(id: Id) => TagClass<Self, Id, Namespace>;
 declare const ContainerNamespace: typeof Tag;
 //#endregion
-export { ContainerStartOptions as n, ContainerStopSignal as r, ContainerNamespace_d_exports as t };
+export { ContainerInstanceClient, ContainerNamespace, ContainerNamespaceClient, ContainerNamespaceDefinition, ContainerNamespaceResource, ContainerNamespaceService, ContainerNamespaceStaticClient, ContainerNamespace_d_exports, ContainerOperationError, ContainerReadinessOptions, ContainerSignal, ContainerStartAndWaitForPortsOptions, ContainerStartOptions, ContainerState, ContainerStopSignal, ContainerStub, ContainerStubOf, ContainerWaitOptions, LayerOptions, Tag, TagClass, isContainerNamespaceResource, layer, make, makeClient };