effect-cf 0.25.2 → 0.26.0

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { a as DurableObjectWebSocket_exports, c as causeMessage, d as WorkerConfig, f as WorkerEnvironment, i as fromExecutionContext, l as violationsMessage, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState, u as Environment_exports } from "./DurableObjectState-CEh0DVw7.mjs";
-import { Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema } from "effect";
+import { t as lookup } from "./ComputerWorkspaceHostRegistry-CY5Fv4Ng.mjs";
+import { Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Function as Function$1, Layer, ManagedRuntime, Option, Predicate, Queue, Result, Schema, Stream } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
@@ -15,7 +16,7 @@ var Binding_exports = /* @__PURE__ */ __exportAll({
 	BindingValidationError: () => BindingValidationError,
 	Service: () => Service$2,
 	TypeId: () => TypeId$3,
-	layer: () => layer$19
+	layer: () => layer$20
 });
 /** Internal type id marker used by binding helper services. */
 const TypeId$3 = "~effect-cf/Binding";
@@ -110,7 +111,7 @@ const makeBindingLayer = (tag, binding, isResource, wrap, options) => Layer.effe
 	const resource = yield* getBinding(env, binding, isResource, options);
 	return wrap === void 0 ? resource : wrap(resource);
 }));
-function layer$19(tag, binding, isResource, wrap, options) {
+function layer$20(tag, binding, isResource, wrap, options) {
 	return makeBindingLayer(tag, binding, isResource, wrap, options);
 }
 const Service$2 = () => {
@@ -129,13 +130,13 @@ const Service$2 = () => {
 //#endregion
 //#region src/WorkersAi.ts
 var WorkersAi_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$16,
+	Tag: () => Tag$17,
 	WorkersAiOperationError: () => WorkersAiOperationError,
 	embeddingResponse: () => embeddingResponse,
 	isWorkersAiBinding: () => isWorkersAiBinding,
-	layer: () => layer$18,
-	make: () => make$18,
-	makeClient: () => makeClient$15
+	layer: () => layer$19,
+	make: () => make$19,
+	makeClient: () => makeClient$17
 });
 const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
 /** Error raised when a Workers AI operation fails. */
@@ -157,13 +158,13 @@ const tryWorkersAiSync = (binding, operation, evaluate) => Effect.try({
 	try: evaluate,
 	catch: (cause) => workersAiError(binding, operation, cause)
 });
-const hasFunction$3 = (value, key) => typeof Reflect.get(value, key) === "function";
-const isWorkersAiBinding = (value) => typeof value === "object" && value !== null && hasFunction$3(value, "run") && hasFunction$3(value, "gateway") && hasFunction$3(value, "models");
+const hasFunction$4 = (value, key) => typeof Reflect.get(value, key) === "function";
+const isWorkersAiBinding = (value) => typeof value === "object" && value !== null && hasFunction$4(value, "run") && hasFunction$4(value, "gateway") && hasFunction$4(value, "models");
 const embeddingResponse = (value) => ({
 	data: value.data ?? [],
 	shape: value.shape ?? []
 });
-const makeClient$15 = (definition) => (ai) => {
+const makeClient$17 = (definition) => (ai) => {
 	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => ai.run(model, input, options)));
 	return {
 		definition,
@@ -175,11 +176,11 @@ const makeClient$15 = (definition) => (ai) => {
 		rawUnsafe: Effect.succeed(ai)
 	};
 };
-const layer$18 = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$15(definition), { expected: expectedWorkersAiBinding });
-const make$18 = (id) => Tag$16()(id);
-const Tag$16 = () => (id) => {
+const layer$19 = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$17(definition), { expected: expectedWorkersAiBinding });
+const make$19 = (id) => Tag$17()(id);
+const Tag$17 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$18(tag, definition);
+	const makeLayer = (definition) => layer$19(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -189,11 +190,11 @@ const Tag$16 = () => (id) => {
 //#region src/AiGateway.ts
 var AiGateway_exports = /* @__PURE__ */ __exportAll({
 	AiGatewayOperationError: () => AiGatewayOperationError,
-	Tag: () => Tag$15,
+	Tag: () => Tag$16,
 	isAiGatewayBinding: () => isAiGatewayBinding,
-	layer: () => layer$17,
-	make: () => make$17,
-	makeClient: () => makeClient$14,
+	layer: () => layer$18,
+	make: () => make$18,
+	makeClient: () => makeClient$16,
 	makeClientFromAi: () => makeClientFromAi,
 	makeHttpClient: () => makeHttpClient
 });
@@ -225,7 +226,7 @@ const providerUrl = (baseUrl, path = "") => {
 };
 const gatewayUrl = (definition) => `https://gateway.ai.cloudflare.com/v1/${definition.accountId}/${definition.gatewayId}/`;
 const isAiGatewayBinding = (value) => isWorkersAiBinding(value);
-const makeClient$14 = (definition, gateway) => ({
+const makeClient$16 = (definition, gateway) => ({
 	definition,
 	run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options))),
 	getUrl: Effect.fn("AiGateway.getUrl")((provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider))),
@@ -245,11 +246,11 @@ const makeClientFromAi = (definition, ai) => {
 	const withGateway = (operation) => gateway.pipe(Effect.flatMap(operation));
 	return {
 		definition,
-		run: (data, options) => withGateway((raw) => makeClient$14(definition, raw).run(data, options)),
-		getUrl: (provider) => withGateway((raw) => makeClient$14(definition, raw).getUrl(provider)),
-		fetch: (options) => withGateway((raw) => makeClient$14(definition, raw).fetch(options)),
-		patchLog: (logId, data) => withGateway((raw) => makeClient$14(definition, raw).patchLog(logId, data)),
-		getLog: (logId) => withGateway((raw) => makeClient$14(definition, raw).getLog(logId)),
+		run: (data, options) => withGateway((raw) => makeClient$16(definition, raw).run(data, options)),
+		getUrl: (provider) => withGateway((raw) => makeClient$16(definition, raw).getUrl(provider)),
+		fetch: (options) => withGateway((raw) => makeClient$16(definition, raw).fetch(options)),
+		patchLog: (logId, data) => withGateway((raw) => makeClient$16(definition, raw).patchLog(logId, data)),
+		getLog: (logId) => withGateway((raw) => makeClient$16(definition, raw).getLog(logId)),
 		rawUnsafe: gateway
 	};
 };
@@ -293,11 +294,11 @@ const makeHttpClient = (definition, request = fetch) => {
 		rawUnsafe: Effect.fail(aiGatewayError(binding, "rawUnsafe", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
 	};
 };
-const layer$17 = (tag, definition) => layer$19(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
-const make$17 = (id) => Tag$15()(id);
-const Tag$15 = () => (id) => {
+const layer$18 = (tag, definition) => layer$20(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
+const make$18 = (id) => Tag$16()(id);
+const Tag$16 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$17(tag, definition);
+	const makeLayer = (definition) => layer$18(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -312,13 +313,13 @@ var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
 	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
 	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
 	QueryTag: () => QueryTag,
-	Tag: () => Tag$14,
+	Tag: () => Tag$15,
 	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
-	layer: () => layer$16,
+	layer: () => layer$17,
 	layerFetch: () => layerFetch,
 	layerFetchConfig: () => layerFetchConfig,
-	make: () => make$16,
-	makeClient: () => makeClient$13,
+	make: () => make$17,
+	makeClient: () => makeClient$15,
 	makeQuery: () => makeQuery,
 	makeQueryClient: () => makeQueryClient,
 	queryConfig: () => queryConfig,
@@ -507,7 +508,7 @@ const isAnalyticsEngineDataset = (value) => {
 	if (typeof value !== "object" || value === null) return false;
 	return typeof Reflect.get(value, "writeDataPoint") === "function";
 };
-const makeClient$13 = (definition, defaults) => (dataset) => {
+const makeClient$15 = (definition, defaults) => (dataset) => {
 	return {
 		definition,
 		writeDataPoint: Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
@@ -537,12 +538,12 @@ const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effe
 	return yield* makeQueryClient(definition);
 }));
 const layerFetchConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
-const layer$16 = (tag, definition) => layer$19(tag, definition.binding, isAnalyticsEngineDataset, makeClient$13(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
-const make$16 = (id) => Tag$14()(id);
+const layer$17 = (tag, definition) => layer$20(tag, definition.binding, isAnalyticsEngineDataset, makeClient$15(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
+const make$17 = (id) => Tag$15()(id);
 const makeQuery = (id) => QueryTag()(id);
-const Tag$14 = () => (id) => {
+const Tag$15 = () => (id) => {
 	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$16(tag, definition);
+	const makeLayer = (definition) => layer$17(tag, definition);
 	return Object.assign(tag, {
 		id,
 		layer: makeLayer
@@ -563,6 +564,125 @@ const QueryTag = () => (id) => {
 	});
 };
 //#endregion
+//#region src/Artifacts.ts
+var Artifacts_exports = /* @__PURE__ */ __exportAll({
+	ArtifactsOperationError: () => ArtifactsOperationError,
+	Tag: () => Tag$14,
+	artifactsErrorCodes: () => artifactsErrorCodes,
+	artifactsErrorNumericCodes: () => artifactsErrorNumericCodes,
+	isArtifactsBinding: () => isArtifactsBinding,
+	isArtifactsRepoBinding: () => isArtifactsRepoBinding,
+	layer: () => layer$16,
+	make: () => make$16,
+	makeClient: () => makeClient$14
+});
+const expectedArtifactsBinding = "Artifacts binding with create(), get(), import(), list(), and delete()";
+const expectedArtifactsRepo = "Artifacts repo handle with createToken(), listTokens(), revokeToken(), fork(), log(), readCommit(), and readTree()";
+/** Documented string error codes returned by Cloudflare Artifacts. */
+const artifactsErrorCodes = [
+	"ALREADY_EXISTS",
+	"NOT_FOUND",
+	"IMPORT_IN_PROGRESS",
+	"FORK_IN_PROGRESS",
+	"INVALID_INPUT",
+	"INVALID_REPO_NAME",
+	"INVALID_TTL",
+	"INVALID_URL",
+	"REMOTE_AUTH_REQUIRED",
+	"UPSTREAM_UNAVAILABLE",
+	"MEMORY_LIMIT",
+	"INTERNAL_ERROR"
+];
+/** Documented numeric error codes returned by Cloudflare Artifacts. */
+const artifactsErrorNumericCodes = {
+	ALREADY_EXISTS: 10201,
+	NOT_FOUND: 10200,
+	IMPORT_IN_PROGRESS: 10302,
+	FORK_IN_PROGRESS: 10303,
+	INVALID_INPUT: 10100,
+	INVALID_REPO_NAME: 10101,
+	INVALID_TTL: 10103,
+	INVALID_URL: 10104,
+	REMOTE_AUTH_REQUIRED: 10106,
+	UPSTREAM_UNAVAILABLE: 10401,
+	MEMORY_LIMIT: 10402,
+	INTERNAL_ERROR: 10400
+};
+/** Error raised when a Cloudflare Artifacts operation fails. */
+var ArtifactsOperationError = class extends Data.TaggedError("ArtifactsOperationError") {
+	get message() {
+		const code = this.code === void 0 ? "" : ` (${this.code})`;
+		return `Artifacts ${this.operation} failed for binding "${this.binding}"${code}: ${causeMessage(this.cause)}`;
+	}
+};
+const artifactsErrorDetails$1 = (cause) => {
+	if (typeof cause !== "object" || cause === null) return {};
+	const code = Reflect.get(cause, "code");
+	const numericCode = Reflect.get(cause, "numericCode");
+	return {
+		...typeof code === "string" ? { code } : {},
+		...typeof numericCode === "number" ? { numericCode } : {}
+	};
+};
+const artifactsError = (binding, operation, cause) => new ArtifactsOperationError({
+	binding,
+	operation,
+	cause,
+	...artifactsErrorDetails$1(cause)
+});
+const tryArtifactsPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => artifactsError(binding, operation, cause)
+});
+const spanOptions$4 = (binding, operation) => ({ attributes: {
+	binding,
+	operation
+} });
+const hasFunction$3 = (value, key) => typeof Reflect.get(value, key) === "function";
+/** Tests whether a value exposes the complete documented Artifacts repo handle API. */
+const isArtifactsRepoBinding = (value) => typeof value === "object" && value !== null && hasFunction$3(value, "createToken") && hasFunction$3(value, "listTokens") && hasFunction$3(value, "revokeToken") && hasFunction$3(value, "fork") && hasFunction$3(value, "log") && hasFunction$3(value, "readCommit") && hasFunction$3(value, "readTree");
+/** Tests whether a value exposes the complete documented Artifacts namespace API. */
+const isArtifactsBinding = (value) => typeof value === "object" && value !== null && hasFunction$3(value, "create") && hasFunction$3(value, "get") && hasFunction$3(value, "import") && hasFunction$3(value, "list") && hasFunction$3(value, "delete");
+const wrapRepo = (binding, repo) => ({
+	id: repo.id,
+	name: repo.name,
+	description: repo.description,
+	defaultBranch: repo.defaultBranch,
+	createdAt: repo.createdAt,
+	updatedAt: repo.updatedAt,
+	lastPushAt: repo.lastPushAt,
+	source: repo.source,
+	readOnly: repo.readOnly,
+	remote: repo.remote,
+	createToken: Effect.fn("Artifacts.createToken", spanOptions$4(binding, "createToken"))((scope, ttl) => tryArtifactsPromise(binding, "createToken", () => repo.createToken(scope, ttl))),
+	listTokens: tryArtifactsPromise(binding, "listTokens", () => repo.listTokens()).pipe(Effect.withSpan("Artifacts.listTokens", spanOptions$4(binding, "listTokens"))),
+	revokeToken: Effect.fn("Artifacts.revokeToken", spanOptions$4(binding, "revokeToken"))((tokenOrId) => tryArtifactsPromise(binding, "revokeToken", () => repo.revokeToken(tokenOrId))),
+	fork: Effect.fn("Artifacts.fork", spanOptions$4(binding, "fork"))((name, options) => tryArtifactsPromise(binding, "fork", () => repo.fork(name, options))),
+	log: Effect.fn("Artifacts.log", spanOptions$4(binding, "log"))((options) => tryArtifactsPromise(binding, "log", () => repo.log(options))),
+	readCommit: Effect.fn("Artifacts.readCommit", spanOptions$4(binding, "readCommit"))((hash) => tryArtifactsPromise(binding, "readCommit", () => repo.readCommit(hash))),
+	readTree: Effect.fn("Artifacts.readTree", spanOptions$4(binding, "readTree"))((hash) => tryArtifactsPromise(binding, "readTree", () => repo.readTree(hash))),
+	raw: repo
+});
+const makeClient$14 = (definition) => (artifacts) => ({
+	definition,
+	create: Effect.fn("Artifacts.create", spanOptions$4(definition.binding, "create"))((name, options) => tryArtifactsPromise(definition.binding, "create", () => artifacts.create(name, options))),
+	get: Effect.fn("Artifacts.get", spanOptions$4(definition.binding, "get"))((name) => tryArtifactsPromise(definition.binding, "get", () => artifacts.get(name)).pipe(Effect.flatMap((repo) => isArtifactsRepoBinding(repo) ? Effect.succeed(wrapRepo(definition.binding, repo)) : Effect.fail(artifactsError(definition.binding, "get", /* @__PURE__ */ new TypeError(`Expected ${expectedArtifactsRepo}`)))))),
+	import: Effect.fn("Artifacts.import", spanOptions$4(definition.binding, "import"))((params) => tryArtifactsPromise(definition.binding, "import", () => artifacts.import(params))),
+	list: Effect.fn("Artifacts.list", spanOptions$4(definition.binding, "list"))((options) => tryArtifactsPromise(definition.binding, "list", () => artifacts.list(options))),
+	delete: Effect.fn("Artifacts.delete", spanOptions$4(definition.binding, "delete"))((name) => tryArtifactsPromise(definition.binding, "delete", () => artifacts.delete(name))),
+	rawUnsafe: Effect.succeed(artifacts)
+});
+const layer$16 = (tag, definition) => layer$20(tag, definition.binding, isArtifactsBinding, makeClient$14(definition), { expected: expectedArtifactsBinding });
+const make$16 = (id) => Tag$14()(id);
+const Tag$14 = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer$16(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
 //#region src/BrowserRendering.ts
 var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
@@ -570,7 +690,7 @@ var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
 	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
 	layer: () => layer$15,
 	make: () => make$15,
-	makeClient: () => makeClient$12
+	makeClient: () => makeClient$13
 });
 const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
 /** Error raised when a Browser Rendering operation fails. */
@@ -611,13 +731,13 @@ const wrapBrowser = (binding, browser) => ({
 	disconnect: browser.disconnect === void 0 ? Effect.void : tryBrowserRenderingSync(binding, "disconnect", () => browser.disconnect())
 });
 const isBrowserRenderingBinding = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
-const makeClient$12 = (definition) => (binding) => ({
+const makeClient$13 = (definition) => (binding) => ({
 	definition,
 	launchWith: (launch, options) => tryBrowserRenderingPromise(definition.binding, "launch", () => launch(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.launchWith")),
 	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.connectWith")),
 	rawUnsafe: Effect.succeed(binding)
 });
-const layer$15 = (tag, definition) => layer$19(tag, definition.binding, isBrowserRenderingBinding, makeClient$12(definition), { expected: expectedBrowserRenderingBinding });
+const layer$15 = (tag, definition) => layer$20(tag, definition.binding, isBrowserRenderingBinding, makeClient$13(definition), { expected: expectedBrowserRenderingBinding });
 const make$15 = (id) => Tag$13()(id);
 const Tag$13 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -635,7 +755,7 @@ var Cache_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer$14,
 	layerFrom: () => layerFrom,
 	makeCacheClient: () => makeCacheClient,
-	makeClient: () => makeClient$11
+	makeClient: () => makeClient$12
 });
 /** Error raised when a Cloudflare Cache API operation fails. */
 var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {
@@ -654,28 +774,28 @@ const tryCachePromise = (cache, operation, evaluate) => Effect.tryPromise({
 	try: evaluate,
 	catch: (cause) => cacheError(cache, operation, cause)
 });
-const spanOptions$2 = (cache, operation) => ({ attributes: {
+const spanOptions$3 = (cache, operation) => ({ attributes: {
 	cache,
 	operation
 } });
 /** Wraps a native Cloudflare `Cache` instance. */
 const makeCacheClient = (cache, name = "default") => ({
 	name,
-	match: Effect.fn("Cache.match", spanOptions$2(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
-	put: Effect.fn("Cache.put", spanOptions$2(name, "put"))((request, response) => tryCachePromise(name, "put", () => cache.put(request, response))),
-	delete: Effect.fn("Cache.delete", spanOptions$2(name, "delete"))((request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options))),
+	match: Effect.fn("Cache.match", spanOptions$3(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
+	put: Effect.fn("Cache.put", spanOptions$3(name, "put"))((request, response) => tryCachePromise(name, "put", () => cache.put(request, response))),
+	delete: Effect.fn("Cache.delete", spanOptions$3(name, "delete"))((request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options))),
 	rawUnsafe: Effect.succeed(cache)
 });
 /** Wraps a native Cloudflare `CacheStorage` instance. */
-const makeClient$11 = (storage) => ({
+const makeClient$12 = (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$2(name, "open"))),
+	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name)), Effect.withSpan("Cache.open", spanOptions$3(name, "open"))),
 	rawUnsafe: Effect.succeed(storage)
 });
 /** Provides Cache API services from an explicit native `CacheStorage` instance. */
-const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$11(storage));
+const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$12(storage));
 /** Provides Cache API services from Cloudflare's global `caches` object. */
-const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
+const layer$14 = Layer.sync(CacheStorage, () => makeClient$12(caches));
 //#endregion
 //#region src/CloudflareOtlp.ts
 /**
@@ -683,8 +803,9 @@ const layer$14 = Layer.sync(CacheStorage, () => makeClient$11(caches));
 *
 * Every layer exposes {@link OtlpExporter.Flusher}, which drains buffered
 * telemetry on demand. Cloudflare isolates can freeze before the periodic
-* export interval fires. Effect-backed Worker fetch handlers and Worker or
-* Durable Object native RPC handlers schedule this flusher automatically.
+* export interval fires. Effect-backed Worker fetch handlers, Worker or
+* Durable Object native RPC handlers, and Durable Object alarm handlers
+* schedule this flusher automatically.
 * Flush or scheduling failures do not replace the handler outcome and emit
 * only bounded framework diagnostics without attaching the foreign cause.
 * Other entrypoint lifecycles can flush explicitly or hand the flush to their
@@ -798,6 +919,650 @@ const layerDurableObject = (options = {}) => Layer.unwrap(Effect.map(DurableObje
 	"cloudflare.durable_object.id": options.includeObjectId ? state.id.toString() : void 0
 })));
 //#endregion
+//#region src/ComputerArtifacts.ts
+var ComputerArtifacts_exports = /* @__PURE__ */ __exportAll({
+	fromClient: () => fromClient,
+	makeClient: () => makeClient$11
+});
+const artifactsErrorDetails = (cause) => {
+	if (typeof cause !== "object" || cause === null) return {};
+	const code = Reflect.get(cause, "code");
+	const numericCode = Reflect.get(cause, "numericCode");
+	return {
+		...typeof code === "string" ? { code } : {},
+		...typeof numericCode === "number" ? { numericCode } : {}
+	};
+};
+const operationError = (binding, operation, cause) => new ArtifactsOperationError({
+	binding,
+	operation,
+	cause,
+	...artifactsErrorDetails(cause)
+});
+const tryOperation = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => operationError(binding, operation, cause)
+});
+const spanOptions$2 = (binding, sessionId, operation) => ({ attributes: {
+	binding,
+	sessionId,
+	operation
+} });
+/** Wraps an already-created upstream session client. */
+const fromClient = (client, options = {}) => {
+	const binding = options.binding ?? "ARTIFACTS";
+	const { sessionId } = client;
+	return {
+		sessionId,
+		create: Effect.fn("ComputerArtifacts.create", spanOptions$2(binding, sessionId, "create"))(function* (name, createOptions) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "create", () => client.create(name, createOptions));
+		}),
+		get: Effect.fn("ComputerArtifacts.get", spanOptions$2(binding, sessionId, "get"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "get", () => client.get(name));
+		}),
+		list: tryOperation(binding, "list", () => client.list()).pipe(Effect.withSpan("ComputerArtifacts.list", spanOptions$2(binding, sessionId, "list"))),
+		import: Effect.fn("ComputerArtifacts.import", spanOptions$2(binding, sessionId, "import"))(function* (name, source, importOptions) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "import", () => client.import(name, source, importOptions));
+		}),
+		delete: Effect.fn("ComputerArtifacts.delete", spanOptions$2(binding, sessionId, "delete"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "delete", () => client.delete(name));
+		}),
+		createToken: Effect.fn("ComputerArtifacts.createToken", spanOptions$2(binding, sessionId, "createToken"))(function* (name, scope, ttl) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "createToken", () => client.createToken(name, scope, ttl));
+		}),
+		listTokens: Effect.fn("ComputerArtifacts.listTokens", spanOptions$2(binding, sessionId, "listTokens"))(function* (name) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "listTokens", () => client.listTokens(name));
+		}),
+		getToken: Effect.fn("ComputerArtifacts.getToken", spanOptions$2(binding, sessionId, "getToken"))(function* (name, id) {
+			yield* Effect.annotateCurrentSpan({
+				repo: name,
+				tokenId: id
+			});
+			return yield* tryOperation(binding, "getToken", () => client.getToken(name, id));
+		}),
+		revokeToken: Effect.fn("ComputerArtifacts.revokeToken", spanOptions$2(binding, sessionId, "revokeToken"))(function* (name, tokenOrId) {
+			yield* Effect.annotateCurrentSpan("repo", name);
+			return yield* tryOperation(binding, "revokeToken", () => client.revokeToken(name, tokenOrId));
+		}),
+		cli: Effect.fn("ComputerArtifacts.cli", spanOptions$2(binding, sessionId, "cli"))(function* (input) {
+			yield* Effect.annotateCurrentSpan("argv", input.argv.join(" "));
+			return yield* tryOperation(binding, "cli", () => client.cli(input));
+		}),
+		rawUnsafe: Effect.succeed(client)
+	};
+};
+/**
+* Creates an Effect-native session client directly from a Worker Artifacts
+* binding. `@cloudflare/computer` is loaded only when this Effect runs, keeping
+* the optional peer out of applications that do not use this integration.
+*/
+const makeClient$11 = Effect.fn("ComputerArtifacts.makeClient")(function* (bindingValue, sessionId, options = {}) {
+	const binding = options.binding ?? "ARTIFACTS";
+	const computerArtifacts = yield* Effect.tryPromise({
+		try: () => import("@cloudflare/computer/artifacts"),
+		catch: (cause) => operationError(binding, "createClient", cause)
+	});
+	const client = yield* Effect.try({
+		try: () => computerArtifacts.createArtifact(bindingValue, sessionId),
+		catch: (cause) => operationError(binding, "createClient", cause)
+	});
+	return fromClient(client, { binding });
+});
+//#endregion
+//#region src/ComputerWorkspace.ts
+var ComputerWorkspace_exports = /* @__PURE__ */ __exportAll({
+	ComputerWorkspace: () => ComputerWorkspace,
+	WorkspaceAssetsError: () => WorkspaceAssetsError,
+	WorkspaceExecError: () => WorkspaceExecError,
+	WorkspaceFsError: () => WorkspaceFsError,
+	WorkspaceGitError: () => WorkspaceGitError,
+	fromWorkspaceClient: () => fromWorkspaceClient
+});
+/**
+* Workspace errors use `Schema.TaggedError`, unlike most local binding errors,
+* because workspace operations commonly sit behind Durable Object RPC methods.
+* The schema form preserves the operation-family tags across that boundary.
+*/
+var WorkspaceFsError = class extends Schema.TaggedError()("WorkspaceFsError", {
+	operation: Schema.String,
+	path: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+/** Schema-serializable error for a workspace Git operation. */
+var WorkspaceGitError = class extends Schema.TaggedError()("WorkspaceGitError", {
+	operation: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+/** Schema-serializable error for a workspace runtime operation. */
+var WorkspaceExecError = class extends Schema.TaggedError()("WorkspaceExecError", {
+	operation: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+/** Schema-serializable error for a workspace Assets operation. */
+var WorkspaceAssetsError = class extends Schema.TaggedError()("WorkspaceAssetsError", {
+	operation: Schema.String,
+	path: Schema.String,
+	message: Schema.String,
+	code: Schema.optionalKey(Schema.String),
+	cause: Schema.optionalKey(Schema.Defect({ includeStack: true }))
+}) {};
+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;
+};
+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)
+});
+const isNotFound = (error) => error.code === "ENOENT" || /ENOENT|no such/i.test(error.message);
+const makeFilesystem = (fsClient) => {
+	const readFile = Effect.fn("ComputerWorkspace.fs.readFile", { attributes: {
+		family: "fs",
+		operation: "readFile"
+	} })(function* (path, options = {}) {
+		yield* Effect.annotateCurrentSpan("path", path);
+		const { encoding = "utf8", ...readOptions } = options;
+		if (encoding === "stream") return yield* tryFs("readFile", path, () => fsClient.readFile(path, readOptions));
+		return yield* tryFs("readFile", path, () => fsClient.readFile(path, {
+			...readOptions,
+			encoding: "utf8"
+		}));
+	});
+	const stat = Effect.fn("ComputerWorkspace.fs.stat", { attributes: {
+		family: "fs",
+		operation: "stat"
+	} })(function* (path) {
+		yield* Effect.annotateCurrentSpan("path", path);
+		return yield* tryFs("stat", path, () => fsClient.stat(path));
+	});
+	return {
+		readFile,
+		stat,
+		lstat: Effect.fn("ComputerWorkspace.fs.lstat", { attributes: {
+			family: "fs",
+			operation: "lstat"
+		} })(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* tryFs("lstat", path, () => fsClient.lstat(path));
+		}),
+		exists: Effect.fn("ComputerWorkspace.fs.exists", { attributes: {
+			family: "fs",
+			operation: "exists"
+		} })(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* stat(path).pipe(Effect.as(true), Effect.catch((error) => isNotFound(error) ? Effect.succeed(false) : Effect.fail(error)));
+		}),
+		readlink: Effect.fn("ComputerWorkspace.fs.readlink", { attributes: {
+			family: "fs",
+			operation: "readlink"
+		} })(function* (path) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* tryFs("readlink", path, () => fsClient.readlink(path));
+		}),
+		readdir: Effect.fn("ComputerWorkspace.fs.readdir", { attributes: {
+			family: "fs",
+			operation: "readdir"
+		} })(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			return yield* tryFs("readdir", path, () => fsClient.readdir(path, options));
+		}),
+		find: Effect.fn("ComputerWorkspace.fs.find", { attributes: {
+			family: "fs",
+			operation: "find"
+		} })(function* (directory, pattern, options) {
+			yield* Effect.annotateCurrentSpan({
+				path: directory,
+				pattern
+			});
+			return yield* tryFs("find", directory, () => fsClient.find(directory, pattern, options));
+		}),
+		ls: Effect.fn("ComputerWorkspace.fs.ls", { attributes: {
+			family: "fs",
+			operation: "ls"
+		} })(function* (prefix) {
+			yield* Effect.annotateCurrentSpan("path", prefix);
+			return yield* tryFs("ls", prefix, () => fsClient.ls(prefix));
+		}),
+		grep: Effect.fn("ComputerWorkspace.fs.grep", { attributes: {
+			family: "fs",
+			operation: "grep"
+		} })(function* (pattern, path, options) {
+			yield* Effect.annotateCurrentSpan({
+				path,
+				pattern
+			});
+			return yield* tryFs("grep", path, () => fsClient.grep(pattern, path, options));
+		}),
+		writeFile: Effect.fn("ComputerWorkspace.fs.writeFile", { attributes: {
+			family: "fs",
+			operation: "writeFile"
+		} })(function* (path, content, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			yield* tryFs("writeFile", path, () => fsClient.writeFile(path, content, options));
+		}),
+		mkdir: Effect.fn("ComputerWorkspace.fs.mkdir", { attributes: {
+			family: "fs",
+			operation: "mkdir"
+		} })(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			yield* tryFs("mkdir", path, () => fsClient.mkdir(path, options));
+		}),
+		rm: Effect.fn("ComputerWorkspace.fs.rm", { attributes: {
+			family: "fs",
+			operation: "rm"
+		} })(function* (path, options) {
+			yield* Effect.annotateCurrentSpan("path", path);
+			yield* tryFs("rm", path, () => fsClient.rm(path, options));
+		}),
+		chmod: Effect.fn("ComputerWorkspace.fs.chmod", { attributes: {
+			family: "fs",
+			operation: "chmod"
+		} })(function* (path, mode) {
+			yield* Effect.annotateCurrentSpan({
+				path,
+				mode
+			});
+			yield* tryFs("chmod", path, () => fsClient.chmod(path, mode));
+		}),
+		symlink: Effect.fn("ComputerWorkspace.fs.symlink", { attributes: {
+			family: "fs",
+			operation: "symlink"
+		} })(function* (target, path) {
+			yield* Effect.annotateCurrentSpan({
+				path,
+				target
+			});
+			yield* tryFs("symlink", path, () => fsClient.symlink(target, path));
+		})
+	};
+};
+const gitPerson = (person) => ({
+	...person,
+	timestampSeconds: person.timestamp
+});
+const gitCommit = (commit) => ({
+	oid: commit.oid,
+	message: commit.message,
+	tree: commit.tree,
+	parent: commit.parent,
+	parents: commit.parent,
+	author: gitPerson(commit.author),
+	committer: gitPerson(commit.committer)
+});
+const makeGit = (gitClient) => {
+	const method = (operation, evaluate) => Effect.fn(`ComputerWorkspace.git.${operation}`, { attributes: {
+		family: "git",
+		operation
+	} })(function* (...args) {
+		return yield* Effect.tryPromise({
+			try: () => evaluate(...args),
+			catch: (cause) => gitError(operation, cause)
+		});
+	});
+	const log = Effect.fn("ComputerWorkspace.git.log", { attributes: {
+		family: "git",
+		operation: "log"
+	} })(function* (options) {
+		const { maxCount, ...upstreamOptions } = options ?? {};
+		return (yield* Effect.tryPromise({
+			try: () => gitClient.log({
+				...upstreamOptions,
+				...upstreamOptions.depth === void 0 && maxCount !== void 0 ? { depth: maxCount } : {}
+			}),
+			catch: (cause) => gitError("log", cause)
+		})).map(gitCommit);
+	});
+	const revParse = Effect.fn("ComputerWorkspace.git.revParse", { attributes: {
+		family: "git",
+		operation: "revParse"
+	} })(function* (input) {
+		const options = typeof input === "string" ? { ref: input } : input;
+		return yield* Effect.tryPromise({
+			try: () => gitClient.revParse(options),
+			catch: (cause) => gitError("revParse", cause)
+		});
+	});
+	return {
+		clone: method("clone", (options) => gitClient.clone(options)),
+		diff: method("diff", (options) => gitClient.diff(options)),
+		diffSummary: method("diffSummary", (options) => gitClient.diffSummary(options)),
+		init: method("init", (options) => gitClient.init(options)),
+		status: method("status", (options) => gitClient.status(options)),
+		add: method("add", (options) => gitClient.add(options)),
+		rm: method("rm", (options) => gitClient.rm(options)),
+		commit: method("commit", (options) => gitClient.commit(options)),
+		log,
+		show: method("show", (options) => gitClient.show(options)),
+		revParse,
+		repoRoot: method("repoRoot", (options) => gitClient.repoRoot(options)),
+		currentBranch: method("currentBranch", (options) => gitClient.currentBranch(options)),
+		lsFiles: method("lsFiles", (options) => gitClient.lsFiles(options)),
+		lsTree: method("lsTree", (options) => gitClient.lsTree(options)),
+		branch: method("branch", (options) => gitClient.branch(options)),
+		branchDelete: method("branchDelete", (options) => gitClient.branchDelete(options)),
+		branchList: method("branchList", (options) => gitClient.branchList(options)),
+		tag: method("tag", (options) => gitClient.tag(options)),
+		tagDelete: method("tagDelete", (options) => gitClient.tagDelete(options)),
+		tagList: method("tagList", (options) => gitClient.tagList(options)),
+		checkout: method("checkout", (options) => gitClient.checkout(options)),
+		fetch: method("fetch", (options) => gitClient.fetch(options)),
+		push: method("push", (options) => gitClient.push(options)),
+		pull: method("pull", (options) => gitClient.pull(options)),
+		merge: method("merge", (options) => gitClient.merge(options)),
+		remoteAdd: method("remoteAdd", (options) => gitClient.remoteAdd(options)),
+		remoteRemove: method("remoteRemove", (options) => gitClient.remoteRemove(options)),
+		remoteList: method("remoteList", (options) => gitClient.remoteList(options)),
+		hashObject: method("hashObject", (options) => gitClient.hashObject(options)),
+		catFile: method("catFile", (options) => gitClient.catFile(options)),
+		updateRef: method("updateRef", (options) => gitClient.updateRef(options)),
+		configGet: method("configGet", (options) => gitClient.configGet(options)),
+		configSet: method("configSet", (options) => gitClient.configSet(options)),
+		stashPush: method("stashPush", (options) => gitClient.stashPush(options)),
+		stashList: method("stashList", (options) => gitClient.stashList(options)),
+		stashPop: method("stashPop", (options) => gitClient.stashPop(options)),
+		reset: method("reset", (options) => gitClient.reset(options)),
+		clean: method("clean", (options) => gitClient.clean(options)),
+		cli: method("cli", (input) => gitClient.cli(input))
+	};
+};
+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 runtimeGetOptions = (options) => {
+	const { encoding = "utf8", ...rest } = options ?? {};
+	return {
+		...rest,
+		...encoding === "utf8" ? { encoding: "utf8" } : {}
+	};
+};
+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" ? {
+				_tag: "Stdout",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				text: chunk
+			} : {
+				_tag: "Stdout",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				bytes: chunk
+			};
+		}
+		case "stderr": {
+			const chunk = event.value;
+			return typeof chunk === "string" ? {
+				_tag: "Stderr",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				text: chunk
+			} : {
+				_tag: "Stderr",
+				id: event.id,
+				sequence: event.seq,
+				chunk,
+				bytes: chunk
+			};
+		}
+		case "exit": return {
+			_tag: "Exit",
+			id: event.id,
+			sequence: event.seq,
+			exitCode: event.code,
+			...event.result === void 0 ? {} : { value: event.result }
+		};
+	}
+};
+const wrapRun = (handle) => {
+	const events = Stream.fromReadableStream({
+		evaluate: () => handle,
+		onError: (cause) => execError("events", cause)
+	}).pipe(Stream.map(wrapRuntimeEvent));
+	const result = Effect.tryPromise({
+		try: () => handle.result(),
+		catch: (cause) => execError("result", cause)
+	}).pipe(Effect.map(wrapRuntimeResult));
+	const kill = Effect.fn("ComputerWorkspace.runtime.run.kill", { attributes: {
+		family: "runtime",
+		operation: "run.kill",
+		runId: handle.id
+	} })(function* (signal) {
+		yield* Effect.tryPromise({
+			try: () => handle.kill(signal),
+			catch: (cause) => execError("run.kill", cause)
+		});
+	});
+	return {
+		id: handle.id,
+		backend: handle.backend,
+		events,
+		result,
+		kill
+	};
+};
+const releaseRun = (handle) => Effect.sync(() => handle[Symbol.dispose]());
+const makeRuntime = (client) => {
+	const execImplementation = Effect.fn("ComputerWorkspace.runtime.exec", { attributes: {
+		family: "runtime",
+		operation: "exec"
+	} })(function* (source, optionsOrValue, ...remainingValues) {
+		const options = typeof source === "string" ? 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));
+				const values = optionsOrValue === void 0 ? remainingValues : [optionsOrValue, ...remainingValues];
+				return client.runtime.exec(source, ...values);
+			},
+			catch: (cause) => execError("exec", cause)
+		}), releaseRun);
+		return wrapRun(handle);
+	});
+	const exec = execImplementation;
+	const getExec = Effect.fn("ComputerWorkspace.runtime.getExec", { attributes: {
+		family: "runtime",
+		operation: "getExec"
+	} })(function* (id, options) {
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: id
+		});
+		const handle = yield* Effect.acquireRelease(Effect.tryPromise({
+			try: () => client.runtime.getExec(id, runtimeGetOptions(options)),
+			catch: (cause) => execError("getExec", cause)
+		}), releaseRun);
+		return wrapRun(handle);
+	});
+	const killExec = Effect.fn("ComputerWorkspace.runtime.killExec", { attributes: {
+		family: "runtime",
+		operation: "killExec"
+	} })(function* (id, options) {
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: id
+		});
+		yield* Effect.tryPromise({
+			try: () => client.runtime.killExec(id, options),
+			catch: (cause) => execError("killExec", cause)
+		});
+	});
+	const disposeExec = Effect.fn("ComputerWorkspace.runtime.disposeExec", { attributes: {
+		family: "runtime",
+		operation: "disposeExec"
+	} })(function* (id, options) {
+		yield* Effect.annotateCurrentSpan({
+			backend: options?.backend,
+			runId: id
+		});
+		yield* Effect.tryPromise({
+			try: () => client.runtime.disposeExec(id, options),
+			catch: (cause) => execError("disposeExec", cause)
+		});
+	});
+	return {
+		exec,
+		execCollect: Effect.fn("ComputerWorkspace.runtime.execCollect", { attributes: {
+			family: "runtime",
+			operation: "execCollect"
+		} })(function* (source, optionsOrValue, ...remainingValues) {
+			return yield* Effect.scoped(Effect.gen(function* () {
+				return yield* (yield* execImplementation(source, optionsOrValue, ...remainingValues)).result;
+			}));
+		}),
+		getExec,
+		killExec,
+		disposeExec
+	};
+};
+const makeAssets = (client) => client === void 0 ? void 0 : { share: Effect.fn("ComputerWorkspace.assets.share", { attributes: {
+	family: "assets",
+	operation: "share"
+} })(function* (path, options) {
+	yield* Effect.annotateCurrentSpan("path", path);
+	return yield* Effect.tryPromise({
+		try: () => client.share(path, options),
+		catch: (cause) => assetsError("share", path, cause)
+	});
+}) };
+const makeThink = (client) => {
+	if (client.readFile === void 0 || client.readFileBytes === void 0 || client.writeFile === void 0 || client.readDir === void 0 || client.rm === void 0 || client.glob === void 0 || client.mkdir === void 0 || client.stat === void 0) return;
+	const method = (operation, pathOf, evaluate) => Effect.fn(`ComputerWorkspace.think.${operation}`, { attributes: {
+		family: "think",
+		operation
+	} })(function* (...args) {
+		const path = pathOf(...args);
+		yield* Effect.annotateCurrentSpan("path", path);
+		return yield* tryFs(`think.${operation}`, path, () => evaluate(...args));
+	});
+	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))
+	};
+};
+/**
+* Wraps a client whose lifetime is owned by the caller. Prefer
+* {@link ComputerWorkspace.layer} in Durable Objects so the parent client and
+* every runtime handle are disposed by Effect `Scope`.
+*/
+const fromWorkspaceClient = (client) => {
+	const fs = makeFilesystem(client.fs);
+	const git = makeGit(client.git);
+	const runtime = makeRuntime(client);
+	return {
+		fs,
+		git,
+		runtime,
+		artifacts: fromClient(client.artifacts, { binding: "ComputerWorkspace.artifacts" }),
+		assets: makeAssets(client.assets),
+		think: makeThink(client),
+		readFile: fs.readFile,
+		stat: fs.stat,
+		lstat: fs.lstat,
+		exists: fs.exists,
+		readlink: fs.readlink,
+		readdir: fs.readdir,
+		listDirectory: fs.readdir,
+		find: fs.find,
+		ls: fs.ls,
+		grep: fs.grep,
+		writeFile: fs.writeFile,
+		mkdir: fs.mkdir,
+		rm: fs.rm,
+		removePath: fs.rm,
+		chmod: fs.chmod,
+		symlink: fs.symlink,
+		exec: runtime.exec,
+		execCollect: runtime.execCollect,
+		getExec: runtime.getExec,
+		killExec: runtime.killExec,
+		disposeExec: runtime.disposeExec
+	};
+};
+/** Effect service for the workspace owned by the enclosing Durable Object. */
+var ComputerWorkspace = class ComputerWorkspace extends Context.Service()("effect-cf/ComputerWorkspace") {
+	/**
+	* Acquires the single workspace registered by `withComputerWorkspace` and
+	* releases its RPC client when the layer scope closes.
+	*/
+	static layer = Layer.effect(ComputerWorkspace, Effect.gen(function* () {
+		const host = lookup((yield* DurableObjectState).raw);
+		if (host === void 0) return yield* Effect.die("ComputerWorkspace.layer requires a Durable Object class built with withComputerWorkspace");
+		const computer = yield* Effect.promise(() => import("@cloudflare/computer"));
+		const client = yield* Effect.acquireRelease(Effect.promise(() => computer.getWorkspace(host)), (workspace) => Effect.sync(() => workspace[Symbol.dispose]()));
+		return ComputerWorkspace.of(fromWorkspaceClient(client));
+	}));
+};
+//#endregion
 //#region src/ContainerNamespace.ts
 var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
 	ContainerNamespace: () => ContainerNamespace,
@@ -920,7 +1685,7 @@ const makeClient$10 = (definition) => (namespace) => {
 		rawUnsafe: Effect.succeed(namespace)
 	};
 };
-const layer$12 = (tag, definition) => layer$19(tag, definition.binding, isContainerNamespaceResource, makeClient$10(definition), { expected: expectedContainerNamespace });
+const layer$12 = (tag, definition) => layer$20(tag, definition.binding, isContainerNamespaceResource, makeClient$10(definition), { expected: expectedContainerNamespace });
 const make$14 = (id) => Tag$12()(id);
 /** Creates a typed Effect service for a Cloudflare Container namespace. */
 const Tag$12 = () => (id) => {
@@ -1066,7 +1831,7 @@ const makeClient$9 = (definition) => {
 		rawUnsafe: Effect.succeed(queue)
 	});
 };
-const layer$11 = (tag, definition) => layer$19(tag, definition.binding, (value) => isQueue(value), makeClient$9(definition), { expected: expectedQueueProducer });
+const layer$11 = (tag, definition) => layer$20(tag, definition.binding, (value) => isQueue(value), makeClient$9(definition), { expected: expectedQueueProducer });
 //#endregion
 //#region src/QueueDefinition.ts
 var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -1527,7 +2292,7 @@ const makeClient$8 = (definition) => {
 		});
 	};
 };
-const layer$10 = (tag, definition) => layer$19(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
+const layer$10 = (tag, definition) => layer$20(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient$8(definition), { expected: expectedServiceBinding });
 /**
 * Creates a typed Effect service for a Worker service binding.
 *
@@ -1928,7 +2693,7 @@ const makeClient$7 = (definition) => {
 		});
 	};
 };
-const layer$9 = (tag, definition) => layer$19(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
+const layer$9 = (tag, definition) => layer$20(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
 const makeDirectMethods = (rpcDefinition, helpers) => {
 	const methods = {};
 	if (rpcDefinition !== void 0) {
@@ -2118,12 +2883,11 @@ const make$7 = (layer, options = {}) => {
 		alarm(alarmInfo) {
 			const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
 			const rawAlarm = options.alarm?.(alarmInfo);
-			if (logicalAlarms !== void 0 && rawAlarm !== void 0) return this[RunSymbol](Effect.gen(function* () {
+			const alarmEffect = logicalAlarms !== void 0 && rawAlarm !== void 0 ? Effect.gen(function* () {
 				yield* logicalAlarms;
 				yield* rawAlarm;
-			}));
-			if (logicalAlarms !== void 0) return this[RunSymbol](logicalAlarms);
-			if (rawAlarm !== void 0) return this[RunSymbol](rawAlarm);
+			}) : logicalAlarms ?? rawAlarm;
+			if (alarmEffect !== void 0) return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)));
 		}
 		webSocketMessage(socket, message) {
 			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message));
@@ -2865,7 +3629,7 @@ const makeClient$6 = (definition, options) => (email) => {
 		rawUnsafe: Effect.succeed(email)
 	};
 };
-const layer$6 = (tag, definition) => layer$19(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
+const layer$6 = (tag, definition) => layer$20(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
 const make$6 = (id) => Tag$7()(id);
 const Tag$7 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -2894,7 +3658,7 @@ const makeClient$5 = (definition) => (hyperdrive) => ({
 	connectionString: hyperdrive.connectionString,
 	rawUnsafe: Effect.succeed(hyperdrive)
 });
-const layer$5 = (tag, definition) => layer$19(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
+const layer$5 = (tag, definition) => layer$20(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
 const make$5 = (id) => Tag$6()(id);
 const Tag$6 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -2991,7 +3755,7 @@ const makeClient$4 = (definition) => (images) => {
 		rawUnsafe: Effect.succeed(images)
 	};
 };
-const layer$4 = (tag, definition) => layer$19(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
+const layer$4 = (tag, definition) => layer$20(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
 const make$4 = (id) => Tag$5()(id);
 const Tag$5 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3104,7 +3868,7 @@ const makeClient$3 = (definition) => {
 		rawUnsafe: Effect.succeed(kv)
 	});
 };
-const layer$3 = (tag, definition) => layer$19(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
+const layer$3 = (tag, definition) => layer$20(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
 const makeDefinition$1 = (id, definition) => {
 	const kvDefinition = {
 		id,
@@ -3228,7 +3992,7 @@ const makeClient$2 = (definition) => {
 		};
 	};
 };
-const layer$2 = (tag, definition) => layer$19(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
+const layer$2 = (tag, definition) => layer$20(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
 const make$3 = (id) => Tag$3()(id);
 const Tag$3 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3286,7 +4050,7 @@ const makeClient$1 = (definition) => (index) => {
 		rawUnsafe: Effect.succeed(index)
 	};
 };
-const layer$1 = (tag, definition) => layer$19(tag, definition.binding, isVectorizeBinding, makeClient$1(definition), { expected: expectedVectorizeBinding });
+const layer$1 = (tag, definition) => layer$20(tag, definition.binding, isVectorizeBinding, makeClient$1(definition), { expected: expectedVectorizeBinding });
 const make$2 = (id) => Tag$2()(id);
 const Tag$2 = () => (id) => {
 	const tag = Context.Service()(id);
@@ -3297,6 +4061,71 @@ const Tag$2 = () => (id) => {
 	});
 };
 //#endregion
+//#region src/WebTransport.ts
+var WebTransport_exports = /* @__PURE__ */ __exportAll({
+	InboundTransport: () => InboundTransport,
+	WebTransportUnsupportedError: () => WebTransportUnsupportedError,
+	capabilities: () => capabilities,
+	inboundSessionsUnsupported: () => inboundSessionsUnsupported,
+	inboundTransport: () => inboundTransport,
+	isHttp3: () => isHttp3
+});
+/**
+* Metadata Cloudflare's edge reports about the inbound client connection.
+*
+* `httpProtocol` and `clientTcpRtt` are declared in
+* `@cloudflare/workers-types`; `clientQuicRtt` is documented by Cloudflare
+* ("only present when the client connected over QUIC (HTTP/3)") but not yet
+* present in the published types, so it is decoded from the open
+* `Record<string, unknown>` side of `request.cf`.
+*/
+var InboundTransport = class extends Schema.Class("InboundTransport")({
+	/** The HTTP protocol the client used, e.g. `"HTTP/2"` or `"HTTP/3"`. */
+	httpProtocol: Schema.String,
+	/** Client round-trip time; only present for QUIC (HTTP/3) connections. */
+	clientQuicRtt: Schema.optional(Schema.Number),
+	/** Client round-trip time; only present for TCP (HTTP/1.x, HTTP/2) connections. */
+	clientTcpRtt: Schema.optional(Schema.Number)
+}) {};
+const decodeInboundTransport = Schema.decodeUnknownResult(InboundTransport);
+/**
+* Decodes the inbound transport metadata from `request.cf`.
+*
+* Returns `None` when the metadata is absent (for example in local `wrangler
+* dev` or when a Worker invokes another Worker directly) or does not match
+* the expected shape.
+*/
+const inboundTransport = (request) => Result.getSuccess(decodeInboundTransport(request.cf));
+/**
+* Returns `true` when the client reached Cloudflare's edge over QUIC
+* (HTTP/3). Prefers the documented QUIC signal (`clientQuicRtt` is only
+* present for QUIC connections) and falls back to the `httpProtocol` string.
+*
+* Note this describes the browser→edge hop only: the edge always terminates
+* QUIC, and the Worker still handles an ordinary `fetch` Request.
+*/
+const isHttp3 = (transport) => transport.clientQuicRtt !== void 0 || transport.httpProtocol === "HTTP/3";
+/** Feature-detects the WebTransport capabilities of the current runtime. */
+const capabilities = Effect.sync(() => ({
+	inboundSessions: false,
+	outboundSessions: typeof globalThis["WebTransport"] === "function"
+}));
+/** Raised when a WebTransport capability is unavailable in this runtime. */
+var WebTransportUnsupportedError = class extends Data.TaggedError("WebTransportUnsupportedError") {
+	get message() {
+		return this.capability === "inbound-sessions" ? "Cloudflare Workers cannot accept inbound WebTransport sessions: the edge terminates QUIC and no runtime session API exists (cloudflare/workerd#6451). Use Durable Object WebSockets for bidirectional push." : "This Workers runtime provides no WebTransport client: workerd has no QUIC stack and cloudflare:sockets is TCP-only.";
+	}
+};
+/**
+* The explicit typed boundary for inbound WebTransport sessions.
+*
+* Always fails with {@link WebTransportUnsupportedError} today. Route the
+* code path that would accept a session through this effect so the
+* limitation is visible in the type system and greppable when Cloudflare
+* ships a real API.
+*/
+const inboundSessionsUnsupported = Effect.fail(new WebTransportUnsupportedError({ capability: "inbound-sessions" }));
+//#endregion
 //#region src/WorkflowBinding.ts
 var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
 	WorkflowOperationError: () => WorkflowOperationError,
@@ -3387,7 +4216,7 @@ const makeClient = (definition) => {
 		rawUnsafe: Effect.succeed(workflow)
 	});
 };
-const layer = (tag, definition) => layer$19(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
+const layer = (tag, definition) => layer$20(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
 //#endregion
 //#region src/WorkflowDefinition.ts
 var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
@@ -3408,7 +4237,7 @@ const make$1 = (id, definition) => Tag$1()(id, definition);
 const Tag$1 = () => (id, definition) => {
 	const workflowDefinition = makeDefinition(id, definition);
 	const tag = Context.Service()(`effect-cf/Workflow/${id}`);
-	const layer$20 = (binding) => layer(tag, {
+	const layer$21 = (binding) => layer(tag, {
 		...binding,
 		payload: definition.payload,
 		result: definition.result
@@ -3428,7 +4257,7 @@ const Tag$1 = () => (id, definition) => {
 		payload: workflowDefinition.payload,
 		result: workflowDefinition.result,
 		make: workflowDefinition.make,
-		layer: layer$20,
+		layer: layer$21,
 		create,
 		createBatch,
 		get,
@@ -3546,4 +4375,4 @@ const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflow
 const Tag = Tag$1;
 const implement = implement$1;
 //#endregion
-export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };
+export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, ComputerArtifacts_exports as ComputerArtifacts, ComputerWorkspace_exports as ComputerWorkspace, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };