@cosmicdrift/kumiko-dev-server 0.329.0 → 0.330.2

package/src/__tests__/scaffold-feature.test.ts

@@ -1,143 +0,0 @@
-// scaffoldFeature tests — verify the CLI's `create` subcommand produces
-// a valid, parsable feature workspace. Strategy: scaffold into an
-// in-tmpdir destination, then read the output back and assert:
-//   1. package.json shape (workspace name, framework dep)
-//   2. feature.ts is parsable by the canonical-form parser without
-//      ParseErrors and contains the Schema-Version-Header
-//   3. featureName extracted by the parser matches what was scaffolded
-//   4. Validation: bad names fail loudly, existing destination refuses
-//      to overwrite
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parseSourceFile, VERSION_HEADER } from "@cosmicdrift/kumiko-framework/engine";
-import { Project } from "ts-morph";
-import { scaffoldFeature } from "../scaffold-feature";
-
-let workdir: string;
-
-beforeEach(() => {
-  workdir = mkdtempSync(join(tmpdir(), "kumiko-scaffold-"));
-});
-
-afterEach(() => {
-  rmSync(workdir, { recursive: true, force: true });
-});
-
-describe("scaffoldFeature — output shape", () => {
-  test("creates package.json + tsconfig.json + src/feature.ts at the resolved destination", () => {
-    const result = scaffoldFeature({
-      name: "todoList",
-      destination: join(workdir, "todoList"),
-    });
-    expect(existsSync(result.packageJsonFile)).toBe(true);
-    expect(existsSync(result.tsconfigFile)).toBe(true);
-    expect(existsSync(result.featureFile)).toBe(true);
-    expect(result.featureName).toBe("todoList");
-    expect(result.packageName).toBe("@cosmicdrift/kumiko-sample-todo-list");
-  });
-
-  test("tsconfig.json is strict + bundler-resolution + no-emit", () => {
-    const result = scaffoldFeature({
-      name: "todoList",
-      destination: join(workdir, "todoList"),
-    });
-    const tsconfig = JSON.parse(readFileSync(result.tsconfigFile, "utf8"));
-    expect(tsconfig.compilerOptions.strict).toBe(true);
-    expect(tsconfig.compilerOptions.noUncheckedIndexedAccess).toBe(true);
-    expect(tsconfig.compilerOptions.moduleResolution).toBe("bundler");
-    expect(tsconfig.compilerOptions.noEmit).toBe(true);
-    expect(tsconfig.include).toEqual(["src/**/*"]);
-  });
-
-  test("package.json has workspace name + framework dep", () => {
-    const result = scaffoldFeature({
-      name: "todoList",
-      destination: join(workdir, "todoList"),
-    });
-    const pkg = JSON.parse(readFileSync(result.packageJsonFile, "utf8"));
-    expect(pkg.name).toBe("@cosmicdrift/kumiko-sample-todo-list");
-    expect(pkg.private).toBe(true);
-    expect(pkg.dependencies["@cosmicdrift/kumiko-framework"]).toBe("workspace:*");
-  });
-
-  test("feature.ts starts with the schema-version header", () => {
-    const result = scaffoldFeature({
-      name: "todoList",
-      destination: join(workdir, "todoList"),
-    });
-    const source = readFileSync(result.featureFile, "utf8");
-    expect(source.startsWith(VERSION_HEADER)).toBe(true);
-  });
-
-  test("scaffolded feature.ts parses cleanly with no errors", () => {
-    const result = scaffoldFeature({
-      name: "todoList",
-      destination: join(workdir, "todoList"),
-    });
-    const source = readFileSync(result.featureFile, "utf8");
-    const project = new Project({
-      skipAddingFilesFromTsConfig: true,
-      skipFileDependencyResolution: true,
-      useInMemoryFileSystem: true,
-    });
-    const sf = project.createSourceFile("scaffolded.ts", source);
-    const parsed = parseSourceFile(sf);
-    expect(parsed.errors).toEqual([]);
-    expect(parsed.featureName).toBe("todoList");
-    expect(parsed.patterns.length).toBeGreaterThan(0);
-    // Starter pattern is an entity, so the user has something to extend.
-    expect(parsed.patterns[0]?.kind).toBe("entity");
-  });
-});
-
-describe("scaffoldFeature — name validation", () => {
-  test("rejects empty name", () => {
-    expect(() => scaffoldFeature({ name: "", destination: join(workdir, "x") })).toThrow(
-      /feature name is required/,
-    );
-  });
-
-  test("rejects PascalCase / dashes / numbers-first", () => {
-    expect(() => scaffoldFeature({ name: "TodoList", destination: join(workdir, "a") })).toThrow(
-      /not a valid feature name/,
-    );
-    expect(() => scaffoldFeature({ name: "todo-list", destination: join(workdir, "b") })).toThrow(
-      /not a valid feature name/,
-    );
-    expect(() => scaffoldFeature({ name: "1todo", destination: join(workdir, "c") })).toThrow(
-      /not a valid feature name/,
-    );
-  });
-
-  test("rejects reserved words", () => {
-    expect(() => scaffoldFeature({ name: "delete", destination: join(workdir, "d") })).toThrow(
-      /reserved word/,
-    );
-  });
-});
-
-describe("scaffoldFeature — destination handling", () => {
-  test("default destination falls under repoRoot/samples/recipes/<kebab>", () => {
-    const result = scaffoldFeature({ name: "todoList", repoRoot: workdir });
-    expect(result.destination).toBe(join(workdir, "samples", "recipes", "todo-list"));
-  });
-
-  test("refuses to overwrite an existing destination", () => {
-    const dest = join(workdir, "todoList");
-    scaffoldFeature({ name: "todoList", destination: dest });
-    expect(() => scaffoldFeature({ name: "todoList", destination: dest })).toThrow(
-      /already exists/,
-    );
-  });
-
-  test("camelCase name → kebab-case directory + package suffix", () => {
-    const result = scaffoldFeature({
-      name: "userProfileCustomization",
-      destination: join(workdir, "userProfileCustomization"),
-    });
-    expect(result.packageName).toBe("@cosmicdrift/kumiko-sample-user-profile-customization");
-  });
-});

package/src/__tests__/schema-apply.integration.test.ts

@@ -1,191 +0,0 @@
-// Production-Behavior von `kumiko schema apply` (runSchemaApply): der
-// migrate-initContainer ruft das gegen eine frische CNPG-DB. Der riskante,
-// neue Teil gegenüber dem alten per-App-Boilerplate ist der Greenfield-
-// Bootstrap — Infra-Tabellen (event-store + pipeline-state) MÜSSEN vor den
-// App-Migrations idempotent angelegt werden, sonst bricht eine leere DB an
-// `relation "kumiko_events" does not exist`. Dieser Test fährt den echten
-// Pfad gegen eine leere DB + den idempotenten Re-Run.
-
-import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  asRawClient,
-  buildEntityTable,
-  createDbConnection,
-  createEventStoreExecutor,
-  createTenantDb,
-  type DbConnection,
-  integer,
-  table as pgTable,
-  selectMany,
-  tableExists,
-  uuid,
-} from "@cosmicdrift/kumiko-framework/db";
-import {
-  createEntity,
-  createTextField,
-  defineApply,
-  defineFeature,
-  type ProjectionDefinition,
-} from "@cosmicdrift/kumiko-framework/engine";
-import {
-  createTestDb,
-  type TestDb,
-  TestUsers,
-  unsafeCreateEntityTable,
-  unsafePushTables,
-} from "@cosmicdrift/kumiko-framework/stack";
-import { runSchemaApply } from "../schema-apply";
-
-let testDb: TestDb;
-let conn: { readonly db: DbConnection; readonly close: () => Promise<void> };
-let appCwd: string;
-let migDir: string;
-const savedDbUrl = process.env["DATABASE_URL"];
-
-const APPLY = { features: [], includeBundled: false } as const;
-
-beforeAll(async () => {
-  const base = process.env["TEST_DATABASE_URL"];
-  if (!base) throw new Error("TEST_DATABASE_URL required for schema-apply integration test");
-
-  testDb = await createTestDb();
-  const testUrl = base.replace(/\/[^/]+$/, `/${testDb.dbName}`);
-  process.env["DATABASE_URL"] = testUrl;
-  conn = createDbConnection(testUrl);
-
-  // Greenfield erzwingen: createTestDb legt kumiko_events bereits an —
-  // wegdroppen, damit runSchemaApply den Infra-Bootstrap echt durchläuft.
-  const raw = asRawClient(conn.db);
-  await raw.unsafe(`DROP TABLE IF EXISTS "kumiko_events" CASCADE`);
-  await raw.unsafe(`DROP TABLE IF EXISTS "kumiko_event_consumers" CASCADE`);
-  await raw.unsafe(`DROP TABLE IF EXISTS "kumiko_projections" CASCADE`);
-  await raw.unsafe(`DROP TABLE IF EXISTS "_kumiko_migrations" CASCADE`);
-
-  appCwd = mkdtempSync(join(tmpdir(), "kumiko-schema-apply-"));
-  migDir = join(appCwd, "kumiko", "migrations");
-  mkdirSync(migDir, { recursive: true });
-  writeFileSync(
-    join(migDir, "0001_init.sql"),
-    `CREATE TABLE "read_thing" ("id" text PRIMARY KEY);`,
-  );
-});
-
-afterAll(async () => {
-  await conn?.close();
-  await testDb?.cleanup();
-  if (appCwd) rmSync(appCwd, { recursive: true, force: true });
-  if (savedDbUrl === undefined) delete process.env["DATABASE_URL"];
-  else process.env["DATABASE_URL"] = savedDbUrl;
-});
-
-describe("runSchemaApply", () => {
-  test("Greenfield: leere DB → Infra-Tabellen + App-Migration appliziert → 0", async () => {
-    expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
-
-    expect(await tableExists(conn.db, "public.kumiko_events")).toBe(true);
-    expect(await tableExists(conn.db, "public.kumiko_event_consumers")).toBe(true);
-    expect(await tableExists(conn.db, "public.kumiko_projections")).toBe(true);
-    expect(await tableExists(conn.db, "public.read_thing")).toBe(true);
-  });
-
-  test("Re-Run auf Bestands-DB ist idempotent → 0 (Infra no-op, Migrations skipped)", async () => {
-    expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
-    expect(await tableExists(conn.db, "public.read_thing")).toBe(true);
-  });
-
-  test("rebuild-Marker für nicht-registrierte Tabelle → kein Crash, 0, aber laut warnen (522/3, #2464)", async () => {
-    writeFileSync(
-      join(migDir, "0002_more.sql"),
-      `CREATE TABLE "read_more" ("id" text PRIMARY KEY);`,
-    );
-    writeFileSync(
-      join(migDir, "0002_more.rebuild.json"),
-      JSON.stringify({ version: 1, tables: ["read_more"] }),
-    );
-
-    // runPendingRebuilds (not the old local helper) owns this warning now —
-    // it logs via createFallbackLogger(...).error(...), not console.warn.
-    const error = spyOn(console, "error").mockImplementation(() => {});
-    expect(await runSchemaApply({ ...APPLY, appCwd })).toBe(0);
-    expect(await tableExists(conn.db, "public.read_more")).toBe(true);
-    expect(error).toHaveBeenCalledWith(expect.stringContaining("read_more"), expect.anything());
-    error.mockRestore();
-  });
-
-  test("failed projection rebuild stays queued and is retried on a later apply with zero new migrations (#2464)", async () => {
-    // Isolate from any pending-rebuild rows the earlier tests in this file left.
-    await asRawClient(conn.db).unsafe(`DROP TABLE IF EXISTS kumiko_pending_rebuilds`);
-
-    const groupId = "00000000-0000-4000-8000-0000000000b1";
-    let failApply = true;
-
-    const failItemEntity = createEntity({
-      table: "read_apply_fail_items",
-      fields: {
-        groupId: createTextField({ personal: false, reason: "test_fixture", required: true }),
-        name: createTextField({ personal: false, reason: "test_fixture", required: true }),
-      },
-    });
-    const failItemTable = buildEntityTable("apply-fail-item", failItemEntity);
-    const failCountsTable = pgTable("read_apply_fail_counts", {
-      groupId: uuid("group_id").primaryKey(),
-      tenantId: uuid("tenant_id").notNull(),
-      itemCount: integer("item_count").notNull().default(0),
-    });
-    const failCountsProjection: ProjectionDefinition = {
-      name: "apply-fail-counts",
-      source: "apply-fail-item",
-      table: failCountsTable,
-      apply: {
-        "apply-fail-item.created": defineApply<{ groupId: string }>(async (event, tx) => {
-          if (failApply) throw new Error("simulated rebuild failure (test)");
-          await asRawClient(tx).unsafe(
-            `INSERT INTO "read_apply_fail_counts" (group_id, tenant_id, item_count) VALUES ($1::uuid, $2::uuid, 1)
-             ON CONFLICT (group_id) DO UPDATE SET item_count = read_apply_fail_counts.item_count + 1`,
-            [event.payload.groupId, event.tenantId],
-          );
-        }),
-      },
-    };
-    const feature = defineFeature("applyfailtest", (r) => {
-      r.entity("apply-fail-item", failItemEntity);
-      r.projection(failCountsProjection);
-    });
-
-    await unsafeCreateEntityTable(conn.db, failItemEntity, "apply-fail-item");
-    await unsafePushTables(conn.db, { readApplyFailCounts: failCountsTable });
-
-    const tdb = createTenantDb(conn.db, TestUsers.admin.tenantId);
-    const executor = createEventStoreExecutor(failItemTable, failItemEntity, {
-      entityName: "apply-fail-item",
-    });
-    await executor.create({ groupId, name: "x" }, TestUsers.admin, tdb);
-
-    writeFileSync(join(migDir, "0003_touch_fail_counts.sql"), "SELECT 1;\n");
-    writeFileSync(
-      join(migDir, "0003_touch_fail_counts.rebuild.json"),
-      JSON.stringify({ version: 1, tables: ["read_apply_fail_counts"] }),
-    );
-
-    const error = spyOn(console, "error").mockImplementation(() => {});
-    const firstRun = await runSchemaApply({ features: [feature], includeBundled: false, appCwd });
-    error.mockRestore();
-    // Fail-loud: a failed rebuild must surface as a non-zero exit, not a
-    // silent 0 — the migration itself is now tracked applied, so without a
-    // persisted queue this table's rebuild would never be retried again.
-    expect(firstRun).toBe(1);
-    const [rowAfterFail] = await selectMany(conn.db, failCountsTable, { groupId });
-    expect(rowAfterFail).toBeUndefined();
-
-    // Second apply: no new migrations (0003 is already tracked), yet the
-    // queued table must still be retried from kumiko_pending_rebuilds.
-    failApply = false;
-    const secondRun = await runSchemaApply({ features: [feature], includeBundled: false, appCwd });
-    expect(secondRun).toBe(0);
-    const [rowAfterRetry] = await selectMany(conn.db, failCountsTable, { groupId });
-    expect(rowAfterRetry?.itemCount).toBe(1);
-  });
-});

package/src/__tests__/setup-test-stack-from-features.integration.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { setupTestStackFromFeatures } from "../setup-test-stack-from-features";
-
-const noopFeature = defineFeature("noop-app", () => {});
-
-describe("setupTestStackFromFeatures", () => {
-  test("includeBundled prepends config/user/tenant/auth", async () => {
-    const stack = await setupTestStackFromFeatures([noopFeature], { includeBundled: true });
-    try {
-      for (const name of ["config", "user", "tenant", "auth-email-password", "noop-app"]) {
-        expect(stack.registry.getFeature(name)).toBeDefined();
-      }
-    } finally {
-      await stack.cleanup();
-    }
-  });
-
-  test("config preset wires configResolver in extraContext", async () => {
-    const stack = await setupTestStackFromFeatures([noopFeature], {
-      includeBundled: true,
-      presets: ["config"],
-    });
-    try {
-      expect(stack.registry.getFeature("config")).toBeDefined();
-    } finally {
-      await stack.cleanup();
-    }
-  });
-});

package/src/__tests__/setup-test-stack-job-run-logger.integration.test.ts

@@ -1,72 +0,0 @@
-// setupTestStackFromFeatures wires prod's job run-logger by default: a job
-// declared with tenantVisibleFailure records its final failure per tenant, and
-// drainJobs() only rejects after that row is written.
-
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { createJobsFeature, JobQueries } from "@cosmicdrift/kumiko-bundled-features/jobs";
-import { defineFeature, defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
-import { createTestUser, type TestStack, testTenantId } from "@cosmicdrift/kumiko-framework/stack";
-import * as z from "zod";
-import { setupTestStackFromFeatures } from "../setup-test-stack-from-features";
-
-const FAILURE_KEY = "app:errors.generationFailed";
-const PROVIDER_MESSAGE = "provider 429: prompt with customer data rejected";
-
-const tenantA = testTenantId(1);
-const tenantB = testTenantId(2);
-const userA = createTestUser({ id: 1, tenantId: tenantA, roles: ["Admin"] });
-const userB = createTestUser({ id: 2, tenantId: tenantB, roles: ["Admin"] });
-
-const appFeature = defineFeature("app", (r) => {
-  r.writeHandler(
-    defineWriteHandler({
-      name: "generate",
-      description: "Test-only: starts a job that always fails.",
-      schema: z.object({ campaignId: z.string() }),
-      access: { roles: ["Admin"] },
-      handler: async (event) => ({ isSuccess: true as const, data: { ...event.payload } }),
-    }),
-  );
-  r.job(
-    "generateTexts",
-    {
-      trigger: { on: "app:write:generate" },
-      retries: 0,
-      tenantVisibleFailure: { messageKey: FAILURE_KEY, subjectFields: ["campaignId"] },
-    },
-    async () => {
-      throw new Error(PROVIDER_MESSAGE);
-    },
-  );
-});
-
-type FailureRow = { readonly jobName: string; readonly messageKey: string };
-
-let stack: TestStack;
-
-beforeAll(async () => {
-  stack = await setupTestStackFromFeatures([appFeature, createJobsFeature()], {
-    jobs: { consumerLane: "worker" },
-  });
-});
-
-afterAll(async () => {
-  await stack.cleanup();
-});
-
-describe("setupTestStackFromFeatures({ jobs }) run-logger default", () => {
-  test("a failed tenant-visible job is readable by its tenant only, once drainJobs() rejects", async () => {
-    await stack.http.writeOk("app:write:generate", { campaignId: "campaign-1" }, userA);
-
-    await expect(stack.drainJobs()).rejects.toThrow(/app:job:generate-texts/);
-
-    const own = await stack.http.queryOk<{ rows: FailureRow[] }>(JobQueries.failures, {}, userA);
-    expect(own.rows).toHaveLength(1);
-    expect(own.rows[0]?.jobName).toBe("app:job:generate-texts");
-    expect(own.rows[0]?.messageKey).toBe(FAILURE_KEY);
-    expect(JSON.stringify(own)).not.toContain(PROVIDER_MESSAGE);
-
-    const other = await stack.http.queryOk<{ rows: FailureRow[] }>(JobQueries.failures, {}, userB);
-    expect(other.rows).toHaveLength(0);
-  });
-});

package/src/__tests__/walkthrough.integration.test.ts

@@ -1,140 +0,0 @@
-// DX-3.1 — walkthrough-snapshot-test. Reproduces the 3-command path from
-// docs.kumiko.rocks/en/walkthrough/ in-process and asserts what the walkthrough
-// claims. Catches drift in scaffoldApp + scaffoldAppFeature against the
-// docs without an actual `bunx … && bun install && bun run boot` CI run.
-//
-// What this test pins:
-//   - scaffoldApp produces the files the walkthrough lists
-//   - scaffoldAppFeature scaffolds + auto-mounts (the diff-block shown)
-//   - composeFeatures(includeBundled:true) yields the exact feature-count
-//     the walkthrough advertises in "Expected output"
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { authFoundationFeature } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
-import { createPersonalAccessTokensFeature } from "@cosmicdrift/kumiko-bundled-features/personal-access-tokens";
-import { createSecretsFeature } from "@cosmicdrift/kumiko-bundled-features/secrets";
-import { createSessionsFeature } from "@cosmicdrift/kumiko-bundled-features/sessions";
-import { createRegistry, defineFeature, validateBoot } from "@cosmicdrift/kumiko-framework/engine";
-import { composeFeatures } from "@cosmicdrift/kumiko-server-runtime/compose-features";
-import { scaffoldApp } from "../scaffold-app";
-import { scaffoldAppFeature } from "../scaffold-app-feature";
-
-describe("walkthrough — DX-3.1 snapshot", () => {
-  let tmp: string;
-  let appRoot: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "walkthrough-"));
-    appRoot = join(tmp, "my-notes");
-  });
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  test("Step 1 (kumiko new app) — produces walkthrough's scaffold files", async () => {
-    const result = await scaffoldApp({ name: "my-notes", destination: appRoot });
-    expect(result.files).toContain("package.json");
-    expect(result.files).toContain("kumiko/schema.ts");
-    expect(result.files).toContain("bin/kumiko.ts");
-    expect(result.files).toContain("deploy/Dockerfile");
-    expect(result.files).toContain("kumiko/migrations/0001_init.sql");
-  });
-
-  test("Step 2 (kumiko add feature) — auto-mounts + walkthrough diff matches", async () => {
-    await scaffoldApp({ name: "my-notes", destination: appRoot });
-    const result = scaffoldAppFeature({ name: "notes", appRoot });
-    expect(result.autoMounted).toBe(true);
-
-    const runConfig = readFileSync(join(appRoot, "src/run-config.ts"), "utf-8");
-    // Walkthrough's diff-block claims:
-    //   + import { notesFeature } from "./features/notes";
-    //   + notesFeature  (in APP_FEATURES)
-    expect(runConfig).toContain(`import { notesFeature } from "./features/notes";`);
-    expect(runConfig).toContain("notesFeature");
-    // Foundation still mounted (createSecretsFeature + createSessionsFeature).
-    expect(runConfig).toContain("createSecretsFeature()");
-    expect(runConfig).toContain("createSessionsFeature()");
-  });
-
-  test("Step 3 (boot validation) — scaffolded run-config matches walkthrough's APP_FEATURES claim", async () => {
-    await scaffoldApp({ name: "my-notes", destination: appRoot });
-    scaffoldAppFeature({ name: "notes", appRoot });
-
-    // Text-assert: scaffolded run-config.ts contains exactly the 3 features
-    // the walkthrough's diff-block shows (secrets + sessions + notesFeature).
-    // Dynamic-import would fail because /tmp can't resolve @cosmicdrift/*
-    // workspace symlinks — instead we reproduce the equivalent APP_FEATURES
-    // array in-process below.
-    const runConfig = readFileSync(join(appRoot, "src/run-config.ts"), "utf-8");
-    expect(runConfig).toContain("createSecretsFeature()");
-    expect(runConfig).toContain("createSessionsFeature()");
-    expect(runConfig).toContain("notesFeature");
-  });
-
-  test("Step 3 (composeFeatures) — 3 explicit + 4 auto-mounted = 7 features", () => {
-    // Reproduces the scaffolded APP_FEATURES in-process. notesFeature gets
-    // a dummy defineFeature here — the scaffold-side of "notesFeature"
-    // (file-content) is pinned in test 2; this test pins the runtime-side
-    // (composeFeatures auto-prepend behaviour the walkthrough claims).
-    //
-    // sessions now requires auth-foundation (#1370/#1371), which itself
-    // needs a tokenVerifier provider mounted (#1368) — PAT here, mirroring
-    // the scaffold picker's real-world default. Not part of the walkthrough's
-    // advertised 7-feature count (that count is about includeBundled's
-    // auto-mount, unrelated to this coupling), so both are added on top.
-    const notesFeature = defineFeature("notes", () => {});
-    const APP_FEATURES = [
-      createSecretsFeature(),
-      authFoundationFeature,
-      createPersonalAccessTokensFeature({ scopes: {} }),
-      createSessionsFeature(),
-      notesFeature,
-    ];
-
-    const composed = composeFeatures(APP_FEATURES, { includeBundled: true });
-    // 5 explicit + 4 auto-mounted bundled = 9 total features.
-    expect(composed.length).toBe(9);
-
-    const composedNames = composed.map((f) => f.name).sort();
-    expect(composedNames).toEqual([
-      "auth-email-password",
-      "auth-foundation",
-      "config",
-      "notes",
-      "personal-access-tokens",
-      "secrets",
-      "sessions",
-      "tenant",
-      "user",
-    ]);
-
-    // validateBoot must pass (no missing-requires, no schema-errors).
-    expect(() => validateBoot(composed)).not.toThrow();
-    // Registry must contain all 9 features.
-    const registry = createRegistry(composed);
-    expect(registry.features.size).toBe(9);
-  });
-
-  test("bin/main.ts contains the auth.admin stub the walkthrough relies on", async () => {
-    await scaffoldApp({ name: "my-notes", destination: appRoot });
-    const main = readFileSync(join(appRoot, "bin/main.ts"), "utf-8");
-    // composeFeatures(includeBundled:true)-trigger is `auth: { admin: { … } }`.
-    // Walkthrough explicitly says this is what auto-mounts the 4 bundled features.
-    expect(main).toContain("auth: {");
-    expect(main).toContain("admin: {");
-    expect(main).toContain("memberships:");
-    expect(main).toContain("runProdApp");
-    // Prod writer stays untouched — the verify flow must run there (#1687).
-    expect(main).not.toContain("emailVerified");
-  });
-
-  test("bin/dev.ts seeds the admin as emailVerified: true so login doesn't 422", async () => {
-    await scaffoldApp({ name: "my-notes", destination: appRoot });
-    const dev = readFileSync(join(appRoot, "bin/dev.ts"), "utf-8");
-    expect(dev).toContain("admin: {");
-    expect(dev).toContain("emailVerified: true,");
-  });
-});

package/src/__tests__/welcome-banner.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { renderWelcomeBanner } from "../welcome-banner";
-
-describe("renderWelcomeBanner", () => {
-  test("includes URL + admin login + features dir + docs link", () => {
-    const banner = renderWelcomeBanner({
-      url: "http://localhost:3000",
-      admin: { email: "admin@demo.test", password: "changeme" },
-    });
-    expect(banner).toContain("http://localhost:3000");
-    expect(banner).toContain("admin@demo.test");
-    expect(banner).toContain("changeme");
-    expect(banner).toContain("src/features/");
-    expect(banner).toContain("docs.kumiko.rocks");
-  });
-
-  test("box rows are aligned (all the same printable width)", () => {
-    const banner = renderWelcomeBanner({
-      url: "http://localhost:3000",
-      admin: { email: "a@b.c", password: "x" },
-    });
-    const rows = banner.split("\n");
-    const widths = rows.map((r) => [...r].length);
-    expect(new Set(widths).size).toBe(1);
-  });
-
-  test("admin is optional (no-auth dev runs still get a banner)", () => {
-    const banner = renderWelcomeBanner({ url: "http://localhost:3000" });
-    expect(banner).toContain("http://localhost:3000");
-    expect(banner).not.toContain("Login als");
-  });
-
-  test("featuresDir + docsUrl overridable", () => {
-    const banner = renderWelcomeBanner({
-      url: "http://localhost:3000",
-      featuresDir: "app/modules/",
-      docsUrl: "https://internal.example.com/dev",
-    });
-    expect(banner).toContain("app/modules/");
-    expect(banner).toContain("internal.example.com/dev");
-  });
-});