mates-fullstack 1.0.0-beta.1

package/dist/build-esbuild.js

@@ -0,0 +1,699 @@
+import path from "node:path";
+import fs from "node:fs";
+import { transform } from "esbuild";
+import { BROWSER_ERRORS_JS } from "./errors.js";
+import { CRASH_OVERLAY_MODULE, DOWNLOAD_MODULE, EMPTY_STYLE_MODULE, ERRORS_MODULE, INTERNAL_ASSET_PREFIX, INTERNAL_PKG_PREFIX, INTERNAL_SRC_PREFIX, NAV_MODULE, RPC_CLIENT_MODULE, STACK_MAP_MODULE, STREAM_MODULE, } from "./internal-prefixes.js";
+// ---------------------------------------------------------------------------
+// Cache
+// ---------------------------------------------------------------------------
+const _transformCache = new Map();
+export function clearTransformCache() {
+    _transformCache.clear();
+}
+// ---------------------------------------------------------------------------
+// Reserved RPC export names (must not be stubbed)
+// ---------------------------------------------------------------------------
+const RESERVED_NAMES = new Set([
+    "default",
+    "loader",
+    "meta",
+    "layout",
+    "staticPaths",
+    "onConnect",
+    "onDisconnect",
+    "then",
+    "catch",
+    "finally",
+]);
+// ---------------------------------------------------------------------------
+// buildDefines
+// ---------------------------------------------------------------------------
+export function buildDefines(publicEnv) {
+    const defines = {
+        "import.meta.env.NODE_ENV": '"development"',
+        "process.env.NODE_ENV": '"development"',
+    };
+    for (const [key, value] of Object.entries(publicEnv)) {
+        defines[`import.meta.env.${key}`] = JSON.stringify(value);
+    }
+    return defines;
+}
+// ---------------------------------------------------------------------------
+// RPC stub extraction
+// ---------------------------------------------------------------------------
+export function extractRpcStub(source, filePath, apiDir) {
+    const exportedNames = [];
+    // export async function NAME(
+    const funcPattern = /^export\s+async\s+function\s+(\w+)\s*\(/gm;
+    let m;
+    while ((m = funcPattern.exec(source)) !== null) {
+        exportedNames.push(m[1]);
+    }
+    // export const NAME = async
+    const constPattern = /^export\s+const\s+(\w+)\s*=\s*async\b/gm;
+    while ((m = constPattern.exec(source)) !== null) {
+        exportedNames.push(m[1]);
+    }
+    const unique = [...new Set(exportedNames)].filter((name) => !RESERVED_NAMES.has(name));
+    // Derive relative module path for URL construction: relative from apiDir
+    // e.g. apiDir = /project/server/api, filePath = /project/server/api/users.ts
+    // → moduleRelPath = "users"
+    const relFromApi = path.relative(apiDir, filePath);
+    let moduleRelPath = relFromApi
+        .replace(/\.(ts|js|tsx|jsx)$/, "")
+        .split(path.sep)
+        .join("/");
+    if (moduleRelPath.endsWith("/index"))
+        moduleRelPath = moduleRelPath.slice(0, -6);
+    if (moduleRelPath === "index")
+        moduleRelPath = "";
+    const lines = [
+        `// Generated RPC stub for ${filePath}`,
+        `import { __rpcCall } from ${JSON.stringify(RPC_CLIENT_MODULE)};`,
+        "",
+    ];
+    for (const name of unique) {
+        const rpcUrl = moduleRelPath
+            ? `/api/${moduleRelPath}/${name}`
+            : `/api/${name}`;
+        lines.push(`export async function ${name}(payload = {}) {`, `  return __rpcCall(${JSON.stringify(rpcUrl)}, payload);`, `}`, "");
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// transformFile
+// ---------------------------------------------------------------------------
+function loaderForExtension(ext) {
+    switch (ext) {
+        case ".ts":
+            return "ts";
+        case ".tsx":
+            return "tsx";
+        case ".js":
+        case ".mjs":
+            return "js";
+        case ".jsx":
+            return "jsx";
+        default:
+            return null;
+    }
+}
+export async function transformFile(filePath, projectRoot, apiDir, publicEnv, sourceUrl) {
+    // File existence check
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+    const mtime = stat.mtimeMs;
+    // If this file lives inside the apiDir, return a generated RPC stub instead
+    // of transforming the real server-only source.
+    if (apiDir) {
+        const normalApi = path.resolve(apiDir);
+        const normalFile = path.resolve(filePath);
+        if (normalFile.startsWith(normalApi + path.sep) ||
+            normalFile === normalApi) {
+            const source = fs.readFileSync(filePath, "utf-8");
+            const stub = extractRpcStub(source, filePath, normalApi);
+            return { code: stub };
+        }
+    }
+    // Check cache
+    const cacheKey = `${filePath}::${sourceUrl ?? ""}`;
+    const cached = _transformCache.get(cacheKey);
+    if (cached && cached.mtime === mtime) {
+        return { code: cached.code };
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    // ── Stylesheet compatibility shim ───────────────────────────────────────
+    // CSS is bundled once into dist/assets/styles*.css and linked from <head>.
+    // If an old transformed module still requests a CSS file as JS, return a
+    // harmless no-op module instead of injecting styles from JavaScript.
+    if (ext === ".css") {
+        const code = "export default {};\n";
+        _transformCache.set(`${filePath}::${sourceUrl ?? ""}`, { mtime, code });
+        return { code };
+    }
+    const loader = loaderForExtension(ext);
+    if (!loader) {
+        // Unknown extension — serve as-is (plain text / JS passthrough)
+        const raw = fs.readFileSync(filePath, "utf-8");
+        return { code: raw };
+    }
+    let source;
+    try {
+        source = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const debugSource = sourceUrl ??
+            `/${path.relative(projectRoot, filePath).split(path.sep).join("/")}`;
+        const result = await transform(source, {
+            loader,
+            sourcemap: "inline",
+            sourcefile: debugSource,
+            target: "es2020",
+            format: "esm",
+            define: buildDefines(publicEnv),
+            sourcesContent: true,
+        });
+        const code = `${result.code}\n//# sourceURL=${debugSource}`;
+        _transformCache.set(cacheKey, { mtime, code });
+        return { code };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        // Return a browser-safe error module rather than throwing
+        const errorModule = `export default null;\n` +
+            `console.error(${JSON.stringify(`[mates] transform error in ${filePath}: ${message}`)});\n` +
+            `//# sourceURL=${sourceUrl ?? filePath}\n`;
+        return { code: errorModule };
+    }
+}
+// ---------------------------------------------------------------------------
+// Dev no-bundle module serving
+// ---------------------------------------------------------------------------
+const CODE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".json"];
+const STYLE_EXT_RE = /\.css$/i;
+const ASSET_EXT_RE = /\.(png|jpe?g|gif|webp|avif|ico|bmp|tiff|svg|woff2?|ttf|otf|eot|mp4|webm|ogg|mov|avi|mkv|mp3|wav|flac|aac|m4a|opus|pdf|docx?|xlsx?|pptx?|txt|csv|glb|gltf|obj|fbx|wasm|json5|geojson|toml|ya?ml|zip|tar|gz)$/i;
+/**
+ * Transform one source file for no-bundle dev mode.
+ *
+ * Unlike `transformFile()`, this rewrites ESM specifiers so the browser can load
+ * TypeScript and package files directly from the dev server. Stylesheets are
+ * bundled separately into one linked CSS file; CSS imports are rewritten to a
+ * no-op compatibility module.
+ */
+export async function transformDevModule(filePath, options) {
+    const transformed = await transformFile(filePath, options.projectRoot, options.apiDir, options.publicEnv, options.sourceUrl);
+    if (!transformed)
+        return null;
+    const sourceUrl = options.sourceUrl ?? filePath;
+    const code = injectDevHmrPrelude(appendComponentHmrRegistration(rewriteImportSpecifiers(transformed.code, filePath, options), sourceUrl), sourceUrl);
+    return { ...transformed, code };
+}
+function injectDevHmrPrelude(code, sourceUrl) {
+    return (`if (import.meta && window.__mates_hmr) import.meta.hot = window.__mates_hmr.createHotContext(${JSON.stringify(sourceUrl)});\n` +
+        code);
+}
+function appendComponentHmrRegistration(code, sourceUrl) {
+    const exports = extractComponentExportBindings(code);
+    if (exports.length === 0)
+        return code;
+    const entries = exports
+        .map(({ exported, local }) => `${JSON.stringify(exported)}: typeof ${local} === "function" ? ${local} : null`)
+        .join(",");
+    return `${code}\n;(() => {\n  const __mates_exports = { ${entries} };\n  if (window.__mates_hmr) {\n    for (const [__name, __value] of Object.entries(__mates_exports)) {\n      if (typeof __value !== "function") continue;\n      const __file = ${JSON.stringify(sourceUrl)};\n      const __id = __file + "::" + __name;\n      try { Object.defineProperty(__value, "__mates_hmr_id", { value: __id, configurable: true }); } catch {}\n      try { Object.defineProperty(__value, "__mates_hmr_file", { value: __file, configurable: true }); } catch {}\n      try { Object.defineProperty(__value, "__mates_hmr_export", { value: __name, configurable: true }); } catch {}\n      window.__mates_hmr.registerComponent(__id, __value, { file: __file, exportName: __name });\n    }\n    if (import.meta.hot) import.meta.hot.accept((mod) => window.__mates_hmr.updateModule(${JSON.stringify(sourceUrl)}, mod));\n  }\n})();\n`;
+}
+function extractComponentExportBindings(code) {
+    const bindings = [];
+    const seen = new Set();
+    const add = (exported, local) => {
+        if (seen.has(exported))
+            return;
+        // Heuristic: components are PascalCase named exports or default exports.
+        if (exported !== "default" && !/^[A-Z]/.test(exported))
+            return;
+        if (!/^[A-Za-z_$][\w$]*$/.test(local))
+            return;
+        seen.add(exported);
+        bindings.push({ exported, local });
+    };
+    const exportBlockRe = /export\s*\{([^}]+)\}/g;
+    let match;
+    while ((match = exportBlockRe.exec(code)) !== null) {
+        for (const raw of match[1].split(",")) {
+            const part = raw.trim();
+            if (!part)
+                continue;
+            const alias = part.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*|default)$/);
+            if (alias)
+                add(alias[2], alias[1]);
+            else
+                add(part, part);
+        }
+    }
+    const defaultRe = /export\s+default\s+([A-Za-z_$][\w$]*)/g;
+    while ((match = defaultRe.exec(code)) !== null)
+        add("default", match[1]);
+    return bindings;
+}
+function rewriteImportSpecifiers(code, filePath, options) {
+    const rewrite = (spec) => resolveDevSpecifier(spec, filePath, options);
+    // Helper: check if a resolved specifier is an asset URL that should become
+    // a const declaration instead of a live ESM import.
+    function isAssetResult(spec) {
+        const result = rewrite(spec);
+        if (!result.startsWith(INTERNAL_ASSET_PREFIX + "/"))
+            return null;
+        return result;
+    }
+    // Step 1: Replace default import statements for assets with const declarations.
+    //   import s from "./s.svg"  →  const s = "/_asset/client/s.svg"
+    code = code.replace(/^import\s+([A-Za-z_$][\w$]*)\s+from\s*["']([^"']+)["'];?$/gm, (_m, binding, spec) => {
+        const assetUrl = isAssetResult(spec);
+        if (!assetUrl)
+            return _m;
+        return `const ${binding} = ${JSON.stringify(assetUrl)};`;
+    });
+    // Step 2: Replace namespace import statements for assets with const declarations.
+    //   import * as s from "./s.svg"  →  const s = "/_asset/client/s.svg"
+    code = code.replace(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*["']([^"']+)["'];?$/gm, (_m, binding, spec) => {
+        const assetUrl = isAssetResult(spec);
+        if (!assetUrl)
+            return _m;
+        // Treat namespace import same as default for single-file assets.
+        return `const ${binding} = ${JSON.stringify(assetUrl)};`;
+    });
+    // Step 3: Rewrite remaining import/export/from specifiers that are not
+    // asset imports (those were already handled above).
+    code = code
+        .replace(/(\bfrom\s*["'])([^"']+)(["'])/g, (_m, a, spec, b) => {
+        return `${a}${rewrite(spec)}${b}`;
+    })
+        .replace(/(\bimport\s*["'])([^"']+)(["'])/g, (_m, a, spec, b) => {
+        return `${a}${rewrite(spec)}${b}`;
+    })
+        .replace(/(\bimport\s*\(\s*["'])([^"']+)(["']\s*\))/g, (_m, a, spec, b) => `${a}${rewrite(spec)}${b}`);
+    return code;
+}
+function resolveDevSpecifier(spec, importer, options) {
+    if (spec.startsWith("/") ||
+        spec.startsWith("http://") ||
+        spec.startsWith("https://") ||
+        spec.startsWith("data:") ||
+        spec.startsWith("blob:")) {
+        return spec;
+    }
+    if (spec.startsWith(".") || spec.startsWith("..")) {
+        const resolved = resolveRelativeSpecifier(importer, spec);
+        if (!resolved)
+            return spec;
+        const moduleRoot = path.resolve(options.moduleRoot ?? options.projectRoot);
+        const modulePrefix = options.modulePrefix ?? INTERNAL_SRC_PREFIX;
+        if (STYLE_EXT_RE.test(resolved)) {
+            return EMPTY_STYLE_MODULE;
+        }
+        if (ASSET_EXT_RE.test(resolved)) {
+            const rel = path
+                .relative(options.projectRoot, resolved)
+                .split(path.sep)
+                .join("/");
+            return `${INTERNAL_ASSET_PREFIX}/${rel}`;
+        }
+        if (path.resolve(resolved).startsWith(moduleRoot + path.sep)) {
+            const rel = path.relative(moduleRoot, resolved).split(path.sep).join("/");
+            return `${modulePrefix}/${rel}`;
+        }
+        const projectRel = path
+            .relative(options.projectRoot, resolved)
+            .split(path.sep)
+            .join("/");
+        if (!projectRel.startsWith(".."))
+            return `${INTERNAL_SRC_PREFIX}/${projectRel}`;
+        return spec;
+    }
+    if (options.importMap?.[spec])
+        return options.importMap[spec];
+    // Prefix import-map entries such as "lit-html/" support subpath imports.
+    for (const [key, value] of Object.entries(options.importMap ?? {})) {
+        if (key.endsWith("/") && spec.startsWith(key)) {
+            return value + spec.slice(key.length);
+        }
+    }
+    return `${INTERNAL_PKG_PREFIX}/${spec}`;
+}
+function resolveRelativeSpecifier(importer, spec) {
+    const base = path.resolve(path.dirname(importer), spec);
+    try {
+        if (fs.statSync(base).isFile())
+            return base;
+    }
+    catch {
+        /* try extensions */
+    }
+    for (const ext of CODE_EXTENSIONS) {
+        const candidate = base + ext;
+        try {
+            if (fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    for (const ext of [".css"]) {
+        const candidate = base + ext;
+        try {
+            if (fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    // Try asset extensions (.svg, .png, .woff2, …) so extensionless imports like
+    // `import logo from "./logo"` resolve when the actual file is logo.svg.
+    const ASSET_EXT_LIST = [
+        ".svg",
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".webp",
+        ".avif",
+        ".ico",
+        ".bmp",
+        ".tiff",
+        ".woff2",
+        ".woff",
+        ".ttf",
+        ".otf",
+        ".eot",
+        ".mp4",
+        ".webm",
+        ".ogg",
+        ".mov",
+        ".avi",
+        ".mkv",
+        ".mp3",
+        ".wav",
+        ".flac",
+        ".aac",
+        ".m4a",
+        ".opus",
+        ".pdf",
+        ".doc",
+        ".docx",
+        ".xls",
+        ".xlsx",
+        ".ppt",
+        ".pptx",
+        ".txt",
+        ".csv",
+        ".glb",
+        ".gltf",
+        ".obj",
+        ".fbx",
+        ".wasm",
+        ".json5",
+        ".geojson",
+        ".toml",
+        ".yaml",
+        ".yml",
+        ".zip",
+        ".tar",
+        ".gz",
+    ];
+    for (const ext of ASSET_EXT_LIST) {
+        const candidate = base + ext;
+        try {
+            if (fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    try {
+        if (fs.statSync(base).isDirectory()) {
+            for (const ext of CODE_EXTENSIONS) {
+                const candidate = path.join(base, `index${ext}`);
+                try {
+                    if (fs.statSync(candidate).isFile())
+                        return candidate;
+                }
+                catch {
+                    /* try next */
+                }
+            }
+        }
+    }
+    catch {
+        /* not a directory */
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Virtual file registry
+// ---------------------------------------------------------------------------
+const RPC_CLIENT_JS = /* js */ `
+export async function __rpcCall(url, payload) {
+  const isFile =
+    payload &&
+    typeof payload === "object" &&
+    Object.values(payload).some(v => v instanceof File || v instanceof Blob);
+
+  let body;
+  let headers = {};
+
+  if (isFile) {
+    const fd = new FormData();
+    for (const [k, v] of Object.entries(payload)) {
+      if (v instanceof File || v instanceof Blob) fd.append(k, v);
+      else fd.append(k, JSON.stringify(v));
+    }
+    body = fd;
+  } else {
+    body = JSON.stringify(payload ?? {});
+    headers["Content-Type"] = "application/json";
+  }
+
+  const res = await fetch(url, { method: "POST", headers, body });
+  const ct = res.headers.get("content-type") ?? "";
+
+  if (res.status >= 300 && res.status < 400) {
+    const data = await res.json();
+    if (data.__type === "Redirect") {
+      const { isExternalUrl, navigateTo } = await import("${NAV_MODULE}");
+      if (isExternalUrl(data.url)) {
+        window.location.href = data.url;
+      } else {
+        navigateTo(data.url);
+      }
+      return;
+    }
+  }
+
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    const { reconstructError, isMatesError } = await import("${ERRORS_MODULE}");
+    if (isMatesError(data)) throw reconstructError(data);
+    throw new Error(data.message ?? \`HTTP \${res.status}\`);
+  }
+
+  if (ct.includes("text/event-stream")) {
+    const { readSseStream } = await import("${STREAM_MODULE}");
+    return readSseStream(res);
+  }
+
+  if (/attachment/i.test(res.headers.get("content-disposition") ?? "")) {
+    const { triggerBrowserDownload } = await import("${DOWNLOAD_MODULE}");
+    triggerBrowserDownload(res);
+    return;
+  }
+
+  return res.json();
+}
+`.trimStart();
+const STREAM_JS = /* js */ `
+export async function* readSseStream(res) {
+  const reader = res.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const events = buffer.split("\n\n");
+    buffer = events.pop() ?? "";
+    for (const rawEvent of events) {
+      let event; const dataLines = [];
+      for (const line of rawEvent.split("\n")) {
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+      }
+      if (dataLines.length === 0) continue;
+      const data = dataLines.join("\n");
+      if (event === "done") return;
+      if (event === "error") {
+        const { reconstructError, isMatesError } = await import("${ERRORS_MODULE}");
+        const parsed = JSON.parse(data);
+        throw isMatesError(parsed) ? reconstructError(parsed) : new Error(data);
+      }
+      try { yield JSON.parse(data); } catch { yield data; }
+    }
+  }
+}
+`.trimStart();
+const STACK_MAP_JS = /* js */ `
+import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
+
+const INLINE_SOURCE_MAP_RE = /\/\/# sourceMappingURL=data:application\/json(?:;charset=[^;,]+)?;base64,([A-Za-z0-9+/=]+)/;
+const traceMapCache = new Map();
+
+export function parseStackFrames(stack) {
+  const frames = [];
+  for (const raw of String(stack || "").split(/\r?\n/)) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("at ")) continue;
+    const withFn = trimmed.match(/^at\s+(.+?)\s+\((.+):(\d+):(\d+)\)$/);
+    const withoutFn = trimmed.match(/^at\s+(.+):(\d+):(\d+)$/);
+    if (withFn) {
+      frames.push({ raw, fnName: withFn[1], file: withFn[2], line: Number(withFn[3]), column: Number(withFn[4]) });
+    } else if (withoutFn) {
+      frames.push({ raw, fnName: null, file: withoutFn[1], line: Number(withoutFn[2]), column: Number(withoutFn[3]) });
+    }
+  }
+  return frames;
+}
+
+export function extractInlineSourceMap(code) {
+  const match = String(code || "").match(INLINE_SOURCE_MAP_RE);
+  if (!match) return null;
+  try { return JSON.parse(atob(match[1])); } catch { return null; }
+}
+
+export async function mapStackTrace(stack) {
+  const frames = parseStackFrames(stack);
+  const mapped = [];
+  for (const frame of frames) {
+    const traceMap = await getTraceMap(frame.file);
+    if (!traceMap) {
+      mapped.push({ ...frame, mappedFile: null, mappedLine: null, mappedColumn: null, mappedName: null });
+      continue;
+    }
+    const original = originalPositionFor(traceMap, { line: frame.line, column: Math.max(0, frame.column - 1) });
+    if (!original.source || original.line == null || original.column == null) {
+      mapped.push({ ...frame, mappedFile: null, mappedLine: null, mappedColumn: null, mappedName: null });
+      continue;
+    }
+    mapped.push({
+      ...frame,
+      mappedFile: original.source,
+      mappedLine: original.line,
+      mappedColumn: original.column + 1,
+      mappedName: original.name || frame.fnName,
+    });
+  }
+  return mapped;
+}
+
+export function formatMappedStack(frames) {
+  return frames.map((frame) => {
+    const file = frame.mappedFile || frame.file;
+    const line = frame.mappedLine || frame.line;
+    const column = frame.mappedColumn || frame.column;
+    const name = frame.mappedName || frame.fnName;
+    const prefix = "    at ";
+    return name
+      ? prefix + name + " (" + file + ":" + line + ":" + column + ")"
+      : prefix + file + ":" + line + ":" + column;
+  }).join("\n");
+}
+
+export async function renderMappedStack(container, error) {
+  const stack = error && (error.stack || error.message) || String(error);
+  const frames = await mapStackTrace(stack);
+  container.textContent = frames.length > 0 ? formatMappedStack(frames) : stack;
+}
+
+async function getTraceMap(url) {
+  if (traceMapCache.has(url)) return traceMapCache.get(url);
+  try {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error("HTTP " + res.status);
+    const code = await res.text();
+    const map = extractInlineSourceMap(code);
+    const traceMap = map ? new TraceMap(map) : null;
+    traceMapCache.set(url, traceMap);
+    return traceMap;
+  } catch {
+    traceMapCache.set(url, null);
+    return null;
+  }
+}
+`.trimStart();
+const CRASH_OVERLAY_JS = /* js */ `
+import { mapStackTrace, formatMappedStack } from "${STACK_MAP_MODULE}";
+
+let overlay;
+
+function ensureOverlay() {
+  if (overlay) return overlay;
+  overlay = document.createElement("div");
+  overlay.id = "mates-crash-overlay";
+  overlay.style.cssText = "position:fixed;inset:0;z-index:2147483647;background:rgba(15,23,42,.96);color:#f8fafc;font:13px ui-monospace,SFMono-Regular,Menlo,monospace;padding:24px;overflow:auto;white-space:pre-wrap";
+  document.body.appendChild(overlay);
+  return overlay;
+}
+
+export async function showCrashOverlay(error) {
+  const el = ensureOverlay();
+  const title = error && error.message ? error.message : String(error);
+  const frames = await mapStackTrace(error && error.stack ? error.stack : title);
+  const stackText = frames.length ? formatMappedStack(frames) : (error && error.stack || title);
+  el.textContent = "[mates-fullstack] " + title + "\n\n" + stackText;
+}
+
+window.addEventListener("error", (event) => {
+  showCrashOverlay(event.error || new Error(event.message));
+});
+
+window.addEventListener("unhandledrejection", (event) => {
+  showCrashOverlay(event.reason || new Error("Unhandled rejection"));
+});
+`.trimStart();
+const DOWNLOAD_JS = /* js */ `
+export async function triggerBrowserDownload(res) {
+  const blob = await res.blob();
+  const disposition = res.headers.get("content-disposition") ?? "";
+  const quoted = disposition.match(/filename="([^"]+)"/);
+  const plain = disposition.match(/filename=([^;\s]+)/);
+  const filename = (quoted && quoted[1]) || (plain && plain[1]) || "download";
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  URL.revokeObjectURL(url);
+}
+`.trimStart();
+const NAV_JS = /* js */ `
+export function isExternalUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//");
+}
+export function navigateTo(url) {
+  history.pushState(null, "", url);
+  window.dispatchEvent(new PopStateEvent("popstate"));
+}
+`.trimStart();
+const EMPTY_STYLE_JS = /* js */ `
+// Compatibility shim. CSS imports are bundled into one linked stylesheet by
+// mates-fullstack, so JS-side CSS imports intentionally have no side effects.
+export default {};
+`.trimStart();
+const VIRTUAL_FILES = {
+    [RPC_CLIENT_MODULE]: RPC_CLIENT_JS,
+    [ERRORS_MODULE]: BROWSER_ERRORS_JS,
+    [STREAM_MODULE]: STREAM_JS,
+    [DOWNLOAD_MODULE]: DOWNLOAD_JS,
+    [NAV_MODULE]: NAV_JS,
+    [STACK_MAP_MODULE]: STACK_MAP_JS,
+    [CRASH_OVERLAY_MODULE]: CRASH_OVERLAY_JS,
+    [EMPTY_STYLE_MODULE]: EMPTY_STYLE_JS,
+};
+export function isVirtualFile(pathname) {
+    return Object.prototype.hasOwnProperty.call(VIRTUAL_FILES, pathname);
+}
+export async function serveVirtualFile(pathname) {
+    return VIRTUAL_FILES[pathname] ?? null;
+}
+//# sourceMappingURL=build-esbuild.js.map