@junejs/server 0.0.31 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -30,10 +30,11 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.32",
+    "@junejs/core": "0.0.33",
     "@junejs/db": "0.0.28",
     "lightningcss": "^1.27.0",
     "marked": "^18.0.5",
+    "oxc-parser": "^0.137.0",
     "rolldown": "^1.1.0"
   },
   "peerDependencies": {

package/src/island-registry.ts

@@ -23,6 +23,8 @@
 import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
 
+import { parseSync } from "oxc-parser";
+
 export const ISLAND_REGISTRY_FILE = "_islands.gen.ts";
 
 // Shared with rsc-manifest.ts (the RSC client-reference codegen).
@@ -62,27 +64,83 @@ export function exportNames(src: string): string[] {
   return names;
 }
 
+// The island NAME an `island(...)` call registers under — the SAME value the
+// runtime derives (options.name ?? the component's function/identifier name).
+// Keying the loader by THIS (not the export name) is what kills the desync
+// (P1-1): the marker, the registry, and the loader all agree by construction.
+// Returns null for an anonymous component with no { name } — island() throws on
+// that at runtime, so we leave it for the runtime to report.
+function islandNameOfCall(init: unknown): string | null {
+  const call = init as { type?: string; callee?: { type?: string; name?: string }; arguments?: any[] };
+  if (call?.type !== "CallExpression") return null;
+  if (call.callee?.type !== "Identifier" || call.callee.name !== "island") return null;
+  const [a0, a1] = call.arguments ?? [];
+  if (a1?.type === "ObjectExpression") {
+    for (const p of a1.properties ?? []) {
+      const key = p.key?.name ?? p.key?.value;
+      if (key === "name" && typeof p.value?.value === "string") return p.value.value;
+    }
+  }
+  if (a0?.type === "FunctionExpression") return a0.id?.name ?? null;
+  if (a0?.type === "Identifier") return a0.name ?? null;
+  return null; // arrow/anonymous without { name } → runtime island() errors
+}
+
+// True iff the module imports `island` from @junejs/core/islands (so a local
+// function happening to be named `island` is never mistaken for the API).
+function importsIslandApi(program: { body: any[] }): boolean {
+  return program.body.some(
+    (n) =>
+      n.type === "ImportDeclaration" &&
+      n.source?.value === "@junejs/core/islands" &&
+      (n.specifiers ?? []).some((s: any) => s.imported?.name === "island"),
+  );
+}
+
 // Write app/_islands.gen.ts. Returns the number of island loaders emitted.
+//
+// AST-based (oxc-parser) — robust against multi-line exports / re-exports that a
+// line regex would miss (P1-2), keyed by the island's runtime name (P1-1), and
+// it throws on a duplicate name across modules (P2-1) instead of silently
+// overwriting.
 export function generateIslandRegistry(appDir: string): number {
-  const mods = walk(appDir)
-    .filter((f) => /\.(tsx|ts|jsx)$/.test(f) && !f.endsWith(ISLAND_REGISTRY_FILE))
-    .map((f) => ({ f, src: readFileSync(f, "utf8") }))
-    .filter(
-      ({ src }) =>
-        firstStatementIsDirective(src, "use client") &&
-        /@junejs\/core\/islands/.test(src) &&
-        /\bisland\s*\(/.test(src),
-    );
-
+  const seen = new Map<string, string>(); // island name → absolute file (dup guard)
   const entries: string[] = [];
-  for (const { f, src } of mods) {
+
+  for (const f of walk(appDir)) {
+    if (!/\.(tsx|ts|jsx)$/.test(f) || f.endsWith(ISLAND_REGISTRY_FILE)) continue;
+    const src = readFileSync(f, "utf8");
+    if (!firstStatementIsDirective(src, "use client")) continue;
+    const { program } = parseSync(f, src);
+    if (!importsIslandApi(program as { body: any[] })) continue;
+
     const rel = "./" + relative(appDir, f).replace(/\.(tsx|ts|jsx)$/, "");
-    for (const name of exportNames(src)) {
-      if (name === "default") continue; // islands are named exports
-      entries.push(`  ${JSON.stringify(name)}: () => import(${JSON.stringify(rel)}),`);
+    for (const node of (program as { body: any[] }).body) {
+      const varDecl =
+        node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration"
+          ? node.declaration
+          : node.type === "VariableDeclaration"
+            ? node
+            : null;
+      if (!varDecl) continue;
+      for (const d of varDecl.declarations ?? []) {
+        const name = islandNameOfCall(d.init);
+        if (!name) continue;
+        const prev = seen.get(name);
+        if (prev && prev !== f) {
+          throw new Error(
+            `[june] duplicate island name "${name}": defined in ${rel} and ` +
+              `./${relative(appDir, prev).replace(/\.(tsx|ts|jsx)$/, "")}. Island names must be unique.`,
+          );
+        }
+        if (seen.has(name)) continue;
+        seen.set(name, f);
+        entries.push(`  ${JSON.stringify(name)}: () => import(${JSON.stringify(rel)}),`);
+      }
     }
   }
 
+  entries.sort(); // deterministic output
   const body = entries.length ? entries.join("\n") + "\n" : "";
   const out =
     "// AUTO-GENERATED by June — do not edit. Lazy loaders for island() modules.\n" +