@briancray/belte 0.1.0 → 0.2.1

package/src/lib/shared/writeRoutesDts.ts

@@ -9,13 +9,11 @@ when dispatching, so the page component sees `params.rest`, not
 `params['*']`.
 */
 function paramsForRoute(routeUrl: string): Record<string, 'string'> {
-    const params: Record<string, 'string'> = {}
-    for (const segment of parseRouteSegments(routeUrl)) {
-        if (segment.kind === 'param') {
-            params[segment.name] = 'string'
-        }
-    }
-    return params
+    return Object.fromEntries(
+        parseRouteSegments(routeUrl)
+            .filter((segment) => segment.kind === 'param')
+            .map((segment) => [segment.name, 'string'] as const),
+    )
 }
 
 function renderParamsShape(shape: Record<string, 'string'>): string {

package/src/serverBuildPlugins.ts

@@ -0,0 +1,25 @@
+import type { BunPlugin } from 'bun'
+import { belteResolverPlugin } from './belteResolverPlugin.ts'
+import type { SvelteConfig } from './lib/server/runtime/types/SvelteConfig.ts'
+import { sveltePlugin } from './sveltePlugin.ts'
+
+/*
+The server-target Bun.build plugin pair shared by compile / buildCli /
+bundleApp: the svelte loader (server generate) plus belte's virtual-module
+resolver. `embedAssets` flips on the zstd asset embed used by the standalone
+server binary; the CLI + launcher builds leave it off.
+*/
+export function serverBuildPlugins({
+    cwd,
+    svelteConfig,
+    embedAssets = false,
+}: {
+    cwd: string
+    svelteConfig?: SvelteConfig
+    embedAssets?: boolean
+}): BunPlugin[] {
+    return [
+        sveltePlugin({ generate: 'server', svelteConfig }),
+        belteResolverPlugin({ cwd, embedAssets, target: 'server' }),
+    ]
+}

package/src/serverEntry.ts

@@ -24,10 +24,14 @@ import { rpc } from './_virtual/rpc.ts'
 import { shell } from './_virtual/shell.ts'
 // @ts-expect-error virtual module resolved by belteResolverPlugin
 import { sockets } from './_virtual/sockets.ts'
+import { exitWithParent } from './lib/bundle/exitWithParent.ts'
 import { createServer } from './lib/server/runtime/createServer.ts'
 import { requestContext } from './lib/server/runtime/requestContext.ts'
 import { setCacheStoreResolver } from './lib/shared/setCacheStoreResolver.ts'
 
+// In a bundle, tie this server's life to the launcher's (no-op standalone).
+exitWithParent()
+
 setCacheStoreResolver(() => requestContext.getStore()?.cache)
 
 await createServer({

package/template/package.json

@@ -7,10 +7,11 @@
         "dev": "belte dev",
         "build": "belte build",
         "start": "belte start",
-        "compile": "belte compile"
+        "compile": "belte compile",
+        "bundle": "belte bundle"
     },
     "dependencies": {
-        "@briancray/belte": "^0.1.0",
+        "belte": "npm:@briancray/belte@^0.2.0",
         "svelte": "^5.0.0"
     }
 }

package/src/lib/server/prompt.ts

@@ -1,30 +0,0 @@
-import type { Prompt } from './prompts/types/Prompt.ts'
-import type { PromptOptions } from './prompts/types/PromptOptions.ts'
-import type { StandardSchemaV1 } from './rpc/types/StandardSchemaV1.ts'
-
-/*
-Declares an MCP prompt inside a file under `src/server/prompts/`. Each
-file contains exactly one export, named after the file (e.g.
-`summarize.ts` → `export const summarize = prompt(...)`). The bundler
-reads the export name from the filename and the prompt name from the file
-path under `src/server/prompts/`, then rewrites this call to bind the name
-into definePrompt.
-
-`render(args)` returns the messages MCP hands back for `prompts/get`:
-either a bare string (one user message) or an explicit message array.
-When `schema` is set, `Args` infers from `InferOutput<Schema>`, incoming
-arguments validate against it, and MCP advertises the argument list in
-`prompts/list`.
-
-This function exists only for the type signature; calling it directly
-means the bundler plugin didn't process the file, which throws.
-*/
-export function prompt<Schema extends StandardSchemaV1>(
-    opts: PromptOptions<StandardSchemaV1.InferOutput<Schema>> & { schema: Schema },
-): Prompt<StandardSchemaV1.InferOutput<Schema>>
-export function prompt<Args = Record<string, string>>(opts: PromptOptions<Args>): Prompt<Args>
-export function prompt(_opts: PromptOptions): Prompt {
-    throw new Error(
-        '[belte] `prompt(...)` was called outside a prompts module — the prompt helper is only valid as the value of `export const <filename> = ...` inside a file under src/server/prompts/',
-    )
-}

package/src/lib/server/prompts/types/PromptMessage.ts

@@ -1,10 +0,0 @@
-/*
-A single message in an MCP prompt's rendered output. `prompt({ render })`
-returns either a bare string (sugar for one `user` message) or an array
-of these. The dispatcher maps each into the MCP `prompts/get` wire shape
-({ role, content: { type: 'text', text } }).
-*/
-export type PromptMessage = {
-    role: 'user' | 'assistant'
-    text: string
-}

package/src/lib/shared/preparePromptModule.ts

@@ -1,36 +0,0 @@
-import { findExportCallSite } from './findExportCallSite.ts'
-import { stripImport } from './stripImport.ts'
-
-const SINGLE_EXPORT_ERROR =
-    '[belte] prompts module contains more than one `prompt(...)` export — each file must declare exactly one prompt'
-
-export type PreparedPromptModule = {
-    exportName: string
-    rewriteForServer: (name: string) => string
-}
-
-/*
-Scans a `src/server/prompts/**` module once and returns its declared
-export name plus a closure that, given the prompt name, emits the
-server-side rewrite (`__belteDefinePrompt__("<name>", opts)` spliced into
-the original source). Mirrors prepareSocketModule — a single tokenizer
-pass so a `prompt` mention inside a string or comment is left alone.
-*/
-export function preparePromptModule(source: string): PreparedPromptModule | undefined {
-    const stripped = stripImport(source, 'belte/server/prompt')
-    const site = findExportCallSite(stripped, (ident) => ident === 'prompt', SINGLE_EXPORT_ERROR)
-    if (!site) {
-        return undefined
-    }
-    return {
-        exportName: site.exportName,
-        rewriteForServer(name: string): string {
-            const inner = stripped.slice(site.parenStart + 1, site.parenEnd).trim()
-            const binding =
-                inner.length === 0
-                    ? `__belteDefinePrompt__(${JSON.stringify(name)})`
-                    : `__belteDefinePrompt__(${JSON.stringify(name)}, ${stripped.slice(site.parenStart + 1, site.parenEnd)})`
-            return stripped.slice(0, site.callStart) + binding + stripped.slice(site.parenEnd + 1)
-        },
-    }
-}