@fungi.computer/cloudflare-worker-bundler 0.0.0-stage → 0.2.3-fungi.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2025 Cloudflare, Inc.
+
+Permission is hereby granted, free of
+charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/NOTICE

@@ -0,0 +1,22 @@
+@fungi.computer/cloudflare-worker-bundler
+Copyright (c) 2025 Cloudflare, Inc.
+
+This package is a fork of @cloudflare/worker-bundler 0.2.3
+(https://github.com/cloudflare/agents/tree/%40cloudflare/worker-bundler%400.2.3/packages/worker-bundler,
+commit d42494503efe836a073fbf911fae1fbd12253198), distributed under the MIT
+License in LICENSE.
+
+Changes from upstream, made by Fungi Computer:
+
+- src/assets.ts: a new `./assets` entry that exports asset serving
+  (handleAssetRequest, buildAssetManifest, buildAssets, createMemoryStorage,
+  inferContentType, isTextContentType) without the esbuild/Sucrase bundler
+  graph. src/index.ts re-exports the same names from it.
+- src/file-system.ts: imports DurableObjectStorage from
+  @cloudflare/workers-types, which is now a dependency, so the published
+  declarations type-check without ambient Workers types.
+- scripts/build.ts: builds the `./assets` entry and drops the upstream
+  monorepo declaration-formatting step.
+- src/index.ts, src/app.ts, src/asset-handler.ts: three expressions rewritten
+  without a redundant spread so the fork passes oxlint's correctness rules.
+- Only the Node-runnable upstream tests (asset-handler, redos) are kept.

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+# @fungi.computer/cloudflare-worker-bundler
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> **Experimental**: this package is under active development and its API may
+> change without notice. Not recommended for production use.
+
+Bundles and serves full-stack applications on Cloudflare's
+[Worker Loader binding](https://developers.cloudflare.com/workers/runtime-apis/bindings/worker-loader/)
+(closed beta). It dynamically generates Workers with real npm dependencies, or
+builds complete apps with client-side bundles and static asset serving.
+
+## Runtime requirement
+
+This package only runs **inside the Cloudflare Workers runtime (`workerd`)** —
+both in production and in `wrangler dev`. It bundles via an `esbuild-wasm`
+`WebAssembly.Module` import that only the Workers module loader can resolve.
+It will **not** work under plain Node.js, including a default-pool
+Vitest/Jest test; test code that depends on it needs
+[`@cloudflare/vitest-pool-workers`](https://developers.cloudflare.com/workers/testing/vitest-integration/).
+
+The `./assets` entry (see below) is the exception: it has no bundler
+dependency and runs anywhere.
+
+## Fungi fork
+
+This package is a Fungi fork of
+[`@cloudflare/worker-bundler`](https://github.com/cloudflare/agents/tree/%40cloudflare/worker-bundler%400.2.3/packages/worker-bundler)
+0.2.3 (commit `d424945`), distributed under the MIT License. Changes from
+upstream, made by Fungi Computer:
+
+- `src/assets.ts`: a new `./assets` entry that exports asset serving
+  (`handleAssetRequest`, `buildAssetManifest`, `buildAssets`,
+  `createMemoryStorage`, `inferContentType`, `isTextContentType`) without the
+  esbuild/Sucrase bundler graph. `src/index.ts` re-exports the same names.
+- `src/file-system.ts`: imports `DurableObjectStorage` from
+  `@cloudflare/workers-types`, now a dependency, so the published
+  declarations type-check without ambient Workers types.
+- `scripts/build.ts`: builds the `./assets` entry and drops the upstream
+  monorepo declaration-formatting step.
+- `src/index.ts`, `src/app.ts`, `src/asset-handler.ts`: three expressions
+  rewritten without a redundant spread so the fork passes oxlint's
+  correctness rules.
+- Only the Node-runnable upstream tests (`asset-handler`, `redos`) are kept.
+
+See [NOTICE](./NOTICE) for the full attribution text.
+
+## Install
+
+```sh
+npm install @fungi.computer/cloudflare-worker-bundler
+```
+
+## Quick start
+
+Bundle a Worker — provide source code and dependencies, the bundler handles
+the rest:
+
+```ts
+import { createWorker } from "@fungi.computer/cloudflare-worker-bundler";
+
+const worker = env.LOADER.get("my-worker", async () => {
+  const { mainModule, modules } = await createWorker({
+    files: {
+      "src/index.ts": `
+        import { Hono } from 'hono';
+        const app = new Hono();
+        app.get('/', (c) => c.text('Hello from Hono!'));
+        export default app;
+      `,
+      "package.json": JSON.stringify({ dependencies: { hono: "^4.0.0" } })
+    }
+  });
+
+  return { mainModule, modules, compatibilityDate: "2026-01-01" };
+});
+
+await worker.getEntrypoint().fetch(request);
+```
+
+Serve static assets from the standalone `./assets` entry (no bundler graph
+required):
+
+```ts
+import {
+  handleAssetRequest,
+  buildAssets
+} from "@fungi.computer/cloudflare-worker-bundler/assets";
+
+const { manifest, storage } = await buildAssets({
+  "/index.html": "<h1>Hello</h1>"
+});
+
+export default {
+  async fetch(request) {
+    const assetResponse = await handleAssetRequest(request, manifest, storage);
+    if (assetResponse) return assetResponse;
+    return new Response("API");
+  }
+};
+```
+
+`createApp` bundles a server Worker, client-side JavaScript, and static
+assets together in one call; see the
+[upstream README](https://github.com/cloudflare/agents/tree/%40cloudflare/worker-bundler%400.2.3/packages/worker-bundler#readme)
+for `createApp`, the full `createWorker`/`createApp` option tables, the
+`FileSystem` interface (`InMemoryFileSystem`, `DurableObjectKVFileSystem`,
+`DurableObjectRawFileSystem`), the in-process TypeScript language service
+(`./typescript` subpath), asset configuration (HTML/not-found handling,
+redirects, headers, caching), and known limitations — none of that changed in
+this fork beyond the `./assets` entry point described above.
+
+## Where it's used
+
+[Oyster](https://github.com/fungi-computer/oyster) uses this fork to bundle
+and serve Worker apps, and uses the `./assets` entry to serve static assets
+without pulling in the bundler.
+
+## License
+
+MIT. This package carries the upstream Cloudflare copyright and license
+unchanged — see [LICENSE](./LICENSE) and [NOTICE](./NOTICE).

package/dist/assets-BlVFmWBF.js

@@ -0,0 +1,464 @@
+//#region src/mime.ts
+/**
+* MIME type inference from file extensions.
+*/
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".htm": "text/html; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".mjs": "application/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".ico": "image/x-icon",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".eot": "application/vnd.ms-fontobject",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".ogg": "audio/ogg",
+	".wav": "audio/wav",
+	".pdf": "application/pdf",
+	".xml": "application/xml",
+	".txt": "text/plain; charset=utf-8",
+	".csv": "text/csv; charset=utf-8",
+	".zip": "application/zip",
+	".gz": "application/gzip",
+	".tar": "application/x-tar",
+	".wasm": "application/wasm",
+	".webmanifest": "application/manifest+json",
+	".map": "application/json"
+};
+/**
+* Get the file extension from a path (including the dot).
+*/
+function getExtension(path) {
+	const lastDot = path.lastIndexOf(".");
+	if (lastDot === -1) return "";
+	if (lastDot < path.lastIndexOf("/")) return "";
+	return path.slice(lastDot).toLowerCase();
+}
+/**
+* Infer MIME type from a file path.
+* Returns undefined if the type is unknown.
+*/
+function inferContentType(path) {
+	const ext = getExtension(path);
+	return MIME_TYPES[ext];
+}
+/**
+* Whether a content type represents a text-based format
+* (used to decide text vs binary module storage).
+*/
+function isTextContentType(contentType) {
+	return contentType.startsWith("text/") || contentType.includes("json") || contentType.includes("xml") || contentType.includes("javascript") || contentType.includes("svg");
+}
+//#endregion
+//#region src/asset-handler.ts
+/**
+* Asset request handler for serving static assets.
+*
+* Key design: the manifest (routing metadata) is separated from the
+* storage (content retrieval). This lets you plug in any backend —
+* in-memory, KV, R2, Workspace, etc.
+*
+* Inspired by Cloudflare's Workers Static Assets behavior and
+* cloudflare-asset-worker by Timo Wilhelm.
+*/
+/**
+* Create an in-memory storage backend from a pathname->content map.
+* This is the zero-config default for small asset sets.
+*/
+function createMemoryStorage(assets) {
+	const map = new Map(Object.entries(assets));
+	return { get(pathname) {
+		return Promise.resolve(map.get(pathname) ?? null);
+	} };
+}
+/**
+* Normalize user config with defaults.
+*/
+function normalizeConfig(config) {
+	const staticRedirects = {};
+	if (config?.redirects?.static) {
+		let lineNumber = 1;
+		for (const [path, rule] of Object.entries(config.redirects.static)) staticRedirects[path] = {
+			...rule,
+			lineNumber: lineNumber++
+		};
+	}
+	return {
+		html_handling: config?.html_handling ?? "auto-trailing-slash",
+		not_found_handling: config?.not_found_handling ?? "none",
+		redirects: {
+			static: staticRedirects,
+			dynamic: config?.redirects?.dynamic ?? {}
+		},
+		headers: config?.headers ?? {}
+	};
+}
+/**
+* Compute a simple hash for ETag generation.
+* Uses a fast string hash (FNV-1a) for text, or SHA-256 for binary.
+*/
+async function computeETag(content) {
+	if (typeof content === "string") {
+		let hash = 2166136261;
+		for (let i = 0; i < content.length; i++) {
+			hash ^= content.charCodeAt(i);
+			hash = hash * 16777619 >>> 0;
+		}
+		return hash.toString(16).padStart(8, "0");
+	}
+	const hashBuffer = await crypto.subtle.digest("SHA-256", content);
+	const hashArray = new Uint8Array(hashBuffer);
+	return Array.from(hashArray.subarray(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Build an AssetManifest from a pathname->content mapping.
+* Only computes metadata (content types, ETags) — doesn't store content.
+*/
+async function buildAssetManifest(assets) {
+	const manifest = /* @__PURE__ */ new Map();
+	const entries = Object.entries(assets);
+	await Promise.all(entries.map(async ([pathname, content]) => {
+		const contentType = inferContentType(pathname);
+		const etag = await computeETag(content);
+		manifest.set(pathname, {
+			contentType,
+			etag
+		});
+	}));
+	return manifest;
+}
+/**
+* Convenience: build both a manifest and an in-memory storage from assets.
+*/
+async function buildAssets(assets) {
+	return {
+		manifest: await buildAssetManifest(assets),
+		storage: createMemoryStorage(assets)
+	};
+}
+/**
+* Check if a pathname exists in the manifest.
+*/
+function exists(manifest, pathname) {
+	return manifest.get(pathname);
+}
+const ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+const escapeRegex = (s) => s.replaceAll(ESCAPE_REGEX_CHARACTERS, String.raw`\$&`);
+const PLACEHOLDER_REGEX = /:([A-Za-z]\w*)/g;
+function replacer(str, replacements) {
+	for (const [key, value] of Object.entries(replacements)) str = str.replaceAll(`:${key}`, value);
+	return str;
+}
+function generateRuleRegExp(rule) {
+	rule = rule.split("*").map((s) => escapeRegex(s)).join("(?<splat>.*)");
+	const matches = rule.matchAll(PLACEHOLDER_REGEX);
+	for (const match of matches) rule = rule.split(match[0]).join(`(?<${match[1]}>[^/]+)`);
+	return new RegExp("^" + rule + "$");
+}
+function matchStaticRedirects(config, host, pathname) {
+	const withHost = config.redirects.static[`https://${host}${pathname}`];
+	const withoutHost = config.redirects.static[pathname];
+	if (withHost && withoutHost) return withHost.lineNumber < withoutHost.lineNumber ? withHost : withoutHost;
+	return withHost || withoutHost;
+}
+function matchDynamicRedirects(config, request) {
+	const { pathname } = new URL(request.url);
+	for (const [pattern, rule] of Object.entries(config.redirects.dynamic)) try {
+		const result = generateRuleRegExp(pattern).exec(pathname);
+		if (result) {
+			const target = replacer(rule.to, result.groups || {}).trim();
+			return {
+				status: rule.status,
+				to: target
+			};
+		}
+	} catch {}
+}
+function handleRedirects(request, config) {
+	const url = new URL(request.url);
+	const { search, host } = url;
+	let { pathname } = url;
+	const staticMatch = matchStaticRedirects(config, host, pathname);
+	const dynamicMatch = staticMatch ? void 0 : matchDynamicRedirects(config, request);
+	const match = staticMatch ?? dynamicMatch;
+	let proxied = false;
+	if (match) if (match.status === 200) {
+		pathname = new URL(match.to, request.url).pathname;
+		proxied = true;
+	} else {
+		const destination = new URL(match.to, request.url);
+		const location = destination.origin === url.origin ? `${destination.pathname}${destination.search || search}${destination.hash}` : `${destination.href}`;
+		return new Response(null, {
+			status: match.status,
+			headers: { Location: location }
+		});
+	}
+	return {
+		proxied,
+		pathname
+	};
+}
+function generateGlobRegExp(pattern) {
+	const escaped = pattern.split("*").map((s) => escapeRegex(s)).join(".*");
+	return new RegExp("^" + escaped + "$");
+}
+function attachCustomHeaders(request, response, config) {
+	if (Object.keys(config.headers).length === 0) return response;
+	const { pathname } = new URL(request.url);
+	const setMap = /* @__PURE__ */ new Set();
+	for (const [pattern, rules] of Object.entries(config.headers)) {
+		try {
+			if (!generateGlobRegExp(pattern).test(pathname)) continue;
+		} catch {
+			continue;
+		}
+		if (rules.unset) for (const key of rules.unset) response.headers.delete(key);
+		if (rules.set) for (const [key, value] of Object.entries(rules.set)) if (setMap.has(key.toLowerCase())) response.headers.append(key, value);
+		else {
+			response.headers.set(key, value);
+			setMap.add(key.toLowerCase());
+		}
+	}
+	return response;
+}
+function decodePath(pathname) {
+	return pathname.split("/").map((segment) => {
+		try {
+			return decodeURIComponent(segment);
+		} catch {
+			return segment;
+		}
+	}).join("/").replaceAll(/\/+/g, "/");
+}
+function encodePath(pathname) {
+	return pathname.split("/").map((segment) => {
+		try {
+			return encodeURIComponent(segment);
+		} catch {
+			return segment;
+		}
+	}).join("/");
+}
+function getIntent(pathname, manifest, config, skipRedirects = false, acceptsHtml = true) {
+	switch (config.html_handling) {
+		case "auto-trailing-slash": return htmlAutoTrailingSlash(pathname, manifest, config, skipRedirects, acceptsHtml);
+		case "force-trailing-slash": return htmlForceTrailingSlash(pathname, manifest, config, skipRedirects, acceptsHtml);
+		case "drop-trailing-slash": return htmlDropTrailingSlash(pathname, manifest, config, skipRedirects, acceptsHtml);
+		case "none": return htmlNone(pathname, manifest, config, acceptsHtml);
+	}
+}
+function assetIntent(pathname, meta, status = 200) {
+	return {
+		type: "asset",
+		pathname,
+		meta,
+		status
+	};
+}
+function redirectIntent(to) {
+	return {
+		type: "redirect",
+		to
+	};
+}
+/**
+* Safe redirect: only redirect if the file exists and the destination
+* itself resolves to the same asset (avoids redirect loops).
+*/
+function safeRedirect(file, destination, manifest, config, skip) {
+	if (skip) return void 0;
+	if (!exists(manifest, destination)) {
+		const intent = getIntent(destination, manifest, config, true);
+		if (intent?.type === "asset" && intent.meta.etag === exists(manifest, file)?.etag) return redirectIntent(destination);
+	}
+}
+function htmlAutoTrailingSlash(pathname, manifest, config, skipRedirects, acceptsHtml) {
+	let meta;
+	let redirect;
+	const exactMeta = exists(manifest, pathname);
+	if (pathname.endsWith("/index")) {
+		if (exactMeta) return assetIntent(pathname, exactMeta);
+		if (redirect = safeRedirect(`${pathname}.html`, pathname.slice(0, -5), manifest, config, skipRedirects)) return redirect;
+		if (redirect = safeRedirect(`${pathname.slice(0, -6)}.html`, pathname.slice(0, -6), manifest, config, skipRedirects)) return redirect;
+	} else if (pathname.endsWith("/index.html")) {
+		if (redirect = safeRedirect(pathname, pathname.slice(0, -10), manifest, config, skipRedirects)) return redirect;
+		if (redirect = safeRedirect(`${pathname.slice(0, -11)}.html`, pathname.slice(0, -11), manifest, config, skipRedirects)) return redirect;
+	} else if (pathname.endsWith("/")) {
+		const indexPath = `${pathname}index.html`;
+		if (meta = exists(manifest, indexPath)) return assetIntent(indexPath, meta);
+		if (redirect = safeRedirect(`${pathname.slice(0, -1)}.html`, pathname.slice(0, -1), manifest, config, skipRedirects)) return redirect;
+	} else if (pathname.endsWith(".html")) {
+		if (redirect = safeRedirect(pathname, pathname.slice(0, -5), manifest, config, skipRedirects)) return redirect;
+		if (redirect = safeRedirect(`${pathname.slice(0, -5)}/index.html`, `${pathname.slice(0, -5)}/`, manifest, config, skipRedirects)) return redirect;
+	}
+	if (exactMeta) return assetIntent(pathname, exactMeta);
+	const htmlPath = `${pathname}.html`;
+	if (meta = exists(manifest, htmlPath)) return assetIntent(htmlPath, meta);
+	if (redirect = safeRedirect(`${pathname}/index.html`, `${pathname}/`, manifest, config, skipRedirects)) return redirect;
+	return notFound(pathname, manifest, config, acceptsHtml);
+}
+function htmlForceTrailingSlash(pathname, manifest, config, skipRedirects, acceptsHtml) {
+	let meta;
+	let redirect;
+	const exactMeta = exists(manifest, pathname);
+	if (pathname.endsWith("/index")) {
+		if (exactMeta) return assetIntent(pathname, exactMeta);
+		if (redirect = safeRedirect(`${pathname}.html`, pathname.slice(0, -5), manifest, config, skipRedirects)) return redirect;
+		if (redirect = safeRedirect(`${pathname.slice(0, -6)}.html`, pathname.slice(0, -5), manifest, config, skipRedirects)) return redirect;
+	} else if (pathname.endsWith("/index.html")) {
+		if (redirect = safeRedirect(pathname, pathname.slice(0, -10), manifest, config, skipRedirects)) return redirect;
+		if (redirect = safeRedirect(`${pathname.slice(0, -11)}.html`, pathname.slice(0, -10), manifest, config, skipRedirects)) return redirect;
+	} else if (pathname.endsWith("/")) {
+		let p = `${pathname}index.html`;
+		if (meta = exists(manifest, p)) return assetIntent(p, meta);
+		p = `${pathname.slice(0, -1)}.html`;
+		if (meta = exists(manifest, p)) return assetIntent(p, meta);
+	} else if (pathname.endsWith(".html")) {
+		if (redirect = safeRedirect(pathname, `${pathname.slice(0, -5)}/`, manifest, config, skipRedirects)) return redirect;
+		if (exactMeta) return assetIntent(pathname, exactMeta);
+		if (redirect = safeRedirect(`${pathname.slice(0, -5)}/index.html`, `${pathname.slice(0, -5)}/`, manifest, config, skipRedirects)) return redirect;
+	}
+	if (exactMeta) return assetIntent(pathname, exactMeta);
+	if (redirect = safeRedirect(`${pathname}.html`, `${pathname}/`, manifest, config, skipRedirects)) return redirect;
+	if (redirect = safeRedirect(`${pathname}/index.html`, `${pathname}/`, manifest, config, skipRedirects)) return redirect;
+	return notFound(pathname, manifest, config, acceptsHtml);
+}
+function htmlDropTrailingSlash(pathname, manifest, config, skipRedirects, acceptsHtml) {
+	let meta;
+	let redirect;
+	const exactMeta = exists(manifest, pathname);
+	if (pathname.endsWith("/index")) {
+		if (exactMeta) return assetIntent(pathname, exactMeta);
+		if (pathname === "/index") {
+			if (redirect = safeRedirect("/index.html", "/", manifest, config, skipRedirects)) return redirect;
+		} else {
+			if (redirect = safeRedirect(`${pathname.slice(0, -6)}.html`, pathname.slice(0, -6), manifest, config, skipRedirects)) return redirect;
+			if (redirect = safeRedirect(`${pathname}.html`, pathname.slice(0, -6), manifest, config, skipRedirects)) return redirect;
+		}
+	} else if (pathname.endsWith("/index.html")) if (pathname === "/index.html") {
+		if (redirect = safeRedirect("/index.html", "/", manifest, config, skipRedirects)) return redirect;
+	} else {
+		if (redirect = safeRedirect(pathname, pathname.slice(0, -11), manifest, config, skipRedirects)) return redirect;
+		if (exactMeta) return assetIntent(pathname, exactMeta);
+		if (redirect = safeRedirect(`${pathname.slice(0, -11)}.html`, pathname.slice(0, -11), manifest, config, skipRedirects)) return redirect;
+	}
+	else if (pathname.endsWith("/")) if (pathname === "/") {
+		if (meta = exists(manifest, "/index.html")) return assetIntent("/index.html", meta);
+	} else {
+		if (redirect = safeRedirect(`${pathname.slice(0, -1)}.html`, pathname.slice(0, -1), manifest, config, skipRedirects)) return redirect;
+		if (redirect = safeRedirect(`${pathname.slice(0, -1)}/index.html`, pathname.slice(0, -1), manifest, config, skipRedirects)) return redirect;
+	}
+	else if (pathname.endsWith(".html")) {
+		if (redirect = safeRedirect(pathname, pathname.slice(0, -5), manifest, config, skipRedirects)) return redirect;
+		if (redirect = safeRedirect(`${pathname.slice(0, -5)}/index.html`, pathname.slice(0, -5), manifest, config, skipRedirects)) return redirect;
+	}
+	if (exactMeta) return assetIntent(pathname, exactMeta);
+	let p = `${pathname}.html`;
+	if (meta = exists(manifest, p)) return assetIntent(p, meta);
+	p = `${pathname}/index.html`;
+	if (meta = exists(manifest, p)) return assetIntent(p, meta);
+	return notFound(pathname, manifest, config, acceptsHtml);
+}
+function htmlNone(pathname, manifest, config, acceptsHtml) {
+	const meta = exists(manifest, pathname);
+	return meta ? assetIntent(pathname, meta) : notFound(pathname, manifest, config, acceptsHtml);
+}
+function notFound(pathname, manifest, config, acceptsHtml = true) {
+	switch (config.not_found_handling) {
+		case "single-page-application": {
+			if (!acceptsHtml) return void 0;
+			const meta = exists(manifest, "/index.html");
+			if (meta) return assetIntent("/index.html", meta, 200);
+			return;
+		}
+		case "404-page": {
+			let cwd = pathname;
+			while (cwd) {
+				cwd = cwd.slice(0, cwd.lastIndexOf("/"));
+				const p = `${cwd}/404.html`;
+				const meta = exists(manifest, p);
+				if (meta) return assetIntent(p, meta, 404);
+			}
+			return;
+		}
+		default: return;
+	}
+}
+const CACHE_CONTROL_REVALIDATE = "public, max-age=0, must-revalidate";
+const CACHE_CONTROL_IMMUTABLE = "public, max-age=31536000, immutable";
+function getCacheControl(pathname) {
+	if (/\.[a-f0-9]{8,}\.\w+$/.test(pathname)) return CACHE_CONTROL_IMMUTABLE;
+	return CACHE_CONTROL_REVALIDATE;
+}
+/**
+* Handle an asset request. Returns a Response if an asset matches,
+* or null if the request should fall through to the user's Worker.
+*
+* @param request - The incoming HTTP request
+* @param manifest - Asset manifest (pathname -> metadata)
+* @param storage - Storage backend for fetching content
+* @param config - Asset serving configuration
+*/
+async function handleAssetRequest(request, manifest, storage, config) {
+	const normalized = normalizeConfig(config);
+	const method = request.method.toUpperCase();
+	if (!["GET", "HEAD"].includes(method)) return null;
+	const redirectResult = handleRedirects(request, normalized);
+	if (redirectResult instanceof Response) return attachCustomHeaders(request, redirectResult, normalized);
+	const { pathname } = redirectResult;
+	const decodedPathname = decodePath(pathname);
+	const intent = getIntent(decodedPathname, manifest, normalized, false, (request.headers.get("Accept") || "").includes("text/html"));
+	if (!intent) return null;
+	if (intent.type === "redirect") {
+		const url = new URL(request.url);
+		const encodedDest = encodePath(intent.to);
+		return attachCustomHeaders(request, new Response(null, {
+			status: 307,
+			headers: { Location: encodedDest + url.search }
+		}), normalized);
+	}
+	const encodedPathname = encodePath(decodedPathname);
+	if (encodedPathname !== pathname) {
+		const url = new URL(request.url);
+		return attachCustomHeaders(request, new Response(null, {
+			status: 307,
+			headers: { Location: encodedPathname + url.search }
+		}), normalized);
+	}
+	const { pathname: assetPath, meta, status } = intent;
+	const strongETag = `"${meta.etag}"`;
+	const weakETag = `W/${strongETag}`;
+	const ifNoneMatch = request.headers.get("If-None-Match") || "";
+	const eTags = new Set(ifNoneMatch.split(",").map((t) => t.trim()));
+	const headers = new Headers();
+	headers.set("ETag", strongETag);
+	if (meta.contentType) headers.set("Content-Type", meta.contentType);
+	headers.set("Cache-Control", getCacheControl(decodedPathname));
+	if (eTags.has(weakETag) || eTags.has(strongETag)) return attachCustomHeaders(request, new Response(null, {
+		status: 304,
+		headers
+	}), normalized);
+	let body = null;
+	if (method !== "HEAD") body = await storage.get(assetPath);
+	return attachCustomHeaders(request, new Response(body, {
+		status,
+		headers
+	}), normalized);
+}
+//#endregion
+export { inferContentType as a, handleAssetRequest as i, buildAssets as n, isTextContentType as o, createMemoryStorage as r, buildAssetManifest as t };
+
+//# sourceMappingURL=assets-BlVFmWBF.js.map