autotel-message-contract 0.1.0

package/dist/index.js

@@ -0,0 +1,414 @@
+import { defaultSerializer, jsonSerializer } from "./serializer.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+//#region src/diff.ts
+/**
+* Minimal line diff for snapshot failures. The goal is a message that points
+* at *what moved* — a renamed field, a switched date format, a dropped value —
+* not a full diff engine. Lines only in the approved file are marked `-`, lines
+* only in the actual output are marked `+`, and a little surrounding context is
+* kept so the change is readable in a terminal.
+*/
+function lineDiff(approved, actual) {
+	const a = approved.split("\n");
+	const b = actual.split("\n");
+	const lcs = longestCommonSubsequence(a, b);
+	const out = [];
+	let i = 0;
+	let j = 0;
+	for (const [ai, bj] of lcs) {
+		while (i < ai) out.push(`- ${a[i++]}`);
+		while (j < bj) out.push(`+ ${b[j++]}`);
+		out.push(`  ${a[i++]}`);
+		j++;
+	}
+	while (i < a.length) out.push(`- ${a[i++]}`);
+	while (j < b.length) out.push(`+ ${b[j++]}`);
+	return out.join("\n");
+}
+/** Indices `[i, j]` of lines common to both, longest such subsequence. */
+function longestCommonSubsequence(a, b) {
+	const n = a.length;
+	const m = b.length;
+	const table = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }, () => 0));
+	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+	const pairs = [];
+	let i = 0;
+	let j = 0;
+	while (i < n && j < m) if (a[i] === b[j]) {
+		pairs.push([i, j]);
+		i++;
+		j++;
+	} else if (table[i + 1][j] >= table[i][j + 1]) i++;
+	else j++;
+	return pairs;
+}
+
+//#endregion
+//#region src/reader.ts
+function isStandardSchema(reader) {
+	return typeof reader === "object" && reader !== null && "~standard" in reader && typeof reader["~standard"]?.validate === "function";
+}
+/**
+* Run a reader against a deserialized value. Never throws — a thrown parse
+* error or reported issues become `{ ok: false, issues }` so the caller can
+* build a single, legible failure message.
+*/
+async function read(reader, value) {
+	if (isStandardSchema(reader)) try {
+		const result = await reader["~standard"].validate(value);
+		if (result.issues && result.issues.length > 0) return {
+			ok: false,
+			issues: result.issues.map((issue) => formatIssue(issue.message, issue.path))
+		};
+		return {
+			ok: true,
+			value: result.value,
+			issues: []
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			issues: [errorMessage(error)]
+		};
+	}
+	try {
+		return {
+			ok: true,
+			value: reader(value),
+			issues: []
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			issues: [errorMessage(error)]
+		};
+	}
+}
+function formatIssue(message, path) {
+	if (Array.isArray(path) && path.length > 0) return `${path.map(String).join(".")}: ${message}`;
+	return message;
+}
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+
+//#endregion
+//#region src/snapshot-storage.ts
+/**
+* Snapshot storage.
+*
+* A snapshot is just a file you commit: the serialized shape of a message,
+* reviewed once and from then on compared on every run. There is no broker, no
+* registry, no service to start — a format change shows up in a normal diff,
+* reviewed like any other code. This mirrors the "approved file" convention
+* (`<name>.approved.txt`) familiar from approval testing.
+*
+* By default the file lives in a `__contracts__` directory beside the test that
+* created it, resolved from the call stack so you do not have to thread paths
+* around. Override `dir` / `path` when you keep snapshots elsewhere.
+*/
+/** Set any of these (e.g. `AUTOTEL_CONTRACT_UPDATE=1`) to (re)write approved files. */
+const UPDATE_ENV_VARS = [
+	"AUTOTEL_CONTRACT_UPDATE",
+	"UPDATE_CONTRACTS",
+	"UPDATE_SNAPSHOTS"
+];
+function isUpdateMode(env = process.env) {
+	return UPDATE_ENV_VARS.some((name) => {
+		const value = env[name];
+		return value === "1" || value === "true";
+	});
+}
+const DEFAULT_DIR_NAME = "__contracts__";
+const APPROVED_SUFFIX = ".approved.txt";
+/** Resolve the absolute file path for a snapshot. */
+function resolveSnapshotPath(location) {
+	if (location.path) return path.isAbsolute(location.path) ? location.path : path.resolve(process.cwd(), location.path);
+	const dir = location.dir ?? defaultSnapshotDir();
+	return path.join(dir, `${sanitize(location.name)}${APPROVED_SUFFIX}`);
+}
+function sanitize(name) {
+	return name.replaceAll(/[^\w.@-]+/g, "_");
+}
+function readSnapshot(location) {
+	const filePath = resolveSnapshotPath(location);
+	if (!existsSync(filePath)) return {
+		exists: false,
+		path: filePath
+	};
+	return {
+		exists: true,
+		content: readFileSync(filePath, "utf8"),
+		path: filePath
+	};
+}
+function writeSnapshot(location, content) {
+	const filePath = resolveSnapshotPath(location);
+	mkdirSync(path.dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content, "utf8");
+	return filePath;
+}
+/**
+* Best-effort `__contracts__` directory beside the calling test file, found by
+* walking the stack past this module and the contract internals. Falls back to
+* `<cwd>/__contracts__` when the caller cannot be determined (e.g. bundled).
+*/
+function defaultSnapshotDir() {
+	const callerFile = callerOutsidePackage();
+	const base = callerFile ? path.dirname(callerFile) : process.cwd();
+	return path.join(base, DEFAULT_DIR_NAME);
+}
+function callerOutsidePackage() {
+	const stack = (/* @__PURE__ */ new Error("stack probe")).stack;
+	if (!stack) return void 0;
+	const lines = stack.split("\n").slice(1);
+	for (const line of lines) {
+		const file = (line.match(/\((.*?):\d+:\d+\)/) ?? line.match(/at (.*?):\d+:\d+/))?.[1];
+		if (!file) continue;
+		if (file.includes("node:")) continue;
+		if (file.includes(`${path.join("autotel-message-contract", "src")}`)) continue;
+		if (file.includes(`${path.join("autotel-message-contract", "dist")}`)) continue;
+		if (file.includes("node_modules")) continue;
+		return file.startsWith("file://") ? fileUrlToPath(file) : file;
+	}
+}
+function fileUrlToPath(url) {
+	return decodeURIComponent(url.replace(/^file:\/\//, ""));
+}
+
+//#endregion
+//#region src/contract.ts
+/**
+* The message contract DSL.
+*
+* Every check starts from {@link messageContract} and reads as a sentence:
+*
+* ```ts
+* // Pin the serialized shape — fail when it drifts.
+* await messageContract()
+*   .given(new OrderPlaced(orderId, 'Alice', placedAt))
+*   .whenSerialized()
+*   .thenContractIsUnchanged();
+*
+* // Prove a newer reader still reads what an older writer produced.
+* await messageContract()
+*   .given(orderPlacedV1)
+*   .whenDeserializedAs(OrderPlacedV2)   // a Zod schema or parse fn
+*   .thenBackwardCompatible((v2) => expect(v2.coupon).toBeUndefined());
+* ```
+*
+* A **snapshot check** confirms a message still serializes exactly as approved,
+* so nothing reading it downstream breaks. A **compatibility check** confirms an
+* older and a newer version can still read each other's data. Both are ordinary
+* unit tests — no broker, no registry, no running service.
+*/
+/** Thrown when a contract check fails. Message is pre-formatted for a test runner. */
+var ContractViolationError = class extends Error {
+	name = "ContractViolationError";
+	constructor(message) {
+		super(message);
+	}
+};
+const SNAPSHOT_SOURCE = Symbol("autotel-message-contract.snapshot-source");
+/**
+* Point a compatibility check at a previously approved snapshot instead of a
+* live in-memory message instance.
+*/
+function approvedSnapshot(location) {
+	return {
+		[SNAPSHOT_SOURCE]: true,
+		location
+	};
+}
+function isApprovedSnapshotSource(value) {
+	return typeof value === "object" && value !== null && SNAPSHOT_SOURCE in value && value[SNAPSHOT_SOURCE] === true;
+}
+/** Start a contract check. */
+function messageContract(options = {}) {
+	return new GivenStep(options);
+}
+var GivenStep = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	/** The message under contract. */
+	given(message) {
+		return new WhenStep(message, this.options);
+	}
+};
+var WhenStep = class {
+	message;
+	options;
+	constructor(message, options) {
+		this.message = message;
+		this.options = options;
+	}
+	/** Serialize the message; the next step pins or inspects the result. */
+	whenSerialized() {
+		if (isApprovedSnapshotSource(this.message)) throw new ContractViolationError("Cannot serialize an approved snapshot source. Use .whenDeserializedAs(...) to run a compatibility check, or pass a live message instance to .given(...).");
+		const serializer = this.options.serializer ?? defaultSerializer;
+		return new SnapshotStep(serializer.serialize(this.message), serializer, this.options);
+	}
+	/**
+	* Round-trip the message through a reader that models a *different version*
+	* (a Standard Schema such as Zod/Valibot, or a parse function). The next step
+	* asserts the versions stay compatible.
+	*/
+	whenDeserializedAs(reader) {
+		const serializer = this.options.serializer ?? defaultSerializer;
+		return new CompatibilityStep(this.message, reader, serializer, this.options);
+	}
+};
+var SnapshotStep = class {
+	serialized;
+	serializer;
+	options;
+	constructor(serialized, serializer, options) {
+		this.serialized = serialized;
+		this.serializer = serializer;
+		this.options = options;
+	}
+	/** The serialized bytes, for ad-hoc assertions outside the snapshot flow. */
+	get output() {
+		return this.serialized;
+	}
+	/**
+	* Compare the serialized output against the approved snapshot. On first run
+	* (or in update mode) it writes the approved file and passes; afterwards it
+	* fails with a diff when the shape drifts.
+	*/
+	thenContractIsUnchanged(snapshotName) {
+		const location = this.resolveLocation(snapshotName);
+		const existing = readSnapshot(location);
+		const update = this.options.update ?? isUpdateMode();
+		if (!existing.exists || update) {
+			writeSnapshot(location, this.serialized);
+			if (!existing.exists) return;
+			return;
+		}
+		if (existing.content !== this.serialized) throw new ContractViolationError(`Message contract drifted from its approved snapshot.\n  serializer: ${this.serializer.name}\n  snapshot:   ${existing.path}\n\n${lineDiff(existing.content ?? "", this.serialized)}\n\nIf this change is intentional, re-run with AUTOTEL_CONTRACT_UPDATE=1 to update the approved file, then review and commit it.`);
+	}
+	resolveLocation(snapshotName) {
+		if (snapshotName) return { name: snapshotName };
+		const configured = this.options.snapshot;
+		if (typeof configured === "string") return { name: configured };
+		if (configured) return configured;
+		throw new ContractViolationError("A snapshot name is required. Pass one to messageContract({ snapshot: 'OrderPlaced' }) or to thenContractIsUnchanged('OrderPlaced').");
+	}
+};
+var CompatibilityStep = class {
+	source;
+	reader;
+	serializer;
+	options;
+	constructor(source, reader, serializer, options) {
+		this.source = source;
+		this.reader = reader;
+		this.serializer = serializer;
+		this.options = options;
+	}
+	/**
+	* The reader models a **newer** version; confirm it still reads what an older
+	* writer produced (stored events, in-flight messages). Optionally assert on
+	* the upgraded value — e.g. that a newly-added field defaults sensibly.
+	*/
+	async thenBackwardCompatible(assert) {
+		return this.check("backward", assert);
+	}
+	/**
+	* The reader models an **older** version; confirm a consumer that has not
+	* upgraded yet still reads what the newer writer produces, so you can ship the
+	* new shape before every reader has caught up.
+	*/
+	async thenForwardCompatible(assert) {
+		return this.check("forward", assert);
+	}
+	async check(direction, assert) {
+		const serialized = this.resolveSourceSerialized();
+		const deserializedSource = this.serializer.deserialize(serialized);
+		const outcome = await read(this.reader, deserializedSource);
+		if (!outcome.ok) throw new ContractViolationError(`Not ${direction}-compatible: ${direction === "backward" ? "the newer reader" : "the older reader"} rejected a message ${direction === "backward" ? "an older writer" : "a newer writer"} produced.\n  serializer: ${this.serializer.name}\n  serialized: ${truncate(serialized)}\n  issues:\n${outcome.issues.map((m) => `    - ${m}`).join("\n")}`);
+		this.assertStructuralCompatibility(deserializedSource, this.serializer.deserialize(this.serializer.serialize(outcome.value)), direction, serialized);
+		if (assert) await assert(outcome.value);
+		return outcome.value;
+	}
+	resolveSourceSerialized() {
+		if (isApprovedSnapshotSource(this.source)) {
+			const existing = readSnapshot(this.resolveSnapshotLocation(this.source.location));
+			if (!existing.exists || existing.content === void 0) throw new ContractViolationError(`Cannot read approved snapshot for compatibility check.\n  snapshot: ${existing.path}\n\nRecord it first with .whenSerialized().thenContractIsUnchanged(), or point approvedSnapshot(...) at an existing file.`);
+			return existing.content;
+		}
+		return this.serializer.serialize(this.source);
+	}
+	resolveSnapshotLocation(location) {
+		if (typeof location === "string") return { name: location };
+		if (location) return location;
+		const configured = this.options.snapshot;
+		if (typeof configured === "string") return { name: configured };
+		if (configured) return configured;
+		throw new ContractViolationError("A snapshot location is required for approvedSnapshot(). Pass approvedSnapshot('OrderPlaced_v1') or configure messageContract({ snapshot: 'OrderPlaced_v1' }).");
+	}
+	assertStructuralCompatibility(sourceValue, targetValue, direction, serialized) {
+		const mismatches = [];
+		compareSharedStructure(sourceValue, targetValue, "$", mismatches);
+		if (mismatches.length === 0) return;
+		throw new ContractViolationError(`Not ${direction}-compatible: shared fields changed meaning across versions.\n  serializer: ${this.serializer.name}\n  serialized: ${truncate(serialized)}\n  mismatches:\n${mismatches.map((issue) => `    - ${issue}`).join("\n")}`);
+	}
+};
+function truncate(value, max = 400) {
+	return value.length > max ? `${value.slice(0, max)}… (${value.length} chars)` : value;
+}
+function compareSharedStructure(sourceValue, targetValue, path, mismatches) {
+	if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+		const sourceKeys = Object.keys(sourceValue);
+		const targetKeys = Object.keys(targetValue);
+		const sourceOnly = sourceKeys.filter((key) => !(key in targetValue));
+		const targetOnly = targetKeys.filter((key) => !(key in sourceValue));
+		if (sourceOnly.length > 0 && targetOnly.length > 0) {
+			mismatches.push(`${path}: structural incompatibility [source-only: ${sourceOnly.join(", ")}, target-only: ${targetOnly.join(", ")}]`);
+			return;
+		}
+		for (const key of sourceKeys.filter((candidate) => candidate in targetValue).toSorted()) compareSharedStructure(sourceValue[key], targetValue[key], joinPath(path, key), mismatches);
+		return;
+	}
+	if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+		if (sourceValue.length !== targetValue.length) {
+			mismatches.push(`${path}: array length differs (${sourceValue.length} vs ${targetValue.length})`);
+			return;
+		}
+		for (const [index, sourceItem] of sourceValue.entries()) compareSharedStructure(sourceItem, targetValue[index], `${path}[${index}]`, mismatches);
+		return;
+	}
+	if (!deepEqual(sourceValue, targetValue)) mismatches.push(`${path}: value differs (${formatValue(sourceValue)} vs ${formatValue(targetValue)})`);
+}
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function deepEqual(left, right) {
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((value, index) => deepEqual(value, right[index]));
+	if (isPlainObject(left) && isPlainObject(right)) {
+		const leftKeys = Object.keys(left);
+		const rightKeys = Object.keys(right);
+		return leftKeys.length === rightKeys.length && leftKeys.every((key) => key in right && deepEqual(left[key], right[key]));
+	}
+	return false;
+}
+function formatValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (value === null || typeof value === "number" || typeof value === "boolean" || value === void 0) return String(value);
+	return JSON.stringify(value);
+}
+function joinPath(path, key) {
+	return path === "$" ? `$.${key}` : `${path}.${key}`;
+}
+
+//#endregion
+export { ContractViolationError, approvedSnapshot, defaultSerializer, isUpdateMode, jsonSerializer, lineDiff, messageContract, read, readSnapshot, resolveSnapshotPath, writeSnapshot };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/diff.ts","../src/reader.ts","../src/snapshot-storage.ts","../src/contract.ts"],"sourcesContent":["/**\n * Minimal line diff for snapshot failures. The goal is a message that points\n * at *what moved* — a renamed field, a switched date format, a dropped value —\n * not a full diff engine. Lines only in the approved file are marked `-`, lines\n * only in the actual output are marked `+`, and a little surrounding context is\n * kept so the change is readable in a terminal.\n */\nexport function lineDiff(approved: string, actual: string): string {\n  const a = approved.split('\\n');\n  const b = actual.split('\\n');\n  const lcs = longestCommonSubsequence(a, b);\n\n  const out: string[] = [];\n  let i = 0;\n  let j = 0;\n  for (const [ai, bj] of lcs) {\n    while (i < ai) out.push(`- ${a[i++]}`);\n    while (j < bj) out.push(`+ ${b[j++]}`);\n    out.push(`  ${a[i++]}`);\n    j++;\n  }\n  while (i < a.length) out.push(`- ${a[i++]}`);\n  while (j < b.length) out.push(`+ ${b[j++]}`);\n\n  return out.join('\\n');\n}\n\n/** Indices `[i, j]` of lines common to both, longest such subsequence. */\nfunction longestCommonSubsequence(\n  a: string[],\n  b: string[],\n): Array<[number, number]> {\n  const n = a.length;\n  const m = b.length;\n  const table: number[][] = Array.from({ length: n + 1 }, () =>\n    Array.from({ length: m + 1 }, () => 0),\n  );\n  for (let i = n - 1; i >= 0; i--) {\n    for (let j = m - 1; j >= 0; j--) {\n      table[i][j] =\n        a[i] === b[j]\n          ? table[i + 1][j + 1] + 1\n          : Math.max(table[i + 1][j], table[i][j + 1]);\n    }\n  }\n  const pairs: Array<[number, number]> = [];\n  let i = 0;\n  let j = 0;\n  while (i < n && j < m) {\n    if (a[i] === b[j]) {\n      pairs.push([i, j]);\n      i++;\n      j++;\n    } else if (table[i + 1][j] >= table[i][j + 1]) {\n      i++;\n    } else {\n      j++;\n    }\n  }\n  return pairs;\n}\n","/**\n * Readers — the \"as this version\" side of a compatibility check.\n *\n * In a JVM contract library you write `whenDeserializedAs(NewType.class)` and\n * reflection does the rest. TypeScript types are erased at runtime, so there is\n * no class to hand over. Instead you describe the *reader*: the thing that\n * accepts a deserialized value and either produces a typed result or rejects\n * it. Two shapes are accepted, in order of how most TS codebases already model\n * a message version:\n *\n *  1. A **Standard Schema** (Zod ≥3.24, Valibot, ArkType, …) — anything exposing\n *     the `~standard` interface. This is the recommended form: the schema is the\n *     version, and it already lives next to your message type.\n *  2. A plain **parse function** `(value) => T` that throws on incompatible input.\n *\n * A reader that accepts the value proves compatibility; a reader that throws or\n * reports issues proves the versions have drifted apart.\n */\n\n/** The subset of the Standard Schema v1 interface we rely on. */\nexport interface StandardSchemaLike<Output = unknown> {\n  readonly '~standard': {\n    readonly version: 1;\n    readonly vendor: string;\n    readonly validate: (value: unknown) =>\n      | StandardResult<Output>\n      | Promise<StandardResult<Output>>;\n  };\n}\n\ninterface StandardResult<Output> {\n  value?: Output;\n  issues?: ReadonlyArray<{ readonly message: string; readonly path?: unknown }>;\n}\n\n/** A bare parse function: returns the typed value or throws. */\nexport type ParseFn<Output = unknown> = (value: unknown) => Output;\n\n/** Either accepted reader form. */\nexport type Reader<Output = unknown> =\n  | StandardSchemaLike<Output>\n  | ParseFn<Output>;\n\nfunction isStandardSchema(reader: Reader): reader is StandardSchemaLike {\n  return (\n    typeof reader === 'object' &&\n    reader !== null &&\n    '~standard' in reader &&\n    typeof (reader as StandardSchemaLike)['~standard']?.validate === 'function'\n  );\n}\n\nexport interface ReadOutcome<Output = unknown> {\n  ok: boolean;\n  /** Present when `ok`. */\n  value?: Output;\n  /** Human-readable reasons the reader rejected the value. */\n  issues: string[];\n}\n\n/**\n * Run a reader against a deserialized value. Never throws — a thrown parse\n * error or reported issues become `{ ok: false, issues }` so the caller can\n * build a single, legible failure message.\n */\nexport async function read<Output>(\n  reader: Reader<Output>,\n  value: unknown,\n): Promise<ReadOutcome<Output>> {\n  if (isStandardSchema(reader)) {\n    try {\n      const result = await reader['~standard'].validate(value);\n      if (result.issues && result.issues.length > 0) {\n        return {\n          ok: false,\n          issues: result.issues.map(\n            (issue) => formatIssue(issue.message, issue.path),\n          ),\n        };\n      }\n      return { ok: true, value: result.value as Output, issues: [] };\n    } catch (error) {\n      return { ok: false, issues: [errorMessage(error)] };\n    }\n  }\n\n  try {\n    const parsed = (reader as ParseFn<Output>)(value);\n    return { ok: true, value: parsed, issues: [] };\n  } catch (error) {\n    return { ok: false, issues: [errorMessage(error)] };\n  }\n}\n\nfunction formatIssue(message: string, path: unknown): string {\n  if (Array.isArray(path) && path.length > 0) {\n    return `${path.map(String).join('.')}: ${message}`;\n  }\n  return message;\n}\n\nfunction errorMessage(error: unknown): string {\n  if (error instanceof Error) return error.message;\n  return String(error);\n}\n","import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';\nimport path from 'node:path';\n\n/**\n * Snapshot storage.\n *\n * A snapshot is just a file you commit: the serialized shape of a message,\n * reviewed once and from then on compared on every run. There is no broker, no\n * registry, no service to start — a format change shows up in a normal diff,\n * reviewed like any other code. This mirrors the \"approved file\" convention\n * (`<name>.approved.txt`) familiar from approval testing.\n *\n * By default the file lives in a `__contracts__` directory beside the test that\n * created it, resolved from the call stack so you do not have to thread paths\n * around. Override `dir` / `path` when you keep snapshots elsewhere.\n */\n\n/** Set any of these (e.g. `AUTOTEL_CONTRACT_UPDATE=1`) to (re)write approved files. */\nconst UPDATE_ENV_VARS = [\n  'AUTOTEL_CONTRACT_UPDATE',\n  'UPDATE_CONTRACTS',\n  'UPDATE_SNAPSHOTS',\n] as const;\n\nexport function isUpdateMode(env: NodeJS.ProcessEnv = process.env): boolean {\n  return UPDATE_ENV_VARS.some((name) => {\n    const value = env[name];\n    return value === '1' || value === 'true';\n  });\n}\n\nexport interface SnapshotLocation {\n  /** Directory holding the approved file. */\n  dir?: string;\n  /** Logical name; the file becomes `<name>.approved.txt`. */\n  name: string;\n  /** Fully-qualified path; when set, `dir`/`name` are ignored for placement. */\n  path?: string;\n}\n\nconst DEFAULT_DIR_NAME = '__contracts__';\nconst APPROVED_SUFFIX = '.approved.txt';\n\n/** Resolve the absolute file path for a snapshot. */\nexport function resolveSnapshotPath(location: SnapshotLocation): string {\n  if (location.path) {\n    return path.isAbsolute(location.path)\n      ? location.path\n      : path.resolve(process.cwd(), location.path);\n  }\n  const dir = location.dir ?? defaultSnapshotDir();\n  return path.join(dir, `${sanitize(location.name)}${APPROVED_SUFFIX}`);\n}\n\nfunction sanitize(name: string): string {\n  // Keep it filesystem-safe while preserving readable type names.\n  return name.replaceAll(/[^\\w.@-]+/g, '_');\n}\n\nexport interface ReadSnapshotResult {\n  exists: boolean;\n  content?: string;\n  path: string;\n}\n\nexport function readSnapshot(location: SnapshotLocation): ReadSnapshotResult {\n  const filePath = resolveSnapshotPath(location);\n  if (!existsSync(filePath)) return { exists: false, path: filePath };\n  return { exists: true, content: readFileSync(filePath, 'utf8'), path: filePath };\n}\n\nexport function writeSnapshot(\n  location: SnapshotLocation,\n  content: string,\n): string {\n  const filePath = resolveSnapshotPath(location);\n  mkdirSync(path.dirname(filePath), { recursive: true });\n  writeFileSync(filePath, content, 'utf8');\n  return filePath;\n}\n\n/**\n * Best-effort `__contracts__` directory beside the calling test file, found by\n * walking the stack past this module and the contract internals. Falls back to\n * `<cwd>/__contracts__` when the caller cannot be determined (e.g. bundled).\n */\nfunction defaultSnapshotDir(): string {\n  const callerFile = callerOutsidePackage();\n  const base = callerFile ? path.dirname(callerFile) : process.cwd();\n  return path.join(base, DEFAULT_DIR_NAME);\n}\n\nfunction callerOutsidePackage(): string | undefined {\n  const stack = new Error('stack probe').stack;\n  if (!stack) return undefined;\n  const lines = stack.split('\\n').slice(1);\n  for (const line of lines) {\n    const match = line.match(/\\((.*?):\\d+:\\d+\\)/) ?? line.match(/at (.*?):\\d+:\\d+/);\n    const file = match?.[1];\n    if (!file) continue;\n    if (file.includes('node:')) continue;\n    // Skip frames inside this package's own source/dist.\n    if (file.includes(`${path.join('autotel-message-contract', 'src')}`)) continue;\n    if (file.includes(`${path.join('autotel-message-contract', 'dist')}`)) continue;\n    if (file.includes('node_modules')) continue;\n    return file.startsWith('file://') ? fileUrlToPath(file) : file;\n  }\n  return undefined;\n}\n\nfunction fileUrlToPath(url: string): string {\n  return decodeURIComponent(url.replace(/^file:\\/\\//, ''));\n}\n","/**\n * The message contract DSL.\n *\n * Every check starts from {@link messageContract} and reads as a sentence:\n *\n * ```ts\n * // Pin the serialized shape — fail when it drifts.\n * await messageContract()\n *   .given(new OrderPlaced(orderId, 'Alice', placedAt))\n *   .whenSerialized()\n *   .thenContractIsUnchanged();\n *\n * // Prove a newer reader still reads what an older writer produced.\n * await messageContract()\n *   .given(orderPlacedV1)\n *   .whenDeserializedAs(OrderPlacedV2)   // a Zod schema or parse fn\n *   .thenBackwardCompatible((v2) => expect(v2.coupon).toBeUndefined());\n * ```\n *\n * A **snapshot check** confirms a message still serializes exactly as approved,\n * so nothing reading it downstream breaks. A **compatibility check** confirms an\n * older and a newer version can still read each other's data. Both are ordinary\n * unit tests — no broker, no registry, no running service.\n */\nimport { lineDiff } from './diff.js';\nimport { read, type Reader } from './reader.js';\nimport {\n  defaultSerializer,\n  type MessageSerializer,\n} from './serializer.js';\nimport {\n  isUpdateMode,\n  readSnapshot,\n  type SnapshotLocation,\n  writeSnapshot,\n} from './snapshot-storage.js';\n\n/** Thrown when a contract check fails. Message is pre-formatted for a test runner. */\nexport class ContractViolationError extends Error {\n  override readonly name = 'ContractViolationError';\n  constructor(message: string) {\n    super(message);\n  }\n}\n\nexport interface MessageContractOptions {\n  /** Serializer producing the bytes you ship. Defaults to deterministic JSON. */\n  serializer?: MessageSerializer<string>;\n  /**\n   * Where approved files live and what they are named. A bare string is used as\n   * the logical name; an object gives full control over `dir`/`path`.\n   */\n  snapshot?: string | SnapshotLocation;\n  /** Override update-mode detection (default reads env, e.g. AUTOTEL_CONTRACT_UPDATE=1). */\n  update?: boolean;\n}\n\nconst SNAPSHOT_SOURCE = Symbol('autotel-message-contract.snapshot-source');\n\nexport interface ApprovedSnapshotSource {\n  readonly [SNAPSHOT_SOURCE]: true;\n  readonly location?: string | SnapshotLocation;\n}\n\n/**\n * Point a compatibility check at a previously approved snapshot instead of a\n * live in-memory message instance.\n */\nexport function approvedSnapshot(\n  location?: string | SnapshotLocation,\n): ApprovedSnapshotSource {\n  return {\n    [SNAPSHOT_SOURCE]: true,\n    location,\n  };\n}\n\nfunction isApprovedSnapshotSource(value: unknown): value is ApprovedSnapshotSource {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    SNAPSHOT_SOURCE in value &&\n    (value as ApprovedSnapshotSource)[SNAPSHOT_SOURCE] === true\n  );\n}\n\n/** Start a contract check. */\nexport function messageContract(options: MessageContractOptions = {}): GivenStep {\n  return new GivenStep(options);\n}\n\nclass GivenStep {\n  constructor(private readonly options: MessageContractOptions) {}\n\n  /** The message under contract. */\n  given<T>(message: T | ApprovedSnapshotSource): WhenStep<T> {\n    return new WhenStep(message, this.options);\n  }\n}\n\nclass WhenStep<T> {\n  constructor(\n    private readonly message: T | ApprovedSnapshotSource,\n    private readonly options: MessageContractOptions,\n  ) {}\n\n  /** Serialize the message; the next step pins or inspects the result. */\n  whenSerialized(): SnapshotStep {\n    if (isApprovedSnapshotSource(this.message)) {\n      throw new ContractViolationError(\n        'Cannot serialize an approved snapshot source. ' +\n          'Use .whenDeserializedAs(...) to run a compatibility check, or ' +\n          'pass a live message instance to .given(...).',\n      );\n    }\n    const serializer = this.options.serializer ?? defaultSerializer;\n    const serialized = serializer.serialize(this.message);\n    return new SnapshotStep(serialized, serializer, this.options);\n  }\n\n  /**\n   * Round-trip the message through a reader that models a *different version*\n   * (a Standard Schema such as Zod/Valibot, or a parse function). The next step\n   * asserts the versions stay compatible.\n   */\n  whenDeserializedAs<Output>(reader: Reader<Output>): CompatibilityStep<Output> {\n    const serializer = this.options.serializer ?? defaultSerializer;\n    return new CompatibilityStep(this.message, reader, serializer, this.options);\n  }\n}\n\nclass SnapshotStep {\n  constructor(\n    private readonly serialized: string,\n    private readonly serializer: MessageSerializer<string>,\n    private readonly options: MessageContractOptions,\n  ) {}\n\n  /** The serialized bytes, for ad-hoc assertions outside the snapshot flow. */\n  get output(): string {\n    return this.serialized;\n  }\n\n  /**\n   * Compare the serialized output against the approved snapshot. On first run\n   * (or in update mode) it writes the approved file and passes; afterwards it\n   * fails with a diff when the shape drifts.\n   */\n  thenContractIsUnchanged(snapshotName?: string): void {\n    const location = this.resolveLocation(snapshotName);\n    const existing = readSnapshot(location);\n    const update = this.options.update ?? isUpdateMode();\n\n    if (!existing.exists || update) {\n      const path = writeSnapshot(location, this.serialized);\n      if (!existing.exists) {\n        // First run: record and pass, leaving the file to be reviewed/committed.\n        return;\n      }\n      // Update mode: rewrite and pass even if it changed.\n      void path;\n      return;\n    }\n\n    if (existing.content !== this.serialized) {\n      throw new ContractViolationError(\n        `Message contract drifted from its approved snapshot.\\n` +\n          `  serializer: ${this.serializer.name}\\n` +\n          `  snapshot:   ${existing.path}\\n\\n` +\n          `${lineDiff(existing.content ?? '', this.serialized)}\\n\\n` +\n          `If this change is intentional, re-run with AUTOTEL_CONTRACT_UPDATE=1 ` +\n          `to update the approved file, then review and commit it.`,\n      );\n    }\n  }\n\n  private resolveLocation(snapshotName?: string): SnapshotLocation {\n    if (snapshotName) return { name: snapshotName };\n    const configured = this.options.snapshot;\n    if (typeof configured === 'string') return { name: configured };\n    if (configured) return configured;\n    throw new ContractViolationError(\n      `A snapshot name is required. Pass one to messageContract({ snapshot: 'OrderPlaced' }) ` +\n        `or to thenContractIsUnchanged('OrderPlaced').`,\n    );\n  }\n}\n\nclass CompatibilityStep<Output> {\n  constructor(\n    private readonly source: unknown,\n    private readonly reader: Reader<Output>,\n    private readonly serializer: MessageSerializer<string>,\n    private readonly options: MessageContractOptions,\n  ) {}\n\n  /**\n   * The reader models a **newer** version; confirm it still reads what an older\n   * writer produced (stored events, in-flight messages). Optionally assert on\n   * the upgraded value — e.g. that a newly-added field defaults sensibly.\n   */\n  async thenBackwardCompatible(\n    assert?: (value: Output) => void | Promise<void>,\n  ): Promise<Output> {\n    return this.check('backward', assert);\n  }\n\n  /**\n   * The reader models an **older** version; confirm a consumer that has not\n   * upgraded yet still reads what the newer writer produces, so you can ship the\n   * new shape before every reader has caught up.\n   */\n  async thenForwardCompatible(\n    assert?: (value: Output) => void | Promise<void>,\n  ): Promise<Output> {\n    return this.check('forward', assert);\n  }\n\n  private async check(\n    direction: 'backward' | 'forward',\n    assert?: (value: Output) => void | Promise<void>,\n  ): Promise<Output> {\n    const serialized = this.resolveSourceSerialized();\n    const deserializedSource = this.serializer.deserialize(serialized);\n    const outcome = await read(this.reader, deserializedSource);\n\n    if (!outcome.ok) {\n      const writer = direction === 'backward' ? 'an older writer' : 'a newer writer';\n      const readerLabel =\n        direction === 'backward' ? 'the newer reader' : 'the older reader';\n      throw new ContractViolationError(\n        `Not ${direction}-compatible: ${readerLabel} rejected a message ${writer} produced.\\n` +\n          `  serializer: ${this.serializer.name}\\n` +\n          `  serialized: ${truncate(serialized)}\\n` +\n          `  issues:\\n${outcome.issues.map((m) => `    - ${m}`).join('\\n')}`,\n      );\n    }\n\n    this.assertStructuralCompatibility(\n      deserializedSource,\n      this.serializer.deserialize(this.serializer.serialize(outcome.value)),\n      direction,\n      serialized,\n    );\n\n    if (assert) await assert(outcome.value as Output);\n    return outcome.value as Output;\n  }\n\n  private resolveSourceSerialized(): string {\n    if (isApprovedSnapshotSource(this.source)) {\n      const location = this.resolveSnapshotLocation(this.source.location);\n      const existing = readSnapshot(location);\n      if (!existing.exists || existing.content === undefined) {\n        throw new ContractViolationError(\n          `Cannot read approved snapshot for compatibility check.\\n` +\n            `  snapshot: ${existing.path}\\n\\n` +\n            `Record it first with .whenSerialized().thenContractIsUnchanged(), ` +\n            `or point approvedSnapshot(...) at an existing file.`,\n        );\n      }\n      return existing.content;\n    }\n    return this.serializer.serialize(this.source);\n  }\n\n  private resolveSnapshotLocation(\n    location?: string | SnapshotLocation,\n  ): SnapshotLocation {\n    if (typeof location === 'string') return { name: location };\n    if (location) return location;\n\n    const configured = this.options.snapshot;\n    if (typeof configured === 'string') return { name: configured };\n    if (configured) return configured;\n\n    throw new ContractViolationError(\n      'A snapshot location is required for approvedSnapshot(). ' +\n        `Pass approvedSnapshot('OrderPlaced_v1') or configure messageContract({ snapshot: 'OrderPlaced_v1' }).`,\n    );\n  }\n\n  private assertStructuralCompatibility(\n    sourceValue: unknown,\n    targetValue: unknown,\n    direction: 'backward' | 'forward',\n    serialized: string,\n  ): void {\n    const mismatches: string[] = [];\n    compareSharedStructure(sourceValue, targetValue, '$', mismatches);\n\n    if (mismatches.length === 0) return;\n\n    throw new ContractViolationError(\n      `Not ${direction}-compatible: shared fields changed meaning across versions.\\n` +\n        `  serializer: ${this.serializer.name}\\n` +\n        `  serialized: ${truncate(serialized)}\\n` +\n        `  mismatches:\\n${mismatches.map((issue) => `    - ${issue}`).join('\\n')}`,\n    );\n  }\n}\n\nfunction truncate(value: string, max = 400): string {\n  return value.length > max ? `${value.slice(0, max)}… (${value.length} chars)` : value;\n}\n\nfunction compareSharedStructure(\n  sourceValue: unknown,\n  targetValue: unknown,\n  path: string,\n  mismatches: string[],\n): void {\n  if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {\n    const sourceKeys = Object.keys(sourceValue);\n    const targetKeys = Object.keys(targetValue);\n    const sourceOnly = sourceKeys.filter((key) => !(key in targetValue));\n    const targetOnly = targetKeys.filter((key) => !(key in sourceValue));\n\n    if (sourceOnly.length > 0 && targetOnly.length > 0) {\n      mismatches.push(\n        `${path}: structural incompatibility ` +\n          `[source-only: ${sourceOnly.join(', ')}, target-only: ${targetOnly.join(', ')}]`,\n      );\n      return;\n    }\n\n    for (const key of sourceKeys.filter((candidate) => candidate in targetValue).toSorted()) {\n      compareSharedStructure(\n        sourceValue[key],\n        targetValue[key],\n        joinPath(path, key),\n        mismatches,\n      );\n    }\n    return;\n  }\n\n  if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {\n    if (sourceValue.length !== targetValue.length) {\n      mismatches.push(\n        `${path}: array length differs (${sourceValue.length} vs ${targetValue.length})`,\n      );\n      return;\n    }\n\n    for (const [index, sourceItem] of sourceValue.entries()) {\n      compareSharedStructure(sourceItem, targetValue[index], `${path}[${index}]`, mismatches);\n    }\n    return;\n  }\n\n  if (!deepEqual(sourceValue, targetValue)) {\n    mismatches.push(\n      `${path}: value differs (${formatValue(sourceValue)} vs ${formatValue(targetValue)})`,\n    );\n  }\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\nfunction deepEqual(left: unknown, right: unknown): boolean {\n  if (Object.is(left, right)) return true;\n\n  if (Array.isArray(left) && Array.isArray(right)) {\n    return (\n      left.length === right.length &&\n      left.every((value, index) => deepEqual(value, right[index]))\n    );\n  }\n\n  if (isPlainObject(left) && isPlainObject(right)) {\n    const leftKeys = Object.keys(left);\n    const rightKeys = Object.keys(right);\n    return (\n      leftKeys.length === rightKeys.length &&\n      leftKeys.every((key) => key in right && deepEqual(left[key], right[key]))\n    );\n  }\n\n  return false;\n}\n\nfunction formatValue(value: unknown): string {\n  if (typeof value === 'string') return JSON.stringify(value);\n  if (\n    value === null ||\n    typeof value === 'number' ||\n    typeof value === 'boolean' ||\n    value === undefined\n  ) {\n    return String(value);\n  }\n  return JSON.stringify(value);\n}\n\nfunction joinPath(path: string, key: string): string {\n  return path === '$' ? `$.${key}` : `${path}.${key}`;\n}\n\nexport type {\n  GivenStep,\n  WhenStep,\n  SnapshotStep,\n  CompatibilityStep,\n};\n"],"mappings":"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"}

package/dist/serializer.cjs

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/serializer.ts
+/**
+* Recursively sort object keys so two values with the same fields serialize
+* identically regardless of insertion order. Arrays keep their order (it is
+* semantically meaningful); plain objects are reordered; class instances,
+* Maps, Sets, Dates, etc. are left untouched so the serializer can decide.
+*/
+function sortKeysDeep(value) {
+	if (Array.isArray(value)) return value.map((element) => sortKeysDeep(element));
+	if (value !== null && typeof value === "object" && isPlainObject(value)) {
+		const sorted = {};
+		for (const key of Object.keys(value).toSorted()) sorted[key] = sortKeysDeep(value[key]);
+		return sorted;
+	}
+	return value;
+}
+function isPlainObject(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* The default serializer: `JSON.stringify` with deterministic key ordering.
+* Good enough to pin most events and commands; swap it for your own when the
+* bytes you ship differ (custom date formats, snake_case, omitted nulls…).
+*/
+function jsonSerializer(options = {}) {
+	const { indent = 2, sortKeys = true } = options;
+	return {
+		name: sortKeys ? "json" : "json (key-order preserved)",
+		serialize(value) {
+			const prepared = sortKeys ? sortKeysDeep(value) : value;
+			return JSON.stringify(prepared, void 0, indent);
+		},
+		deserialize(serialized) {
+			return JSON.parse(serialized);
+		}
+	};
+}
+/** The serializer used when a contract does not specify one. */
+const defaultSerializer = jsonSerializer();
+
+//#endregion
+exports.defaultSerializer = defaultSerializer;
+exports.jsonSerializer = jsonSerializer;
+//# sourceMappingURL=serializer.cjs.map

package/dist/serializer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.cjs","names":[],"sources":["../src/serializer.ts"],"sourcesContent":["/**\n * Message serializers.\n *\n * A contract pins the bytes a message becomes *once serialized* — the exact\n * shape a consumer, a queue, or a stored event reads. The only way that\n * snapshot is meaningful is if it is produced by the **same serializer your\n * application ships with**. Pin a shape your consumers never see and you have\n * pinned nothing.\n *\n * So a {@link MessageSerializer} is a tiny, explicit seam: `serialize` /\n * `deserialize`. The default is JSON with deterministic key ordering (so a\n * snapshot does not churn when object construction order changes), but you are\n * encouraged to pass your app's real serializer — `superjson`, `devalue`, a\n * snake_case Jackson-equivalent, a protobuf codec — so the snapshot records the\n * exact bytes you put on the wire.\n */\n\n/** A reversible mapping between an in-memory value and its serialized form. */\nexport interface MessageSerializer<Serialized = string> {\n  /** Human-facing name, surfaced in snapshot headers and failure messages. */\n  readonly name: string;\n  /** Turn a value into its serialized form (the bytes you ship). */\n  serialize(value: unknown): Serialized;\n  /** Turn a serialized form back into a value. */\n  deserialize(serialized: Serialized): unknown;\n}\n\n/**\n * Recursively sort object keys so two values with the same fields serialize\n * identically regardless of insertion order. Arrays keep their order (it is\n * semantically meaningful); plain objects are reordered; class instances,\n * Maps, Sets, Dates, etc. are left untouched so the serializer can decide.\n */\nfunction sortKeysDeep(value: unknown): unknown {\n  if (Array.isArray(value)) {\n    return value.map((element) => sortKeysDeep(element));\n  }\n  if (value !== null && typeof value === 'object' && isPlainObject(value)) {\n    const sorted: Record<string, unknown> = {};\n    for (const key of Object.keys(value).toSorted()) {\n      sorted[key] = sortKeysDeep((value as Record<string, unknown>)[key]);\n    }\n    return sorted;\n  }\n  return value;\n}\n\nfunction isPlainObject(value: object): boolean {\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\nexport interface JsonSerializerOptions {\n  /**\n   * Pretty-print with this indent. Defaults to `2` so the approved file reads\n   * cleanly in a diff. Set to `0` to pin the compact bytes you actually ship.\n   */\n  indent?: number;\n  /**\n   * Sort object keys deterministically before serializing. Defaults to `true`\n   * so a snapshot reflects *fields*, not construction order. Turn it off when\n   * key order is itself part of the contract.\n   */\n  sortKeys?: boolean;\n}\n\n/**\n * The default serializer: `JSON.stringify` with deterministic key ordering.\n * Good enough to pin most events and commands; swap it for your own when the\n * bytes you ship differ (custom date formats, snake_case, omitted nulls…).\n */\nexport function jsonSerializer(\n  options: JsonSerializerOptions = {},\n): MessageSerializer<string> {\n  const { indent = 2, sortKeys = true } = options;\n  return {\n    name: sortKeys ? 'json' : 'json (key-order preserved)',\n    serialize(value) {\n      const prepared = sortKeys ? sortKeysDeep(value) : value;\n      return JSON.stringify(prepared, undefined, indent);\n    },\n    deserialize(serialized) {\n      return JSON.parse(serialized) as unknown;\n    },\n  };\n}\n\n/** The serializer used when a contract does not specify one. */\nexport const defaultSerializer: MessageSerializer<string> = jsonSerializer();\n"],"mappings":";;;;;;;;;AAiCA,SAAS,aAAa,OAAyB;CAC7C,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,KAAK,YAAY,aAAa,OAAO,CAAC;CAErD,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,cAAc,KAAK,GAAG;EACvE,MAAM,SAAkC,CAAC;EACzC,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,CAAC,CAAC,SAAS,GAC5C,OAAO,OAAO,aAAc,MAAkC,IAAI;EAEpE,OAAO;CACT;CACA,OAAO;AACT;AAEA,SAAS,cAAc,OAAwB;CAC7C,MAAM,QAAQ,OAAO,eAAe,KAAK;CACzC,OAAO,UAAU,OAAO,aAAa,UAAU;AACjD;;;;;;AAqBA,SAAgB,eACd,UAAiC,CAAC,GACP;CAC3B,MAAM,EAAE,SAAS,GAAG,WAAW,SAAS;CACxC,OAAO;EACL,MAAM,WAAW,SAAS;EAC1B,UAAU,OAAO;GACf,MAAM,WAAW,WAAW,aAAa,KAAK,IAAI;GAClD,OAAO,KAAK,UAAU,UAAU,QAAW,MAAM;EACnD;EACA,YAAY,YAAY;GACtB,OAAO,KAAK,MAAM,UAAU;EAC9B;CACF;AACF;;AAGA,MAAa,oBAA+C,eAAe"}

package/dist/serializer.d.cts

@@ -0,0 +1,50 @@
+//#region src/serializer.d.ts
+/**
+ * Message serializers.
+ *
+ * A contract pins the bytes a message becomes *once serialized* — the exact
+ * shape a consumer, a queue, or a stored event reads. The only way that
+ * snapshot is meaningful is if it is produced by the **same serializer your
+ * application ships with**. Pin a shape your consumers never see and you have
+ * pinned nothing.
+ *
+ * So a {@link MessageSerializer} is a tiny, explicit seam: `serialize` /
+ * `deserialize`. The default is JSON with deterministic key ordering (so a
+ * snapshot does not churn when object construction order changes), but you are
+ * encouraged to pass your app's real serializer — `superjson`, `devalue`, a
+ * snake_case Jackson-equivalent, a protobuf codec — so the snapshot records the
+ * exact bytes you put on the wire.
+ */
+/** A reversible mapping between an in-memory value and its serialized form. */
+interface MessageSerializer<Serialized = string> {
+  /** Human-facing name, surfaced in snapshot headers and failure messages. */
+  readonly name: string;
+  /** Turn a value into its serialized form (the bytes you ship). */
+  serialize(value: unknown): Serialized;
+  /** Turn a serialized form back into a value. */
+  deserialize(serialized: Serialized): unknown;
+}
+interface JsonSerializerOptions {
+  /**
+   * Pretty-print with this indent. Defaults to `2` so the approved file reads
+   * cleanly in a diff. Set to `0` to pin the compact bytes you actually ship.
+   */
+  indent?: number;
+  /**
+   * Sort object keys deterministically before serializing. Defaults to `true`
+   * so a snapshot reflects *fields*, not construction order. Turn it off when
+   * key order is itself part of the contract.
+   */
+  sortKeys?: boolean;
+}
+/**
+ * The default serializer: `JSON.stringify` with deterministic key ordering.
+ * Good enough to pin most events and commands; swap it for your own when the
+ * bytes you ship differ (custom date formats, snake_case, omitted nulls…).
+ */
+declare function jsonSerializer(options?: JsonSerializerOptions): MessageSerializer<string>;
+/** The serializer used when a contract does not specify one. */
+declare const defaultSerializer: MessageSerializer<string>;
+//#endregion
+export { JsonSerializerOptions, MessageSerializer, defaultSerializer, jsonSerializer };
+//# sourceMappingURL=serializer.d.cts.map

package/dist/serializer.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.cts","names":[],"sources":["../src/serializer.ts"],"mappings":";;AAkBA;;;;;;;;;;;;;AAMoC;AA4BpC;;UAlCiB,iBAAA;EAuCf;EAAA,SArCS,IAAA;EAmDK;EAjDd,SAAA,CAAU,KAAA,YAAiB,UAAA;;EAE3B,WAAA,CAAY,UAAA,EAAY,UAAU;AAAA;AAAA,UA4BnB,qBAAA;EAqBd;;AAAiB;AAepB;EA/BE,MAAA;;;AA+B+C;;;EAzB/C,QAAQ;AAAA;;;;;;iBAQM,cAAA,CACd,OAAA,GAAS,qBAAA,GACR,iBAAiB;;cAeP,iBAAA,EAAmB,iBAAiB"}

package/dist/serializer.d.ts

@@ -0,0 +1,50 @@
+//#region src/serializer.d.ts
+/**
+ * Message serializers.
+ *
+ * A contract pins the bytes a message becomes *once serialized* — the exact
+ * shape a consumer, a queue, or a stored event reads. The only way that
+ * snapshot is meaningful is if it is produced by the **same serializer your
+ * application ships with**. Pin a shape your consumers never see and you have
+ * pinned nothing.
+ *
+ * So a {@link MessageSerializer} is a tiny, explicit seam: `serialize` /
+ * `deserialize`. The default is JSON with deterministic key ordering (so a
+ * snapshot does not churn when object construction order changes), but you are
+ * encouraged to pass your app's real serializer — `superjson`, `devalue`, a
+ * snake_case Jackson-equivalent, a protobuf codec — so the snapshot records the
+ * exact bytes you put on the wire.
+ */
+/** A reversible mapping between an in-memory value and its serialized form. */
+interface MessageSerializer<Serialized = string> {
+  /** Human-facing name, surfaced in snapshot headers and failure messages. */
+  readonly name: string;
+  /** Turn a value into its serialized form (the bytes you ship). */
+  serialize(value: unknown): Serialized;
+  /** Turn a serialized form back into a value. */
+  deserialize(serialized: Serialized): unknown;
+}
+interface JsonSerializerOptions {
+  /**
+   * Pretty-print with this indent. Defaults to `2` so the approved file reads
+   * cleanly in a diff. Set to `0` to pin the compact bytes you actually ship.
+   */
+  indent?: number;
+  /**
+   * Sort object keys deterministically before serializing. Defaults to `true`
+   * so a snapshot reflects *fields*, not construction order. Turn it off when
+   * key order is itself part of the contract.
+   */
+  sortKeys?: boolean;
+}
+/**
+ * The default serializer: `JSON.stringify` with deterministic key ordering.
+ * Good enough to pin most events and commands; swap it for your own when the
+ * bytes you ship differ (custom date formats, snake_case, omitted nulls…).
+ */
+declare function jsonSerializer(options?: JsonSerializerOptions): MessageSerializer<string>;
+/** The serializer used when a contract does not specify one. */
+declare const defaultSerializer: MessageSerializer<string>;
+//#endregion
+export { JsonSerializerOptions, MessageSerializer, defaultSerializer, jsonSerializer };
+//# sourceMappingURL=serializer.d.ts.map

package/dist/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","names":[],"sources":["../src/serializer.ts"],"mappings":";;AAkBA;;;;;;;;;;;;;AAMoC;AA4BpC;;UAlCiB,iBAAA;EAuCf;EAAA,SArCS,IAAA;EAmDK;EAjDd,SAAA,CAAU,KAAA,YAAiB,UAAA;;EAE3B,WAAA,CAAY,UAAA,EAAY,UAAU;AAAA;AAAA,UA4BnB,qBAAA;EAqBd;;AAAiB;AAepB;EA/BE,MAAA;;;AA+B+C;;;EAzB/C,QAAQ;AAAA;;;;;;iBAQM,cAAA,CACd,OAAA,GAAS,qBAAA,GACR,iBAAiB;;cAeP,iBAAA,EAAmB,iBAAiB"}