@cosmicdrift/kumiko-testing 0.367.0 → 0.369.0

package/src/helpers/index.ts

@@ -0,0 +1,67 @@
+// Test assertions and domain test fixtures. Production code (dev-server, bin/)
+// must import nothing from this subpath — the stack builders live in
+// `@cosmicdrift/kumiko-testing/stack`.
+
+// The four cache/injection resets stay in their own modules (they close over
+// module-private state) and are only re-exported here — they are out of /crypto
+// and /db as of #1631. A production call to resetPiiSubjectKmsForTests() silently
+// switches the PII layer off, and subject-annotated fields are written in
+// plaintext from then on: no error, no log.
+export {
+  resetBlindIndexKeyForTests,
+  resetEntityFieldEncryptionCacheForTests,
+  resetEventPiiCatalogForTests,
+  resetPiiSubjectKmsForTests,
+} from "@cosmicdrift/kumiko-framework/internal/testing";
+
+export { rolesOf } from "./access-assertions.js";
+export { expectError, expectSuccess } from "./assertions.js";
+export { withBootValidatorFixture } from "./boot-validator-fixture.js";
+export {
+  captureClosedConnectionError,
+  terminateBackendsByApplicationName,
+  testDatabaseUrl,
+} from "./closed-connection-error.js";
+export { type ClearableTable, clearTables, resetTestTables } from "./db-cleanup.js";
+export {
+  type E2EGeneratorOptions,
+  type E2ETestSpec,
+  type EditFillOp,
+  generateE2ESpec,
+  generateZodFixture,
+} from "./e2e-generator.js";
+export { expectErrorIncludes } from "./expect-error.js";
+export { describeFileProviderContract } from "./file-provider-contract.js";
+export {
+  getSetCookieRaw,
+  getSetCookies,
+  getSetCookieValue,
+  type ParsedSetCookie,
+} from "./http-cookies.js";
+export { createLateBoundHolder, type LateBoundHolder } from "./late-bound.js";
+export { createManualClock, type ManualClock } from "./manual-clock.js";
+export { buildMultipartBody, patchFileInstanceofForBunTest } from "./multipart-helper.js";
+export {
+  createMutableMasterKeyProvider,
+  createTestEnvelopeCipher,
+  createTestMasterKeyProvider,
+  type MutableMasterKeyProvider,
+} from "./mutable-master-key-provider.js";
+export {
+  createRecordingProvider,
+  type RecordingProvider,
+} from "./observability-recorder.js";
+export { isRealProviderRun, REAL_PROVIDERS_ENV, requireRealProviders } from "./real-providers.js";
+export { deleteRows, seedRow, seedRows, updateRows } from "./seed.js";
+export {
+  sharedItemEntity,
+  sharedItemTable,
+  sharedUserEntity,
+  sharedUserTable,
+  sharedWidgetEntity,
+  sharedWidgetTable,
+} from "./shared-entities.js";
+export { sleep } from "./utils.js";
+export { waitFor } from "./wait-for.js";
+export { withoutAmbientTemporal } from "./without-ambient-temporal.js";
+export { zipWithEntries } from "./zip-fixture.js";

package/src/helpers/late-bound.ts

@@ -0,0 +1,41 @@
+// Late-bound reference for values that only exist AFTER setupTestStack
+// returns — typically the session-callbacks, which close over stack.db.
+//
+// Without this helper, integration tests repeat the same trampoline
+// pattern (let real; async wrapper; null-check on each call). The holder
+// inverts the dependency: the test passes the trampolines into setupTestStack
+// first, then injects the concrete impl once db is available.
+//
+// Production wiring (runDevApp / runProdApp) doesn't reuse this — those
+// wrappers inline an equivalent let-closure-throw pattern to avoid the
+// runtime-isolation cross from dev → test packages. Same idea, different
+// file.
+
+export type LateBoundHolder<T> = {
+  /** Store the concrete value. Must be called before any trampoline fires. */
+  set(value: T): void;
+  /** Fetch the concrete value or throw if set() hasn't been called yet. */
+  get(): T;
+  /** True after set() has been called. */
+  isReady(): boolean;
+};
+
+export function createLateBoundHolder<T>(label = "value"): LateBoundHolder<T> {
+  let value: T | undefined;
+  let isSet = false;
+  return {
+    set(v) {
+      value = v;
+      isSet = true;
+    },
+    get() {
+      if (!isSet) {
+        throw new Error(`late-bound ${label} accessed before set() was called`);
+      }
+      return value as T;
+    },
+    isReady() {
+      return isSet;
+    },
+  };
+}

package/src/helpers/manual-clock.ts

@@ -0,0 +1,28 @@
+import type { Temporal } from "@cosmicdrift/kumiko-types/temporal";
+import type { Clock } from "@cosmicdrift/kumiko-types/tz-context";
+
+// Instant arithmetic rejects calendar units (days and larger).
+type ClockStep = {
+  readonly hours?: number;
+  readonly minutes?: number;
+  readonly seconds?: number;
+  readonly milliseconds?: number;
+};
+
+export type ManualClock = Clock & {
+  set(instant: Temporal.Instant): void;
+  advance(step: ClockStep): void;
+};
+
+export function createManualClock(start: Temporal.Instant): ManualClock {
+  let current = start;
+  return {
+    now: () => current,
+    set: (instant) => {
+      current = instant;
+    },
+    advance: (step) => {
+      current = current.add(step);
+    },
+  };
+}

package/src/helpers/multipart-helper.ts

@@ -0,0 +1,96 @@
+import { isPlainObject } from "@cosmicdrift/kumiko-types/type-guards";
+
+// Workarounds for Bun v1.3.x bun:test limitations with multipart/form-data.
+//
+// Two bugs combine to break file upload tests in bun:test:
+//
+// 1. Content-Type omission: both app.request({body: formData}) and
+//    fetch(url, {body: formData}) stringify FormData via .toString() instead
+//    of serializing it as multipart, so no Content-Type header is set.
+//    Fix: serialize FormData manually via buildMultipartBody().
+//
+// 2. Cross-realm instanceof: Hono's multipart parser creates Blob objects from
+//    a different JS realm than the test globals. In bun:test this means
+//    `parsedValue instanceof File` is always false even when the value has all
+//    File properties. Fix: patchFilInstanceofForBunTest().
+//
+// Both fixes are test-only — production code and real HTTP clients are unaffected.
+
+/**
+ * Serializes a FormData instance to multipart/form-data bytes.
+ *
+ * Returns the encoded body and the Content-Type header value (including the
+ * generated boundary). Pass both directly to app.request or fetch.
+ */
+
+export async function buildMultipartBody(
+  fd: FormData,
+): Promise<{ body: BodyInit; contentType: string }> {
+  const boundary = `KumikoBnd${Date.now()}${Math.random().toString(36).slice(2, 8)}`;
+  const enc = new TextEncoder();
+  const parts: Uint8Array[] = [];
+
+  for (const [name, value] of fd.entries()) {
+    const v = value as unknown as {
+      name?: string;
+      type?: string;
+      arrayBuffer?: () => Promise<ArrayBuffer>;
+    };
+    if (typeof v === "object" && v !== null && typeof v.arrayBuffer === "function") {
+      parts.push(
+        enc.encode(
+          `--${boundary}\r\nContent-Disposition: form-data; name="${name}"; filename="${v.name ?? "blob"}"\r\nContent-Type: ${v.type || "application/octet-stream"}\r\n\r\n`,
+        ),
+      );
+      parts.push(new Uint8Array(await v.arrayBuffer()));
+      parts.push(enc.encode("\r\n"));
+    } else {
+      parts.push(
+        enc.encode(
+          `--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${String(value)}\r\n`,
+        ),
+      );
+    }
+  }
+  parts.push(enc.encode(`--${boundary}--\r\n`));
+
+  const total = parts.reduce((s, p) => s + p.length, 0);
+  const buf = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    buf.set(p, off);
+    off += p.length;
+  }
+  return {
+    body: buf as unknown as BodyInit,
+    contentType: `multipart/form-data; boundary=${boundary}`,
+  };
+}
+
+/**
+ * Patches File[Symbol.hasInstance] so that cross-realm Blob objects returned
+ * by Hono's parseBody() pass `instanceof File` checks in bun:test.
+ *
+ * In bun:test the multipart parser runs in a different JS realm than the test
+ * globals, so the Blob/File constructors differ. The patch replaces the
+ * prototype-chain check with a duck-type check: an object with string `.name`,
+ * number `.size`, and function `.arrayBuffer` is treated as a File.
+ *
+ * Safe to call multiple times (idempotent via the `_patched` marker).
+ */
+export function patchFileInstanceofForBunTest(): void {
+  // skip: idempotent re-patch — already installed, nothing to do
+  if ((File as unknown as { _kumikoPatched?: boolean })._kumikoPatched) return;
+  Object.defineProperty(File, Symbol.hasInstance, {
+    value(instance: unknown): boolean {
+      if (!isPlainObject(instance)) return false;
+      return (
+        typeof instance["name"] === "string" &&
+        typeof instance["size"] === "number" &&
+        typeof instance["arrayBuffer"] === "function"
+      );
+    },
+    configurable: true,
+  });
+  (File as unknown as { _kumikoPatched?: boolean })._kumikoPatched = true;
+}

package/src/helpers/mutable-master-key-provider.ts

@@ -0,0 +1,57 @@
+// Test utility: a MasterKeyProvider wrapper whose backing provider can be
+// swapped mid-test. Use-case: simulating KEK-rotation ("ops flipped
+// CURRENT=2") without rebuilding the whole stack + SecretsContext.
+//
+// Prod analogue: ENV swap + process restart. This helper is purely for
+// tests that want to exercise pre- and post-rotation behaviour in a
+// single suite.
+
+import { randomBytes } from "node:crypto";
+import {
+  createEnvelopeCipher,
+  createEnvMasterKeyProvider,
+  type EnvelopeCipher,
+  type EnvelopeCipherOptions,
+  type MasterKeyProvider,
+} from "@cosmicdrift/kumiko-framework/secrets";
+
+export type MutableMasterKeyProvider = MasterKeyProvider & {
+  // Replace the backing provider. All future wrapDek/unwrapDek/currentVersion
+  // calls delegate to `next`. Existing in-flight calls already hold a
+  // reference to the old provider's closure and finish under its contract.
+  replace(next: MasterKeyProvider): void;
+};
+
+export function createMutableMasterKeyProvider(
+  initial: MasterKeyProvider,
+): MutableMasterKeyProvider {
+  let current = initial;
+  return {
+    wrapDek: (dek, scope) => current.wrapDek(dek, scope),
+    unwrapDek: (e, v, scope) => current.unwrapDek(e, v, scope),
+    currentVersion: () => current.currentVersion(),
+    isAvailable: () => current.isAvailable(),
+    replace: (next) => {
+      current = next;
+    },
+  };
+}
+
+// Single-version env provider for tests — the shape every integration test
+// needs to exercise encrypted config keys / entity fields without caring
+// about keyring mechanics. Pass a fixed key to share it across stacks.
+export function createTestMasterKeyProvider(keyBase64?: string): MasterKeyProvider {
+  return createEnvMasterKeyProvider({
+    env: {
+      KUMIKO_SECRETS_MASTER_KEY_CURRENT_VERSION: "1",
+      KUMIKO_SECRETS_MASTER_KEY_V1: keyBase64 ?? randomBytes(32).toString("base64"),
+    },
+  });
+}
+
+export function createTestEnvelopeCipher(
+  keyBase64?: string,
+  opts?: EnvelopeCipherOptions,
+): EnvelopeCipher {
+  return createEnvelopeCipher(createTestMasterKeyProvider(keyBase64), opts ?? {});
+}

package/src/helpers/observability-recorder.ts

@@ -0,0 +1,54 @@
+import {
+  DEFAULT_SENSITIVE_CONFIG,
+  type MetricEvent,
+  mergeSensitiveConfig,
+  type ObservabilityOptions,
+  type ObservabilityProvider,
+  type RecordedSpan,
+  RecordingMeter,
+  RecordingTracer,
+} from "@cosmicdrift/kumiko-framework/observability";
+
+// Provider that keeps every emitted span + metric event in arrays for
+// assertion in integration tests. Use instead of ConsoleProvider when the
+// test needs to inspect the trace tree or verify metric emissions.
+export type RecordingProvider = ObservabilityProvider & {
+  readonly spans: readonly RecordedSpan[];
+  readonly metricEvents: readonly MetricEvent[];
+  // Returns spans filtered by name — handy for `.find(s => s.name === "http.request")`.
+  spansByName(name: string): readonly RecordedSpan[];
+  // All spans sharing a trace id — use this to reconstruct a single request's tree.
+  spansByTraceId(traceId: string): readonly RecordedSpan[];
+  reset(): void;
+};
+
+export function createRecordingProvider(options: ObservabilityOptions = {}): RecordingProvider {
+  const sensitiveConfig = mergeSensitiveConfig(options.sensitiveFilter ?? DEFAULT_SENSITIVE_CONFIG);
+  const spans: RecordedSpan[] = [];
+  const metricEvents: MetricEvent[] = [];
+
+  const tracer = new RecordingTracer({
+    sensitiveConfig,
+    onSpanEnd: (s) => spans.push(s),
+  });
+  const meter = new RecordingMeter((e) => metricEvents.push(e));
+
+  return {
+    name: "recording",
+    tracer,
+    meter,
+    spans,
+    metricEvents,
+    spansByName(name: string) {
+      return spans.filter((s) => s.name === name);
+    },
+    spansByTraceId(traceId: string) {
+      return spans.filter((s) => s.traceId === traceId);
+    },
+    reset() {
+      spans.length = 0;
+      metricEvents.length = 0;
+    },
+    async shutdown() {},
+  };
+}

package/src/helpers/real-providers.ts

@@ -0,0 +1,30 @@
+// Playwright configs load this module under plain Node via
+// @cosmicdrift/kumiko-testing/e2e, so it must stay import-free.
+export const REAL_PROVIDERS_ENV = "KUMIKO_REAL_PROVIDERS";
+const CI_FLAG = "CI";
+
+function isCi(): boolean {
+  const ci = process.env[CI_FLAG];
+  return ci !== undefined && ci !== "" && ci !== "0" && ci.toLowerCase() !== "false";
+}
+
+// Apps and the e2e/bunfig templates gate real-provider runs on this same
+// check instead of re-reading KUMIKO_REAL_PROVIDERS themselves.
+export function isRealProviderRun(
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): boolean {
+  return env[REAL_PROVIDERS_ENV] === "1";
+}
+
+export function requireRealProviders(): void {
+  if (isCi()) {
+    throw new Error(
+      `Real-provider tests never run in CI (CI is set). Run them locally with ${REAL_PROVIDERS_ENV}=1 via the test:real / e2e:real script.`,
+    );
+  }
+  if (!isRealProviderRun()) {
+    throw new Error(
+      `Real-provider test needs ${REAL_PROVIDERS_ENV}=1 (an API key alone never enables it). Run it via the test:real / e2e:real script.`,
+    );
+  }
+}

package/src/helpers/seed.ts

@@ -0,0 +1,49 @@
+// Test-only ES-bypass: seed / mutate a managed projection directly, skipping
+// the event log. Production code CANNOT do this — the write helpers reject a
+// branded EntityTable at compile time (#742). Tests seed read-model state to
+// arrange a scenario without driving the full event path; a projection rebuild
+// is not part of the test lifecycle, so eventless writes are safe here. The
+// `as EntityTableMeta` strips the executor-only brand at this single sanctioned
+// seam — the signatures mirror the query helpers so a call-site migration is a
+// plain identifier rename.
+
+import type { EntityTable, EntityTableMeta } from "@cosmicdrift/kumiko-framework/db";
+import {
+  deleteMany,
+  insertMany,
+  insertOne,
+  updateMany,
+  type WhereObject,
+} from "@cosmicdrift/kumiko-framework/db";
+import type { AnyDb } from "@cosmicdrift/kumiko-framework/internal/stack-support";
+
+type SeedTable = EntityTable | EntityTableMeta;
+
+export function seedRow<TRow = unknown>(
+  db: AnyDb,
+  table: SeedTable,
+  values: Record<string, unknown>,
+): Promise<TRow | undefined> {
+  return insertOne<TRow>(db, table as EntityTableMeta, values);
+}
+
+export function seedRows<TRow = unknown>(
+  db: AnyDb,
+  table: SeedTable,
+  rows: ReadonlyArray<Record<string, unknown>>,
+): Promise<readonly TRow[]> {
+  return insertMany<TRow>(db, table as EntityTableMeta, rows);
+}
+
+export function updateRows<TRow = unknown>(
+  db: AnyDb,
+  table: SeedTable,
+  set: Record<string, unknown>,
+  where: WhereObject,
+): Promise<readonly TRow[]> {
+  return updateMany<TRow>(db, table as EntityTableMeta, set, where);
+}
+
+export function deleteRows(db: AnyDb, table: SeedTable, where: WhereObject): Promise<void> {
+  return deleteMany(db, table as EntityTableMeta, where);
+}

package/src/helpers/shared-entities.ts

@@ -0,0 +1,65 @@
+import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createBooleanField,
+  createEntity,
+  createNumberField,
+  createTextField,
+} from "@cosmicdrift/kumiko-framework/engine";
+
+// --- Shared Entity Fixtures -------------------------------------------------
+//
+// Replaces inline `createEntity(...) + buildEntityTable(...)` boilerplate
+// that appeared in 20+ integration tests. Pick the shape closest to what
+// the test needs; if a feature needs extras (hooks, state-machine, fields),
+// keep a local inline entity rather than bloating these shared ones.
+
+// "Just a name" — minimal entity with `name: text`, softDelete on.
+// Used by every pipeline test that only needs SOMETHING to write events
+// against (event-dispatcher*, event-retention, event-dedup, …).
+export const sharedWidgetEntity = createEntity({
+  fields: {
+    name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+  },
+  softDelete: true,
+});
+export const sharedWidgetTable = buildEntityTable("widget", sharedWidgetEntity);
+
+// User with searchable name/email fields. Used by full-stack, cascade,
+// and any test that exercises search-indexing or field-access on a
+// realistic-looking user record.
+export const sharedUserEntity = createEntity({
+  fields: {
+    email: createTextField({
+      required: true,
+      format: "email",
+      searchable: true,
+      personal: false,
+      reason: "test_fixture",
+    }),
+    firstName: createTextField({
+      searchable: true,
+      personal: false,
+      reason: "test_fixture",
+    }),
+    lastName: createTextField({
+      searchable: true,
+      personal: false,
+      reason: "test_fixture",
+    }),
+    isEnabled: createBooleanField({ default: true }),
+  },
+  softDelete: true,
+  searchWeight: 10,
+});
+export const sharedUserTable = buildEntityTable("user", sharedUserEntity);
+
+// Item with name + optional price. Used by error-contract, batch,
+// projection-rebuild — tests that need "a thing you can CRUD".
+export const sharedItemEntity = createEntity({
+  fields: {
+    name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+    price: createNumberField(),
+  },
+  softDelete: true,
+});
+export const sharedItemTable = buildEntityTable("item", sharedItemEntity);

package/src/helpers/utils.ts

@@ -0,0 +1 @@
+export const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

package/src/helpers/wait-for.ts

@@ -0,0 +1,50 @@
+/**
+ * Polls a condition with escalating timeouts.
+ *
+ * Default schedule: 250ms → 1s → 3s between attempts. Tries first (already-true
+ * returns immediately), then sleeps `delays[i]` after each failure before the
+ * next try — so N delays yield N+1 attempts and the full backoff budget.
+ * Throws the last assertion error if all attempts fail.
+ *
+ * Usage (assertion form):
+ *   await waitFor(() => {
+ *     expect(events).toHaveLength(1);
+ *   });
+ *
+ * Usage (predicate form — a literal `false` return means "not yet", anything
+ * else, including `undefined`, counts as success):
+ *   await waitFor(() => events.length >= 4);
+ */
+export async function waitFor(
+  // biome-ignore lint/suspicious/noConfusingVoidType: void must stay in the union so the existing expect(...) block form (implicit void return) still type-checks
+  fn: () => void | boolean | Promise<void | boolean>,
+  options?: { delays?: number[] },
+): Promise<void> {
+  const delays = options?.delays ?? [250, 1000, 3000];
+  if (delays.length === 0) {
+    throw new Error("waitFor: empty delay schedule");
+  }
+  let lastError: unknown;
+
+  for (let i = 0; ; i++) {
+    try {
+      const result = await fn();
+      if (result !== false) {
+        // skip: condition already true — no further polling
+        return;
+      }
+      lastError = undefined;
+    } catch (err) {
+      lastError = err;
+    }
+    if (i >= delays.length) {
+      break;
+    }
+    await new Promise((r) => setTimeout(r, delays[i]));
+  }
+
+  if (lastError !== undefined) {
+    throw lastError;
+  }
+  throw new Error("waitFor: condition never became true within the delay schedule");
+}

package/src/helpers/without-ambient-temporal.ts

@@ -0,0 +1,14 @@
+/**
+ * Run `fn` with `globalThis.Temporal` deleted, then restore.
+ * Used by ambient-independence regression tests (kumiko-framework#1525/#1550).
+ */
+export async function withoutAmbientTemporal<T>(fn: () => T | Promise<T>): Promise<T> {
+  const savedGlobal: unknown = Reflect.get(globalThis, "Temporal");
+  Reflect.deleteProperty(globalThis, "Temporal");
+  try {
+    return await fn();
+  } finally {
+    if (savedGlobal === undefined) Reflect.deleteProperty(globalThis, "Temporal");
+    else Reflect.set(globalThis, "Temporal", savedGlobal);
+  }
+}

package/src/helpers/zip-fixture.ts

@@ -0,0 +1,41 @@
+const LOCAL_HEADER_FIXED_LENGTH = 30;
+const CENTRAL_HEADER_FIXED_LENGTH = 46;
+const EOCD_LENGTH = 22;
+
+// Minimal stored ZIP (no compression, zero CRC): enough structure for readers that
+// walk the central directory. Not for extraction.
+export function zipWithEntries(...entryNames: readonly string[]): Uint8Array {
+  const encoder = new TextEncoder();
+  const names = entryNames.map((name) => encoder.encode(name));
+  const localSize = names.reduce((sum, name) => sum + LOCAL_HEADER_FIXED_LENGTH + name.length, 0);
+  const centralSize = names.reduce(
+    (sum, name) => sum + CENTRAL_HEADER_FIXED_LENGTH + name.length,
+    0,
+  );
+  const bytes = new Uint8Array(localSize + centralSize + EOCD_LENGTH);
+  const view = new DataView(bytes.buffer);
+
+  let localOffset = 0;
+  let centralOffset = localSize;
+  for (const name of names) {
+    view.setUint32(localOffset, 0x04034b50, true);
+    view.setUint16(localOffset + 26, name.length, true);
+    bytes.set(name, localOffset + LOCAL_HEADER_FIXED_LENGTH);
+
+    view.setUint32(centralOffset, 0x02014b50, true);
+    view.setUint16(centralOffset + 28, name.length, true);
+    view.setUint32(centralOffset + 42, localOffset, true);
+    bytes.set(name, centralOffset + CENTRAL_HEADER_FIXED_LENGTH);
+
+    localOffset += LOCAL_HEADER_FIXED_LENGTH + name.length;
+    centralOffset += CENTRAL_HEADER_FIXED_LENGTH + name.length;
+  }
+
+  const eocdOffset = localSize + centralSize;
+  view.setUint32(eocdOffset, 0x06054b50, true);
+  view.setUint16(eocdOffset + 8, names.length, true);
+  view.setUint16(eocdOffset + 10, names.length, true);
+  view.setUint32(eocdOffset + 12, centralSize, true);
+  view.setUint32(eocdOffset + 16, localSize, true);
+  return bytes;
+}

package/src/preload/real.ts

@@ -1,4 +1,4 @@
-import { requireRealProviders } from "@cosmicdrift/kumiko-framework/testing";
+import { requireRealProviders } from "../helpers/real-providers.js";
 import "./schema-env-defaults";
 import "./service-env-defaults";
 

package/src/scaffold.ts

@@ -1,6 +1,6 @@
 // @runtime tooling
-import { REAL_PROVIDERS_ENV } from "@cosmicdrift/kumiko-framework/testing/real-providers";
 import { BUNFIG_FILES, renderBunfigFiles, TEST_TIMEOUT_MS } from "./bunfig";
+import { REAL_PROVIDERS_ENV } from "./helpers/real-providers.js";
 
 export type ScaffoldTestSetup = {
   readonly files: Readonly<Record<string, string>>;
@@ -140,8 +140,8 @@ function renderUnitTest(): string {
 function renderIntegrationTest(): string {
   return [
     'import { afterAll, beforeAll, describe, expect, test } from "bun:test";',
-    'import type { TestStack } from "@cosmicdrift/kumiko-framework/stack";',
     'import { seedTenant, setupAppTestStack } from "@cosmicdrift/kumiko-testing";',
+    'import type { TestStack } from "@cosmicdrift/kumiko-testing/stack";',
     'import { tasksFeature } from "../features/tasks";',
     "",
     `const TASK_CREATE = ${JSON.stringify(TASK_CREATE)};`,

package/src/seed-tenant.ts

@@ -10,7 +10,6 @@ import {
   tenantChannel,
   type WriteResult,
 } from "@cosmicdrift/kumiko-framework/engine";
-import type { TestStack } from "@cosmicdrift/kumiko-framework/stack";
 import { isPlainObject } from "@cosmicdrift/kumiko-framework/utils";
 import {
   type BoundApi,
@@ -21,6 +20,7 @@ import {
   splitSeedRoles,
   withSession,
 } from "./seed-types";
+import type { TestStack } from "./stack/index.js";
 
 export type {
   BoundApi,

package/src/setup-app-test-stack.ts

@@ -3,7 +3,7 @@ import {
   setupTestStackFromFeatures,
 } from "@cosmicdrift/kumiko-dev-server/setup-test-stack-from-features";
 import type { FeatureDefinition } from "@cosmicdrift/kumiko-framework/engine";
-import { pushEntityProjectionTables, type TestStack } from "@cosmicdrift/kumiko-framework/stack";
+import { pushEntityProjectionTables, type TestStack } from "./stack/index.js";
 
 export type SetupAppTestStackOptions = SetupTestStackFromFeaturesOptions & {
   readonly registryTables?: boolean;