@shware/workflow 0.0.0-stage → 0.0.0

package/dist/contract.cjs

@@ -0,0 +1,212 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_dsl_refs = require("./dsl/refs.cjs");
+require("./dsl/index.cjs");
+let zod_mini = require("zod/mini");
+zod_mini = require_runtime.__toESM(zod_mini, 1);
+//#region src/contract.ts
+function defineContract(definition) {
+	for (const [name, schema] of Object.entries(definition.events)) {
+		if (name.startsWith("$")) throw new TypeError(`contract event '${name}': names starting with $ are reserved`);
+		assertJsonSchema(schema, `event '${name}'`, true);
+	}
+	assertJsonSchema(definition.profile, "profile", true);
+	const profileShape = definition.profile._zod.def.shape;
+	for (const [field, schema] of Object.entries(profileShape)) assertFlatScalar(schema, `profile.${field}`);
+	const strictProfile = definition.profile._zod.def.catchall?._zod.def.type === "never";
+	const names = Object.keys(definition.events);
+	return {
+		kind: "journey-contract",
+		events: require_dsl_refs.event(),
+		user: require_dsl_refs.user(),
+		schemas: {
+			events: definition.events,
+			profile: definition.profile
+		},
+		eventNames: names,
+		isEvent: (name) => Object.hasOwn(definition.events, name),
+		parseEvent(name, payload) {
+			if (!Object.hasOwn(definition.events, name)) return {
+				ok: false,
+				issues: [{
+					path: "",
+					message: `unknown event '${name}'`
+				}]
+			};
+			return toResult(zod_mini.safeParse(definition.events[name], payload));
+		},
+		parseProfilePatch(patch) {
+			if (typeof patch !== "object" || patch === null || Array.isArray(patch)) return {
+				ok: false,
+				issues: [{
+					path: "",
+					message: "props must be an object"
+				}]
+			};
+			const issues = [];
+			const data = {};
+			for (const [field, value] of Object.entries(patch)) {
+				if (!Object.hasOwn(profileShape, field)) {
+					if (strictProfile || field === "userId") issues.push({
+						path: field,
+						message: "not a declared profile field"
+					});
+					else data[field] = value;
+					continue;
+				}
+				if (value === null) {
+					data[field] = null;
+					continue;
+				}
+				const result = zod_mini.safeParse(profileShape[field], value);
+				if (result.success) data[field] = result.data;
+				else issues.push(...prefixed(field, result.error));
+			}
+			return issues.length > 0 ? {
+				ok: false,
+				issues
+			} : {
+				ok: true,
+				data
+			};
+		}
+	};
+}
+/**
+* An event the contract refuses — raised for events a journey emits itself
+* (`.sendEvent()`), which never pass the HTTP ingest: they go through the same
+* check, and a refusal is deterministic, so it is not retried.
+*/
+var ContractValidationError = class extends Error {
+	event;
+	issues;
+	name = "ContractValidationError";
+	constructor(event, issues) {
+		super(`event '${event}' refused by the contract: ${issues.map((i) => `${i.path || "(root)"} ${i.message}`).join("; ")}`);
+		this.event = event;
+		this.issues = issues;
+	}
+};
+/** The one check every event passes, from HTTP or from a journey: declared, and its payload parses. */
+function checkEvent(contract, name, payload) {
+	if (!contract.isEvent(name)) return {
+		ok: false,
+		issues: [{
+			path: "",
+			message: `'${String(name)}' is not in the contract`
+		}]
+	};
+	return contract.parseEvent(name, payload);
+}
+function isContract(value) {
+	return typeof value === "object" && value !== null && value.kind === "journey-contract";
+}
+function toResult(result) {
+	return result.success ? {
+		ok: true,
+		data: result.data
+	} : {
+		ok: false,
+		issues: prefixed("", result.error)
+	};
+}
+function prefixed(prefix, error) {
+	return error.issues.map((issue) => ({
+		path: [prefix, ...issue.path.map(String)].filter((p) => p !== "").join("."),
+		message: issue.message
+	}));
+}
+/**
+* The schema types a contract may use — JSON shapes that parse synchronously
+* and mean the same before and after parsing. Anything not listed (default,
+* transform, pipe, lazy, promise, custom, date, bigint, …) is refused, and
+* every container is walked so nothing unsupported hides inside one.
+*/
+const ALLOWED = /* @__PURE__ */ new Set([
+	"object",
+	"array",
+	"tuple",
+	"union",
+	"intersection",
+	"record",
+	"optional",
+	"nullable",
+	"readonly",
+	"nonoptional",
+	"string",
+	"number",
+	"boolean",
+	"null",
+	"enum",
+	"literal",
+	"unknown",
+	"any",
+	"never"
+]);
+/** Checks that change the value (`overwrite`: `.trim()`, `.toLowerCase()`, …) or run arbitrary code (`custom`: `.refine()`, async or not). */
+const REFUSED_CHECKS = /* @__PURE__ */ new Set(["custom", "overwrite"]);
+function assertJsonSchema(schema, where, top = false) {
+	const def = schema?._zod?.def;
+	if (def === void 0) throw new TypeError(`contract ${where}: not a Zod schema`);
+	if (top && def.type !== "object") throw new TypeError(`contract ${where}: must be an object schema (z.looseObject / z.strictObject)`);
+	if (!ALLOWED.has(def.type)) throw new TypeError(`contract ${where}: ${def.type} schemas are not supported (input and output must mean the same JSON, parsed synchronously)`);
+	if (def.coerce === true) throw new TypeError(`contract ${where}: coercion (z.coerce) is not supported`);
+	for (const check of def.checks ?? []) if (REFUSED_CHECKS.has(check._zod.def.check)) throw new TypeError(`contract ${where}: ${check._zod.def.check === "overwrite" ? "value-changing checks (.overwrite, .trim, …)" : "custom refinements"} are not supported`);
+	const children = [];
+	switch (def.type) {
+		case "object": {
+			const object = def;
+			for (const [k, v] of Object.entries(object.shape)) children.push([`${where}.${k}`, v]);
+			if (object.catchall !== void 0) children.push([`${where}.*`, object.catchall]);
+			break;
+		}
+		case "optional":
+		case "nullable":
+		case "readonly":
+		case "nonoptional":
+			children.push([where, def.innerType]);
+			break;
+		case "array":
+			children.push([`${where}[]`, def.element]);
+			break;
+		case "tuple": {
+			const tuple = def;
+			tuple.items.forEach((item, index) => children.push([`${where}[${index}]`, item]));
+			if (tuple.rest !== null) children.push([`${where}[…]`, tuple.rest]);
+			break;
+		}
+		case "union":
+			for (const option of def.options) children.push([where, option]);
+			break;
+		case "intersection": {
+			const intersection = def;
+			children.push([where, intersection.left], [where, intersection.right]);
+			break;
+		}
+		case "record": {
+			const record = def;
+			children.push([`${where}{key}`, record.keyType], [`${where}{}`, record.valueType]);
+			break;
+		}
+	}
+	for (const [path, child] of children) assertJsonSchema(child, path);
+}
+const SCALARS = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"boolean",
+	"enum",
+	"literal"
+]);
+function assertFlatScalar(schema, where) {
+	let def = schema._zod.def;
+	if (def.type === "optional") def = def.innerType._zod.def;
+	if (!SCALARS.has(def.type)) throw new TypeError(`contract ${where}: profile fields must be flat scalars (string, number, boolean, enum, literal), got ${def.type}`);
+}
+//#endregion
+exports.ContractValidationError = ContractValidationError;
+exports.checkEvent = checkEvent;
+exports.defineContract = defineContract;
+exports.isContract = isContract;
+
+//# sourceMappingURL=contract.cjs.map

package/dist/contract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.cjs","names":["event","user","z"],"sources":["../src/contract.ts"],"sourcesContent":["import * as z from 'zod/mini';\nimport type * as core from 'zod/v4/core';\nimport { type EventRefs, type UserRefs, event, user } from './dsl';\n\n/**\n * `defineContract({ events, profile })` — the producer/engine contract as Zod\n * schemas, written once in a package both sides import. From it:\n *\n * - `contract.events` / `contract.user` are the DSL's typed reference tables\n *   (what `event<E>()` / `user<U>()` used to be, now derived from the schemas);\n * - `JourneyClient({ contract })` types `track` / `identify` by event name and\n *   checks payloads before sending;\n * - `journeyWorker({ contract })` re-validates every inbound `/events` and\n *   `/identify` — never trusting the caller used the SDK — and refuses a bad\n *   one with a 4xx before anything is stored, woken or started.\n *\n * Supported schemas (v1), synchronous and JSON-shaped: event payloads are\n * object schemas (`z.looseObject` keeps a producer's extra analytics fields,\n * `z.strictObject` refuses them) and may nest objects and arrays; the profile\n * is a flat object of string / number / boolean / enum / literal fields. Input\n * and output must mean the same thing, so defaults, transforms, coercion,\n * custom refinements and async checks are refused when the contract is\n * defined. The Zod instances stay in the host; nothing here changes the IR.\n */\n\ntype ObjectSchema = core.$ZodObject;\n\n/** The declared fields of an object schema — without a loose object's `[key: string]: unknown`, so the DSL only offers fields that were written down. */\nexport type DeclaredOutput<S> =\n  S extends core.$ZodObject<infer Shape>\n    ? core.$InferObjectOutput<Shape, Record<never, never>>\n    : never;\n\nexport interface ContractDefinition<\n  E extends Record<string, ObjectSchema>,\n  P extends ObjectSchema,\n> {\n  events: E;\n  profile: P;\n}\n\n/** One rejected field, with the dotted path the producer can fix. */\nexport interface ContractIssue {\n  path: string;\n  message: string;\n}\n\nexport type ContractResult<T> = { ok: true; data: T } | { ok: false; issues: ContractIssue[] };\n\nexport interface Contract<\n  E extends Record<string, ObjectSchema> = Record<string, ObjectSchema>,\n  P extends ObjectSchema = ObjectSchema,\n> {\n  readonly kind: 'journey-contract';\n  /** The DSL's event reference table: `e.purchase` — payload refs from the declared fields only. */\n  readonly events: EventRefs<{ [K in keyof E]: DeclaredOutput<E[K]> }>;\n  /** The DSL's user-property reference table: `u.name`, plus the system `u.userId`. */\n  readonly user: UserRefs<DeclaredOutput<P> & { userId: string }>;\n  /** The raw schemas, for hosts that need them (validation, docs). */\n  readonly schemas: { readonly events: E; readonly profile: P };\n  /** Every event name the contract declares — what a producer forwards. */\n  readonly eventNames: readonly (keyof E & string)[];\n  isEvent(name: string): name is keyof E & string;\n  /** Validate one event's payload; the parsed value is what may be stored. */\n  parseEvent<K extends keyof E & string>(\n    name: K,\n    payload: unknown\n  ): ContractResult<core.output<E[K]>>;\n  /**\n   * Validate an `/identify` merge patch: omitted fields stay as they are,\n   * `null` removes a field, every provided value is checked against its field\n   * schema, and an undeclared field is refused — a patch, never a full parse\n   * that would fill defaults over fields the caller did not send.\n   */\n  parseProfilePatch(patch: unknown): ContractResult<ProfilePatch<P>>;\n}\n\n/** An `/identify` patch over the profile: any subset of fields, `null` to remove one. */\nexport type ProfilePatch<P> = { [K in keyof DeclaredOutput<P>]?: DeclaredOutput<P>[K] | null };\n\n/** Payload type of one event, for producers: `EventPayload<typeof contract, 'purchase'>`. */\nexport type EventPayload<C, K extends string> =\n  C extends Contract<infer E> ? (K extends keyof E ? core.input<E[K]> : never) : never;\n\nexport function defineContract<E extends Record<string, ObjectSchema>, P extends ObjectSchema>(\n  definition: ContractDefinition<E, P>\n): Contract<E, P> {\n  for (const [name, schema] of Object.entries(definition.events)) {\n    if (name.startsWith('$')) {\n      throw new TypeError(`contract event '${name}': names starting with $ are reserved`);\n    }\n    assertJsonSchema(schema, `event '${name}'`, true);\n  }\n  assertJsonSchema(definition.profile, 'profile', true);\n  const profileShape = (definition.profile._zod.def as core.$ZodObjectDef).shape;\n  for (const [field, schema] of Object.entries(profileShape)) {\n    assertFlatScalar(schema, `profile.${field}`);\n  }\n  const strictProfile = definition.profile._zod.def.catchall?._zod.def.type === 'never';\n\n  const names = Object.keys(definition.events) as (keyof E & string)[];\n  return {\n    kind: 'journey-contract',\n    events: event() as never,\n    user: user() as never,\n    schemas: { events: definition.events, profile: definition.profile },\n    eventNames: names,\n    isEvent: (name): name is keyof E & string => Object.hasOwn(definition.events, name),\n    parseEvent(name, payload) {\n      if (!Object.hasOwn(definition.events, name)) {\n        return { ok: false, issues: [{ path: '', message: `unknown event '${name}'` }] };\n      }\n      return toResult(z.safeParse(definition.events[name], payload));\n    },\n    parseProfilePatch(patch) {\n      if (typeof patch !== 'object' || patch === null || Array.isArray(patch)) {\n        return { ok: false, issues: [{ path: '', message: 'props must be an object' }] };\n      }\n      const issues: ContractIssue[] = [];\n      const data: Record<string, unknown> = {};\n      for (const [field, value] of Object.entries(patch)) {\n        if (!Object.hasOwn(profileShape, field)) {\n          // userId is the request's identity, not a profile field\n          if (strictProfile || field === 'userId') {\n            issues.push({ path: field, message: 'not a declared profile field' });\n          } else {\n            data[field] = value;\n          }\n          continue;\n        }\n        if (value === null) {\n          data[field] = null;\n          continue;\n        }\n        const result = z.safeParse(profileShape[field], value);\n        if (result.success) data[field] = result.data;\n        else issues.push(...prefixed(field, result.error));\n      }\n      return issues.length > 0 ? { ok: false, issues } : { ok: true, data: data as never };\n    },\n  };\n}\n\n/**\n * An event the contract refuses — raised for events a journey emits itself\n * (`.sendEvent()`), which never pass the HTTP ingest: they go through the same\n * check, and a refusal is deterministic, so it is not retried.\n */\nexport class ContractValidationError extends Error {\n  override readonly name = 'ContractValidationError';\n  constructor(\n    readonly event: string,\n    readonly issues: ContractIssue[]\n  ) {\n    super(\n      `event '${event}' refused by the contract: ${issues\n        .map((i) => `${i.path || '(root)'} ${i.message}`)\n        .join('; ')}`\n    );\n  }\n}\n\n/** The one check every event passes, from HTTP or from a journey: declared, and its payload parses. */\nexport function checkEvent(\n  contract: Contract,\n  name: string,\n  payload: unknown\n): ContractResult<Record<string, unknown>> {\n  if (!contract.isEvent(name)) {\n    return {\n      ok: false,\n      issues: [{ path: '', message: `'${String(name)}' is not in the contract` }],\n    };\n  }\n  return contract.parseEvent(name, payload);\n}\n\nexport function isContract(value: unknown): value is Contract {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'journey-contract'\n  );\n}\n\nfunction toResult<T>(result: core.util.SafeParseResult<T>): ContractResult<T> {\n  return result.success\n    ? { ok: true, data: result.data }\n    : { ok: false, issues: prefixed('', result.error) };\n}\n\nfunction prefixed(prefix: string, error: core.$ZodError): ContractIssue[] {\n  return error.issues.map((issue) => ({\n    path: [prefix, ...issue.path.map(String)].filter((p) => p !== '').join('.'),\n    message: issue.message,\n  }));\n}\n\n/* ---------------------------- supported schemas ---------------------------- */\n\n/**\n * The schema types a contract may use — JSON shapes that parse synchronously\n * and mean the same before and after parsing. Anything not listed (default,\n * transform, pipe, lazy, promise, custom, date, bigint, …) is refused, and\n * every container is walked so nothing unsupported hides inside one.\n */\nconst ALLOWED = new Set([\n  'object',\n  'array',\n  'tuple',\n  'union',\n  'intersection',\n  'record',\n  'optional',\n  'nullable',\n  'readonly',\n  'nonoptional',\n  'string',\n  'number',\n  'boolean',\n  'null',\n  'enum',\n  'literal',\n  'unknown',\n  'any',\n  'never',\n]);\n\n/** Checks that change the value (`overwrite`: `.trim()`, `.toLowerCase()`, …) or run arbitrary code (`custom`: `.refine()`, async or not). */\nconst REFUSED_CHECKS = new Set(['custom', 'overwrite']);\n\nfunction assertJsonSchema(schema: unknown, where: string, top = false): void {\n  const def = (schema as core.$ZodType | undefined)?._zod?.def;\n  if (def === undefined) throw new TypeError(`contract ${where}: not a Zod schema`);\n  if (top && def.type !== 'object') {\n    throw new TypeError(\n      `contract ${where}: must be an object schema (z.looseObject / z.strictObject)`\n    );\n  }\n  if (!ALLOWED.has(def.type)) {\n    throw new TypeError(\n      `contract ${where}: ${def.type} schemas are not supported (input and output must mean the same JSON, parsed synchronously)`\n    );\n  }\n  if ((def as { coerce?: boolean }).coerce === true) {\n    throw new TypeError(`contract ${where}: coercion (z.coerce) is not supported`);\n  }\n  for (const check of def.checks ?? []) {\n    if (REFUSED_CHECKS.has(check._zod.def.check)) {\n      throw new TypeError(\n        `contract ${where}: ${check._zod.def.check === 'overwrite' ? 'value-changing checks (.overwrite, .trim, …)' : 'custom refinements'} are not supported`\n      );\n    }\n  }\n  const children: [string, unknown][] = [];\n  switch (def.type) {\n    case 'object': {\n      const object = def as core.$ZodObjectDef;\n      for (const [k, v] of Object.entries(object.shape)) children.push([`${where}.${k}`, v]);\n      if (object.catchall !== undefined) children.push([`${where}.*`, object.catchall]);\n      break;\n    }\n    case 'optional':\n    case 'nullable':\n    case 'readonly':\n    case 'nonoptional':\n      children.push([where, (def as unknown as { innerType: unknown }).innerType]);\n      break;\n    case 'array':\n      children.push([`${where}[]`, (def as core.$ZodArrayDef).element]);\n      break;\n    case 'tuple': {\n      const tuple = def as core.$ZodTupleDef;\n      tuple.items.forEach((item, index) => children.push([`${where}[${index}]`, item]));\n      if (tuple.rest !== null) children.push([`${where}[…]`, tuple.rest]);\n      break;\n    }\n    case 'union':\n      for (const option of (def as core.$ZodUnionDef).options) children.push([where, option]);\n      break;\n    case 'intersection': {\n      const intersection = def as core.$ZodIntersectionDef;\n      children.push([where, intersection.left], [where, intersection.right]);\n      break;\n    }\n    case 'record': {\n      const record = def as core.$ZodRecordDef;\n      children.push([`${where}{key}`, record.keyType], [`${where}{}`, record.valueType]);\n      break;\n    }\n    default:\n      break;\n  }\n  for (const [path, child] of children) assertJsonSchema(child, path);\n}\n\nconst SCALARS = new Set(['string', 'number', 'boolean', 'enum', 'literal']);\n\nfunction assertFlatScalar(schema: unknown, where: string): void {\n  let def = (schema as core.$ZodType)._zod.def;\n  if (def.type === 'optional') def = (def as core.$ZodOptionalDef).innerType._zod.def;\n  if (!SCALARS.has(def.type)) {\n    throw new TypeError(\n      `contract ${where}: profile fields must be flat scalars (string, number, boolean, enum, literal), got ${def.type}`\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/contract.d.cts

@@ -0,0 +1,90 @@
+import { EventRefs, UserRefs } from "./dsl/refs.cjs";
+import "./dsl/index.cjs";
+import * as core from "zod/v4/core";
+//#region src/contract.d.ts
+/**
+ * `defineContract({ events, profile })` — the producer/engine contract as Zod
+ * schemas, written once in a package both sides import. From it:
+ *
+ * - `contract.events` / `contract.user` are the DSL's typed reference tables
+ *   (what `event<E>()` / `user<U>()` used to be, now derived from the schemas);
+ * - `JourneyClient({ contract })` types `track` / `identify` by event name and
+ *   checks payloads before sending;
+ * - `journeyWorker({ contract })` re-validates every inbound `/events` and
+ *   `/identify` — never trusting the caller used the SDK — and refuses a bad
+ *   one with a 4xx before anything is stored, woken or started.
+ *
+ * Supported schemas (v1), synchronous and JSON-shaped: event payloads are
+ * object schemas (`z.looseObject` keeps a producer's extra analytics fields,
+ * `z.strictObject` refuses them) and may nest objects and arrays; the profile
+ * is a flat object of string / number / boolean / enum / literal fields. Input
+ * and output must mean the same thing, so defaults, transforms, coercion,
+ * custom refinements and async checks are refused when the contract is
+ * defined. The Zod instances stay in the host; nothing here changes the IR.
+ */
+type ObjectSchema = core.$ZodObject;
+/** The declared fields of an object schema — without a loose object's `[key: string]: unknown`, so the DSL only offers fields that were written down. */
+export type DeclaredOutput<S> = S extends core.$ZodObject<infer Shape> ? core.$InferObjectOutput<Shape, Record<never, never>> : never;
+export interface ContractDefinition<E extends Record<string, ObjectSchema>, P extends ObjectSchema> {
+  events: E;
+  profile: P;
+}
+/** One rejected field, with the dotted path the producer can fix. */
+export interface ContractIssue {
+  path: string;
+  message: string;
+}
+export type ContractResult<T> = {
+  ok: true;
+  data: T;
+} | {
+  ok: false;
+  issues: ContractIssue[];
+};
+export interface Contract<E extends Record<string, ObjectSchema> = Record<string, ObjectSchema>, P extends ObjectSchema = ObjectSchema> {
+  readonly kind: 'journey-contract';
+  /** The DSL's event reference table: `e.purchase` — payload refs from the declared fields only. */
+  readonly events: EventRefs<{ [K in keyof E]: DeclaredOutput<E[K]>; }>;
+  /** The DSL's user-property reference table: `u.name`, plus the system `u.userId`. */
+  readonly user: UserRefs<DeclaredOutput<P> & {
+    userId: string;
+  }>;
+  /** The raw schemas, for hosts that need them (validation, docs). */
+  readonly schemas: {
+    readonly events: E;
+    readonly profile: P;
+  };
+  /** Every event name the contract declares — what a producer forwards. */
+  readonly eventNames: readonly (keyof E & string)[];
+  isEvent(name: string): name is keyof E & string;
+  /** Validate one event's payload; the parsed value is what may be stored. */
+  parseEvent<K extends keyof E & string>(name: K, payload: unknown): ContractResult<core.output<E[K]>>;
+  /**
+   * Validate an `/identify` merge patch: omitted fields stay as they are,
+   * `null` removes a field, every provided value is checked against its field
+   * schema, and an undeclared field is refused — a patch, never a full parse
+   * that would fill defaults over fields the caller did not send.
+   */
+  parseProfilePatch(patch: unknown): ContractResult<ProfilePatch<P>>;
+}
+/** An `/identify` patch over the profile: any subset of fields, `null` to remove one. */
+export type ProfilePatch<P> = { [K in keyof DeclaredOutput<P>]?: DeclaredOutput<P>[K] | null; };
+/** Payload type of one event, for producers: `EventPayload<typeof contract, 'purchase'>`. */
+export type EventPayload<C, K extends string> = C extends Contract<infer E> ? (K extends keyof E ? core.input<E[K]> : never) : never;
+export declare function defineContract<E extends Record<string, ObjectSchema>, P extends ObjectSchema>(definition: ContractDefinition<E, P>): Contract<E, P>;
+/**
+ * An event the contract refuses — raised for events a journey emits itself
+ * (`.sendEvent()`), which never pass the HTTP ingest: they go through the same
+ * check, and a refusal is deterministic, so it is not retried.
+ */
+export declare class ContractValidationError extends Error {
+  readonly event: string;
+  readonly issues: ContractIssue[];
+  readonly name = "ContractValidationError";
+  constructor(event: string, issues: ContractIssue[]);
+}
+/** The one check every event passes, from HTTP or from a journey: declared, and its payload parses. */
+export declare function checkEvent(contract: Contract, name: string, payload: unknown): ContractResult<Record<string, unknown>>;
+export declare function isContract(value: unknown): value is Contract;
+//#endregion
+//# sourceMappingURL=contract.d.cts.map

package/dist/contract.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.cts","names":[],"sources":["../src/contract.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;KAyBK,eAAe,KAAK;;YAGb,eAAe,KACzB,UAAU,KAAK,iBAAiB,SAC5B,KAAK,mBAAmB,OAAO;iBAGpB,mBACf,UAAU,eAAe,eACzB,UAAU;EAEV,QAAQ;EACR,SAAS;;;iBAIM;EACf;EACA;;YAGU,eAAe;EAAO;EAAU,MAAM;;EAAQ;EAAW,QAAQ;;iBAE5D,SACf,UAAU,eAAe,gBAAgB,eAAe,eACxD,UAAU,eAAe;WAEhB;;WAEA,QAAQ,aAAa,WAAW,IAAI,eAAe,EAAE;;WAErD,MAAM,SAAS,eAAe;IAAO;;;WAErC;aAAoB,QAAQ;aAAY,SAAS;;;WAEjD,4BAA4B;EACrC,QAAQ,eAAe,cAAc;;EAErC,WAAW,gBAAgB,YACzB,MAAM,GACN,mBACC,eAAe,KAAK,OAAO,EAAE;;;;;;;EAOhC,kBAAkB,iBAAiB,eAAe,aAAa;;;YAIrD,aAAa,QAAQ,WAAW,eAAe,MAAM,eAAe,GAAG;;YAGvE,aAAa,GAAG,oBAC1B,UAAU,eAAe,MAAM,gBAAgB,IAAI,KAAK,MAAM,EAAE;wBAElD,eAAe,UAAU,eAAe,eAAe,UAAU,cAC/E,YAAY,mBAAmB,GAAG,KACjC,SAAS,GAAG;;;;;;qBA8DF,gCAAgC;WAGhC;WACA,QAAQ;WAHD;EAClB,YACW,eACA,QAAQ;;;wBAWL,WACd,UAAU,UACV,cACA,mBACC,eAAe;wBAUF,WAAW,iBAAiB,SAAS"}

package/dist/contract.d.mts

@@ -0,0 +1,90 @@
+import { EventRefs, UserRefs } from "./dsl/refs.mjs";
+import "./dsl/index.mjs";
+import * as core from "zod/v4/core";
+//#region src/contract.d.ts
+/**
+ * `defineContract({ events, profile })` — the producer/engine contract as Zod
+ * schemas, written once in a package both sides import. From it:
+ *
+ * - `contract.events` / `contract.user` are the DSL's typed reference tables
+ *   (what `event<E>()` / `user<U>()` used to be, now derived from the schemas);
+ * - `JourneyClient({ contract })` types `track` / `identify` by event name and
+ *   checks payloads before sending;
+ * - `journeyWorker({ contract })` re-validates every inbound `/events` and
+ *   `/identify` — never trusting the caller used the SDK — and refuses a bad
+ *   one with a 4xx before anything is stored, woken or started.
+ *
+ * Supported schemas (v1), synchronous and JSON-shaped: event payloads are
+ * object schemas (`z.looseObject` keeps a producer's extra analytics fields,
+ * `z.strictObject` refuses them) and may nest objects and arrays; the profile
+ * is a flat object of string / number / boolean / enum / literal fields. Input
+ * and output must mean the same thing, so defaults, transforms, coercion,
+ * custom refinements and async checks are refused when the contract is
+ * defined. The Zod instances stay in the host; nothing here changes the IR.
+ */
+type ObjectSchema = core.$ZodObject;
+/** The declared fields of an object schema — without a loose object's `[key: string]: unknown`, so the DSL only offers fields that were written down. */
+export type DeclaredOutput<S> = S extends core.$ZodObject<infer Shape> ? core.$InferObjectOutput<Shape, Record<never, never>> : never;
+export interface ContractDefinition<E extends Record<string, ObjectSchema>, P extends ObjectSchema> {
+  events: E;
+  profile: P;
+}
+/** One rejected field, with the dotted path the producer can fix. */
+export interface ContractIssue {
+  path: string;
+  message: string;
+}
+export type ContractResult<T> = {
+  ok: true;
+  data: T;
+} | {
+  ok: false;
+  issues: ContractIssue[];
+};
+export interface Contract<E extends Record<string, ObjectSchema> = Record<string, ObjectSchema>, P extends ObjectSchema = ObjectSchema> {
+  readonly kind: 'journey-contract';
+  /** The DSL's event reference table: `e.purchase` — payload refs from the declared fields only. */
+  readonly events: EventRefs<{ [K in keyof E]: DeclaredOutput<E[K]>; }>;
+  /** The DSL's user-property reference table: `u.name`, plus the system `u.userId`. */
+  readonly user: UserRefs<DeclaredOutput<P> & {
+    userId: string;
+  }>;
+  /** The raw schemas, for hosts that need them (validation, docs). */
+  readonly schemas: {
+    readonly events: E;
+    readonly profile: P;
+  };
+  /** Every event name the contract declares — what a producer forwards. */
+  readonly eventNames: readonly (keyof E & string)[];
+  isEvent(name: string): name is keyof E & string;
+  /** Validate one event's payload; the parsed value is what may be stored. */
+  parseEvent<K extends keyof E & string>(name: K, payload: unknown): ContractResult<core.output<E[K]>>;
+  /**
+   * Validate an `/identify` merge patch: omitted fields stay as they are,
+   * `null` removes a field, every provided value is checked against its field
+   * schema, and an undeclared field is refused — a patch, never a full parse
+   * that would fill defaults over fields the caller did not send.
+   */
+  parseProfilePatch(patch: unknown): ContractResult<ProfilePatch<P>>;
+}
+/** An `/identify` patch over the profile: any subset of fields, `null` to remove one. */
+export type ProfilePatch<P> = { [K in keyof DeclaredOutput<P>]?: DeclaredOutput<P>[K] | null; };
+/** Payload type of one event, for producers: `EventPayload<typeof contract, 'purchase'>`. */
+export type EventPayload<C, K extends string> = C extends Contract<infer E> ? (K extends keyof E ? core.input<E[K]> : never) : never;
+export declare function defineContract<E extends Record<string, ObjectSchema>, P extends ObjectSchema>(definition: ContractDefinition<E, P>): Contract<E, P>;
+/**
+ * An event the contract refuses — raised for events a journey emits itself
+ * (`.sendEvent()`), which never pass the HTTP ingest: they go through the same
+ * check, and a refusal is deterministic, so it is not retried.
+ */
+export declare class ContractValidationError extends Error {
+  readonly event: string;
+  readonly issues: ContractIssue[];
+  readonly name = "ContractValidationError";
+  constructor(event: string, issues: ContractIssue[]);
+}
+/** The one check every event passes, from HTTP or from a journey: declared, and its payload parses. */
+export declare function checkEvent(contract: Contract, name: string, payload: unknown): ContractResult<Record<string, unknown>>;
+export declare function isContract(value: unknown): value is Contract;
+//#endregion
+//# sourceMappingURL=contract.d.mts.map

package/dist/contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.mts","names":[],"sources":["../src/contract.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;KAyBK,eAAe,KAAK;;YAGb,eAAe,KACzB,UAAU,KAAK,iBAAiB,SAC5B,KAAK,mBAAmB,OAAO;iBAGpB,mBACf,UAAU,eAAe,eACzB,UAAU;EAEV,QAAQ;EACR,SAAS;;;iBAIM;EACf;EACA;;YAGU,eAAe;EAAO;EAAU,MAAM;;EAAQ;EAAW,QAAQ;;iBAE5D,SACf,UAAU,eAAe,gBAAgB,eAAe,eACxD,UAAU,eAAe;WAEhB;;WAEA,QAAQ,aAAa,WAAW,IAAI,eAAe,EAAE;;WAErD,MAAM,SAAS,eAAe;IAAO;;;WAErC;aAAoB,QAAQ;aAAY,SAAS;;;WAEjD,4BAA4B;EACrC,QAAQ,eAAe,cAAc;;EAErC,WAAW,gBAAgB,YACzB,MAAM,GACN,mBACC,eAAe,KAAK,OAAO,EAAE;;;;;;;EAOhC,kBAAkB,iBAAiB,eAAe,aAAa;;;YAIrD,aAAa,QAAQ,WAAW,eAAe,MAAM,eAAe,GAAG;;YAGvE,aAAa,GAAG,oBAC1B,UAAU,eAAe,MAAM,gBAAgB,IAAI,KAAK,MAAM,EAAE;wBAElD,eAAe,UAAU,eAAe,eAAe,UAAU,cAC/E,YAAY,mBAAmB,GAAG,KACjC,SAAS,GAAG;;;;;;qBA8DF,gCAAgC;WAGhC;WACA,QAAQ;WAHD;EAClB,YACW,eACA,QAAQ;;;wBAWL,WACd,UAAU,UACV,cACA,mBACC,eAAe;wBAUF,WAAW,iBAAiB,SAAS"}

package/dist/contract.mjs

@@ -0,0 +1,206 @@
+import { event, user } from "./dsl/refs.mjs";
+import "./dsl/index.mjs";
+import * as z from "zod/mini";
+//#region src/contract.ts
+function defineContract(definition) {
+	for (const [name, schema] of Object.entries(definition.events)) {
+		if (name.startsWith("$")) throw new TypeError(`contract event '${name}': names starting with $ are reserved`);
+		assertJsonSchema(schema, `event '${name}'`, true);
+	}
+	assertJsonSchema(definition.profile, "profile", true);
+	const profileShape = definition.profile._zod.def.shape;
+	for (const [field, schema] of Object.entries(profileShape)) assertFlatScalar(schema, `profile.${field}`);
+	const strictProfile = definition.profile._zod.def.catchall?._zod.def.type === "never";
+	const names = Object.keys(definition.events);
+	return {
+		kind: "journey-contract",
+		events: event(),
+		user: user(),
+		schemas: {
+			events: definition.events,
+			profile: definition.profile
+		},
+		eventNames: names,
+		isEvent: (name) => Object.hasOwn(definition.events, name),
+		parseEvent(name, payload) {
+			if (!Object.hasOwn(definition.events, name)) return {
+				ok: false,
+				issues: [{
+					path: "",
+					message: `unknown event '${name}'`
+				}]
+			};
+			return toResult(z.safeParse(definition.events[name], payload));
+		},
+		parseProfilePatch(patch) {
+			if (typeof patch !== "object" || patch === null || Array.isArray(patch)) return {
+				ok: false,
+				issues: [{
+					path: "",
+					message: "props must be an object"
+				}]
+			};
+			const issues = [];
+			const data = {};
+			for (const [field, value] of Object.entries(patch)) {
+				if (!Object.hasOwn(profileShape, field)) {
+					if (strictProfile || field === "userId") issues.push({
+						path: field,
+						message: "not a declared profile field"
+					});
+					else data[field] = value;
+					continue;
+				}
+				if (value === null) {
+					data[field] = null;
+					continue;
+				}
+				const result = z.safeParse(profileShape[field], value);
+				if (result.success) data[field] = result.data;
+				else issues.push(...prefixed(field, result.error));
+			}
+			return issues.length > 0 ? {
+				ok: false,
+				issues
+			} : {
+				ok: true,
+				data
+			};
+		}
+	};
+}
+/**
+* An event the contract refuses — raised for events a journey emits itself
+* (`.sendEvent()`), which never pass the HTTP ingest: they go through the same
+* check, and a refusal is deterministic, so it is not retried.
+*/
+var ContractValidationError = class extends Error {
+	event;
+	issues;
+	name = "ContractValidationError";
+	constructor(event, issues) {
+		super(`event '${event}' refused by the contract: ${issues.map((i) => `${i.path || "(root)"} ${i.message}`).join("; ")}`);
+		this.event = event;
+		this.issues = issues;
+	}
+};
+/** The one check every event passes, from HTTP or from a journey: declared, and its payload parses. */
+function checkEvent(contract, name, payload) {
+	if (!contract.isEvent(name)) return {
+		ok: false,
+		issues: [{
+			path: "",
+			message: `'${String(name)}' is not in the contract`
+		}]
+	};
+	return contract.parseEvent(name, payload);
+}
+function isContract(value) {
+	return typeof value === "object" && value !== null && value.kind === "journey-contract";
+}
+function toResult(result) {
+	return result.success ? {
+		ok: true,
+		data: result.data
+	} : {
+		ok: false,
+		issues: prefixed("", result.error)
+	};
+}
+function prefixed(prefix, error) {
+	return error.issues.map((issue) => ({
+		path: [prefix, ...issue.path.map(String)].filter((p) => p !== "").join("."),
+		message: issue.message
+	}));
+}
+/**
+* The schema types a contract may use — JSON shapes that parse synchronously
+* and mean the same before and after parsing. Anything not listed (default,
+* transform, pipe, lazy, promise, custom, date, bigint, …) is refused, and
+* every container is walked so nothing unsupported hides inside one.
+*/
+const ALLOWED = /* @__PURE__ */ new Set([
+	"object",
+	"array",
+	"tuple",
+	"union",
+	"intersection",
+	"record",
+	"optional",
+	"nullable",
+	"readonly",
+	"nonoptional",
+	"string",
+	"number",
+	"boolean",
+	"null",
+	"enum",
+	"literal",
+	"unknown",
+	"any",
+	"never"
+]);
+/** Checks that change the value (`overwrite`: `.trim()`, `.toLowerCase()`, …) or run arbitrary code (`custom`: `.refine()`, async or not). */
+const REFUSED_CHECKS = /* @__PURE__ */ new Set(["custom", "overwrite"]);
+function assertJsonSchema(schema, where, top = false) {
+	const def = schema?._zod?.def;
+	if (def === void 0) throw new TypeError(`contract ${where}: not a Zod schema`);
+	if (top && def.type !== "object") throw new TypeError(`contract ${where}: must be an object schema (z.looseObject / z.strictObject)`);
+	if (!ALLOWED.has(def.type)) throw new TypeError(`contract ${where}: ${def.type} schemas are not supported (input and output must mean the same JSON, parsed synchronously)`);
+	if (def.coerce === true) throw new TypeError(`contract ${where}: coercion (z.coerce) is not supported`);
+	for (const check of def.checks ?? []) if (REFUSED_CHECKS.has(check._zod.def.check)) throw new TypeError(`contract ${where}: ${check._zod.def.check === "overwrite" ? "value-changing checks (.overwrite, .trim, …)" : "custom refinements"} are not supported`);
+	const children = [];
+	switch (def.type) {
+		case "object": {
+			const object = def;
+			for (const [k, v] of Object.entries(object.shape)) children.push([`${where}.${k}`, v]);
+			if (object.catchall !== void 0) children.push([`${where}.*`, object.catchall]);
+			break;
+		}
+		case "optional":
+		case "nullable":
+		case "readonly":
+		case "nonoptional":
+			children.push([where, def.innerType]);
+			break;
+		case "array":
+			children.push([`${where}[]`, def.element]);
+			break;
+		case "tuple": {
+			const tuple = def;
+			tuple.items.forEach((item, index) => children.push([`${where}[${index}]`, item]));
+			if (tuple.rest !== null) children.push([`${where}[…]`, tuple.rest]);
+			break;
+		}
+		case "union":
+			for (const option of def.options) children.push([where, option]);
+			break;
+		case "intersection": {
+			const intersection = def;
+			children.push([where, intersection.left], [where, intersection.right]);
+			break;
+		}
+		case "record": {
+			const record = def;
+			children.push([`${where}{key}`, record.keyType], [`${where}{}`, record.valueType]);
+			break;
+		}
+	}
+	for (const [path, child] of children) assertJsonSchema(child, path);
+}
+const SCALARS = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"boolean",
+	"enum",
+	"literal"
+]);
+function assertFlatScalar(schema, where) {
+	let def = schema._zod.def;
+	if (def.type === "optional") def = def.innerType._zod.def;
+	if (!SCALARS.has(def.type)) throw new TypeError(`contract ${where}: profile fields must be flat scalars (string, number, boolean, enum, literal), got ${def.type}`);
+}
+//#endregion
+export { ContractValidationError, checkEvent, defineContract, isContract };
+
+//# sourceMappingURL=contract.mjs.map