@cosmicdrift/kumiko-framework 0.19.1 → 0.21.0

package/LICENSE

@@ -21,7 +21,7 @@ managed offering of the Licensed Work.
 This restriction does not apply to the Licensor, any entity controlled by, 
 controlling, or under common control with the Licensor ("Affiliates"), or 
 contractors acting on their behalf. The Licensor remains free to use the 
-Licensed Work for any purpose, including for the operation of kumiko.so.
+Licensed Work for any purpose, including for the operation of kumiko.rocks.
 
 Change Date:          2030-05-05
 Change License:       Apache License, Version 2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -12,7 +12,7 @@
   "bugs": {
     "url": "https://github.com/CosmicDriftGameStudio/kumiko-framework/issues"
   },
-  "homepage": "https://kumiko.so",
+  "homepage": "https://kumiko.rocks",
   "keywords": [
     "framework",
     "multi-tenant",

package/src/compliance/sub-processors.ts

@@ -4,7 +4,7 @@
 // Plattform-Betrieb einsetzt. Wird oeffentlich exposed unter
 //   /api/compliance/sub-processors        (JSON, Sprint 1)
 //   /api/compliance/sub-processors.rss    (RSS, Sprint 1)
-//   kumiko.so/subprocessors               (HTML, Marketing-Repo)
+//   kumiko.rocks/subprocessors               (HTML, Marketing-Repo)
 //
 // Tenant-Admins muessen ueber Add/Change/Remove informiert werden mit
 // Lead-Time aus dem Compliance-Profile (typisch 30d). Cron-Job kommt

package/src/db/__tests__/rebuild-marker.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { EntityTableMeta } from "../entity-table-meta";
+import { diffSnapshots, snapshotFromMetas } from "../migrate-generator";
+import { readRebuildMarker, rebuildTablesFromDiff, writeRebuildMarker } from "../rebuild-marker";
+
+function meta(
+  tableName: string,
+  extraColumn?: EntityTableMeta["columns"][number],
+): EntityTableMeta {
+  return {
+    tableName,
+    source: "unmanaged",
+    indexes: [],
+    columns: [
+      { name: "id", pgType: "uuid", notNull: true, primaryKey: true },
+      ...(extraColumn ? [extraColumn] : []),
+    ],
+  };
+}
+
+function tmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "rebuild-marker-"));
+}
+
+describe("rebuildTablesFromDiff", () => {
+  test("includes new + changed tables, excludes dropped, sorted + unique", () => {
+    const prev = snapshotFromMetas([meta("read_a"), meta("read_c")]);
+    const next = snapshotFromMetas([
+      meta("read_a", { name: "title", pgType: "text", notNull: true }),
+      meta("read_b"),
+    ]);
+    const diff = diffSnapshots(prev, next);
+    expect(rebuildTablesFromDiff(diff)).toEqual(["read_a", "read_b"]);
+  });
+
+  test("no schema change → empty", () => {
+    const snap = snapshotFromMetas([meta("read_a")]);
+    expect(rebuildTablesFromDiff(diffSnapshots(snap, snap))).toEqual([]);
+  });
+});
+
+describe("write/read marker", () => {
+  test("roundtrip: write tables → read them back via migration-id", () => {
+    const dir = tmpDir();
+    try {
+      writeRebuildMarker(dir, "0002_add_locale.sql", ["read_users", "read_text_blocks"]);
+      expect(existsSync(join(dir, "0002_add_locale.rebuild.json"))).toBe(true);
+      expect(readRebuildMarker(dir, "0002_add_locale")).toEqual(["read_users", "read_text_blocks"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("empty table list → no marker file written, read returns []", () => {
+    const dir = tmpDir();
+    try {
+      writeRebuildMarker(dir, "0003_noop.sql", []);
+      expect(existsSync(join(dir, "0003_noop.rebuild.json"))).toBe(false);
+      expect(readRebuildMarker(dir, "0003_noop")).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("missing marker → []", () => {
+    const dir = tmpDir();
+    try {
+      expect(readRebuildMarker(dir, "9999_absent")).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("corrupt marker file → [] (does not throw)", () => {
+    const dir = tmpDir();
+    try {
+      writeFileSync(join(dir, "0004_broken.rebuild.json"), "{ not json");
+      expect(readRebuildMarker(dir, "0004_broken")).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/db/index.ts

@@ -95,6 +95,11 @@ export {
   transaction,
   updateMany,
 } from "./query-api";
+export {
+  readRebuildMarker,
+  rebuildTablesFromDiff,
+  writeRebuildMarker,
+} from "./rebuild-marker";
 export { seedReferenceData } from "./reference-data";
 export { renderTableDdl, renderTablesDdl } from "./render-ddl";
 export { tableExists } from "./schema-inspection";

package/src/db/rebuild-marker.ts

@@ -0,0 +1,75 @@
+// Rebuild-Marker für den drizzle-freien Migrations-Pfad.
+//
+// `kumiko schema generate` schreibt neben jedes `NNNN_<name>.sql` einen
+// Sibling-Marker `NNNN_<name>.rebuild.json`, der die in dieser Migration
+// geänderten/neu angelegten Tabellen listet. `kumiko schema apply` liest den
+// Marker für jede frisch applizierte Migration und rebuildet die betroffenen
+// Projektionen.
+//
+// Bewusst nur **Tabellennamen** (kein Projection-Name): der Generator ist
+// registry-frei (kennt die App-Projektionen nicht). Die Auflösung
+// Tabelle→Projection passiert app-seitig beim Apply via
+// `buildProjectionTableIndex(registry)`. Tabellen ohne zugehörige Projektion
+// werden dort einfach übersprungen.
+//
+// Marker werden zum generate-Zeitpunkt aus dem strukturierten `SchemaDiff`
+// geschrieben — nicht beim Apply aus dem (ggf. hand-editierten) SQL
+// re-derived.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { SchemaDiff } from "./migrate-generator";
+
+const MARKER_VERSION = 1 as const;
+
+type RebuildMarker = {
+  readonly version: typeof MARKER_VERSION;
+  readonly tables: readonly string[];
+};
+
+function markerPathFor(migrationsDir: string, migrationId: string): string {
+  return join(migrationsDir, `${migrationId}.rebuild.json`);
+}
+
+// Tabellen die nach dieser Migration einen Projection-Rebuild brauchen können:
+// neu angelegte + spalten-/index-geänderte. Gelöschte Tabellen NICHT (die
+// Projektion ist mit der Tabelle weg). Sortiert + dedupliziert für stabilen
+// PR-Diff.
+export function rebuildTablesFromDiff(diff: SchemaDiff): readonly string[] {
+  const names = new Set<string>();
+  for (const t of diff.changedTables) names.add(t.tableName);
+  for (const t of diff.newTables) names.add(t.tableName);
+  return [...names].sort();
+}
+
+// Schreibt `<sqlFilename ohne .sql>.rebuild.json`. Leere Tabellen-Liste →
+// kein Marker (z.B. reine Drop-Migration).
+export function writeRebuildMarker(
+  migrationsDir: string,
+  sqlFilename: string,
+  tables: readonly string[],
+): void {
+  // skip: leere Tabellen-Liste → kein Marker (z.B. reine Drop-Migration).
+  if (tables.length === 0) return;
+  const migrationId = sqlFilename.replace(/\.sql$/, "");
+  const marker: RebuildMarker = { version: MARKER_VERSION, tables };
+  writeFileSync(markerPathFor(migrationsDir, migrationId), `${JSON.stringify(marker, null, 2)}\n`);
+}
+
+// Liest die Tabellen-Liste für eine applizierte Migration. Kein Marker /
+// kaputtes File → leere Liste (Migration ohne Projection-Impact).
+export function readRebuildMarker(migrationsDir: string, migrationId: string): readonly string[] {
+  const path = markerPathFor(migrationsDir, migrationId);
+  if (!existsSync(path)) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null || !("tables" in parsed)) return [];
+  const { tables } = parsed;
+  if (!Array.isArray(tables)) return [];
+  return tables.filter((t): t is string => typeof t === "string");
+}

package/src/engine/types/handlers.ts

@@ -614,7 +614,7 @@ export type TypedAppendEventArgs<TMap extends object, K extends keyof TMap> = {
 //   We pick the first option and force the wrong path to fail visibly.
 //
 // How this is wired in practice:
-//   - Apps run `yarn kumiko codegen`, which writes `.kumiko/define.ts`
+//   - Apps run `bun kumiko codegen`, which writes `.kumiko/define.ts`
 //     with locally-bound `defineWriteHandler<TName, TSchema, TData,
 //     KumikoEventTypeMap>(...)` wrappers. Handlers inside those wrappers
 //     get a strict ctx.appendEvent.

package/src/errors/__tests__/classes.test.ts

@@ -30,22 +30,22 @@ describe("KumikoError: abstract base", () => {
   describe("docsUrl getter — Self-Service-Link", () => {
     test("uses details.reason when set (NotFoundError sets entity-specific reason)", () => {
       const err = new NotFoundError("order", 42);
-      expect(err.docsUrl).toBe("https://docs.kumiko.so/errors/order_not_found");
+      expect(err.docsUrl).toBe("https://docs.kumiko.rocks/errors/order_not_found");
     });
 
     test("uses details.reason when explicitly set (ConflictError-style)", () => {
       const err = new ConflictError({ details: { reason: "stale_state" } });
-      expect(err.docsUrl).toBe("https://docs.kumiko.so/errors/stale_state");
+      expect(err.docsUrl).toBe("https://docs.kumiko.rocks/errors/stale_state");
     });
 
     test("falls back to code when details has no reason field", () => {
       const err = new ConflictError({ details: { foo: "bar" } });
-      expect(err.docsUrl).toBe("https://docs.kumiko.so/errors/conflict");
+      expect(err.docsUrl).toBe("https://docs.kumiko.rocks/errors/conflict");
     });
 
     test("falls back to code when details is undefined", () => {
       const err = new ConflictError();
-      expect(err.docsUrl).toBe("https://docs.kumiko.so/errors/conflict");
+      expect(err.docsUrl).toBe("https://docs.kumiko.rocks/errors/conflict");
     });
 
     test("respects KUMIKO_DOCS_URL env override (Self-Hosted-Kunden)", () => {
@@ -63,7 +63,7 @@ describe("KumikoError: abstract base", () => {
     test("serializeError exposes docsUrl in the wire response", () => {
       const err = new ConflictError({ details: { reason: "stale_state" } });
       const body = serializeError(err);
-      expect(body.error.docsUrl).toBe("https://docs.kumiko.so/errors/stale_state");
+      expect(body.error.docsUrl).toBe("https://docs.kumiko.rocks/errors/stale_state");
     });
   });
 });

package/src/errors/kumiko-error.ts

@@ -22,7 +22,7 @@ export type ErrorCtorInput = {
 // Default-Doku-URL für Self-Service-Errors. Kann via env-var
 // `KUMIKO_DOCS_URL` überschrieben werden — z.B. für Self-Hosted-Kunden
 // die ihre eigene Doku-Instanz hosten.
-const DEFAULT_DOCS_BASE_URL = "https://docs.kumiko.so";
+const DEFAULT_DOCS_BASE_URL = "https://docs.kumiko.rocks";
 
 function docsBaseUrl(): string {
   return process.env["KUMIKO_DOCS_URL"] ?? DEFAULT_DOCS_BASE_URL;

package/src/migrations/index.ts

@@ -1,6 +1,4 @@
 // Drizzle-free gate (kumiko/migrations system) — the canonical boot-gate.
-// `SchemaDriftError` is re-exported from here; the legacy drizzle gate above
-// keeps its own internal error until Phase 3 removes schema-drift.ts.
 export {
   assertKumikoSchemaCurrent,
   type ChecksumMismatch,
@@ -9,30 +7,5 @@ export {
   type KumikoDriftReport,
   SchemaDriftError,
 } from "./kumiko-drift";
-export {
-  buildProjectionTableIndex,
-  type ChangedTable,
-  compareSnapshots,
-  detectProjectionsToRebuild,
-  latestMigrationTag,
-  projectionsFromChanges,
-} from "./projection-detection";
-export { type RebuildMarker, readRebuildMarker, writeRebuildMarker } from "./rebuild-marker";
-export {
-  type AppliedMigration,
-  assertSchemaCurrent,
-  type ColumnIssue,
-  type ColumnSpec,
-  type DriftReport,
-  detectDrift,
-  formatDriftReport,
-  type Journal,
-  type JournalEntry,
-  loadAppliedMigrations,
-  loadJournal,
-  loadLatestSnapshot,
-  loadPreviousSnapshot,
-  loadSnapshot,
-  type Snapshot,
-  type SnapshotTable,
-} from "./schema-drift";
+// tableName → projection-name, für den app-seitigen Projection-Rebuild.
+export { buildProjectionTableIndex } from "./projection-table-index";

package/src/migrations/projection-table-index.ts

@@ -0,0 +1,35 @@
+// Index `tableName → projection-name` aus der Registry. Genutzt vom
+// app-seitigen Projection-Rebuild (`kumiko schema apply` liest die
+// rebuild-Marker → mappt Tabellen auf Projektionen → rebuildProjection).
+//
+// Drizzle-frei: der Tabellen-Name kommt aus dem kumiko-Symbol das
+// buildEntityTable/buildEntityTableMeta an die Table-Definition hängt.
+
+import type { Registry } from "../engine/types/feature";
+
+const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
+
+function getTableName(table: unknown): string {
+  if (typeof table !== "object" || table === null) {
+    throw new Error("projection-table-index: table is not a table object");
+  }
+  const name = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
+  if (typeof name !== "string") {
+    throw new Error("projection-table-index: table missing kumiko name symbol");
+  }
+  return name;
+}
+
+/** Index `tableName → projection-name` aus der Registry. Nur Projections mit
+ *  table-Definition (single-stream + multi-stream-with-table) zählen.
+ *  Side-effect-only MSPs (table omitted) haben keinen Rebuild-Sinn. */
+export function buildProjectionTableIndex(registry: Registry): ReadonlyMap<string, string> {
+  const index = new Map<string, string>();
+  for (const [name, def] of registry.getAllProjections()) {
+    index.set(getTableName(def.table), name);
+  }
+  for (const [name, def] of registry.getAllMultiStreamProjections()) {
+    if (def.table) index.set(getTableName(def.table), name);
+  }
+  return index;
+}

package/src/pipeline/msp-rebuild.ts

@@ -99,7 +99,7 @@ export async function rebuildMultiStreamProjection(
   }
   if (!msp.table) {
     throw new Error(
-      `MultiStreamProjection "${mspName}" has no backing table — it is a pure side-effect consumer (webhooks, notifications, external sync). Rebuild would re-invoke those side-effects by replaying the log. For poison events use yarn kumiko consumer skip / restart; there is no analogous "rebuild" concept for side-effect sinks.`,
+      `MultiStreamProjection "${mspName}" has no backing table — it is a pure side-effect consumer (webhooks, notifications, external sync). Rebuild would re-invoke those side-effects by replaying the log. For poison events use bun kumiko consumer skip / restart; there is no analogous "rebuild" concept for side-effect sinks.`,
     );
   }
 

package/src/schema-cli.ts

@@ -17,8 +17,10 @@ import {
   generateMigration,
   loadMigrationsFromDir,
   loadSnapshotJson,
+  rebuildTablesFromDiff,
   type renderTablesDdl,
   runMigrationsFromDir,
+  writeRebuildMarker,
   writeSnapshotJson,
 } from "./db";
 
@@ -105,11 +107,22 @@ export async function runSchemaCli(
       writeFileSync(join(migrationsDir, result.filename), result.sqlContent);
       writeSnapshotJson(snapshotPath, result.snapshot);
 
+      // Rebuild-Marker nur für inkrementelle Migrationen — die Init-Migration
+      // (prevSnapshot===null) legt nur Tabellen an, es gibt keine historischen
+      // Events zum Replayen.
+      const rebuildTables = prevSnapshot === null ? [] : rebuildTablesFromDiff(result.diff);
+      writeRebuildMarker(migrationsDir, result.filename, rebuildTables);
+
       out.log("");
       out.log(`  ✓ ${result.filename}`);
       out.log(
         `    new tables: ${result.diff.newTables.length}, changed: ${result.diff.changedTables.length}, dropped: ${result.diff.droppedTables.length}`,
       );
+      if (rebuildTables.length > 0) {
+        out.log(
+          `    rebuild-marker: ${result.filename.replace(/\.sql$/, ".rebuild.json")} (${rebuildTables.length} table(s))`,
+        );
+      }
       out.log("");
       out.log("  Review + ggf. hand-edit + git add + commit. Apply via: kumiko-schema apply");
       out.log("");

package/src/db/queries/schema-drift.ts

@@ -1,35 +0,0 @@
-import type { AnyDb } from "../query";
-import { asRawClient } from "../query";
-
-export type AppliedMigrationRow = {
-  readonly hash: string;
-  readonly created_at: bigint | number | null;
-};
-
-export type DbColumnInfoRow = {
-  readonly column_name: string;
-  readonly data_type: string;
-  readonly is_nullable: "YES" | "NO";
-};
-
-/** tableRef must be `drizzle.__drizzle_migrations` or `public.__drizzle_migrations`. */
-export async function selectAppliedMigrations(
-  db: AnyDb,
-  tableRef: "drizzle.__drizzle_migrations" | "public.__drizzle_migrations",
-): Promise<readonly AppliedMigrationRow[]> {
-  return (await asRawClient(db).unsafe(
-    `SELECT hash, created_at FROM ${tableRef} ORDER BY id`,
-  )) as readonly AppliedMigrationRow[];
-}
-
-export async function selectPublicTableColumns(
-  db: AnyDb,
-  tableName: string,
-): Promise<readonly DbColumnInfoRow[]> {
-  return (await asRawClient(db).unsafe(
-    `SELECT column_name, data_type, is_nullable
-     FROM information_schema.columns
-     WHERE table_schema = 'public' AND table_name = $1`,
-    [tableName],
-  )) as readonly DbColumnInfoRow[];
-}

package/src/migrations/__tests__/compare-snapshots.test.ts

@@ -1,150 +0,0 @@
-// Unit-Tests für compareSnapshots — der Diff-Algorithmus zwischen zwei
-// Drizzle-Snapshots. Production-Behavior: bei Schema-Drift einer
-// Projection-Tabelle muss der Detector die richtigen Tabellen-Namen
-// melden, damit migrate apply den richtigen Rebuild triggert.
-
-import { describe, expect, test } from "bun:test";
-import { compareSnapshots } from "../projection-detection";
-import type { Snapshot, SnapshotTable } from "../schema-drift";
-
-function snapshot(tables: Record<string, Partial<SnapshotTable>>): Snapshot {
-  const out: Record<string, SnapshotTable> = {};
-  for (const [key, partial] of Object.entries(tables)) {
-    out[key] = {
-      schema: partial.schema ?? "",
-      name: partial.name ?? key.replace(/^public\./, ""),
-      columns: partial.columns ?? {},
-    };
-  }
-  return { tables: out };
-}
-
-const userTable: SnapshotTable = {
-  schema: "",
-  name: "users",
-  columns: {
-    id: { name: "id", type: "uuid", primaryKey: true, notNull: true },
-    email: { name: "email", type: "text", notNull: true },
-  },
-};
-
-describe("compareSnapshots", () => {
-  test("prev=null → all current tables marked as added", () => {
-    const current = snapshot({ "public.users": userTable });
-    const changes = compareSnapshots(null, current);
-    expect(changes).toHaveLength(1);
-    expect(changes[0]).toMatchObject({ tableName: "users", kind: "added" });
-  });
-
-  test("identical snapshots → no changes", () => {
-    const s = snapshot({ "public.users": userTable });
-    expect(compareSnapshots(s, s)).toHaveLength(0);
-  });
-
-  test("table appears in current → kind=added", () => {
-    const prev = snapshot({});
-    const current = snapshot({ "public.users": userTable });
-    const changes = compareSnapshots(prev, current);
-    expect(changes).toEqual([{ fullName: "users", tableName: "users", kind: "added" }]);
-  });
-
-  test("table missing in current → kind=removed", () => {
-    const prev = snapshot({ "public.users": userTable });
-    const current = snapshot({});
-    const changes = compareSnapshots(prev, current);
-    expect(changes).toEqual([{ fullName: "users", tableName: "users", kind: "removed" }]);
-  });
-
-  test("column added → kind=modified", () => {
-    const prev = snapshot({ "public.users": userTable });
-    const current = snapshot({
-      "public.users": {
-        ...userTable,
-        columns: { ...userTable.columns, name: { name: "name", type: "text" } },
-      },
-    });
-    const changes = compareSnapshots(prev, current);
-    expect(changes).toEqual([{ fullName: "users", tableName: "users", kind: "modified" }]);
-  });
-
-  test("column type changed → kind=modified", () => {
-    const prev = snapshot({ "public.users": userTable });
-    const current = snapshot({
-      "public.users": {
-        ...userTable,
-        columns: {
-          ...userTable.columns,
-          email: { name: "email", type: "varchar(255)", notNull: true },
-        },
-      },
-    });
-    expect(compareSnapshots(prev, current)).toEqual([
-      { fullName: "users", tableName: "users", kind: "modified" },
-    ]);
-  });
-
-  test("notNull flipped → kind=modified", () => {
-    const prev = snapshot({ "public.users": userTable });
-    const current = snapshot({
-      "public.users": {
-        ...userTable,
-        columns: { ...userTable.columns, email: { name: "email", type: "text", notNull: false } },
-      },
-    });
-    expect(compareSnapshots(prev, current)).toEqual([
-      { fullName: "users", tableName: "users", kind: "modified" },
-    ]);
-  });
-
-  test("default value changed → kind=modified", () => {
-    const prev = snapshot({
-      "public.users": {
-        ...userTable,
-        columns: {
-          ...userTable.columns,
-          status: { name: "status", type: "text", default: "'active'" },
-        },
-      },
-    });
-    const current = snapshot({
-      "public.users": {
-        ...userTable,
-        columns: {
-          ...userTable.columns,
-          status: { name: "status", type: "text", default: "'pending'" },
-        },
-      },
-    });
-    expect(compareSnapshots(prev, current)).toEqual([
-      { fullName: "users", tableName: "users", kind: "modified" },
-    ]);
-  });
-
-  test("schema-prefix in fullName when set", () => {
-    const prev = snapshot({});
-    const current = snapshot({
-      "auth.users": { ...userTable, schema: "auth" },
-    });
-    const changes = compareSnapshots(prev, current);
-    expect(changes[0]?.fullName).toBe("auth.users");
-  });
-
-  test("multiple changes preserved with stable kind classification", () => {
-    const tableA: SnapshotTable = { ...userTable, name: "a" };
-    const tableB: SnapshotTable = { ...userTable, name: "b" };
-    const tableC: SnapshotTable = { ...userTable, name: "c" };
-    const prev = snapshot({
-      "public.a": tableA,
-      "public.b": tableB,
-    });
-    const current = snapshot({
-      "public.a": tableA, // unchanged
-      "public.c": tableC, // added
-      // b removed
-    });
-    const changes = compareSnapshots(prev, current);
-    expect(changes).toHaveLength(2);
-    expect(changes.find((c) => c.tableName === "c")?.kind).toBe("added");
-    expect(changes.find((c) => c.tableName === "b")?.kind).toBe("removed");
-  });
-});