brustjs 0.1.11-alpha → 0.1.13-alpha

package/runtime/routes.ts

@@ -17,7 +17,9 @@ import {
   resolveComponentContext,
 } from './islands/native-render.ts'
 import type { IslandCache } from './islands/native-render.ts'
-import type { ActionDef } from './actions.ts'
+import type { EndpointDef } from './define-actions.ts'
+import { isRespondSentinel, makeRespond } from './define-actions.ts'
+import { validate } from './standard-schema.ts'
 
 // Sub-project J — island ISR cache, backed by the Rust-side store (shared across
 // the worker pool) via NAPI. napi-rs maps snake→camel: island_cache_get →
@@ -334,7 +336,7 @@ function validateRoute(r: Route, basePath: string): void {
 
 /** Walk the nested route tree, emitting one FlatRoute per leaf or index node.
  * Composes paths, middleware, errorBoundary, and cache per the rules in
- * the design spec (§3). */
+ * the design spec (S3). */
 export function flattenRoutes(routes: Route[]): FlatRoute[] {
   const out: FlatRoute[] = []
   walkRoutes(routes, [], '', out)
@@ -441,6 +443,8 @@ export type RouteCall =
       /** Base64-encoded binary body — present for multipart/form-data.
        * JS decodes via Buffer.from(s, 'base64') before parsing. */
       body_b64?: string
+      /** Path params extracted by the Rust router (e.g. {id} → "abc"). */
+      params?: Record<string, string>
       req: BrustRequest
     }
   | {
@@ -475,7 +479,7 @@ export interface MakeRendererOptions {
    * Both the main process and each worker call `brust.scanActions(...)` at
    * module top-level and pass the resulting array here — the wire keys (ids)
    * and the handler functions (fn) must agree across both ends. */
-  actions?: ActionDef[]
+  actions?: EndpointDef[]
   /** MCP server instance — built once per worker at module top-level. */
   mcp?: import('./mcp/server.ts').McpServer
 }
@@ -491,8 +495,10 @@ export function makeRenderer(
   routes.forEach((r, i) => {
     byRouteId.set(i, r)
   })
-  const byActionId = new Map<string, ActionDef>()
-  for (const a of opts.actions ?? []) byActionId.set(a.id, a)
+  const byActionId = new Map<string, EndpointDef>()
+  opts.actions?.forEach((e, i) => {
+    byActionId.set(String(i), e)
+  })
 
   // napi shim for the chunk channel. The sabBytes arg is ignored by the
   // native fn (Rust reads from the pre-registered BufPtr) — the call sites
@@ -587,7 +593,7 @@ export function makeRenderer(
       // path above and works for native routes. But middleware that calls
       // next() then mutates status/headers (e.g. adds Cache-Control) is NOT
       // forwarded; napi_render_jinja hardcodes status: 200 and empty headers.
-      // Spec §4 doesn't define post-next() mutation semantics for native;
+      // Spec S4 doesn't define post-next() mutation semantics for native;
       // deferred to v2.x. If your middleware needs to mutate, use a React
       // route for now.
       if (flat.nativeTemplate !== undefined) {
@@ -726,7 +732,7 @@ export function makeRenderer(
     if (call.kind === 'action') {
       // FAST LANE: pack the framed response into the SAB and return its length.
       // Rust reads it directly after the Promise settles — no chunk channel.
-      const resp = await actionBranchToResponse(call, byActionId)
+      const resp = await dispatchAction(call, byActionId)
       return packSingleChunkResponse(view, encoder, resp)
     }
     if (call.kind === 'mcp') {
@@ -878,13 +884,24 @@ async function navigationBranch(
   }
 
   try {
-    const element = await buildRenderElement(call as any, flat, getWorkerId)
-    if (!element) throw new Error('render setup failed')
-    // Use renderToPipeableStream + onAllReady so pages with <Suspense> emit
-    // their RESOLVED markup, not the fallback. renderToString would only
-    // capture the shell — navigating SPA-style to a Suspense-using route
-    // would otherwise ship "loading…" and never recover.
-    const fullHtml = await renderToAwaitedString(element)
+    // Native (jinja) routes have no React tree, so we can't renderToString them.
+    // Render the template Rust-side (same path as a full document load) and use
+    // its HTML; React routes keep the renderToAwaitedString path below. Without
+    // this branch, a SPA navigation to a native route React-renders a component
+    // whose loader fields arrive undefined → throws → 500 → full-reload fallback
+    // on every internal link.
+    let fullHtml: string
+    if (flat.nativeTemplate !== undefined) {
+      fullHtml = await renderNativeRouteToHtml(call, flat, view, encoder, workerId)
+    } else {
+      const element = await buildRenderElement(call as any, flat, getWorkerId)
+      if (!element) throw new Error('render setup failed')
+      // Use renderToPipeableStream + onAllReady so pages with <Suspense> emit
+      // their RESOLVED markup, not the fallback. renderToString would only
+      // capture the shell — navigating SPA-style to a Suspense-using route
+      // would otherwise ship "loading…" and never recover.
+      fullHtml = await renderToAwaitedString(element)
+    }
 
     // Extract <main> inner content. If the page didn't render a <main>,
     // ship the full HTML — the client's no-main check will fire its
@@ -919,6 +936,65 @@ async function navigationBranch(
   }
 }
 
+/** Render a native (jinja) route to its full HTML document for a SPA navigation.
+ *
+ * Mirrors the render-branch native path: run the leaf loader, merge island /
+ * component manifest context, then call the SYNC `napiRenderJinja`, which writes
+ * a framed `[meta_len u16 BE][meta JSON][body]` response into the SAB and returns
+ * its length. Here — unlike the render branch, which returns that length so Rust
+ * streams the SAB straight to the socket — we read the body back out of the SAB
+ * and hand it to navigationBranch, which extracts `<main>` + `<title>` from it.
+ *
+ * Throws on loader failure / oversized data / non-200 render; navigationBranch's
+ * catch turns that into a 500 (→ client full-reload fallback). */
+async function renderNativeRouteToHtml(
+  call: Extract<RouteCall, { kind: 'navigation' }>,
+  flat: FlatRoute,
+  view: Uint8Array,
+  encoder: TextEncoder,
+  workerId: bigint,
+): Promise<string> {
+  const templateName = flat.nativeTemplate as string
+  const leaf = flat.chain[flat.chain.length - 1]
+
+  let data: unknown = {}
+  if (leaf.loader) {
+    data = await leaf.loader({ params: call.params, path: call.path, req: call.req } as any)
+  }
+
+  let ctx = (data ?? {}) as Record<string, unknown>
+  const manifest = loadIslandManifest(templateName)
+  const compManifest = loadComponentManifest(templateName)
+  if ((manifest && manifest.length > 0) || (compManifest && compManifest.length > 0)) {
+    const [islandExtra, componentExtra] = await Promise.all([
+      manifest && manifest.length > 0
+        ? resolveIslandContext(manifest, ctx, islandCache)
+        : Promise.resolve({} as Record<string, string>),
+      compManifest && compManifest.length > 0
+        ? resolveComponentContext(compManifest, ctx, templateName, undefined, islandCache)
+        : Promise.resolve({} as Record<string, string>),
+    ])
+    ctx = { ...ctx, ...islandExtra, ...componentExtra }
+  }
+
+  const bytes = encoder.encode(JSON.stringify(ctx))
+  if (bytes.length > view.length) throw new Error('native loader data too large for SAB')
+  view.set(bytes, 0)
+
+  const len = (native as any).napiRenderJinja(
+    Number(workerId),
+    bytes.length,
+    templateName,
+  ) as number
+
+  // Parse the framed response the SAB now holds: [meta_len u16 BE][meta][body].
+  const metaLen = (view[0] << 8) | view[1]
+  const decoder = new TextDecoder()
+  const meta = JSON.parse(decoder.decode(view.subarray(2, 2 + metaLen))) as { status?: number }
+  if (meta.status !== 200) throw new Error(`native render returned status ${meta.status}`)
+  return decoder.decode(view.subarray(2 + metaLen, len))
+}
+
 /** Build the React element for a render or navigation call: runs loaders
  * top-down, builds the element bottom-up wrapping in OutletContext.Provider
  * so nested routes receive the deeper element via <Outlet />. The caller
@@ -1090,82 +1166,131 @@ interface BranchResponse {
   headers?: Record<string, string>
 }
 
-async function actionBranchToResponse(
+async function decodeActionBody(
   call: Extract<RouteCall, { kind: 'action' }>,
-  byId: Map<string, ActionDef>,
+): Promise<{ ok: true; value: unknown } | { ok: false; status: number; body: string }> {
+  const ct = (call.content_type ?? '').toLowerCase()
+  // urlencoded → flat object of strings
+  if (ct.startsWith('application/x-www-form-urlencoded')) {
+    return { ok: true, value: Object.fromEntries(new URLSearchParams(call.body_text ?? '')) }
+  }
+  // multipart → object of strings + File entries (via Bun's Response.formData)
+  if (ct.startsWith('multipart/form-data')) {
+    try {
+      const bytes = Buffer.from(call.body_b64 ?? '', 'base64')
+      const fd = await new Response(bytes, {
+        headers: { 'content-type': call.content_type },
+      }).formData()
+      return { ok: true, value: Object.fromEntries(fd.entries()) }
+    } catch (err) {
+      return {
+        ok: false,
+        status: 400,
+        body: JSON.stringify({
+          error: { message: `invalid multipart body: ${(err as Error).message}` },
+        }),
+      }
+    }
+  }
+  // default: JSON
+  try {
+    return {
+      ok: true,
+      value:
+        call.body_text != null && call.body_text !== '' ? JSON.parse(call.body_text) : undefined,
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      status: 400,
+      body: JSON.stringify({
+        error: { message: `invalid JSON body: ${(err as Error).message}` },
+      }),
+    }
+  }
+}
+
+export async function dispatchAction(
+  call: Extract<RouteCall, { kind: 'action' }>,
+  byId: Map<string, EndpointDef>,
 ): Promise<BranchResponse> {
   const def = byId.get(call.action_id)
   if (!def) {
-    // Rust already 404s when the id isn't registered, but a race during
-    // hot-reload (or a desynced worker) could land here. Log and 404.
-    // Action clients always expect JSON, so ship a JSON envelope even
-    // when Rust would have 404'd first.
-    console.error(`[brust] unknown action_id=${call.action_id}`)
     return {
       status: 404,
       body: '{"error":{"message":"unknown action"}}',
       contentType: 'application/json; charset=utf-8',
     }
   }
-  // Populate req.signal with the permanently-unaborted sentinel. Action
-  // handlers reading req.signal.aborted always see false; the SSE branch
-  // is where real disconnect lives.
   call.req.signal = NEVER_ABORTS
 
-  // Decode the body into the args array that will be spread into the handler.
-  // Three paths: multipart (body_b64), form-urlencoded (body_text), or JSON (body_text).
-  // Body decode happens BEFORE middleware so a malformed body 400s without running
-  // any user code.
-  let args: unknown[]
-  try {
-    if (call.body_b64 !== undefined) {
-      // Multipart path — base64 → bytes → Web Request.formData()
-      const bytes = Buffer.from(call.body_b64, 'base64')
-      const synthReq = new Request('http://x', {
-        method: 'POST',
-        headers: { 'Content-Type': call.content_type },
-        body: bytes,
-      })
-      const fd = await synthReq.formData()
-      args = [fd]
-    } else if (call.content_type.toLowerCase().startsWith('application/x-www-form-urlencoded')) {
-      // Form-urlencoded path — URLSearchParams → FormData
-      const params = new URLSearchParams(call.body_text ?? '')
-      const fd = new FormData()
-      for (const [k, v] of params) fd.append(k, v)
-      args = [fd]
-    } else {
-      // JSON path (default — empty or application/json content type).
-      const decoded = JSON.parse(call.body_text ?? '') as unknown
-      if (!Array.isArray(decoded)) {
-        return {
-          status: 400,
-          body: '{"error":{"message":"args must be a JSON array"}}',
-          contentType: 'application/json; charset=utf-8',
-        }
+  // Body decode — dispatch by content-type (JSON / urlencoded / multipart).
+  let rawBody: unknown
+  if (def.method !== 'GET' && def.method !== 'HEAD') {
+    const decoded = await decodeActionBody(call)
+    if (!decoded.ok) {
+      return {
+        status: decoded.status,
+        body: decoded.body,
+        contentType: 'application/json; charset=utf-8',
       }
-      args = decoded
     }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err)
+    rawBody = decoded.value
+  }
+
+  const bodyCheck = await validate(def.body, rawBody)
+  if (!bodyCheck.ok) {
     return {
-      status: 400,
-      body: JSON.stringify({ error: { message: `invalid request body: ${msg}` } }),
+      status: 422,
+      body: JSON.stringify({
+        error: { message: 'body validation failed', issues: bodyCheck.issues },
+      }),
+      contentType: 'application/json; charset=utf-8',
+    }
+  }
+  // `req.search` already arrives as a parsed key→value object from the Rust
+  // envelope (BrustRequest.search: Record<string, string>) — use it directly
+  // as the query object rather than re-parsing it as a string.
+  const queryObj = call.req.search ?? {}
+  const queryCheck = await validate(def.query, queryObj)
+  if (!queryCheck.ok) {
+    return {
+      status: 422,
+      body: JSON.stringify({
+        error: { message: 'query validation failed', issues: queryCheck.issues },
+      }),
       contentType: 'application/json; charset=utf-8',
     }
   }
 
+  const ctx = {
+    req: call.req,
+    body: bodyCheck.value,
+    params: call.params ?? {},
+    query: queryCheck.value,
+    headers: call.req.headers ?? {},
+    respond: makeRespond(),
+  }
+
   const terminal = async (): Promise<RouteResponse> => {
     try {
-      const result = await def.fn(call.req, ...args)
+      const result = await def.handler(ctx as never)
+      if (isRespondSentinel(result)) {
+        return {
+          status: result.status,
+          body: result.body === undefined ? '' : JSON.stringify(result.body),
+          contentType: 'application/json; charset=utf-8',
+          headers: result.headers,
+        }
+      }
       return {
         status: 200,
         body: result === undefined ? '' : JSON.stringify(result),
         contentType: 'application/json; charset=utf-8',
       }
     } catch (err) {
-      console.error(`[brust] action ${def.id} threw:`, err)
       const e = err instanceof Error ? err : new Error(String(err))
+      console.error(`[brust] action ${def.method} ${def.path} threw:`, err)
       return {
         status: 500,
         body: JSON.stringify({ error: { message: e.message, name: e.name } }),
@@ -1175,15 +1300,14 @@ async function actionBranchToResponse(
   }
 
   const chain = composeChain(call.req, def.middleware, terminal)
-
   let response: RouteResponse
   try {
     response = await chain()
   } catch (err) {
-    console.error(`[brust] action middleware uncaught:`, err)
+    console.error('[brust] action middleware uncaught:', err)
     response = {
       status: 500,
-      body: JSON.stringify({ error: { message: 'internal error' } }),
+      body: '{"error":{"message":"internal error"}}',
       contentType: 'application/json; charset=utf-8',
     }
   }

package/runtime/standard-schema.ts

@@ -0,0 +1,29 @@
+/** Minimal Standard Schema v1 surface — https://standardschema.dev */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly '~standard': {
+    readonly version: 1
+    readonly vendor: string
+    readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>
+  }
+}
+type StandardResult<Output> =
+  | { readonly value: Output; readonly issues?: undefined }
+  | { readonly issues: ReadonlyArray<StandardIssue> }
+export interface StandardIssue {
+  readonly message: string
+  readonly path?: ReadonlyArray<PropertyKey | { key: PropertyKey }>
+}
+export type InferOutput<S> = S extends StandardSchemaV1<unknown, infer O> ? O : never
+export type ValidateOk<T> = { ok: true; value: T }
+export type ValidateErr = { ok: false; issues: ReadonlyArray<StandardIssue> }
+
+export async function validate<S extends StandardSchemaV1 | undefined>(
+  schema: S,
+  input: unknown,
+): Promise<ValidateOk<S extends StandardSchemaV1 ? InferOutput<S> : unknown> | ValidateErr> {
+  if (schema === undefined) return { ok: true, value: input as never }
+  let result = schema['~standard'].validate(input)
+  if (result instanceof Promise) result = await result
+  if (result.issues) return { ok: false, issues: result.issues }
+  return { ok: true, value: result.value as never }
+}

package/runtime/treaty.ts

@@ -0,0 +1,156 @@
+import type { ActionsBuilder } from './define-actions.ts'
+
+const METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head'])
+
+export interface TreatyResponse<Data = unknown, Err = unknown> {
+  data: Data | null
+  error: { status: number; value: Err } | null
+  status: number
+  headers: Record<string, string>
+  response: Response | null
+}
+export interface ClientOptions {
+  prefix?: string
+  headers?: Record<string, string> | (() => Record<string, string>)
+  fetch?: typeof fetch
+}
+
+type FirstSegment<S extends string> = S extends `/${infer Rest}`
+  ? FirstSegment<Rest>
+  : S extends `${infer T}/${infer _U}`
+    ? T
+    : S
+
+export type PermissiveProxy = {
+  (arg?: any): PermissiveProxy
+  [key: string]: PermissiveProxy
+} & {
+  get: (options?: any) => Promise<TreatyResponse<any, any>>
+  post: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>
+  put: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>
+  patch: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>
+  delete: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>
+  head: (options?: any) => Promise<TreatyResponse<any, any>>
+}
+
+export type Treaty<App> =
+  App extends ActionsBuilder<infer Acc>
+    ? { [K in FirstSegment<keyof Acc & string>]: PermissiveProxy } & PermissiveProxy
+    : PermissiveProxy
+
+function resolvePrefix(opts?: ClientOptions): string {
+  if (opts?.prefix) return opts.prefix
+  const g = (globalThis as { __BRUST_ACTION_PREFIX__?: string }).__BRUST_ACTION_PREFIX__
+  return g ?? '/_brust/action'
+}
+
+/** Build a treaty proxy. Static segments accumulate as a path; a function call
+ * with an object fills the next {param}(s) positionally (in insertion order); a
+ * terminal method key (.get/.post/…) performs the request. URL is composed from
+ * the literal accumulated segments — never from any inferred type. */
+export function client<App = unknown>(opts?: ClientOptions): Treaty<App> {
+  const prefix = resolvePrefix(opts)
+  const doFetch = opts?.fetch ?? fetch
+  function make(segments: string[]): any {
+    return new Proxy(() => {}, {
+      get(_t, key: string) {
+        if (METHODS.has(key)) {
+          return async (arg1?: unknown, arg2?: unknown): Promise<TreatyResponse> => {
+            const isBodyless = key === 'get' || key === 'head'
+            const options = (isBodyless ? arg1 : arg2) as
+              | { query?: Record<string, string>; headers?: Record<string, string> }
+              | undefined
+            const body = isBodyless ? undefined : arg1
+            let url = prefix + '/' + segments.join('/')
+            if (options?.query) {
+              const qs = new URLSearchParams(options.query as Record<string, string>).toString()
+              if (qs) url += '?' + qs
+            }
+            const baseHeaders =
+              typeof opts?.headers === 'function' ? opts.headers() : (opts?.headers ?? {})
+            const init: RequestInit = {
+              method: key.toUpperCase(),
+              headers: { ...baseHeaders, ...(options?.headers ?? {}) },
+            }
+            if (!isBodyless && body !== undefined) {
+              if (hasFilePart(body)) {
+                init.body = toFormData(body)
+                // Let fetch set the multipart boundary; a stale content-type
+                // (e.g. from caller headers) would break it.
+                delete (init.headers as Record<string, string>)['content-type']
+              } else {
+                init.body = JSON.stringify(body)
+                ;(init.headers as Record<string, string>)['content-type'] = 'application/json'
+              }
+            }
+            try {
+              const res = await doFetch(url, init)
+              const text = await res.text()
+              const parsed = text ? safeJson(text) : undefined
+              const headers: Record<string, string> = {}
+              res.headers.forEach((v, k) => {
+                headers[k] = v
+              })
+              if (res.ok)
+                return {
+                  data: parsed ?? null,
+                  error: null,
+                  status: res.status,
+                  headers,
+                  response: res,
+                }
+              return {
+                data: null,
+                error: { status: res.status, value: parsed ?? text },
+                status: res.status,
+                headers,
+                response: res,
+              }
+            } catch (err) {
+              return {
+                data: null,
+                error: { status: 0, value: err },
+                status: 0,
+                headers: {},
+                response: null,
+              }
+            }
+          }
+        }
+        return make([...segments, key])
+      },
+      apply(_t, _this, args: unknown[]) {
+        const arg = args[0] as Record<string, string> | undefined
+        if (!arg) return make(segments)
+        return make([...segments, ...Object.values(arg).map(String)])
+      },
+    })
+  }
+  return make([]) as any as Treaty<App>
+}
+
+function hasFilePart(b: unknown): boolean {
+  if (b instanceof FormData || b instanceof Blob) return true
+  if (b && typeof b === 'object')
+    return Object.values(b as Record<string, unknown>).some((v) => v instanceof Blob)
+  return false
+}
+
+function toFormData(b: unknown): FormData {
+  if (b instanceof FormData) return b
+  const fd = new FormData()
+  for (const [k, v] of Object.entries(b as Record<string, unknown>)) {
+    if (v instanceof Blob) fd.append(k, v)
+    else if (v !== null && typeof v === 'object') fd.append(k, JSON.stringify(v))
+    else fd.append(k, String(v))
+  }
+  return fd
+}
+
+function safeJson(s: string): unknown {
+  try {
+    return JSON.parse(s)
+  } catch {
+    return s
+  }
+}

package/runtime/cli/actions-prebuilt-plugin.ts

@@ -1,97 +0,0 @@
-import { writeFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-import type { BunPlugin } from 'bun'
-
-/** Write a TypeScript file that re-exports `scanActions` as a pure function
- * returning a hard-coded ActionDef[]. Bundle this file via `actionsPrebuiltPlugin`
- * below to satisfy `import { scanActions } from './scan-actions.ts'` lookups
- * inside the runtime bundle without walking the filesystem at runtime.
- *
- * `idToSourcePath` maps each discovered action id → absolute path of the
- * `'use server'` file it was exported from. The orchestrator builds this map
- * by calling `collectExports(sourceFile)` for every file in `scan.sourceFiles`.
- *
- * `repoRoot` is the absolute path of the brust repo (where `runtime/` lives).
- * `outPath` is where to write the generated file (e.g. <outDir>/_actions-prebuilt.ts).
- */
-export async function writePrebuiltActionsFileWithMap(
-  outPath: string,
-  idToSourcePath: Map<string, string>,
-  repoRoot: string,
-): Promise<void> {
-  const actionsPath = resolve(repoRoot, 'runtime/actions.ts')
-  const scanPath = resolve(repoRoot, 'runtime/scan-actions.ts')
-
-  // Stable file order = stable import order = deterministic builds.
-  const filePaths = [...new Set(idToSourcePath.values())].sort()
-  const fileToVar = new Map<string, string>()
-  filePaths.forEach((p, i) => {
-    fileToVar.set(p, `__mod${i}`)
-  })
-
-  const imports = filePaths
-    .map((p, i) => `import * as __mod${i} from ${JSON.stringify(p)}`)
-    .join('\n')
-
-  const sortedIds = [...idToSourcePath.keys()].sort((a, b) => a.localeCompare(b))
-  const entries = sortedIds
-    .map((id) => {
-      const v = fileToVar.get(idToSourcePath.get(id)!)!
-      const key = JSON.stringify(id)
-      return `  { id: ${key}, fn: (${v}[${key}] as any), middleware: getActionMiddleware(${v}[${key}]) }`
-    })
-    .join(',\n')
-
-  const src = `// AUTO-GENERATED by brust build — do not edit.
-import { getActionMiddleware } from ${JSON.stringify(actionsPath)}
-import type { ActionDef } from ${JSON.stringify(actionsPath)}
-import type { ScanOptions, ScanActionsResult } from ${JSON.stringify(scanPath)}
-${imports}
-
-// Re-export auxiliaries so any bundle import from scan-actions.ts still resolves.
-export { stripLeadingTrivia, hasUseServerDirective, collectExports } from ${JSON.stringify(scanPath)}
-export type { ScanOptions, ScanActionsResult } from ${JSON.stringify(scanPath)}
-
-const PREBUILT: ActionDef[] = [
-${entries}
-]
-
-export async function scanActions(_opts: ScanOptions = {}): Promise<ScanActionsResult> {
-  return { actions: PREBUILT, sourceFiles: [] }
-}
-`
-  await writeFile(outPath, src, 'utf-8')
-}
-
-/** Bun.build plugin that aliases `runtime/scan-actions.ts` to the generated
- * prebuilt file. Combined with `writePrebuiltActionsFileWithMap` this makes
- * the bundled `scanActions()` return a hard-coded list. */
-export function actionsPrebuiltPlugin(generatedFilePath: string, repoRoot: string): BunPlugin {
-  const targetPath = resolve(repoRoot, 'runtime/scan-actions.ts')
-
-  return {
-    name: 'brust-actions-prebuilt',
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, (args) => {
-        // The generated file re-exports symbols from scan-actions.ts. Without this
-        // guard those re-exports would self-redirect back into the generated file,
-        // creating a circular module graph where the re-exported bindings resolve
-        // to `undefined`.
-        if (args.importer === generatedFilePath) return undefined
-
-        // Match the canonical scan-actions.ts file regardless of how it's
-        // imported (relative './scan-actions.ts' from runtime/index.ts, etc.).
-        // Resolve the import to an absolute path and compare.
-        const resolved = resolve(
-          args.importer ? args.importer.replace(/\/[^/]*$/, '') : repoRoot,
-          args.path,
-        )
-        if (resolved === targetPath || resolved + '.ts' === targetPath) {
-          return { path: generatedFilePath }
-        }
-        // Default resolution for everything else.
-        return undefined
-      })
-    },
-  }
-}