brustjs 0.1.39-alpha → 0.1.41-alpha

package/runtime/index.ts

@@ -372,6 +372,15 @@ export const brust = {
       console.log(`[brust] main: spawning ${workers} worker threads`)
       if (cacheMaxEntries !== undefined) this.configureCache({ maxEntries: cacheMaxEntries })
 
+      // md routes present? (leaf carries `__mdSource`, attached by mdRoutes()).
+      // Checked inline — no md-module import — so md-free apps never load the
+      // markdown pipeline. Gates the md emits below AND in the dev coordinator.
+      const hasMdRoutes = opts.routes.some(
+        (r) =>
+          (r.chain[r.chain.length - 1] as { __mdSource?: unknown } | undefined)?.__mdSource !==
+          undefined,
+      )
+
       // Component CSS pipeline. Build the manifest + capture the loader plugin
       // BEFORE buildIslands and pass it EXPLICITLY below (global Bun.plugin()
       // does NOT reach Bun.build) — otherwise Bun's default loader emits
@@ -439,8 +448,37 @@ export const brust = {
       } else {
         const routesPath = path.join(scanRoot, 'routes.tsx')
         if (existsSync(routesPath)) {
+          // md routes (task 2.8): emit `Md_*.jinja` + `.brust/md-manifest.json`
+          // BEFORE the island scan so islands used only from md content get
+          // chunks. Runs every boot when md routes exist (isJinjaStale below
+          // only watches .tsx — it can't see edited .md files); strict no-op
+          // otherwise. A failure degrades like the staleness re-emit: warn and
+          // keep booting (non-md routes still serve).
+          let mdIslands = new Map<string, string>()
+          if (hasMdRoutes) {
+            try {
+              const { emitMdArtifacts } = await import('./md/emit.ts')
+              ;({ mdIslands } = await emitMdArtifacts({
+                entryFile: routesPath,
+                flatRoutes: opts.routes,
+                outDir: path.resolve(process.cwd(), '.brust/jinja'),
+                withDevClient: dev,
+                manifestDirs: [path.resolve(process.cwd(), '.brust')],
+              }))
+            } catch (err) {
+              console.warn(
+                `[brust] main: md template emit failed (run \`brust build\`): ${(err as Error).message}`,
+              )
+              // The stale templates on disk (if any) still LOAD below — md
+              // routes then silently serve previous content. Make that state
+              // operator-visible instead of indistinguishable from fresh.
+              console.warn(
+                '[brust] main: md routes may be serving previously-built templates (stale content)',
+              )
+            }
+          }
           const { scanIslandChunks, buildIslands: build } = await import('./islands/build.ts')
-          const islandMap = scanIslandChunks(routesPath)
+          const islandMap = scanIslandChunks(routesPath, mdIslands)
           let islandsDir: string | undefined
           if (islandMap.size > 0) {
             const islands = await build(islandMap, { plugins: cssBuildPlugins })
@@ -518,11 +556,17 @@ export const brust = {
       // entirely. A compile failure warns and continues (non-native routes still
       // boot). The heavy emitter is imported lazily so it never enters the hot
       // path (or the prebuilt bundle's live code).
+      // (md templates need no staleness check here: the island block above
+      // already re-emitted them this boot — emitMdArtifacts runs whenever md
+      // routes exist, under the same !prebuilt + routes.tsx guards.)
       if (!prebuilt) {
         const routesPath = path.join(scanRoot, 'routes.tsx')
         if (existsSync(routesPath)) {
           const { isJinjaStale } = await import('./cli/jinja-staleness.ts')
-          if (isJinjaStale(scanRoot, jinjaDir)) {
+          // manifestDir passed explicitly: it is the same `.brust` dir the md
+          // emit above wrote `md-manifest.json` into (manifestDirs) — no
+          // reliance on the dirname(jinjaDir) positional default.
+          if (isJinjaStale(scanRoot, jinjaDir, path.resolve(process.cwd(), '.brust'))) {
             try {
               const { emitNativeTemplates } = await import('./cli/native-routes-emit.ts')
               await emitNativeTemplates({
@@ -633,7 +677,25 @@ export const brust = {
             const routesPath = pathModule.join(scanRoot, 'routes.tsx')
             if (fsModule.existsSync(routesPath)) {
               const { scanIslandChunks, buildIslands } = await import('./islands/build.ts')
-              const islandMap = scanIslandChunks(routesPath)
+              // md routes: re-emit (md content may be what changed) so the
+              // island scan below sees the current md-content islands. Same
+              // warn-and-continue degrade as the boot emit.
+              let mdIslands = new Map<string, string>()
+              if (hasMdRoutes) {
+                try {
+                  const { emitMdArtifacts } = await import('./md/emit.ts')
+                  ;({ mdIslands } = await emitMdArtifacts({
+                    entryFile: routesPath,
+                    flatRoutes: opts.routes,
+                    outDir: pathModule.resolve(process.cwd(), '.brust/jinja'),
+                    withDevClient: true,
+                    manifestDirs: [pathModule.resolve(process.cwd(), '.brust')],
+                  }))
+                } catch (err) {
+                  console.warn(`[brust] dev: md template emit failed: ${(err as Error).message}`)
+                }
+              }
+              const islandMap = scanIslandChunks(routesPath, mdIslands)
               if (islandMap.size > 0) {
                 await buildIslands(islandMap)
               }
@@ -689,6 +751,9 @@ export const brust = {
 
         createWatcher({
           root: scanRoot,
+          // md-free apps must not restart workers on stray .md edits
+          // (README.md etc.) — gate the watcher's 'md' kind (S4).
+          hasMdRoutes,
           onChange: (ev) => {
             void coordinator.handleChange(ev)
           },

package/runtime/islands/bootstrap.ts

@@ -226,6 +226,20 @@ export function isInternalLink(a: HTMLAnchorElement, event: MouseEvent): boolean
   return classifyClick(a, event) === 'navigate'
 }
 
+/** True iff a navigation payload is a FULL HTML document rather than the inner
+ * `<main>` content of a shared shell. A standalone route (one that renders its
+ * own `<html>` with no `<main>`) ships its whole document here — see the no-main
+ * contract in routes.ts navigationBranch. Such a payload CANNOT be swapped into
+ * the current shell's `<main>` (it would nest a second document inside the live
+ * chrome — duplicate topbar/sidebar). The navigator falls back to a full load.
+ *
+ * Inner `<main>` content is the element's children and can never begin with
+ * `<html>`/`<!doctype>`, so this prefix sniff has no false positives. */
+export function isFullDocumentPayload(html: string): boolean {
+  const head = html.trimStart().slice(0, 16).toLowerCase()
+  return head.startsWith('<!doctype') || head.startsWith('<html')
+}
+
 let inFlight: AbortController | null = null
 
 export async function navigate(url: URL, mode: 'push' | 'replace' | 'none'): Promise<void> {
@@ -244,6 +258,15 @@ export async function navigate(url: URL, mode: 'push' | 'replace' | 'none'): Pro
       title: string
       store?: Record<string, Record<string, unknown>>
     }
+    // A standalone (no-<main>) route ships its FULL document here. We can't swap
+    // that into the current shell's <main> without nesting a second document
+    // (duplicate chrome — the classic two-topbars artifact), and the current
+    // document's own <main> existence can't tell us the TARGET has one. Detect
+    // the full-document payload and fall back to the authoritative full load.
+    if (isFullDocumentPayload(html)) {
+      location.href = url.href
+      return
+    }
     const main = document.querySelector('main')
     if (!main) throw new Error('navigation: no <main> element')
     unmountIslandsIn(main as HTMLElement)

package/runtime/islands/build.ts

@@ -41,8 +41,19 @@ export interface BuildIslandsOptions {
  *    marker carries this same id (native: reconcileIslandManifest rewrite;
  *    React: the Component→id registry seeded at worker boot), so there is no
  *    app-unique-name requirement.
+ *
+ * `extraIslands` (task 2.8) merges additional islands the routes-graph scan
+ * cannot see — md-route islands resolved by `emitMdTemplates` (`name →
+ * absolute source path`, the bare-name map it returns). Each is keyed by the
+ * same content-addressed id, so same name + same path dedups against the scan
+ * result; same name + different path yields a distinct id (two chunks, the
+ * shipped same-name parity). A same-id-different-path collision is a hard
+ * error — never silently rebind a chunk id.
  */
-export function scanIslandChunks(routesEntryFile: string): Map<string, string> {
+export function scanIslandChunks(
+  routesEntryFile: string,
+  extraIslands?: Map<string, string>,
+): Map<string, string> {
   const chunks = new Map<string, string>()
   const visited = new Set<string>()
 
@@ -92,6 +103,17 @@ export function scanIslandChunks(routesEntryFile: string): Map<string, string> {
     }
   }
 
+  for (const [name, src] of extraIslands ?? []) {
+    const id = islandChunkBasename(name, src)
+    const existing = chunks.get(id)
+    if (existing !== undefined && existing !== src) {
+      throw new Error(
+        `island chunk id "${id}" resolves to two different sources: ${existing} and ${src}`,
+      )
+    }
+    chunks.set(id, src)
+  }
+
   return chunks
 }
 

package/runtime/islands/native-render.ts

@@ -42,6 +42,11 @@ export interface NativeIslandEntry {
   component: string
   instance: number
   propsPath: string
+  /** Literal props value baked at build time (md pages). When present
+   * (`!== undefined` — `null` and falsy literals are valid), it is used as the
+   * props value and `propsPath` is ignored (md entries carry `propsPath: ''`
+   * since the field is required). */
+  propsLiteral?: unknown
   ssr: boolean
   hydrate: string
   sourcePath: string
@@ -160,9 +165,17 @@ export async function resolveIslandContext(
 ): Promise<Record<string, string>> {
   const out: Record<string, string> = {}
   for (const entry of manifest) {
-    // Empty propsPath = a propless island → `{}`. (pathInto('') returns the whole
-    // context, which is NOT what an absent `props` attr means.)
-    const props = entry.propsPath === '' ? {} : pathInto(data, entry.propsPath)
+    // Build-time literal props (md pages) win over any loader-data path —
+    // guarded with `!== undefined` only, so `0` / `''` / `false` / `null`
+    // literals are honored. Otherwise: empty propsPath = a propless island →
+    // `{}`. (pathInto('') returns the whole context, which is NOT what an
+    // absent `props` attr means.)
+    const props =
+      entry.propsLiteral !== undefined
+        ? entry.propsLiteral
+        : entry.propsPath === ''
+          ? {}
+          : pathInto(data, entry.propsPath)
     // `?? null` handles undefined props; the `?? 'null'` belt-and-braces covers
     // the case where JSON.stringify itself returns undefined (e.g. a function
     // value), so entityEncode never receives undefined. Hoisted ABOVE the ssr