@cosmicdrift/kumiko-dev-server 0.329.0 → 0.330.2

package/dist/scaffold-feature.js

@@ -0,0 +1,163 @@
+// scaffoldFeature — generate a fresh feature workspace from a name.
+// Used by `bun kumiko create <name>` and (later) by the Designer when
+// a tenant scaffolds a new feature inside their repo. Wraps the
+// canonical-form renderer (feature-ast/render.ts) so every freshly
+// scaffolded feature is born in canonical Object-Form with the
+// schema-version header set.
+//
+// The generated workspace is intentionally minimal: a single entity
+// pattern as a starter, so the user has something to point a "bun
+// kumiko dev" at and immediately see something on screen. Adding more
+// patterns is the user's job (or the Designer's / AI's, on top of this
+// scaffolding).
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { renderFeatureFile, } from "@cosmicdrift/kumiko-framework/engine";
+/**
+ * Generate a starter feature workspace at `destination`. Throws when
+ * the destination already exists — refuses to overwrite. The caller is
+ * expected to run `bun install` afterwards to wire the workspace.
+ */
+export function scaffoldFeature(options) {
+    const featureName = validateFeatureName(options.name);
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const kebab = camelToKebab(featureName);
+    const destination = resolve(options.destination
+        ? resolveDestination(options.destination, repoRoot)
+        : join(repoRoot, "samples", "recipes", kebab));
+    if (existsSync(destination)) {
+        throw new Error(`scaffoldFeature: destination already exists at ${destination} — refusing to overwrite`);
+    }
+    mkdirSync(join(destination, "src"), { recursive: true });
+    const packageName = `@cosmicdrift/kumiko-sample-${kebab}`;
+    const packageJson = renderPackageJson(packageName);
+    const packageJsonFile = join(destination, "package.json");
+    writeFileSync(packageJsonFile, packageJson);
+    const tsconfigFile = join(destination, "tsconfig.json");
+    writeFileSync(tsconfigFile, renderTsconfig());
+    const featureFile = join(destination, "src", "feature.ts");
+    const featureSource = renderFeatureFile({
+        featureName,
+        patterns: starterPatterns(),
+    });
+    writeFileSync(featureFile, featureSource);
+    return {
+        destination,
+        featureFile,
+        packageJsonFile,
+        tsconfigFile,
+        featureName,
+        packageName,
+    };
+}
+// =============================================================================
+// Internal — name + path validation
+// =============================================================================
+const RESERVED_WORDS = new Set([
+    // Subset of TS reserved words that would be confusing as feature names.
+    "default",
+    "delete",
+    "function",
+    "import",
+    "export",
+    "class",
+    "interface",
+    "enum",
+    "type",
+    "module",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "void",
+    "null",
+    "true",
+    "false",
+]);
+const NAME_RE = /^[a-z][A-Za-z0-9]*$/;
+function validateFeatureName(raw) {
+    if (!raw) {
+        throw new Error("scaffoldFeature: feature name is required");
+    }
+    if (!NAME_RE.test(raw)) {
+        throw new Error(`scaffoldFeature: "${raw}" is not a valid feature name — use camelCase starting with a lowercase letter (e.g. "todoList")`);
+    }
+    if (RESERVED_WORDS.has(raw)) {
+        throw new Error(`scaffoldFeature: "${raw}" is a reserved word and cannot be a feature name`);
+    }
+    return raw;
+}
+function camelToKebab(name) {
+    return name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function resolveDestination(dest, repoRoot) {
+    // Allow callers to pass either an absolute path or a repo-relative
+    // one — keep both ergonomic. `resolve(repoRoot, dest)` is a no-op for
+    // absolute paths.
+    return resolve(repoRoot, dest);
+}
+// =============================================================================
+// Internal — content generators
+// =============================================================================
+function renderPackageJson(packageName) {
+    return `${JSON.stringify({
+        name: packageName,
+        description: "Kumiko sample feature — scaffolded by `bun kumiko create`",
+        private: true,
+        dependencies: {
+            "@cosmicdrift/kumiko-framework": "workspace:*",
+        },
+    }, null, 2)}\n`;
+}
+/**
+ * Standard tsconfig matching the rest of the sample workspaces:
+ * strict, ESNext, bundler-resolution, no-emit. Without this file
+ * `bun install + tsc` immediately complains about missing config —
+ * scaffolded features should compile cleanly out of the box.
+ */
+function renderTsconfig() {
+    return `${JSON.stringify({
+        compilerOptions: {
+            strict: true,
+            noUncheckedIndexedAccess: true,
+            noPropertyAccessFromIndexSignature: true,
+            forceConsistentCasingInFileNames: true,
+            verbatimModuleSyntax: true,
+            target: "ESNext",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            esModuleInterop: true,
+            skipLibCheck: true,
+            lib: ["ESNext"],
+            types: ["bun-types"],
+            noEmit: true,
+        },
+        include: ["src/**/*"],
+    }, null, 2)}\n`;
+}
+// Synthetic SourceLocation — the renderer reads `.raw` only for opaque
+// (closure-bearing) bodies. Static patterns like `entity` don't touch
+// `source.raw` at render-time, so an empty placeholder is fine.
+const SYNTHETIC_LOC = {
+    file: "<scaffold>",
+    start: { line: 1, column: 1 },
+    end: { line: 1, column: 1 },
+    raw: "",
+};
+function starterPatterns() {
+    // One entity, one field. Smallest interesting output: parses, renders,
+    // can be `bun kumiko dev`'d, and gives the user something to extend.
+    return [
+        {
+            kind: "entity",
+            source: SYNTHETIC_LOC,
+            entityName: "item",
+            definition: {
+                fields: {
+                    title: { type: "text", required: true },
+                },
+            },
+        },
+    ];
+}

package/dist/schema-apply.d.ts

@@ -0,0 +1,11 @@
+import { type FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import { type ComposeFeaturesOptions } from "@cosmicdrift/kumiko-server-runtime/compose-features";
+export type SchemaApplyOptions = ComposeFeaturesOptions & {
+    /** App-Features (z.B. APP_FEATURES aus run-config) — composed mit den
+     *  bundled-Features für den Projection-Rebuild-Registry. */
+    readonly features: readonly FeatureDefinition[];
+    /** Default INIT_CWD ?? process.cwd(); Migrations unter <appCwd>/kumiko/migrations. */
+    readonly appCwd?: string;
+};
+export declare function runSchemaApply(opts: SchemaApplyOptions): Promise<number>;
+export declare function runStandaloneSchemaCli(opts: SchemaApplyOptions): Promise<never>;

package/dist/schema-apply.js

@@ -0,0 +1,95 @@
+// Standalone `kumiko schema apply` für Production-Bundles. Apps bündeln ein
+// dünnes bin/kumiko.ts das nur runStandaloneSchemaCli mit den App-Features
+// aufruft — die ganze Orchestrierung (Infra-Bootstrap, Migrations,
+// Projection-Rebuild) lebt hier statt als ~100-Zeilen-Boilerplate pro App.
+//
+// Der Pulumi-migrate-initContainer ruft `bun /app/kumiko.js schema apply`;
+// kumiko-build entdeckt das App-bin via findRepoRoot() und bündelt es.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createDbConnection, runMigrationsFromDir } from "@cosmicdrift/kumiko-framework/db";
+import { createRegistry } from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import { queueRebuildsFromMarkers, runPendingRebuilds, } from "@cosmicdrift/kumiko-framework/migrations";
+import { createEventConsumerStateTable, createProjectionStateTable, } from "@cosmicdrift/kumiko-framework/pipeline";
+import { composeFeatures, } from "@cosmicdrift/kumiko-server-runtime/compose-features";
+export async function runSchemaApply(opts) {
+    const dbUrl = process.env["DATABASE_URL"];
+    if (!dbUrl) {
+        console.error("\n  DATABASE_URL not set.\n");
+        return 1;
+    }
+    const appCwd = opts.appCwd ?? process.env["INIT_CWD"] ?? process.cwd();
+    const migrationsDir = join(appCwd, "kumiko/migrations");
+    if (!existsSync(migrationsDir)) {
+        console.error(`\n  ${migrationsDir} fehlt — kumiko/migrations/ muss im Image liegen.\n`);
+        return 1;
+    }
+    const { db, close } = createDbConnection(dbUrl);
+    try {
+        // Infra-Tabellen (event-store + pipeline-state) zuerst, alle
+        // tableExists-gated idempotent: auf einer Bestands-DB no-op, auf einer
+        // leeren Greenfield-DB legen sie kumiko_events/_consumers/_projections an
+        // bevor die App-Migrations dagegen laufen. Ohne das bricht eine leere DB
+        // (z.B. cashcolt auf frischem CNPG) an `relation "kumiko_events" does not exist`.
+        console.log("\n  Lege Framework-Infra-Tabellen an (idempotent)…");
+        await createEventsTable(db);
+        await createEventConsumerStateTable(db);
+        await createProjectionStateTable(db);
+        console.log(`  Wende kumiko-Migrations an (${migrationsDir})…`);
+        const result = await runMigrationsFromDir(db, migrationsDir);
+        if (result.applied.length === 0) {
+            console.log(`\n  ✓ All ${result.skipped.length} migrations already applied.\n`);
+        }
+        else {
+            console.log(`\n  ✓ Applied ${result.applied.length}:`);
+            for (const id of result.applied)
+                console.log(`    + ${id}`);
+            if (result.skipped.length > 0)
+                console.log(`  (${result.skipped.length} already applied)`);
+            console.log("");
+        }
+        // Projection rebuild: persistent queue instead of "only this run's
+        // result.applied" — otherwise a failed rebuild stays silently stuck
+        // forever, since the migration is already tracked applied and gets
+        // skipped on the next apply (#2464). queueRebuildsFromMarkers persists
+        // the marker tables BEFORE the rebuild; runPendingRebuilds unconditionally
+        // also picks up open entries from earlier, failed runs — not just the
+        // ones this run freshly applied.
+        const thisRunTables = await queueRebuildsFromMarkers(db, {
+            migrationsDir,
+            appliedIds: result.applied,
+        });
+        const registry = createRegistry(composeFeatures([...opts.features], opts));
+        const rebuildRun = await runPendingRebuilds(db, registry, { thisRunTables });
+        if (rebuildRun.rebuilt.length > 0) {
+            console.log(`  Rebuild ${rebuildRun.rebuilt.length} Projection(s)…`);
+            for (const r of rebuildRun.rebuilt) {
+                console.log(`    ↻ ${r.projection} (${r.eventsProcessed} events)`);
+            }
+            console.log("");
+        }
+        if (rebuildRun.failed.length > 0) {
+            throw new Error(`Projection rebuild failed for: ${rebuildRun.failed
+                .map((f) => `${f.projection} (${f.error})`)
+                .join("; ")}. Table(s) stay queued in kumiko_pending_rebuilds — retried on the next apply.`);
+        }
+        return 0;
+    }
+    catch (e) {
+        console.error(`\n  ✗ ${e instanceof Error ? (e.stack ?? e.message) : String(e)}\n`);
+        return 1;
+    }
+    finally {
+        await close();
+    }
+}
+export async function runStandaloneSchemaCli(opts) {
+    const cmd = Bun.argv[2];
+    const sub = Bun.argv[3];
+    if (cmd === "schema" && sub === "apply") {
+        process.exit(await runSchemaApply(opts));
+    }
+    console.error(`\n  Unbekannt: kumiko ${cmd ?? ""} ${sub ?? ""}\n  Nur 'kumiko schema apply' im Standalone-Bundle.\n`);
+    process.exit(1);
+}

package/dist/schema-check-core.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveGeneratePath(cwd: string): string;
+export declare function implicitAuthModeFeatureNames(): readonly string[];

package/{src/schema-check-core.ts → dist/schema-check-core.js}

@@ -1,26 +1,24 @@
 // Pure helpers for the `kumiko-schema-check` bin. Kept in src/ (vs. the bin)
 // so they are part of the tsc project + unit-testable without importing the
 // auto-running CLI.
-
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { composeFeatures } from "@cosmicdrift/kumiko-server-runtime/compose-features";
-
 // The generate-script lives under different roots across apps: publicstatus
 // uses `drizzle/generate.ts`, the framework's own sample-apps use
 // `schema/generate.ts`. Pick whichever exists so a no-arg `bunx
 // kumiko-schema-check` works in both layouts; default to `drizzle/` for the
 // error message when neither is present.
-export function resolveGeneratePath(cwd: string): string {
-  const drizzlePath = resolve(cwd, "drizzle/generate.ts");
-  const schemaPath = resolve(cwd, "schema/generate.ts");
-  if (!existsSync(drizzlePath) && existsSync(schemaPath)) return schemaPath;
-  return drizzlePath;
+export function resolveGeneratePath(cwd) {
+    const drizzlePath = resolve(cwd, "drizzle/generate.ts");
+    const schemaPath = resolve(cwd, "schema/generate.ts");
+    if (!existsSync(drizzlePath) && existsSync(schemaPath))
+        return schemaPath;
+    return drizzlePath;
 }
-
 // The features composeFeatures auto-prepends in auth-mode (config + user +
 // tenant + auth-email-password). Derived from composeFeatures itself so this
 // can't drift from the real prepend-list in compose-features.ts.
-export function implicitAuthModeFeatureNames(): readonly string[] {
-  return composeFeatures([], { includeBundled: true }).map((f) => f.name);
+export function implicitAuthModeFeatureNames() {
+    return composeFeatures([], { includeBundled: true }).map((f) => f.name);
 }

package/dist/schema-tables-auth-mode.d.ts

@@ -0,0 +1,2 @@
+export { archivedStreamsTable, eventsTable, snapshotsTable, } from "@cosmicdrift/kumiko-framework/event-store";
+export { eventConsumerStateTable, projectionStateTable, } from "@cosmicdrift/kumiko-framework/pipeline";

package/{src/schema-tables-auth-mode.ts → dist/schema-tables-auth-mode.js}

@@ -19,14 +19,6 @@
 //
 // (Datei-Name "auth-mode" ist historisch — heute ist der Inhalt reine
 // Framework-Infra. Umbenennen ist breaking change für App-Imports.)
-
 // Framework-Infra (immer da, unabhängig von Features)
-export {
-  archivedStreamsTable,
-  eventsTable,
-  snapshotsTable,
-} from "@cosmicdrift/kumiko-framework/event-store";
-export {
-  eventConsumerStateTable,
-  projectionStateTable,
-} from "@cosmicdrift/kumiko-framework/pipeline";
+export { archivedStreamsTable, eventsTable, snapshotsTable, } from "@cosmicdrift/kumiko-framework/event-store";
+export { eventConsumerStateTable, projectionStateTable, } from "@cosmicdrift/kumiko-framework/pipeline";

package/dist/schema-tables-minimal.d.ts

@@ -0,0 +1,2 @@
+export { archivedStreamsTable, eventsTable, snapshotsTable, upcasterDeadLetterTable, } from "@cosmicdrift/kumiko-framework/event-store";
+export { eventConsumerStateTable, projectionStateTable, } from "@cosmicdrift/kumiko-framework/pipeline";

package/{src/schema-tables-minimal.ts → dist/schema-tables-minimal.js}

@@ -9,14 +9,5 @@
 //
 // Wer Auth-Tables will, nutzt drizzle-tables-auth-mode (umfasst Minimal
 // plus Bundle-Tables für Config, Tenant, User, Sessions).
-
-export {
-  archivedStreamsTable,
-  eventsTable,
-  snapshotsTable,
-  upcasterDeadLetterTable,
-} from "@cosmicdrift/kumiko-framework/event-store";
-export {
-  eventConsumerStateTable,
-  projectionStateTable,
-} from "@cosmicdrift/kumiko-framework/pipeline";
+export { archivedStreamsTable, eventsTable, snapshotsTable, upcasterDeadLetterTable, } from "@cosmicdrift/kumiko-framework/event-store";
+export { eventConsumerStateTable, projectionStateTable, } from "@cosmicdrift/kumiko-framework/pipeline";

package/dist/setup-test-stack-from-features.d.ts

@@ -0,0 +1,11 @@
+import type { FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import { type TestStack, type TestStackOptions } from "@cosmicdrift/kumiko-framework/stack";
+import { type ComposeFeaturesOptions } from "@cosmicdrift/kumiko-server-runtime/compose-features";
+export type TestStackPreset = "config" | "template-resolver";
+export type SetupTestStackFromFeaturesOptions = Omit<TestStackOptions, "features"> & {
+    readonly includeBundled?: boolean;
+    readonly authOptions?: ComposeFeaturesOptions["authOptions"];
+    readonly presets?: readonly TestStackPreset[];
+};
+export declare function mergeExtraContext(base: TestStackOptions["extraContext"], presets: readonly TestStackPreset[]): TestStackOptions["extraContext"];
+export declare function setupTestStackFromFeatures(appFeatures: readonly FeatureDefinition[], options?: SetupTestStackFromFeaturesOptions): Promise<TestStack>;

package/dist/setup-test-stack-from-features.js

@@ -0,0 +1,42 @@
+// Test helper: composeFeatures + setupTestStack in one call.
+// Apps pass the same feature list as run-config (APP_FEATURES / buildAppFeatures).
+import { createConfigResolver, } from "@cosmicdrift/kumiko-bundled-features/config";
+import { createTemplateResolverApi } from "@cosmicdrift/kumiko-bundled-features/template-resolver";
+import { setupTestStack, } from "@cosmicdrift/kumiko-framework/stack";
+import { jobRunLoggerCallbacks } from "@cosmicdrift/kumiko-server-runtime/boot/job-run-logger";
+import { composeFeatures, } from "@cosmicdrift/kumiko-server-runtime/compose-features";
+import { addConfigAccessorFactory } from "@cosmicdrift/kumiko-server-runtime/run-prod-app";
+export function mergeExtraContext(base, presets) {
+    if (presets.length === 0)
+        return base;
+    return (deps) => {
+        const fromBase = typeof base === "function" ? base(deps) : base !== undefined ? { ...base } : {};
+        const merged = { ...fromBase };
+        if (presets.includes("config")) {
+            // Same precedence as mergeConfigResolverDefault (run-dev-app.ts) — a base-supplied resolver wins, factory always derives from it (fw#3313).
+            const configResolver = fromBase["configResolver"] ?? createConfigResolver();
+            Object.assign(merged, addConfigAccessorFactory({ configResolver }, deps.registry));
+        }
+        if (presets.includes("template-resolver")) {
+            merged["templateResolver"] = createTemplateResolverApi(deps.db);
+        }
+        return merged;
+    };
+}
+export async function setupTestStackFromFeatures(appFeatures, options = {}) {
+    const { includeBundled = false, authOptions, presets = [], ...stackOptions } = options;
+    const features = composeFeatures(appFeatures, { includeBundled, authOptions });
+    const extraContext = mergeExtraContext(stackOptions.extraContext, presets);
+    // Same run-logger wiring as prod, so jobs that declare tenantVisibleFailure
+    // write their failure rows in tests too.
+    const defaultRunLogger = ({ registry, db, }) => jobRunLoggerCallbacks(registry, db);
+    const jobs = stackOptions.jobs === undefined
+        ? undefined
+        : { runLogger: defaultRunLogger, ...stackOptions.jobs };
+    return setupTestStack({
+        ...stackOptions,
+        ...(jobs !== undefined && { jobs }),
+        features,
+        ...(extraContext !== undefined && { extraContext }),
+    });
+}

package/dist/welcome-banner.d.ts

@@ -0,0 +1,15 @@
+export type WelcomeBannerInput = {
+    /** Resolved listen-URL (`http://localhost:3000`). */
+    readonly url: string;
+    /** Login the seeded admin uses (from runDevApp options.auth.admin). */
+    readonly admin?: {
+        readonly email: string;
+        readonly password: string;
+    };
+    /** Hot-reload hint shown in the "add a feature" line. Defaults to
+     *  `src/features/`. */
+    readonly featuresDir?: string;
+    /** Custom docs URL — defaults to the public docs site. */
+    readonly docsUrl?: string;
+};
+export declare function renderWelcomeBanner(input: WelcomeBannerInput): string;

package/dist/welcome-banner.js

@@ -0,0 +1,27 @@
+// First-run welcome banner for `runDevApp({ welcomeBanner: true })`.
+// Opt-in only — `bun dev` should not normalize this for apps that
+// already log their own startup. Scaffolded apps (create-kumiko-app)
+// flip it on so the first `bun dev` doesn't end on "Server läuft" with
+// the user wondering where to click.
+export function renderWelcomeBanner(input) {
+    const featuresDir = input.featuresDir ?? "src/features/";
+    const docsUrl = input.docsUrl ?? "https://docs.kumiko.rocks/quickstart";
+    const lines = [];
+    lines.push(`✓ kumiko-app läuft`);
+    lines.push(`→ Browser:        ${input.url}`);
+    if (input.admin) {
+        lines.push(`→ Login als:      ${input.admin.email} / ${input.admin.password}`);
+    }
+    lines.push(`→ Feature add:    edit ${featuresDir}`);
+    lines.push(`→ Docs:           ${docsUrl}`);
+    const innerWidth = Math.max(...lines.map((l) => stringWidth(l)));
+    const border = "─".repeat(innerWidth + 2);
+    const top = `┌${border}┐`;
+    const bottom = `└${border}┘`;
+    const padded = lines.map((l) => `│ ${l}${" ".repeat(innerWidth - stringWidth(l))} │`);
+    return [top, ...padded, bottom].join("\n");
+}
+// ponytail: codepoint width; ok for ASCII + arrows, add a width-lib if CJK ever lands here.
+function stringWidth(s) {
+    return [...s].length;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.329.0",
+  "version": "0.330.2",
   "description": "Dev-tooling for Kumiko apps: local dev-server bootstrap (runDevApp), scaffolding, codegen. Its compose-stacks/env-schema subpaths are consumed at prod boot too — see @cosmicdrift/kumiko-server-runtime for the prod runner itself.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -19,36 +19,40 @@
   },
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./build": {
-      "types": "./src/build.ts",
-      "default": "./src/build.ts"
+      "types": "./dist/build.d.ts",
+      "default": "./dist/build.js"
     },
     "./compose-stacks": {
-      "types": "./src/compose-stacks.ts",
-      "default": "./src/compose-stacks.ts"
+      "types": "./dist/compose-stacks.d.ts",
+      "default": "./dist/compose-stacks.js"
     },
     "./env-schema": {
-      "types": "./src/env-schema.ts",
-      "default": "./src/env-schema.ts"
+      "types": "./dist/env-schema.d.ts",
+      "default": "./dist/env-schema.js"
     },
     "./setup-test-stack-from-features": {
-      "types": "./src/setup-test-stack-from-features.ts",
-      "default": "./src/setup-test-stack-from-features.ts"
+      "types": "./dist/setup-test-stack-from-features.d.ts",
+      "default": "./dist/setup-test-stack-from-features.js"
     },
     "./schema-apply": {
-      "types": "./src/schema-apply.ts",
-      "default": "./src/schema-apply.ts"
+      "types": "./dist/schema-apply.d.ts",
+      "default": "./dist/schema-apply.js"
     },
     "./schema-tables-auth-mode": {
-      "types": "./src/schema-tables-auth-mode.ts",
-      "default": "./src/schema-tables-auth-mode.ts"
+      "types": "./dist/schema-tables-auth-mode.d.ts",
+      "default": "./dist/schema-tables-auth-mode.js"
     },
     "./schema-tables-minimal": {
-      "types": "./src/schema-tables-minimal.ts",
-      "default": "./src/schema-tables-minimal.ts"
+      "types": "./dist/schema-tables-minimal.d.ts",
+      "default": "./dist/schema-tables-minimal.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
     }
   },
   "bin": {
@@ -60,19 +64,62 @@
     "kumiko-upgrade": "./bin/kumiko-upgrade.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.329.0",
-    "@cosmicdrift/kumiko-framework": "0.329.0",
-    "@cosmicdrift/kumiko-headless": "0.329.0",
-    "@cosmicdrift/kumiko-server-runtime": "0.329.0",
-    "ts-morph": "^28.0.0"
+    "@cosmicdrift/kumiko-bundled-features": "0.330.2",
+    "@cosmicdrift/kumiko-framework": "0.330.2",
+    "@cosmicdrift/kumiko-headless": "0.330.2",
+    "@cosmicdrift/kumiko-renderer-web": "0.330.2",
+    "@cosmicdrift/kumiko-server-runtime": "0.330.2",
+    "bun-types": "^1.3.13",
+    "ts-morph": "^28.0.0",
+    "zod": "^4.4.3"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./build": {
+        "types": "./dist/build.d.ts",
+        "default": "./dist/build.js"
+      },
+      "./compose-stacks": {
+        "types": "./dist/compose-stacks.d.ts",
+        "default": "./dist/compose-stacks.js"
+      },
+      "./env-schema": {
+        "types": "./dist/env-schema.d.ts",
+        "default": "./dist/env-schema.js"
+      },
+      "./setup-test-stack-from-features": {
+        "types": "./dist/setup-test-stack-from-features.d.ts",
+        "default": "./dist/setup-test-stack-from-features.js"
+      },
+      "./schema-apply": {
+        "types": "./dist/schema-apply.d.ts",
+        "default": "./dist/schema-apply.js"
+      },
+      "./schema-tables-auth-mode": {
+        "types": "./dist/schema-tables-auth-mode.d.ts",
+        "default": "./dist/schema-tables-auth-mode.js"
+      },
+      "./schema-tables-minimal": {
+        "types": "./dist/schema-tables-minimal.d.ts",
+        "default": "./dist/schema-tables-minimal.js"
+      },
+      "./cli": {
+        "types": "./dist/cli.d.ts",
+        "default": "./dist/cli.js"
+      }
+    }
   },
   "files": [
-    "src",
+    "dist",
+    "bin",
     "templates",
+    "src/changes.json",
     "README.md",
     "LICENSE"
   ]

package/src/changes.json

@@ -1,4 +1,10 @@
 [
+  {
+    "version": "0.330.0",
+    "type": "improvement",
+    "title": "kumiko-server-runtime and kumiko-dev-server are published as compiled JavaScript plus .d.ts",
+    "detail": "Both packages now ship `dist` (`.js` and `.d.ts`) instead of TypeScript source. Export keys are unchanged; only the targets behind them move to `dist`. `kumiko-dev-server` keeps its `bin/*.ts` entrypoints (they still need Bun) and ships them together with `templates`; they now import through the new `@cosmicdrift/kumiko-dev-server/cli` export instead of reaching into `src`. `kumiko-server-runtime` now declares `ioredis` and `kumiko-dev-server` declares `zod` as dependencies, which their code already imported. `ioredis` is imported as a named `{ Redis }` so the class resolves under Node's ESM loader."
+  },
   {
     "version": "0.328.0",
     "type": "improvement",