@absolutejs/absolute 0.20.0-beta.155 → 0.20.0-beta.157

package/dist/cli/{compile-n5fbn66t.js → compile-myhwnrrn.js}

@@ -1,7 +1,9 @@
 // @bun
 import {
-  maskLiterals
-} from "./index-039rh39e.js";
+  maskLiterals,
+  compileSpecifierRewriter,
+  rewriteContentSpecifiers
+} from "./index-bp60baze.js";
 import {
   loadIslandRegistryBuildInfo
 } from "./index-e6ysp900.js";
@@ -61,14 +63,191 @@ import {
 // src/cli/scripts/compile.ts
 var {env } = globalThis.Bun;
 
+// src/build/compiledClientGraph.ts
+import { createHash } from "crypto";
+import ts from "typescript";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  mkdirSync,
+  writeFileSync
+} from "fs";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+var assetUrlEdit = (node, tree, urls) => {
+  if (!ts.isNewExpression(node) || !ts.isIdentifier(node.expression) || node.expression.text !== "URL")
+    return;
+  const [path, base] = node.arguments ?? [];
+  if (!path || !ts.isStringLiteral(path) || base?.getText(tree) !== "import.meta.url" || !urls[path.text])
+    return;
+  const edit = {
+    end: path.end,
+    start: path.getStart(tree),
+    value: JSON.stringify(urls[path.text])
+  };
+  return edit;
+};
+var rewriteAssetUrlConstructors = (source, urls) => {
+  if (!/\bnew\s+URL\s*\(/u.test(source))
+    return source;
+  const tree = ts.createSourceFile("client.js", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+  const edits = [];
+  const visit = (node) => {
+    const edit = assetUrlEdit(node, tree, urls);
+    if (edit)
+      edits.push(edit);
+    ts.forEachChild(node, visit);
+  };
+  visit(tree);
+  return edits.sort((left, right) => right.start - left.start).reduce((text, edit) => text.slice(0, edit.start) + edit.value + text.slice(edit.end), source);
+};
+var referencedAsset = (node, tree, file, directory) => {
+  if (!ts.isNewExpression(node) || !ts.isIdentifier(node.expression) || node.expression.text !== "URL")
+    return;
+  const [path, base] = node.arguments ?? [];
+  if (!path || !ts.isStringLiteral(path) || base?.getText(tree) !== "import.meta.url")
+    return;
+  return path.text.startsWith("/") ? resolve(directory, path.text.slice(1)) : resolve(dirname(file), path.text);
+};
+var includeUrlDependencies = (files, directory, allowed) => {
+  const included = new Set(files);
+  for (let index = 0;index < files.length; index++) {
+    const file = files[index];
+    if (!file || !/\.m?js$/.test(file))
+      continue;
+    const source = readFileSync(file, "utf8");
+    if (!/\bnew\s+URL\s*\(/u.test(source))
+      continue;
+    const tree = ts.createSourceFile("client.js", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const visit = (node) => {
+      const target = referencedAsset(node, tree, file, directory);
+      if (target && allowed.has(target) && !included.has(target)) {
+        included.add(target);
+        files.push(target);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(tree);
+  }
+  return files;
+};
+var CLIENT_GRAPH_PREFIX = "/_absolute/assets/";
+var isClientGraphAsset = (path) => {
+  const parts = path.split("/");
+  if (parts.some((part) => part.startsWith(".") || [
+    "server",
+    "node_modules",
+    "_absolute",
+    "_prerendered"
+  ].includes(part)))
+    return false;
+  if (/^(?:react|vue|svelte|angular|ember)\/pages\//.test(path))
+    return false;
+  return /\.(?:js|mjs|css|wasm|woff2?|ttf|otf|png|jpe?g|svg|gif|webp|avif|ico)$/.test(path);
+};
+var filesIn = (root) => readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+  const path = join(root, entry.name);
+  if (entry.isDirectory())
+    return filesIn(path);
+  if (entry.isFile())
+    return [path];
+  return [];
+});
+var readBuildManifest = (directory) => {
+  const path = join(directory, "manifest.json");
+  const manifest = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest))
+    throw new Error("Invalid build manifest");
+  return manifest;
+};
+var withinDirectory = (directory, path) => {
+  const rel = relative(directory, path);
+  return rel !== "" && !isAbsolute(rel) && rel.split(/[\\/]/u)[0] !== "..";
+};
+var localServerDependencies = (file, directory, scanner) => {
+  if (!existsSync(file) || !/\.m?js$/.test(file))
+    return [];
+  return scanner.scanImports(readFileSync(file, "utf8")).filter((dependency) => dependency.path.startsWith(".")).map((dependency) => resolve(dirname(file), dependency.path)).filter((path) => withinDirectory(directory, path));
+};
+var collectServerGraph = (directory, manifest) => {
+  const serverFiles = new Set(Object.values(manifest).filter((value) => typeof value === "string" && withinDirectory(directory, value)));
+  const pending = [...serverFiles];
+  const scanner = new Bun.Transpiler({ loader: "js" });
+  for (let index = 0;index < pending.length; index++) {
+    const file = pending[index];
+    if (!file)
+      continue;
+    const children = localServerDependencies(file, directory, scanner).filter((path) => !serverFiles.has(path));
+    children.forEach((path) => serverFiles.add(path));
+    pending.push(...children);
+  }
+  return serverFiles;
+};
+var rewriteCssUrls = (source, urls) => source.replace(/url\(\s*(["']?)(\/[^\s)'"?#]+)([^)'"\s]*)\1\s*\)/g, (match, quote, path, suffix) => urls[path] ? `url(${quote}${urls[path]}${suffix}${quote})` : match);
+var rewriteGraphAsset = (file, rewriter, urls) => {
+  const bytes = readFileSync(file);
+  if (/\.m?js$/.test(file))
+    return rewriteAssetUrlConstructors(rewriteContentSpecifiers(bytes.toString(), rewriter, {
+      sweep: true
+    }), urls);
+  if (file.endsWith(".css"))
+    return rewriteCssUrls(bytes.toString(), urls);
+  return bytes;
+};
+var rewriteManifest = (directory, urls) => {
+  const path = join(directory, "manifest.json");
+  if (!existsSync(path))
+    return;
+  const manifest = readBuildManifest(directory);
+  for (const [key, value] of Object.entries(manifest)) {
+    if (typeof value !== "string" || !urls[value])
+      continue;
+    Reflect.set(manifest, key, urls[value]);
+  }
+  writeFileSync(path, JSON.stringify(manifest, null, "\t"));
+};
+var prepareCompiledClientGraph = (directory, serverBundle, publicDirectory) => {
+  const manifest = readBuildManifest(directory);
+  const serverFiles = collectServerGraph(directory, manifest);
+  const publicFiles = new Set(publicDirectory && existsSync(publicDirectory) ? filesIn(publicDirectory).map((path) => relative(publicDirectory, path).replace(/\\/g, "/")) : []);
+  const clientEntries = new Set(Object.values(manifest).filter((value) => typeof value === "string" && value.startsWith("/") && !withinDirectory(directory, value)).map((value) => value.slice(1)));
+  const available = filesIn(directory);
+  const allowed = new Set(available.filter((path) => path !== resolve(directory, serverBundle) && !serverFiles.has(path) && isClientGraphAsset(relative(directory, path).replace(/\\/g, "/"))));
+  const files = available.filter((path) => {
+    const name = relative(directory, path).replace(/\\/g, "/");
+    return name !== serverBundle && !serverFiles.has(path) && isClientGraphAsset(name) && (publicFiles.has(name) || clientEntries.has(name) || /^(?:chunk-[^/]+|(?:vue|react|svelte|angular|ember|islands|workers|assets|vendor)\/)/.test(name));
+  }).sort();
+  includeUrlDependencies(files, directory, allowed).sort();
+  const hash = createHash("sha256");
+  for (const file of files)
+    hash.update(relative(directory, file)).update("\x00").update(readFileSync(file)).update("\x00");
+  const id = hash.digest("hex");
+  const prefix = `${CLIENT_GRAPH_PREFIX}${id}`;
+  const urls = Object.create(null);
+  for (const file of files) {
+    const url = `/${relative(directory, file).replace(/\\/g, "/")}`;
+    urls[url] = `${prefix}${url}`;
+  }
+  const rewriter = compileSpecifierRewriter(urls);
+  for (const file of files) {
+    const destination = join(directory, prefix.slice(1), relative(directory, file));
+    mkdirSync(dirname(destination), { recursive: true });
+    const bytes = rewriteGraphAsset(file, rewriter, urls);
+    writeFileSync(destination, bytes);
+    writeFileSync(file, bytes);
+  }
+  rewriteManifest(directory, urls);
+  return id;
+};
+
 // src/build/externalAssetPlugin.ts
-import { copyFileSync, existsSync, mkdirSync, statSync } from "fs";
-import { basename, dirname, join, resolve } from "path";
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, statSync } from "fs";
+import { basename, dirname as dirname2, join as join2, resolve as resolve2 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
     const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-    const skipRoots = userSourceRoots.map((root) => resolve(root));
+    const skipRoots = userSourceRoots.map((root) => resolve2(root));
     const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
     bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
       if (isUserSource(args.path))
@@ -78,20 +257,20 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname(args.path);
+      const sourceDir = dirname2(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
           continue;
-        const assetPath = resolve(sourceDir, relPath);
-        if (!existsSync(assetPath))
+        const assetPath = resolve2(sourceDir, relPath);
+        if (!existsSync2(assetPath))
           continue;
         if (!statSync(assetPath).isFile())
           continue;
-        const targetPath = join(outDir, basename(assetPath));
-        if (existsSync(targetPath))
+        const targetPath = join2(outDir, basename(assetPath));
+        if (existsSync2(targetPath))
           continue;
-        mkdirSync(dirname(targetPath), { recursive: true });
+        mkdirSync2(dirname2(targetPath), { recursive: true });
         copyFileSync(assetPath, targetPath);
       }
       return;
@@ -102,23 +281,23 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
 // src/cli/scripts/compile.ts
 import {
   cpSync,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  readFileSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
   rmSync,
   statSync as statSync2,
   unlinkSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
 import { createRequire } from "module";
 import {
   basename as basename2,
-  dirname as dirname2,
-  isAbsolute,
-  join as join2,
-  relative,
-  resolve as resolve2
+  dirname as dirname3,
+  isAbsolute as isAbsolute2,
+  join as join3,
+  relative as relative2,
+  resolve as resolve3
 } from "path";
 var cliTag = (color, message) => `\x1B[2m${formatTimestamp2()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`;
 var compileBanner = (version) => {
@@ -129,14 +308,14 @@ var compileBanner = (version) => {
 };
 var collectFiles = (dir) => {
   const result = [];
-  let pending = readdirSync(dir, { withFileTypes: true });
+  let pending = readdirSync2(dir, { withFileTypes: true });
   while (pending.length > 0) {
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join2(entry.parentPath, entry.name);
+    const fullPath = join3(entry.parentPath, entry.name);
     if (entry.isDirectory())
-      pending = pending.concat(readdirSync(fullPath, { withFileTypes: true }));
+      pending = pending.concat(readdirSync2(fullPath, { withFileTypes: true }));
     else
       result.push(fullPath);
   }
@@ -144,7 +323,7 @@ var collectFiles = (dir) => {
 };
 var INLINE_SOURCE_MAP_RE = /sourceMappingURL=data:application\/json(?:;[^,]+)?;base64,([A-Za-z0-9+/=]+)\s*$/;
 var rebaseInlineSourceMap = (filePath) => {
-  const source = readFileSync(filePath, "utf-8");
+  const source = readFileSync2(filePath, "utf-8");
   const match = source.match(INLINE_SOURCE_MAP_RE);
   const encoded = match?.[1];
   if (!encoded)
@@ -155,20 +334,20 @@ var rebaseInlineSourceMap = (filePath) => {
   if (!Array.isArray(map.sources))
     return;
   const sourceRoot = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
-  const bundleDirectory = dirname2(filePath);
+  const bundleDirectory = dirname3(filePath);
   map.sources = map.sources.map((entry) => {
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(entry))
       return entry;
-    if (isAbsolute(entry))
+    if (isAbsolute2(entry))
       return entry;
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(sourceRoot)) {
       return new URL(entry, sourceRoot).href;
     }
-    return resolve2(bundleDirectory, sourceRoot, entry);
+    return resolve3(bundleDirectory, sourceRoot, entry);
   });
   delete map.sourceRoot;
   const rebased = Buffer.from(JSON.stringify(map)).toString("base64");
-  writeFileSync(filePath, source.replace(encoded, rebased));
+  writeFileSync2(filePath, source.replace(encoded, rebased));
 };
 var SERVER_RUNTIME_ASSET_RE = /new\s+URL\(\s*["'](\.\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
 var SERVER_RUNTIME_IMPORT_META_DIR_JOIN_RE = /(?:join|resolve)\(\s*import\.meta\.dir\s*,\s*((?:(?:"[^"]+"|'[^']+')\s*,?\s*)+)\)/g;
@@ -198,16 +377,16 @@ var normalizeServerRuntimeAssetPath = (parts) => {
 };
 var collectProjectSourceFiles = (dir) => {
   const result = [];
-  let pending = readdirSync(dir, { withFileTypes: true });
+  let pending = readdirSync2(dir, { withFileTypes: true });
   while (pending.length > 0) {
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join2(entry.parentPath, entry.name);
+    const fullPath = join3(entry.parentPath, entry.name);
     if (entry.isDirectory()) {
       if (SERVER_RUNTIME_SCAN_SKIP_DIRS.has(entry.name))
         continue;
-      pending = pending.concat(readdirSync(fullPath, { withFileTypes: true }));
+      pending = pending.concat(readdirSync2(fullPath, { withFileTypes: true }));
     } else if (hasSourceExtension(fullPath)) {
       result.push(fullPath);
     }
@@ -216,22 +395,22 @@ var collectProjectSourceFiles = (dir) => {
 };
 var copyServerRuntimeAssetReferences = (outdir) => {
   const copied = new Set;
-  const normalizedOutdir = resolve2(outdir);
+  const normalizedOutdir = resolve3(outdir);
   const copyReference = (filePath, relPath) => {
-    const assetSource = resolve2(dirname2(filePath), relPath);
-    if (!existsSync2(assetSource) || !statSync2(assetSource).isFile())
+    const assetSource = resolve3(dirname3(filePath), relPath);
+    if (!existsSync3(assetSource) || !statSync2(assetSource).isFile())
       return;
-    const assetTarget = resolve2(normalizedOutdir, relPath.replace(/^\.\//, ""));
+    const assetTarget = resolve3(normalizedOutdir, relPath.replace(/^\.\//, ""));
     if (assetTarget !== normalizedOutdir && !assetTarget.startsWith(`${normalizedOutdir}/`))
       return;
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync2(dirname2(assetTarget), { recursive: true });
+    mkdirSync3(dirname3(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
-    const source = readFileSync(filePath, "utf-8");
+    const source = readFileSync2(filePath, "utf-8");
     SERVER_RUNTIME_ASSET_RE.lastIndex = 0;
     let match;
     while ((match = SERVER_RUNTIME_ASSET_RE.exec(source)) !== null) {
@@ -261,7 +440,7 @@ var copyServerRuntimeAssetReferences = (outdir) => {
 };
 var readPackageVersion = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -300,18 +479,18 @@ var resolveBuildModule = async (candidates) => {
 };
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve2(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve2(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve2(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve2(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve2(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve2(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve3(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve3(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve3(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve3(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve3(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve3(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync2(candidate))
+    if (existsSync3(candidate))
       return candidate;
   }
-  return resolve2(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve3(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 };
 var jsxDevRuntimeCompatPath = resolveJsxDevRuntimeCompatPath();
 var shouldEmbedCompiledAsset = (relativePath, skip = new Set) => {
@@ -342,7 +521,7 @@ var resolveCompileNativeAssets = (buildConfig) => (buildConfig.compile?.nativeAs
 var requireForCompile = createRequire(import.meta.url);
 var resolveNativeAssetForRuntime = (specifier) => {
   if (specifier.startsWith("."))
-    return resolve2(process.cwd(), specifier);
+    return resolve3(process.cwd(), specifier);
   if (specifier.startsWith("/"))
     return specifier;
   return requireForCompile.resolve(specifier, { paths: [process.cwd()] });
@@ -356,12 +535,12 @@ var resolveCompileNativeAssetEnv = (buildConfig) => {
 };
 var tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync(join2(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync2(join3(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
 };
-var resolveProjectPackageDir = (specifier) => resolve2(process.cwd(), "node_modules", ...specifier.split("/"));
+var resolveProjectPackageDir = (specifier) => resolve3(process.cwd(), "node_modules", ...specifier.split("/"));
 var copyPackageToBuild = (specifier, outdir, seen) => {
   if (seen.has(specifier))
     return;
@@ -370,13 +549,13 @@ var copyPackageToBuild = (specifier, outdir, seen) => {
   if (!pkg)
     return;
   seen.add(specifier);
-  const destDir = join2(outdir, "node_modules", ...specifier.split("/"));
+  const destDir = join3(outdir, "node_modules", ...specifier.split("/"));
   rmSync(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     force: true,
     recursive: true,
     filter(source) {
-      const rel = relative(srcDir, source);
+      const rel = relative2(srcDir, source);
       const [firstSegment] = rel.split(/[\\/]/);
       return firstSegment !== "node_modules" && firstSegment !== ".git";
     }
@@ -393,8 +572,8 @@ var copyPackageToBuild = (specifier, outdir, seen) => {
 var copyAngularRuntimePackages = (buildConfig, outdir) => {
   if (!buildConfig.angularDirectory)
     return;
-  const angularScopeDir = resolve2(process.cwd(), "node_modules", "@angular");
-  const angularPackages = existsSync2(angularScopeDir) ? readdirSync(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
+  const angularScopeDir = resolve3(process.cwd(), "node_modules", "@angular");
+  const angularPackages = existsSync3(angularScopeDir) ? readdirSync2(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
   const roots = new Set([...angularPackages, "rxjs", "tslib", "typescript"]);
   const seen = new Set;
   for (const specifier of roots) {
@@ -414,16 +593,16 @@ var copyFrameworkRuntimePackages = (buildConfig, outdir) => {
   copyChunkReferencedPackages(outdir, seen);
 };
 var collectRuntimePackageSpecifiers = (distDir) => {
-  const nodeModulesDir = join2(distDir, "node_modules");
-  if (!existsSync2(nodeModulesDir))
+  const nodeModulesDir = join3(distDir, "node_modules");
+  if (!existsSync3(nodeModulesDir))
     return [];
   const specifiers = [];
-  for (const entry of readdirSync(nodeModulesDir, { withFileTypes: true })) {
+  for (const entry of readdirSync2(nodeModulesDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = join2(nodeModulesDir, entry.name);
-      for (const scopedEntry of readdirSync(scopeDir, {
+      const scopeDir = join3(nodeModulesDir, entry.name);
+      for (const scopedEntry of readdirSync2(scopeDir, {
         withFileTypes: true
       })) {
         if (scopedEntry.isDirectory()) {
@@ -437,7 +616,7 @@ var collectRuntimePackageSpecifiers = (distDir) => {
   return specifiers.sort((firstSpecifier, secondSpecifier) => secondSpecifier.length - firstSpecifier.length);
 };
 var ensureRelativeModuleSpecifier = (fromFile, toFile) => {
-  const rel = relative(dirname2(fromFile), toFile).replace(/\\/g, "/");
+  const rel = relative2(dirname3(fromFile), toFile).replace(/\\/g, "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 };
 var pickExportEntry = (value) => {
@@ -456,18 +635,18 @@ var resolvePackageEntryFile = (distDir, packageSpecifiers, specifier) => {
   const packageSpecifier = packageSpecifiers.find((root) => specifier === root || specifier.startsWith(`${root}/`));
   if (!packageSpecifier)
     return null;
-  const packageDir = join2(distDir, "node_modules", ...packageSpecifier.split("/"));
+  const packageDir = join3(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
-  const subPackageDir = subpath ? join2(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync2(join2(subPackageDir, "package.json")) ? subPackageDir : packageDir;
-  const packageJsonPath = join2(resolvedPackageDir, "package.json");
-  if (!existsSync2(packageJsonPath))
+  const subPackageDir = subpath ? join3(packageDir, ...subpath.slice(1).split("/")) : null;
+  const resolvedPackageDir = subPackageDir && existsSync3(join3(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const packageJsonPath = join3(resolvedPackageDir, "package.json");
+  if (!existsSync3(packageJsonPath))
     return null;
-  const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
-  return join2(resolvedPackageDir, entry);
+  return join3(resolvedPackageDir, entry);
 };
 var RUNTIME_JS_EXTENSIONS = [".js", ".mjs", ".cjs"];
 var MODULE_SPECIFIER_RE = /(from\s*|import\s*|import\(\s*|require\(\s*)(["'])([^"']+)\2/g;
@@ -486,17 +665,17 @@ var resolveRuntimeJsFile = (candidate) => {
   const candidates = [
     candidate,
     ...RUNTIME_JS_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-    ...RUNTIME_JS_EXTENSIONS.map((extension) => join2(candidate, `index${extension}`))
+    ...RUNTIME_JS_EXTENSIONS.map((extension) => join3(candidate, `index${extension}`))
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 };
 var findContainingRuntimePackageDir = (filePath) => {
-  let dir = dirname2(filePath);
-  while (dir !== dirname2(dir)) {
-    if (isNodeModulesPath(dir) && existsSync2(join2(dir, "package.json"))) {
+  let dir = dirname3(filePath);
+  while (dir !== dirname3(dir)) {
+    if (isNodeModulesPath(dir) && existsSync3(join3(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname2(dir);
+    dir = dirname3(dir);
   }
   return null;
 };
@@ -510,17 +689,17 @@ var resolvePackageImportEntryFile = (fromFile, specifier) => {
   const entry = pickExportEntry(pkg?.imports?.[specifier]);
   if (!entry)
     return null;
-  return join2(packageDir, entry);
+  return join3(packageDir, entry);
 };
 var collectRuntimeRewriteRoots = (distDir) => collectFiles(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath));
 var toTopLevelPackage = (specifier) => specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
 var FRAMEWORK_PACKAGE_NAME = "@absolutejs/absolute";
 var copyChunkReferencedPackages = (distDir, seen) => {
-  const distRoot = resolve2(distDir);
+  const distRoot = resolve3(distDir);
   for (const filePath of collectRuntimeRewriteRoots(distDir)) {
-    if (resolve2(dirname2(filePath)) === distRoot)
+    if (resolve3(dirname3(filePath)) === distRoot)
       continue;
-    const source = readFileSync(filePath, "utf-8");
+    const source = readFileSync2(filePath, "utf-8");
     for (const match of source.matchAll(MODULE_SPECIFIER_RE)) {
       const [, , , specifier] = match;
       if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.startsWith("node:") || specifier.startsWith("bun:")) {
@@ -551,11 +730,11 @@ var rewriteRuntimeModuleSpecifiers = (distDir) => {
     if (!filePath || seen.has(filePath))
       continue;
     seen.add(filePath);
-    const source = readFileSync(filePath, "utf-8");
+    const source = readFileSync2(filePath, "utf-8");
     const { masked, restore } = maskLiterals(source);
     const rewrittenMasked = masked.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
-        enqueue(resolveRuntimeJsFile(resolve2(dirname2(filePath), specifier)));
+        enqueue(resolveRuntimeJsFile(resolve3(dirname3(filePath), specifier)));
         return match;
       }
       const packageImportTarget = resolveRuntimeJsFile(resolvePackageImportEntryFile(filePath, specifier) ?? "");
@@ -571,7 +750,7 @@ var rewriteRuntimeModuleSpecifiers = (distDir) => {
     });
     const rewritten = restore(rewrittenMasked);
     if (rewritten !== source) {
-      writeFileSync(filePath, rewritten);
+      writeFileSync2(filePath, rewritten);
     }
   }
 };
@@ -585,12 +764,12 @@ var generateEntrypoint = (distDir, serverEntry, prerenderMap, version, buildConf
     "_compile_entrypoint.ts"
   ]);
   const embeddedFiles = allFiles.filter((file) => {
-    const rel = relative(distDir, file);
+    const rel = relative2(distDir, file);
     if (embeddedSkip.has(rel))
       return false;
     return true;
   });
-  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative(distDir, file), assetSkip));
+  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative2(distDir, file), assetSkip));
   const imports = [];
   const nativeImports = [];
   const nativeMappings = [];
@@ -600,19 +779,19 @@ var generateEntrypoint = (distDir, serverEntry, prerenderMap, version, buildConf
   const nativeAssets = resolveCompileNativeAssets(buildConfig);
   nativeAssets.forEach((asset, idx) => {
     const varName = `__native${idx}`;
-    const importSpecifier = asset.import.startsWith(".") ? resolve2(process.cwd(), asset.import) : asset.import;
+    const importSpecifier = asset.import.startsWith(".") ? resolve3(process.cwd(), asset.import) : asset.import;
     nativeImports.push(`import ${varName} from ${JSON.stringify(importSpecifier)} with { type: "file" };`);
     nativeMappings.push(`	[${JSON.stringify(asset.env)}, resolveNativeAssetPath(${varName})],`);
   });
   embeddedFiles.forEach((filePath, idx) => {
-    const rel = relative(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative2(distDir, filePath).replace(/\\/g, "/");
     const varName = `__a${idx}`;
     embeddedVarMap.set(rel, varName);
     imports.push(`import ${varName} from "./${rel}" with { type: "file" };`);
     embeddedMappings.push(`	["${rel}", ${varName}],`);
   });
   clientFiles.forEach((filePath) => {
-    const rel = relative(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative2(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (!varName)
       return;
@@ -626,7 +805,7 @@ var generateEntrypoint = (distDir, serverEntry, prerenderMap, version, buildConf
   const pageVarMap = new Map;
   const prerenderEntries = Array.from(prerenderMap.entries());
   prerenderEntries.forEach(([route, filePath]) => {
-    const rel = relative(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative2(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (varName)
       pageVarMap.set(route, varName);
@@ -655,11 +834,12 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 // ws.data.*). Wiring it into Bun.serve below is what lets compiled servers
 // serve .ws() routes \u2014 without it every upgrade falls through to a 404.
 import { buildGlobalWSHandler } from "elysia/ws";
+import { createClientAssetArchive } from ${JSON.stringify([resolve3(import.meta.dir, "../../runtime/clientAssetArchive.ts"), resolve3(import.meta.dir, "../runtime/clientAssetArchive.js")].find((path) => existsSync3(path)))};
 
 const SERVER_MODULE = (runtimeDir: string) => import(pathToFileURL(join(runtimeDir, ${JSON.stringify(serverBundleName)})).href);
 const RUNTIME_BUILD_ID = ${JSON.stringify(runtimeBuildId)};
 const RUNTIME_CONFIG_SOURCE = ${JSON.stringify(runtimeConfigSource)};
-const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve2(distDir))};
+const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve3(distDir))};
 const ORIGINAL_BUILD_DIR_NORMALIZED = ORIGINAL_BUILD_DIR.replace(/\\\\/g, "/");
 const EMBEDDED_NATIVE_AUTH_CLIENTS = ${JSON.stringify(process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV2])};
 
@@ -696,6 +876,8 @@ ${routeEntries}
 // \u2500\u2500 MIME types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 const MIME: Record<string, string> = {
 	".js": "application/javascript; charset=utf-8",
+	".mjs": "application/javascript; charset=utf-8",
+	".wasm": "application/wasm",
 	".css": "text/css; charset=utf-8",
 	".html": "text/html; charset=utf-8",
 	".json": "application/json",
@@ -876,6 +1058,13 @@ const getRuntimeFetch = () => {
 	return runtimeFetchPromise;
 };
 
+let archivedAsset: ((path: string) => Promise<Blob | undefined>) | undefined;
+try {
+	archivedAsset = await createClientAssetArchive(ASSETS);
+} catch (error) {
+	console.error("[compile] Client asset retention unavailable:", error);
+}
+
 const server = Bun.serve({
 	port,
 	idleTimeout,
@@ -904,11 +1093,14 @@ const server = Bun.serve({
 		if (page) return servePage(page);
 
 		// Check for embedded asset
-		const embedded = ASSETS[url.pathname];
+		let assetPath: string;
+		try { assetPath = decodeURIComponent(url.pathname); }
+		catch { return new Response("Malformed asset path", { status: 400 }); }
+		const embedded = ASSETS[url.pathname] ?? ASSETS[assetPath];
 		if (embedded) {
 			return new Response(Bun.file(embedded), {
 				headers: {
-					"cache-control": isFingerprintedAsset(url.pathname)
+					"cache-control": url.pathname.startsWith("/_absolute/assets/") || isFingerprintedAsset(url.pathname)
 						? "public, max-age=31536000, immutable"
 						: "public, max-age=0, must-revalidate",
 					"content-type": getMime(url.pathname),
@@ -916,6 +1108,15 @@ const server = Bun.serve({
 			});
 		}
 
+		if (url.pathname.startsWith("/_absolute/assets/")) {
+			const retained = await archivedAsset?.(url.pathname) ?? await archivedAsset?.(assetPath);
+			if (retained) return new Response(retained, { headers: {
+				"content-type": getMime(url.pathname),
+				"cache-control": "public, max-age=31536000, immutable",
+				"x-content-type-options": "nosniff"
+			} });
+			return new Response("Asset release no longer available. Refresh to load the current release.", { status: 404, headers: { "cache-control": "no-store" } });
+		}
 		const runtimeFetch = await getRuntimeFetch();
 		if (runtimeFetch) return runtimeFetch(request);
 
@@ -1083,11 +1284,11 @@ var createStubPlugin = (options = {}) => ({
   }
 });
 var compile = async (serverEntry, outdir, outfile, configPath) => {
-  const resolvedOutdir = resolve2(outdir ?? "dist");
+  const resolvedOutdir = resolve3(outdir ?? "dist");
   await withBuildDirectoryLock(resolvedOutdir, () => compileUnlocked(serverEntry, resolvedOutdir, outfile, configPath));
 };
 var compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath) => {
-  rmSync(join2(resolvedOutdir, "node_modules"), {
+  rmSync(join3(resolvedOutdir, "node_modules"), {
     force: true,
     recursive: true
   });
@@ -1095,13 +1296,17 @@ var compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath) =
   const prerenderPort = configuredPrerenderPort > 0 ? configuredPrerenderPort : await findFreePort();
   killStaleProcesses(prerenderPort);
   const entryName = basename2(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutfile = resolve2(outfile ?? "compiled-server");
+  const resolvedOutfile = resolve3(outfile ?? "compiled-server");
   const absoluteVersion = resolvePackageVersion([
-    resolve2(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve2(import.meta.dir, "..", "..", "package.json")
+    resolve3(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve3(import.meta.dir, "..", "..", "package.json")
   ]);
   compileBanner(absoluteVersion);
   const totalStart = performance.now();
+  rmSync(join3(resolvedOutdir, "_absolute", "assets"), {
+    force: true,
+    recursive: true
+  });
   const buildStart = performance.now();
   process.stdout.write(cliTag("\x1B[36m", "Building assets"));
   const buildConfig = await loadConfig(configPath);
@@ -1111,8 +1316,8 @@ var compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath) =
     installAbsoluteMobileAuthEnvironment2(process.cwd(), normalizeAbsoluteMobileConfig2(buildConfig.mobile, process.cwd()));
   try {
     const build = await resolveBuildModule([
-      resolve2(import.meta.dir, "..", "..", "core", "build"),
-      resolve2(import.meta.dir, "..", "build")
+      resolve3(import.meta.dir, "..", "..", "core", "build"),
+      resolve3(import.meta.dir, "..", "build")
     ]);
     if (!build)
       throw new Error("Could not locate build module");
@@ -1123,6 +1328,7 @@ var compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath) =
     process.exit(1);
   }
   console.log(` \x1B[2m(${getDurationString(performance.now() - buildStart)})\x1B[0m`);
+  prepareCompiledClientGraph(resolvedOutdir, `${entryName}.js`, buildConfig.publicDirectory);
   const bundleStart = performance.now();
   process.stdout.write(cliTag("\x1B[36m", "Bundling production server"));
   const userSourceRoots = [
@@ -1134,12 +1340,12 @@ var compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath) =
     buildConfig.htmxDirectory
   ].filter((dir) => Boolean(dir));
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve2(islandRegistrySpec))) : undefined;
-  const serverBundleEntryDirectory = join2(resolvedOutdir, ".absolutejs-server-entry");
-  mkdirSync2(serverBundleEntryDirectory, { recursive: true });
-  const typeboxSetupEntry = join2(serverBundleEntryDirectory, "_typebox_setup.ts");
-  const serverBundleEntry = join2(serverBundleEntryDirectory, basename2(serverEntry));
-  writeFileSync(typeboxSetupEntry, `import { setupTypebox } from 'elysia';
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve3(islandRegistrySpec))) : undefined;
+  const serverBundleEntryDirectory = join3(resolvedOutdir, ".absolutejs-server-entry");
+  mkdirSync3(serverBundleEntryDirectory, { recursive: true });
+  const typeboxSetupEntry = join3(serverBundleEntryDirectory, "_typebox_setup.ts");
+  const serverBundleEntry = join3(serverBundleEntryDirectory, basename2(serverEntry));
+  writeFileSync2(typeboxSetupEntry, `import { setupTypebox } from 'elysia';
 import * as compile from 'typebox/compile';
 import * as schema from 'typebox/schema';
 import * as system from 'typebox/system';
@@ -1148,8 +1354,8 @@ import * as value from 'typebox/value';
 
 setupTypebox({ typebox: { compile, schema, system, type, value } });
 `);
-  writeFileSync(serverBundleEntry, `import './_typebox_setup';
-import * as serverModule from ${JSON.stringify(resolve2(serverEntry))};
+  writeFileSync2(serverBundleEntry, `import './_typebox_setup';
+import * as serverModule from ${JSON.stringify(resolve3(serverEntry))};
 
 export const server = serverModule.server ?? serverModule.app ?? serverModule.default;
 export default server;
@@ -1164,7 +1370,7 @@ export default server;
       ...islandRegistryPlugin ? [islandRegistryPlugin] : [],
       ...buildConfig.mobile ? [
         createAbsoluteMobileRouteMetadataPlugin({
-          entry: resolve2(serverEntry)
+          entry: resolve3(serverEntry)
         })
       ] : [],
       createElysiaOpenApiTypeboxPlugin(),
@@ -1188,14 +1394,14 @@ export default server;
     console.error(cliTag("\x1B[31m", "Server bundle failed."));
     process.exit(1);
   }
-  const outputPath = resolve2(resolvedOutdir, `${entryName}.js`);
-  if (!existsSync2(outputPath)) {
+  const outputPath = resolve3(resolvedOutdir, `${entryName}.js`);
+  if (!existsSync3(outputPath)) {
     console.error(cliTag("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync2(resolve2(resolvedOutdir, "angular", "vendor", "server"))) {
-    const vendorDir = resolve2(resolvedOutdir, "angular", "vendor", "server");
-    const vendorEntries = readdirSync(vendorDir).filter((fileName) => fileName.endsWith(".js"));
+  if (existsSync3(resolve3(resolvedOutdir, "angular", "vendor", "server"))) {
+    const vendorDir = resolve3(resolvedOutdir, "angular", "vendor", "server");
+    const vendorEntries = readdirSync2(vendorDir).filter((fileName) => fileName.endsWith(".js"));
     const angularServerVendorPaths = {};
     for (const file of vendorEntries) {
       const stem = file.replace(/\.js$/, "");
@@ -1203,11 +1409,11 @@ export default server;
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = relative(dirname2(outputPath), resolve2(vendorDir, file));
+      const relPath = relative2(dirname3(outputPath), resolve3(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
-      const { rewriteImports } = await import("./rewriteImports-k6rjjmg1.js");
+      const { rewriteImports } = await import("./rewriteImports-z6629aww.js");
       await rewriteImports([outputPath], angularServerVendorPaths);
     }
   }
@@ -1215,7 +1421,7 @@ export default server;
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag("\x1B[36m", "Pre-rendering pages"));
-  rmSync(join2(resolvedOutdir, "_prerendered"), {
+  rmSync(join3(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -1245,9 +1451,9 @@ export default server;
   const compileStart = performance.now();
   process.stdout.write(cliTag("\x1B[36m", "Compiling standalone executable"));
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
-  const entrypointPath = join2(resolvedOutdir, "_compile_entrypoint.ts");
+  const entrypointPath = join3(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync2(dirname2(resolvedOutfile), { recursive: true });
+  mkdirSync3(dirname3(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },