@cosmicdrift/kumiko-dev-server 0.328.1 → 0.330.0

package/README.md

@@ -0,0 +1,17 @@
+# @cosmicdrift/kumiko-dev-server
+
+Dev tooling for Kumiko apps: local dev server (`runDevApp`), scaffolding and codegen, plus the `kumiko-*` build and schema commands.
+
+## Install
+
+```bash
+bun add @cosmicdrift/kumiko-dev-server
+```
+
+```ts
+import { runDevApp } from "@cosmicdrift/kumiko-dev-server";
+```
+
+Bun is required for the bundled commands.
+
+Documentation: https://kumiko.rocks

package/bin/kumiko-build.ts

@@ -23,12 +23,13 @@ import {
   buildServerBundle,
   discoverServerEntry,
   formatBuildResult,
+  formatScanWarning,
   formatServerBuildResult,
   readClientEntriesConfig,
   readExtraRuntimeExternals,
   resolveClientEntries,
-} from "../src/build";
-import { formatScanWarning, runCodegen } from "../src/codegen";
+  runCodegen,
+} from "@cosmicdrift/kumiko-dev-server/cli";
 
 const explicit = process.argv[2];
 const cwd = explicit ? resolve(process.cwd(), explicit) : process.cwd();

package/bin/kumiko-dev.ts

@@ -19,7 +19,7 @@
 
 import { spawn } from "node:child_process";
 import process from "node:process";
-import { createCrashTracker } from "../src/crash-tracker";
+import { createCrashTracker } from "@cosmicdrift/kumiko-dev-server/cli";
 
 const SCHEMA_RESTART_EXIT_CODE = 75;
 const MAX_CRASHES = 5;

package/bin/kumiko-init-deploy.ts

@@ -7,7 +7,7 @@
 //   bunx kumiko-init-deploy --app <name> [--port <n>] [--github-org <org>] [--out <dir>] [--force]
 //   bunx kumiko-init-deploy --check   # drift check, exit 1 if deploy/ is stale
 
-import { runInitDeployCli } from "../src/init-deploy-cli";
+import { runInitDeployCli } from "@cosmicdrift/kumiko-dev-server/cli";
 
 // Only run when executed as a CLI, not when imported (e.g. from tests that
 // exercise runInitDeployCli directly).

package/bin/kumiko-schema-check.ts

@@ -25,7 +25,10 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { implicitAuthModeFeatureNames, resolveGeneratePath } from "../src/schema-check-core";
+import {
+  implicitAuthModeFeatureNames,
+  resolveGeneratePath,
+} from "@cosmicdrift/kumiko-dev-server/cli";
 
 type Args = {
   readonly runConfigPath: string;

package/dist/build-server-bundle.d.ts

@@ -0,0 +1,31 @@
+export type BuildServerBundleOptions = {
+    /** App-Root. Default: process.cwd(). */
+    readonly cwd?: string;
+    /** Output-Folder relativ zu cwd. Default: "dist-server". */
+    readonly outDir?: string;
+    /** Zusätzliche Pakete die zur Laufzeit installiert sein müssen
+     *  (beyond RUNTIME_EXTERNALS). App-spezifisch — Default leer. */
+    readonly extraRuntimeExternals?: readonly string[];
+    /** Zusätzliche Build-only-Externals. App-spezifisch — Default leer. */
+    readonly extraBuildOnlyExternals?: readonly string[];
+};
+export type BuildServerBundleEntry = {
+    readonly file: string;
+    readonly sizeBytes: number;
+};
+export type BuildServerBundleResult = {
+    readonly outDir: string;
+    /** Benannte Entry-Files (server.js, ggf. kumiko.js). */
+    readonly entries: readonly BuildServerBundleEntry[];
+    /** Geteilte Framework-Chunks (von splitting). */
+    readonly chunks: readonly BuildServerBundleEntry[];
+    /** Gesamt-Größe aller Outputs (entries + chunks) in Bytes. */
+    readonly totalBytes: number;
+    readonly runtimeDeps: Readonly<Record<string, string>>;
+};
+export declare function buildServerBundle(options?: BuildServerBundleOptions): Promise<BuildServerBundleResult>;
+export declare function discoverServerEntry(cwd: string): string | undefined;
+/** Read `package.json#kumiko.extraRuntimeExternals` for kumiko-build (#1484).
+ *  Invalid / missing shapes → empty list (CLI stays convention-driven). */
+export declare function readExtraRuntimeExternals(cwd: string): readonly string[];
+export declare function formatServerBuildResult(result: BuildServerBundleResult, durationMs: number): string;

package/dist/build-server-bundle.js

@@ -0,0 +1,282 @@
+// buildServerBundle — Production-Server-Bundle für Kumiko-Apps. Pendant zu
+// buildProdBundle (Client). Convention-Driven Discovery liest bin/main.ts
+// (+ optional <repo>/bin/kumiko.ts) und produziert ein runtime-self-contained
+// dist-server/ aus dem ein Bun-Alpine-Container ohne Monorepo bootet.
+//
+// Convention:
+//
+//   bin/main.ts            →  dist-server/server.js   (App-Boot, ruft runProdApp)
+//   <repo>/bin/kumiko.ts   →  dist-server/kumiko.js   (Migrate-CLI: `schema apply`,
+//                             gefunden via walk-up bis bin/kumiko.ts)
+//   dist-server/package.json → runtime-deps mit gepinnten Versionen
+//
+// Beide Entries werden in EINEM Bun.build-Call mit `splitting` gebaut: das
+// Framework landet als geteilte chunk-*.js, server.js + kumiko.js sind schlanke
+// Entries die sie importieren — statt das Framework pro Entry neu zu inlinen
+// (vorher ~14 MB × N separate Bundles).
+//
+// Output:
+//
+//   dist-server/
+//     server.js            ← App-Boot-Entry
+//     kumiko.js            ← Migrate-CLI-Entry (wenn bin/kumiko.ts gefunden)
+//     chunk-*.js           ← geteilte Framework-Chunks
+//     package.json         ← runtime-deps mit gepinnten Versionen
+//
+// Externals — Pakete die NICHT ins Bundle gebakt werden, sondern via
+// `bun install` im Runtime-Container nachgeholt werden:
+//
+//   RUNTIME_EXTERNALS — wird zur Laufzeit gebraucht (native bindings,
+//                       worker-threads, dynamic-require). Landet in
+//                       dist-server/package.json#dependencies.
+//
+//   BUILD_ONLY_EXTERNALS — referenziert nur transitiv im Framework, vom
+//                          App-Code aber nie. Tree-Shake wirft sie aus dem
+//                          Bundle, der external-Marker schaltet nur das
+//                          resolution-during-build ab. NICHT in runtime-deps.
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { parseJsonOrThrow, parseJsonSafe } from "@cosmicdrift/kumiko-framework/utils";
+const hasBun = typeof globalThis.Bun !== "undefined";
+// Pakete die das Bundle zur Laufzeit weiter referenziert (`from "<pkg>"` nach
+// Tree-Shake). Native bindings (argon2), worker-thread-Loader (bullmq,
+// ioredis), dynamic-require (postgres, temporal-polyfill) — alles was unter
+// Bun-bundling bricht. (drizzle-kit/drizzle-orm sind raus: der Migrate-Pfad
+// nutzt jetzt den framework-eigenen runMigrationsFromDir, kein drizzle-kit.)
+// meilisearch: deliberately here, not in BUILD_ONLY_EXTERNALS below — apps
+// that import createMeilisearchAdapter (kumiko-framework/search/meilisearch)
+// reference the package at runtime (no native binding, plain HTTP client,
+// but a real runtime import). Found 2026-07-19: money-horse prod crash
+// "Cannot find package 'meilisearch'" because it used to sit in
+// BUILD_ONLY_EXTERNALS instead.
+const RUNTIME_EXTERNALS = [
+    "@node-rs/argon2",
+    "sharp",
+    "bullmq",
+    "ioredis",
+    "postgres",
+    "temporal-polyfill",
+    "pino",
+    "pino-pretty",
+    "meilisearch",
+];
+// Pakete die nur im Build-Stack erscheinen (transitive Imports im Framework),
+// aber vom App-Code nicht referenziert werden. Ohne external-Markierung
+// scheitert bun build an dynamic-imports. Tree-Shake wirft sie eh aus dem
+// Bundle — der Marker schaltet nur das resolution-during-build ab. NICHT in
+// runtime-deps.
+const BUILD_ONLY_EXTERNALS = [
+    "@planetscale/database",
+    "@libsql/client",
+    "better-sqlite3",
+    "@neondatabase/serverless",
+    "@vercel/postgres",
+    "mysql2",
+    // ink (kumiko-tui) hat react-devtools-core als dev-only transitive import.
+    "react-devtools-core",
+];
+// Bun benennt Entries nach Source-Basename (bin/main.ts → main.js). server.js
+// ist die Runtime-Convention; der Entry wird von nichts importiert (nur die
+// chunks werden referenziert, per relativem Pfad), darum ist der Rename sicher.
+const ENTRY_RENAMES = { "main.js": "server.js" };
+export async function buildServerBundle(options = {}) {
+    if (!hasBun) {
+        throw new Error("buildServerBundle requires Bun runtime (Bun.build is missing).");
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const outDir = resolve(cwd, options.outDir ?? "dist-server");
+    const serverEntry = discoverServerEntry(cwd);
+    if (!serverEntry) {
+        throw new Error(`[buildServerBundle] Kein bin/main.ts in ${cwd}.\n  Convention: bin/main.ts ist der Server-Bootstrap.`);
+    }
+    const repoRoot = findRepoRoot(cwd);
+    const kumikoCli = repoRoot ? join(repoRoot, "bin/kumiko.ts") : undefined;
+    if (kumikoCli && !existsSync(kumikoCli)) {
+        throw new Error(`[buildServerBundle] Repo-Root erkannt (${repoRoot}), aber bin/kumiko.ts fehlt — kann Migrate-CLI nicht bündeln.`);
+    }
+    const externals = [
+        ...RUNTIME_EXTERNALS,
+        ...BUILD_ONLY_EXTERNALS,
+        ...(options.extraRuntimeExternals ?? []),
+        ...(options.extraBuildOnlyExternals ?? []),
+    ];
+    await rm(outDir, { recursive: true, force: true });
+    await mkdir(outDir, { recursive: true });
+    // Ein Bun.build-Call mit allen Entries + splitting → das Framework wird
+    // einmal als shared chunk abgelegt statt pro Entry inlined.
+    const entrypoints = kumikoCli ? [serverEntry, kumikoCli] : [serverEntry];
+    const result = await Bun.build({
+        entrypoints,
+        outdir: outDir,
+        target: "bun",
+        external: externals,
+        splitting: true,
+        sourcemap: "none",
+        naming: { entry: "[name].js", chunk: "chunk-[hash].js" },
+        minify: false,
+    });
+    if (!result.success) {
+        const logs = result.logs.map(String).join("\n");
+        throw new Error(`[buildServerBundle] build FAILED:\n${logs}`);
+    }
+    // Größe von Disk lesen, nicht aus out.size — letzteres ist für gesplittete
+    // Entry-Points unzuverlässig (meldet teils ~0 für den Entry-Stub).
+    const entries = [];
+    const chunks = [];
+    for (const out of result.outputs) {
+        const base = out.path.split("/").pop() ?? out.path;
+        if (out.kind === "entry-point") {
+            const desired = ENTRY_RENAMES[base] ?? base;
+            if (desired !== base) {
+                await rename(join(outDir, base), join(outDir, desired));
+            }
+            entries.push({ file: desired, sizeBytes: statSync(join(outDir, desired)).size });
+        }
+        else if (out.kind === "chunk") {
+            chunks.push({ file: base, sizeBytes: statSync(join(outDir, base)).size });
+        }
+    }
+    entries.sort((a, b) => a.file.localeCompare(b.file));
+    const totalBytes = [...entries, ...chunks].reduce((sum, e) => sum + e.sizeBytes, 0);
+    const runtimeDeps = await resolveRuntimeDepsVersions(cwd, repoRoot, [
+        ...RUNTIME_EXTERNALS,
+        ...(options.extraRuntimeExternals ?? []),
+    ]);
+    const runtimePkg = {
+        name: derivePkgName(cwd),
+        private: true,
+        type: "module",
+        scripts: { start: "bun run server.js" },
+        dependencies: runtimeDeps,
+    };
+    await writeFile(join(outDir, "package.json"), `${JSON.stringify(runtimePkg, null, 2)}\n`);
+    return { outDir, entries, chunks, totalBytes, runtimeDeps };
+}
+export function discoverServerEntry(cwd) {
+    const tsEntry = join(cwd, "bin/main.ts");
+    if (existsSync(tsEntry))
+        return tsEntry;
+    const jsEntry = join(cwd, "bin/main.js");
+    if (existsSync(jsEntry))
+        return jsEntry;
+    return undefined;
+}
+// Walking up vom App-cwd bis ein Verzeichnis mit `bin/kumiko.ts` gefunden wird.
+// Failsafe: nach 8 Levels aufgeben — nichts gefunden, kein Repo-Root, dann
+// liefert die Funktion undefined und der Caller skippt das CLI-Bundle.
+function findRepoRoot(start) {
+    let cur = start;
+    for (let i = 0; i < 8; i++) {
+        if (existsSync(join(cur, "bin/kumiko.ts")))
+            return cur;
+        const parent = dirname(cur);
+        if (parent === cur)
+            return undefined;
+        cur = parent;
+    }
+    return undefined;
+}
+/** Read `package.json#kumiko.extraRuntimeExternals` for kumiko-build (#1484).
+ *  Invalid / missing shapes → empty list (CLI stays convention-driven). */
+export function readExtraRuntimeExternals(cwd) {
+    const pkgJson = join(cwd, "package.json");
+    if (!existsSync(pkgJson))
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(pkgJson, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const parsed = parseJsonSafe(raw, {});
+    const list = parsed.kumiko?.extraRuntimeExternals;
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((x) => typeof x === "string" && x.trim().length > 0);
+}
+// Versionen für RUNTIME_EXTERNALS auflösen: erst aus den installierten
+// node_modules/@cosmicdrift/*-Packages (relativ zu cwd — funktioniert für
+// jede Consumer-App), dann als Zusatz aus packages/framework + bundled-
+// features (Workspace-Checkout des Frameworks selbst). Fallback auf "*"
+// wenn keine Quelle den Namen kennt.
+async function resolveRuntimeDepsVersions(cwd, repoRoot, packages) {
+    const out = {};
+    const pinSources = [
+        ...(repoRoot
+            ? [
+                join(repoRoot, "packages/framework/package.json"),
+                join(repoRoot, "packages/bundled-features/package.json"),
+            ]
+            : []),
+        // node_modules applied last among framework sources so installed versions
+        // win over the repo-root fallback (#1217).
+        join(cwd, "node_modules/@cosmicdrift/kumiko-framework/package.json"),
+        join(cwd, "node_modules/@cosmicdrift/kumiko-bundled-features/package.json"),
+    ];
+    const allDeps = {};
+    for (const path of pinSources) {
+        if (!existsSync(path))
+            continue;
+        const raw = await readFile(path, "utf-8");
+        const parsed = parseJsonOrThrow(raw, path);
+        Object.assign(allDeps, parsed.dependencies ?? {}, parsed.optionalDependencies ?? {});
+    }
+    // App package.json fills gaps only — pins extraRuntimeExternals without
+    // overriding framework-native pins the app may also list (#1484 / review).
+    const appPkg = join(cwd, "package.json");
+    if (existsSync(appPkg)) {
+        const raw = await readFile(appPkg, "utf-8");
+        const parsed = parseJsonOrThrow(raw, appPkg);
+        for (const [name, ver] of Object.entries({
+            ...(parsed.dependencies ?? {}),
+            ...(parsed.optionalDependencies ?? {}),
+        })) {
+            if (allDeps[name] === undefined)
+                allDeps[name] = ver;
+        }
+    }
+    for (const pkg of packages) {
+        out[pkg] = allDeps[pkg] ?? "*";
+    }
+    return out;
+}
+function derivePkgName(cwd) {
+    const pkgJson = join(cwd, "package.json");
+    if (!existsSync(pkgJson))
+        return "kumiko-app-runtime";
+    // existsSync/readFileSync race (deleted between the two calls) or a
+    // permission error must fall back like a missing file, not crash the
+    // build — read here too, not just the JSON.parse below.
+    let raw;
+    try {
+        raw = readFileSync(pkgJson, "utf-8");
+    }
+    catch {
+        return "kumiko-app-runtime";
+    }
+    const parsed = parseJsonSafe(raw, {});
+    return parsed.name ? `${parsed.name}-runtime` : "kumiko-app-runtime";
+}
+export function formatServerBuildResult(result, durationMs) {
+    const cyan = "\x1b[36m";
+    const dim = "\x1b[2m";
+    const green = "\x1b[32m";
+    const reset = "\x1b[0m";
+    // @wrapper-known semantic-alias
+    const mb = (bytes) => (bytes / 1024 / 1024).toFixed(2);
+    const lines = [];
+    lines.push("");
+    lines.push(`  ${green}✓${reset} server bundle ${dim}(${durationMs}ms)${reset}`);
+    for (const entry of result.entries) {
+        lines.push(`    ${cyan}→${reset} ${entry.file}  ${mb(entry.sizeBytes)} MB`);
+    }
+    if (result.chunks.length > 0) {
+        const chunkBytes = result.chunks.reduce((sum, c) => sum + c.sizeBytes, 0);
+        lines.push(`    ${cyan}→${reset} ${result.chunks.length} shared chunk(s)  ${mb(chunkBytes)} MB`);
+    }
+    const depCount = Object.keys(result.runtimeDeps).length;
+    lines.push(`    ${dim}total: ${mb(result.totalBytes)} MB · runtime-deps: ${depCount} packages${reset}`);
+    return lines.join("\n");
+}

package/dist/build.d.ts

@@ -0,0 +1,2 @@
+export { ASSETS_DIR, type BuildManifest, type BuildProdBundleOptions, type BuildResult, buildProdBundle, type ClientEntry, type ClientEntryDeclaration, discoverHtmlTemplate, formatBuildResult, injectAssetTags, readClientEntriesConfig, resolveClientEntries, } from "@cosmicdrift/kumiko-server-runtime/build-prod-bundle";
+export { type BuildServerBundleEntry, type BuildServerBundleOptions, type BuildServerBundleResult, buildServerBundle, discoverServerEntry, formatServerBuildResult, readExtraRuntimeExternals, } from "./build-server-bundle.js";

package/dist/build.js

@@ -0,0 +1,5 @@
+// Build-Toolchain Public-API. Eigener Sub-Path-Export `@cosmicdrift/kumiko-dev-server/build`
+// damit der Main-Barrel kein Bun-Toolchain-Bundle in Production-Reads zieht
+// (z.B. wenn drizzle-kit die App-Config unter Node lädt).
+export { ASSETS_DIR, buildProdBundle, discoverHtmlTemplate, formatBuildResult, injectAssetTags, readClientEntriesConfig, resolveClientEntries, } from "@cosmicdrift/kumiko-server-runtime/build-prod-bundle";
+export { buildServerBundle, discoverServerEntry, formatServerBuildResult, readExtraRuntimeExternals, } from "./build-server-bundle.js";

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+export { buildProdBundle, buildServerBundle, discoverServerEntry, formatBuildResult, formatServerBuildResult, readClientEntriesConfig, readExtraRuntimeExternals, resolveClientEntries, } from "./build.js";
+export { formatScanWarning, runCodegen } from "./codegen/index.js";
+export { createCrashTracker } from "./crash-tracker.js";
+export { runInitDeployCli } from "./init-deploy-cli.js";
+export { implicitAuthModeFeatureNames, resolveGeneratePath } from "./schema-check-core.js";

package/dist/cli.js

@@ -0,0 +1,9 @@
+// Surface used by the `bin/*.ts` entrypoints. The bins import this through
+// the package self-reference (`@cosmicdrift/kumiko-dev-server/cli`) so they
+// resolve to src in the workspace and to dist once installed from the
+// tarball, where `src` is not shipped.
+export { buildProdBundle, buildServerBundle, discoverServerEntry, formatBuildResult, formatServerBuildResult, readClientEntriesConfig, readExtraRuntimeExternals, resolveClientEntries, } from "./build.js";
+export { formatScanWarning, runCodegen } from "./codegen/index.js";
+export { createCrashTracker } from "./crash-tracker.js";
+export { runInitDeployCli } from "./init-deploy-cli.js";
+export { implicitAuthModeFeatureNames, resolveGeneratePath } from "./schema-check-core.js";

package/dist/codegen/index.d.ts

@@ -0,0 +1,4 @@
+export { renderDefineFile, renderInlineSchemasFile, renderTypesAugmentation, renderWriteHandlerTypes, } from "./render.js";
+export { type CodegenOptions, type CodegenResult, runCodegen } from "./run-codegen.js";
+export { formatScanWarning, qualifiedNameToConstName, rewriteImportPath, type ScannedEvent, type ScanOptions, type ScanResult, type ScanWarning, type SchemaSource, scanEvents, } from "./scan-events.js";
+export { type WatchHandle, type WatchOptions, watchAndRegenerate } from "./watch.js";

package/dist/codegen/index.js

@@ -0,0 +1,4 @@
+export { renderDefineFile, renderInlineSchemasFile, renderTypesAugmentation, renderWriteHandlerTypes, } from "./render.js";
+export { runCodegen } from "./run-codegen.js";
+export { formatScanWarning, qualifiedNameToConstName, rewriteImportPath, scanEvents, } from "./scan-events.js";
+export { watchAndRegenerate } from "./watch.js";

package/dist/codegen/render.d.ts

@@ -0,0 +1,55 @@
+import type { ScannedEvent } from "./scan-events.js";
+/**
+ * Start-of-block markers for the two handler-derived sections that
+ * `run-codegen.ts` may need to carry forward verbatim from a previous
+ * run (when the current run has no `handlerQns` to render a fresh
+ * block from). Each marker is always the last thing its renderer
+ * emits, so a caller can locate it in a previously-written file and
+ * slice from the marker to EOF to recover the whole block.
+ */
+export declare const WRITE_HANDLER_QN_MARKER = "// --- WriteHandlerQn (generated from live registry / feature-manifest.json) ---";
+export declare const TYPED_DISPATCHER_MARKER = "// --- TypedDispatcher (generated from live registry / feature-manifest.json) ---";
+/**
+ * Render `types.generated.d.ts`. Imports the schema-identifiers as
+ * type-only — sources can be either named exports of feature-events
+ * files (kind: "imported") or extracted const-exports of the
+ * co-generated schemas.generated.ts (kind: "inline"). Result is wired
+ * via `z.infer<typeof X>` into the augmentation. Empty events list →
+ * minimal but valid file (still augmentable, just no entries yet —
+ * useful first-time scaffold).
+ */
+export declare function renderTypesAugmentation(events: readonly ScannedEvent[], outputDirAbs: string): string;
+/**
+ * Render `schemas.generated.ts`. One `export const` per inline-schema
+ * event, named via the qualifiedName-derived stable identifier. The
+ * source-text of the original `z.*(...)` expression is replayed — we
+ * don't try to be cleverer than the zod compiler about reconstructing
+ * the schema. Returns undefined when no inline-schemas exist (so the
+ * runner can skip writing the file entirely).
+ */
+export declare function renderInlineSchemasFile(events: readonly ScannedEvent[], appRootAbs: string): string | undefined;
+/**
+ * Render `define.ts` — local thin wrappers that fix TMap to
+ * KumikoEventTypeMap. Apps import `defineWriteHandler` /
+ * `defineQueryHandler` from this file; framework's strict-overload
+ * becomes the only matching overload because TMap is no longer the
+ * eager-resolved default.
+ *
+ * The wrappers are intentionally *thin* — same signature as the
+ * framework's, just with TMap pre-bound. Apps stay portable: switch
+ * the import back to "@cosmicdrift/kumiko-framework/engine" and you're back on the
+ * loose default. Migration is reversible, no behavioural surface change.
+ */
+export declare function renderDefineFile(handlerQns?: readonly string[]): string;
+/**
+ * Render `WriteHandlerQn` type lines — exports a union of all registered
+ * write handler QNs so custom-screen code can type-check dispatcher.write
+ * calls at compile time:
+ *
+ *   ```ts
+ *   import type { WriteHandlerQn } from "@app/define";
+ *   dispatcher.write<WriteHandlerQn>("tenant:write:create", payload);  // ✓
+ *   dispatcher.write<WriteHandlerQn>("tenant:write:creat", payload);   // ✗ TS error
+ *   ```
+ */
+export declare function renderWriteHandlerTypes(handlerQns: readonly string[]): string;