gemi 0.107.0 → 0.109.0

package/dist/app/index.js

@@ -1,4 +1,4 @@
 // @bun
-import{za as a}from"../chunk-wsftnxzs.js";import"../chunk-82hpq0bq.js";import"../chunk-3s3awh38.js";export{a as App};
+import{za as a}from"../chunk-q8k7f11z.js";import"../chunk-hf32yq23.js";import"../chunk-wvwee7dn.js";export{a as App};
 
 //# debugId=EB7487A2EF3436A164756E2164756E21

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) => {
@@ -36067,8 +36067,8 @@ function exportedType(ts, checker, sourceFile, reference) {
   return { type: checker.getTypeOfSymbolAtLocation(symbol, sourceFile), name: symbol.getName() };
 }
 function specifier(from, to) {
-  const relative4 = path7.relative(path7.dirname(from), to).split(path7.sep).join("/").replace(/(\.d)?\.(ts|tsx|mts|cts)$/, "");
-  return relative4.startsWith(".") ? relative4 : `./${relative4}`;
+  const relative5 = path7.relative(path7.dirname(from), to).split(path7.sep).join("/").replace(/(\.d)?\.(ts|tsx|mts|cts)$/, "");
+  return relative5.startsWith(".") ? relative5 : `./${relative5}`;
 }
 function isFrameworkJsonValue(type) {
   const alias = type.aliasSymbol;
@@ -36748,8 +36748,16 @@ async function createRollupInput_default(appDir) {
       continue;
     if (/\.(test|spec)\.tsx$/.test(file))
       continue;
+    if (/\.island\.tsx$/.test(file))
+      continue;
     entries.add(`/app/views/${file}`);
   }
+  const islandGlob = new Glob("**/*.island.{ts,tsx,js,jsx,mts,mjs}");
+  for await (const file of islandGlob.scan({ cwd: appDir })) {
+    if (file.split("/").includes("node_modules"))
+      continue;
+    entries.add(`/app/${file}`);
+  }
   return Array.from(entries);
 }
 
@@ -40088,6 +40096,55 @@ function documentBase(base) {
   return base.startsWith("/") || /^[a-z][a-z\d+.-]*:\/\//i.test(base) ? normalizeAssetBase(base) : DEFAULT_ASSET_BASE;
 }
 
+// vite/islandPlugin.ts
+import { realpathSync } from "fs";
+import { relative, sep } from "path";
+var ISLAND_LOADER = /\(\s*\)\s*=>\s*import\(\s*(["'])([^"'\n]+?\.island(?:\.[cm]?[jt]sx?)?)\1\s*\)/g;
+function realPath(path3) {
+  try {
+    return realpathSync(path3);
+  } catch {
+    return path3;
+  }
+}
+function gemiIslandPlugin() {
+  let root = process.cwd();
+  return {
+    name: "gemi-plugin-islands",
+    enforce: "pre",
+    configResolved(config) {
+      root = realPath(config.root);
+    },
+    async transform(code, id, options) {
+      if (id.includes("/node_modules/") || id.startsWith("\x00"))
+        return null;
+      if (!/\.[cm]?[jt]sx?$/.test(id.split("?")[0]))
+        return null;
+      if (!code.includes(".island"))
+        return null;
+      const ssr = Boolean(options?.ssr) || this.environment?.config?.consumer === "server";
+      const s = new MagicString(code);
+      let changed = false;
+      for (const match of code.matchAll(ISLAND_LOADER)) {
+        const [whole, quote, specifier] = match;
+        const resolved = await this.resolve(specifier, id);
+        if (!resolved || resolved.external)
+          continue;
+        const file = realPath(resolved.id.split("?")[0]);
+        const key = relative(root, file).split(sep).join("/");
+        if (key.startsWith(".."))
+          continue;
+        const loader = ssr ? `() => Promise.reject(new Error("Island modules load in the browser."))` : `() => import(${quote}${specifier}${quote})`;
+        s.overwrite(match.index, match.index + whole.length, `Object.assign(${loader}, { gemiIsland: ${JSON.stringify(key)} })`);
+        changed = true;
+      }
+      if (!changed)
+        return null;
+      return { code: s.toString(), map: s.generateMap({ hires: true }) };
+    }
+  };
+}
+
 // vite/index.ts
 var gemi = async () => {
   const userConfig = await loadGemiConfig(process.cwd());
@@ -40106,7 +40163,7 @@ var gemi = async () => {
             ssrEmitAssets: true,
             sourcemap: true,
             rollupOptions: {
-              input: Array.from(JSON.parse(process.env.GEMI_INPUT ?? "[]")),
+              input: Array.from(JSON.parse(process.env.GEMI_INPUT ?? "[]")).filter((entry) => !(env.isSsrBuild && /\.island\.[cm]?[jt]sx?$/.test(entry))),
               preserveEntrySignatures: "strict",
               ...env.isSsrBuild ? { external: isGemiExternal } : {}
             }
@@ -40124,6 +40181,7 @@ var gemi = async () => {
       config: () => userViteConfig
     },
     gemiAssetBasePlugin(assetBase),
+    gemiIslandPlugin(),
     {
       name: "gemi-plugin-hot-reload",
       handleHotUpdate({ server, modules }) {
@@ -40140,7 +40198,7 @@ var vite_default = gemi;
 
 // vite/previousAssets.ts
 import { copyFile, lstat, mkdir as mkdir2, readdir, readFile, stat, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, isAbsolute, join as join4, relative, resolve, sep } from "path";
+import { dirname as dirname2, isAbsolute, join as join4, relative as relative2, resolve, sep as sep2 } from "path";
 var PREVIOUS_ASSETS_RECORD = ".vite/previous-assets.json";
 var DEFAULT_RETAINED_RELEASES = 2;
 var DEFAULT_RETAINED_MAX_AGE_SECONDS = 7 * 24 * 60 * 60;
@@ -40174,7 +40232,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 +40250,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 +40261,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 +40272,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 +40285,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;
@@ -40256,8 +40332,8 @@ function isCarriable(file) {
 }
 function inside(root, file) {
   const path3 = resolve(root, file);
-  const rel2 = relative(root, path3);
-  return rel2 && !rel2.startsWith("..") && !isAbsolute(rel2) && rel2.split(sep)[0] === ASSETS_DIR ? path3 : null;
+  const rel2 = relative2(root, path3);
+  return rel2 && !rel2.startsWith("..") && !isAbsolute(rel2) && rel2.split(sep2)[0] === ASSETS_DIR ? path3 : null;
 }
 async function isDirectory(path3) {
   try {
@@ -40282,6 +40358,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 {
@@ -40300,26 +40485,26 @@ var {
 
 // bin/check-models.ts
 import { statSync as statSync2 } from "fs";
-import { relative as relative3, resolve as resolve2 } from "path";
+import { relative as relative4, 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 relative3 } from "path";
 function sourceFiles(dir, ignore = []) {
   const out = [];
   const ignored = (path3) => {
-    const rel2 = relative2(dir, path3).split("\\").join("/");
+    const rel2 = relative3(dir, path3).split("\\").join("/");
     return ignore.some((pattern) => rel2 === pattern || rel2.startsWith(`${pattern}/`));
   };
   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;
@@ -40412,7 +40597,7 @@ async function declaredModules(rootDir) {
   try {
     ({ default: Kernel } = await import(path3));
   } catch (error) {
-    throw new CheckModelsError(`Could not load ${relative3(rootDir, path3)}:
+    throw new CheckModelsError(`Could not load ${relative4(rootDir, path3)}:
     ${error.message}`);
   }
   return new Kernel().models ?? [];
@@ -40465,8 +40650,8 @@ ${error.message}`);
   const paths = modelFiles(modelsDir, ignore);
   const files = [];
   for (const path3 of paths) {
-    const label = relative3(rootDir, path3);
-    const specifier = `./${relative3(modelsDir, path3).split("\\").join("/").replace(/\.tsx?$/, "")}`;
+    const label = relative4(rootDir, path3);
+    const specifier = `./${relative4(modelsDir, path3).split("\\").join("/").replace(/\.tsx?$/, "")}`;
     try {
       files.push({
         label,
@@ -40515,7 +40700,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 +40752,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 +40784,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 +40832,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 +40936,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 +40972,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 {
@@ -40999,11 +41184,11 @@ function hashDirectory(dir) {
     const entries = readdirSync3(current, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     for (const entry of entries) {
       const full = path5.join(current, entry.name);
-      const relative4 = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const relative5 = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        walk3(full, relative4);
+        walk3(full, relative5);
       } else if (entry.isFile()) {
-        hash.update(relative4);
+        hash.update(relative5);
         hash.update("\x00");
         hash.update(readFileSync3(full));
         hash.update("\x00");
@@ -41266,7 +41451,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 +41481,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 +41528,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 +41724,5 @@ program.command("app:route-manifest").action(async () => {
 });
 program.parse();
 
-//# debugId=D394A7B3011B327964756E2164756E21
+//# debugId=C2424D7419BD4C9164756E2164756E21
 //# sourceMappingURL=gemi.js.map