@junejs/server 0.0.14 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "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.14",
-    "@junejs/db": "0.0.14",
+    "@junejs/core": "0.0.16",
+    "@junejs/db": "0.0.16",
     "marked": "^18.0.5",
     "rolldown": "^1.1.0",
     "postcss": "^8.4.0",

package/src/index.ts

@@ -29,6 +29,7 @@ export { loadJuneConfig } from "./config-loader";
 export {
   migrate,
   migrateApp,
+  typesApp,
   classify,
   readMigrations,
   blockedMessage,

package/src/migrate.ts

@@ -112,6 +112,24 @@ export async function migrateApp(
   }
 }
 
+// `june db types`: open the declared db, bring it to head (safe migrations only, so
+// the schema is present even on a fresh checkout), then hand it to the data layer's
+// codegen hook for the type-declaration text. Returns null when there's no db or the
+// data layer doesn't generate types — the CLI owns the messaging. Introspection is
+// read-only; the safe migrate is idempotent (the ledger skips applied ones).
+export async function typesApp(root: string, config: JuneConfig): Promise<string | null> {
+  const factory = config.resources?.db;
+  const emit = config.dataLayer?.emitTypes;
+  if (!factory || !emit) return null;
+  const db = await factory.open();
+  try {
+    await migrate(db, join(root, "db", "migrations"), { allowDestructive: false });
+    return await emit(db);
+  } finally {
+    await db.close();
+  }
+}
+
 // The "this migration was gated" guidance, shared by dev (warns, keeps serving)
 // and `june db migrate` (exits non-zero).
 export function blockedMessage(m: ClassifiedMigration): string {

package/src/pipeline.ts

@@ -124,25 +124,6 @@ function StreamedView({
   return provideLoaderData(data, def.view ? def.view(data, ctx) : null);
 }
 
-// renderToReadableStream does not emit the doctype; prepend it without buffering
-// the React stream (streaming stays incremental).
-function withDoctype(source: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> {
-  const reader = source.getReader();
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      controller.enqueue(new TextEncoder().encode("<!doctype html>\n"));
-    },
-    async pull(controller) {
-      const { done, value } = await reader.read();
-      if (done) controller.close();
-      else controller.enqueue(value);
-    },
-    cancel(reason) {
-      void reader.cancel(reason);
-    },
-  });
-}
-
 // 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
@@ -187,8 +168,9 @@ export function createPipeline(cfg: PipelineConfig): Pipeline {
       React.createElement(Document, { config: docConfigForRender(), metadata, children: wrapped }),
     );
     await stream.allReady; // fully resolved markup (no streamed Suspense fallbacks)
-    const html = "<!doctype html>\n" + (await new Response(stream).text());
-    return new Response(html, { status, headers: htmlHeaders() });
+    // React 19 emits <!DOCTYPE html> itself for an <html> root — don't prepend a
+    // second one.
+    return new Response(stream, { status, headers: htmlHeaders() });
   }
 
   // Route A: the [data-june-root] inner HTML for a soft-nav / live-apply request
@@ -249,8 +231,9 @@ export function createPipeline(cfg: PipelineConfig): Pipeline {
       React.createElement(Document, { config: docConfigForRender(), metadata, children: wrapped }),
       { onError: (e: unknown) => console.error("[june] streaming render error:", e) },
     );
-    // NO allReady — return the live stream (shell first), doctype prepended.
-    return new Response(withDoctype(stream), { status: 200, headers: htmlHeaders() });
+    // NO allReady — return the live stream (shell first). React 19 streams the
+    // <!DOCTYPE html> as the first bytes, so nothing to prepend.
+    return new Response(stream, { status: 200, headers: htmlHeaders() });
   }
 
   function notFoundResponse(target: RenderTarget, pathname: string): Promise<Response> | Response {
@@ -300,6 +283,23 @@ export function createPipeline(cfg: PipelineConfig): Pipeline {
       return notFoundResponse(target, ctx.url.pathname);
     }
 
+    const res = await renderTarget(target, def, data, ctx, chain);
+    // Every projection here is chosen by the Accept header at the SAME url (a full
+    // page, its fragment, its .md and .json all live at the clean path). Without
+    // Vary, a shared/browser cache can hand a soft-nav fragment to a real page
+    // load — which surfaces as a document that starts mid-body. Make Accept part
+    // of the cache key.
+    res.headers.set("vary", "accept");
+    return res;
+  }
+
+  async function renderTarget(
+    target: RenderTarget,
+    def: Resolved["def"],
+    data: unknown,
+    ctx: RouteContext,
+    chain: LayoutComponent[],
+  ): Promise<Response> {
     if (target === "md") return renderMarkdown(def, data, ctx);
     if (target === "json") {
       // Convention: a json() fn customizes; absent → serialize the loader data.