@junejs/server 0.0.27 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.27",
+  "version": "0.0.30",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -30,8 +30,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.27",
-    "@junejs/db": "0.0.27",
+    "@junejs/core": "0.0.29",
+    "@junejs/db": "0.0.28",
     "marked": "^18.0.5",
     "rolldown": "^1.1.0",
     "lightningcss": "^1.27.0"

package/src/app.ts

@@ -23,7 +23,7 @@ import { createPipeline, type ExtraHandler, type LayoutComponent, type Pipeline,
 import { resolveBoundary } from "./segment";
 import { memoizeResources } from "./resources";
 import { findClientEntry, bundleClientToString, CLIENT_SCRIPT_URL } from "./client-bundle";
-import { findGlobalCss, processCssCached, STYLES_URL } from "./css";
+import { findGlobalCss, globalCssUsesTailwind, processCssCached, STYLES_URL } from "./css";
 import { buildModuleCss, registerCssModules, MODULE_STYLES_URL, type ModuleMaps } from "./css-modules";
 
 export type CreateAppOptions = {
@@ -107,6 +107,8 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
     speculationRules: resolveSpeculationRules(speculation ?? undefined),
     speculationDelivery: speculation ? speculation.delivery ?? "inline" : "inline",
     viewTransitions: config.viewTransitions ?? true,
+    // Default the baseline reset OFF when the app uses Tailwind (its Preflight is the reset).
+    cssReset: config.cssReset ?? !globalCssUsesTailwind(appDir),
     clientRouter: config.clientRouter ?? false,
     clientScript: clientEntry ? CLIENT_SCRIPT_URL : null,
     styles: cssEntry ? STYLES_URL : null,

package/src/build.ts

@@ -35,7 +35,7 @@ import { findMiddlewareFile } from "./router";
 import { resolveBoundary } from "./segment";
 import type { ExtraHandler, LayoutComponent, LoadingComponent, ResourceHandler } from "./pipeline";
 import { findClientEntry, bundleClientToFile, CLIENT_SCRIPT_URL } from "./client-bundle";
-import { cssTargets, findGlobalCss, minifyCss, processCss, STYLES_URL } from "./css";
+import { cssTargets, findGlobalCss, globalCssUsesTailwind, minifyCss, processCss, STYLES_URL } from "./css";
 import { buildModuleCss, rolldownCssModulesPlugin, registerCssModules } from "./css-modules";
 
 export type BuildResult = {
@@ -62,6 +62,12 @@ const ROUTE_EXTS = [".tsx", ".jsx", ".ts", ".js"];
 
 const isRouteGroup = (name: string) => /^\(.+\)$/.test(name);
 
+// Bun built-ins (`bun`, `bun:sqlite`, …) exist only at the Bun runtime and must never enter the
+// workerd graph. Marking them external keeps rolldown from constant-folding the `const x = "bun";
+// import(x)` runtime guard (in @junejs/core's cache.ts) and warning UNRESOLVED_IMPORT. Exported so
+// the build keeps externalizing them — see test/build-externals.test.ts.
+export const isBunSpecifier = (id: string): boolean => id === "bun" || id.startsWith("bun:");
+
 function segmentFile(dir: string, base: string): string | undefined {
   return ROUTE_EXTS.map((e) => join(dir, `${base}${e}`)).find(existsSync);
 }
@@ -142,6 +148,8 @@ export async function freezeConfig(appRoot: string): Promise<{
       speculationRules: resolveSpeculationRules(cfg.speculation ?? undefined),
       speculationDelivery: "inline",
       viewTransitions: cfg.viewTransitions ?? true,
+      // Default the baseline reset OFF when the app uses Tailwind (its Preflight is the reset).
+      cssReset: cfg.cssReset ?? !globalCssUsesTailwind(join(appRoot, "app")),
       clientRouter: cfg.clientRouter ?? false,
       clientScript: hasClient ? CLIENT_SCRIPT_URL : null,
       styles: hasCss ? STYLES_URL : null,
@@ -516,6 +524,8 @@ ${adapterEntry.wrap("pipeline")}
     transform: { define: { "process.env.NODE_ENV": JSON.stringify("production") } },
     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).
+      if (isBunSpecifier(id)) return true;
       // Binary assets stay external — wrangler's CompiledWasm/Data rules own them.
       if (/\.(wasm|ttf|otf|woff2?|png|jpe?g|avif|webp)$/.test(id)) return true;
       // config build.external: packages wrangler must bundle itself (its own

package/src/content.ts

@@ -79,7 +79,10 @@ function loadEntry(file: string, slug: string, locale?: string): ContentEntry {
 }
 
 const isMd = (f: string) => f.endsWith(".md") || f.endsWith(".mdx");
-const slugOf = (f: string) => f.replace(/\.(md|mdx)$/, "");
+// Strip the extension, then collapse a directory index file to the directory itself, so it owns the
+// folder's URL (Next.js / GitBook / Fumadocs convention): `a/b/index.md` → `a/b`, `a/b/README.md` →
+// `a/b`, and a root `index`/`README` → "". A folder with an index becomes a page (not a buried child).
+const slugOf = (f: string) => f.replace(/\.(md|mdx)$/, "").replace(/(^|\/)(index|README)$/i, "");
 const byDate = (a: ContentEntry, b: ContentEntry) =>
   String(b.data.date ?? "").localeCompare(String(a.data.date ?? "")) ||
   a.slug.localeCompare(b.slug);
@@ -104,25 +107,44 @@ function isLocaleDir(name: string, known?: readonly string[]): boolean {
   return known ? known.includes(name) : LOCALE_DIR.test(name);
 }
 
+// Recursively collect markdown under `root`; slug = the path relative to `root`, POSIX, no extension
+// (`guides/install.md` → `guides/install`) so routes and the sidebar can nest. `skipTopLocales` skips
+// locale buckets at the TOP level only (scanned separately) — so a top-level `ja-JP/` is a locale, but
+// a nested `guides/` (or `guides/ja-JP/`) is plain content.
+function collectMd(
+  root: string,
+  knownLocales: readonly string[] | undefined,
+  skipTopLocales: boolean,
+  sub = "",
+): { file: string; slug: string }[] {
+  const out: { file: string; slug: string }[] = [];
+  for (const ent of readdirSync(join(root, sub), { withFileTypes: true })) {
+    const rel = sub ? `${sub}/${ent.name}` : ent.name;
+    if (ent.isDirectory()) {
+      if (skipTopLocales && sub === "" && isLocaleDir(ent.name, knownLocales)) continue;
+      out.push(...collectMd(root, knownLocales, skipTopLocales, rel));
+    } else if (isMd(ent.name)) {
+      out.push({ file: join(root, rel), slug: slugOf(rel) });
+    }
+  }
+  return out;
+}
+
 export function scanCollection(dir: string, knownLocales?: readonly string[]): ScannedCollection {
-  const def: ContentEntry[] = [];
+  // Default-locale entries: every .md under `dir` except inside top-level locale buckets. Flat files
+  // keep flat slugs (zero migration); subdirs become slug paths.
+  const def = collectMd(dir, knownLocales, true)
+    .map(({ file, slug }) => loadEntry(file, slug))
+    .sort(byDate);
   const byLocale: Record<string, ContentEntry[]> = {};
   for (const ent of readdirSync(dir, { withFileTypes: true })) {
-    if (ent.isDirectory()) {
-      // Only a configured locale (or, without a list, a BCP-47-shaped name) is a
-      // locale bucket — a stray content/<col>/images/ is NOT a phantom "images".
-      if (!isLocaleDir(ent.name, knownLocales)) continue;
+    if (ent.isDirectory() && isLocaleDir(ent.name, knownLocales)) {
       const locale = ent.name;
-      const sub = join(dir, locale);
-      byLocale[locale] = readdirSync(sub)
-        .filter(isMd)
-        .map((f) => loadEntry(join(sub, f), slugOf(f), locale))
+      byLocale[locale] = collectMd(join(dir, locale), knownLocales, false)
+        .map(({ file, slug }) => loadEntry(file, slug, locale))
         .sort(byDate);
-    } else if (isMd(ent.name)) {
-      def.push(loadEntry(join(dir, ent.name), slugOf(ent.name)));
     }
   }
-  def.sort(byDate);
   return { default: def, byLocale };
 }
 
@@ -158,8 +180,9 @@ export function entry(
   locale?: string,
   opts?: { fallback?: boolean },
 ): ContentEntry | null {
-  // Guard the slug — it comes from the URL.
-  if (!/^[A-Za-z0-9._-]+$/.test(slug)) return null;
+  // Guard the slug — it comes from the URL. Allow "/" so nested content (`guides/install`) resolves,
+  // but reject path traversal and absolute/empty segments so the slug can't escape `dir`.
+  if (!/^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/.test(slug) || slug.includes("..")) return null;
   if (!locale) return probe(dir, slug);
   const variant = probe(join(dir, locale), slug, locale);
   if (variant) return variant;
@@ -207,6 +230,9 @@ export function generateContentModule(
     body += `export const ${CONST}: ContentEntry[] = ${JSON.stringify(def.map(strip), null, 2)};\n`;
     if (Object.keys(byLocale).length === 0) {
       body += `export const ${finder} = (slug: string): ContentEntry | null => ${CONST}.find((p) => p.slug === slug) ?? null;\n`;
+      // Always export the locale lister (a no-op for single-locale collections) so consumers can
+      // import `${d.name}` unconditionally — adding/removing locales never changes the module's shape.
+      body += `export const ${d.name} = (_locale?: string): ContentEntry[] => ${CONST};\n`;
     } else {
       anyLocale = true;
       const map: Record<string, Record<string, unknown>> = {};

package/src/css.ts

@@ -4,15 +4,16 @@
 // (served immutable). Only the asset HREF diverges dev↔built, never the rendered
 // structure — so dev/built parity (the agent surface) holds.
 //
-// Floor: plain CSS, zero deps. Blessed: if global.css opts into Tailwind
-// (`@import "tailwindcss"`), June compiles it via the app's own Tailwind v4
-// (resolved from the app, not bundled into June) — Tailwind auto-detects the
-// content it scans. CSS never touches the agent projections (.md/.json/mcp).
+// Floor: plain CSS, zero deps — Lightning CSS (the SAME Rust engine Tailwind v4 uses) handles
+// nesting/prefix/minify. Blessed: if global.css opts into Tailwind (`@import "tailwindcss"`), June
+// compiles it via the app's own Tailwind v4 ENGINE DIRECTLY — @tailwindcss/node + the @tailwindcss/oxide
+// Rust scanner (the first-party Vite-plugin path, not PostCSS) — resolved from the app, napi-portable
+// across Bun and Node. CSS never touches the agent projections (.md/.json/mcp).
 
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import type { Targets } from "lightningcss"; // type-only — never enters the graph
@@ -31,6 +32,18 @@ export function findGlobalCss(appDir: string): string | null {
 
 const usesTailwind = (css: string) => /@import\s+["']tailwindcss["']|@tailwind\b/.test(css);
 
+// True when app/global.css opts into Tailwind. Sync (build-time, tiny file) so the document config —
+// built synchronously in dev (app.ts) and the build (build.ts) — can default `cssReset` off when
+// Tailwind is present: its Preflight IS the reset, so June need not add its own baseline reset.
+export function globalCssUsesTailwind(appDir: string): boolean {
+  const p = join(appDir, GLOBAL_CSS);
+  try {
+    return existsSync(p) && usesTailwind(readFileSync(p, "utf8"));
+  } catch {
+    return false;
+  }
+}
+
 // Resolve a tool from the APP's node_modules (Tailwind/postcss are the app's
 // deps, not June's). Returns null when absent.
 function resolveFromApp(specifier: string, appDir: string): string | null {
@@ -67,23 +80,40 @@ export async function cssTargets(appDir: string): Promise<Targets> {
   return targets;
 }
 
+// Minimal type surface of the bits of Tailwind v4's engine we drive directly.
+type TwSource = { base: string; pattern: string; negated: boolean };
+type TwCompiler = { build(candidates: string[]): string; sources: TwSource[]; features: number };
+type TwNode = {
+  compile(css: string, opts: { base: string; onDependency: (p: string) => void }): Promise<TwCompiler>;
+  optimize(css: string, opts: { minify: boolean }): { code: string };
+  Features: { Utilities: number };
+};
+type TwOxide = { Scanner: new (o: { sources: TwSource[] }) => { scan(): string[] } };
+
+// Compile Tailwind v4 via its programmatic engine — @tailwindcss/node (compile + Lightning CSS optimize)
+// + @tailwindcss/oxide (the Rust content Scanner) — the SAME direct path the first-party Vite plugin
+// uses, NOT PostCSS. No postcss dependency or extra parse pass; the Oxide scanner (Rust) finds class
+// candidates and the compiler emits only those (tree-shaken). Engine resolved from the APP (its dep,
+// not June's); napi works identically on Bun and Node. Returns null when Tailwind isn't installed.
 async function compileTailwind(
   css: string,
   file: string,
   appDir: string,
   minify: boolean,
 ): Promise<string | null> {
-  const postcssPath = resolveFromApp("postcss", appDir);
-  const tailwindPath = resolveFromApp("@tailwindcss/postcss", appDir);
-  if (!postcssPath || !tailwindPath) return null;
-  const postcss = ((await import(postcssPath)) as { default: (p: unknown[]) => { process(css: string, opts: { from: string }): Promise<{ css: string }> } }).default;
-  const tailwind = ((await import(tailwindPath)) as { default: (opts?: unknown) => unknown }).default;
-  // Tailwind v4 only emits the classes the project actually uses (content
-  // detection = tree-shaking). For build we ALSO minify via its Lightning CSS
-  // optimizer; dev stays unminified for readability.
-  const plugin = minify ? tailwind({ optimize: { minify: true } }) : tailwind();
-  const result = await postcss([plugin]).process(css, { from: file });
-  return result.css;
+  const nodePath = resolveFromApp("@tailwindcss/node", appDir);
+  const oxidePath = resolveFromApp("@tailwindcss/oxide", appDir);
+  if (!nodePath || !oxidePath) return null;
+  const { compile, optimize, Features } = (await import(nodePath)) as TwNode;
+  const { Scanner } = (await import(oxidePath)) as TwOxide;
+  const base = dirname(file); // the CSS's dir — resolves @import / @source / auto-detection
+  const compiler = await compile(css, { base, onDependency: () => {} });
+  // Scan the project (app root) plus whatever the compiler declares; Oxide skips node_modules/.gitignore.
+  const sources: TwSource[] = [{ base: dirname(appDir), pattern: "**/*", negated: false }, ...compiler.sources];
+  const candidates = compiler.features & Features.Utilities ? new Scanner({ sources }).scan() : [];
+  const out = compiler.build(candidates);
+  // Lightning CSS optimize for build (minify + prefix/lower); dev stays readable.
+  return minify ? optimize(out, { minify: true }).code : out;
 }
 
 // Dev-only memo. The dev server re-fetches /global.css on EVERY navigation, but
@@ -138,7 +168,7 @@ export async function processCss(
     });
     if (compiled !== null) return compiled; // Tailwind already minified when asked
     console.warn(
-      "[june] global.css uses Tailwind but @tailwindcss/postcss isn't installed — serving raw CSS.",
+      "[june] global.css uses Tailwind but @tailwindcss/node + @tailwindcss/oxide aren't installed — serving raw CSS.",
     );
   }
   // Plain CSS (or the Tailwind fallback): minify + autoprefix/lower for the app's

package/src/dev-reload.ts

@@ -38,10 +38,13 @@ const RELOAD_JS = `// june dev live-reload: reconnect-after-drop → reload; "cs
     es.addEventListener("open", () => {
       if (dropped) {
         // push-HMR: morph the freshly-restarted page in place (state survives);
-        // hard-reload only if there's no morph hook or it can't apply.
+        // hard-reload only if there's no morph hook or it can't apply. On a
+        // successful morph also swap the stylesheet: a .tsx edit can change the
+        // class set, so the Tailwind-compiled /_june/global.css must refresh too
+        // (cache-busted) — otherwise new utility classes render unstyled.
         const hot = window.__juneLiveReload;
         (hot ? hot() : Promise.resolve(false)).then(
-          (ok) => { if (!ok) location.reload(); },
+          (ok) => { if (ok) swapCss(); else location.reload(); },
           () => location.reload(),
         );
       }