@belte/belte 0.19.0

package/src/build.ts

@@ -0,0 +1,147 @@
+import { clientBuildPlugins } from './clientBuildPlugins.ts'
+import { exitOnBuildFailure } from './lib/shared/exitOnBuildFailure.ts'
+import { loadSvelteConfig } from './lib/shared/loadSvelteConfig.ts'
+import { log } from './lib/shared/log.ts'
+import type { SvelteConfig } from './lib/shared/types/SvelteConfig.ts'
+
+const CLIENT_ENTRY = new URL('./clientEntry.ts', import.meta.url).pathname
+
+/*
+Builds the client-side bundle into `${cwd}/dist/_app`. Runs Bun.build with
+the svelte-dedupe plugin, the svelte loader, the virtual-module resolver,
+and (optionally) Tailwind. When `compress`, each emitted file is also
+written as a zstd-compressed `.zst` sibling (level 22 — paid once at build
+time) so the server can stream the precompressed bytes directly when the
+client supports it, and decompress on the fly for older clients. Dev skips
+compression (zstd-22 on every rebuild dwarfs the bundle itself) — the
+server falls back to serving the plain bytes when no `.zst` sibling exists.
+
+The bundle is emitted into a per-build staging dir, then swapped into
+`_app` with two atomic renames. This keeps every build's writes isolated to
+a unique path (so a stray concurrent build can never `rm` files Bun is
+mid-flushing — the "writing sourcemap: No such file or directory" race) and
+means a long-running dev server reading `_app` lazily off disk never sees a
+half-built or emptied directory.
+
+`clean` (one-shot builds) clears the whole dist up front so downstream
+writers — the bundle's connect screen, the CLI manifest — start fresh; the
+dev orchestrator passes `clean: false` to leave the live dist untouched and
+only swap `_app` at the end.
+
+Returns whether the build succeeded. Never throws: a thrown Bun.build / fs
+error is logged and treated as a failed build, so the dev loop (and its
+last-good server) survives instead of crashing and orphaning the child. By
+default a failure exits the process (one-shot `belte build` / `compile`);
+the dev orchestrator passes `exitOnFailure: false`.
+*/
+export async function build({
+    cwd = process.cwd(),
+    svelteConfig,
+    minify = true,
+    compress = true,
+    clean = true,
+    exitOnFailure = true,
+}: {
+    cwd?: string
+    svelteConfig?: SvelteConfig
+    minify?: boolean
+    compress?: boolean
+    clean?: boolean
+    exitOnFailure?: boolean
+} = {}): Promise<boolean> {
+    const distDir = `${cwd}/dist`
+    const outDir = `${distDir}/_app`
+    // Per-build staging + holding dirs; the suffix isolates concurrent builds.
+    const buildId = crypto.randomUUID().slice(0, 8)
+    const stagingDir = `${distDir}/_app.staging-${buildId}`
+    const previousDir = `${distDir}/_app.old-${buildId}`
+
+    const fail = (): boolean => {
+        if (exitOnFailure) {
+            process.exit(1)
+        }
+        return false
+    }
+
+    try {
+        // shell-rm/-mv are the impure boundary for the dist swap — Bun.$ is first-party.
+        if (clean) {
+            await Bun.$`rm -rf ${distDir}`.quiet()
+        }
+
+        const config = svelteConfig ?? (await loadSvelteConfig(cwd))
+        const plugins = await clientBuildPlugins({
+            cwd,
+            svelteConfig: config,
+            tailwindWarning: 'bun-plugin-tailwind not installed; building without Tailwind',
+        })
+
+        const result = await Bun.build({
+            entrypoints: [CLIENT_ENTRY],
+            outdir: stagingDir,
+            target: 'browser',
+            splitting: true,
+            minify,
+            sourcemap: 'linked',
+            naming: {
+                entry: 'client-[hash].[ext]',
+                chunk: '[name]-[hash].[ext]',
+                asset: '[name].[ext]',
+            },
+            plugins,
+        })
+
+        if (!result.success) {
+            await Bun.$`rm -rf ${stagingDir}`.quiet().nothrow()
+            if (exitOnFailure) {
+                exitOnBuildFailure(result)
+            }
+            result.logs.forEach((entry) => {
+                log.error(entry)
+            })
+            return false
+        }
+
+        // Dev skips the zstd siblings (paths still point into stagingDir here).
+        const compressedBytes = compress
+            ? (
+                  await Promise.all(
+                      result.outputs.map(async (output) => {
+                          const bytes = await Bun.file(output.path).bytes()
+                          const compressed = await Bun.zstdCompress(bytes, { level: 22 })
+                          await Bun.write(`${output.path}.zst`, compressed)
+                          return compressed.byteLength
+                      }),
+                  )
+              ).reduce((total, length) => total + length, 0)
+            : 0
+
+        /*
+        Swap staging into _app with two renames: move any existing _app aside,
+        then rename staging into place. The window where _app is absent is a
+        single rename, so a reader (the running dev server) never observes a
+        partial bundle. nothrow on the first move: no _app exists on the first
+        build or after `clean`.
+        */
+        await Bun.$`mv ${outDir} ${previousDir}`.quiet().nothrow()
+        await Bun.$`mv ${stagingDir} ${outDir}`.quiet()
+        await Bun.$`rm -rf ${previousDir}`.quiet().nothrow()
+
+        if (compress) {
+            log.info(
+                `wrote ${result.outputs.length} files to ${outDir} (+${result.outputs.length} .zst, ${(compressedBytes / 1024).toFixed(1)} KiB total)`,
+            )
+            // Per-file paths are noise at startup; surface them only under DEBUG=belte:build.
+            result.outputs.forEach((output) => {
+                log.debug('belte:build', `  - ${output.path.replace(stagingDir, outDir)}`)
+            })
+        } else {
+            log.info(`wrote ${result.outputs.length} files to ${outDir}`)
+        }
+        return true
+    } catch (error) {
+        log.error(error)
+        await Bun.$`rm -rf ${stagingDir} ${previousDir}`.quiet().nothrow()
+        return fail()
+    }
+}

package/src/buildCli.ts

@@ -0,0 +1,129 @@
+import { dirname, join } from 'node:path'
+import { build } from './build.ts'
+import { compile } from './compile.ts'
+import { detectTarget } from './lib/shared/detectTarget.ts'
+import { exeSuffix } from './lib/shared/exeSuffix.ts'
+import { exitOnBuildFailure } from './lib/shared/exitOnBuildFailure.ts'
+import { loadSvelteConfig } from './lib/shared/loadSvelteConfig.ts'
+import { log } from './lib/shared/log.ts'
+import { programNameForPackage } from './lib/shared/programNameForPackage.ts'
+import { readPackageJson } from './lib/shared/readPackageJson.ts'
+import type { CompileTarget } from './lib/shared/types/CompileTarget.ts'
+import { serverBuildPlugins } from './serverBuildPlugins.ts'
+
+const DISCOVERY_ENTRY = new URL('./discoveryEntry.ts', import.meta.url).pathname
+const CLI_ENTRY = new URL('./cliEntry.ts', import.meta.url).pathname
+
+/*
+CLI binary build. The CLI is a thin remote client — it bakes in the per-rpc
+manifest and talks to a running server over HTTP — but the **full** binary ships
+the compiled server beside it, so `/start` can spawn a local instance.
+
+  1. Client build (once): `build` produces the platform-independent `dist/_app`
+     the server binaries embed. It clears dist first, so it runs before everything.
+  2. Discovery: build the discovery entry into a temporary JS bundle and run it. It
+     imports every rpc/socket module so defineVerb / defineSocket populate the
+     registries, then prints the CLI manifest to stdout → `dist/cli-manifest.json`.
+  3. Per target: a server binary (`compile`, reusing the shared `dist/_app` via
+     `buildClient:false`) plus the CLI binary, written side by side. The resolver's
+     `belte:cli-manifest` virtual splices in the manifest from step 2.
+
+`platforms` cross-compiles per target into `dist/cli-thin/<platform>/` (the layout
+the /__belte/cli download endpoint serves): `<programName>` + `server` together.
+*/
+export async function buildCli({
+    cwd = process.cwd(),
+    target = detectTarget(),
+    outfile,
+    platforms,
+}: {
+    cwd?: string
+    target?: CompileTarget
+    outfile?: string
+    platforms?: CompileTarget[]
+} = {}): Promise<string[]> {
+    const distDir = `${cwd}/dist`
+    const manifestPath = `${distDir}/cli-manifest.json`
+    const discoveryOut = `${distDir}/_discovery.js`
+
+    const svelteConfig = await loadSvelteConfig(cwd)
+    const plugins = serverBuildPlugins({ cwd, svelteConfig })
+
+    // Step 1 — client build once (clears dist, writes _app). Every server binary
+    // embeds it, so it must precede discovery and the per-target compiles.
+    await build({ cwd, svelteConfig })
+
+    /*
+    Step 2 — discovery. Build a runnable bundle, execute it under bun, capture
+    stdout. We don't `bun build --compile` here because the discovery output is
+    throwaway; a plain JS bundle runs faster. Additive — does not clear dist.
+    */
+    const discoveryResult = await Bun.build({
+        entrypoints: [DISCOVERY_ENTRY],
+        target: 'bun',
+        outdir: distDir,
+        naming: '_discovery.js',
+        plugins,
+    })
+    exitOnBuildFailure(discoveryResult)
+
+    const proc = Bun.spawn({
+        cmd: ['bun', discoveryOut],
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+    ])
+    if (exitCode !== 0) {
+        log.error(`discovery exited ${exitCode}:\n${stderr}`)
+        process.exit(1)
+    }
+    await Bun.write(manifestPath, stdout)
+    await Bun.$`rm -f ${discoveryOut}`.quiet()
+    const entryCount = Object.keys(JSON.parse(stdout) as Record<string, unknown>).length
+    log.info(`discovered ${entryCount} cli commands → ${manifestPath}`)
+
+    const programName = await readProgramName(cwd)
+
+    /*
+    Step 3 — compile a CLI binary + sibling server binary for a single target,
+    written side by side so `resolveServerBinary()` finds the server next to the
+    running CLI. The server reuses the shared client build (buildClient:false).
+    */
+    async function buildTargetPair(platformTarget: CompileTarget, cliOut: string): Promise<string> {
+        const serverOut = join(dirname(cliOut), `server${exeSuffix(platformTarget)}`)
+        await compile({ cwd, target: platformTarget, outfile: serverOut, buildClient: false })
+        const result = await Bun.build({
+            entrypoints: [CLI_ENTRY],
+            target: 'bun',
+            compile: { target: platformTarget, outfile: cliOut },
+            plugins,
+        })
+        exitOnBuildFailure(result)
+        log.success(`compiled cli + server: ${cliOut}`)
+        return cliOut
+    }
+
+    if (platforms && platforms.length > 0) {
+        // Cross-compile every target in parallel — each pair is independent.
+        return Promise.all(
+            platforms.map(async (platformTarget) => {
+                const shortName = platformTarget.replace(/^bun-/, '')
+                const cliOut = `${distDir}/cli-thin/${shortName}/${programName}${exeSuffix(platformTarget)}`
+                await Bun.$`mkdir -p ${`${distDir}/cli-thin/${shortName}`}`.quiet()
+                return buildTargetPair(platformTarget, cliOut)
+            }),
+        )
+    }
+
+    const cliOut = outfile ?? `${distDir}/cli${exeSuffix(target)}`
+    return [await buildTargetPair(target, cliOut)]
+}
+
+async function readProgramName(cwd: string): Promise<string> {
+    const pkg = (await readPackageJson(cwd)) as { name?: string } | undefined
+    return programNameForPackage(pkg?.name)
+}

package/src/buildDisconnected.ts

@@ -0,0 +1,122 @@
+import { clientBuildPlugins } from './clientBuildPlugins.ts'
+import { exitOnBuildFailure } from './lib/shared/exitOnBuildFailure.ts'
+import { log } from './lib/shared/log.ts'
+import type { SvelteConfig } from './lib/shared/types/SvelteConfig.ts'
+
+const ENTRY = new URL('./bundleDisconnectedEntry.ts', import.meta.url).pathname
+const CSS_ENTRY = new URL('./lib/bundle/disconnected.css', import.meta.url).pathname
+
+/*
+Default screen logo: a minimal inline-SVG belte mark, used when the project ships
+no src/bundle/logo.png. Inline SVG keeps the bundle self-contained with no asset
+file to vendor; a project overrides it just by adding the PNG.
+*/
+const DEFAULT_LOGO = `data:image/svg+xml,${encodeURIComponent(
+    '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">' +
+        '<rect width="64" height="64" rx="16" fill="#111827"/>' +
+        '<text x="32" y="45" font-family="system-ui,sans-serif" font-size="38" ' +
+        'font-weight="700" fill="#fff" text-anchor="middle">b</text></svg>',
+)}`
+
+/*
+Builds the bundle connect screen into a single self-contained HTML string and
+writes it to `dist/bundle-disconnected.html`, which the launcher bakes in via the
+`belte:bundle-disconnected` virtual. The client bundle (Svelte component +
+injected CSS + compiled Tailwind) is inlined into the page so the launcher serves
+it with zero external requests; the logo is embedded as a data URI. The app title
+(`window.__BELTE_TITLE__`) is injected by the launcher at serve time, so a
+`<!--belte:connect-config-->` marker is left in <head> for it.
+
+Must run after the client build has cleared and repopulated dist (it writes a
+file into dist), and before the launcher build that reads it. Uses no outdir of
+its own — Bun.build artifacts are read from memory — so it never touches dist
+beyond the one file it writes.
+*/
+export async function buildDisconnected({
+    cwd = process.cwd(),
+    svelteConfig,
+}: {
+    cwd?: string
+    svelteConfig?: SvelteConfig
+} = {}): Promise<string> {
+    const plugins = await clientBuildPlugins({
+        cwd,
+        svelteConfig,
+        tailwindWarning:
+            'bun-plugin-tailwind not installed; building connect screen without Tailwind',
+    })
+
+    /*
+    The Tailwind CSS rides as its own entrypoint rather than a `.css` import from
+    the entry (which TS can't type), so it compiles to a standalone artifact we
+    inline alongside the JS — the component carries no <style> of its own.
+    */
+    const result = await Bun.build({
+        entrypoints: [ENTRY, CSS_ENTRY],
+        target: 'browser',
+        minify: true,
+        plugins,
+    })
+    exitOnBuildFailure(result)
+
+    // Collect the JS bundle + extracted CSS from the in-memory artifacts.
+    let js = ''
+    let css = ''
+    for (const output of result.outputs) {
+        const text = await output.text()
+        if (output.path.endsWith('.css')) {
+            css += text
+        } else if (output.path.endsWith('.js')) {
+            js += text
+        }
+    }
+
+    const logo = await readLogo(cwd)
+    const html = composeHtml({ js, css, logo })
+    const outPath = `${cwd}/dist/bundle-disconnected.html`
+    await Bun.write(outPath, html)
+    log.success(`built connect screen: ${outPath} (${(html.length / 1024).toFixed(1)} KiB)`)
+    return outPath
+}
+
+// Reads the project's src/bundle/logo.png as a data URI, or the default mark.
+async function readLogo(cwd: string): Promise<string> {
+    const userLogo = Bun.file(`${cwd}/src/bundle/logo.png`)
+    if (await userLogo.exists()) {
+        const bytes = await userLogo.bytes()
+        return `data:image/png;base64,${bytes.toBase64()}`
+    }
+    return DEFAULT_LOGO
+}
+
+/*
+Escapes a closing `</script>` so an inline `<script>` body can't be terminated
+early by content in the bundle (rare, but a `</script>` substring would break the
+page). The browser still parses `<\/script>` as the intended characters.
+*/
+function escapeScriptBody(value: string): string {
+    return value.replace(/<\/(script)/gi, '<\\/$1')
+}
+
+// Assembles the final standalone HTML document from the inlined pieces.
+function composeHtml({ js, css, logo }: { js: string; css: string; logo: string }): string {
+    const logoScript = `window.__BELTE_LOGO__=${JSON.stringify(logo)}`
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<!--belte:connect-config-->
+<script>${escapeScriptBody(logoScript)}</script>
+<!-- Paint the screen background before the client mounts, so there's no white
+flash ahead of the splash (gray-50 / gray-950 to match the rendered screen). -->
+<style>html,body{margin:0;background:#f9fafb}@media (prefers-color-scheme:dark){html,body{background:#030712}}</style>
+<style>${css}</style>
+</head>
+<body>
+<div id="app"></div>
+<script type="module">${escapeScriptBody(js)}</script>
+</body>
+</html>
+`
+}

package/src/bundleApp.ts

@@ -0,0 +1,149 @@
+import { dirname } from 'node:path'
+import { buildDisconnected } from './buildDisconnected.ts'
+import { compile } from './compile.ts'
+import { ensureWebviewLib } from './lib/bundle/ensureWebviewLib.ts'
+import { infoPlist } from './lib/bundle/infoPlist.ts'
+import { pngToIcns } from './lib/bundle/pngToIcns.ts'
+import { serverBinaryFilename } from './lib/bundle/serverBinaryFilename.ts'
+import { signMacApp } from './lib/bundle/signMacApp.ts'
+import { webviewLibName } from './lib/bundle/webviewLibName.ts'
+import { bundleLayout } from './lib/shared/bundleLayout.ts'
+import { detectTarget } from './lib/shared/detectTarget.ts'
+import { exitOnBuildFailure } from './lib/shared/exitOnBuildFailure.ts'
+import { loadSvelteConfig } from './lib/shared/loadSvelteConfig.ts'
+import { log } from './lib/shared/log.ts'
+import { programNameForPackage } from './lib/shared/programNameForPackage.ts'
+import { readPackageJson } from './lib/shared/readPackageJson.ts'
+import { serverBuildPlugins } from './serverBuildPlugins.ts'
+
+const APP_ENTRY = new URL('./appEntry.ts', import.meta.url).pathname
+const WORKER_ENTRY = new URL('./controlServerWorker.ts', import.meta.url).pathname
+
+/*
+Assembles a movable, self-contained app bundle for the host platform —
+no cross-compilation, and on macOS an ad-hoc seal so it launches on other
+Macs (signMacApp). Three pieces travel together so the app runs on another
+machine of the same OS with nothing installed:
+
+  - the standalone server binary (`compile()`, assets embedded)
+  - the launcher binary (appEntry — spawns the server, opens the webview)
+  - the native webview shared library
+
+macOS gets a `.app` bundle (`Contents/MacOS/` + `Contents/Frameworks/` +
+Info.plist); other platforms get a flat `<name>/` directory with the two
+binaries and the lib side by side. The launcher finds both relatives at
+runtime via resolveServerBinary / resolveWebviewLib.
+*/
+export async function bundleApp({ cwd = process.cwd() }: { cwd?: string } = {}): Promise<string> {
+    const target = detectTarget()
+    const { name, version } = await readPackage(cwd)
+    const programName = programNameForPackage(name)
+    const svelteConfig = await loadSvelteConfig(cwd)
+
+    /*
+    Layout differs by OS: a macOS .app nests binaries under Contents/MacOS, the
+    lib under Contents/Frameworks, and data under Contents/Resources; elsewhere
+    everything sits flat in one directory. bundleLayout derives the rest from
+    binDir — the same source the boot readers resolve from — so build and runtime
+    agree on where the lib, resources, and shipped `.env` land.
+    */
+    const isMac = process.platform === 'darwin'
+    const bundleRoot = isMac ? `${cwd}/dist/${programName}.app` : `${cwd}/dist/${programName}`
+    const binDir = isMac ? `${bundleRoot}/Contents/MacOS` : bundleRoot
+    const { libDir, resourcesDir, envPath } = bundleLayout(binDir)
+
+    await Bun.$`rm -rf ${bundleRoot}`.quiet()
+    await Bun.$`mkdir -p ${binDir} ${libDir}`.quiet()
+
+    // 1. Server binary — self-contained, embeds the client assets. compile()
+    // runs the client build, which clears dist first, so it must precede the
+    // connect-screen build that writes into dist.
+    await compile({ cwd, target, outfile: `${binDir}/${serverBinaryFilename()}` })
+
+    /*
+    Opt-in: ship the project's `bundle.env` as the shipped `.env`, which the
+    server loads at boot (loadEnvFromBinaryDir) as its default config layer. A
+    dedicated file, never the working `.env` — a compiled bundle is extractable,
+    so only ship-safe defaults belong here; user-specific/secret values come from
+    the data-dir `.env` instead. Named outside Bun's `.env.*` autoload family on
+    purpose: it's a build input, not a runtime overlay, so `bun dev`/`bun start`
+    never pick it up. bundleLayout places it under Contents/Resources
+    in a macOS `.app` (sealed as a resource, so it survives codesign) and beside
+    the binaries otherwise. Skipped when absent.
+    */
+    const bundleEnv = Bun.file(`${cwd}/bundle.env`)
+    if (await bundleEnv.exists()) {
+        await Bun.$`mkdir -p ${dirname(envPath)}`.quiet()
+        await Bun.write(envPath, bundleEnv)
+    }
+
+    // 2. Connect screen — bake dist/bundle-disconnected.html before the launcher
+    // build, which inlines it via the belte:bundle-disconnected virtual.
+    await buildDisconnected({ cwd, svelteConfig })
+
+    // 3. Launcher binary — named after the program so CFBundleExecutable matches.
+    const launcherSuffix = target.includes('windows') ? '.exe' : ''
+    const launcherPath = `${binDir}/${programName}${launcherSuffix}`
+    const launcherResult = await Bun.build({
+        entrypoints: [APP_ENTRY],
+        target: 'bun',
+        compile: { target, outfile: launcherPath },
+        plugins: serverBuildPlugins({ cwd, svelteConfig }),
+        /*
+        Inject the worker's absolute path as a static literal. `new Worker()` is
+        embedded into the standalone binary only when its specifier is a build-time
+        literal, and a relative one would resolve against `cwd` (the consumer
+        project) rather than appEntry's directory — so the launcher passes the
+        absolute path through this define instead.
+        */
+        define: { __BELTE_WORKER_ENTRY__: JSON.stringify(WORKER_ENTRY) },
+    })
+    exitOnBuildFailure(launcherResult)
+
+    // 4. Webview lib — built from the vendored source if needed, then copied
+    // beside the binaries (or into Frameworks on macOS) so the bundle is self-contained.
+    const libSource = await ensureWebviewLib(cwd)
+    await Bun.write(`${libDir}/${webviewLibName()}`, Bun.file(libSource))
+
+    /*
+    macOS-only: produce Contents/Resources/icon.icns from an optional project
+    icon, then write the Info.plist that makes the .app launchable from
+    Finder, wiring CFBundleIconFile when an icon was produced. A ready-made
+    src/bundle/icon.icns is used as-is; otherwise src/bundle/icon.png is
+    converted via sips + iconutil so authors don't need to make an .icns.
+    */
+    if (isMac) {
+        const icnsSource = `${cwd}/src/bundle/icon.icns`
+        const pngSource = `${cwd}/src/bundle/icon.png`
+        let hasIcon = false
+        if (await Bun.file(icnsSource).exists()) {
+            await Bun.$`mkdir -p ${resourcesDir}`.quiet()
+            await Bun.write(`${resourcesDir}/icon.icns`, Bun.file(icnsSource))
+            hasIcon = true
+        } else if (await Bun.file(pngSource).exists()) {
+            await Bun.$`mkdir -p ${resourcesDir}`.quiet()
+            hasIcon = await pngToIcns(pngSource, `${resourcesDir}/icon.icns`)
+        }
+        await Bun.write(
+            `${bundleRoot}/Contents/Info.plist`,
+            infoPlist({ name: programName, version, icon: hasIcon ? 'icon' : undefined }),
+        )
+
+        // Seal the finished bundle so it launches on other Macs — must run last,
+        // after every binary, the lib, and Info.plist are in place.
+        await signMacApp(bundleRoot, [
+            `${libDir}/${webviewLibName()}`,
+            `${binDir}/${serverBinaryFilename()}`,
+            launcherPath,
+        ])
+    }
+
+    log.success(`bundled app: ${bundleRoot} (target: ${target})`)
+    return bundleRoot
+}
+
+// Reads name + version from package.json, with fallbacks when absent.
+async function readPackage(cwd: string): Promise<{ name: string | undefined; version: string }> {
+    const pkg = (await readPackageJson(cwd)) as { name?: string; version?: string } | undefined
+    return { name: pkg?.name, version: pkg?.version ?? '0.0.0' }
+}

package/src/bundleDisconnectedEntry.ts

@@ -0,0 +1,17 @@
+import { mount } from 'svelte'
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import Disconnected from './_virtual/bundle-disconnected-component.ts'
+
+/*
+Client entry for the bundle connect screen. Standalone — it mounts the
+disconnected component (the user's src/bundle/disconnected.svelte override or the
+lib default, picked by the resolver) into #app, with no router or SSR hydration.
+buildDisconnected bundles this into a single self-contained HTML file (the Tailwind
+CSS is a separate build entrypoint, not imported here). The `svelte` import sits
+first so biome's import sorting leaves the `_virtual` component's `@ts-expect-error`
+attached.
+*/
+const target = document.getElementById('app')
+if (target) {
+    mount(Disconnected, { target })
+}

package/src/cliEntry.ts

@@ -0,0 +1,25 @@
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import { banner, footer } from './_virtual/cli-chrome.ts'
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import manifest from './_virtual/cli-manifest.ts'
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import programName from './_virtual/cli-name.ts'
+import { runCli } from './lib/cli/runCli.ts'
+
+/*
+Standalone CLI binary entry. Compiled with `bun build --compile` into
+`dist/cli` (or `dist/cli-thin/<platform>/` for cross-builds). The CLI is
+a thin remote client — no handler code is bundled; it talks to a running
+server over HTTP (BELTE_APP_URL at runtime). The bundler emits:
+  - belte:cli-manifest — the per-rpc manifest (method, url, jsonSchema)
+  - belte:cli-name     — the program name from package.json
+  - belte:cli-chrome   — optional banner/footer text from src/cli/
+*/
+const exitCode = await runCli({
+    programName,
+    manifest,
+    banner,
+    footer,
+    argv: process.argv.slice(2),
+})
+process.exit(exitCode)

package/src/clientBuildPlugins.ts

@@ -0,0 +1,41 @@
+import type { BunPlugin } from 'bun'
+import { belteResolverPlugin } from './belteResolverPlugin.ts'
+import { dedupeSveltePlugin } from './dedupeSveltePlugin.ts'
+import { isModuleNotFound } from './lib/shared/isModuleNotFound.ts'
+import { log } from './lib/shared/log.ts'
+import type { SvelteConfig } from './lib/shared/types/SvelteConfig.ts'
+import { sveltePlugin } from './sveltePlugin.ts'
+
+/*
+The client-target Bun.build plugin chain shared by the page bundle (build)
+and the bundle connect screen (buildDisconnected): svelte-dedupe, the svelte
+client loader, belte's virtual-module resolver, and the optional Tailwind
+plugin. Tailwind is an optional peer — a genuine "not installed" builds
+without it, but any other load error surfaces (a plugin that loaded then
+threw on a real misconfig must not silently ship unstyled). `tailwindWarning`
+names what each caller builds without when Tailwind is absent.
+*/
+export async function clientBuildPlugins({
+    cwd,
+    svelteConfig,
+    tailwindWarning,
+}: {
+    cwd: string
+    svelteConfig?: SvelteConfig
+    tailwindWarning: string
+}): Promise<BunPlugin[]> {
+    const plugins: BunPlugin[] = [
+        dedupeSveltePlugin({ cwd, conditions: ['browser', 'default'] }),
+        sveltePlugin({ generate: 'client', svelteConfig }),
+        belteResolverPlugin({ cwd, target: 'client' }),
+    ]
+    try {
+        plugins.push((await import('bun-plugin-tailwind')).default)
+    } catch (error) {
+        if (!isModuleNotFound(error)) {
+            throw error
+        }
+        log.warn(tailwindWarning)
+    }
+    return plugins
+}

package/src/clientEntry.ts

@@ -0,0 +1,7 @@
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import { layouts } from './_virtual/layouts.ts'
+// @ts-expect-error virtual module resolved by belteResolverPlugin
+import { pages } from './_virtual/pages.ts'
+import { startClient } from './lib/browser/startClient.ts'
+
+await startClient({ pages, layouts })