@ayepi/mock 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Philip Diffenderfer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @ayepi/mock
+
+Generate **schema-valid fake data** from an [`@ayepi/core`](../core) spec. Turn any
+`spec(...)` into a real server whose endpoints return generated bodies that parse against
+their own response schemas — great for frontend dev, demos, and tests before the backend
+exists.
+
+- **Deterministic by default** — the PRNG is seeded from `seed + endpoint + JSON(request)`,
+  so identical inputs yield identical output and pagination is naturally stable.
+- **Generic over zod** — deeply walks objects, arrays, unions, enums, string formats, and
+  wrappers; no per-endpoint fixtures.
+- **Pagination** — array sizes follow a `limit`-style query key (configurable), clamped to
+  schema length bounds.
+- **Overrides** — pin values by field name/path or by zod string format.
+
+```sh
+pnpm add -D @ayepi/mock        # peers: @ayepi/core, zod
+```
+
+```ts
+import { mockServer, generate } from '@ayepi/mock'
+import { z } from 'zod'
+
+// one-off value from any schema
+generate(z.object({ id: z.uuid(), name: z.string() }))
+
+// a real server with generated, schema-valid responses
+const app = mockServer(api, { seed: 1, arraySize: 5 })
+const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method: 'POST' }))
+```
+
+## Exports
+
+- `generate(schema, opts?, ctx?)` — one fake value from a zod schema.
+- `mockHandlers(spec, opts?)` — a handler bag for `server(spec, [implement(spec).handlers(bag)])`.
+- `mockServer(spec, opts?)` — a real ayepi `Server` with generated responses.
+
+See [`ayepi-mock.md`](./ayepi-mock.md) for the full reference (options, seeding,
+determinism, pagination, overrides, supported zod types, and gotchas).
+
+## For AI coding agents
+
+This package ships dense, machine-oriented reference docs written for **AI coding agents**
+(Claude Code, Cursor, and the like) to understand and drive the package — point your agent at them:
+
+- [`ayepi-mock.md`](./ayepi-mock.md)
+
+They live next to the source in the [repo](https://github.com/ClickerMonkey/ayepi/tree/main/packages/mock) and are **not** shipped in the npm tarball.
+

package/dist/index.cjs

@@ -0,0 +1,448 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _ayepi_core = require("@ayepi/core");
+//#region src/rng.ts
+/**
+* # Seeded PRNG
+*
+* A tiny, dependency-free deterministic random number generator. {@link fnv1a}
+* folds an arbitrary string into a 32-bit seed; {@link mulberry32} turns that
+* seed into a `() => number` stream of floats in `[0, 1)`. Given the same seed
+* the stream is byte-for-byte reproducible, which is what makes deterministic
+* mocking — and therefore stable pagination — possible.
+*
+* @module
+*/
+/** FNV-1a offset basis (32-bit). */
+const FNV_OFFSET_BASIS = 2166136261;
+/** FNV-1a prime (32-bit). */
+const FNV_PRIME = 16777619;
+/** Mask to keep arithmetic within 32 unsigned bits. */
+const U32_MASK = 4294967295;
+/** mulberry32 mixing constant added to the running state each step. */
+const MULBERRY_INCREMENT = 1831565813;
+/** mulberry32 second-round multiply constant. */
+const MULBERRY_ROUND2 = 3266489909;
+/** Divisor that maps a 32-bit unsigned integer into `[0, 1)`. */
+const U32_DIVISOR = 4294967296;
+/**
+* Hash a string into a 32-bit unsigned integer with FNV-1a.
+*
+* Used to fold a composite seed (`baseSeed + endpoint + JSON(request)`) down to a
+* single integer the PRNG can be initialized from.
+*/
+function fnv1a(input) {
+	let hash = FNV_OFFSET_BASIS;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, FNV_PRIME);
+	}
+	return hash >>> 0;
+}
+/**
+* Build a deterministic `() => number` PRNG (floats in `[0, 1)`) from a 32-bit
+* seed using the mulberry32 algorithm. Identical seeds yield identical streams.
+*/
+function mulberry32(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + MULBERRY_INCREMENT & U32_MASK;
+		let t = state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | MULBERRY_ROUND2);
+		t = (t ^ t >>> 14) >>> 0;
+		return t / U32_DIVISOR;
+	};
+}
+/**
+* Convenience: hash a string seed and return a fresh PRNG stream for it.
+*
+* @param parts - composite seed parts joined into the hash input.
+*/
+function rngFromParts(...parts) {
+	return mulberry32(fnv1a(parts.join("\0")));
+}
+/** Default query keys whose value sizes generated arrays. */
+const DEFAULT_LIMIT_KEYS = [
+	"limit",
+	"pageSize",
+	"count"
+];
+/** Default base seed when none is supplied. */
+const DEFAULT_SEED = "0";
+/** Fallback string length used when a format/length constraint gives no better hint. */
+const WORD_LENGTH = 8;
+/** Default integer ceiling (exclusive) for unconstrained number generation. */
+const INT_RANGE = 1e3;
+/** Decimal places kept for unconstrained floats. */
+const FLOAT_PRECISION = 1e3;
+/** Probability an optional/nullable value is *present* (non-undefined / non-null). */
+const PRESENCE_PROB = .7;
+/** Record entry count when generating from a `z.record`. */
+const RECORD_SIZE = 2;
+/** Bound used for bigint generation when unconstrained. */
+const BIGINT_RANGE = 1e3;
+/** Number `format` values that require an integer result. */
+const INT_FORMATS = new Set([
+	"safeint",
+	"int32",
+	"uint32"
+]);
+/** Characters drawn from when padding/building plain strings. */
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+/** Hex characters for uuid/id-shaped formats. */
+const HEX = "0123456789abcdef";
+/** Read a schema's internal `_zod.def`. */
+function def(schema) {
+	return schema._zod.def;
+}
+/** Read the (possibly empty) list of check descriptors on a schema. */
+function checks(d) {
+	return (d.checks ?? []).map((c) => c._zod.def);
+}
+/** Pull min/max/int constraints off a number schema's checks (and its `format`). */
+function numBounds(d) {
+	let min = null;
+	let max = null;
+	let int = d.format !== void 0 && INT_FORMATS.has(d.format);
+	for (const c of checks(d)) if (c.check === "greater_than" && typeof c.value === "number") min = c.inclusive ? c.value : c.value + 1;
+	else if (c.check === "less_than" && typeof c.value === "number") max = c.inclusive ? c.value : c.value - 1;
+	else if (c.check === "number_format") int = true;
+	return {
+		min,
+		max,
+		int
+	};
+}
+/** Pull min/max length constraints off a string/array schema's checks. */
+function lenBounds(d) {
+	let min = null;
+	let max = null;
+	for (const c of checks(d)) if (c.check === "min_length" && typeof c.minimum === "number") min = c.minimum;
+	else if (c.check === "max_length" && typeof c.maximum === "number") max = c.maximum;
+	else if (c.check === "length_equals" && typeof c.length === "number") min = max = c.length;
+	return {
+		min,
+		max
+	};
+}
+/** Draw an integer in `[lo, hi]` (inclusive) from the rng. */
+function intIn(rng, lo, hi) {
+	/* v8 ignore next */ if (hi < lo) return lo;
+	return lo + Math.floor(rng() * (hi - lo + 1));
+}
+/** Pick a random element of a non-empty array. */
+function pick(rng, arr) {
+	return arr[Math.floor(rng() * arr.length)];
+}
+/** Build a lowercase word of `len` characters. */
+function word(rng, len) {
+	let s = "";
+	for (let i = 0; i < len; i++) s += ALPHABET[Math.floor(rng() * 26)];
+	return s;
+}
+/** Build a hex string of `len` characters. */
+function hex(rng, len) {
+	let s = "";
+	for (let i = 0; i < len; i++) s += HEX[Math.floor(rng() * 16)];
+	return s;
+}
+/** Build a value for a detected/declared zod string `format`. */
+function formatValue(format, rng, now) {
+	switch (format) {
+		case "email": return `${word(rng, WORD_LENGTH)}@example.com`;
+		case "url": return `https://${word(rng, WORD_LENGTH)}.example.com`;
+		case "uuid":
+		case "guid": return `${hex(rng, 8)}-${hex(rng, 4)}-4${hex(rng, 3)}-8${hex(rng, 3)}-${hex(rng, 12)}`;
+		case "datetime": return new Date(now).toISOString();
+		case "date": return new Date(now).toISOString().slice(0, 10);
+		case "time": return new Date(now).toISOString().slice(11, 23);
+		case "duration": return `PT${intIn(rng, 1, 60)}M`;
+		case "ipv4": return `${intIn(rng, 1, 254)}.${intIn(rng, 0, 255)}.${intIn(rng, 0, 255)}.${intIn(rng, 1, 254)}`;
+		case "ipv6": return `${hex(rng, 4)}:${hex(rng, 4)}::${hex(rng, 4)}`;
+		case "cuid":
+		case "cuid2": return `c${word(rng, 24)}`;
+		case "ulid": return hex(rng, 26).toUpperCase();
+		case "nanoid": return word(rng, 21);
+		case "emoji": return pick(rng, [
+			"😀",
+			"🎉",
+			"🚀",
+			"🌟",
+			"🔥"
+		]);
+		case "e164": return `+1${intIn(rng, 2e9, 9999999999)}`;
+		case "base64": return Buffer.from(word(rng, WORD_LENGTH)).toString("base64");
+		case "base64url": return Buffer.from(word(rng, WORD_LENGTH)).toString("base64url");
+		default: return word(rng, WORD_LENGTH);
+	}
+}
+/** Build a plain string whose length lands within the schema's min/max bounds. */
+function plainString(rng, bounds) {
+	const min = bounds.min ?? 0;
+	return word(rng, intIn(rng, min, bounds.max ?? Math.max(min, WORD_LENGTH)));
+}
+/** Build a number honoring int/min/max constraints. */
+function genNumber(d, rng) {
+	const { min, max, int } = numBounds(d);
+	if (int) {
+		const lo = min ?? 0;
+		return intIn(rng, lo, max ?? lo + INT_RANGE);
+	}
+	const lo = min ?? 0;
+	const hi = max ?? lo + INT_RANGE;
+	const raw = lo + rng() * (hi - lo);
+	return Math.round(raw * FLOAT_PRECISION) / FLOAT_PRECISION;
+}
+/** Build a bigint honoring min/max constraints. */
+function genBigint(d, rng) {
+	let min = null;
+	let max = null;
+	for (const c of checks(d)) if (c.check === "greater_than" && typeof c.value === "bigint") min = c.inclusive ? c.value : c.value + 1n;
+	else if (c.check === "less_than" && typeof c.value === "bigint") max = c.inclusive ? c.value : c.value - 1n;
+	const lo = min ?? 0n;
+	const span = (max ?? lo + BigInt(BIGINT_RANGE)) - lo;
+	if (span <= 0n) return lo;
+	return lo + BigInt(Math.floor(rng() * BIGINT_RANGE)) % (span + 1n);
+}
+/**
+* Resolve a collection size from the request query. A `limit`-style query key
+* (the first of {@link MockOptions.limitKeys | limitKeys} present and non-negative)
+* wins; otherwise the configured default {@link MockOptions.arraySize | arraySize}
+* is used. Shared by array generation and `streamOut` item counting so pagination
+* is consistent across both.
+*/
+function resolveSize(query, cfg) {
+	for (const key of cfg.limitKeys) {
+		const raw = query[key];
+		if (typeof raw !== "string" && typeof raw !== "number") continue;
+		const n = Number(raw);
+		if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+	}
+	return cfg.arraySize;
+}
+/** Last path segment (the field/property name) for override lookup. */
+function leaf(path) {
+	const i = path.lastIndexOf(".");
+	return i < 0 ? path : path.slice(i + 1);
+}
+/**
+* Generate a value for `schema` at `ctx.path`. Recurses over the zod type tree,
+* applying field overrides (by leaf name or full path) and format overrides.
+*/
+function genValue(schema, ctx, cfg) {
+	const fieldOverride = cfg.overrides.fields[ctx.path] ?? cfg.overrides.fields[leaf(ctx.path)];
+	if (fieldOverride) return fieldOverride(ctx);
+	const d = def(schema);
+	switch (d.type) {
+		case "string": {
+			const format = d.format;
+			if (format) {
+				const fmtOverride = cfg.overrides.formats[format];
+				if (fmtOverride) return fmtOverride(ctx);
+				return formatValue(format, ctx.rng, cfg.now());
+			}
+			return plainString(ctx.rng, lenBounds(d));
+		}
+		case "number": return genNumber(d, ctx.rng);
+		case "bigint": return genBigint(d, ctx.rng);
+		case "boolean": return ctx.rng() < .5;
+		case "date": return new Date(cfg.now());
+		case "literal": return d.values[0];
+		case "enum": return pick(ctx.rng, Object.values(d.entries));
+		case "object": {
+			const out = {};
+			for (const [key, child] of Object.entries(d.shape)) {
+				const childPath = ctx.path ? `${ctx.path}.${key}` : key;
+				out[key] = genValue(child, {
+					...ctx,
+					path: childPath
+				}, cfg);
+			}
+			return out;
+		}
+		case "array": {
+			const n = resolveSize(ctx.query, cfg);
+			const bounds = lenBounds(d);
+			const count = Math.max(bounds.min ?? 0, Math.min(n, bounds.max ?? n));
+			const out = [];
+			for (let i = 0; i < count; i++) out.push(genValue(d.element, {
+				...ctx,
+				path: `${ctx.path}.${i}`
+			}, cfg));
+			return out;
+		}
+		case "tuple": {
+			const out = d.items.map((item, i) => genValue(item, {
+				...ctx,
+				path: `${ctx.path}.${i}`
+			}, cfg));
+			if (d.rest) out.push(genValue(d.rest, {
+				...ctx,
+				path: `${ctx.path}.${out.length}`
+			}, cfg));
+			return out;
+		}
+		case "record": {
+			const out = {};
+			for (let i = 0; i < RECORD_SIZE; i++) {
+				const key = word(ctx.rng, WORD_LENGTH);
+				out[key] = genValue(d.valueType, {
+					...ctx,
+					path: `${ctx.path}.${key}`
+				}, cfg);
+			}
+			return out;
+		}
+		case "union": return genValue(pick(ctx.rng, d.options), ctx, cfg);
+		case "optional":
+			if (ctx.rng() < PRESENCE_PROB) return genValue(d.innerType, ctx, cfg);
+			return;
+		case "nullable":
+			if (ctx.rng() < PRESENCE_PROB) return genValue(d.innerType, ctx, cfg);
+			return null;
+		case "default":
+		case "prefault":
+			if (ctx.rng() < PRESENCE_PROB) return genValue(d.innerType, ctx, cfg);
+			return d.defaultValue;
+		case "catch":
+		case "readonly":
+		case "nonoptional": return genValue(d.innerType, ctx, cfg);
+		default: return fallback(d, ctx);
+	}
+}
+/** Sensible value for schema types we don't model precisely (any/unknown/null/etc.). */
+function fallback(d, ctx) {
+	switch (d.type) {
+		case "null": return null;
+		case "undefined":
+		case "void": return;
+		default: return word(ctx.rng, WORD_LENGTH);
+	}
+}
+/** Build the resolved {@link GenConfig} from public {@link MockOptions}. */
+function resolveConfig(opts) {
+	return {
+		arraySize: opts?.arraySize ?? 3,
+		limitKeys: opts?.limitKeys ?? DEFAULT_LIMIT_KEYS,
+		overrides: {
+			fields: { ...opts?.overrides?.fields ?? {} },
+			formats: { ...opts?.overrides?.formats ?? {} }
+		},
+		now: opts?.now ?? Date.now
+	};
+}
+/** Build the per-generation RNG: deterministic hash-seeded, or `Math.random`. */
+function makeRng(opts, ...seedParts) {
+	if (opts?.deterministic === false) return Math.random;
+	return rngFromParts(String(opts?.seed ?? DEFAULT_SEED), ...seedParts);
+}
+/**
+* Generate one schema-valid fake value from a zod schema.
+*
+* @param schema - any zod schema.
+* @param opts   - seeding / sizing / override options.
+* @param ctx    - partial context overrides (e.g. a fixed `path`, `request`, `query`).
+* @returns a value that parses against `schema`.
+*
+* @example
+* ```ts
+* const user = generate(z.object({ id: z.uuid(), name: z.string() }), { seed: 1 })
+* ```
+*/
+function generate(schema, opts, ctx) {
+	const cfg = resolveConfig(opts);
+	const rng = ctx?.rng ?? makeRng(opts, JSON.stringify(ctx?.request ?? null));
+	return genValue(schema, {
+		path: ctx?.path ?? "",
+		rng,
+		request: ctx?.request,
+		query: ctx?.query ?? {}
+	}, cfg);
+}
+//#endregion
+//#region src/server.ts
+/** Build a {@link GenContext} from a handler payload + endpoint name. */
+function contextFor(name, payload, opts) {
+	const data = payload.data ?? {};
+	return {
+		path: "",
+		rng: makeRng(opts, name, JSON.stringify(payload.data ?? null)),
+		request: payload.data,
+		query: data
+	};
+}
+/** Read an endpoint config's schemas off its erased definition. */
+function cfgOf(def) {
+	return def.cfg;
+}
+/** Smallest declared status in a multi-status map (deterministic choice). */
+function firstStatus(responses) {
+	return Math.min(...Object.keys(responses).map(Number));
+}
+/** Build the handler for one endpoint, dispatching on its response shape. */
+function handlerFor(name, def, opts) {
+	const cfg = cfgOf(def);
+	const gcfg = resolveConfig(opts);
+	if (cfg.streamOut && typeof cfg.streamOut !== "string") {
+		const itemSchema = cfg.streamOut;
+		return (payload) => {
+			const ctx = contextFor(name, payload, opts);
+			const n = resolveSize(ctx.query, gcfg);
+			return (async function* () {
+				for (let i = 0; i < n; i++) yield genValue(itemSchema, {
+					...ctx,
+					path: String(i)
+				}, gcfg);
+			})();
+		};
+	}
+	if (cfg.responses) {
+		const responses = cfg.responses;
+		const status = firstStatus(responses);
+		const schema = responses[status];
+		return (payload) => {
+			return {
+				status,
+				data: genValue(schema, contextFor(name, payload, opts), gcfg)
+			};
+		};
+	}
+	if (cfg.response) {
+		const schema = cfg.response;
+		return (payload) => genValue(schema, contextFor(name, payload, opts), gcfg);
+	}
+	return () => void 0;
+}
+/**
+* Build the handler bag for a spec — one generated handler per endpoint, suitable
+* for `server(spec, [implement(spec).handlers(bag)])`.
+*
+* @example
+* ```ts
+* const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+* ```
+*/
+function mockHandlers(spec, opts) {
+	const bag = {};
+	for (const [name, def] of Object.entries(spec.endpoints)) bag[name] = handlerFor(name, def, opts);
+	return bag;
+}
+/**
+* Build a real ayepi {@link Server} for a spec where every endpoint returns
+* generated, schema-valid data. Routing, input validation, output validation, and
+* the OpenAPI/AsyncAPI docs all behave exactly as a real server's.
+*
+* @example
+* ```ts
+* const app = mockServer(api, { seed: 1, arraySize: 5 })
+* const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method: 'POST' }))
+* ```
+*/
+function mockServer(spec, opts) {
+	const bag = mockHandlers(spec, opts);
+	return (0, _ayepi_core.server)(spec, [(0, _ayepi_core.implement)(spec).handlers(bag)]);
+}
+//#endregion
+exports.generate = generate;
+exports.mockHandlers = mockHandlers;
+exports.mockServer = mockServer;

package/dist/index.d.cts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { AnySpec, Server } from "@ayepi/core";
+
+//#region src/types.d.ts
+
+/**
+ * # Public option & context types
+ *
+ * The configuration surface ({@link MockOptions}) and the per-generation context
+ * ({@link GenContext}) passed to override callbacks. Kept in their own module so
+ * both the generator and the server entry points can import them without a cycle.
+ *
+ * @module
+ */
+/**
+ * Context handed to override callbacks (and threaded through the generator). It
+ * exposes where in the schema we are ({@link GenContext.path | path}), the seeded
+ * {@link GenContext.rng | rng}, and the request inputs that seeded it.
+ */
+interface GenContext {
+  /** Dotted path to the value being generated, e.g. `user.address.city` or `items.0`. */
+  readonly path: string;
+  /** The seeded PRNG for this generation — call it for floats in `[0, 1)`. */
+  readonly rng: () => number;
+  /** The full request data that seeded this generation (server mocks), else `undefined`. */
+  readonly request: unknown;
+  /** The request query params that seeded this generation (drives pagination). */
+  readonly query: Record<string, unknown>;
+}
+/** An override callback: receives the {@link GenContext} and returns a value. */
+type Override = (g: GenContext) => unknown;
+/** Per-field and per-format override tables. */
+interface MockOverrides {
+  /** Keyed by property name or dotted path (e.g. `email` or `user.email`). */
+  readonly fields?: Readonly<Record<string, Override>>;
+  /** Keyed by detected zod string format (e.g. `email`, `uuid`, `url`, `datetime`). */
+  readonly formats?: Readonly<Record<string, Override>>;
+}
+/**
+ * Configuration for fake-data generation and the mock server.
+ *
+ * The defaults aim for *deterministic* output: with {@link MockOptions.deterministic}
+ * on (the default), the PRNG is seeded from `seed + endpoint + JSON(request)`, so the
+ * same inputs always produce the same bytes — which is what makes paginated responses
+ * stable across calls.
+ */
+interface MockOptions {
+  /** Base seed; combined with the endpoint + request to seed the PRNG. Default `0`. */
+  readonly seed?: number | string;
+  /** When `true` (default), generation is a pure function of seed + inputs. When `false`, uses `Math.random`. */
+  readonly deterministic?: boolean;
+  /** Default element count for arrays with no size hint. Default `3`. */
+  readonly arraySize?: number;
+  /** Query keys whose value sizes generated arrays (pagination). Default `['limit', 'pageSize', 'count']`. */
+  readonly limitKeys?: readonly string[];
+  /** Per-field / per-format value overrides. */
+  readonly overrides?: MockOverrides;
+  /** Clock used for date generation (injectable for tests). Default `Date.now`. */
+  readonly now?: () => number;
+}
+//#endregion
+//#region src/generate.d.ts
+
+/**
+ * Generate one schema-valid fake value from a zod schema.
+ *
+ * @param schema - any zod schema.
+ * @param opts   - seeding / sizing / override options.
+ * @param ctx    - partial context overrides (e.g. a fixed `path`, `request`, `query`).
+ * @returns a value that parses against `schema`.
+ *
+ * @example
+ * ```ts
+ * const user = generate(z.object({ id: z.uuid(), name: z.string() }), { seed: 1 })
+ * ```
+ */
+declare function generate(schema: z.ZodType, opts?: MockOptions, ctx?: Partial<GenContext>): unknown;
+//#endregion
+//#region src/server.d.ts
+/** A handler payload, narrowed to the parts the mock reads. */
+interface MockPayload {
+  readonly data?: unknown;
+}
+/** A single generated mock handler (erased payload/return types). */
+type MockHandler = (payload: MockPayload) => unknown;
+/**
+ * Build the handler bag for a spec — one generated handler per endpoint, suitable
+ * for `server(spec, [implement(spec).handlers(bag)])`.
+ *
+ * @example
+ * ```ts
+ * const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+ * ```
+ */
+declare function mockHandlers(spec: AnySpec, opts?: MockOptions): Record<string, MockHandler>;
+/**
+ * Build a real ayepi {@link Server} for a spec where every endpoint returns
+ * generated, schema-valid data. Routing, input validation, output validation, and
+ * the OpenAPI/AsyncAPI docs all behave exactly as a real server's.
+ *
+ * @example
+ * ```ts
+ * const app = mockServer(api, { seed: 1, arraySize: 5 })
+ * const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method: 'POST' }))
+ * ```
+ */
+declare function mockServer(spec: AnySpec, opts?: MockOptions): Server<AnySpec>;
+//#endregion
+export { type GenContext, type MockOptions, type MockOverrides, type Override, generate, mockHandlers, mockServer };

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+import { AnySpec, Server } from "@ayepi/core";
+import { z } from "zod";
+
+//#region src/types.d.ts
+
+/**
+ * # Public option & context types
+ *
+ * The configuration surface ({@link MockOptions}) and the per-generation context
+ * ({@link GenContext}) passed to override callbacks. Kept in their own module so
+ * both the generator and the server entry points can import them without a cycle.
+ *
+ * @module
+ */
+/**
+ * Context handed to override callbacks (and threaded through the generator). It
+ * exposes where in the schema we are ({@link GenContext.path | path}), the seeded
+ * {@link GenContext.rng | rng}, and the request inputs that seeded it.
+ */
+interface GenContext {
+  /** Dotted path to the value being generated, e.g. `user.address.city` or `items.0`. */
+  readonly path: string;
+  /** The seeded PRNG for this generation — call it for floats in `[0, 1)`. */
+  readonly rng: () => number;
+  /** The full request data that seeded this generation (server mocks), else `undefined`. */
+  readonly request: unknown;
+  /** The request query params that seeded this generation (drives pagination). */
+  readonly query: Record<string, unknown>;
+}
+/** An override callback: receives the {@link GenContext} and returns a value. */
+type Override = (g: GenContext) => unknown;
+/** Per-field and per-format override tables. */
+interface MockOverrides {
+  /** Keyed by property name or dotted path (e.g. `email` or `user.email`). */
+  readonly fields?: Readonly<Record<string, Override>>;
+  /** Keyed by detected zod string format (e.g. `email`, `uuid`, `url`, `datetime`). */
+  readonly formats?: Readonly<Record<string, Override>>;
+}
+/**
+ * Configuration for fake-data generation and the mock server.
+ *
+ * The defaults aim for *deterministic* output: with {@link MockOptions.deterministic}
+ * on (the default), the PRNG is seeded from `seed + endpoint + JSON(request)`, so the
+ * same inputs always produce the same bytes — which is what makes paginated responses
+ * stable across calls.
+ */
+interface MockOptions {
+  /** Base seed; combined with the endpoint + request to seed the PRNG. Default `0`. */
+  readonly seed?: number | string;
+  /** When `true` (default), generation is a pure function of seed + inputs. When `false`, uses `Math.random`. */
+  readonly deterministic?: boolean;
+  /** Default element count for arrays with no size hint. Default `3`. */
+  readonly arraySize?: number;
+  /** Query keys whose value sizes generated arrays (pagination). Default `['limit', 'pageSize', 'count']`. */
+  readonly limitKeys?: readonly string[];
+  /** Per-field / per-format value overrides. */
+  readonly overrides?: MockOverrides;
+  /** Clock used for date generation (injectable for tests). Default `Date.now`. */
+  readonly now?: () => number;
+}
+//#endregion
+//#region src/generate.d.ts
+
+/**
+ * Generate one schema-valid fake value from a zod schema.
+ *
+ * @param schema - any zod schema.
+ * @param opts   - seeding / sizing / override options.
+ * @param ctx    - partial context overrides (e.g. a fixed `path`, `request`, `query`).
+ * @returns a value that parses against `schema`.
+ *
+ * @example
+ * ```ts
+ * const user = generate(z.object({ id: z.uuid(), name: z.string() }), { seed: 1 })
+ * ```
+ */
+declare function generate(schema: z.ZodType, opts?: MockOptions, ctx?: Partial<GenContext>): unknown;
+//#endregion
+//#region src/server.d.ts
+/** A handler payload, narrowed to the parts the mock reads. */
+interface MockPayload {
+  readonly data?: unknown;
+}
+/** A single generated mock handler (erased payload/return types). */
+type MockHandler = (payload: MockPayload) => unknown;
+/**
+ * Build the handler bag for a spec — one generated handler per endpoint, suitable
+ * for `server(spec, [implement(spec).handlers(bag)])`.
+ *
+ * @example
+ * ```ts
+ * const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+ * ```
+ */
+declare function mockHandlers(spec: AnySpec, opts?: MockOptions): Record<string, MockHandler>;
+/**
+ * Build a real ayepi {@link Server} for a spec where every endpoint returns
+ * generated, schema-valid data. Routing, input validation, output validation, and
+ * the OpenAPI/AsyncAPI docs all behave exactly as a real server's.
+ *
+ * @example
+ * ```ts
+ * const app = mockServer(api, { seed: 1, arraySize: 5 })
+ * const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method: 'POST' }))
+ * ```
+ */
+declare function mockServer(spec: AnySpec, opts?: MockOptions): Server<AnySpec>;
+//#endregion
+export { type GenContext, type MockOptions, type MockOverrides, type Override, generate, mockHandlers, mockServer };

package/dist/index.js

@@ -0,0 +1,445 @@
+import { implement, server } from "@ayepi/core";
+//#region src/rng.ts
+/**
+* # Seeded PRNG
+*
+* A tiny, dependency-free deterministic random number generator. {@link fnv1a}
+* folds an arbitrary string into a 32-bit seed; {@link mulberry32} turns that
+* seed into a `() => number` stream of floats in `[0, 1)`. Given the same seed
+* the stream is byte-for-byte reproducible, which is what makes deterministic
+* mocking — and therefore stable pagination — possible.
+*
+* @module
+*/
+/** FNV-1a offset basis (32-bit). */
+const FNV_OFFSET_BASIS = 2166136261;
+/** FNV-1a prime (32-bit). */
+const FNV_PRIME = 16777619;
+/** Mask to keep arithmetic within 32 unsigned bits. */
+const U32_MASK = 4294967295;
+/** mulberry32 mixing constant added to the running state each step. */
+const MULBERRY_INCREMENT = 1831565813;
+/** mulberry32 second-round multiply constant. */
+const MULBERRY_ROUND2 = 3266489909;
+/** Divisor that maps a 32-bit unsigned integer into `[0, 1)`. */
+const U32_DIVISOR = 4294967296;
+/**
+* Hash a string into a 32-bit unsigned integer with FNV-1a.
+*
+* Used to fold a composite seed (`baseSeed + endpoint + JSON(request)`) down to a
+* single integer the PRNG can be initialized from.
+*/
+function fnv1a(input) {
+	let hash = FNV_OFFSET_BASIS;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, FNV_PRIME);
+	}
+	return hash >>> 0;
+}
+/**
+* Build a deterministic `() => number` PRNG (floats in `[0, 1)`) from a 32-bit
+* seed using the mulberry32 algorithm. Identical seeds yield identical streams.
+*/
+function mulberry32(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + MULBERRY_INCREMENT & U32_MASK;
+		let t = state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | MULBERRY_ROUND2);
+		t = (t ^ t >>> 14) >>> 0;
+		return t / U32_DIVISOR;
+	};
+}
+/**
+* Convenience: hash a string seed and return a fresh PRNG stream for it.
+*
+* @param parts - composite seed parts joined into the hash input.
+*/
+function rngFromParts(...parts) {
+	return mulberry32(fnv1a(parts.join("\0")));
+}
+/** Default query keys whose value sizes generated arrays. */
+const DEFAULT_LIMIT_KEYS = [
+	"limit",
+	"pageSize",
+	"count"
+];
+/** Default base seed when none is supplied. */
+const DEFAULT_SEED = "0";
+/** Fallback string length used when a format/length constraint gives no better hint. */
+const WORD_LENGTH = 8;
+/** Default integer ceiling (exclusive) for unconstrained number generation. */
+const INT_RANGE = 1e3;
+/** Decimal places kept for unconstrained floats. */
+const FLOAT_PRECISION = 1e3;
+/** Probability an optional/nullable value is *present* (non-undefined / non-null). */
+const PRESENCE_PROB = .7;
+/** Record entry count when generating from a `z.record`. */
+const RECORD_SIZE = 2;
+/** Bound used for bigint generation when unconstrained. */
+const BIGINT_RANGE = 1e3;
+/** Number `format` values that require an integer result. */
+const INT_FORMATS = new Set([
+	"safeint",
+	"int32",
+	"uint32"
+]);
+/** Characters drawn from when padding/building plain strings. */
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+/** Hex characters for uuid/id-shaped formats. */
+const HEX = "0123456789abcdef";
+/** Read a schema's internal `_zod.def`. */
+function def(schema) {
+	return schema._zod.def;
+}
+/** Read the (possibly empty) list of check descriptors on a schema. */
+function checks(d) {
+	return (d.checks ?? []).map((c) => c._zod.def);
+}
+/** Pull min/max/int constraints off a number schema's checks (and its `format`). */
+function numBounds(d) {
+	let min = null;
+	let max = null;
+	let int = d.format !== void 0 && INT_FORMATS.has(d.format);
+	for (const c of checks(d)) if (c.check === "greater_than" && typeof c.value === "number") min = c.inclusive ? c.value : c.value + 1;
+	else if (c.check === "less_than" && typeof c.value === "number") max = c.inclusive ? c.value : c.value - 1;
+	else if (c.check === "number_format") int = true;
+	return {
+		min,
+		max,
+		int
+	};
+}
+/** Pull min/max length constraints off a string/array schema's checks. */
+function lenBounds(d) {
+	let min = null;
+	let max = null;
+	for (const c of checks(d)) if (c.check === "min_length" && typeof c.minimum === "number") min = c.minimum;
+	else if (c.check === "max_length" && typeof c.maximum === "number") max = c.maximum;
+	else if (c.check === "length_equals" && typeof c.length === "number") min = max = c.length;
+	return {
+		min,
+		max
+	};
+}
+/** Draw an integer in `[lo, hi]` (inclusive) from the rng. */
+function intIn(rng, lo, hi) {
+	/* v8 ignore next */ if (hi < lo) return lo;
+	return lo + Math.floor(rng() * (hi - lo + 1));
+}
+/** Pick a random element of a non-empty array. */
+function pick(rng, arr) {
+	return arr[Math.floor(rng() * arr.length)];
+}
+/** Build a lowercase word of `len` characters. */
+function word(rng, len) {
+	let s = "";
+	for (let i = 0; i < len; i++) s += ALPHABET[Math.floor(rng() * 26)];
+	return s;
+}
+/** Build a hex string of `len` characters. */
+function hex(rng, len) {
+	let s = "";
+	for (let i = 0; i < len; i++) s += HEX[Math.floor(rng() * 16)];
+	return s;
+}
+/** Build a value for a detected/declared zod string `format`. */
+function formatValue(format, rng, now) {
+	switch (format) {
+		case "email": return `${word(rng, WORD_LENGTH)}@example.com`;
+		case "url": return `https://${word(rng, WORD_LENGTH)}.example.com`;
+		case "uuid":
+		case "guid": return `${hex(rng, 8)}-${hex(rng, 4)}-4${hex(rng, 3)}-8${hex(rng, 3)}-${hex(rng, 12)}`;
+		case "datetime": return new Date(now).toISOString();
+		case "date": return new Date(now).toISOString().slice(0, 10);
+		case "time": return new Date(now).toISOString().slice(11, 23);
+		case "duration": return `PT${intIn(rng, 1, 60)}M`;
+		case "ipv4": return `${intIn(rng, 1, 254)}.${intIn(rng, 0, 255)}.${intIn(rng, 0, 255)}.${intIn(rng, 1, 254)}`;
+		case "ipv6": return `${hex(rng, 4)}:${hex(rng, 4)}::${hex(rng, 4)}`;
+		case "cuid":
+		case "cuid2": return `c${word(rng, 24)}`;
+		case "ulid": return hex(rng, 26).toUpperCase();
+		case "nanoid": return word(rng, 21);
+		case "emoji": return pick(rng, [
+			"😀",
+			"🎉",
+			"🚀",
+			"🌟",
+			"🔥"
+		]);
+		case "e164": return `+1${intIn(rng, 2e9, 9999999999)}`;
+		case "base64": return Buffer.from(word(rng, WORD_LENGTH)).toString("base64");
+		case "base64url": return Buffer.from(word(rng, WORD_LENGTH)).toString("base64url");
+		default: return word(rng, WORD_LENGTH);
+	}
+}
+/** Build a plain string whose length lands within the schema's min/max bounds. */
+function plainString(rng, bounds) {
+	const min = bounds.min ?? 0;
+	return word(rng, intIn(rng, min, bounds.max ?? Math.max(min, WORD_LENGTH)));
+}
+/** Build a number honoring int/min/max constraints. */
+function genNumber(d, rng) {
+	const { min, max, int } = numBounds(d);
+	if (int) {
+		const lo = min ?? 0;
+		return intIn(rng, lo, max ?? lo + INT_RANGE);
+	}
+	const lo = min ?? 0;
+	const hi = max ?? lo + INT_RANGE;
+	const raw = lo + rng() * (hi - lo);
+	return Math.round(raw * FLOAT_PRECISION) / FLOAT_PRECISION;
+}
+/** Build a bigint honoring min/max constraints. */
+function genBigint(d, rng) {
+	let min = null;
+	let max = null;
+	for (const c of checks(d)) if (c.check === "greater_than" && typeof c.value === "bigint") min = c.inclusive ? c.value : c.value + 1n;
+	else if (c.check === "less_than" && typeof c.value === "bigint") max = c.inclusive ? c.value : c.value - 1n;
+	const lo = min ?? 0n;
+	const span = (max ?? lo + BigInt(BIGINT_RANGE)) - lo;
+	if (span <= 0n) return lo;
+	return lo + BigInt(Math.floor(rng() * BIGINT_RANGE)) % (span + 1n);
+}
+/**
+* Resolve a collection size from the request query. A `limit`-style query key
+* (the first of {@link MockOptions.limitKeys | limitKeys} present and non-negative)
+* wins; otherwise the configured default {@link MockOptions.arraySize | arraySize}
+* is used. Shared by array generation and `streamOut` item counting so pagination
+* is consistent across both.
+*/
+function resolveSize(query, cfg) {
+	for (const key of cfg.limitKeys) {
+		const raw = query[key];
+		if (typeof raw !== "string" && typeof raw !== "number") continue;
+		const n = Number(raw);
+		if (Number.isFinite(n) && n >= 0) return Math.floor(n);
+	}
+	return cfg.arraySize;
+}
+/** Last path segment (the field/property name) for override lookup. */
+function leaf(path) {
+	const i = path.lastIndexOf(".");
+	return i < 0 ? path : path.slice(i + 1);
+}
+/**
+* Generate a value for `schema` at `ctx.path`. Recurses over the zod type tree,
+* applying field overrides (by leaf name or full path) and format overrides.
+*/
+function genValue(schema, ctx, cfg) {
+	const fieldOverride = cfg.overrides.fields[ctx.path] ?? cfg.overrides.fields[leaf(ctx.path)];
+	if (fieldOverride) return fieldOverride(ctx);
+	const d = def(schema);
+	switch (d.type) {
+		case "string": {
+			const format = d.format;
+			if (format) {
+				const fmtOverride = cfg.overrides.formats[format];
+				if (fmtOverride) return fmtOverride(ctx);
+				return formatValue(format, ctx.rng, cfg.now());
+			}
+			return plainString(ctx.rng, lenBounds(d));
+		}
+		case "number": return genNumber(d, ctx.rng);
+		case "bigint": return genBigint(d, ctx.rng);
+		case "boolean": return ctx.rng() < .5;
+		case "date": return new Date(cfg.now());
+		case "literal": return d.values[0];
+		case "enum": return pick(ctx.rng, Object.values(d.entries));
+		case "object": {
+			const out = {};
+			for (const [key, child] of Object.entries(d.shape)) {
+				const childPath = ctx.path ? `${ctx.path}.${key}` : key;
+				out[key] = genValue(child, {
+					...ctx,
+					path: childPath
+				}, cfg);
+			}
+			return out;
+		}
+		case "array": {
+			const n = resolveSize(ctx.query, cfg);
+			const bounds = lenBounds(d);
+			const count = Math.max(bounds.min ?? 0, Math.min(n, bounds.max ?? n));
+			const out = [];
+			for (let i = 0; i < count; i++) out.push(genValue(d.element, {
+				...ctx,
+				path: `${ctx.path}.${i}`
+			}, cfg));
+			return out;
+		}
+		case "tuple": {
+			const out = d.items.map((item, i) => genValue(item, {
+				...ctx,
+				path: `${ctx.path}.${i}`
+			}, cfg));
+			if (d.rest) out.push(genValue(d.rest, {
+				...ctx,
+				path: `${ctx.path}.${out.length}`
+			}, cfg));
+			return out;
+		}
+		case "record": {
+			const out = {};
+			for (let i = 0; i < RECORD_SIZE; i++) {
+				const key = word(ctx.rng, WORD_LENGTH);
+				out[key] = genValue(d.valueType, {
+					...ctx,
+					path: `${ctx.path}.${key}`
+				}, cfg);
+			}
+			return out;
+		}
+		case "union": return genValue(pick(ctx.rng, d.options), ctx, cfg);
+		case "optional":
+			if (ctx.rng() < PRESENCE_PROB) return genValue(d.innerType, ctx, cfg);
+			return;
+		case "nullable":
+			if (ctx.rng() < PRESENCE_PROB) return genValue(d.innerType, ctx, cfg);
+			return null;
+		case "default":
+		case "prefault":
+			if (ctx.rng() < PRESENCE_PROB) return genValue(d.innerType, ctx, cfg);
+			return d.defaultValue;
+		case "catch":
+		case "readonly":
+		case "nonoptional": return genValue(d.innerType, ctx, cfg);
+		default: return fallback(d, ctx);
+	}
+}
+/** Sensible value for schema types we don't model precisely (any/unknown/null/etc.). */
+function fallback(d, ctx) {
+	switch (d.type) {
+		case "null": return null;
+		case "undefined":
+		case "void": return;
+		default: return word(ctx.rng, WORD_LENGTH);
+	}
+}
+/** Build the resolved {@link GenConfig} from public {@link MockOptions}. */
+function resolveConfig(opts) {
+	return {
+		arraySize: opts?.arraySize ?? 3,
+		limitKeys: opts?.limitKeys ?? DEFAULT_LIMIT_KEYS,
+		overrides: {
+			fields: { ...opts?.overrides?.fields ?? {} },
+			formats: { ...opts?.overrides?.formats ?? {} }
+		},
+		now: opts?.now ?? Date.now
+	};
+}
+/** Build the per-generation RNG: deterministic hash-seeded, or `Math.random`. */
+function makeRng(opts, ...seedParts) {
+	if (opts?.deterministic === false) return Math.random;
+	return rngFromParts(String(opts?.seed ?? DEFAULT_SEED), ...seedParts);
+}
+/**
+* Generate one schema-valid fake value from a zod schema.
+*
+* @param schema - any zod schema.
+* @param opts   - seeding / sizing / override options.
+* @param ctx    - partial context overrides (e.g. a fixed `path`, `request`, `query`).
+* @returns a value that parses against `schema`.
+*
+* @example
+* ```ts
+* const user = generate(z.object({ id: z.uuid(), name: z.string() }), { seed: 1 })
+* ```
+*/
+function generate(schema, opts, ctx) {
+	const cfg = resolveConfig(opts);
+	const rng = ctx?.rng ?? makeRng(opts, JSON.stringify(ctx?.request ?? null));
+	return genValue(schema, {
+		path: ctx?.path ?? "",
+		rng,
+		request: ctx?.request,
+		query: ctx?.query ?? {}
+	}, cfg);
+}
+//#endregion
+//#region src/server.ts
+/** Build a {@link GenContext} from a handler payload + endpoint name. */
+function contextFor(name, payload, opts) {
+	const data = payload.data ?? {};
+	return {
+		path: "",
+		rng: makeRng(opts, name, JSON.stringify(payload.data ?? null)),
+		request: payload.data,
+		query: data
+	};
+}
+/** Read an endpoint config's schemas off its erased definition. */
+function cfgOf(def) {
+	return def.cfg;
+}
+/** Smallest declared status in a multi-status map (deterministic choice). */
+function firstStatus(responses) {
+	return Math.min(...Object.keys(responses).map(Number));
+}
+/** Build the handler for one endpoint, dispatching on its response shape. */
+function handlerFor(name, def, opts) {
+	const cfg = cfgOf(def);
+	const gcfg = resolveConfig(opts);
+	if (cfg.streamOut && typeof cfg.streamOut !== "string") {
+		const itemSchema = cfg.streamOut;
+		return (payload) => {
+			const ctx = contextFor(name, payload, opts);
+			const n = resolveSize(ctx.query, gcfg);
+			return (async function* () {
+				for (let i = 0; i < n; i++) yield genValue(itemSchema, {
+					...ctx,
+					path: String(i)
+				}, gcfg);
+			})();
+		};
+	}
+	if (cfg.responses) {
+		const responses = cfg.responses;
+		const status = firstStatus(responses);
+		const schema = responses[status];
+		return (payload) => {
+			return {
+				status,
+				data: genValue(schema, contextFor(name, payload, opts), gcfg)
+			};
+		};
+	}
+	if (cfg.response) {
+		const schema = cfg.response;
+		return (payload) => genValue(schema, contextFor(name, payload, opts), gcfg);
+	}
+	return () => void 0;
+}
+/**
+* Build the handler bag for a spec — one generated handler per endpoint, suitable
+* for `server(spec, [implement(spec).handlers(bag)])`.
+*
+* @example
+* ```ts
+* const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+* ```
+*/
+function mockHandlers(spec, opts) {
+	const bag = {};
+	for (const [name, def] of Object.entries(spec.endpoints)) bag[name] = handlerFor(name, def, opts);
+	return bag;
+}
+/**
+* Build a real ayepi {@link Server} for a spec where every endpoint returns
+* generated, schema-valid data. Routing, input validation, output validation, and
+* the OpenAPI/AsyncAPI docs all behave exactly as a real server's.
+*
+* @example
+* ```ts
+* const app = mockServer(api, { seed: 1, arraySize: 5 })
+* const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method: 'POST' }))
+* ```
+*/
+function mockServer(spec, opts) {
+	const bag = mockHandlers(spec, opts);
+	return server(spec, [implement(spec).handlers(bag)]);
+}
+//#endregion
+export { generate, mockHandlers, mockServer };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@ayepi/mock",
+  "version": "0.1.0",
+  "description": "Mock server for @ayepi/core — generate schema-valid fake data from a spec, with deterministic seeding and automatic pagination",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ClickerMonkey/ayepi.git",
+    "directory": "packages/mock"
+  },
+  "homepage": "https://github.com/ClickerMonkey/ayepi/tree/main/packages/mock#readme",
+  "bugs": {
+    "url": "https://github.com/ClickerMonkey/ayepi/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "zod": "^4",
+    "@ayepi/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.8",
+    "publint": "^0.3.0",
+    "tsdown": "^0.12.0",
+    "vitest": "^2.1.8",
+    "zod": "^4.4.3",
+    "@ayepi/core": "0.1.0"
+  },
+  "keywords": [
+    "ayepi",
+    "mock",
+    "faker",
+    "testing",
+    "fixtures",
+    "seed"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --coverage",
+    "publint": "publint"
+  }
+}