@vttforge/testing 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # @vttforge/testing
 
+## 0.3.0
+
+### Minor Changes
+
+- ae8dafb: `withMockFoundry` records sheets and enrichers.
+  
+  Registering a sheet through `registerSystem({ sheets })` goes via `foundry.applications.apps.DocumentSheetConfig`, which the mock did not have — so a consumer's boot test got "Foundry is not available" rather than a result. Enrichers landed on `CONFIG.TextEditor.enrichers` with no way to read them back.
+  
+  Both are now on the handle:
+  
+  ```ts
+  const foundry = withMockFoundry();
+  registerSystem({ id: 'my-system', sheets: [{ id: 'character', document: 'Actor', sheet: CharacterSheet }] });
+  foundry.callHook('init');
+  
+  foundry.sheets.map((s) => s.key); // ['my-system.character']
+  ```
+  
+  `key` is the assertion worth writing. Foundry saves it on every document whose owner picked the sheet and builds it from the class name, which a bundler is free to rename between builds — so pinning the key is pinning that the reader's choice survives your next release.
+  
+  `foundry.enrichers` reads back the namespaced id, pattern and `onRender`.
+
+## 0.2.0
+
+### Minor Changes
+
+- 6a39f2a: First real release. It was a three-line placeholder.
+  
+  Two entry points, because the two kinds of test run in different places.
+  
+  `@vttforge/testing/vitest` installs the Foundry globals a package reaches for and hands back a handle that records what your code registered — hooks, settings, notifications — so a test can assert on what happened rather than only on what did not throw. Every `@vttforge/core` test built this by hand, differently each time; that is the problem it solves.
+  
+  `@vttforge/testing/quench` registers a batch inside a live world, for what a mock cannot answer: a sheet that really draws, a socket with two clients, a document that round-trips through the database.
+  
+  Also ships ambient declarations for the globals, since a test that mocks Foundry then reads `game.settings` otherwise gets "Cannot find name 'game'".
+
+### Patch Changes
+
+- 9305156: The ambient globals now arrive with the import.
+  
+  They shipped as a separate `@vttforge/testing/globals` export, documented for `compilerOptions.types`. That does not work: `types` entries resolve against package roots, not subpath exports, and a consumer following the README got `Cannot find type definition file`.
+  
+  Importing from `@vttforge/testing/vitest` declares them instead — the import a test already writes is the moment it needs them, and there is nothing to configure.
+  
+  Found by using the package from `@vttforge/core`.
+- d015aee: Stop requiring Node 26 to install a browser package.
+  
+  Every package declared `engines.node: ">=26.0.0"`. Four of them — `core`, `styles`, `types` and `dev-module` — compile to ES2022 and run in the browser inside Foundry. They never touch Node, and the floor did nothing except stop anyone on Node 22 LTS from installing the SDK at all.
+  
+  Those four declare no engine now. `@vttforge/testing` drops to `>=22` — its Quench half runs in the browser too. `@vttforge/cli` and `@vttforge/vite-plugin` keep `>=26`, which is what they actually build against.
+
 ## 0.1.0
 
 ### Minor Changes

package/README.md

@@ -1,11 +1,71 @@
 # @vttforge/testing
 
-Test helpers and Foundry mocks for VTTForge consumers. Wraps Vitest (unit tests) and Quench (in-Foundry browser tests).
+Helpers for testing Foundry VTT packages.
 
-> **Status:** v0.0.1 placeholder. Implementation lands in v1.0.0.
+Two entry points, because the two kinds of test run in different places.
 
-## Planned scope (v1.0.0)
+## `@vttforge/testing/vitest`
 
-- Pre-built Foundry global mocks (`game`, `Hooks`, `CONFIG`, `Roll`, `ui.notifications`).
-- Quench test harness with VTTForge sheet helpers.
-- Snapshot helpers for `system.json` / `template.json` regression tests.
+Runs in CI against mocked globals. Covers everything up to the moment a window
+renders: data models, settings, hook registration, migrations, document
+updates.
+
+```ts
+import { createMockActor, withMockFoundry } from '@vttforge/testing/vitest';
+
+const foundry = withMockFoundry();
+registerMyModule();
+
+foundry.callHook('init');
+expect(foundry.settings[0].key).toBe('cacheSize');
+
+foundry.restore();
+```
+
+`withMockFoundry` installs `foundry`, `game`, `CONFIG`, `Hooks`, `ui` and
+`CONST`, and hands back a handle that records what your code registered — hooks,
+settings, notifications — so a test can assert on what happened rather than only
+on what did not throw. `restore()` puts every global back, including deleting the
+ones that never existed.
+
+The mock documents behave like real ones where it counts: `update` merges rather
+than replacing, and dotted paths expand. Both matter — a mock that replaces lets
+a test pass while the real thing drops every sibling key.
+
+### Naming the globals
+
+A test that reads `game.settings` would otherwise get "Cannot find name
+'game'". Importing from this entry declares them, so there is nothing to
+configure — the import a test already writes is what brings them.
+
+## `@vttforge/testing/quench`
+
+Runs inside a live world, for what a mock cannot answer: a sheet that really
+draws, a socket with two clients, a document that round-trips through the
+database.
+
+```ts
+import { registerBatch } from '@vttforge/testing/quench';
+
+registerBatch('my-module.sheets', ({ describe, it, assert }) => {
+  describe('character sheet', () => {
+    it('renders', async () => {
+      const actor = await Actor.create({ name: 'T', type: 'character' });
+      await actor.sheet.render(true);
+      assert.ok(actor.sheet.rendered);
+      await actor.delete();
+    });
+  });
+});
+```
+
+Safe to call at module scope: it waits for `quenchReady` rather than assuming
+Quench has loaded, which is the mistake that makes a batch silently never
+appear. Outside Foundry it is a no-op, so a file holding both kinds of test can
+still be imported by the vitest run.
+
+## Where the line sits
+
+Anything before `_renderHTML` is testable in Vitest. Real rendering is Quench's
+half. Reaching for a mock past that line produces tests that pass and tell you
+nothing.

package/dist/index-CcUzNUCI.d.mts

@@ -0,0 +1,151 @@
+//#region src/vitest/mock-foundry.d.ts
+/**
+ * A Foundry runtime, faked well enough to import a package and construct
+ * its classes.
+ *
+ * Every `@vttforge/core` test built this by hand before this existed, and no
+ * two built it quite the same way. That is the problem: the globals a package
+ * needs are not obvious, they are not documented anywhere, and you discover
+ * them one `ReferenceError` at a time.
+ *
+ * What this covers is the boundary the SDK actually sits on — everything up
+ * to the moment a window renders. `_renderHTML` and beyond needs a real
+ * browser and a real Foundry; that is what the Quench half is for.
+ */
+/** A Foundry document, as much of one as a unit test needs. */
+interface MockDocument {
+  id: string;
+  name: string;
+  type: string;
+  system: Record<string, any>;
+  flags: Record<string, Record<string, unknown>>;
+  getFlag(scope: string, key: string): unknown;
+  setFlag(scope: string, key: string, value: unknown): Promise<MockDocument>;
+  unsetFlag(scope: string, key: string): Promise<MockDocument>;
+  update(delta: Record<string, unknown>): Promise<MockDocument>;
+  /** Every update this document received, in order. */
+  readonly updates: ReadonlyArray<Record<string, unknown>>;
+}
+interface MockDocumentOptions {
+  id?: string;
+  name?: string;
+  type?: string;
+  system?: Record<string, any>;
+  flags?: Record<string, Record<string, unknown>>;
+}
+/** An Actor for a test. Its `updates` record what the code under test wrote. */
+declare function createMockActor(options?: MockDocumentOptions): MockDocument;
+/** An Item for a test. */
+declare function createMockItem(options?: MockDocumentOptions): MockDocument;
+//#endregion
+//#region src/vitest/with-mock-foundry.d.ts
+/**
+ * Install the Foundry globals a package needs, and take them away again.
+ *
+ * The globals are the awkward part of testing anything built on Foundry:
+ * `foundry`, `game`, `CONFIG`, `Hooks`, `ui`, `CONST`. A package touches some
+ * subset, the subset is not written down, and you find it one
+ * `ReferenceError` at a time.
+ *
+ * Everything here is a plain object or a recording stub, so a test can assert
+ * on what was registered rather than only on what did not throw.
+ */
+/** A hook registration the code under test made. */
+interface RecordedHook {
+  event: string;
+  once: boolean;
+  fn: (...args: unknown[]) => unknown;
+}
+/** A setting the code under test registered. */
+interface RecordedSetting {
+  namespace: string;
+  key: string;
+  config: Record<string, unknown>;
+}
+/** One `DocumentSheetConfig.registerSheet`, as VTTForge makes it. */
+interface RecordedSheet {
+  /** The key Foundry persists: `<package id>.<sheet id>`. */
+  readonly key: string;
+  /** The package that registered it. */
+  readonly scope: string;
+  /** The sheet id — the class name VTTForge pinned. */
+  readonly id: string;
+  readonly sheetClass: unknown;
+  readonly documentClass: unknown;
+  readonly options: Record<string, unknown>;
+}
+/** One entry pushed onto `CONFIG.TextEditor.enrichers`. */
+interface RecordedEnricher {
+  /** The namespaced id: `<package id>.<enricher id>`. */
+  readonly id: string;
+  readonly pattern: RegExp;
+  readonly onRender?: unknown;
+}
+interface MockFoundry {
+  /** Every `Hooks.on` and `Hooks.once`, in order. */
+  readonly hooks: ReadonlyArray<RecordedHook>;
+  /** Every `game.settings.register`, in order. */
+  readonly settings: ReadonlyArray<RecordedSetting>;
+  /** Every notification raised, by severity. */
+  readonly notifications: ReadonlyArray<{
+    level: 'info' | 'warn' | 'error';
+    message: string;
+  }>;
+  /**
+   * Every sheet registered, in order.
+   *
+   * `key` is the thing worth asserting: Foundry saves it on each document
+   * using the sheet, so a test that pins the key is a test that the reader's
+   * choice survives your next build.
+   */
+  readonly sheets: ReadonlyArray<RecordedSheet>;
+  /**
+   * Every text enricher registered, in order.
+   *
+   * `id` is namespaced, which is what stops a common name from colliding with
+   * another package — and what makes `onRender` fire at all.
+   */
+  readonly enrichers: ReadonlyArray<RecordedEnricher>;
+  /** Fire a hook the way Foundry would, for the listeners registered so far. */
+  callHook(event: string, ...args: unknown[]): unknown[];
+  /** Read back a registered setting's current value. */
+  getSetting(namespace: string, key: string): unknown;
+  /** Put every global back the way it was. */
+  restore(): void;
+}
+interface MockFoundryOptions {
+  /** The current user. Defaults to a GM, since most module code checks. */
+  user?: {
+    id?: string;
+    isGM?: boolean;
+    name?: string;
+  };
+  /** Extra `foundry.*` members, merged over the defaults. */
+  foundry?: Record<string, unknown>;
+  /** Extra `game.*` members, merged over the defaults. */
+  game?: Record<string, unknown>;
+}
+/**
+ * Stand up the globals, run the callback, tear them down.
+ *
+ * ```ts
+ * const foundry = withMockFoundry();
+ * registerMyModule();
+ * expect(foundry.hooks.map((h) => h.event)).toContain('init');
+ * foundry.restore();
+ * ```
+ */
+declare function withMockFoundry(options?: MockFoundryOptions): MockFoundry;
+//#endregion
+//#region src/vitest/index.d.ts
+declare global {
+  const foundry: any;
+  const game: any;
+  const CONFIG: any;
+  const Hooks: any;
+  const ui: any;
+  const CONST: any;
+}
+//#endregion
+export { RecordedSheet as a, createMockActor as c, RecordedSetting as i, createMockItem as l, RecordedEnricher as n, withMockFoundry as o, RecordedHook as r, MockDocument as s, MockFoundry as t };
+//# sourceMappingURL=index-CcUzNUCI.d.mts.map

package/dist/index-DLgaf8hZ.d.mts

@@ -0,0 +1,57 @@
+//#region src/quench/register-batch.d.ts
+/**
+ * Registering a Quench batch, for the tests that need a real Foundry.
+ *
+ * The vitest half covers everything up to the moment a window renders. Past
+ * that — a sheet that actually draws, a socket with two clients, a document
+ * that really round-trips through the database — needs the real thing, and
+ * Quench is how the community runs those from inside a running world.
+ *
+ * The whole ceremony is one `quenchReady` hook and a registration call, which
+ * everyone writes again and gets subtly wrong: register too early and Quench
+ * is not there, too late and the batch is missed.
+ */
+/** What Quench hands a batch to describe its cases. */
+interface QuenchContext {
+  describe(title: string, fn: () => void): void;
+  it(title: string, fn: () => unknown): void;
+  before(fn: () => unknown): void;
+  after(fn: () => unknown): void;
+  beforeEach(fn: () => unknown): void;
+  afterEach(fn: () => unknown): void;
+  assert: any;
+  expect: any;
+}
+interface BatchOptions {
+  /** Shown in the Quench window. Defaults to the batch id. */
+  displayName?: string;
+  /**
+   * Groups the batch in the Quench UI. Use your package id so a user running
+   * everything can tell whose failures are whose.
+   */
+  snapBaseline?: boolean;
+}
+/**
+ * Register a batch once Quench is ready.
+ *
+ * Safe to call at module scope — it waits for the hook rather than assuming
+ * Quench has loaded, which is the mistake that makes a batch silently never
+ * appear.
+ *
+ * ```ts
+ * registerBatch('my-module.sheets', ({ describe, it, assert }) => {
+ *   describe('character sheet', () => {
+ *     it('renders', async () => {
+ *       const actor = await Actor.create({ name: 'T', type: 'character' });
+ *       await actor.sheet.render(true);
+ *       assert.ok(actor.sheet.rendered);
+ *       await actor.delete();
+ *     });
+ *   });
+ * });
+ * ```
+ */
+declare function registerBatch(id: string, fn: (context: QuenchContext) => void, options?: BatchOptions): void;
+//#endregion
+export { QuenchContext as n, registerBatch as r, BatchOptions as t };
+//# sourceMappingURL=index-DLgaf8hZ.d.mts.map

package/dist/index.d.mts

@@ -1,8 +1,3 @@
-//#region src/index.d.ts
-/**
- * @vttforge/testing — placeholder. Implementation lands in v1.0.0.
- */
-declare const VTTFORGE_TESTING_VERSION = "0.0.1";
-//#endregion
-export { VTTFORGE_TESTING_VERSION };
-//# sourceMappingURL=index.d.mts.map
+import { n as QuenchContext, r as registerBatch, t as BatchOptions } from "./index-DLgaf8hZ.mjs";
+import { a as RecordedSheet, c as createMockActor, i as RecordedSetting, l as createMockItem, n as RecordedEnricher, o as withMockFoundry, r as RecordedHook, s as MockDocument, t as MockFoundry } from "./index-CcUzNUCI.mjs";
+export { type BatchOptions, type MockDocument, type MockFoundry, type QuenchContext, type RecordedEnricher, type RecordedHook, type RecordedSetting, type RecordedSheet, createMockActor, createMockItem, registerBatch, withMockFoundry };

package/dist/index.mjs

@@ -1,9 +1,3 @@
-//#region src/index.ts
-/**
-* @vttforge/testing — placeholder. Implementation lands in v1.0.0.
-*/
-const VTTFORGE_TESTING_VERSION = "0.0.1";
-//#endregion
-export { VTTFORGE_TESTING_VERSION };
-
-//# sourceMappingURL=index.mjs.map
+import { t as registerBatch } from "./quench-CdVnhmcA.mjs";
+import { n as createMockActor, r as createMockItem, t as withMockFoundry } from "./vitest-D0qlXJeT.mjs";
+export { createMockActor, createMockItem, registerBatch, withMockFoundry };

package/dist/quench/index.d.mts

@@ -0,0 +1,2 @@
+import { n as QuenchContext, r as registerBatch, t as BatchOptions } from "../index-DLgaf8hZ.mjs";
+export { type BatchOptions, type QuenchContext, registerBatch };

package/dist/quench/index.mjs

@@ -0,0 +1,2 @@
+import { t as registerBatch } from "../quench-CdVnhmcA.mjs";
+export { registerBatch };

package/dist/quench-CdVnhmcA.mjs

@@ -0,0 +1,35 @@
+//#region src/quench/register-batch.ts
+/**
+* Register a batch once Quench is ready.
+*
+* Safe to call at module scope — it waits for the hook rather than assuming
+* Quench has loaded, which is the mistake that makes a batch silently never
+* appear.
+*
+* ```ts
+* registerBatch('my-module.sheets', ({ describe, it, assert }) => {
+*   describe('character sheet', () => {
+*     it('renders', async () => {
+*       const actor = await Actor.create({ name: 'T', type: 'character' });
+*       await actor.sheet.render(true);
+*       assert.ok(actor.sheet.rendered);
+*       await actor.delete();
+*     });
+*   });
+* });
+* ```
+*/
+function registerBatch(id, fn, options = {}) {
+	const hooks = globalThis.Hooks;
+	if (!hooks?.once) return;
+	hooks.once("quenchReady", (quench) => {
+		quench.registerBatch(id, fn, {
+			displayName: options.displayName ?? id,
+			...options
+		});
+	});
+}
+//#endregion
+export { registerBatch as t };
+
+//# sourceMappingURL=quench-CdVnhmcA.mjs.map

package/dist/quench-CdVnhmcA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"quench-CdVnhmcA.mjs","names":[],"sources":["../src/quench/register-batch.ts"],"sourcesContent":["/**\n * Registering a Quench batch, for the tests that need a real Foundry.\n *\n * The vitest half covers everything up to the moment a window renders. Past\n * that — a sheet that actually draws, a socket with two clients, a document\n * that really round-trips through the database — needs the real thing, and\n * Quench is how the community runs those from inside a running world.\n *\n * The whole ceremony is one `quenchReady` hook and a registration call, which\n * everyone writes again and gets subtly wrong: register too early and Quench\n * is not there, too late and the batch is missed.\n */\n\n/** What Quench hands a batch to describe its cases. */\nexport interface QuenchContext {\n  describe(title: string, fn: () => void): void;\n  it(title: string, fn: () => unknown): void;\n  before(fn: () => unknown): void;\n  after(fn: () => unknown): void;\n  beforeEach(fn: () => unknown): void;\n  afterEach(fn: () => unknown): void;\n  // biome-ignore lint/suspicious/noExplicitAny: Quench bundles chai, whose assert surface is its own\n  assert: any;\n  // biome-ignore lint/suspicious/noExplicitAny: chai's expect, likewise\n  expect: any;\n}\n\nexport interface BatchOptions {\n  /** Shown in the Quench window. Defaults to the batch id. */\n  displayName?: string;\n  /**\n   * Groups the batch in the Quench UI. Use your package id so a user running\n   * everything can tell whose failures are whose.\n   */\n  snapBaseline?: boolean;\n}\n\ninterface QuenchApi {\n  registerBatch(\n    id: string,\n    fn: (context: QuenchContext) => void,\n    options?: Record<string, unknown>,\n  ): void;\n}\n\n/**\n * Register a batch once Quench is ready.\n *\n * Safe to call at module scope — it waits for the hook rather than assuming\n * Quench has loaded, which is the mistake that makes a batch silently never\n * appear.\n *\n * ```ts\n * registerBatch('my-module.sheets', ({ describe, it, assert }) => {\n *   describe('character sheet', () => {\n *     it('renders', async () => {\n *       const actor = await Actor.create({ name: 'T', type: 'character' });\n *       await actor.sheet.render(true);\n *       assert.ok(actor.sheet.rendered);\n *       await actor.delete();\n *     });\n *   });\n * });\n * ```\n */\nexport function registerBatch(\n  id: string,\n  fn: (context: QuenchContext) => void,\n  options: BatchOptions = {},\n): void {\n  const hooks = (globalThis as Record<string, unknown>).Hooks as\n    | { once(event: string, cb: (quench: QuenchApi) => void): void }\n    | undefined;\n\n  if (!hooks?.once) {\n    // No Foundry here at all. Quench batches only mean anything inside a\n    // running world, so this is a no-op rather than an error — it lets a file\n    // holding both kinds of test be imported by the vitest run.\n    return;\n  }\n\n  hooks.once('quenchReady', (quench) => {\n    quench.registerBatch(id, fn, { displayName: options.displayName ?? id, ...options });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,cACd,IACA,IACA,UAAwB,CAAC,GACnB;CACN,MAAM,QAAS,WAAuC;CAItD,IAAI,CAAC,OAAO,MAIV;CAGF,MAAM,KAAK,gBAAgB,WAAW;EACpC,OAAO,cAAc,IAAI,IAAI;GAAE,aAAa,QAAQ,eAAe;GAAI,GAAG;EAAQ,CAAC;CACrF,CAAC;AACH"}

package/dist/vitest/index.d.mts

@@ -0,0 +1,2 @@
+import { a as RecordedSheet, c as createMockActor, i as RecordedSetting, l as createMockItem, n as RecordedEnricher, o as withMockFoundry, r as RecordedHook, s as MockDocument, t as MockFoundry } from "../index-CcUzNUCI.mjs";
+export { type MockDocument, type MockFoundry, type RecordedEnricher, type RecordedHook, type RecordedSetting, type RecordedSheet, createMockActor, createMockItem, withMockFoundry };

package/dist/vitest/index.mjs

@@ -0,0 +1,2 @@
+import { n as createMockActor, r as createMockItem, t as withMockFoundry } from "../vitest-D0qlXJeT.mjs";
+export { createMockActor, createMockItem, withMockFoundry };

package/dist/vitest-D0qlXJeT.mjs

@@ -0,0 +1,307 @@
+//#region src/vitest/mock-foundry.ts
+let nextId = 0;
+/** `{'system.hp.value': 3}` → `{system: {hp: {value: 3}}}`. */
+function expand(flat) {
+	const out = {};
+	for (const [path, value] of Object.entries(flat)) {
+		const parts = path.split(".");
+		const last = parts.pop();
+		if (!last) continue;
+		let target = out;
+		for (const part of parts) {
+			target[part] ??= {};
+			target = target[part];
+		}
+		target[last] = value;
+	}
+	return out;
+}
+/** Deep-merge, the way a document update behaves. Arrays replace wholesale. */
+function merge(target, source) {
+	for (const [key, value] of Object.entries(source)) if (value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype) {
+		if (typeof target[key] !== "object" || target[key] === null) target[key] = {};
+		merge(target[key], value);
+	} else target[key] = value;
+}
+function createMockDocument(kind, options = {}) {
+	nextId += 1;
+	const updates = [];
+	const doc = {
+		id: options.id ?? `${kind}${String(nextId).padStart(12, "0")}`,
+		name: options.name ?? `Test ${kind}`,
+		type: options.type ?? "base",
+		system: options.system ?? {},
+		flags: options.flags ?? {},
+		updates,
+		getFlag: (scope, key) => doc.flags[scope]?.[key],
+		setFlag: async (scope, key, value) => {
+			doc.flags[scope] ??= {};
+			doc.flags[scope][key] = value;
+			return doc;
+		},
+		unsetFlag: async (scope, key) => {
+			delete doc.flags[scope]?.[key];
+			return doc;
+		},
+		/**
+		* Records the delta and merges it in.
+		*
+		* Merges, not replaces — which is what Foundry does and what a mock has
+		* to match. Assigning `{system: {hp: {value: 4}}}` wholesale drops
+		* `hp.max`, and a test written against that passes while the real thing
+		* loses data.
+		*
+		* Dotted keys are expanded first, because that is how updates arrive.
+		*/
+		update: async (delta) => {
+			updates.push(delta);
+			merge(doc, expand(delta));
+			return doc;
+		}
+	};
+	return doc;
+}
+/** An Actor for a test. Its `updates` record what the code under test wrote. */
+function createMockActor(options = {}) {
+	return createMockDocument("Actor", {
+		type: "character",
+		...options
+	});
+}
+/** An Item for a test. */
+function createMockItem(options = {}) {
+	return createMockDocument("Item", {
+		type: "base",
+		...options
+	});
+}
+//#endregion
+//#region src/vitest/with-mock-foundry.ts
+const GLOBALS = [
+	"foundry",
+	"game",
+	"CONFIG",
+	"Hooks",
+	"ui",
+	"CONST"
+];
+/**
+* Flatten and expand, the way `foundry.utils` does.
+*
+* Provided because SDK code calls them on the global, not because a test
+* needs them: leaving them out means every consumer stubs them again.
+*/
+function flattenObject(obj, prefix = "") {
+	const flat = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype && Object.keys(value).length > 0) Object.assign(flat, flattenObject(value, path));
+		else flat[path] = value;
+	}
+	return flat;
+}
+function expandObject(flat) {
+	const out = {};
+	for (const [path, value] of Object.entries(flat)) {
+		const parts = path.split(".");
+		const last = parts.pop();
+		if (!last) continue;
+		let target = out;
+		for (const part of parts) {
+			target[part] ??= {};
+			target = target[part];
+		}
+		target[last] = value;
+	}
+	return out;
+}
+/**
+* Stand up the globals, run the callback, tear them down.
+*
+* ```ts
+* const foundry = withMockFoundry();
+* registerMyModule();
+* expect(foundry.hooks.map((h) => h.event)).toContain('init');
+* foundry.restore();
+* ```
+*/
+function withMockFoundry(options = {}) {
+	const saved = /* @__PURE__ */ new Map();
+	const scope = globalThis;
+	for (const name of GLOBALS) saved.set(name, scope[name]);
+	const hooks = [];
+	const settings = [];
+	const values = /* @__PURE__ */ new Map();
+	const notifications = [];
+	const Hooks = {
+		on: (event, fn) => {
+			hooks.push({
+				event,
+				once: false,
+				fn
+			});
+			return hooks.length;
+		},
+		once: (event, fn) => {
+			hooks.push({
+				event,
+				once: true,
+				fn
+			});
+			return hooks.length;
+		},
+		off: () => {},
+		call: (event, ...args) => callHook(event, ...args).every((r) => r !== false),
+		callAll: (event, ...args) => {
+			callHook(event, ...args);
+			return true;
+		}
+	};
+	function callHook(event, ...args) {
+		return hooks.filter((h) => h.event === event).map((h) => h.fn(...args));
+	}
+	const user = {
+		id: "user000000000001",
+		isGM: true,
+		name: "Gamemaster",
+		...options.user
+	};
+	const sheets = [];
+	const enrichers = [];
+	scope.Hooks = Hooks;
+	scope.CONST = { DOCUMENT_OWNERSHIP_LEVELS: {
+		NONE: 0,
+		LIMITED: 1,
+		OBSERVER: 2,
+		OWNER: 3
+	} };
+	scope.CONFIG = {
+		Actor: {
+			dataModels: {},
+			sheetClasses: {}
+		},
+		Item: {
+			dataModels: {},
+			sheetClasses: {}
+		},
+		TextEditor: { enrichers },
+		Combat: {},
+		ActiveEffect: {},
+		statusEffects: [],
+		debug: { hooks: false }
+	};
+	scope.ui = { notifications: {
+		info: (m) => notifications.push({
+			level: "info",
+			message: m
+		}),
+		warn: (m) => notifications.push({
+			level: "warn",
+			message: m
+		}),
+		error: (m) => notifications.push({
+			level: "error",
+			message: m
+		})
+	} };
+	scope.foundry = {
+		utils: {
+			flattenObject,
+			expandObject,
+			mergeObject: (a, b) => ({
+				...a,
+				...b
+			}),
+			deepClone: (v) => structuredClone(v),
+			randomID: () => Math.random().toString(36).slice(2, 18),
+			isNewerVersion: (a, b) => a.localeCompare(b, void 0, { numeric: true }) > 0
+		},
+		abstract: {
+			TypeDataModel: class {},
+			DataModel: class {},
+			Document: class {}
+		},
+		data: { fields: {} },
+		applications: {
+			api: {
+				ApplicationV2: class {},
+				HandlebarsApplicationMixin: (b) => b
+			},
+			sheets: {
+				ActorSheetV2: class {},
+				ItemSheetV2: class {}
+			},
+			apps: { DocumentSheetConfig: {
+				registerSheet(documentClass, scope, sheetClass, sheetOptions = {}) {
+					sheets.push({
+						key: `${scope}.${sheetClass.name}`,
+						scope,
+						id: sheetClass.name,
+						sheetClass,
+						documentClass,
+						options: sheetOptions
+					});
+				},
+				unregisterSheet: () => {}
+			} },
+			ux: {},
+			instances: /* @__PURE__ */ new Map()
+		},
+		documents: { collections: {
+			Actors: {
+				registerSheet: () => {},
+				unregisterSheet: () => {}
+			},
+			Items: {
+				registerSheet: () => {},
+				unregisterSheet: () => {}
+			}
+		} },
+		...options.foundry
+	};
+	scope.game = {
+		user,
+		userId: user.id,
+		ready: true,
+		modules: /* @__PURE__ */ new Map(),
+		actors: [],
+		items: [],
+		i18n: {
+			localize: (key) => key,
+			format: (key, data) => `${key} ${JSON.stringify(data)}`
+		},
+		settings: {
+			register: (namespace, key, config) => {
+				settings.push({
+					namespace,
+					key,
+					config
+				});
+				values.set(`${namespace}.${key}`, config.default);
+			},
+			get: (namespace, key) => values.get(`${namespace}.${key}`),
+			set: async (namespace, key, value) => {
+				values.set(`${namespace}.${key}`, value);
+				return value;
+			}
+		},
+		...options.game
+	};
+	return {
+		hooks,
+		settings,
+		notifications,
+		sheets,
+		enrichers,
+		callHook,
+		getSetting: (namespace, key) => values.get(`${namespace}.${key}`),
+		restore() {
+			for (const [name, value] of saved) if (value === void 0) delete scope[name];
+			else scope[name] = value;
+		}
+	};
+}
+//#endregion
+export { createMockActor as n, createMockItem as r, withMockFoundry as t };
+
+//# sourceMappingURL=vitest-D0qlXJeT.mjs.map

package/dist/vitest-D0qlXJeT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-D0qlXJeT.mjs","names":[],"sources":["../src/vitest/mock-foundry.ts","../src/vitest/with-mock-foundry.ts"],"sourcesContent":["/**\n * A Foundry runtime, faked well enough to import a package and construct\n * its classes.\n *\n * Every `@vttforge/core` test built this by hand before this existed, and no\n * two built it quite the same way. That is the problem: the globals a package\n * needs are not obvious, they are not documented anywhere, and you discover\n * them one `ReferenceError` at a time.\n *\n * What this covers is the boundary the SDK actually sits on — everything up\n * to the moment a window renders. `_renderHTML` and beyond needs a real\n * browser and a real Foundry; that is what the Quench half is for.\n */\n\n/** A Foundry document, as much of one as a unit test needs. */\nexport interface MockDocument {\n  id: string;\n  name: string;\n  type: string;\n  // biome-ignore lint/suspicious/noExplicitAny: a document's system data is whatever its schema says\n  system: Record<string, any>;\n  flags: Record<string, Record<string, unknown>>;\n  getFlag(scope: string, key: string): unknown;\n  setFlag(scope: string, key: string, value: unknown): Promise<MockDocument>;\n  unsetFlag(scope: string, key: string): Promise<MockDocument>;\n  update(delta: Record<string, unknown>): Promise<MockDocument>;\n  /** Every update this document received, in order. */\n  readonly updates: ReadonlyArray<Record<string, unknown>>;\n}\n\ninterface MockDocumentOptions {\n  id?: string;\n  name?: string;\n  type?: string;\n  // biome-ignore lint/suspicious/noExplicitAny: mirrors MockDocument.system\n  system?: Record<string, any>;\n  flags?: Record<string, Record<string, unknown>>;\n}\n\nlet nextId = 0;\n\n/** `{'system.hp.value': 3}` → `{system: {hp: {value: 3}}}`. */\nfunction expand(flat: Record<string, unknown>): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const [path, value] of Object.entries(flat)) {\n    const parts = path.split('.');\n    const last = parts.pop();\n    if (!last) continue;\n    let target = out;\n    for (const part of parts) {\n      target[part] ??= {};\n      target = target[part] as Record<string, unknown>;\n    }\n    target[last] = value;\n  }\n  return out;\n}\n\n/** Deep-merge, the way a document update behaves. Arrays replace wholesale. */\nfunction merge(target: Record<string, unknown>, source: Record<string, unknown>): void {\n  for (const [key, value] of Object.entries(source)) {\n    const isPlain =\n      value !== null &&\n      typeof value === 'object' &&\n      !Array.isArray(value) &&\n      Object.getPrototypeOf(value) === Object.prototype;\n    if (isPlain) {\n      if (typeof target[key] !== 'object' || target[key] === null) target[key] = {};\n      merge(target[key] as Record<string, unknown>, value as Record<string, unknown>);\n    } else {\n      target[key] = value;\n    }\n  }\n}\n\nfunction createMockDocument(kind: string, options: MockDocumentOptions = {}): MockDocument {\n  nextId += 1;\n  const updates: Record<string, unknown>[] = [];\n\n  const doc: MockDocument = {\n    id: options.id ?? `${kind}${String(nextId).padStart(12, '0')}`,\n    name: options.name ?? `Test ${kind}`,\n    type: options.type ?? 'base',\n    system: options.system ?? {},\n    flags: options.flags ?? {},\n    updates,\n\n    getFlag: (scope, key) => doc.flags[scope]?.[key],\n\n    setFlag: async (scope, key, value) => {\n      doc.flags[scope] ??= {};\n      doc.flags[scope][key] = value;\n      return doc;\n    },\n\n    unsetFlag: async (scope, key) => {\n      delete doc.flags[scope]?.[key];\n      return doc;\n    },\n\n    /**\n     * Records the delta and merges it in.\n     *\n     * Merges, not replaces — which is what Foundry does and what a mock has\n     * to match. Assigning `{system: {hp: {value: 4}}}` wholesale drops\n     * `hp.max`, and a test written against that passes while the real thing\n     * loses data.\n     *\n     * Dotted keys are expanded first, because that is how updates arrive.\n     */\n    update: async (delta) => {\n      updates.push(delta);\n      merge(doc as unknown as Record<string, unknown>, expand(delta));\n      return doc;\n    },\n  };\n\n  return doc;\n}\n\n/** An Actor for a test. Its `updates` record what the code under test wrote. */\nexport function createMockActor(options: MockDocumentOptions = {}): MockDocument {\n  return createMockDocument('Actor', { type: 'character', ...options });\n}\n\n/** An Item for a test. */\nexport function createMockItem(options: MockDocumentOptions = {}): MockDocument {\n  return createMockDocument('Item', { type: 'base', ...options });\n}\n","/**\n * Install the Foundry globals a package needs, and take them away again.\n *\n * The globals are the awkward part of testing anything built on Foundry:\n * `foundry`, `game`, `CONFIG`, `Hooks`, `ui`, `CONST`. A package touches some\n * subset, the subset is not written down, and you find it one\n * `ReferenceError` at a time.\n *\n * Everything here is a plain object or a recording stub, so a test can assert\n * on what was registered rather than only on what did not throw.\n */\n\n/** A hook registration the code under test made. */\nexport interface RecordedHook {\n  event: string;\n  once: boolean;\n  fn: (...args: unknown[]) => unknown;\n}\n\n/** A setting the code under test registered. */\nexport interface RecordedSetting {\n  namespace: string;\n  key: string;\n  config: Record<string, unknown>;\n}\n\n/** One `DocumentSheetConfig.registerSheet`, as VTTForge makes it. */\nexport interface RecordedSheet {\n  /** The key Foundry persists: `<package id>.<sheet id>`. */\n  readonly key: string;\n  /** The package that registered it. */\n  readonly scope: string;\n  /** The sheet id — the class name VTTForge pinned. */\n  readonly id: string;\n  readonly sheetClass: unknown;\n  readonly documentClass: unknown;\n  readonly options: Record<string, unknown>;\n}\n\n/** One entry pushed onto `CONFIG.TextEditor.enrichers`. */\nexport interface RecordedEnricher {\n  /** The namespaced id: `<package id>.<enricher id>`. */\n  readonly id: string;\n  readonly pattern: RegExp;\n  readonly onRender?: unknown;\n}\n\nexport interface MockFoundry {\n  /** Every `Hooks.on` and `Hooks.once`, in order. */\n  readonly hooks: ReadonlyArray<RecordedHook>;\n  /** Every `game.settings.register`, in order. */\n  readonly settings: ReadonlyArray<RecordedSetting>;\n  /** Every notification raised, by severity. */\n  readonly notifications: ReadonlyArray<{ level: 'info' | 'warn' | 'error'; message: string }>;\n  /**\n   * Every sheet registered, in order.\n   *\n   * `key` is the thing worth asserting: Foundry saves it on each document\n   * using the sheet, so a test that pins the key is a test that the reader's\n   * choice survives your next build.\n   */\n  readonly sheets: ReadonlyArray<RecordedSheet>;\n  /**\n   * Every text enricher registered, in order.\n   *\n   * `id` is namespaced, which is what stops a common name from colliding with\n   * another package — and what makes `onRender` fire at all.\n   */\n  readonly enrichers: ReadonlyArray<RecordedEnricher>;\n  /** Fire a hook the way Foundry would, for the listeners registered so far. */\n  callHook(event: string, ...args: unknown[]): unknown[];\n  /** Read back a registered setting's current value. */\n  getSetting(namespace: string, key: string): unknown;\n  /** Put every global back the way it was. */\n  restore(): void;\n}\n\ninterface MockFoundryOptions {\n  /** The current user. Defaults to a GM, since most module code checks. */\n  user?: { id?: string; isGM?: boolean; name?: string };\n  /** Extra `foundry.*` members, merged over the defaults. */\n  foundry?: Record<string, unknown>;\n  /** Extra `game.*` members, merged over the defaults. */\n  game?: Record<string, unknown>;\n}\n\nconst GLOBALS = ['foundry', 'game', 'CONFIG', 'Hooks', 'ui', 'CONST'] as const;\n\n/**\n * Flatten and expand, the way `foundry.utils` does.\n *\n * Provided because SDK code calls them on the global, not because a test\n * needs them: leaving them out means every consumer stubs them again.\n */\nfunction flattenObject(obj: Record<string, unknown>, prefix = ''): Record<string, unknown> {\n  const flat: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    const path = prefix ? `${prefix}.${key}` : key;\n    const isPlain =\n      value !== null &&\n      typeof value === 'object' &&\n      Object.getPrototypeOf(value) === Object.prototype;\n    if (isPlain && Object.keys(value as object).length > 0) {\n      Object.assign(flat, flattenObject(value as Record<string, unknown>, path));\n    } else {\n      flat[path] = value;\n    }\n  }\n  return flat;\n}\n\nfunction expandObject(flat: Record<string, unknown>): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const [path, value] of Object.entries(flat)) {\n    const parts = path.split('.');\n    const last = parts.pop();\n    if (!last) continue;\n    let target = out;\n    for (const part of parts) {\n      target[part] ??= {};\n      target = target[part] as Record<string, unknown>;\n    }\n    target[last] = value;\n  }\n  return out;\n}\n\n/**\n * Stand up the globals, run the callback, tear them down.\n *\n * ```ts\n * const foundry = withMockFoundry();\n * registerMyModule();\n * expect(foundry.hooks.map((h) => h.event)).toContain('init');\n * foundry.restore();\n * ```\n */\nexport function withMockFoundry(options: MockFoundryOptions = {}): MockFoundry {\n  const saved = new Map<string, unknown>();\n  const scope = globalThis as Record<string, unknown>;\n  for (const name of GLOBALS) saved.set(name, scope[name]);\n\n  const hooks: RecordedHook[] = [];\n  const settings: RecordedSetting[] = [];\n  const values = new Map<string, unknown>();\n  const notifications: { level: 'info' | 'warn' | 'error'; message: string }[] = [];\n\n  const Hooks = {\n    on: (event: string, fn: (...a: unknown[]) => unknown) => {\n      hooks.push({ event, once: false, fn });\n      return hooks.length;\n    },\n    once: (event: string, fn: (...a: unknown[]) => unknown) => {\n      hooks.push({ event, once: true, fn });\n      return hooks.length;\n    },\n    off: () => {},\n    call: (event: string, ...args: unknown[]) => callHook(event, ...args).every((r) => r !== false),\n    callAll: (event: string, ...args: unknown[]) => {\n      callHook(event, ...args);\n      return true;\n    },\n  };\n\n  function callHook(event: string, ...args: unknown[]): unknown[] {\n    return hooks.filter((h) => h.event === event).map((h) => h.fn(...args));\n  }\n\n  const user = { id: 'user000000000001', isGM: true, name: 'Gamemaster', ...options.user };\n\n  const sheets: RecordedSheet[] = [];\n  const enrichers: RecordedEnricher[] = [];\n\n  scope.Hooks = Hooks;\n  scope.CONST = { DOCUMENT_OWNERSHIP_LEVELS: { NONE: 0, LIMITED: 1, OBSERVER: 2, OWNER: 3 } };\n  scope.CONFIG = {\n    Actor: { dataModels: {}, sheetClasses: {} },\n    Item: { dataModels: {}, sheetClasses: {} },\n    TextEditor: { enrichers },\n    Combat: {},\n    ActiveEffect: {},\n    statusEffects: [],\n    debug: { hooks: false },\n  };\n  scope.ui = {\n    notifications: {\n      info: (m: string) => notifications.push({ level: 'info', message: m }),\n      warn: (m: string) => notifications.push({ level: 'warn', message: m }),\n      error: (m: string) => notifications.push({ level: 'error', message: m }),\n    },\n  };\n  scope.foundry = {\n    utils: {\n      flattenObject,\n      expandObject,\n      mergeObject: (a: Record<string, unknown>, b: Record<string, unknown>) => ({ ...a, ...b }),\n      deepClone: <T>(v: T): T => structuredClone(v),\n      randomID: () => Math.random().toString(36).slice(2, 18),\n      isNewerVersion: (a: string, b: string) =>\n        a.localeCompare(b, undefined, { numeric: true }) > 0,\n    },\n    abstract: { TypeDataModel: class {}, DataModel: class {}, Document: class {} },\n    data: { fields: {} },\n    applications: {\n      api: { ApplicationV2: class {}, HandlebarsApplicationMixin: (b: unknown) => b },\n      sheets: { ActorSheetV2: class {}, ItemSheetV2: class {} },\n      apps: {\n        // Where `registerSystem({ sheets })` and `registerModule({ sheets })`\n        // register. Foundry builds the key from the class name, so this\n        // records the same key it would persist.\n        DocumentSheetConfig: {\n          registerSheet(\n            documentClass: unknown,\n            scope: string,\n            sheetClass: { name: string },\n            sheetOptions: Record<string, unknown> = {},\n          ) {\n            sheets.push({\n              key: `${scope}.${sheetClass.name}`,\n              scope,\n              id: sheetClass.name,\n              sheetClass,\n              documentClass,\n              options: sheetOptions,\n            });\n          },\n          unregisterSheet: () => {},\n        },\n      },\n      ux: {},\n      instances: new Map(),\n    },\n    documents: {\n      collections: {\n        Actors: { registerSheet: () => {}, unregisterSheet: () => {} },\n        Items: { registerSheet: () => {}, unregisterSheet: () => {} },\n      },\n    },\n    ...options.foundry,\n  };\n  scope.game = {\n    user,\n    userId: user.id,\n    ready: true,\n    modules: new Map(),\n    actors: [],\n    items: [],\n    i18n: {\n      localize: (key: string) => key,\n      format: (key: string, data: Record<string, unknown>) => `${key} ${JSON.stringify(data)}`,\n    },\n    settings: {\n      register: (namespace: string, key: string, config: Record<string, unknown>) => {\n        settings.push({ namespace, key, config });\n        values.set(`${namespace}.${key}`, config.default);\n      },\n      get: (namespace: string, key: string) => values.get(`${namespace}.${key}`),\n      set: async (namespace: string, key: string, value: unknown) => {\n        values.set(`${namespace}.${key}`, value);\n        return value;\n      },\n    },\n    ...options.game,\n  };\n\n  return {\n    hooks,\n    settings,\n    notifications,\n    sheets,\n    enrichers,\n    callHook,\n    getSetting: (namespace, key) => values.get(`${namespace}.${key}`),\n    restore() {\n      for (const [name, value] of saved) {\n        if (value === undefined) delete scope[name];\n        else scope[name] = value;\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vttforge/testing",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Quench-compatible test helpers and Foundry mocks for VTTForge systems and modules.",
   "type": "module",
   "license": "MIT",
@@ -22,6 +22,14 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
     },
+    "./vitest": {
+      "types": "./dist/vitest/index.d.mts",
+      "import": "./dist/vitest/index.mjs"
+    },
+    "./quench": {
+      "types": "./dist/quench/index.d.mts",
+      "import": "./dist/quench/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.mjs",
@@ -42,7 +50,7 @@
     "vitest": "^4.1.11"
   },
   "engines": {
-    "node": ">=26.0.0"
+    "node": ">=22.0.0"
   },
   "publishConfig": {
     "access": "public",

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * @vttforge/testing — placeholder. Implementation lands in v1.0.0.\n */\nexport const VTTFORGE_TESTING_VERSION = '0.0.1';\n"],"mappings":";;;;AAGA,MAAa,2BAA2B"}