@junejs/server 0.0.31 → 0.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "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/build.ts

@@ -532,7 +532,12 @@ ${adapterEntry.wrap("pipeline")}
     // the dev-only code tree-shakes. Build-time on purpose: runtime process.env.NODE_ENV
     // differs by target (Vercel sets it; workerd may not), so baking it makes the output
     // deterministic and target-agnostic. `june dev` doesn't use this path.
-    transform: { define: { "process.env.NODE_ENV": JSON.stringify("production") } },
+    transform: {
+      define: { "process.env.NODE_ENV": JSON.stringify("production") },
+      // Route JSX through June's runtime so `<X client:*/>` in pages emits island
+      // markers at SSR (rolldown ignores the tsconfig/pragma; set it explicitly).
+      jsx: { runtime: "automatic", importSource: "@junejs/core" },
+    },
     plugins: [rolldownCssModulesPlugin(cssModuleMaps)], // .module.css → scoped class map
     external: (id: string) => {
       // Bun built-ins exist only at Bun runtime, never in the workerd graph (see isBunSpecifier).

package/src/client-bundle.ts

@@ -50,7 +50,10 @@ async function bundleClient(entryFile: string, cwd: string, mode: BundleMode, ma
     // branch resolved at build (no `process` in the browser to read it at runtime).
     platform: "browser",
     plugins: [rolldownCssModulesPlugin(maps)], // islands may import .module.css
-    transform: { define: { "process.env.NODE_ENV": JSON.stringify(mode) } },
+    transform: {
+      define: { "process.env.NODE_ENV": JSON.stringify(mode) },
+      jsx: { runtime: "automatic", importSource: "@junejs/core" }, // June's island JSX runtime
+    },
     resolve: { conditionNames: ["browser", "import", "default"] },
   });
   return bundle;

package/src/island-registry.ts

@@ -1,27 +1,18 @@
-// Auto-generate the island registry by scanning "use client" island() modules,
-// so the author never hand-writes the `{ name: () => import("./Island") }` map.
+// Auto-generate the island registry by scanning ISLAND USAGE — every
+// `<Counter client:*/>` in the app — and resolving the component's import AT THE
+// USAGE SITE. Writes app/_islands.gen.ts mapping each island name to a lazy loader
+// that dynamic-imports its module and resolves the component export.
 //
-// Scans app/** for modules that (a) start with the "use client" directive AND
-// (b) use `island()` from @junejs/core/islands, and writes app/_islands.gen.ts:
+// Usage-driven, so a third-party (lib) island is discovered the same way as an app
+// one — the import specifier is right there at the call site (no lib manifest, no
+// scan of node_modules). The KEY is the imported name = the component's runtime name
+// = the marker the JSX runtime stamps, so all three agree by construction.
 //
-//   export const ISLAND_LOADERS = {
-//     "Counter": () => import("./poc/Counter"),
-//     "Tabs":    () => import("./poc/Tabs"),
-//   };
-//
-// The KEY is the module's EXPORT name; importing the module runs its `island()`
-// call, which self-registers the component under its runtime name. Those must
-// agree — the marker the server stamps (the island's name) is what the client
-// looks up. So the convention is: an island's name == its export name (the React
-// default — `export const Counter = island(function Counter() {…})` satisfies it
-// for free; otherwise pass `island(C, { name })`).
-//
-// Over-inclusion is harmless: a loader whose name no marker references is never
-// called, so no chunk for an unused export is ever fetched.
-//
-// Host-coupled (node:fs), so it lives in @junejs/server, never the contract layer.
+// Host-coupled (node:fs + oxc-parser), so it lives in @junejs/server.
 import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { join, relative, dirname, resolve } from "node:path";
+
+import { parseSync } from "oxc-parser";
 
 export const ISLAND_REGISTRY_FILE = "_islands.gen.ts";
 
@@ -34,7 +25,7 @@ export function walk(dir: string): string[] {
 }
 
 // True iff the first real statement (skipping blanks + line comments) is the
-// directive — the same rule the bundler uses to treat a module as client.
+// directive — used by the RSC manifest codegen.
 export function firstStatementIsDirective(src: string, directive: string): boolean {
   for (const line of src.split("\n")) {
     const t = line.trim();
@@ -44,14 +35,14 @@ export function firstStatementIsDirective(src: string, directive: string): boole
   return false;
 }
 
-// The named exports of a module (skipping `export default` and `export type`).
+// The named exports of a module — used by the RSC manifest codegen.
 export function exportNames(src: string): string[] {
   const names: string[] = [];
   for (const line of src.split("\n")) {
     const t = line.trim();
     const decl = t.match(/^export\s+(?:async\s+)?(?:function|const|let|var|class)\s+([A-Za-z0-9_$]+)/);
     if (decl) names.push(decl[1]!);
-    const named = t.match(/^export\s*\{([^}]*)\}/); // `export type { … }` won't match (the `type` breaks it)
+    const named = t.match(/^export\s*\{([^}]*)\}/);
     if (named) {
       for (const part of named[1]!.split(",")) {
         const e = part.split(" as ").pop()?.trim();
@@ -62,31 +53,96 @@ export function exportNames(src: string): string[] {
   return names;
 }
 
+type Import = { spec: string; imported: string; kind: "named" | "default" | "namespace" };
+
+// local binding name → its import, for one module.
+function importMap(program: { body: any[] }): Map<string, Import> {
+  const map = new Map<string, Import>();
+  for (const n of program.body) {
+    if (n.type !== "ImportDeclaration" || typeof n.source?.value !== "string") continue;
+    const spec = n.source.value as string;
+    for (const s of n.specifiers ?? []) {
+      if (s.type === "ImportSpecifier") map.set(s.local.name, { spec, imported: s.imported.name, kind: "named" });
+      else if (s.type === "ImportDefaultSpecifier") map.set(s.local.name, { spec, imported: "default", kind: "default" });
+      else if (s.type === "ImportNamespaceSpecifier") map.set(s.local.name, { spec, imported: "*", kind: "namespace" });
+    }
+  }
+  return map;
+}
+
+// Does this JSX element carry a `client:*` directive?
+function hasClientDirective(openingElement: any): boolean {
+  return (openingElement.attributes ?? []).some(
+    (a: any) => a.type === "JSXAttribute" && a.name?.type === "JSXNamespacedName" && a.name.namespace?.name === "client",
+  );
+}
+
+// Collect every JSX element tag used with a client:* directive (recursive walk).
+function islandTags(program: { body: any[] }): string[] {
+  const tags: string[] = [];
+  (function walkNode(node: any) {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) return node.forEach(walkNode);
+    if (node.type === "JSXElement" && node.openingElement?.name?.type === "JSXIdentifier" && hasClientDirective(node.openingElement)) {
+      tags.push(node.openingElement.name.name);
+    }
+    for (const k in node) if (k !== "type") walkNode(node[k]);
+  })(program);
+  return tags;
+}
+
 // Write app/_islands.gen.ts. Returns the number of island loaders emitted.
 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 → loader specifier (dup guard)
   const entries: string[] = [];
-  for (const { f, src } of mods) {
-    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 f of walk(appDir)) {
+    if (!/\.(tsx|jsx)$/.test(f) || f.endsWith(ISLAND_REGISTRY_FILE) || f.endsWith(".gen.ts")) continue;
+    const src = readFileSync(f, "utf8");
+    if (!src.includes("client:")) continue; // cheap pre-filter
+    const { program } = parseSync(f, src);
+    const ast = program as { body: any[] };
+    const imports = importMap(ast);
+    const rel = "./" + relative(appDir, f);
+
+    for (const tag of islandTags(ast)) {
+      const imp = imports.get(tag);
+      if (!imp) {
+        throw new Error(
+          `[june] <${tag} client:*/> in ${rel}: an island must be an IMPORTED component (a named import), not a local definition.`,
+        );
+      }
+      if (imp.kind !== "named") {
+        throw new Error(
+          `[june] <${tag} client:*/> in ${rel}: island imports must be NAMED imports (a named \`{ ${tag} }\` import; default/namespace imports aren't supported as islands).`,
+        );
+      }
+      const name = imp.imported; // = the component's runtime name = the marker the JSX runtime stamps
+      // Re-base a relative specifier from the importing file to appDir (the gen
+      // file lives in appDir); a package specifier is used verbatim.
+      const loaderSpec = imp.spec.startsWith(".")
+        ? "./" + relative(appDir, resolve(dirname(f), imp.spec))
+        : imp.spec;
+
+      const prev = seen.get(name);
+      if (prev && prev !== loaderSpec) {
+        throw new Error(
+          `[june] duplicate island name "${name}" from different modules ("${prev}" and "${loaderSpec}"). Island names must be unique.`,
+        );
+      }
+      if (seen.has(name)) continue; // same island used on several pages — fine
+      seen.set(name, loaderSpec);
+      entries.push(
+        `  ${JSON.stringify(name)}: () => import(${JSON.stringify(loaderSpec)}).then((m) => m.${name}),`,
+      );
     }
   }
 
+  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" +
-    "// Maps each island name to a lazy chunk loader; hydrateIslandsLazy consumes it.\n" +
+    "// AUTO-GENERATED by June — do not edit. Lazy loaders for client:* islands.\n" +
+    "// Maps each island name to a loader that resolves its component; hydrateIslands uses it.\n" +
     "export const ISLAND_LOADERS: Record<string, () => Promise<unknown>> = {\n" +
     body +
     "};\n";