@junejs/server 0.0.6 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@junejs/core": "0.0.6",
+    "@junejs/core": "0.0.8",
     "marked": "^18.0.5",
     "rolldown": "^1.1.0"
   },

package/src/build.ts

@@ -341,15 +341,24 @@ ${chains.join("\n")}
     const pkg = existsSync(pkgPath)
       ? (JSON.parse(await Bun.file(pkgPath).text()) as { name?: string })
       : {};
+    const deployCfg = (await loadJuneConfig(appRoot)).deploy;
     await writeFile(
       join(outDir, "wrangler.jsonc"),
       JSON.stringify(
         {
-          name: (pkg.name ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase(),
+          name:
+            deployCfg?.name ??
+            (pkg.name ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase(),
           main: "./worker.js",
           compatibility_date: "2025-01-01",
           compatibility_flags: ["nodejs_compat"],
           ...(hasAssets ? { assets: { directory: "./assets" } } : {}),
+          // config deploy.domain → a Workers custom domain; without it the
+          // generated file regenerating on every build would silently drop a
+          // hand-attached domain.
+          ...(deployCfg?.domain
+            ? { routes: [{ pattern: deployCfg.domain, custom_domain: true }] }
+            : {}),
         },
         null,
         2,

package/src/db.ts

@@ -3,15 +3,28 @@
 // by the host, injected onto RouteContext as `ctx.db`. The framework depends on
 // the JuneDb contract; these adapters (and Juno on top) are swappable.
 
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
 import type { DbFactory, JuneDb, RunResult } from "@junejs/core/resources";
 
 import { host } from "./host";
 
-// Local SQLite — the zero-config dev default (embedded file or :memory:). Built
-// on the demoted host.openDb primitive (the sync bun:/node: driver wrapped async).
+// Local SQLite — the zero-config dev default. A persistent FILE, not :memory:,
+// on purpose: `june dev` restarts the process on every save (the watch
+// supervisor), so an in-memory default would evaporate your dev data at each
+// edit. A file also makes the dev db inspectable with the sqlite3 every
+// machine already has (`sqlite3 .june/dev.sqlite`). Pass ":memory:" explicitly
+// for ephemerality.
 export function sqlite(opts: { path?: string } = {}): DbFactory {
-  const path = opts.path ?? ":memory:";
-  return { kind: "sqlite", open: () => host.openDb(path) };
+  const path = opts.path ?? ".june/dev.sqlite";
+  return {
+    kind: "sqlite",
+    open: () => {
+      if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+      return host.openDb(path);
+    },
+  };
 }
 
 // --- D1 (Cloudflare) — the third openDb impl (rebuild-plan Phase 5) ----------

package/src/dev-reload.ts

@@ -37,11 +37,24 @@ const RELOAD_JS = `// june dev live-reload: reconnect-after-drop → location.re
 `;
 
 function devEvents(): Response {
+  let heartbeat: ReturnType<typeof setInterval> | undefined;
   const stream = new ReadableStream<Uint8Array>({
     start(controller) {
-      // One greeting so the browser fires `open`; then the socket just stays
-      // up until this process dies — the restart is the next event.
-      controller.enqueue(new TextEncoder().encode("retry: 300\n\ndata: connected\n\n"));
+      // One greeting so the browser fires `open`, then a comment heartbeat:
+      // a silent stream gets culled by idle timeouts (hosts, proxies), and a
+      // culled stream reads as a restart to the client — which reloads.
+      const enc = new TextEncoder();
+      controller.enqueue(enc.encode("retry: 300\n\ndata: connected\n\n"));
+      heartbeat = setInterval(() => {
+        try {
+          controller.enqueue(enc.encode(":hb\n\n"));
+        } catch {
+          clearInterval(heartbeat);
+        }
+      }, 20_000);
+    },
+    cancel() {
+      clearInterval(heartbeat);
     },
   });
   return new Response(stream, {

package/src/host.ts

@@ -108,7 +108,10 @@ function bunHost(): JuneHost {
   return {
     name: "bun",
     serve(handler, opts) {
-      const server = Bun.serve({ port: opts.port, fetch: handler });
+      // idleTimeout 0: Bun's 10s default kills quiet long-lived responses —
+      // the dev live-reload SSE most visibly (the browser then reconnects,
+      // reads it as a server restart, and reloads the page every 10s).
+      const server = Bun.serve({ port: opts.port, fetch: handler, idleTimeout: 0 });
       return { port: server.port ?? opts.port, stop: (force) => void server.stop(force) };
     },
     spawnModule(entry, args, opts) {

package/src/pipeline.ts

@@ -95,6 +95,23 @@ function text(body: string, contentType: string, init?: ResponseInit) {
   return new Response(body, { ...init, headers });
 }
 
+// The default favicon: the site name's first character in a rounded square —
+// a plain SVG string, so it needs no fonts, no rasterizer, and works for CJK
+// names as readily as latin ones. Served at /favicon.svg AND /favicon.ico
+// (browsers respect the svg content-type), so no June app 404s its icon.
+function letterFavicon(siteName: string | undefined): Response {
+  const first = (siteName ?? "").trim().charAt(0) || "•";
+  const letter = first.toUpperCase().replace(/[<>&"']/g, "");
+  return text(
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">` +
+      `<rect width="64" height="64" rx="12" fill="#1d1d1f"/>` +
+      `<text x="32" y="32" dy=".36em" text-anchor="middle" font-family="ui-sans-serif, system-ui, sans-serif" font-size="34" font-weight="600" fill="#fbfbf8">${letter || "•"}</text>` +
+      `</svg>\n`,
+    "image/svg+xml",
+    { headers: { "cache-control": "public, max-age=86400" } },
+  );
+}
+
 export function createPipeline(cfg: PipelineConfig): Pipeline {
   const { docConfig, agent } = cfg;
   const NotFound = cfg.notFoundComponent ?? DefaultNotFound;
@@ -219,6 +236,15 @@ export function createPipeline(cfg: PipelineConfig): Pipeline {
         if (out) return out;
       }
 
+      // --- default favicon (after extra so an app can override it) ----------
+      if (
+        request.method === "GET" &&
+        !docConfig.site.icon &&
+        (url.pathname === "/favicon.svg" || url.pathname === "/favicon.ico")
+      ) {
+        return letterFavicon(docConfig.site.name);
+      }
+
       // --- routes ----------------------------------------------------------
       const { target, pathname, speculative } = negotiate(url, request);
       const resolved = await cfg.resolve(pathname);

package/src/router.ts

@@ -67,8 +67,12 @@ function isSpecialFile(file: string) {
 
 const isRouteGroup = (name: string) => /^\(.+\)$/.test(name);
 const isParamDir = (name: string) => /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
+// [[slug]] / [[...slug]] — match like their required forms, and ALSO match the
+// segment being absent (the param is then simply missing from ctx.params).
+const isOptionalDir = (name: string) => /^\[\[([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
+const isOptionalCatchAllDir = (name: string) => /^\[\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]\]$/.test(name);
 const isCatchAllDir = (name: string) => /^\[\.\.\.([A-Za-z_][A-Za-z0-9_]*)\]$/.test(name);
-const paramName = (name: string) => name.replace(/^\[(\.\.\.)?|\]$/g, "");
+const paramName = (name: string) => name.replace(/^\[+(\.\.\.)?|\]+$/g, "");
 
 type DirEntry = { name: string; dir: boolean };
 
@@ -164,7 +168,16 @@ export async function matchRouteTree(
       if (hit) return hit;
     }
 
-    if (rest.length === 0) return null;
+    if (rest.length === 0) {
+      // Optional segments match ABSENCE too: descend without consuming and
+      // without setting the param.
+      for (const e of entries) {
+        if (!e.dir || !(isOptionalDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
+        const hit = await descend(join(dir, e.name), [], params, segments);
+        if (hit) return hit;
+      }
+      return null;
+    }
     const [head, ...tail] = rest as [string, ...string[]];
 
     // 1) exact static dir
@@ -173,9 +186,9 @@ export async function matchRouteTree(
       const hit = await descend(join(dir, head), tail, params, segments);
       if (hit) return hit;
     }
-    // 2) [param] dirs
+    // 2) [param] and [[param]] dirs consume one segment
     for (const e of entries) {
-      if (!e.dir || !isParamDir(e.name)) continue;
+      if (!e.dir || !(isParamDir(e.name) || isOptionalDir(e.name))) continue;
       const hit = await descend(
         join(dir, e.name),
         tail,
@@ -184,9 +197,9 @@ export async function matchRouteTree(
       );
       if (hit) return hit;
     }
-    // 3) [...catchAll] dirs consume everything remaining
+    // 3) [...catchAll] and [[...catchAll]] dirs consume everything remaining
     for (const e of entries) {
-      if (!e.dir || !isCatchAllDir(e.name)) continue;
+      if (!e.dir || !(isCatchAllDir(e.name) || isOptionalCatchAllDir(e.name))) continue;
       const hit = await descend(
         join(dir, e.name),
         [],

package/src/worker.ts

@@ -41,26 +41,45 @@ export type WorkerManifest = {
 
 type Compiled = { regex: RegExp; names: string[]; def: BrandedRoute; pattern: string };
 
-// "/posts/[slug]" | "/docs/[...path]" → matcher
+// "/posts/[slug]" | "/docs/[...path]" | "/notes/[[tag]]" → matcher. Optional
+// segments ([[x]], [[...x]]) wrap slash + capture together so absence matches;
+// a pattern of ONLY optional segments must also match the bare "/".
 function compilePattern(pattern: string): { regex: RegExp; names: string[] } {
   const names: string[] = [];
-  const source = pattern
-    .split("/")
-    .map((seg) => {
-      const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
-      if (ca) {
-        names.push(ca[1]!);
-        return "(.+)";
-      }
-      const p = seg.match(/^\[(\w+)\]$/);
-      if (p) {
-        names.push(p[1]!);
-        return "([^/]+)";
-      }
-      return seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
-    })
-    .join("/");
-  return { regex: new RegExp(`^${source}$`), names };
+  let source = "";
+  let allOptional = true;
+  for (const seg of pattern.split("/").filter(Boolean)) {
+    const oca = seg.match(/^\[\[\.\.\.(\w+)\]\]$/);
+    if (oca) {
+      names.push(oca[1]!);
+      source += "(?:/(.+))?";
+      continue;
+    }
+    const ca = seg.match(/^\[\.\.\.(\w+)\]$/);
+    if (ca) {
+      names.push(ca[1]!);
+      source += "/(.+)";
+      allOptional = false;
+      continue;
+    }
+    const op = seg.match(/^\[\[(\w+)\]\]$/);
+    if (op) {
+      names.push(op[1]!);
+      source += "(?:/([^/]+))?";
+      continue;
+    }
+    const p = seg.match(/^\[(\w+)\]$/);
+    if (p) {
+      names.push(p[1]!);
+      source += "/([^/]+)";
+      allOptional = false;
+      continue;
+    }
+    source += "/" + seg.replace(/[.*+?^${}()|\\]/g, "\\$&");
+    allOptional = false;
+  }
+  if (source === "") return { regex: /^\/$/, names };
+  return { regex: new RegExp(allOptional ? `^(?:${source}|/)$` : `^${source}$`), names };
 }
 
 export function createWorker(manifest: WorkerManifest): { fetch(request: Request): Promise<Response> } {
@@ -91,7 +110,14 @@ export function createWorker(manifest: WorkerManifest): { fetch(request: Request
       for (const d of dynamic) {
         const m = pathname.match(d.regex);
         if (m) {
-          const params = Object.fromEntries(d.names.map((n, i) => [n, decodeURIComponent(m[i + 1]!)]));
+          // Optional segments leave their capture undefined — the param is
+          // then absent, matching the dev matcher's semantics.
+          const params = Object.fromEntries(
+            d.names.flatMap((n, i) => {
+              const v = m[i + 1];
+              return v === undefined ? [] : [[n, decodeURIComponent(v)]];
+            }),
+          );
           return { def: d.def, params, chain: chainFor(d.pattern) };
         }
       }