@warlock.js/core 5.30.0 → 5.32.0

package/esm/tests/authenticated-test-client.d.mts

@@ -0,0 +1,31 @@
+import { TestRequestClient, testDelete, testGet, testPatch, testPost, testPut, testRequest } from "./test-helpers.mjs";
+//#region ../../packages/core/src/tests/authenticated-test-client.d.ts
+/** Structural auth contract: an Auth model satisfies this without a runtime auth import. */
+export interface TestAuthenticableUser {
+  generateAccessToken(): Promise<{
+    token: string;
+  }>;
+  removeAccessToken(token: string): Promise<void>;
+}
+/** An isolated HTTP client using one real issued access token. */
+export type AuthenticatedTestClient = {
+  request: typeof testRequest;
+  get: typeof testGet;
+  post: typeof testPost;
+  put: typeof testPut;
+  patch: typeof testPatch;
+  delete: typeof testDelete;
+  /** Revoke only this client's token; fixtures still own their user/data cleanup. */
+  dispose(): Promise<void>;
+};
+/**
+ * Issue a real persisted access token and bind it to this client's requests.
+ * Authentication middleware still verifies every request; no globals or bypasses
+ * are installed. The bound identity takes precedence over per-request headers.
+ *
+ * Requests go to the shared test server, or through `client` — e.g. the one
+ * `createTestHttpServer()` returns (its own `actingAs()` passes it).
+ */
+export declare function actingAs(user: TestAuthenticableUser, client?: TestRequestClient): Promise<AuthenticatedTestClient>;
+//#endregion
+//# sourceMappingURL=authenticated-test-client.d.mts.map

package/esm/tests/authenticated-test-client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authenticated-test-client.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/tests/authenticated-test-client.ts"],"mappings":";;;iBAaiB;EACf,uBAAuB;IAAU;;EACjC,kBAAkB,gBAAgB;;;YAIxB;EACV,gBAAgB;EAChB,YAAY;EACZ,aAAa;EACb,YAAY;EACZ,cAAc;EACd,eAAe;;EAEf,WAAW;;;;;;;;;;wBAWS,SACpB,MAAM,uBACN,SAAQ,oBACP,QAAQ"}

package/esm/tests/authenticated-test-client.mjs

@@ -0,0 +1,40 @@
+import { createTestRequestClient, getTestServerUrl } from "./test-helpers.mjs";
+
+//#region ../../packages/core/src/tests/authenticated-test-client.ts
+/**
+* Issue a real persisted access token and bind it to this client's requests.
+* Authentication middleware still verifies every request; no globals or bypasses
+* are installed. The bound identity takes precedence over per-request headers.
+*
+* Requests go to the shared test server, or through `client` — e.g. the one
+* `createTestHttpServer()` returns (its own `actingAs()` passes it).
+*/
+async function actingAs(user, client = createTestRequestClient(getTestServerUrl)) {
+	if (process.env.NODE_ENV !== "test") throw new Error(`actingAs() requires NODE_ENV="test", but received NODE_ENV=${JSON.stringify(process.env.NODE_ENV)}. Set NODE_ENV=test before creating a test client.`);
+	const { token } = await user.generateAccessToken();
+	if (!token.trim()) {
+		await user.removeAccessToken(token).catch(() => void 0);
+		throw new Error("actingAs() requires a non-empty access token.");
+	}
+	const authorized = (options = {}) => {
+		const headers = new Headers(options.headers);
+		headers.set("authorization", `Bearer ${token}`);
+		return {
+			...options,
+			headers
+		};
+	};
+	return {
+		request: (path, options) => client.request(path, authorized(options)),
+		get: (path, options) => client.get(path, authorized(options)),
+		post: (path, body, options) => client.post(path, body, authorized(options)),
+		put: (path, body, options) => client.put(path, body, authorized(options)),
+		patch: (path, body, options) => client.patch(path, body, authorized(options)),
+		delete: (path, options) => client.delete(path, authorized(options)),
+		dispose: () => user.removeAccessToken(token)
+	};
+}
+
+//#endregion
+export { actingAs };
+//# sourceMappingURL=authenticated-test-client.mjs.map

package/esm/tests/authenticated-test-client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"authenticated-test-client.mjs","names":[],"sources":["../../../../../../../../packages/core/src/tests/authenticated-test-client.ts"],"sourcesContent":["import {\n  type TestRequestClient,\n  createTestRequestClient,\n  getTestServerUrl,\n  type testDelete,\n  type testGet,\n  type testPatch,\n  type testPost,\n  type testPut,\n  type testRequest,\n} from \"./test-helpers\";\n\n/** Structural auth contract: an Auth model satisfies this without a runtime auth import. */\nexport interface TestAuthenticableUser {\n  generateAccessToken(): Promise<{ token: string }>;\n  removeAccessToken(token: string): Promise<void>;\n}\n\n/** An isolated HTTP client using one real issued access token. */\nexport type AuthenticatedTestClient = {\n  request: typeof testRequest;\n  get: typeof testGet;\n  post: typeof testPost;\n  put: typeof testPut;\n  patch: typeof testPatch;\n  delete: typeof testDelete;\n  /** Revoke only this client's token; fixtures still own their user/data cleanup. */\n  dispose(): Promise<void>;\n};\n\n/**\n * Issue a real persisted access token and bind it to this client's requests.\n * Authentication middleware still verifies every request; no globals or bypasses\n * are installed. The bound identity takes precedence over per-request headers.\n *\n * Requests go to the shared test server, or through `client` — e.g. the one\n * `createTestHttpServer()` returns (its own `actingAs()` passes it).\n */\nexport async function actingAs(\n  user: TestAuthenticableUser,\n  client: TestRequestClient = createTestRequestClient(getTestServerUrl),\n): Promise<AuthenticatedTestClient> {\n  if (process.env.NODE_ENV !== \"test\") {\n    throw new Error(\n      `actingAs() requires NODE_ENV=\"test\", but received NODE_ENV=${JSON.stringify(process.env.NODE_ENV)}. Set NODE_ENV=test before creating a test client.`,\n    );\n  }\n  const { token } = await user.generateAccessToken();\n  if (!token.trim()) {\n    await user.removeAccessToken(token).catch(() => undefined);\n    throw new Error(\"actingAs() requires a non-empty access token.\");\n  }\n\n  const authorized = (options: RequestInit = {}): RequestInit => {\n    const headers = new Headers(options.headers);\n    headers.set(\"authorization\", `Bearer ${token}`);\n    return { ...options, headers };\n  };\n\n  return {\n    request: (path, options) => client.request(path, authorized(options)),\n    get: (path, options) => client.get(path, authorized(options)),\n    post: (path, body, options) => client.post(path, body, authorized(options)),\n    put: (path, body, options) => client.put(path, body, authorized(options)),\n    patch: (path, body, options) => client.patch(path, body, authorized(options)),\n    delete: (path, options) => client.delete(path, authorized(options)),\n    dispose: () => user.removeAccessToken(token),\n  };\n}\n"],"mappings":";;;;;;;;;;;AAsCA,eAAsB,SACpB,MACA,SAA4B,wBAAwB,gBAAgB,GAClC;CAClC,IAAI,QAAQ,IAAI,aAAa,QAC3B,MAAM,IAAI,MACR,8DAA8D,KAAK,UAAU,QAAQ,IAAI,QAAQ,EAAE,mDACrG;CAEF,MAAM,EAAE,UAAU,MAAM,KAAK,oBAAoB;CACjD,IAAI,CAAC,MAAM,KAAK,GAAG;EACjB,MAAM,KAAK,kBAAkB,KAAK,CAAC,CAAC,YAAY,MAAS;EACzD,MAAM,IAAI,MAAM,+CAA+C;CACjE;CAEA,MAAM,cAAc,UAAuB,CAAC,MAAmB;EAC7D,MAAM,UAAU,IAAI,QAAQ,QAAQ,OAAO;EAC3C,QAAQ,IAAI,iBAAiB,UAAU,OAAO;EAC9C,OAAO;GAAE,GAAG;GAAS;EAAQ;CAC/B;CAEA,OAAO;EACL,UAAU,MAAM,YAAY,OAAO,QAAQ,MAAM,WAAW,OAAO,CAAC;EACpE,MAAM,MAAM,YAAY,OAAO,IAAI,MAAM,WAAW,OAAO,CAAC;EAC5D,OAAO,MAAM,MAAM,YAAY,OAAO,KAAK,MAAM,MAAM,WAAW,OAAO,CAAC;EAC1E,MAAM,MAAM,MAAM,YAAY,OAAO,IAAI,MAAM,MAAM,WAAW,OAAO,CAAC;EACxE,QAAQ,MAAM,MAAM,YAAY,OAAO,MAAM,MAAM,MAAM,WAAW,OAAO,CAAC;EAC5E,SAAS,MAAM,YAAY,OAAO,OAAO,MAAM,WAAW,OAAO,CAAC;EAClE,eAAe,KAAK,kBAAkB,KAAK;CAC7C;AACF"}

package/esm/tests/factories.d.mts

@@ -0,0 +1,74 @@
+import { ChildModel, Model, ModelSchema } from "@warlock.js/cascade";
+//#region ../../packages/core/src/tests/factories.d.ts
+/** A model's schema type. */
+type SchemaOf<TModel extends Model> = TModel extends Model<infer TSchema> ? TSchema : ModelSchema;
+/** The attributes a model is created from: a partial of its schema, as `Model.create()` takes. */
+export type FactoryAttributes<TModel extends Model> = Partial<SchemaOf<TModel>>;
+/**
+ * Deterministic values for one record, derived only from its sequence number:
+ * the n-th record a factory builds is the same on every run, with no faker
+ * and no randomness.
+ */
+export type FactorySeed = {
+  /** 1 for the first record this factory builds, 2 for the second, ... */
+  readonly sequence: number;
+  /** Position within the current `makeMany()` / `createMany()` call, from 0. */
+  readonly index: number;
+  /** `"<prefix> <sequence>"`, e.g. `text("Post")` → `"Post 3"`. */
+  text(prefix?: string): string;
+  /** `"<prefix><sequence>@example.test"`, e.g. `"user3@example.test"`. */
+  email(prefix?: string): string;
+  /** A valid v4-shaped UUID numbered by the sequence. */
+  uuid(): string;
+  /** 2026-01-01T00:00:00Z plus `offsetDays` days. */
+  date(offsetDays?: number): Date;
+  /** An integer in `[min, max]`, cycling with the sequence. */
+  number(min?: number, max?: number): number;
+  /** One of `values`, cycling with the sequence. */
+  pick<T>(values: readonly T[]): T;
+};
+/** Overrides: a partial, or a function of the seed returning one. */
+export type FactoryOverrides<TAttributes> = Partial<TAttributes> | ((seed: FactorySeed) => Partial<TAttributes>);
+/** A named variation, applied on top of the definition (and earlier states). */
+export type FactoryState<TAttributes> = (seed: FactorySeed, attributes: TAttributes) => Partial<TAttributes>;
+export type Factory<TModel extends Model, TAttributes = FactoryAttributes<TModel>> = {
+  /** Build attributes without saving anything — no database needed. */
+  make(overrides?: FactoryOverrides<TAttributes>): TAttributes;
+  /** Build `count` attribute sets without saving anything. */
+  makeMany(count: number, overrides?: FactoryOverrides<TAttributes>): TAttributes[];
+  /** Create and save one record through `Model.create()`. */
+  create(overrides?: FactoryOverrides<TAttributes>): Promise<TModel>;
+  /** Create and save `count` records, one `Model.create()` each, in order. */
+  create(count: number, overrides?: FactoryOverrides<TAttributes>): Promise<TModel[]>;
+  /** Same as `create(count, overrides)`. */
+  createMany(count: number, overrides?: FactoryOverrides<TAttributes>): Promise<TModel[]>;
+  /** Register a named state on this factory; returns the factory for chaining. */
+  state(name: string, state: FactoryState<TAttributes>): Factory<TModel, TAttributes>;
+  /** A factory that applies the named states, in order, on top of the definition. */
+  with(...states: string[]): Factory<TModel, TAttributes>;
+  /** Restart this factory's sequence at 1. */
+  resetSequence(): void;
+};
+/** Restart every factory's sequence, e.g. in `beforeEach`. */
+export declare function resetFactorySequences(): void;
+/**
+ * Define a model factory: deterministic attributes for tests and seeders.
+ *
+ * `make()` builds attributes only (no database), `create()` saves through the
+ * model's own `create()`, so casts, defaults, hooks and events all run.
+ *
+ * @example
+ * export const userFactory = defineFactory(User, (seed) => ({
+ *   name: seed.text("User"),
+ *   email: seed.email(),
+ *   password: "test-password",
+ * })).state("admin", () => ({ role: "admin" }));
+ *
+ * const body = userFactory.make({ name: "Ada" });   // { name: "Ada", email: "user1@example.test", ... }
+ * const admin = await userFactory.with("admin").create();
+ * const users = await userFactory.create(3);
+ */
+export declare function defineFactory<TModel extends Model>(model: ChildModel<TModel>, definition: (seed: FactorySeed) => FactoryAttributes<TModel>): Factory<TModel>;
+//#endregion
+export {};
+//# sourceMappingURL=factories.d.mts.map

package/esm/tests/factories.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.d.mts","names":[],"sources":["../../../../../../../../packages/core/src/tests/factories.ts"],"mappings":";;;KAIK,SAAS,eAAe,SAAS,eAAe,YAAY,WAAW,UAAU;;YAG1E,kBAAkB,eAAe,SAAS,QAAQ,SAAS;;;;;;YAO3D;;WAED;;WAEA;;EAET,KAAK;;EAEL,MAAM;;EAEN;;EAEA,KAAK,sBAAsB;;EAE3B,OAAO,cAAc;;EAErB,KAAK,GAAG,iBAAiB,MAAM;;;YAIrB,iBAAiB,eACzB,QAAQ,iBACN,MAAM,gBAAgB,QAAQ;;YAGxB,aAAa,gBACvB,MAAM,aACN,YAAY,gBACT,QAAQ;YAED,QAAQ,eAAe,OAAO,cAAc,kBAAkB;;EAExE,KAAK,YAAY,iBAAiB,eAAe;;EAEjD,SAAS,eAAe,YAAY,iBAAiB,eAAe;;EAEpE,OAAO,YAAY,iBAAiB,eAAe,QAAQ;;EAE3D,OAAO,eAAe,YAAY,iBAAiB,eAAe,QAAQ;;EAE1E,WAAW,eAAe,YAAY,iBAAiB,eAAe,QAAQ;;EAE9E,MAAM,cAAc,OAAO,aAAa,eAAe,QAAQ,QAAQ;;EAEvE,QAAQ,mBAAmB,QAAQ,QAAQ;;EAE3C;;;wBAQc;;;;;;;;;;;;;;;;;;wBAqIA,cAAc,eAAe,OAC3C,OAAO,WAAW,SAClB,aAAa,MAAM,gBAAgB,kBAAkB,UACpD,QAAQ"}

package/esm/tests/factories.mjs

@@ -0,0 +1,105 @@
+import { DEFAULT_FAKE_NOW } from "./fakes/clock-fake.mjs";
+
+//#region ../../packages/core/src/tests/factories.ts
+const counters = /* @__PURE__ */ new Set();
+/** Restart every factory's sequence, e.g. in `beforeEach`. */
+function resetFactorySequences() {
+	for (const counter of counters) counter.value = 0;
+}
+function createSeed(sequence, index) {
+	return {
+		sequence,
+		index,
+		text: (prefix = "Text") => `${prefix} ${sequence}`,
+		email: (prefix = "user") => `${prefix}${sequence}@example.test`,
+		uuid: () => `00000000-0000-4000-8000-${String(sequence).padStart(12, "0")}`,
+		date: (offsetDays = 0) => new Date(DEFAULT_FAKE_NOW + offsetDays * 864e5),
+		number: (min = 1, max = 1e3) => {
+			if (max < min) throw new RangeError(`seed.number(${min}, ${max}): max is below min.`);
+			return min + (sequence - 1) % (max - min + 1);
+		},
+		pick: (values) => {
+			const value = values[(sequence - 1) % values.length];
+			if (value === void 0) throw new RangeError("seed.pick() needs at least one value.");
+			return value;
+		}
+	};
+}
+function buildFactory(model, definition, counter, states, applied) {
+	const build = (index, overrides) => {
+		counter.value += 1;
+		const seed = createSeed(counter.value, index);
+		let attributes = { ...definition(seed) };
+		for (const name of applied) {
+			const state = states.get(name);
+			if (!state) throw new Error(`Factory state "${name}" is not defined. Defined states: ${[...states.keys()].join(", ") || "(none)"}.`);
+			attributes = {
+				...attributes,
+				...state(seed, attributes)
+			};
+		}
+		const extra = typeof overrides === "function" ? overrides(seed) : overrides;
+		return {
+			...attributes,
+			...extra
+		};
+	};
+	const assertCount = (count) => {
+		if (!Number.isInteger(count) || count < 0) throw new RangeError(`A factory count must be a non-negative integer, got ${String(count)}.`);
+	};
+	const persist = (attributes) => model.create(attributes);
+	const createMany = async (count, overrides) => {
+		assertCount(count);
+		const records = [];
+		for (let index = 0; index < count; index++) records.push(await persist(build(index, overrides)));
+		return records;
+	};
+	function create(countOrOverrides, overrides) {
+		if (typeof countOrOverrides === "number") return createMany(countOrOverrides, overrides);
+		return persist(build(0, countOrOverrides));
+	}
+	const factory = {
+		make: (overrides) => build(0, overrides),
+		makeMany: (count, overrides) => {
+			assertCount(count);
+			return Array.from({ length: count }, (_, index) => build(index, overrides));
+		},
+		create,
+		createMany,
+		state: (name, state) => {
+			states.set(name, state);
+			return factory;
+		},
+		with: (...names) => buildFactory(model, definition, counter, states, [...applied, ...names]),
+		resetSequence: () => {
+			counter.value = 0;
+		}
+	};
+	return factory;
+}
+/**
+* Define a model factory: deterministic attributes for tests and seeders.
+*
+* `make()` builds attributes only (no database), `create()` saves through the
+* model's own `create()`, so casts, defaults, hooks and events all run.
+*
+* @example
+* export const userFactory = defineFactory(User, (seed) => ({
+*   name: seed.text("User"),
+*   email: seed.email(),
+*   password: "test-password",
+* })).state("admin", () => ({ role: "admin" }));
+*
+* const body = userFactory.make({ name: "Ada" });   // { name: "Ada", email: "user1@example.test", ... }
+* const admin = await userFactory.with("admin").create();
+* const users = await userFactory.create(3);
+*/
+function defineFactory(model, definition) {
+	const counter = { value: 0 };
+	counters.add(counter);
+	return buildFactory(model, definition, counter, /* @__PURE__ */ new Map(), []);
+}
+
+//#endregion
+export { defineFactory, resetFactorySequences };
+//# sourceMappingURL=factories.mjs.map

package/esm/tests/factories.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.mjs","names":[],"sources":["../../../../../../../../packages/core/src/tests/factories.ts"],"sourcesContent":["import type { ChildModel, Model, ModelSchema } from \"@warlock.js/cascade\";\nimport { DEFAULT_FAKE_NOW } from \"./fakes/clock-fake\";\n\n/** A model's schema type. */\ntype SchemaOf<TModel extends Model> = TModel extends Model<infer TSchema> ? TSchema : ModelSchema;\n\n/** The attributes a model is created from: a partial of its schema, as `Model.create()` takes. */\nexport type FactoryAttributes<TModel extends Model> = Partial<SchemaOf<TModel>>;\n\n/**\n * Deterministic values for one record, derived only from its sequence number:\n * the n-th record a factory builds is the same on every run, with no faker\n * and no randomness.\n */\nexport type FactorySeed = {\n  /** 1 for the first record this factory builds, 2 for the second, ... */\n  readonly sequence: number;\n  /** Position within the current `makeMany()` / `createMany()` call, from 0. */\n  readonly index: number;\n  /** `\"<prefix> <sequence>\"`, e.g. `text(\"Post\")` → `\"Post 3\"`. */\n  text(prefix?: string): string;\n  /** `\"<prefix><sequence>@example.test\"`, e.g. `\"user3@example.test\"`. */\n  email(prefix?: string): string;\n  /** A valid v4-shaped UUID numbered by the sequence. */\n  uuid(): string;\n  /** 2026-01-01T00:00:00Z plus `offsetDays` days. */\n  date(offsetDays?: number): Date;\n  /** An integer in `[min, max]`, cycling with the sequence. */\n  number(min?: number, max?: number): number;\n  /** One of `values`, cycling with the sequence. */\n  pick<T>(values: readonly T[]): T;\n};\n\n/** Overrides: a partial, or a function of the seed returning one. */\nexport type FactoryOverrides<TAttributes> =\n  | Partial<TAttributes>\n  | ((seed: FactorySeed) => Partial<TAttributes>);\n\n/** A named variation, applied on top of the definition (and earlier states). */\nexport type FactoryState<TAttributes> = (\n  seed: FactorySeed,\n  attributes: TAttributes,\n) => Partial<TAttributes>;\n\nexport type Factory<TModel extends Model, TAttributes = FactoryAttributes<TModel>> = {\n  /** Build attributes without saving anything — no database needed. */\n  make(overrides?: FactoryOverrides<TAttributes>): TAttributes;\n  /** Build `count` attribute sets without saving anything. */\n  makeMany(count: number, overrides?: FactoryOverrides<TAttributes>): TAttributes[];\n  /** Create and save one record through `Model.create()`. */\n  create(overrides?: FactoryOverrides<TAttributes>): Promise<TModel>;\n  /** Create and save `count` records, one `Model.create()` each, in order. */\n  create(count: number, overrides?: FactoryOverrides<TAttributes>): Promise<TModel[]>;\n  /** Same as `create(count, overrides)`. */\n  createMany(count: number, overrides?: FactoryOverrides<TAttributes>): Promise<TModel[]>;\n  /** Register a named state on this factory; returns the factory for chaining. */\n  state(name: string, state: FactoryState<TAttributes>): Factory<TModel, TAttributes>;\n  /** A factory that applies the named states, in order, on top of the definition. */\n  with(...states: string[]): Factory<TModel, TAttributes>;\n  /** Restart this factory's sequence at 1. */\n  resetSequence(): void;\n};\n\ntype SequenceCounter = { value: number };\n\nconst counters = new Set<SequenceCounter>();\n\n/** Restart every factory's sequence, e.g. in `beforeEach`. */\nexport function resetFactorySequences(): void {\n  for (const counter of counters) counter.value = 0;\n}\n\nfunction createSeed(sequence: number, index: number): FactorySeed {\n  return {\n    sequence,\n    index,\n    text: (prefix = \"Text\") => `${prefix} ${sequence}`,\n    email: (prefix = \"user\") => `${prefix}${sequence}@example.test`,\n    uuid: () => `00000000-0000-4000-8000-${String(sequence).padStart(12, \"0\")}`,\n    date: (offsetDays = 0) => new Date(DEFAULT_FAKE_NOW + offsetDays * 86_400_000),\n    number: (min = 1, max = 1000) => {\n      if (max < min) throw new RangeError(`seed.number(${min}, ${max}): max is below min.`);\n\n      return min + ((sequence - 1) % (max - min + 1));\n    },\n    pick: <T>(values: readonly T[]): T => {\n      const value = values[(sequence - 1) % values.length];\n\n      if (value === undefined) throw new RangeError(\"seed.pick() needs at least one value.\");\n\n      return value;\n    },\n  };\n}\n\nfunction buildFactory<TModel extends Model>(\n  model: ChildModel<TModel>,\n  definition: (seed: FactorySeed) => FactoryAttributes<TModel>,\n  counter: SequenceCounter,\n  states: Map<string, FactoryState<FactoryAttributes<TModel>>>,\n  applied: readonly string[],\n): Factory<TModel> {\n  type TAttributes = FactoryAttributes<TModel>;\n\n  const build = (index: number, overrides?: FactoryOverrides<TAttributes>): TAttributes => {\n    counter.value += 1;\n\n    const seed = createSeed(counter.value, index);\n    let attributes: TAttributes = { ...definition(seed) };\n\n    for (const name of applied) {\n      const state = states.get(name);\n\n      if (!state) {\n        throw new Error(\n          `Factory state \"${name}\" is not defined. Defined states: ${[...states.keys()].join(\", \") || \"(none)\"}.`,\n        );\n      }\n\n      attributes = { ...attributes, ...state(seed, attributes) };\n    }\n\n    const extra = typeof overrides === \"function\" ? overrides(seed) : overrides;\n\n    return { ...attributes, ...extra };\n  };\n\n  const assertCount = (count: number): void => {\n    if (!Number.isInteger(count) || count < 0) {\n      throw new RangeError(`A factory count must be a non-negative integer, got ${String(count)}.`);\n    }\n  };\n\n  const persist = (attributes: TAttributes): Promise<TModel> => model.create(attributes);\n\n  const createMany = async (\n    count: number,\n    overrides?: FactoryOverrides<TAttributes>,\n  ): Promise<TModel[]> => {\n    assertCount(count);\n\n    const records: TModel[] = [];\n\n    for (let index = 0; index < count; index++) {\n      records.push(await persist(build(index, overrides)));\n    }\n\n    return records;\n  };\n\n  function create(overrides?: FactoryOverrides<TAttributes>): Promise<TModel>;\n  function create(count: number, overrides?: FactoryOverrides<TAttributes>): Promise<TModel[]>;\n  function create(\n    countOrOverrides?: number | FactoryOverrides<TAttributes>,\n    overrides?: FactoryOverrides<TAttributes>,\n  ): Promise<TModel | TModel[]> {\n    if (typeof countOrOverrides === \"number\") return createMany(countOrOverrides, overrides);\n\n    return persist(build(0, countOrOverrides));\n  }\n\n  const factory: Factory<TModel> = {\n    make: (overrides) => build(0, overrides),\n    makeMany: (count, overrides) => {\n      assertCount(count);\n\n      return Array.from({ length: count }, (_, index) => build(index, overrides));\n    },\n    create,\n    createMany,\n    state: (name, state) => {\n      states.set(name, state);\n\n      return factory;\n    },\n    with: (...names) => buildFactory(model, definition, counter, states, [...applied, ...names]),\n    resetSequence: () => {\n      counter.value = 0;\n    },\n  };\n\n  return factory;\n}\n\n/**\n * Define a model factory: deterministic attributes for tests and seeders.\n *\n * `make()` builds attributes only (no database), `create()` saves through the\n * model's own `create()`, so casts, defaults, hooks and events all run.\n *\n * @example\n * export const userFactory = defineFactory(User, (seed) => ({\n *   name: seed.text(\"User\"),\n *   email: seed.email(),\n *   password: \"test-password\",\n * })).state(\"admin\", () => ({ role: \"admin\" }));\n *\n * const body = userFactory.make({ name: \"Ada\" });   // { name: \"Ada\", email: \"user1@example.test\", ... }\n * const admin = await userFactory.with(\"admin\").create();\n * const users = await userFactory.create(3);\n */\nexport function defineFactory<TModel extends Model>(\n  model: ChildModel<TModel>,\n  definition: (seed: FactorySeed) => FactoryAttributes<TModel>,\n): Factory<TModel> {\n  const counter: SequenceCounter = { value: 0 };\n\n  counters.add(counter);\n\n  return buildFactory<TModel>(model, definition, counter, new Map(), []);\n}\n"],"mappings":"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"}

package/esm/tests/fakes/cache-fake.d.mts

@@ -0,0 +1,34 @@
+import { CacheKey, MemoryCacheDriver } from "@warlock.js/cache";
+//#region ../../packages/core/src/tests/fakes/cache-fake.d.ts
+/**
+ * Swaps the cache's current driver for a fresh in-memory one.
+ *
+ * Installed by default in the test environment, so tests never need Redis
+ * and never see another test's keys. Everything goes through the real cache
+ * manager and the real memory driver: TTLs, tags, namespaces and locks behave
+ * as they do in production.
+ *
+ * @example
+ * await getDashboardStats(); // caches under "stats.dashboard"
+ *
+ * await cacheFake.assertHas("stats.dashboard");
+ */
+export declare const cacheFake: {
+  /** Start a fresh in-memory store (idempotent: a second call empties it). */
+  install(): Promise<void>;
+  /** Put the previous driver back and drop the in-memory store. */
+  restore(): Promise<void>;
+  isInstalled(): boolean;
+  /** The in-memory driver standing in for the configured one. */
+  driver(): MemoryCacheDriver;
+  /** Empty the store. */
+  clear(): Promise<void>;
+  /** Assert `key` is cached. */
+  assertHas(key: CacheKey): Promise<void>;
+  /** Assert `key` is not cached. */
+  assertMissing(key: CacheKey): Promise<void>;
+  /** Assert `key` holds a value deeply equal to `value`. */
+  assertStored(key: CacheKey, value: unknown): Promise<void>;
+};
+//#endregion
+//# sourceMappingURL=cache-fake.d.mts.map

package/esm/tests/fakes/cache-fake.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-fake.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/tests/fakes/cache-fake.ts"],"mappings":";;;;;;;;;;;;;;;qBA+Ba;;EAEL,WAAW;;EAkBX,WAAW;EAgBjB;;EAKA,UAAU;;EAKJ,SAAS;;EAKT,UAAS,KAAM,WAAW;;EAS1B,cAAa,KAAM,WAAW;;EAS9B,aAAY,KAAM,UAAQ,iBAAmB"}

package/esm/tests/fakes/cache-fake.mjs

@@ -0,0 +1,79 @@
+import { FakeAssertionError } from "./fake-assertion-error.mjs";
+import { MemoryCacheDriver, cache } from "@warlock.js/cache";
+import { isDeepStrictEqual } from "node:util";
+
+//#region ../../packages/core/src/tests/fakes/cache-fake.ts
+let fakeDriver;
+let previousDriver;
+let installed = false;
+function driver() {
+	if (!fakeDriver) throw new FakeAssertionError("cacheFake is not installed. It installs by default in the test environment; check `tests.fakes` in src/config/tests.ts, or call cacheFake.install().");
+	return fakeDriver;
+}
+/**
+* Swaps the cache's current driver for a fresh in-memory one.
+*
+* Installed by default in the test environment, so tests never need Redis
+* and never see another test's keys. Everything goes through the real cache
+* manager and the real memory driver: TTLs, tags, namespaces and locks behave
+* as they do in production.
+*
+* @example
+* await getDashboardStats(); // caches under "stats.dashboard"
+*
+* await cacheFake.assertHas("stats.dashboard");
+*/
+const cacheFake = {
+	/** Start a fresh in-memory store (idempotent: a second call empties it). */
+	async install() {
+		if (!installed) {
+			previousDriver = cache.currentDriver;
+			installed = true;
+		}
+		await fakeDriver?.disconnect();
+		const next = new MemoryCacheDriver();
+		next.setOptions({});
+		await next.connect();
+		fakeDriver = next;
+		await cache.use(next);
+	},
+	/** Put the previous driver back and drop the in-memory store. */
+	async restore() {
+		if (!installed) return;
+		const fake = fakeDriver;
+		fakeDriver = void 0;
+		installed = false;
+		if (previousDriver) await cache.use(previousDriver);
+		else cache.currentDriver = void 0;
+		previousDriver = void 0;
+		await fake?.disconnect();
+	},
+	isInstalled() {
+		return installed;
+	},
+	/** The in-memory driver standing in for the configured one. */
+	driver() {
+		return driver();
+	},
+	/** Empty the store. */
+	async clear() {
+		await driver().flush();
+	},
+	/** Assert `key` is cached. */
+	async assertHas(key) {
+		if (!await driver().has(key)) throw new FakeAssertionError(`Expected cache key ${JSON.stringify(key)} to be set. Cached keys: ${JSON.stringify(Object.keys(driver().data))}.`);
+	},
+	/** Assert `key` is not cached. */
+	async assertMissing(key) {
+		if (await driver().has(key)) throw new FakeAssertionError(`Expected cache key ${JSON.stringify(key)} not to be set, but it holds ${JSON.stringify(await driver().get(key))}.`);
+	},
+	/** Assert `key` holds a value deeply equal to `value`. */
+	async assertStored(key, value) {
+		const stored = await driver().get(key);
+		if (!isDeepStrictEqual(stored, value)) throw new FakeAssertionError(`Expected cache key ${JSON.stringify(key)} to hold ${JSON.stringify(value)}, but it holds ${JSON.stringify(stored)}.`);
+	}
+};
+
+//#endregion
+export { cacheFake };
+//# sourceMappingURL=cache-fake.mjs.map

package/esm/tests/fakes/cache-fake.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-fake.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/tests/fakes/cache-fake.ts"],"sourcesContent":["import { type CacheDriver, type CacheKey, MemoryCacheDriver, cache } from \"@warlock.js/cache\";\nimport { isDeepStrictEqual } from \"node:util\";\nimport { FakeAssertionError } from \"./fake-assertion-error\";\n\nlet fakeDriver: MemoryCacheDriver | undefined;\nlet previousDriver: CacheDriver<unknown, unknown> | undefined;\nlet installed = false;\n\nfunction driver(): MemoryCacheDriver {\n  if (!fakeDriver) {\n    throw new FakeAssertionError(\n      \"cacheFake is not installed. It installs by default in the test environment; check `tests.fakes` in src/config/tests.ts, or call cacheFake.install().\",\n    );\n  }\n\n  return fakeDriver;\n}\n\n/**\n * Swaps the cache's current driver for a fresh in-memory one.\n *\n * Installed by default in the test environment, so tests never need Redis\n * and never see another test's keys. Everything goes through the real cache\n * manager and the real memory driver: TTLs, tags, namespaces and locks behave\n * as they do in production.\n *\n * @example\n * await getDashboardStats(); // caches under \"stats.dashboard\"\n *\n * await cacheFake.assertHas(\"stats.dashboard\");\n */\nexport const cacheFake = {\n  /** Start a fresh in-memory store (idempotent: a second call empties it). */\n  async install(): Promise<void> {\n    if (!installed) {\n      previousDriver = cache.currentDriver;\n      installed = true;\n    }\n\n    await fakeDriver?.disconnect();\n\n    const next = new MemoryCacheDriver();\n\n    next.setOptions({});\n    await next.connect();\n\n    fakeDriver = next;\n    await cache.use(next);\n  },\n\n  /** Put the previous driver back and drop the in-memory store. */\n  async restore(): Promise<void> {\n    if (!installed) return;\n\n    const fake = fakeDriver;\n\n    fakeDriver = undefined;\n    installed = false;\n\n    if (previousDriver) await cache.use(previousDriver);\n    else cache.currentDriver = undefined;\n\n    previousDriver = undefined;\n\n    await fake?.disconnect();\n  },\n\n  isInstalled(): boolean {\n    return installed;\n  },\n\n  /** The in-memory driver standing in for the configured one. */\n  driver(): MemoryCacheDriver {\n    return driver();\n  },\n\n  /** Empty the store. */\n  async clear(): Promise<void> {\n    await driver().flush();\n  },\n\n  /** Assert `key` is cached. */\n  async assertHas(key: CacheKey): Promise<void> {\n    if (!(await driver().has(key))) {\n      throw new FakeAssertionError(\n        `Expected cache key ${JSON.stringify(key)} to be set. Cached keys: ${JSON.stringify(Object.keys(driver().data))}.`,\n      );\n    }\n  },\n\n  /** Assert `key` is not cached. */\n  async assertMissing(key: CacheKey): Promise<void> {\n    if (await driver().has(key)) {\n      throw new FakeAssertionError(\n        `Expected cache key ${JSON.stringify(key)} not to be set, but it holds ${JSON.stringify(await driver().get(key))}.`,\n      );\n    }\n  },\n\n  /** Assert `key` holds a value deeply equal to `value`. */\n  async assertStored(key: CacheKey, value: unknown): Promise<void> {\n    const stored: unknown = await driver().get(key);\n\n    if (!isDeepStrictEqual(stored, value)) {\n      throw new FakeAssertionError(\n        `Expected cache key ${JSON.stringify(key)} to hold ${JSON.stringify(value)}, but it holds ${JSON.stringify(stored)}.`,\n      );\n    }\n  },\n};\n"],"mappings":";;;;;AAIA,IAAI;AACJ,IAAI;AACJ,IAAI,YAAY;AAEhB,SAAS,SAA4B;CACnC,IAAI,CAAC,YACH,MAAM,IAAI,mBACR,sJACF;CAGF,OAAO;AACT;;;;;;;;;;;;;;AAeA,MAAa,YAAY;;CAEvB,MAAM,UAAyB;EAC7B,IAAI,CAAC,WAAW;GACd,iBAAiB,MAAM;GACvB,YAAY;EACd;EAEA,MAAM,YAAY,WAAW;EAE7B,MAAM,OAAO,IAAI,kBAAkB;EAEnC,KAAK,WAAW,CAAC,CAAC;EAClB,MAAM,KAAK,QAAQ;EAEnB,aAAa;EACb,MAAM,MAAM,IAAI,IAAI;CACtB;;CAGA,MAAM,UAAyB;EAC7B,IAAI,CAAC,WAAW;EAEhB,MAAM,OAAO;EAEb,aAAa;EACb,YAAY;EAEZ,IAAI,gBAAgB,MAAM,MAAM,IAAI,cAAc;OAC7C,MAAM,gBAAgB;EAE3B,iBAAiB;EAEjB,MAAM,MAAM,WAAW;CACzB;CAEA,cAAuB;EACrB,OAAO;CACT;;CAGA,SAA4B;EAC1B,OAAO,OAAO;CAChB;;CAGA,MAAM,QAAuB;EAC3B,MAAM,OAAO,CAAC,CAAC,MAAM;CACvB;;CAGA,MAAM,UAAU,KAA8B;EAC5C,IAAI,CAAE,MAAM,OAAO,CAAC,CAAC,IAAI,GAAG,GAC1B,MAAM,IAAI,mBACR,sBAAsB,KAAK,UAAU,GAAG,EAAE,2BAA2B,KAAK,UAAU,OAAO,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,EAClH;CAEJ;;CAGA,MAAM,cAAc,KAA8B;EAChD,IAAI,MAAM,OAAO,CAAC,CAAC,IAAI,GAAG,GACxB,MAAM,IAAI,mBACR,sBAAsB,KAAK,UAAU,GAAG,EAAE,+BAA+B,KAAK,UAAU,MAAM,OAAO,CAAC,CAAC,IAAI,GAAG,CAAC,EAAE,EACnH;CAEJ;;CAGA,MAAM,aAAa,KAAe,OAA+B;EAC/D,MAAM,SAAkB,MAAM,OAAO,CAAC,CAAC,IAAI,GAAG;EAE9C,IAAI,CAAC,kBAAkB,QAAQ,KAAK,GAClC,MAAM,IAAI,mBACR,sBAAsB,KAAK,UAAU,GAAG,EAAE,WAAW,KAAK,UAAU,KAAK,EAAE,iBAAiB,KAAK,UAAU,MAAM,EAAE,EACrH;CAEJ;AACF"}

package/esm/tests/fakes/clock-fake.d.mts

@@ -0,0 +1,37 @@
+//#region ../../packages/core/src/tests/fakes/clock-fake.d.ts
+/**
+ * The instant the fake clock starts at: 2026-01-01T00:00:00.000Z. Fixed so a
+ * snapshot or an expiry computed in a test is the same on every run.
+ */
+export declare const DEFAULT_FAKE_NOW: number;
+/**
+ * A frozen `clock` (from `@warlock.js/core`) that only moves when told to.
+ *
+ * Installed by default in the test environment, frozen at
+ * {@link DEFAULT_FAKE_NOW}. It replaces only the framework clock: `Date`,
+ * `setTimeout` and drivers keep real time, so nothing stalls.
+ *
+ * @example
+ * const token = await issueResetToken(user); // expires in 15 minutes
+ *
+ * clockFake.travel(16 * 60_000);
+ *
+ * expect(await isResetTokenValid(token)).toBe(false);
+ */
+export declare const clockFake: {
+  /** Freeze the clock at `at` (default {@link DEFAULT_FAKE_NOW}). */
+  install(at?: Date | string | number): void;
+  /** Hand the clock back to real time. */
+  restore(): void;
+  isInstalled(): boolean;
+  /** Freeze at a given instant (installs the fake if needed). */
+  freeze(at?: Date | string | number): Date;
+  /** Move the frozen clock by `milliseconds` (negative goes back). */
+  travel(milliseconds: number): Date;
+  /** Jump the frozen clock to an instant. */
+  travelTo(at: Date | string | number): Date;
+  /** The fake clock's current time. */
+  now(): Date;
+};
+//#endregion
+//# sourceMappingURL=clock-fake.d.mts.map

package/esm/tests/fakes/clock-fake.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock-fake.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/tests/fakes/clock-fake.ts"],"mappings":";;;;;qBAMa;;;;;;;;;;;;;;;qBA6BA;;EAEX,QAAO,KAAK;;EAOZ;EAMA;;EAKA,OAAM,KAAK,yBAA8D;;EAOzE,OAAM,uBAAwB;;EAS9B,SAAQ,IAAK,yBAAyB;;EAKtC,OAAO"}

package/esm/tests/fakes/clock-fake.mjs

@@ -0,0 +1,69 @@
+import { setClockSource } from "../../utils/clock.mjs";
+
+//#region ../../packages/core/src/tests/fakes/clock-fake.ts
+/**
+* The instant the fake clock starts at: 2026-01-01T00:00:00.000Z. Fixed so a
+* snapshot or an expiry computed in a test is the same on every run.
+*/
+const DEFAULT_FAKE_NOW = Date.UTC(2026, 0, 1, 0, 0, 0, 0);
+let now = DEFAULT_FAKE_NOW;
+let installed = false;
+function toTimestamp(value) {
+	const timestamp = value instanceof Date ? value.getTime() : new Date(value).getTime();
+	if (Number.isNaN(timestamp)) throw new RangeError(`clockFake cannot travel to ${JSON.stringify(value)}: not a valid date.`);
+	return timestamp;
+}
+/**
+* A frozen `clock` (from `@warlock.js/core`) that only moves when told to.
+*
+* Installed by default in the test environment, frozen at
+* {@link DEFAULT_FAKE_NOW}. It replaces only the framework clock: `Date`,
+* `setTimeout` and drivers keep real time, so nothing stalls.
+*
+* @example
+* const token = await issueResetToken(user); // expires in 15 minutes
+*
+* clockFake.travel(16 * 60_000);
+*
+* expect(await isResetTokenValid(token)).toBe(false);
+*/
+const clockFake = {
+	/** Freeze the clock at `at` (default {@link DEFAULT_FAKE_NOW}). */
+	install(at = DEFAULT_FAKE_NOW) {
+		now = toTimestamp(at);
+		installed = true;
+		setClockSource({ now: () => now });
+	},
+	/** Hand the clock back to real time. */
+	restore() {
+		installed = false;
+		now = DEFAULT_FAKE_NOW;
+		setClockSource(void 0);
+	},
+	isInstalled() {
+		return installed;
+	},
+	/** Freeze at a given instant (installs the fake if needed). */
+	freeze(at = installed ? now : DEFAULT_FAKE_NOW) {
+		clockFake.install(at);
+		return new Date(now);
+	},
+	/** Move the frozen clock by `milliseconds` (negative goes back). */
+	travel(milliseconds) {
+		if (!installed) clockFake.install();
+		now += milliseconds;
+		return new Date(now);
+	},
+	/** Jump the frozen clock to an instant. */
+	travelTo(at) {
+		return clockFake.freeze(at);
+	},
+	/** The fake clock's current time. */
+	now() {
+		return new Date(now);
+	}
+};
+
+//#endregion
+export { DEFAULT_FAKE_NOW, clockFake };
+//# sourceMappingURL=clock-fake.mjs.map

package/esm/tests/fakes/clock-fake.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock-fake.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/tests/fakes/clock-fake.ts"],"sourcesContent":["import { setClockSource } from \"../../utils/clock\";\n\n/**\n * The instant the fake clock starts at: 2026-01-01T00:00:00.000Z. Fixed so a\n * snapshot or an expiry computed in a test is the same on every run.\n */\nexport const DEFAULT_FAKE_NOW = Date.UTC(2026, 0, 1, 0, 0, 0, 0);\n\nlet now = DEFAULT_FAKE_NOW;\nlet installed = false;\n\nfunction toTimestamp(value: Date | string | number): number {\n  const timestamp = value instanceof Date ? value.getTime() : new Date(value).getTime();\n\n  if (Number.isNaN(timestamp)) {\n    throw new RangeError(`clockFake cannot travel to ${JSON.stringify(value)}: not a valid date.`);\n  }\n\n  return timestamp;\n}\n\n/**\n * A frozen `clock` (from `@warlock.js/core`) that only moves when told to.\n *\n * Installed by default in the test environment, frozen at\n * {@link DEFAULT_FAKE_NOW}. It replaces only the framework clock: `Date`,\n * `setTimeout` and drivers keep real time, so nothing stalls.\n *\n * @example\n * const token = await issueResetToken(user); // expires in 15 minutes\n *\n * clockFake.travel(16 * 60_000);\n *\n * expect(await isResetTokenValid(token)).toBe(false);\n */\nexport const clockFake = {\n  /** Freeze the clock at `at` (default {@link DEFAULT_FAKE_NOW}). */\n  install(at: Date | string | number = DEFAULT_FAKE_NOW): void {\n    now = toTimestamp(at);\n    installed = true;\n    setClockSource({ now: () => now });\n  },\n\n  /** Hand the clock back to real time. */\n  restore(): void {\n    installed = false;\n    now = DEFAULT_FAKE_NOW;\n    setClockSource(undefined);\n  },\n\n  isInstalled(): boolean {\n    return installed;\n  },\n\n  /** Freeze at a given instant (installs the fake if needed). */\n  freeze(at: Date | string | number = installed ? now : DEFAULT_FAKE_NOW): Date {\n    clockFake.install(at);\n\n    return new Date(now);\n  },\n\n  /** Move the frozen clock by `milliseconds` (negative goes back). */\n  travel(milliseconds: number): Date {\n    if (!installed) clockFake.install();\n\n    now += milliseconds;\n\n    return new Date(now);\n  },\n\n  /** Jump the frozen clock to an instant. */\n  travelTo(at: Date | string | number): Date {\n    return clockFake.freeze(at);\n  },\n\n  /** The fake clock's current time. */\n  now(): Date {\n    return new Date(now);\n  },\n};\n"],"mappings":";;;;;;;AAMA,MAAa,mBAAmB,KAAK,IAAI,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE/D,IAAI,MAAM;AACV,IAAI,YAAY;AAEhB,SAAS,YAAY,OAAuC;CAC1D,MAAM,YAAY,iBAAiB,OAAO,MAAM,QAAQ,IAAI,IAAI,KAAK,KAAK,CAAC,CAAC,QAAQ;CAEpF,IAAI,OAAO,MAAM,SAAS,GACxB,MAAM,IAAI,WAAW,8BAA8B,KAAK,UAAU,KAAK,EAAE,oBAAoB;CAG/F,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,MAAa,YAAY;;CAEvB,QAAQ,KAA6B,kBAAwB;EAC3D,MAAM,YAAY,EAAE;EACpB,YAAY;EACZ,eAAe,EAAE,WAAW,IAAI,CAAC;CACnC;;CAGA,UAAgB;EACd,YAAY;EACZ,MAAM;EACN,eAAe,MAAS;CAC1B;CAEA,cAAuB;EACrB,OAAO;CACT;;CAGA,OAAO,KAA6B,YAAY,MAAM,kBAAwB;EAC5E,UAAU,QAAQ,EAAE;EAEpB,OAAO,IAAI,KAAK,GAAG;CACrB;;CAGA,OAAO,cAA4B;EACjC,IAAI,CAAC,WAAW,UAAU,QAAQ;EAElC,OAAO;EAEP,OAAO,IAAI,KAAK,GAAG;CACrB;;CAGA,SAAS,IAAkC;EACzC,OAAO,UAAU,OAAO,EAAE;CAC5B;;CAGA,MAAY;EACV,OAAO,IAAI,KAAK,GAAG;CACrB;AACF"}

package/esm/tests/fakes/fake-assertion-error.d.mts

@@ -0,0 +1,12 @@
+//#region ../../packages/core/src/tests/fakes/fake-assertion-error.d.ts
+/**
+ * Thrown by a fake's `assert*` helper. The message says what was expected and
+ * lists what the fake actually recorded, so a failing test explains itself.
+ */
+export declare class FakeAssertionError extends Error {
+  constructor(message: string);
+}
+/** Render recorded entries for an assertion message, one per line. */
+export declare function describeRecorded<T>(entries: readonly T[], describe: (entry: T) => string, noun: string): string;
+//#endregion
+//# sourceMappingURL=fake-assertion-error.d.mts.map

package/esm/tests/fakes/fake-assertion-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-assertion-error.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/tests/fakes/fake-assertion-error.ts"],"mappings":";;;;;qBAIa,2BAA2B;EACtC,YAAmB;;;wBAQL,iBAAiB,GAC/B,kBAAkB,KAClB,WAAW,OAAO,cAClB"}

package/esm/tests/fakes/fake-assertion-error.mjs

@@ -0,0 +1,20 @@
+//#region ../../packages/core/src/tests/fakes/fake-assertion-error.ts
+/**
+* Thrown by a fake's `assert*` helper. The message says what was expected and
+* lists what the fake actually recorded, so a failing test explains itself.
+*/
+var FakeAssertionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FakeAssertionError";
+	}
+};
+/** Render recorded entries for an assertion message, one per line. */
+function describeRecorded(entries, describe, noun) {
+	if (entries.length === 0) return `Nothing was ${noun}.`;
+	return `${entries.length} ${entries.length === 1 ? "entry was" : "entries were"} ${noun}:\n${entries.map((entry, index) => `  ${index + 1}. ${describe(entry)}`).join("\n")}`;
+}
+
+//#endregion
+export { FakeAssertionError, describeRecorded };
+//# sourceMappingURL=fake-assertion-error.mjs.map

package/esm/tests/fakes/fake-assertion-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-assertion-error.mjs","names":[],"sources":["../../../../../../../../../packages/core/src/tests/fakes/fake-assertion-error.ts"],"sourcesContent":["/**\n * Thrown by a fake's `assert*` helper. The message says what was expected and\n * lists what the fake actually recorded, so a failing test explains itself.\n */\nexport class FakeAssertionError extends Error {\n  public constructor(message: string) {\n    super(message);\n\n    this.name = \"FakeAssertionError\";\n  }\n}\n\n/** Render recorded entries for an assertion message, one per line. */\nexport function describeRecorded<T>(\n  entries: readonly T[],\n  describe: (entry: T) => string,\n  noun: string,\n): string {\n  if (entries.length === 0) return `Nothing was ${noun}.`;\n\n  return `${entries.length} ${entries.length === 1 ? \"entry was\" : \"entries were\"} ${noun}:\\n${entries\n    .map((entry, index) => `  ${index + 1}. ${describe(entry)}`)\n    .join(\"\\n\")}`;\n}\n"],"mappings":";;;;;AAIA,IAAa,qBAAb,cAAwC,MAAM;CAC5C,AAAO,YAAY,SAAiB;EAClC,MAAM,OAAO;EAEb,KAAK,OAAO;CACd;AACF;;AAGA,SAAgB,iBACd,SACA,UACA,MACQ;CACR,IAAI,QAAQ,WAAW,GAAG,OAAO,eAAe,KAAK;CAErD,OAAO,GAAG,QAAQ,OAAO,GAAG,QAAQ,WAAW,IAAI,cAAc,eAAe,GAAG,KAAK,KAAK,QAC1F,KAAK,OAAO,UAAU,KAAK,QAAQ,EAAE,IAAI,SAAS,KAAK,GAAG,CAAC,CAC3D,KAAK,IAAI;AACd"}

package/esm/tests/fakes/ids-fake.d.mts

@@ -0,0 +1,23 @@
+//#region ../../packages/core/src/tests/fakes/ids-fake.d.ts
+/**
+ * Deterministic `ids` (from `@warlock.js/core`): numbered UUIDs and tokens.
+ *
+ * Installed by default in the test environment. Each sequence restarts on
+ * install and on `reset()`, so the n-th id in a test is the same on every run.
+ *
+ * @example
+ * const file = await storeReport(report); // named ids.uuid() + ".pdf"
+ *
+ * expect(file.path).toBe("reports/00000000-0000-4000-8000-000000000001.pdf");
+ */
+export declare const idsFake: {
+  install(): void;
+  restore(): void;
+  isInstalled(): boolean;
+  /** Restart both sequences. */
+  reset(): void;
+  /** The UUID the n-th `ids.uuid()` call returns (1-based). */
+  uuid(n: number): string;
+};
+//#endregion
+//# sourceMappingURL=ids-fake.d.mts.map

package/esm/tests/fakes/ids-fake.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids-fake.d.mts","names":[],"sources":["../../../../../../../../../packages/core/src/tests/fakes/ids-fake.ts"],"mappings":";;;;;;;;;;;;qBA6Ba;EACX;EASA;EAMA;;EAKA;;EAMA,KAAI"}