gemi 0.107.0 → 0.108.0

package/dist/bin/gemi.js

@@ -36002,10 +36002,10 @@ function extractAgent(ts, reference, { cwd = process.cwd(), name } = {}) {
   ].join(`
 `);
   const host = ts.createCompilerHost(options);
-  const { getSourceFile, fileExists, readFile: readFile2 } = host;
+  const { getSourceFile, fileExists, readFile: readFile3 } = host;
   host.getSourceFile = (fileName, languageVersion, ...rest) => fileName === probe ? ts.createSourceFile(fileName, source, languageVersion) : getSourceFile.call(host, fileName, languageVersion, ...rest);
   host.fileExists = (fileName) => fileName === probe || fileExists.call(host, fileName);
-  host.readFile = (fileName) => fileName === probe ? source : readFile2.call(host, fileName);
+  host.readFile = (fileName) => fileName === probe ? source : readFile3.call(host, fileName);
   const second = ts.createProgram({ rootNames: [file, probe], options, host, oldProgram: first });
   const probeFile = second.getSourceFile(probe);
   const alias = (aliasName) => {
@@ -40174,7 +40174,9 @@ async function stagePreviousAssets(options, stagingDir, now = new Date) {
   }
   const carried = await readRecord(from);
   const carriedFiles = new Set(carried.flatMap((release) => release.files));
-  const own = (await listFiles(from, ASSETS_DIR)).filter((file) => isCarriable(file) && !carriedFiles.has(file));
+  const listed = await listFiles(from, ASSETS_DIR);
+  const listedSet = new Set(listed);
+  const own = listed.filter((file) => isCarriable(file) && !carriedFiles.has(file) && !isSiblingIn(file, listedSet));
   const releases = [
     { retiredAt: now.toISOString(), files: own },
     ...carried.filter((release) => now.getTime() - Date.parse(release.retiredAt) < options.maxAgeMs)
@@ -40190,6 +40192,7 @@ async function stagePreviousAssets(options, stagingDir, now = new Date) {
       const target = join4(stagingDir, file);
       await mkdir2(dirname2(target), { recursive: true });
       await copyFile(source, target);
+      await copySiblings(source, target);
       files.push(file);
     }
     if (files.length > 0) {
@@ -40200,6 +40203,7 @@ async function stagePreviousAssets(options, stagingDir, now = new Date) {
 }
 async function restorePreviousAssets(stagingDir, clientDir, releases) {
   const record = [];
+  const paths = [];
   let count = 0;
   for (const release of releases) {
     const files = [];
@@ -40210,7 +40214,9 @@ async function restorePreviousAssets(stagingDir, clientDir, releases) {
       }
       await mkdir2(dirname2(target), { recursive: true });
       await copyFile(join4(stagingDir, file), target);
+      await copySiblings(join4(stagingDir, file), target);
       files.push(file);
+      paths.push(file);
     }
     if (files.length > 0) {
       record.push({ retiredAt: release.retiredAt, files });
@@ -40221,7 +40227,19 @@ async function restorePreviousAssets(stagingDir, clientDir, releases) {
   await mkdir2(dirname2(recordPath), { recursive: true });
   await writeFile2(recordPath, `${JSON.stringify({ releases: record }, null, 2)}
 `);
-  return { files: count, releases: record.length };
+  return { files: count, releases: record.length, paths };
+}
+var SIBLING_SUFFIXES = [".br", ".gz"];
+function isSiblingIn(file, files) {
+  const suffix = SIBLING_SUFFIXES.find((ext) => file.endsWith(ext));
+  return suffix !== undefined && files.has(file.slice(0, -suffix.length));
+}
+async function copySiblings(source, target) {
+  for (const ext of SIBLING_SUFFIXES) {
+    if (await isFile(source + ext)) {
+      await copyFile(source + ext, target + ext);
+    }
+  }
 }
 async function readRecord(clientDir) {
   let raw;
@@ -40282,6 +40300,115 @@ async function exists(path3) {
   }
 }
 
+// vite/precompressAssets.ts
+import { mkdir as mkdir3, readFile as readFile2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { availableParallelism } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+import { promisify } from "util";
+import { brotliCompress, constants, gzip } from "zlib";
+var STATIC_ASSETS_RECORD = ".vite/static-assets.json";
+var PRECOMPRESS_MIN_BYTES = 1024;
+var COMPRESSIBLE = /\.(?:m?js|cjs|css|svg|json|webmanifest|wasm|txt|xml|ttf|otf|eot)$/i;
+var TEXT = /\.(?:m?js|cjs|css|svg|json|webmanifest|txt|xml)$/i;
+var FONT = /\.(?:ttf|otf|eot)$/i;
+var SIBLING_EXTENSION = {
+  br: ".br",
+  gzip: ".gz"
+};
+var ENCODINGS = ["br", "gzip"];
+var brotli = promisify(brotliCompress);
+var gzipAsync = promisify(gzip);
+function isPrecompressible(file) {
+  return COMPRESSIBLE.test(file);
+}
+async function encode2(encoding, file, input) {
+  if (encoding === "gzip") {
+    return gzipAsync(input, { level: 9 });
+  }
+  return brotli(input, {
+    params: {
+      [constants.BROTLI_PARAM_QUALITY]: constants.BROTLI_MAX_QUALITY,
+      [constants.BROTLI_PARAM_MODE]: TEXT.test(file) ? constants.BROTLI_MODE_TEXT : FONT.test(file) ? constants.BROTLI_MODE_FONT : constants.BROTLI_MODE_GENERIC,
+      [constants.BROTLI_PARAM_SIZE_HINT]: input.length
+    }
+  });
+}
+async function fileSize(path3) {
+  try {
+    const info = await stat2(path3);
+    return info.isFile() ? info.size : null;
+  } catch {
+    return null;
+  }
+}
+async function precompressAssets(clientDir, files, options = {}) {
+  const minBytes = options.minBytes ?? PRECOMPRESS_MIN_BYTES;
+  const record = { files: {} };
+  const stats = {
+    files: 0,
+    identityBytes: 0,
+    brBytes: 0,
+    gzipBytes: 0
+  };
+  const queue = [...new Set(files)];
+  for (const file of queue) {
+    record.files[file] = [];
+  }
+  async function work(file) {
+    if (!isPrecompressible(file)) {
+      return;
+    }
+    const path3 = join5(clientDir, file);
+    const size = await fileSize(path3);
+    if (size === null || size < minBytes) {
+      return;
+    }
+    let input = null;
+    const available = [];
+    const sizes = {};
+    for (const encoding of ENCODINGS) {
+      const siblingPath = path3 + SIBLING_EXTENSION[encoding];
+      const existing = options.reuseExisting ? await fileSize(siblingPath) : null;
+      if (existing !== null) {
+        if (existing < size) {
+          available.push(encoding);
+          sizes[encoding] = existing;
+        }
+        continue;
+      }
+      input ??= await readFile2(path3);
+      const output = await encode2(encoding, file, input);
+      if (output.length < size) {
+        await writeFile3(siblingPath, output);
+        available.push(encoding);
+        sizes[encoding] = output.length;
+      }
+    }
+    record.files[file] = available;
+    if (available.length > 0) {
+      stats.files += 1;
+      stats.identityBytes += size;
+      stats.brBytes += sizes.br ?? size;
+      stats.gzipBytes += sizes.gzip ?? size;
+    }
+  }
+  const concurrency = Math.max(1, options.concurrency ?? Math.min(8, availableParallelism()));
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+    while (next < queue.length) {
+      await work(queue[next++]);
+    }
+  }));
+  return { record, stats };
+}
+async function writeStaticAssetsRecord(clientDir, record) {
+  const path3 = join5(clientDir, STATIC_ASSETS_RECORD);
+  await mkdir3(dirname3(path3), { recursive: true });
+  const files = Object.fromEntries(Object.entries(record.files).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+  await writeFile3(path3, `${JSON.stringify({ files }, null, 2)}
+`);
+}
+
 // ../../node_modules/.bun/commander@12.1.0/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -40304,7 +40431,7 @@ import { relative as relative3, resolve as resolve2 } from "path";
 
 // support/discover.ts
 import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join5, relative as relative2 } from "path";
+import { join as join6, relative as relative2 } from "path";
 function sourceFiles(dir, ignore = []) {
   const out = [];
   const ignored = (path3) => {
@@ -40313,13 +40440,13 @@ function sourceFiles(dir, ignore = []) {
   };
   const walk3 = (current) => {
     for (const entry of readdirSync2(current, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
-      const path3 = join5(current, entry.name);
+      const path3 = join6(current, entry.name);
       if (ignored(path3))
         continue;
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules")
           continue;
-        if (existsSync3(join5(path3, "package.json")))
+        if (existsSync3(join6(path3, "package.json")))
           continue;
         walk3(path3);
         continue;
@@ -40515,7 +40642,7 @@ function indent(message) {
 
 // bin/ide/generateApiManifest.ts
 var import_recast2 = __toESM(require_main2(), 1);
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { existsSync as existsSync4 } from "fs";
 
 // utils/toCamelCase.ts
@@ -40567,7 +40694,7 @@ class ApiManifestGenerator {
   rootRouterBody;
   routerBodyCache = new Map;
   controllerCache = new Map;
-  manifestCacheDir = join6(ROOT, ".gemi/cache/api-routes-manifest");
+  manifestCacheDir = join7(ROOT, ".gemi/cache/api-routes-manifest");
   async writeManifest(cacheFilePath) {
     const manifest = {};
     for (const [routeName, method] of this.routes.entries()) {
@@ -40599,7 +40726,7 @@ class ApiManifestGenerator {
     if (path4.startsWith("@/app")) {
       return path4.replace("@", "") + ".ts";
     }
-    return join6(parentPath, path4) + ".ts";
+    return join7(parentPath, path4) + ".ts";
   }
   isFileShouldBeParsed(path4) {
     return path4.includes("app/http/router") || path4.includes("app/http/controllers");
@@ -40647,7 +40774,7 @@ class ApiManifestGenerator {
     if (normalizedPath.startsWith("/app/http/controllers")) {
       for (const specifier of node.specifiers) {
         const name = specifier.type === "ImportDefaultSpecifier" ? specifier.local.name : specifier.imported.name;
-        await this.parseControllerFile(await this.parseFile(join6(ROOT, normalizedPath)), name, normalizedPath);
+        await this.parseControllerFile(await this.parseFile(join7(ROOT, normalizedPath)), name, normalizedPath);
       }
     }
     if (normalizedPath.startsWith("/app/http/routes")) {
@@ -40751,7 +40878,7 @@ class ApiManifestGenerator {
   }
   async parse(cacheFilePath, filePath, isRoot = true, name = "") {
     console.log({ ROOT, filePath });
-    const file = await this.parseFile(join6(ROOT, filePath));
+    const file = await this.parseFile(join7(ROOT, filePath));
     for (const body of file.program.body) {
       if (!this.isNodeShouldBeParsed(body))
         continue;
@@ -40787,7 +40914,7 @@ class ApiManifestGenerator {
   }
   async run(filePath) {
     const cacheId = generateGitDiffId();
-    const cacheFilePath = join6(this.manifestCacheDir, `${cacheId}.json`);
+    const cacheFilePath = join7(this.manifestCacheDir, `${cacheId}.json`);
     if (existsSync4(cacheFilePath)) {
       console.log(await Bun.file(cacheFilePath).text());
     } else {
@@ -41266,7 +41393,7 @@ gemi is now ${resolved}.`);
 }
 
 // bin/forwardSignals.ts
-import { constants } from "os";
+import { constants as constants2 } from "os";
 var FORWARDED = ["SIGTERM", "SIGINT"];
 async function spawnForwardingSignals(options) {
   const proc = Bun.spawn({
@@ -41296,7 +41423,7 @@ async function spawnForwardingSignals(options) {
 function exitCodeOf(proc) {
   if (proc.exitCode !== null)
     return proc.exitCode;
-  const signal = proc.signalCode && constants.signals[proc.signalCode];
+  const signal = proc.signalCode && constants2.signals[proc.signalCode];
   return signal ? 128 + signal : 1;
 }
 
@@ -41343,23 +41470,47 @@ program.command("build").action(async () => {
   process.env.GEMI_INPUT = JSON.stringify(input);
   const previousAssets = resolvePreviousAssets(config.previousAssets, rootDir);
   const stagingDir = previousAssets ? await mkdtemp(path9.join(tmpdir(), "gemi-previous-assets-")) : undefined;
+  const clientDir = path9.join(rootDir, "dist", "client");
+  const emitted = [];
+  let carriedPaths = [];
   try {
     const retained = previousAssets && stagingDir ? await stagePreviousAssets(previousAssets, stagingDir) : [];
     console.log("Building client...");
     await build({
       configFile: false,
-      plugins: [vite_default()],
+      plugins: [
+        vite_default(),
+        {
+          name: "gemi:emitted-assets",
+          apply: "build",
+          writeBundle(_options, bundle) {
+            for (const file of Object.keys(bundle)) {
+              if (file.startsWith("assets/"))
+                emitted.push(file);
+            }
+          }
+        }
+      ],
       build: { outDir: "dist/client" }
     });
     if (stagingDir) {
-      const carried = await restorePreviousAssets(stagingDir, path9.join(rootDir, "dist", "client"), retained);
-      console.log(`Kept ${carried.files} asset file(s) from ${carried.releases} earlier release(s).`);
+      const carried2 = await restorePreviousAssets(stagingDir, clientDir, retained);
+      carriedPaths = carried2.paths;
+      console.log(`Kept ${carried2.files} asset file(s) from ${carried2.releases} earlier release(s).`);
     }
   } finally {
     if (stagingDir) {
       await rm(stagingDir, { recursive: true, force: true });
     }
   }
+  const startedAt = performance.now();
+  const fresh = await precompressAssets(clientDir, emitted);
+  const carried = await precompressAssets(clientDir, carriedPaths, { reuseExisting: true });
+  await writeStaticAssetsRecord(clientDir, {
+    files: { ...carried.record.files, ...fresh.record.files }
+  });
+  const kb = (bytes) => `${(bytes / 1024).toFixed(1)} kB`;
+  console.log(`Precompressed ${fresh.stats.files} asset(s): ${kb(fresh.stats.identityBytes)} \u2192 ` + `${kb(fresh.stats.brBytes)} br / ${kb(fresh.stats.gzipBytes)} gzip ` + `(${Math.round(performance.now() - startedAt)} ms).`);
   console.log("Building server...");
   await build({
     configFile: false,
@@ -41515,5 +41666,5 @@ program.command("app:route-manifest").action(async () => {
 });
 program.parse();
 
-//# debugId=D394A7B3011B327964756E2164756E21
+//# debugId=45F966AEDDDBFC5864756E2164756E21
 //# sourceMappingURL=gemi.js.map