@ayepi/mock 0.4.0 → 0.5.0

package/README.md

@@ -32,8 +32,9 @@ const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method:
 ## 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)])`.
+- `mockHandlers(spec, opts?)` — a handler bag typed per endpoint for `server(spec, [implement(spec).handlers(bag)])`; `except` leaves out the endpoints you implement for real.
 - `mockServer(spec, opts?)` — a real ayepi `Server` with generated responses.
+- `mockEvents(app, opts?)` — generated, schema-valid events through a server's `emit`, on demand or on a timer.
 
 See [`ayepi-mock.md`](./ayepi-mock.md) for the full reference (options, seeding,
 determinism, pagination, overrides, supported zod types, and gotchas).

package/ayepi-mock.md

@@ -40,8 +40,11 @@ const body = await res.json() // schema-valid, deterministic, 10 items
 ## Public API
 
 ```ts
-import { generate, mockServer, mockHandlers } from '@ayepi/mock'
-import type { MockOptions, MockOverrides, GenContext, Override } from '@ayepi/mock'
+import { generate, mockServer, mockHandlers, mockEvents } from '@ayepi/mock'
+import type {
+  MockOptions, MockOverrides, GenContext, Override,
+  MockHandlersOptions, MockHandlerBag, MockEventsOptions, MockEvents, EndpointName, EventName,
+} from '@ayepi/mock'
 ```
 
 ### `generate(schema, opts?, ctx?) => unknown`
@@ -62,18 +65,36 @@ const user = generate(z.object({ id: z.uuid(), name: z.string(), age: z.int().mi
   - `path` — starting path for override lookup (rarely needed).
   - `rng` — supply your own `() => number` to fully control randomness (tests).
 
-### `mockHandlers(spec, opts?) => Record<string, Handler>`
+### `mockHandlers(spec, opts?) => MockHandlerBag<S, Exclude<EndpointName<S>, X>>`
 
-The handler bag for `server(spec, [implement(spec).handlers(bag)])`. One generated handler
-per endpoint. Use this when you want to mix mock handlers with real ones, or add
-middleware/options yourself.
+The handler bag for `server(spec, [implement(spec).handlers(bag)])`: one generated handler
+per endpoint, **typed per endpoint** (`HandlerFor<S, S['endpoints'][K]>`), so it needs no
+cast. `opts` is `MockOptions` plus `except?: readonly X[]` — endpoint names to leave out
+(you implement them for real). The bag's type omits them, so `server()`'s missing-handler
+compile check sees exactly which endpoints the mock covers and which still need a handler.
 
 ```ts
 import { server, implement } from '@ayepi/core'
 const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
 ```
 
-### `mockServer(spec, opts?) => Server`
+### `mockEvents(app, opts?) => MockEvents<S>`
+
+Generated, schema-valid event traffic through a server's typed `emit` (any `Pick<Server<S>,
+'spec' | 'emit'>`, real or mock). Each emission generates the event's channel params (when it
+has a `params` schema) and its `data`. The n-th emission of an event is seeded from
+`seed + 'event' + name + n`, so a run replays identically. `opts` is `MockOptions` plus
+`only?: readonly EventName<S>[]` — the events `tick`/`start` pick from (default: all).
+
+```ts
+const events = mockEvents(app, { seed: 1, only: ['userChanged'] })
+events.emit('userChanged') // one generated event now (unknown names fail to compile; throw at runtime)
+events.tick()              // the next event from the chosen set, in order
+events.start(1_000)        // tick every second (restarts if already running)
+events.stop()
+```
+
+### `mockServer(spec, opts?) => Server<S>`
 
 The convenience path: builds the handler bag and wires it into
 `server(spec, [implement(spec).handlers(bag)])`, returning a real ayepi `Server`. Routing, **input validation**, **output validation**, and
@@ -217,16 +238,23 @@ word — pin those with a `fields`/`formats` override.
 ## Recipes
 
 **Mix mock and real handlers** — implement the endpoints you have, mock the rest.
-`mockHandlers` returns a plain handler bag, so merge it with your real handlers (real keys
-win) and wrap the merged bag in a single `implement(api).handlers(...)` builder:
+Name the real endpoints in `except`; the typed bag covers the rest, and `server()` checks at
+compile time that the two builders together handle every endpoint exactly once:
 
 ```ts
 import { implement, server } from '@ayepi/core'
 import { mockHandlers } from '@ayepi/mock'
 
-const real = { getUser: ({ data }) => loadUser(data.id) }
-const bag = { ...mockHandlers(api), ...real }     // mocks fill the gaps; real overrides
-const app = server(api, [implement(api).handlers(bag)])
+const real = implement(api).handlers({ getUser: ({ data }) => loadUser(data.id) })
+const mocked = implement(api).handlers(mockHandlers(api, { except: ['getUser'] }))
+const app = server(api, [real, mocked])
+```
+
+**Realtime UI on a mock** — emit generated events on a timer:
+
+```ts
+const app = mockServer(api, { seed: 1 })
+mockEvents(app, { seed: 1 }).start(2_000)
 ```
 
 **Stable demo data** — fix the seed and clock so screenshots never drift:

package/dist/index.cjs

@@ -363,14 +363,17 @@ function generate(schema, opts, ctx) {
 //#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
+		query: isRecord(payload.data) ? payload.data : {}
 	};
 }
+/** Whether `value` is a plain keyed object (the merged params/query/body record a handler receives). */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /** Read an endpoint config's schemas off its erased definition. */
 function cfgOf(def) {
 	return def.cfg;
@@ -414,17 +417,23 @@ function handlerFor(name, def, opts) {
 	return () => void 0;
 }
 /**
-* Build the handler bag for a spec — one generated handler per endpoint, suitable
-* for `server(spec, [implement(spec).handlers(bag)])`.
+* Build the handler bag for a spec — one generated handler per endpoint (minus any
+* named in `except`), typed per endpoint, so it drops straight into
+* `implement(spec).handlers(bag)` and `server()`'s missing-handler check sees exactly
+* which endpoints it covers.
 *
 * @example
 * ```ts
 * const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+* // real handlers for some endpoints, generated data for the rest:
+* const real = implement(api).handlers({ getUser: loadUser })
+* const app2 = server(api, [real, implement(api).handlers(mockHandlers(api, { except: ['getUser'] }))])
 * ```
 */
 function mockHandlers(spec, opts) {
+	const except = new Set(opts?.except ?? []);
 	const bag = {};
-	for (const [name, def] of Object.entries(spec.endpoints)) bag[name] = handlerFor(name, def, opts);
+	for (const [name, def] of Object.entries(spec.endpoints)) if (!except.has(name)) bag[name] = handlerFor(name, def, opts);
 	return bag;
 }
 /**
@@ -439,10 +448,65 @@ function mockHandlers(spec, opts) {
 * ```
 */
 function mockServer(spec, opts) {
-	const bag = mockHandlers(spec, opts);
-	return (0, _ayepi_core.server)(spec, [(0, _ayepi_core.implement)(spec).handlers(bag)]);
+	const erased = spec;
+	return (0, _ayepi_core.server)(erased, [(0, _ayepi_core.implement)(erased).handlers(mockHandlers(erased, opts))]);
+}
+//#endregion
+//#region src/events.ts
+/**
+* Build a generated event emitter over `app` (any server for the spec, real or mock).
+*
+* @example
+* ```ts
+* const app = mockServer(api, { seed: 1 })
+* const events = mockEvents(app, { seed: 1, only: ['userChanged'] })
+* events.start(1_000) // a generated userChanged every second
+* ```
+*/
+function mockEvents(app, opts) {
+	const gcfg = resolveConfig(opts);
+	const defs = app.spec.events ?? {};
+	const send = app.emit;
+	const names = opts?.only ?? Object.keys(defs);
+	const counts = /* @__PURE__ */ new Map();
+	let next = 0;
+	let timer;
+	const emit = (name) => {
+		const def = defs[name];
+		if (def === void 0) throw new Error(`mockEvents: the spec has no event "${name}"`);
+		const n = counts.get(name) ?? 0;
+		counts.set(name, n + 1);
+		const ctx = {
+			path: "",
+			rng: makeRng(opts, "event", name, String(n)),
+			request: void 0,
+			query: {}
+		};
+		const data = genValue(def.data, ctx, gcfg);
+		if (def.params) send(name, genValue(def.params, ctx, gcfg), data);
+		else send(name, data);
+	};
+	const stop = () => {
+		if (timer !== void 0) clearInterval(timer);
+		timer = void 0;
+	};
+	const tick = () => {
+		const name = names[next++ % Math.max(names.length, 1)];
+		if (name !== void 0) emit(name);
+	};
+	const start = (every) => {
+		stop();
+		timer = setInterval(tick, every);
+	};
+	return {
+		emit,
+		tick,
+		start,
+		stop
+	};
 }
 //#endregion
 exports.generate = generate;
+exports.mockEvents = mockEvents;
 exports.mockHandlers = mockHandlers;
 exports.mockServer = mockServer;

package/dist/index.d.cts

@@ -1,17 +1,12 @@
+import { AnySpec, EventsOf, HandlerFor, Server } from "@ayepi/core";
 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
- */
+/** A spec's endpoint names. */
+type EndpointName<S extends AnySpec> = keyof S['endpoints'] & string;
+/** A spec's event names. */
+type EventName<S extends AnySpec> = keyof EventsOf<S> & string;
 /**
  * Context handed to override callbacks (and threaded through the generator). It
  * exposes where in the schema we are ({@link GenContext.path | path}), the seeded
@@ -58,9 +53,29 @@ interface MockOptions {
   /** Clock used for date generation (injectable for tests). Default `Date.now`. */
   readonly now?: () => number;
 }
+/** Options for {@link mockHandlers}: generation options plus the endpoints to leave out. */
+interface MockHandlersOptions<X extends string = never> extends MockOptions {
+  /** Endpoints to skip (you implement them for real); the returned bag's type omits them. */
+  readonly except?: readonly X[];
+}
+/** Options for {@link mockEvents}: generation options plus which events to emit. */
+interface MockEventsOptions<S extends AnySpec> extends MockOptions {
+  /** The events `tick`/`start` pick from. Default: every event in the spec. */
+  readonly only?: readonly EventName<S>[];
+}
+/** A generated event emitter over a server (see {@link mockEvents}). */
+interface MockEvents<S extends AnySpec> {
+  /** Emit one generated event (params and data both generated) now. */
+  emit(name: EventName<S>): void;
+  /** Emit the next event from the chosen set, in order. Does nothing for a spec with no events. */
+  tick(): void;
+  /** Call {@link MockEvents.tick | tick} every `every` ms until {@link MockEvents.stop | stop}. Restarts if already running. */
+  start(every: number): void;
+  /** Stop the timer `start` began. Safe to call when not running. */
+  stop(): void;
+}
 //#endregion
 //#region src/generate.d.ts
-
 /**
  * Generate one schema-valid fake value from a zod schema.
  *
@@ -77,22 +92,26 @@ interface MockOptions {
 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)])`.
+ * The handler bag {@link mockHandlers} returns, typed per endpoint: one handler for each
+ * endpoint name in `K`, each exactly what `implement(spec).handlers(...)` expects.
+ */
+type MockHandlerBag<S extends AnySpec, K extends EndpointName<S> = EndpointName<S>> = { readonly [P in K]: HandlerFor<S, S['endpoints'][P]> };
+/**
+ * Build the handler bag for a spec — one generated handler per endpoint (minus any
+ * named in `except`), typed per endpoint, so it drops straight into
+ * `implement(spec).handlers(bag)` and `server()`'s missing-handler check sees exactly
+ * which endpoints it covers.
  *
  * @example
  * ```ts
  * const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+ * // real handlers for some endpoints, generated data for the rest:
+ * const real = implement(api).handlers({ getUser: loadUser })
+ * const app2 = server(api, [real, implement(api).handlers(mockHandlers(api, { except: ['getUser'] }))])
  * ```
  */
-declare function mockHandlers(spec: AnySpec, opts?: MockOptions): Record<string, MockHandler>;
+declare function mockHandlers<S extends AnySpec, const X extends EndpointName<S> = never>(spec: S, opts?: MockHandlersOptions<X>): MockHandlerBag<S, Exclude<EndpointName<S>, X>>;
 /**
  * Build a real ayepi {@link Server} for a spec where every endpoint returns
  * generated, schema-valid data. Routing, input validation, output validation, and
@@ -104,6 +123,19 @@ declare function mockHandlers(spec: AnySpec, opts?: MockOptions): Record<string,
  * const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method: 'POST' }))
  * ```
  */
-declare function mockServer(spec: AnySpec, opts?: MockOptions): Server<AnySpec>;
+declare function mockServer<S extends AnySpec>(spec: S, opts?: MockOptions): Server<S>;
+//#endregion
+//#region src/events.d.ts
+/**
+ * Build a generated event emitter over `app` (any server for the spec, real or mock).
+ *
+ * @example
+ * ```ts
+ * const app = mockServer(api, { seed: 1 })
+ * const events = mockEvents(app, { seed: 1, only: ['userChanged'] })
+ * events.start(1_000) // a generated userChanged every second
+ * ```
+ */
+declare function mockEvents<S extends AnySpec>(app: Pick<Server<S>, 'spec' | 'emit'>, opts?: MockEventsOptions<S>): MockEvents<S>;
 //#endregion
-export { type GenContext, type MockOptions, type MockOverrides, type Override, generate, mockHandlers, mockServer };
+export { type EndpointName, type EventName, type GenContext, type MockEvents, type MockEventsOptions, type MockHandlerBag, type MockHandlersOptions, type MockOptions, type MockOverrides, type Override, generate, mockEvents, mockHandlers, mockServer };

package/dist/index.d.ts

@@ -1,17 +1,12 @@
-import { AnySpec, Server } from "@ayepi/core";
+import { AnySpec, EventsOf, HandlerFor, 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
- */
+/** A spec's endpoint names. */
+type EndpointName<S extends AnySpec> = keyof S['endpoints'] & string;
+/** A spec's event names. */
+type EventName<S extends AnySpec> = keyof EventsOf<S> & string;
 /**
  * Context handed to override callbacks (and threaded through the generator). It
  * exposes where in the schema we are ({@link GenContext.path | path}), the seeded
@@ -58,9 +53,29 @@ interface MockOptions {
   /** Clock used for date generation (injectable for tests). Default `Date.now`. */
   readonly now?: () => number;
 }
+/** Options for {@link mockHandlers}: generation options plus the endpoints to leave out. */
+interface MockHandlersOptions<X extends string = never> extends MockOptions {
+  /** Endpoints to skip (you implement them for real); the returned bag's type omits them. */
+  readonly except?: readonly X[];
+}
+/** Options for {@link mockEvents}: generation options plus which events to emit. */
+interface MockEventsOptions<S extends AnySpec> extends MockOptions {
+  /** The events `tick`/`start` pick from. Default: every event in the spec. */
+  readonly only?: readonly EventName<S>[];
+}
+/** A generated event emitter over a server (see {@link mockEvents}). */
+interface MockEvents<S extends AnySpec> {
+  /** Emit one generated event (params and data both generated) now. */
+  emit(name: EventName<S>): void;
+  /** Emit the next event from the chosen set, in order. Does nothing for a spec with no events. */
+  tick(): void;
+  /** Call {@link MockEvents.tick | tick} every `every` ms until {@link MockEvents.stop | stop}. Restarts if already running. */
+  start(every: number): void;
+  /** Stop the timer `start` began. Safe to call when not running. */
+  stop(): void;
+}
 //#endregion
 //#region src/generate.d.ts
-
 /**
  * Generate one schema-valid fake value from a zod schema.
  *
@@ -77,22 +92,26 @@ interface MockOptions {
 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)])`.
+ * The handler bag {@link mockHandlers} returns, typed per endpoint: one handler for each
+ * endpoint name in `K`, each exactly what `implement(spec).handlers(...)` expects.
+ */
+type MockHandlerBag<S extends AnySpec, K extends EndpointName<S> = EndpointName<S>> = { readonly [P in K]: HandlerFor<S, S['endpoints'][P]> };
+/**
+ * Build the handler bag for a spec — one generated handler per endpoint (minus any
+ * named in `except`), typed per endpoint, so it drops straight into
+ * `implement(spec).handlers(bag)` and `server()`'s missing-handler check sees exactly
+ * which endpoints it covers.
  *
  * @example
  * ```ts
  * const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+ * // real handlers for some endpoints, generated data for the rest:
+ * const real = implement(api).handlers({ getUser: loadUser })
+ * const app2 = server(api, [real, implement(api).handlers(mockHandlers(api, { except: ['getUser'] }))])
  * ```
  */
-declare function mockHandlers(spec: AnySpec, opts?: MockOptions): Record<string, MockHandler>;
+declare function mockHandlers<S extends AnySpec, const X extends EndpointName<S> = never>(spec: S, opts?: MockHandlersOptions<X>): MockHandlerBag<S, Exclude<EndpointName<S>, X>>;
 /**
  * Build a real ayepi {@link Server} for a spec where every endpoint returns
  * generated, schema-valid data. Routing, input validation, output validation, and
@@ -104,6 +123,19 @@ declare function mockHandlers(spec: AnySpec, opts?: MockOptions): Record<string,
  * const res = await app.fetch(new Request('http://x/listUsers?limit=10', { method: 'POST' }))
  * ```
  */
-declare function mockServer(spec: AnySpec, opts?: MockOptions): Server<AnySpec>;
+declare function mockServer<S extends AnySpec>(spec: S, opts?: MockOptions): Server<S>;
+//#endregion
+//#region src/events.d.ts
+/**
+ * Build a generated event emitter over `app` (any server for the spec, real or mock).
+ *
+ * @example
+ * ```ts
+ * const app = mockServer(api, { seed: 1 })
+ * const events = mockEvents(app, { seed: 1, only: ['userChanged'] })
+ * events.start(1_000) // a generated userChanged every second
+ * ```
+ */
+declare function mockEvents<S extends AnySpec>(app: Pick<Server<S>, 'spec' | 'emit'>, opts?: MockEventsOptions<S>): MockEvents<S>;
 //#endregion
-export { type GenContext, type MockOptions, type MockOverrides, type Override, generate, mockHandlers, mockServer };
+export { type EndpointName, type EventName, type GenContext, type MockEvents, type MockEventsOptions, type MockHandlerBag, type MockHandlersOptions, type MockOptions, type MockOverrides, type Override, generate, mockEvents, mockHandlers, mockServer };

package/dist/index.js

@@ -362,14 +362,17 @@ function generate(schema, opts, ctx) {
 //#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
+		query: isRecord(payload.data) ? payload.data : {}
 	};
 }
+/** Whether `value` is a plain keyed object (the merged params/query/body record a handler receives). */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /** Read an endpoint config's schemas off its erased definition. */
 function cfgOf(def) {
 	return def.cfg;
@@ -413,17 +416,23 @@ function handlerFor(name, def, opts) {
 	return () => void 0;
 }
 /**
-* Build the handler bag for a spec — one generated handler per endpoint, suitable
-* for `server(spec, [implement(spec).handlers(bag)])`.
+* Build the handler bag for a spec — one generated handler per endpoint (minus any
+* named in `except`), typed per endpoint, so it drops straight into
+* `implement(spec).handlers(bag)` and `server()`'s missing-handler check sees exactly
+* which endpoints it covers.
 *
 * @example
 * ```ts
 * const app = server(api, [implement(api).handlers(mockHandlers(api, { seed: 1 }))])
+* // real handlers for some endpoints, generated data for the rest:
+* const real = implement(api).handlers({ getUser: loadUser })
+* const app2 = server(api, [real, implement(api).handlers(mockHandlers(api, { except: ['getUser'] }))])
 * ```
 */
 function mockHandlers(spec, opts) {
+	const except = new Set(opts?.except ?? []);
 	const bag = {};
-	for (const [name, def] of Object.entries(spec.endpoints)) bag[name] = handlerFor(name, def, opts);
+	for (const [name, def] of Object.entries(spec.endpoints)) if (!except.has(name)) bag[name] = handlerFor(name, def, opts);
 	return bag;
 }
 /**
@@ -438,8 +447,62 @@ function mockHandlers(spec, opts) {
 * ```
 */
 function mockServer(spec, opts) {
-	const bag = mockHandlers(spec, opts);
-	return server(spec, [implement(spec).handlers(bag)]);
+	const erased = spec;
+	return server(erased, [implement(erased).handlers(mockHandlers(erased, opts))]);
+}
+//#endregion
+//#region src/events.ts
+/**
+* Build a generated event emitter over `app` (any server for the spec, real or mock).
+*
+* @example
+* ```ts
+* const app = mockServer(api, { seed: 1 })
+* const events = mockEvents(app, { seed: 1, only: ['userChanged'] })
+* events.start(1_000) // a generated userChanged every second
+* ```
+*/
+function mockEvents(app, opts) {
+	const gcfg = resolveConfig(opts);
+	const defs = app.spec.events ?? {};
+	const send = app.emit;
+	const names = opts?.only ?? Object.keys(defs);
+	const counts = /* @__PURE__ */ new Map();
+	let next = 0;
+	let timer;
+	const emit = (name) => {
+		const def = defs[name];
+		if (def === void 0) throw new Error(`mockEvents: the spec has no event "${name}"`);
+		const n = counts.get(name) ?? 0;
+		counts.set(name, n + 1);
+		const ctx = {
+			path: "",
+			rng: makeRng(opts, "event", name, String(n)),
+			request: void 0,
+			query: {}
+		};
+		const data = genValue(def.data, ctx, gcfg);
+		if (def.params) send(name, genValue(def.params, ctx, gcfg), data);
+		else send(name, data);
+	};
+	const stop = () => {
+		if (timer !== void 0) clearInterval(timer);
+		timer = void 0;
+	};
+	const tick = () => {
+		const name = names[next++ % Math.max(names.length, 1)];
+		if (name !== void 0) emit(name);
+	};
+	const start = (every) => {
+		stop();
+		timer = setInterval(tick, every);
+	};
+	return {
+		emit,
+		tick,
+		start,
+		stop
+	};
 }
 //#endregion
-export { generate, mockHandlers, mockServer };
+export { generate, mockEvents, mockHandlers, mockServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ayepi/mock",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Mock server for @ayepi/core — generate schema-valid fake data from a spec, with deterministic seeding and automatic pagination",
   "license": "MIT",
   "publishConfig": {
@@ -38,16 +38,16 @@
     "node": ">=18"
   },
   "peerDependencies": {
-    "zod": "^4",
-    "@ayepi/core": "^0.4.0"
+    "zod": "^4.6.7",
+    "@ayepi/core": "^0.5.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.4.0"
+    "zod": "^4.6.7",
+    "@ayepi/core": "0.5.0"
   },
   "keywords": [
     "ayepi",