@aigne/afs-cloudflare 1.11.0-beta.7

package/dist/cloudflare-afs.mjs

@@ -0,0 +1,2725 @@
+import { CloudflareCache } from "./cache.mjs";
+import { createCloudflareClient } from "./client.mjs";
+import { confirmationRequired, mapCloudflareError } from "./errors.mjs";
+import { generateKVPlatformRef, generatePagesPlatformRef, generateWorkerPlatformRef } from "./platform-ref.mjs";
+import { AFSCloudflareConfigSchema, KINDS, normalizeConfig } from "./types.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { AFSBaseProvider, AFSNotFoundError, AFSReadonlyError, Actions, Delete, Explain, List, Meta, Read, Search, Stat, Write } from "@aigne/afs";
+import { zodParse } from "@aigne/afs/utils/zod";
+import { minimatch } from "minimatch";
+import { joinURL } from "ufo";
+
+//#region src/cloudflare-afs.ts
+function camelize(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+		if (value && typeof value === "object" && !Array.isArray(value)) result[camelKey] = camelize(value);
+		else result[camelKey] = value;
+	}
+	return result;
+}
+var AFSCloudflare = class AFSCloudflare extends AFSBaseProvider {
+	name;
+	description;
+	accessMode;
+	config;
+	cfClient;
+	cache;
+	destroyed = false;
+	constructor(config) {
+		super();
+		this.config = normalizeConfig(AFSCloudflareConfigSchema.parse(config));
+		this.name = this.config.name;
+		this.description = this.config.description;
+		this.accessMode = this.config.accessMode;
+		this.cfClient = createCloudflareClient(this.config);
+		this.cache = new CloudflareCache(this.config.cacheTtl, this.config.cacheDisabled);
+	}
+	static schema() {
+		return AFSCloudflareConfigSchema;
+	}
+	static async load({ basePath, config } = {}) {
+		return new AFSCloudflare(zodParse(AFSCloudflareConfigSchema, camelize(config ?? {}), { prefix: basePath }));
+	}
+	setClient(client) {
+		this.cfClient.setClient(client);
+	}
+	get client() {
+		return this.cfClient.getClient();
+	}
+	async accountId() {
+		return this.cfClient.getAccountId();
+	}
+	ensureNotDestroyed() {
+		if (this.destroyed) throw new Error("Provider has been destroyed");
+	}
+	requireReadwrite(path) {
+		if (this.config.accessMode !== "readwrite") throw new AFSReadonlyError(`Read-only mode: Cannot perform write operation at ${path}`);
+	}
+	async resolveKVNamespaceId(title) {
+		const cacheKey = `kv:title:${title}`;
+		const cached = this.cache.get(cacheKey);
+		if (cached) return cached;
+		const accountId = await this.accountId();
+		const namespaces = this.client.kv.namespaces.list({ account_id: accountId });
+		for await (const ns of namespaces) if (ns.title === title) {
+			const id = ns.id;
+			this.cache.set(cacheKey, id);
+			return id;
+		}
+		throw new AFSNotFoundError(`KV namespace not found: ${title}`);
+	}
+	async collect(iter) {
+		const items = [];
+		for await (const item of iter) items.push(item);
+		return items;
+	}
+	validateAfsPath(path) {
+		if (!path.startsWith("/") && !path.startsWith("$afs")) throw new Error(`Invalid path: "${path}". Must be an AFS path (starting with / or $afs)`);
+		if (/^\/[a-zA-Z]:\//.test(path) || path.includes("..")) throw new Error(`Invalid path: "${path}". System filesystem paths are not allowed. Use an AFS mount path.`);
+	}
+	getAfsFromContext(ctx) {
+		const afs = ctx.options?.context?.afs;
+		if (!afs) throw new Error("AFS context not available. Directory operations require the AFS instance in exec context.");
+		return afs;
+	}
+	async readDirectoryFiles(afs, basePath) {
+		const files = /* @__PURE__ */ new Map();
+		const { data: entries } = await afs.list(basePath, { recursive: true });
+		for (const entry of entries) {
+			if (entry.meta?.kind === "directory" || entry.meta?.childrenCount !== void 0) continue;
+			try {
+				const { data } = await afs.read(entry.path);
+				if (data?.content !== void 0 && data?.content !== null) {
+					const relPath = entry.path.slice(basePath.length).replace(/^\//, "");
+					files.set(relPath, typeof data.content === "string" ? data.content : JSON.stringify(data.content));
+				}
+			} catch {}
+		}
+		if (files.size === 0) throw new Error(`No files found in directory: ${basePath}`);
+		return files;
+	}
+	detectMainModule(files) {
+		for (const candidate of [
+			"index.js",
+			"index.mjs",
+			"index.ts",
+			"worker.js",
+			"worker.mjs",
+			"src/index.js",
+			"src/index.ts"
+		]) if (files.has(candidate)) return candidate;
+		for (const name of files.keys()) if (name.endsWith(".js") || name.endsWith(".mjs") || name.endsWith(".ts")) return name;
+		throw new Error("No JavaScript/TypeScript main module found in directory");
+	}
+	getContentType(filename) {
+		if (filename.endsWith(".html") || filename.endsWith(".htm")) return "text/html";
+		if (filename.endsWith(".css")) return "text/css";
+		if (filename.endsWith(".js") || filename.endsWith(".mjs")) return "application/javascript+module";
+		if (filename.endsWith(".ts")) return "application/typescript";
+		if (filename.endsWith(".json")) return "application/json";
+		if (filename.endsWith(".svg")) return "image/svg+xml";
+		if (filename.endsWith(".png")) return "image/png";
+		if (filename.endsWith(".jpg") || filename.endsWith(".jpeg")) return "image/jpeg";
+		if (filename.endsWith(".gif")) return "image/gif";
+		if (filename.endsWith(".ico")) return "image/x-icon";
+		if (filename.endsWith(".woff2")) return "font/woff2";
+		if (filename.endsWith(".woff")) return "font/woff";
+		if (filename.endsWith(".wasm")) return "application/wasm";
+		if (filename.endsWith(".xml")) return "application/xml";
+		if (filename.endsWith(".txt")) return "text/plain";
+		return "application/octet-stream";
+	}
+	async listRoot(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const [workers, kvNamespaces, pagesProjects, zones] = await Promise.all([
+			this.collect(this.client.workers.scripts.list({ account_id: accountId })),
+			this.collect(this.client.kv.namespaces.list({ account_id: accountId })),
+			this.collect(this.client.pages.projects.list({ account_id: accountId })),
+			this.collect(this.client.zones.list())
+		]);
+		return { data: [
+			{
+				id: "WORLD.md",
+				path: "/WORLD.md",
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "text/markdown"
+				}
+			},
+			{
+				id: "workers",
+				path: "/workers",
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: workers.length
+				}
+			},
+			{
+				id: "kv",
+				path: "/kv",
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: kvNamespaces.length
+				}
+			},
+			{
+				id: "pages",
+				path: "/pages",
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: pagesProjects.length
+				}
+			},
+			{
+				id: "by-zone",
+				path: "/by-zone",
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: zones.length
+				}
+			}
+		] };
+	}
+	async readCapabilities(_ctx) {
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				description: this.description ?? "Cloudflare provider",
+				tools: [],
+				actions: [],
+				operations: this.getOperationsDeclaration()
+			},
+			meta: { kind: "afs:capabilities" }
+		};
+	}
+	async readRoot(_ctx) {
+		return {
+			id: "/",
+			path: "/",
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: 5
+			}
+		};
+	}
+	async readWorldMd(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const cacheKey = "world-md";
+		const cached = this.cache.get(cacheKey);
+		if (cached) return {
+			id: "WORLD.md",
+			path: "/WORLD.md",
+			content: cached,
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "text/markdown"
+			}
+		};
+		const [workers, kvNamespaces, pagesProjects, zones] = await Promise.all([
+			this.collect(this.client.workers.scripts.list({ account_id: accountId })),
+			this.collect(this.client.kv.namespaces.list({ account_id: accountId })),
+			this.collect(this.client.pages.projects.list({ account_id: accountId })),
+			this.collect(this.client.zones.list())
+		]);
+		const content = `# Cloudflare Account Overview
+
+**Account ID**: ${accountId}
+
+## Resources
+
+| Resource | Count |
+|----------|-------|
+| Workers | ${workers.length} |
+| KV Namespaces | ${kvNamespaces.length} |
+| Pages Projects | ${pagesProjects.length} |
+| Zones | ${zones.length} |
+
+## Workers
+${workers.map((w) => `- ${w.id}`).join("\n")}
+
+## KV Namespaces
+${kvNamespaces.map((ns) => `- ${ns.title}`).join("\n")}
+
+## Pages Projects
+${pagesProjects.map((p) => `- ${p.name}`).join("\n")}
+
+## Zones
+${zones.map((z) => `- ${z.name}`).join("\n")}
+`;
+		this.cache.set(cacheKey, content);
+		return {
+			id: "WORLD.md",
+			path: "/WORLD.md",
+			content,
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "text/markdown"
+			}
+		};
+	}
+	async metaRoot(_ctx) {
+		return {
+			id: "",
+			path: "/.meta",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: 5
+			}
+		};
+	}
+	async statRoot(ctx) {
+		if (ctx.path === "/WORLD.md" || ctx.path === "/WORLD.md/.stat") return { data: {
+			id: "WORLD.md",
+			path: "/WORLD.md",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "text/markdown"
+			}
+		} };
+		return { data: {
+			id: "/",
+			path: "/",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: 5
+			}
+		} };
+	}
+	async explainRoot(_ctx) {
+		return {
+			format: "markdown",
+			content: `# Cloudflare Provider
+
+This provider gives file-system-like access to Cloudflare Developer Platform resources.
+
+**Account ID**: ${await this.accountId()}
+
+## Available Paths
+
+- \`/workers\` — Cloudflare Workers (edge functions)
+- \`/kv\` — KV Namespaces (key-value storage)
+- \`/pages\` — Pages Projects (static site hosting)
+- \`/by-zone\` — Resources grouped by DNS zone
+- \`/WORLD.md\` — Account overview and resource statistics
+`
+		};
+	}
+	async listFileNode(_ctx) {
+		return { data: [] };
+	}
+	async metaWorldMd(_ctx) {
+		return {
+			id: "WORLD.md",
+			path: "/WORLD.md/.meta",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "text/markdown"
+			}
+		};
+	}
+	async metaWorkerScript(ctx) {
+		return {
+			id: "script.js",
+			path: joinURL("/workers", ctx.params.name, "script.js", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "application/javascript"
+			}
+		};
+	}
+	async metaWorkerSettings(ctx) {
+		return {
+			id: "settings.json",
+			path: joinURL("/workers", ctx.params.name, "settings.json", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "application/json"
+			}
+		};
+	}
+	async metaWorkerBindings(ctx) {
+		return {
+			id: "bindings",
+			path: joinURL("/workers", ctx.params.name, "bindings", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaWorkerBinding(ctx) {
+		return {
+			id: ctx.params.binding,
+			path: joinURL("/workers", ctx.params.name, "bindings", ctx.params.binding, ".meta"),
+			meta: {
+				kind: KINDS.BINDING,
+				kinds: [KINDS.BINDING, KINDS.NODE]
+			}
+		};
+	}
+	async metaWorkerRoutes(ctx) {
+		return {
+			id: "routes",
+			path: joinURL("/workers", ctx.params.name, "routes", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaWorkerRoute(ctx) {
+		return {
+			id: ctx.params.route,
+			path: joinURL("/workers", ctx.params.name, "routes", ctx.params.route, ".meta"),
+			meta: {
+				kind: KINDS.ROUTE,
+				kinds: [KINDS.ROUTE, KINDS.NODE]
+			}
+		};
+	}
+	async metaWorkerCronTriggers(ctx) {
+		return {
+			id: "cron-triggers",
+			path: joinURL("/workers", ctx.params.name, "cron-triggers", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaWorkerCronTrigger(ctx) {
+		return {
+			id: ctx.params.cron,
+			path: joinURL("/workers", ctx.params.name, "cron-triggers", ctx.params.cron, ".meta"),
+			meta: {
+				kind: KINDS.CRON_TRIGGER,
+				kinds: [KINDS.CRON_TRIGGER, KINDS.NODE]
+			}
+		};
+	}
+	async metaKVMetadataFile(ctx) {
+		return {
+			id: "metadata.json",
+			path: joinURL("/kv", ctx.params.title, "metadata.json", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "application/json"
+			}
+		};
+	}
+	async metaKVKeys(ctx) {
+		return {
+			id: "keys",
+			path: joinURL("/kv", ctx.params.title, "keys", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaKVKey(ctx) {
+		return {
+			id: decodeURIComponent(ctx.params.key),
+			path: joinURL("/kv", ctx.params.title, "keys", ctx.params.key, ".meta"),
+			meta: {
+				kind: KINDS.KV_KEY,
+				kinds: [KINDS.KV_KEY, KINDS.NODE]
+			}
+		};
+	}
+	async metaPagesMetadataFile(ctx) {
+		return {
+			id: "metadata.json",
+			path: joinURL("/pages", ctx.params.project, "metadata.json", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "application/json"
+			}
+		};
+	}
+	async metaPagesDeployments(ctx) {
+		return {
+			id: "deployments",
+			path: joinURL("/pages", ctx.params.project, "deployments", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaPagesDeployment(ctx) {
+		return {
+			id: ctx.params.id,
+			path: joinURL("/pages", ctx.params.project, "deployments", ctx.params.id, ".meta"),
+			meta: {
+				kind: KINDS.DEPLOYMENT,
+				kinds: [KINDS.DEPLOYMENT, KINDS.NODE]
+			}
+		};
+	}
+	async metaPagesDomains(ctx) {
+		return {
+			id: "domains",
+			path: joinURL("/pages", ctx.params.project, "domains", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaPagesDomain(ctx) {
+		return {
+			id: ctx.params.domain,
+			path: joinURL("/pages", ctx.params.project, "domains", ctx.params.domain, ".meta"),
+			meta: {
+				kind: KINDS.DOMAIN,
+				kinds: [KINDS.DOMAIN, KINDS.NODE]
+			}
+		};
+	}
+	async metaByZoneDir(ctx) {
+		return {
+			id: ctx.params.zone,
+			path: joinURL("/by-zone", ctx.params.zone, ".meta"),
+			meta: {
+				kind: KINDS.ZONE,
+				kinds: [KINDS.ZONE, KINDS.NODE],
+				childrenCount: 2
+			}
+		};
+	}
+	async metaByZoneWorkers(ctx) {
+		return {
+			id: "workers",
+			path: joinURL("/by-zone", ctx.params.zone, "workers", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaByZoneWorker(ctx) {
+		return {
+			id: ctx.params.name,
+			path: joinURL("/by-zone", ctx.params.zone, "workers", ctx.params.name, ".meta"),
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE]
+			}
+		};
+	}
+	async metaByZonePages(ctx) {
+		return {
+			id: "pages",
+			path: joinURL("/by-zone", ctx.params.zone, "pages", ".meta"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaByZoneProject(ctx) {
+		return {
+			id: ctx.params.project,
+			path: joinURL("/by-zone", ctx.params.zone, "pages", ctx.params.project, ".meta"),
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE]
+			}
+		};
+	}
+	async listGlobalActions(_ctx) {
+		return { data: [{
+			id: "refresh",
+			path: "/.actions/refresh",
+			summary: "Refresh all cached data",
+			meta: {
+				kind: KINDS.EXECUTABLE,
+				kinds: [KINDS.EXECUTABLE, KINDS.NODE]
+			}
+		}] };
+	}
+	async execRefresh(_ctx, _args) {
+		this.ensureNotDestroyed();
+		this.cache.clear();
+		return {
+			success: true,
+			data: { message: "Cache cleared" }
+		};
+	}
+	async listWorkers(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const cacheKey = "list:workers";
+		const cached = this.cache.get(cacheKey);
+		if (cached) return { data: cached };
+		const entries = (await this.collect(this.client.workers.scripts.list({ account_id: accountId }))).map((w) => ({
+			id: w.id,
+			path: joinURL("/workers", w.id),
+			summary: w.id,
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE],
+				childrenCount: 5
+			}
+		}));
+		this.cache.set(cacheKey, entries);
+		return { data: entries };
+	}
+	async listWorkerDir(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		const basePath = joinURL("/workers", name);
+		const bindings = (await this.client.workers.scripts.settings.get(name, { account_id: accountId }))?.result?.bindings || [];
+		const triggers = (await this.client.workers.scripts.schedules.get(name, { account_id: accountId }))?.schedules || [];
+		const zones = await this.collect(this.client.zones.list());
+		let routeCount = 0;
+		for (const zone of zones) {
+			const routes = await this.collect(this.client.workers.routes.list({ zone_id: zone.id }));
+			routeCount += routes.filter((r) => r.script === name).length;
+		}
+		return { data: [
+			{
+				id: "script.js",
+				path: joinURL(basePath, "script.js"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "application/javascript"
+				}
+			},
+			{
+				id: "settings.json",
+				path: joinURL(basePath, "settings.json"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "application/json"
+				}
+			},
+			{
+				id: "bindings",
+				path: joinURL(basePath, "bindings"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: bindings.length
+				}
+			},
+			{
+				id: "routes",
+				path: joinURL(basePath, "routes"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: routeCount
+				}
+			},
+			{
+				id: "cron-triggers",
+				path: joinURL(basePath, "cron-triggers"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: triggers.length
+				}
+			}
+		] };
+	}
+	async listWorkerBindings(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		return { data: ((await this.client.workers.scripts.settings.get(name, { account_id: accountId }))?.result?.bindings || []).map((b) => ({
+			id: b.name,
+			path: joinURL("/workers", name, "bindings", b.name),
+			content: JSON.stringify(b, null, 2),
+			meta: {
+				kind: KINDS.BINDING,
+				kinds: [KINDS.BINDING, KINDS.NODE],
+				bindingType: b.type
+			}
+		})) };
+	}
+	async listWorkerRoutes(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const zones = await this.collect(this.client.zones.list());
+		const entries = [];
+		for (const zone of zones) {
+			const routes = await this.collect(this.client.workers.routes.list({ zone_id: zone.id }));
+			for (const route of routes) if (route.script === name) {
+				const pattern = route.pattern;
+				entries.push({
+					id: pattern,
+					path: joinURL("/workers", name, "routes", pattern),
+					content: JSON.stringify(route, null, 2),
+					meta: {
+						kind: KINDS.ROUTE,
+						kinds: [KINDS.ROUTE, KINDS.NODE],
+						zoneName: zone.name
+					}
+				});
+			}
+		}
+		return { data: entries };
+	}
+	async listWorkerCronTriggers(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		return { data: ((await this.client.workers.scripts.schedules.get(name, { account_id: accountId }))?.schedules || []).map((t) => ({
+			id: t.cron,
+			path: joinURL("/workers", name, "cron-triggers", t.cron),
+			content: JSON.stringify(t, null, 2),
+			meta: {
+				kind: KINDS.CRON_TRIGGER,
+				kinds: [KINDS.CRON_TRIGGER, KINDS.NODE]
+			}
+		})) };
+	}
+	async readWorkers(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const workers = await this.collect(this.client.workers.scripts.list({ account_id: accountId }));
+		return {
+			id: "workers",
+			path: "/workers",
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: workers.length
+			}
+		};
+	}
+	async readWorkerDir(ctx) {
+		return {
+			id: ctx.params.name,
+			path: joinURL("/workers", ctx.params.name),
+			content: "",
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE],
+				childrenCount: 5
+			}
+		};
+	}
+	async readWorkerBindingsDir(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		const bindings = (await this.client.workers.scripts.settings.get(name, { account_id: accountId }))?.result?.bindings || [];
+		return {
+			id: "bindings",
+			path: joinURL("/workers", name, "bindings"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: bindings.length
+			}
+		};
+	}
+	async readWorkerRoutesDir(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const zones = await this.collect(this.client.zones.list());
+		let routeCount = 0;
+		for (const zone of zones) {
+			const routes = await this.collect(this.client.workers.routes.list({ zone_id: zone.id }));
+			routeCount += routes.filter((r) => r.script === name).length;
+		}
+		return {
+			id: "routes",
+			path: joinURL("/workers", name, "routes"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: routeCount
+			}
+		};
+	}
+	async readWorkerCronTriggersDir(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		const triggers = (await this.client.workers.scripts.schedules.get(name, { account_id: accountId }))?.schedules || [];
+		return {
+			id: "cron-triggers",
+			path: joinURL("/workers", name, "cron-triggers"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: triggers.length
+			}
+		};
+	}
+	async readWorkerScript(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			const response = await this.client.workers.scripts.content.get(name, { account_id: accountId });
+			const content = response instanceof Response ? await response.text() : typeof response === "string" ? response : "";
+			return {
+				id: "script.js",
+				path: joinURL("/workers", name, "script.js"),
+				content,
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "application/javascript"
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async readWorkerSettings(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			const settings = await this.client.workers.scripts.settings.get(name, { account_id: accountId });
+			const content = JSON.stringify(settings?.result || {}, null, 2);
+			return {
+				id: "settings.json",
+				path: joinURL("/workers", name, "settings.json"),
+				content,
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "application/json"
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async readWorkerBinding(ctx) {
+		this.ensureNotDestroyed();
+		const { name, binding } = ctx.params;
+		const accountId = await this.accountId();
+		const found = ((await this.client.workers.scripts.settings.get(name, { account_id: accountId }))?.result?.bindings || []).find((b) => b.name === binding);
+		if (!found) throw new AFSNotFoundError(`Binding not found: ${binding}`);
+		return {
+			id: binding,
+			path: joinURL("/workers", name, "bindings", binding),
+			content: JSON.stringify(found, null, 2),
+			meta: {
+				kind: KINDS.BINDING,
+				kinds: [KINDS.BINDING, KINDS.NODE],
+				bindingType: found.type
+			}
+		};
+	}
+	async readWorkerRoute(ctx) {
+		this.ensureNotDestroyed();
+		const { name, route } = ctx.params;
+		const decodedRoute = route;
+		const zones = await this.collect(this.client.zones.list());
+		for (const zone of zones) {
+			const routes = await this.collect(this.client.workers.routes.list({ zone_id: zone.id }));
+			for (const r of routes) if (r.script === name && r.pattern === decodedRoute) return {
+				id: decodedRoute,
+				path: joinURL("/workers", name, "routes", route),
+				content: JSON.stringify(r, null, 2),
+				meta: {
+					kind: KINDS.ROUTE,
+					kinds: [KINDS.ROUTE, KINDS.NODE],
+					zoneName: zone.name
+				}
+			};
+		}
+		throw new AFSNotFoundError(`Route not found: ${decodedRoute}`);
+	}
+	async readWorkerCronTrigger(ctx) {
+		this.ensureNotDestroyed();
+		const { name, cron } = ctx.params;
+		const decodedCron = cron;
+		const accountId = await this.accountId();
+		const found = ((await this.client.workers.scripts.schedules.get(name, { account_id: accountId }))?.schedules || []).find((t) => t.cron === decodedCron);
+		if (!found) throw new AFSNotFoundError(`Cron trigger not found: ${decodedCron}`);
+		return {
+			id: decodedCron,
+			path: joinURL("/workers", name, "cron-triggers", cron),
+			content: JSON.stringify(found, null, 2),
+			meta: {
+				kind: KINDS.CRON_TRIGGER,
+				kinds: [KINDS.CRON_TRIGGER, KINDS.NODE]
+			}
+		};
+	}
+	async metaWorkers(_ctx) {
+		return {
+			id: "workers",
+			path: "/workers/.meta",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaWorker(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		const worker = await this.client.workers.scripts.get(name, { account_id: accountId });
+		if (!worker) throw new AFSNotFoundError(`Worker not found: ${name}`);
+		const settings = await this.client.workers.scripts.settings.get(name, { account_id: accountId });
+		const bindings = settings?.result?.bindings || [];
+		const cronTriggers = (await this.client.workers.scripts.schedules.get(name, { account_id: accountId }))?.schedules || [];
+		const zones = await this.collect(this.client.zones.list());
+		let routeCount = 0;
+		for (const zone of zones) {
+			const routes = await this.collect(this.client.workers.routes.list({ zone_id: zone.id }));
+			routeCount += routes.filter((r) => r.script === name).length;
+		}
+		return {
+			id: name,
+			path: joinURL("/workers", name, ".meta"),
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE],
+				childrenCount: 5,
+				scriptName: name,
+				createdOn: worker.created_on,
+				modifiedOn: worker.modified_on,
+				compatibilityDate: settings?.result?.compatibility_date,
+				usageModel: settings?.result?.usage_model,
+				routeCount,
+				bindingCount: bindings.length,
+				cronTriggerCount: cronTriggers.length,
+				platformRef: generateWorkerPlatformRef(accountId, name)
+			}
+		};
+	}
+	async statWorkers(ctx) {
+		const parts = ctx.path.replace(/\/.stat$/, "").split("/").filter(Boolean);
+		return { data: {
+			id: parts[parts.length - 1] || "workers",
+			path: ctx.path.replace(/\/.stat$/, ""),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		} };
+	}
+	async explainWorkers(_ctx) {
+		return {
+			format: "markdown",
+			content: `# Workers
+
+Cloudflare Workers are serverless edge functions. Each worker contains:
+- \`script.js\` — The worker source code
+- \`settings.json\` — Configuration (compatibility_date, usage_model)
+- \`bindings/\` — Resource bindings (KV, R2, D1, etc.)
+- \`routes/\` — URL patterns that trigger this worker
+- \`cron-triggers/\` — Scheduled execution patterns
+`
+		};
+	}
+	async explainWorker(ctx) {
+		this.ensureNotDestroyed();
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		const worker = await this.client.workers.scripts.get(name, { account_id: accountId });
+		if (!worker) throw new AFSNotFoundError(`Worker not found: ${name}`);
+		return {
+			format: "markdown",
+			content: `# Worker: ${name}
+
+**Created**: ${worker.created_on}
+**Modified**: ${worker.modified_on}
+
+## Structure
+- \`script.js\` — Source code (read/write)
+- \`settings.json\` — Configuration
+- \`bindings/\` — Resource bindings
+- \`routes/\` — URL route patterns
+- \`cron-triggers/\` — Scheduled triggers
+
+## Actions
+- \`deploy\` — Deploy latest version to production
+- \`rollback\` — Rollback to previous version
+- \`delete\` — Delete this worker (requires confirm: true)
+`
+		};
+	}
+	async writeWorkerScript(ctx, payload) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		const content = typeof payload.content === "string" ? payload.content : "";
+		try {
+			const scriptFile = new File([content], "script.js", { type: "application/javascript+module" });
+			const result = await this.client.workers.scripts.update(name, {
+				account_id: accountId,
+				metadata: { main_module: "script.js" },
+				files: { "script.js": scriptFile }
+			});
+			this.cache.invalidate("list:workers");
+			this.cache.invalidate(`worker:${name}`);
+			return { data: {
+				id: "script.js",
+				path: joinURL("/workers", name, "script.js"),
+				content,
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "application/javascript",
+					etag: result?.etag
+				}
+			} };
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async writeWorkerSettings(ctx, payload) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			const settings = typeof payload.content === "string" ? JSON.parse(payload.content) : payload.content || {};
+			const applied = {};
+			if ("workers_dev" in settings) {
+				await this.client.workers.scripts.subdomain.create(name, {
+					account_id: accountId,
+					enabled: !!settings.workers_dev
+				});
+				applied.workers_dev = !!settings.workers_dev;
+			}
+			this.cache.invalidate(`worker:${name}`);
+			return { data: {
+				id: "settings.json",
+				path: joinURL("/workers", name, "settings.json"),
+				content: JSON.stringify(applied, null, 2),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "application/json"
+				}
+			} };
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async listRootWorkerActions(_ctx) {
+		if (this.config.accessMode !== "readwrite") throw new AFSNotFoundError("Actions not available in readonly mode");
+		return { data: [{
+			id: "create",
+			path: "/workers/.actions/create",
+			summary: "Create and deploy a new worker",
+			meta: {
+				kind: KINDS.EXECUTABLE,
+				kinds: [KINDS.EXECUTABLE, KINDS.NODE],
+				inputSchema: {
+					type: "object",
+					required: ["name"],
+					properties: {
+						name: {
+							type: "string",
+							description: "Worker name"
+						},
+						script: {
+							type: "string",
+							description: "Inline script content (for single-file workers)"
+						},
+						directory: {
+							type: "string",
+							description: "AFS directory path containing worker files (must be an AFS mount path)"
+						},
+						mainModule: {
+							type: "string",
+							description: "Main module filename (auto-detected if not provided)"
+						},
+						bindings: {
+							type: "array",
+							description: "KV/R2/etc bindings, e.g. [{\"type\":\"kv_namespace\",\"name\":\"KV\",\"namespace_id\":\"...\"}]",
+							items: { type: "object" }
+						},
+						compatibilityDate: {
+							type: "string",
+							description: "Compatibility date (default: today)"
+						}
+					}
+				}
+			}
+		}] };
+	}
+	async execWorkerCreate(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const accountId = await this.accountId();
+		const name = args.name;
+		const script = args.script;
+		const directory = args.directory;
+		const mainModuleArg = args.mainModule;
+		const rawBindings = args.bindings;
+		let bindings;
+		if (typeof rawBindings === "string") try {
+			bindings = JSON.parse(rawBindings);
+		} catch {
+			return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: "bindings must be valid JSON array"
+				}
+			};
+		}
+		else bindings = rawBindings;
+		const compatibilityDate = args.compatibilityDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+		if (!name) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "name is required"
+			}
+		};
+		if (!script && !directory) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "Either script (inline content) or directory (AFS path) is required"
+			}
+		};
+		try {
+			const hasBindings = bindings && bindings.length > 0;
+			let fileCount = 1;
+			if (script) {
+				const scriptFile = new File([script], "index.js", { type: "application/javascript+module" });
+				await this.client.workers.scripts.update(name, {
+					account_id: accountId,
+					metadata: {
+						main_module: "index.js",
+						...hasBindings ? { bindings } : {},
+						compatibility_date: compatibilityDate
+					},
+					files: { "index.js": scriptFile }
+				});
+			} else if (directory) {
+				this.validateAfsPath(directory);
+				const afs = this.getAfsFromContext(ctx);
+				const files = await this.readDirectoryFiles(afs, directory);
+				const mainModule = mainModuleArg || this.detectMainModule(files);
+				fileCount = files.size;
+				const fileUploads = {};
+				for (const [filename, content] of files) fileUploads[filename] = new File([content], filename, { type: this.getContentType(filename) });
+				await this.client.workers.scripts.update(name, {
+					account_id: accountId,
+					metadata: {
+						main_module: mainModule,
+						...hasBindings ? { bindings } : {},
+						compatibility_date: compatibilityDate
+					},
+					files: fileUploads
+				});
+			}
+			try {
+				await this.client.workers.scripts.subdomain.create(name, {
+					account_id: accountId,
+					enabled: true
+				});
+			} catch {}
+			this.cache.invalidate("list:workers");
+			this.cache.invalidate(`worker:${name}`);
+			return {
+				success: true,
+				data: {
+					name,
+					type: script ? "single-file" : "directory",
+					fileCount
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async listWorkerActions(ctx) {
+		if (this.config.accessMode !== "readwrite") throw new AFSNotFoundError("Actions not available in readonly mode");
+		const basePath = joinURL("/workers", ctx.params.name, ".actions");
+		return { data: [
+			{
+				id: "deploy",
+				path: joinURL(basePath, "deploy"),
+				summary: "Deploy version to production",
+				meta: {
+					kind: KINDS.EXECUTABLE,
+					kinds: [KINDS.EXECUTABLE, KINDS.NODE]
+				}
+			},
+			{
+				id: "rollback",
+				path: joinURL(basePath, "rollback"),
+				summary: "Rollback to previous version",
+				meta: {
+					kind: KINDS.EXECUTABLE,
+					kinds: [KINDS.EXECUTABLE, KINDS.NODE]
+				}
+			},
+			{
+				id: "delete",
+				path: joinURL(basePath, "delete"),
+				summary: "Delete worker (requires confirm: true)",
+				meta: {
+					kind: KINDS.EXECUTABLE,
+					kinds: [KINDS.EXECUTABLE, KINDS.NODE],
+					inputSchema: {
+						type: "object",
+						required: ["confirm"],
+						properties: { confirm: {
+							type: "boolean",
+							description: "Must be true to confirm deletion"
+						} }
+					}
+				}
+			}
+		] };
+	}
+	async execWorkerDeploy(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			const directory = args.directory;
+			if (directory) {
+				this.validateAfsPath(directory);
+				const afs = this.getAfsFromContext(ctx);
+				const files = await this.readDirectoryFiles(afs, directory);
+				const mainModule = args.mainModule || this.detectMainModule(files);
+				const fileUploads = {};
+				for (const [filename, content] of files) fileUploads[filename] = new File([content], filename, { type: this.getContentType(filename) });
+				await this.client.workers.scripts.update(name, {
+					account_id: accountId,
+					metadata: { main_module: mainModule },
+					files: fileUploads
+				});
+			}
+			let versionId = args.versionId;
+			if (!versionId) {
+				const versions$1 = await this.collect(this.client.workers.scripts.versions.list(name, { account_id: accountId }));
+				if (versions$1.length > 0) versionId = versions$1[0].id;
+			}
+			const versions = versionId ? [{
+				version_id: versionId,
+				percentage: 100
+			}] : [];
+			const deployment = await this.client.workers.scripts.deployments.create(name, {
+				account_id: accountId,
+				strategy: "percentage",
+				versions
+			});
+			this.cache.invalidate("list:workers");
+			this.cache.invalidate(`worker:${name}`);
+			return {
+				success: true,
+				data: {
+					deploymentId: deployment?.id,
+					versionId
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async execWorkerRollback(ctx, _args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			const versions = await this.collect(this.client.workers.scripts.versions.list(name, { account_id: accountId }));
+			if (versions.length < 2) return {
+				success: false,
+				error: {
+					code: "NO_PREVIOUS_VERSION",
+					message: "No previous version to rollback to"
+				}
+			};
+			const previousVersionId = versions[1].id;
+			const deployment = await this.client.workers.scripts.deployments.create(name, {
+				account_id: accountId,
+				strategy: "percentage",
+				versions: [{
+					version_id: previousVersionId,
+					percentage: 100
+				}]
+			});
+			this.cache.invalidate("list:workers");
+			this.cache.invalidate(`worker:${name}`);
+			return {
+				success: true,
+				data: {
+					deploymentId: deployment?.id,
+					versionId: previousVersionId
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async execWorkerDelete(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		if (args.confirm !== true) throw confirmationRequired("delete", ctx.path);
+		const { name } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			await this.client.workers.scripts.delete(name, { account_id: accountId });
+			this.cache.invalidate("list:workers");
+			this.cache.invalidate(`worker:${name}`);
+			return {
+				success: true,
+				data: { deleted: name }
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async searchWorkers(_ctx, query, options) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const matched = (await this.collect(this.client.workers.scripts.list({ account_id: accountId }))).filter((w) => minimatch(w.id, query));
+		const limit = options?.limit ?? 100;
+		return { data: matched.slice(0, limit).map((w) => ({
+			id: w.id,
+			path: joinURL("/workers", w.id),
+			summary: w.id,
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE]
+			}
+		})) };
+	}
+	async listKV(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const cacheKey = "list:kv";
+		const cached = this.cache.get(cacheKey);
+		if (cached) return { data: cached };
+		const entries = (await this.collect(this.client.kv.namespaces.list({ account_id: accountId }))).map((ns) => ({
+			id: ns.title,
+			path: joinURL("/kv", ns.title),
+			summary: ns.title,
+			meta: {
+				kind: KINDS.KV_NAMESPACE,
+				kinds: [KINDS.KV_NAMESPACE, KINDS.NODE],
+				childrenCount: 2
+			}
+		}));
+		this.cache.set(cacheKey, entries);
+		return { data: entries };
+	}
+	async listKVNamespaceDir(ctx) {
+		this.ensureNotDestroyed();
+		const { title } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		const basePath = joinURL("/kv", title);
+		const keys = await this.collect(this.client.kv.namespaces.keys.list(namespaceId, { account_id: accountId }));
+		return { data: [{
+			id: "metadata.json",
+			path: joinURL(basePath, "metadata.json"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "application/json"
+			}
+		}, {
+			id: "keys",
+			path: joinURL(basePath, "keys"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: keys.length
+			}
+		}] };
+	}
+	async listKVKeys(ctx) {
+		this.ensureNotDestroyed();
+		const { title } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		return { data: (await this.collect(this.client.kv.namespaces.keys.list(namespaceId, { account_id: accountId }))).map((k) => ({
+			id: k.name,
+			path: joinURL("/kv", title, "keys", k.name),
+			meta: {
+				kind: KINDS.KV_KEY,
+				kinds: [KINDS.KV_KEY, KINDS.NODE]
+			}
+		})) };
+	}
+	async readKV(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const namespaces = await this.collect(this.client.kv.namespaces.list({ account_id: accountId }));
+		return {
+			id: "kv",
+			path: "/kv",
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: namespaces.length
+			}
+		};
+	}
+	async readKVNamespaceDir(ctx) {
+		return {
+			id: ctx.params.title,
+			path: joinURL("/kv", ctx.params.title),
+			content: "",
+			meta: {
+				kind: KINDS.KV_NAMESPACE,
+				kinds: [KINDS.KV_NAMESPACE, KINDS.NODE],
+				childrenCount: 2
+			}
+		};
+	}
+	async readKVMetadata(ctx) {
+		this.ensureNotDestroyed();
+		const { title } = ctx.params;
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		const content = JSON.stringify({
+			id: namespaceId,
+			title
+		}, null, 2);
+		return {
+			id: "metadata.json",
+			path: joinURL("/kv", title, "metadata.json"),
+			content,
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "application/json"
+			}
+		};
+	}
+	async readKVKeysDir(ctx) {
+		this.ensureNotDestroyed();
+		const { title } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		const keys = await this.collect(this.client.kv.namespaces.keys.list(namespaceId, { account_id: accountId }));
+		return {
+			id: "keys",
+			path: joinURL("/kv", title, "keys"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: keys.length
+			}
+		};
+	}
+	async readKVKey(ctx) {
+		this.ensureNotDestroyed();
+		const { title, key } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		const decodedKey = key;
+		try {
+			const response = await this.client.kv.namespaces.values.get(namespaceId, decodedKey, { account_id: accountId });
+			if (!response) throw new AFSNotFoundError(`KV key not found: ${decodedKey}`);
+			const content = response instanceof Response ? await response.text() : typeof response === "string" ? response : String(response);
+			return {
+				id: decodedKey,
+				path: joinURL("/kv", title, "keys", key),
+				content,
+				meta: {
+					kind: KINDS.KV_KEY,
+					kinds: [KINDS.KV_KEY, KINDS.NODE]
+				}
+			};
+		} catch (error) {
+			if (error instanceof AFSNotFoundError) throw error;
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async metaKV(_ctx) {
+		return {
+			id: "kv",
+			path: "/kv/.meta",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaKVNamespace(ctx) {
+		this.ensureNotDestroyed();
+		const { title } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		return {
+			id: title,
+			path: joinURL("/kv", title, ".meta"),
+			meta: {
+				kind: KINDS.KV_NAMESPACE,
+				kinds: [KINDS.KV_NAMESPACE, KINDS.NODE],
+				childrenCount: 2,
+				namespaceId,
+				title,
+				platformRef: generateKVPlatformRef(accountId, namespaceId)
+			}
+		};
+	}
+	async statKV(ctx) {
+		const parts = ctx.path.replace(/\/.stat$/, "").split("/").filter(Boolean);
+		return { data: {
+			id: parts[parts.length - 1] || "kv",
+			path: ctx.path.replace(/\/.stat$/, ""),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		} };
+	}
+	async explainKV(_ctx) {
+		return {
+			format: "markdown",
+			content: `# KV Namespaces
+
+Cloudflare KV is a global, low-latency key-value data store. Each namespace contains:
+- \`metadata.json\` — Namespace configuration
+- \`keys/\` — Key-value pairs (read/write/delete)
+`
+		};
+	}
+	async explainKVNamespace(ctx) {
+		return {
+			format: "markdown",
+			content: `# KV Namespace: ${ctx.params.title}
+
+## Structure
+- \`metadata.json\` — Namespace metadata
+- \`keys/\` — All key-value pairs
+
+## Actions
+- \`delete\` — Delete this namespace (requires confirm: true)
+`
+		};
+	}
+	async writeKVKey(ctx, payload) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { title, key } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		const decodedKey = key;
+		const content = typeof payload.content === "string" ? payload.content : JSON.stringify(payload.content);
+		try {
+			await this.client.kv.namespaces.values.update(namespaceId, decodedKey, {
+				account_id: accountId,
+				value: content
+			});
+			this.cache.invalidate(`list:kv:${title}`);
+			return { data: {
+				id: decodedKey,
+				path: joinURL("/kv", title, "keys", key),
+				content,
+				meta: {
+					kind: KINDS.KV_KEY,
+					kinds: [KINDS.KV_KEY, KINDS.NODE]
+				}
+			} };
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async deleteKVKey(ctx) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { title, key } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		const decodedKey = key;
+		try {
+			await this.client.kv.namespaces.values.delete(namespaceId, decodedKey, { account_id: accountId });
+			this.cache.invalidate(`list:kv:${title}`);
+			return { message: `Key '${decodedKey}' deleted` };
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async listRootKVActions(_ctx) {
+		if (this.config.accessMode !== "readwrite") throw new AFSNotFoundError("Actions not available in readonly mode");
+		return { data: [{
+			id: "create",
+			path: "/kv/.actions/create",
+			summary: "Create a new KV namespace",
+			meta: {
+				kind: KINDS.EXECUTABLE,
+				kinds: [KINDS.EXECUTABLE, KINDS.NODE],
+				inputSchema: {
+					type: "object",
+					required: ["title"],
+					properties: { title: {
+						type: "string",
+						description: "Namespace title"
+					} }
+				}
+			}
+		}] };
+	}
+	async execKVCreate(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const accountId = await this.accountId();
+		const title = args.title;
+		if (!title) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "title is required"
+			}
+		};
+		try {
+			const namespace = await this.client.kv.namespaces.create({
+				account_id: accountId,
+				title
+			});
+			this.cache.invalidate("list:kv");
+			return {
+				success: true,
+				data: {
+					id: namespace.id,
+					title: namespace.title
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async listKVActions(ctx) {
+		if (this.config.accessMode !== "readwrite") throw new AFSNotFoundError("Actions not available in readonly mode");
+		return { data: [{
+			id: "delete",
+			path: joinURL(joinURL("/kv", ctx.params.title, ".actions"), "delete"),
+			summary: "Delete namespace (requires confirm: true)",
+			meta: {
+				kind: KINDS.EXECUTABLE,
+				kinds: [KINDS.EXECUTABLE, KINDS.NODE],
+				inputSchema: {
+					type: "object",
+					required: ["confirm"],
+					properties: { confirm: {
+						type: "boolean",
+						description: "Must be true to confirm deletion"
+					} }
+				}
+			}
+		}] };
+	}
+	async execKVDelete(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		if (args.confirm !== true) throw confirmationRequired("delete", ctx.path);
+		const { title } = ctx.params;
+		const accountId = await this.accountId();
+		const namespaceId = await this.resolveKVNamespaceId(title);
+		try {
+			await this.client.kv.namespaces.delete(namespaceId, { account_id: accountId });
+			this.cache.invalidate("list:kv");
+			this.cache.invalidate(`kv:title:${title}`);
+			return {
+				success: true,
+				data: { deleted: title }
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async searchKV(_ctx, query, options) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const matched = (await this.collect(this.client.kv.namespaces.list({ account_id: accountId }))).filter((ns) => minimatch(ns.title, query));
+		const limit = options?.limit ?? 100;
+		return { data: matched.slice(0, limit).map((ns) => ({
+			id: ns.title,
+			path: joinURL("/kv", ns.title),
+			summary: ns.title,
+			meta: {
+				kind: KINDS.KV_NAMESPACE,
+				kinds: [KINDS.KV_NAMESPACE, KINDS.NODE]
+			}
+		})) };
+	}
+	async listPages(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const cacheKey = "list:pages";
+		const cached = this.cache.get(cacheKey);
+		if (cached) return { data: cached };
+		const entries = (await this.collect(this.client.pages.projects.list({ account_id: accountId }))).map((p) => ({
+			id: p.name,
+			path: joinURL("/pages", p.name),
+			summary: p.name,
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE],
+				childrenCount: 3
+			}
+		}));
+		this.cache.set(cacheKey, entries);
+		return { data: entries };
+	}
+	async listPagesProjectDir(ctx) {
+		this.ensureNotDestroyed();
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		const basePath = joinURL("/pages", project);
+		const [deployments, domains] = await Promise.all([this.collect(this.client.pages.projects.deployments.list(project, { account_id: accountId })), this.collect(this.client.pages.projects.domains.list(project, { account_id: accountId }))]);
+		return { data: [
+			{
+				id: "metadata.json",
+				path: joinURL(basePath, "metadata.json"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					contentType: "application/json"
+				}
+			},
+			{
+				id: "deployments",
+				path: joinURL(basePath, "deployments"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: deployments.length
+				}
+			},
+			{
+				id: "domains",
+				path: joinURL(basePath, "domains"),
+				meta: {
+					kind: KINDS.NODE,
+					kinds: [KINDS.NODE],
+					childrenCount: domains.length
+				}
+			}
+		] };
+	}
+	async listPagesDeployments(ctx) {
+		this.ensureNotDestroyed();
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		return { data: (await this.collect(this.client.pages.projects.deployments.list(project, { account_id: accountId }))).map((d) => ({
+			id: d.id,
+			path: joinURL("/pages", project, "deployments", d.id),
+			summary: `${d.environment} - ${d.created_on}`,
+			meta: {
+				kind: KINDS.DEPLOYMENT,
+				kinds: [KINDS.DEPLOYMENT, KINDS.NODE]
+			}
+		})) };
+	}
+	async listPagesDomains(ctx) {
+		this.ensureNotDestroyed();
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		return { data: (await this.collect(this.client.pages.projects.domains.list(project, { account_id: accountId }))).map((d) => ({
+			id: d.name,
+			path: joinURL("/pages", project, "domains", d.name),
+			content: JSON.stringify(d, null, 2),
+			meta: {
+				kind: KINDS.DOMAIN,
+				kinds: [KINDS.DOMAIN, KINDS.NODE]
+			}
+		})) };
+	}
+	async readPages(_ctx) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const projects = await this.collect(this.client.pages.projects.list({ account_id: accountId }));
+		return {
+			id: "pages",
+			path: "/pages",
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: projects.length
+			}
+		};
+	}
+	async readPagesProjectDir(ctx) {
+		return {
+			id: ctx.params.project,
+			path: joinURL("/pages", ctx.params.project),
+			content: "",
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE],
+				childrenCount: 3
+			}
+		};
+	}
+	async readPagesMetadata(ctx) {
+		this.ensureNotDestroyed();
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		const projectData = await this.client.pages.projects.get(project, { account_id: accountId });
+		if (!projectData) throw new AFSNotFoundError(`Pages project not found: ${project}`);
+		const content = JSON.stringify(projectData, null, 2);
+		return {
+			id: "metadata.json",
+			path: joinURL("/pages", project, "metadata.json"),
+			content,
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				contentType: "application/json"
+			}
+		};
+	}
+	async readPagesDeploymentsDir(ctx) {
+		this.ensureNotDestroyed();
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		const deployments = await this.collect(this.client.pages.projects.deployments.list(project, { account_id: accountId }));
+		return {
+			id: "deployments",
+			path: joinURL("/pages", project, "deployments"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: deployments.length
+			}
+		};
+	}
+	async readPagesDeployment(ctx) {
+		this.ensureNotDestroyed();
+		const { project, id } = ctx.params;
+		const accountId = await this.accountId();
+		const deployment = await this.client.pages.projects.deployments.get(project, id, { account_id: accountId });
+		if (!deployment) throw new AFSNotFoundError(`Deployment not found: ${id}`);
+		return {
+			id,
+			path: joinURL("/pages", project, "deployments", id),
+			content: JSON.stringify(deployment, null, 2),
+			meta: {
+				kind: KINDS.DEPLOYMENT,
+				kinds: [KINDS.DEPLOYMENT, KINDS.NODE]
+			}
+		};
+	}
+	async readPagesDomainsDir(ctx) {
+		this.ensureNotDestroyed();
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		const domains = await this.collect(this.client.pages.projects.domains.list(project, { account_id: accountId }));
+		return {
+			id: "domains",
+			path: joinURL("/pages", project, "domains"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: domains.length
+			}
+		};
+	}
+	async readPagesDomain(ctx) {
+		this.ensureNotDestroyed();
+		const { project, domain } = ctx.params;
+		const accountId = await this.accountId();
+		const found = (await this.collect(this.client.pages.projects.domains.list(project, { account_id: accountId }))).find((d) => d.name === domain);
+		if (!found) throw new AFSNotFoundError(`Domain not found: ${domain}`);
+		return {
+			id: domain,
+			path: joinURL("/pages", project, "domains", domain),
+			content: JSON.stringify(found, null, 2),
+			meta: {
+				kind: KINDS.DOMAIN,
+				kinds: [KINDS.DOMAIN, KINDS.NODE]
+			}
+		};
+	}
+	async metaPages(_ctx) {
+		return {
+			id: "pages",
+			path: "/pages/.meta",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async metaPagesProject(ctx) {
+		this.ensureNotDestroyed();
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		const projectData = await this.client.pages.projects.get(project, { account_id: accountId });
+		if (!projectData) throw new AFSNotFoundError(`Pages project not found: ${project}`);
+		const domains = await this.collect(this.client.pages.projects.domains.list(project, { account_id: accountId }));
+		return {
+			id: project,
+			path: joinURL("/pages", project, ".meta"),
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE],
+				childrenCount: 3,
+				projectName: project,
+				subdomain: projectData.subdomain,
+				productionBranch: projectData.production_branch,
+				latestDeployment: projectData.latest_deployment ? {
+					id: projectData.latest_deployment.id,
+					url: projectData.latest_deployment.url,
+					environment: projectData.latest_deployment.environment,
+					createdOn: projectData.latest_deployment.created_on
+				} : void 0,
+				domainCount: domains.length,
+				platformRef: generatePagesPlatformRef(accountId, project)
+			}
+		};
+	}
+	async statPages(ctx) {
+		const parts = ctx.path.replace(/\/.stat$/, "").split("/").filter(Boolean);
+		return { data: {
+			id: parts[parts.length - 1] || "pages",
+			path: ctx.path.replace(/\/.stat$/, ""),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		} };
+	}
+	async explainPages(_ctx) {
+		return {
+			format: "markdown",
+			content: `# Pages Projects
+
+Cloudflare Pages provides static site hosting with CI/CD. Each project contains:
+- \`metadata.json\` — Project configuration
+- \`deployments/\` — Deployment history
+- \`domains/\` — Custom domains
+`
+		};
+	}
+	async explainPagesProject(ctx) {
+		return {
+			format: "markdown",
+			content: `# Pages Project: ${ctx.params.project}
+
+## Structure
+- \`metadata.json\` — Project metadata
+- \`deployments/\` — Deployment history
+- \`domains/\` — Custom domain mappings
+
+## Actions
+- \`deploy\` — Deploy new version
+- \`rollback\` — Rollback to a specific deployment
+- \`delete\` — Delete project (requires confirm: true)
+`
+		};
+	}
+	async listRootPagesActions(_ctx) {
+		if (this.config.accessMode !== "readwrite") throw new AFSNotFoundError("Actions not available in readonly mode");
+		return { data: [{
+			id: "create",
+			path: "/pages/.actions/create",
+			summary: "Create a new Pages project and deploy files",
+			meta: {
+				kind: KINDS.EXECUTABLE,
+				kinds: [KINDS.EXECUTABLE, KINDS.NODE],
+				inputSchema: {
+					type: "object",
+					required: ["name", "directory"],
+					properties: {
+						name: {
+							type: "string",
+							description: "Project name"
+						},
+						directory: {
+							type: "string",
+							description: "AFS directory path containing static files to deploy"
+						},
+						productionBranch: {
+							type: "string",
+							description: "Production branch name (default: \"main\")"
+						}
+					}
+				}
+			}
+		}] };
+	}
+	async execPagesCreate(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const accountId = await this.accountId();
+		const name = args.name;
+		const directory = args.directory;
+		const productionBranch = args.productionBranch || "main";
+		if (!name) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "name is required"
+			}
+		};
+		if (!directory) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "directory (AFS path) is required"
+			}
+		};
+		this.validateAfsPath(directory);
+		const afs = this.getAfsFromContext(ctx);
+		try {
+			await this.client.pages.projects.create({
+				account_id: accountId,
+				name,
+				production_branch: productionBranch
+			});
+			const deployment = await this.uploadPagesFiles(name, afs, directory);
+			this.cache.invalidate("list:pages");
+			return {
+				success: true,
+				data: {
+					name,
+					deploymentId: deployment.id,
+					url: deployment.url
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	/**
+	* Upload files to a Pages project via the Direct Upload API.
+	*
+	* Follows the same multi-step flow as wrangler:
+	* 1. Read files from AFS directory
+	* 2. Hash each file with BLAKE3 (base64Content + extension, truncated to 32 hex chars)
+	* 3. Get upload JWT token
+	* 4. Check which files are missing (deduplication)
+	* 5. Upload missing files as JSON with base64 content
+	* 6. Upsert all hashes
+	* 7. Create deployment with manifest
+	*/
+	async uploadPagesFiles(projectName, afs, directory) {
+		const accountId = await this.accountId();
+		const apiToken = this.config.apiToken || process.env.CLOUDFLARE_API_TOKEN;
+		if (!apiToken) throw new Error("API token is required for Pages Direct Upload. Set apiToken in config or CLOUDFLARE_API_TOKEN env var.");
+		const baseUrl = "https://api.cloudflare.com/client/v4";
+		const files = await this.readDirectoryFiles(afs, directory);
+		let workerScript;
+		const staticFiles = /* @__PURE__ */ new Map();
+		for (const [filePath, content] of files) if (filePath === "_worker.js") workerScript = content;
+		else staticFiles.set(filePath, content);
+		const { hash: blake3hash } = await import("blake3-wasm");
+		const manifest = {};
+		const uploadEntries = [];
+		for (const [filePath, content] of staticFiles) {
+			const base64Content = Buffer.from(content, "utf-8").toString("base64");
+			const hash = blake3hash(base64Content + (filePath.includes(".") ? filePath.split(".").pop() : "")).toString("hex").slice(0, 32);
+			manifest[`/${filePath}`] = hash;
+			uploadEntries.push({
+				key: hash,
+				value: base64Content,
+				metadata: { contentType: this.getContentType(filePath) },
+				base64: true
+			});
+		}
+		const tokenRes = await fetch(`${baseUrl}/accounts/${accountId}/pages/projects/${projectName}/upload-token`, { headers: { Authorization: `Bearer ${apiToken}` } });
+		if (!tokenRes.ok) throw new Error(`Failed to get upload token: ${tokenRes.status} ${await tokenRes.text()}`);
+		const jwt = (await tokenRes.json()).result?.jwt;
+		if (!jwt) throw new Error("Failed to get upload JWT from Cloudflare");
+		const allHashes = uploadEntries.map((e) => e.key);
+		const checkRes = await fetch(`${baseUrl}/pages/assets/check-missing`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${jwt}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ hashes: allHashes })
+		});
+		if (!checkRes.ok) throw new Error(`Failed to check missing assets: ${checkRes.status} ${await checkRes.text()}`);
+		const missingHashes = new Set((await checkRes.json()).result || []);
+		const toUpload = uploadEntries.filter((e) => missingHashes.has(e.key));
+		if (toUpload.length > 0) {
+			const uploadRes = await fetch(`${baseUrl}/pages/assets/upload`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${jwt}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify(toUpload)
+			});
+			if (!uploadRes.ok) throw new Error(`Failed to upload files: ${uploadRes.status} ${await uploadRes.text()}`);
+		}
+		const upsertRes = await fetch(`${baseUrl}/pages/assets/upsert-hashes`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${jwt}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ hashes: allHashes })
+		});
+		if (!upsertRes.ok) throw new Error(`Failed to upsert hashes: ${upsertRes.status} ${await upsertRes.text()}`);
+		const formData = new FormData();
+		formData.append("manifest", JSON.stringify(manifest));
+		if (workerScript) formData.append("_worker.js", new Blob([workerScript], { type: "application/javascript+module" }), "_worker.js");
+		const deployRes = await fetch(`${baseUrl}/accounts/${accountId}/pages/projects/${projectName}/deployments`, {
+			method: "POST",
+			headers: { Authorization: `Bearer ${apiToken}` },
+			body: formData
+		});
+		if (!deployRes.ok) throw new Error(`Failed to create deployment: ${deployRes.status} ${await deployRes.text()}`);
+		const { result } = await deployRes.json();
+		return {
+			id: result?.id || "unknown",
+			url: result?.url || `https://${projectName}.pages.dev`
+		};
+	}
+	async listPagesActions(ctx) {
+		if (this.config.accessMode !== "readwrite") throw new AFSNotFoundError("Actions not available in readonly mode");
+		const basePath = joinURL("/pages", ctx.params.project, ".actions");
+		return { data: [
+			{
+				id: "deploy",
+				path: joinURL(basePath, "deploy"),
+				summary: "Deploy new version",
+				meta: {
+					kind: KINDS.EXECUTABLE,
+					kinds: [KINDS.EXECUTABLE, KINDS.NODE]
+				}
+			},
+			{
+				id: "rollback",
+				path: joinURL(basePath, "rollback"),
+				summary: "Rollback to specific deployment",
+				meta: {
+					kind: KINDS.EXECUTABLE,
+					kinds: [KINDS.EXECUTABLE, KINDS.NODE]
+				}
+			},
+			{
+				id: "delete",
+				path: joinURL(basePath, "delete"),
+				summary: "Delete project (requires confirm: true)",
+				meta: {
+					kind: KINDS.EXECUTABLE,
+					kinds: [KINDS.EXECUTABLE, KINDS.NODE],
+					inputSchema: {
+						type: "object",
+						required: ["confirm"],
+						properties: { confirm: {
+							type: "boolean",
+							description: "Must be true to confirm deletion"
+						} }
+					}
+				}
+			},
+			{
+				id: "configure-bindings",
+				path: joinURL(basePath, "configure-bindings"),
+				summary: "Configure Pages Functions bindings (KV, D1, R2, etc.)",
+				meta: {
+					kind: KINDS.EXECUTABLE,
+					kinds: [KINDS.EXECUTABLE, KINDS.NODE],
+					inputSchema: {
+						type: "object",
+						properties: {
+							environment: {
+								type: "string",
+								description: "Environment to configure (default: production)"
+							},
+							kv_namespaces: {
+								type: "object",
+								description: "KV namespace bindings, e.g. {\"KV\":{\"namespace_id\":\"...\"}}"
+							},
+							d1_databases: {
+								type: "object",
+								description: "D1 database bindings, e.g. {\"DB\":{\"id\":\"...\"}}"
+							},
+							r2_buckets: {
+								type: "object",
+								description: "R2 bucket bindings, e.g. {\"BUCKET\":{\"name\":\"...\"}}"
+							},
+							compatibility_date: {
+								type: "string",
+								description: "Compatibility date for Pages Functions"
+							}
+						}
+					}
+				}
+			}
+		] };
+	}
+	async execPagesDeploy(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			const directory = args.directory;
+			if (directory) {
+				this.validateAfsPath(directory);
+				const afs = this.getAfsFromContext(ctx);
+				const deployment$1 = await this.uploadPagesFiles(project, afs, directory);
+				this.cache.invalidate("list:pages");
+				return {
+					success: true,
+					data: {
+						deploymentId: deployment$1.id,
+						url: deployment$1.url
+					}
+				};
+			}
+			const deployment = await this.client.pages.projects.deployments.create(project, { account_id: accountId });
+			this.cache.invalidate("list:pages");
+			return {
+				success: true,
+				data: {
+					deploymentId: deployment?.id,
+					url: deployment?.url
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async execPagesRollback(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		const deploymentId = args.deploymentId;
+		try {
+			const deployment = await this.client.pages.projects.deployments.create(project, { account_id: accountId });
+			this.cache.invalidate("list:pages");
+			return {
+				success: true,
+				data: {
+					deploymentId: deployment?.id,
+					rolledBackTo: deploymentId
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async execPagesDelete(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		if (args.confirm !== true) throw confirmationRequired("delete", ctx.path);
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		try {
+			await this.client.pages.projects.delete(project, { account_id: accountId });
+			this.cache.invalidate("list:pages");
+			return {
+				success: true,
+				data: { deleted: project }
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async execPagesConfigureBindings(ctx, args) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		const { project } = ctx.params;
+		const accountId = await this.accountId();
+		const environment = args.environment || "production";
+		const envConfig = {};
+		if (args.kv_namespaces) envConfig.kv_namespaces = args.kv_namespaces;
+		if (args.d1_databases) envConfig.d1_databases = args.d1_databases;
+		if (args.r2_buckets) envConfig.r2_buckets = args.r2_buckets;
+		if (args.compatibility_date) envConfig.compatibility_date = args.compatibility_date;
+		try {
+			await this.client.pages.projects.edit(project, {
+				account_id: accountId,
+				deployment_configs: { [environment]: envConfig }
+			});
+			this.cache.invalidate("list:pages");
+			return {
+				success: true,
+				data: {
+					project,
+					environment,
+					bindings: Object.keys(envConfig)
+				}
+			};
+		} catch (error) {
+			throw mapCloudflareError(error, ctx.path);
+		}
+	}
+	async searchPages(_ctx, query, options) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const matched = (await this.collect(this.client.pages.projects.list({ account_id: accountId }))).filter((p) => minimatch(p.name, query));
+		const limit = options?.limit ?? 100;
+		return { data: matched.slice(0, limit).map((p) => ({
+			id: p.name,
+			path: joinURL("/pages", p.name),
+			summary: p.name,
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE]
+			}
+		})) };
+	}
+	async listByZone(_ctx) {
+		this.ensureNotDestroyed();
+		const cacheKey = "list:by-zone";
+		const cached = this.cache.get(cacheKey);
+		if (cached) return { data: cached };
+		const entries = (await this.collect(this.client.zones.list())).map((z) => ({
+			id: z.name,
+			path: joinURL("/by-zone", z.name),
+			summary: z.name,
+			meta: {
+				kind: KINDS.ZONE,
+				kinds: [KINDS.ZONE, KINDS.NODE],
+				childrenCount: 2
+			}
+		}));
+		this.cache.set(cacheKey, entries);
+		return { data: entries };
+	}
+	async listByZoneDir(ctx) {
+		this.ensureNotDestroyed();
+		const { zone } = ctx.params;
+		const accountId = await this.accountId();
+		const basePath = joinURL("/by-zone", zone);
+		const zoneData = (await this.collect(this.client.zones.list())).find((z) => z.name === zone);
+		let workerCount = 0;
+		if (zoneData) {
+			const routes = await this.collect(this.client.workers.routes.list({ zone_id: zoneData.id }));
+			workerCount = [...new Set(routes.map((r) => r.script).filter(Boolean))].length;
+		}
+		const projects = await this.collect(this.client.pages.projects.list({ account_id: accountId }));
+		let pagesCount = 0;
+		for (const project of projects) if ((await this.collect(this.client.pages.projects.domains.list(project.name, { account_id: accountId }))).some((d) => d.name.endsWith(zone))) pagesCount++;
+		return { data: [{
+			id: "workers",
+			path: joinURL(basePath, "workers"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: workerCount
+			}
+		}, {
+			id: "pages",
+			path: joinURL(basePath, "pages"),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: pagesCount
+			}
+		}] };
+	}
+	async listByZoneWorkers(ctx) {
+		this.ensureNotDestroyed();
+		const { zone } = ctx.params;
+		const zoneData = (await this.collect(this.client.zones.list())).find((z) => z.name === zone);
+		if (!zoneData) throw new AFSNotFoundError(`Zone not found: ${zone}`);
+		const routes = await this.collect(this.client.workers.routes.list({ zone_id: zoneData.id }));
+		return { data: [...new Set(routes.map((r) => r.script).filter(Boolean))].map((name) => ({
+			id: name,
+			path: joinURL("/by-zone", zone, "workers", name),
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE]
+			}
+		})) };
+	}
+	async listByZonePages(ctx) {
+		this.ensureNotDestroyed();
+		const { zone } = ctx.params;
+		const accountId = await this.accountId();
+		const projects = await this.collect(this.client.pages.projects.list({ account_id: accountId }));
+		const matchingProjects = [];
+		for (const project of projects) if ((await this.collect(this.client.pages.projects.domains.list(project.name, { account_id: accountId }))).some((d) => d.name.endsWith(zone))) matchingProjects.push({
+			id: project.name,
+			path: joinURL("/by-zone", zone, "pages", project.name),
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE]
+			}
+		});
+		return { data: matchingProjects };
+	}
+	async readByZone(_ctx) {
+		this.ensureNotDestroyed();
+		const zones = await this.collect(this.client.zones.list());
+		return {
+			id: "by-zone",
+			path: "/by-zone",
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: zones.length
+			}
+		};
+	}
+	async readByZoneDir(ctx) {
+		return {
+			id: ctx.params.zone,
+			path: joinURL("/by-zone", ctx.params.zone),
+			content: "",
+			meta: {
+				kind: KINDS.ZONE,
+				kinds: [KINDS.ZONE, KINDS.NODE],
+				childrenCount: 2
+			}
+		};
+	}
+	async readByZoneWorkersDir(ctx) {
+		this.ensureNotDestroyed();
+		const { zone } = ctx.params;
+		const zoneData = (await this.collect(this.client.zones.list())).find((z) => z.name === zone);
+		if (!zoneData) throw new AFSNotFoundError(`Zone not found: ${zone}`);
+		const routes = await this.collect(this.client.workers.routes.list({ zone_id: zoneData.id }));
+		const workerNames = [...new Set(routes.map((r) => r.script).filter(Boolean))];
+		return {
+			id: "workers",
+			path: joinURL("/by-zone", zone, "workers"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: workerNames.length
+			}
+		};
+	}
+	async readByZoneWorker(ctx) {
+		return {
+			id: ctx.params.name,
+			path: joinURL("/by-zone", ctx.params.zone, "workers", ctx.params.name),
+			content: "",
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE]
+			}
+		};
+	}
+	async readByZonePagesDir(ctx) {
+		this.ensureNotDestroyed();
+		const { zone } = ctx.params;
+		const accountId = await this.accountId();
+		const projects = await this.collect(this.client.pages.projects.list({ account_id: accountId }));
+		let matchCount = 0;
+		for (const project of projects) if ((await this.collect(this.client.pages.projects.domains.list(project.name, { account_id: accountId }))).some((d) => d.name.endsWith(zone))) matchCount++;
+		return {
+			id: "pages",
+			path: joinURL("/by-zone", zone, "pages"),
+			content: "",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE],
+				childrenCount: matchCount
+			}
+		};
+	}
+	async readByZoneProject(ctx) {
+		return {
+			id: ctx.params.project,
+			path: joinURL("/by-zone", ctx.params.zone, "pages", ctx.params.project),
+			content: "",
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE]
+			}
+		};
+	}
+	async metaByZone(_ctx) {
+		return {
+			id: "by-zone",
+			path: "/by-zone/.meta",
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		};
+	}
+	async statByZone(ctx) {
+		const parts = ctx.path.replace(/\/.stat$/, "").split("/").filter(Boolean);
+		return { data: {
+			id: parts[parts.length - 1] || "by-zone",
+			path: ctx.path.replace(/\/.stat$/, ""),
+			meta: {
+				kind: KINDS.NODE,
+				kinds: [KINDS.NODE]
+			}
+		} };
+	}
+	async explainByZone(_ctx) {
+		return {
+			format: "markdown",
+			content: `# By Zone
+
+Resources grouped by DNS zone. Workers are associated through route bindings, Pages through custom domains.
+`
+		};
+	}
+	async searchRoot(_ctx, query, options) {
+		this.ensureNotDestroyed();
+		const accountId = await this.accountId();
+		const limit = options?.limit ?? 100;
+		const results = [];
+		const [workers, kvNamespaces, pagesProjects] = await Promise.all([
+			this.collect(this.client.workers.scripts.list({ account_id: accountId })),
+			this.collect(this.client.kv.namespaces.list({ account_id: accountId })),
+			this.collect(this.client.pages.projects.list({ account_id: accountId }))
+		]);
+		for (const w of workers) if (minimatch(w.id, query) && results.length < limit) results.push({
+			id: w.id,
+			path: joinURL("/workers", w.id),
+			summary: w.id,
+			meta: {
+				kind: KINDS.WORKER,
+				kinds: [KINDS.WORKER, KINDS.NODE]
+			}
+		});
+		for (const ns of kvNamespaces) if (minimatch(ns.title, query) && results.length < limit) results.push({
+			id: ns.title,
+			path: joinURL("/kv", ns.title),
+			summary: ns.title,
+			meta: {
+				kind: KINDS.KV_NAMESPACE,
+				kinds: [KINDS.KV_NAMESPACE, KINDS.NODE]
+			}
+		});
+		for (const p of pagesProjects) if (minimatch(p.name, query) && results.length < limit) results.push({
+			id: p.name,
+			path: joinURL("/pages", p.name),
+			summary: p.name,
+			meta: {
+				kind: KINDS.PAGES_PROJECT,
+				kinds: [KINDS.PAGES_PROJECT, KINDS.NODE]
+			}
+		});
+		return { data: results };
+	}
+	async deleteCatchAll(ctx) {
+		this.ensureNotDestroyed();
+		this.requireReadwrite(ctx.path);
+		throw new AFSNotFoundError(`Cannot delete: ${ctx.path}`);
+	}
+	async destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		await this.cfClient.destroy();
+		this.cache.clear();
+	}
+	clearCache() {
+		this.cache.clear();
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			description: this.description,
+			accessMode: this.accessMode,
+			accountId: this.config.accountId
+		};
+	}
+};
+__decorate([List("/")], AFSCloudflare.prototype, "listRoot", null);
+__decorate([Read("/.meta/.capabilities")], AFSCloudflare.prototype, "readCapabilities", null);
+__decorate([Read("/")], AFSCloudflare.prototype, "readRoot", null);
+__decorate([Read("/WORLD.md")], AFSCloudflare.prototype, "readWorldMd", null);
+__decorate([Meta("/")], AFSCloudflare.prototype, "metaRoot", null);
+__decorate([Stat("/"), Stat("/WORLD.md")], AFSCloudflare.prototype, "statRoot", null);
+__decorate([Explain("/")], AFSCloudflare.prototype, "explainRoot", null);
+__decorate([
+	List("/WORLD.md"),
+	List("/workers/:name/script.js"),
+	List("/workers/:name/settings.json"),
+	List("/workers/:name/bindings/:binding"),
+	List("/workers/:name/routes/:route+"),
+	List("/workers/:name/cron-triggers/:cron+"),
+	List("/kv/:title/metadata.json"),
+	List("/kv/:title/keys/:key+"),
+	List("/pages/:project/metadata.json"),
+	List("/pages/:project/deployments/:id"),
+	List("/pages/:project/domains/:domain"),
+	List("/by-zone/:zone/workers/:name"),
+	List("/by-zone/:zone/pages/:project")
+], AFSCloudflare.prototype, "listFileNode", null);
+__decorate([Meta("/WORLD.md")], AFSCloudflare.prototype, "metaWorldMd", null);
+__decorate([Meta("/workers/:name/script.js")], AFSCloudflare.prototype, "metaWorkerScript", null);
+__decorate([Meta("/workers/:name/settings.json")], AFSCloudflare.prototype, "metaWorkerSettings", null);
+__decorate([Meta("/workers/:name/bindings")], AFSCloudflare.prototype, "metaWorkerBindings", null);
+__decorate([Meta("/workers/:name/bindings/:binding")], AFSCloudflare.prototype, "metaWorkerBinding", null);
+__decorate([Meta("/workers/:name/routes")], AFSCloudflare.prototype, "metaWorkerRoutes", null);
+__decorate([Meta("/workers/:name/routes/:route+")], AFSCloudflare.prototype, "metaWorkerRoute", null);
+__decorate([Meta("/workers/:name/cron-triggers")], AFSCloudflare.prototype, "metaWorkerCronTriggers", null);
+__decorate([Meta("/workers/:name/cron-triggers/:cron+")], AFSCloudflare.prototype, "metaWorkerCronTrigger", null);
+__decorate([Meta("/kv/:title/metadata.json")], AFSCloudflare.prototype, "metaKVMetadataFile", null);
+__decorate([Meta("/kv/:title/keys")], AFSCloudflare.prototype, "metaKVKeys", null);
+__decorate([Meta("/kv/:title/keys/:key+")], AFSCloudflare.prototype, "metaKVKey", null);
+__decorate([Meta("/pages/:project/metadata.json")], AFSCloudflare.prototype, "metaPagesMetadataFile", null);
+__decorate([Meta("/pages/:project/deployments")], AFSCloudflare.prototype, "metaPagesDeployments", null);
+__decorate([Meta("/pages/:project/deployments/:id")], AFSCloudflare.prototype, "metaPagesDeployment", null);
+__decorate([Meta("/pages/:project/domains")], AFSCloudflare.prototype, "metaPagesDomains", null);
+__decorate([Meta("/pages/:project/domains/:domain")], AFSCloudflare.prototype, "metaPagesDomain", null);
+__decorate([Meta("/by-zone/:zone")], AFSCloudflare.prototype, "metaByZoneDir", null);
+__decorate([Meta("/by-zone/:zone/workers")], AFSCloudflare.prototype, "metaByZoneWorkers", null);
+__decorate([Meta("/by-zone/:zone/workers/:name")], AFSCloudflare.prototype, "metaByZoneWorker", null);
+__decorate([Meta("/by-zone/:zone/pages")], AFSCloudflare.prototype, "metaByZonePages", null);
+__decorate([Meta("/by-zone/:zone/pages/:project")], AFSCloudflare.prototype, "metaByZoneProject", null);
+__decorate([Actions("")], AFSCloudflare.prototype, "listGlobalActions", null);
+__decorate([Actions.Exec("", "refresh")], AFSCloudflare.prototype, "execRefresh", null);
+__decorate([List("/workers")], AFSCloudflare.prototype, "listWorkers", null);
+__decorate([List("/workers/:name")], AFSCloudflare.prototype, "listWorkerDir", null);
+__decorate([List("/workers/:name/bindings")], AFSCloudflare.prototype, "listWorkerBindings", null);
+__decorate([List("/workers/:name/routes")], AFSCloudflare.prototype, "listWorkerRoutes", null);
+__decorate([List("/workers/:name/cron-triggers")], AFSCloudflare.prototype, "listWorkerCronTriggers", null);
+__decorate([Read("/workers")], AFSCloudflare.prototype, "readWorkers", null);
+__decorate([Read("/workers/:name")], AFSCloudflare.prototype, "readWorkerDir", null);
+__decorate([Read("/workers/:name/bindings")], AFSCloudflare.prototype, "readWorkerBindingsDir", null);
+__decorate([Read("/workers/:name/routes")], AFSCloudflare.prototype, "readWorkerRoutesDir", null);
+__decorate([Read("/workers/:name/cron-triggers")], AFSCloudflare.prototype, "readWorkerCronTriggersDir", null);
+__decorate([Read("/workers/:name/script.js")], AFSCloudflare.prototype, "readWorkerScript", null);
+__decorate([Read("/workers/:name/settings.json")], AFSCloudflare.prototype, "readWorkerSettings", null);
+__decorate([Read("/workers/:name/bindings/:binding")], AFSCloudflare.prototype, "readWorkerBinding", null);
+__decorate([Read("/workers/:name/routes/:route+")], AFSCloudflare.prototype, "readWorkerRoute", null);
+__decorate([Read("/workers/:name/cron-triggers/:cron+")], AFSCloudflare.prototype, "readWorkerCronTrigger", null);
+__decorate([Meta("/workers")], AFSCloudflare.prototype, "metaWorkers", null);
+__decorate([Meta("/workers/:name")], AFSCloudflare.prototype, "metaWorker", null);
+__decorate([
+	Stat("/workers"),
+	Stat("/workers/:name"),
+	Stat("/workers/:name/script.js"),
+	Stat("/workers/:name/settings.json"),
+	Stat("/workers/:name/bindings"),
+	Stat("/workers/:name/bindings/:binding"),
+	Stat("/workers/:name/routes"),
+	Stat("/workers/:name/routes/:route+"),
+	Stat("/workers/:name/cron-triggers"),
+	Stat("/workers/:name/cron-triggers/:cron+")
+], AFSCloudflare.prototype, "statWorkers", null);
+__decorate([Explain("/workers")], AFSCloudflare.prototype, "explainWorkers", null);
+__decorate([Explain("/workers/:name")], AFSCloudflare.prototype, "explainWorker", null);
+__decorate([Write("/workers/:name/script.js")], AFSCloudflare.prototype, "writeWorkerScript", null);
+__decorate([Write("/workers/:name/settings.json")], AFSCloudflare.prototype, "writeWorkerSettings", null);
+__decorate([Actions("/workers")], AFSCloudflare.prototype, "listRootWorkerActions", null);
+__decorate([Actions.Exec("/workers", "create")], AFSCloudflare.prototype, "execWorkerCreate", null);
+__decorate([Actions("/workers/:name")], AFSCloudflare.prototype, "listWorkerActions", null);
+__decorate([Actions.Exec("/workers/:name", "deploy")], AFSCloudflare.prototype, "execWorkerDeploy", null);
+__decorate([Actions.Exec("/workers/:name", "rollback")], AFSCloudflare.prototype, "execWorkerRollback", null);
+__decorate([Actions.Exec("/workers/:name", "delete")], AFSCloudflare.prototype, "execWorkerDelete", null);
+__decorate([Search("/workers")], AFSCloudflare.prototype, "searchWorkers", null);
+__decorate([List("/kv")], AFSCloudflare.prototype, "listKV", null);
+__decorate([List("/kv/:title")], AFSCloudflare.prototype, "listKVNamespaceDir", null);
+__decorate([List("/kv/:title/keys")], AFSCloudflare.prototype, "listKVKeys", null);
+__decorate([Read("/kv")], AFSCloudflare.prototype, "readKV", null);
+__decorate([Read("/kv/:title")], AFSCloudflare.prototype, "readKVNamespaceDir", null);
+__decorate([Read("/kv/:title/metadata.json")], AFSCloudflare.prototype, "readKVMetadata", null);
+__decorate([Read("/kv/:title/keys")], AFSCloudflare.prototype, "readKVKeysDir", null);
+__decorate([Read("/kv/:title/keys/:key+")], AFSCloudflare.prototype, "readKVKey", null);
+__decorate([Meta("/kv")], AFSCloudflare.prototype, "metaKV", null);
+__decorate([Meta("/kv/:title")], AFSCloudflare.prototype, "metaKVNamespace", null);
+__decorate([
+	Stat("/kv"),
+	Stat("/kv/:title"),
+	Stat("/kv/:title/metadata.json"),
+	Stat("/kv/:title/keys"),
+	Stat("/kv/:title/keys/:key+")
+], AFSCloudflare.prototype, "statKV", null);
+__decorate([Explain("/kv")], AFSCloudflare.prototype, "explainKV", null);
+__decorate([Explain("/kv/:title")], AFSCloudflare.prototype, "explainKVNamespace", null);
+__decorate([Write("/kv/:title/keys/:key+")], AFSCloudflare.prototype, "writeKVKey", null);
+__decorate([Delete("/kv/:title/keys/:key+")], AFSCloudflare.prototype, "deleteKVKey", null);
+__decorate([Actions("/kv")], AFSCloudflare.prototype, "listRootKVActions", null);
+__decorate([Actions.Exec("/kv", "create")], AFSCloudflare.prototype, "execKVCreate", null);
+__decorate([Actions("/kv/:title")], AFSCloudflare.prototype, "listKVActions", null);
+__decorate([Actions.Exec("/kv/:title", "delete")], AFSCloudflare.prototype, "execKVDelete", null);
+__decorate([Search("/kv")], AFSCloudflare.prototype, "searchKV", null);
+__decorate([List("/pages")], AFSCloudflare.prototype, "listPages", null);
+__decorate([List("/pages/:project")], AFSCloudflare.prototype, "listPagesProjectDir", null);
+__decorate([List("/pages/:project/deployments")], AFSCloudflare.prototype, "listPagesDeployments", null);
+__decorate([List("/pages/:project/domains")], AFSCloudflare.prototype, "listPagesDomains", null);
+__decorate([Read("/pages")], AFSCloudflare.prototype, "readPages", null);
+__decorate([Read("/pages/:project")], AFSCloudflare.prototype, "readPagesProjectDir", null);
+__decorate([Read("/pages/:project/metadata.json")], AFSCloudflare.prototype, "readPagesMetadata", null);
+__decorate([Read("/pages/:project/deployments")], AFSCloudflare.prototype, "readPagesDeploymentsDir", null);
+__decorate([Read("/pages/:project/deployments/:id")], AFSCloudflare.prototype, "readPagesDeployment", null);
+__decorate([Read("/pages/:project/domains")], AFSCloudflare.prototype, "readPagesDomainsDir", null);
+__decorate([Read("/pages/:project/domains/:domain")], AFSCloudflare.prototype, "readPagesDomain", null);
+__decorate([Meta("/pages")], AFSCloudflare.prototype, "metaPages", null);
+__decorate([Meta("/pages/:project")], AFSCloudflare.prototype, "metaPagesProject", null);
+__decorate([
+	Stat("/pages"),
+	Stat("/pages/:project"),
+	Stat("/pages/:project/metadata.json"),
+	Stat("/pages/:project/deployments"),
+	Stat("/pages/:project/deployments/:id"),
+	Stat("/pages/:project/domains"),
+	Stat("/pages/:project/domains/:domain")
+], AFSCloudflare.prototype, "statPages", null);
+__decorate([Explain("/pages")], AFSCloudflare.prototype, "explainPages", null);
+__decorate([Explain("/pages/:project")], AFSCloudflare.prototype, "explainPagesProject", null);
+__decorate([Actions("/pages")], AFSCloudflare.prototype, "listRootPagesActions", null);
+__decorate([Actions.Exec("/pages", "create")], AFSCloudflare.prototype, "execPagesCreate", null);
+__decorate([Actions("/pages/:project")], AFSCloudflare.prototype, "listPagesActions", null);
+__decorate([Actions.Exec("/pages/:project", "deploy")], AFSCloudflare.prototype, "execPagesDeploy", null);
+__decorate([Actions.Exec("/pages/:project", "rollback")], AFSCloudflare.prototype, "execPagesRollback", null);
+__decorate([Actions.Exec("/pages/:project", "delete")], AFSCloudflare.prototype, "execPagesDelete", null);
+__decorate([Actions.Exec("/pages/:project", "configure-bindings")], AFSCloudflare.prototype, "execPagesConfigureBindings", null);
+__decorate([Search("/pages")], AFSCloudflare.prototype, "searchPages", null);
+__decorate([List("/by-zone")], AFSCloudflare.prototype, "listByZone", null);
+__decorate([List("/by-zone/:zone")], AFSCloudflare.prototype, "listByZoneDir", null);
+__decorate([List("/by-zone/:zone/workers")], AFSCloudflare.prototype, "listByZoneWorkers", null);
+__decorate([List("/by-zone/:zone/pages")], AFSCloudflare.prototype, "listByZonePages", null);
+__decorate([Read("/by-zone")], AFSCloudflare.prototype, "readByZone", null);
+__decorate([Read("/by-zone/:zone")], AFSCloudflare.prototype, "readByZoneDir", null);
+__decorate([Read("/by-zone/:zone/workers")], AFSCloudflare.prototype, "readByZoneWorkersDir", null);
+__decorate([Read("/by-zone/:zone/workers/:name")], AFSCloudflare.prototype, "readByZoneWorker", null);
+__decorate([Read("/by-zone/:zone/pages")], AFSCloudflare.prototype, "readByZonePagesDir", null);
+__decorate([Read("/by-zone/:zone/pages/:project")], AFSCloudflare.prototype, "readByZoneProject", null);
+__decorate([Meta("/by-zone")], AFSCloudflare.prototype, "metaByZone", null);
+__decorate([
+	Stat("/by-zone"),
+	Stat("/by-zone/:zone"),
+	Stat("/by-zone/:zone/workers"),
+	Stat("/by-zone/:zone/workers/:name"),
+	Stat("/by-zone/:zone/pages"),
+	Stat("/by-zone/:zone/pages/:project")
+], AFSCloudflare.prototype, "statByZone", null);
+__decorate([Explain("/by-zone")], AFSCloudflare.prototype, "explainByZone", null);
+__decorate([Search("/")], AFSCloudflare.prototype, "searchRoot", null);
+__decorate([Delete("/:path+")], AFSCloudflare.prototype, "deleteCatchAll", null);
+
+//#endregion
+export { AFSCloudflare };
+//# sourceMappingURL=cloudflare-afs.mjs.map