stitchkit 0.71.0 → 0.72.0

package/dist/primitives.js

@@ -0,0 +1,750 @@
+import {
+  ManagedFileRefSchema
+} from "./index-f6n5n7nz.js";
+import"./index-ksp6e2ye.js";
+
+// src/primitives/audit.ts
+import { z as z2 } from "zod";
+
+// src/primitives/event.ts
+import { z } from "zod";
+var DomainEventActorSchema = z.object({
+  id: z.string().min(1),
+  role: z.string().min(1)
+});
+var DomainEventSubjectSchema = z.object({
+  type: z.string().min(1),
+  id: z.string().min(1)
+});
+function createDomainEventSchema(payload) {
+  return z.object({
+    id: z.string().min(1),
+    type: z.string().min(1),
+    occurredAt: z.iso.datetime({ offset: true }),
+    actor: DomainEventActorSchema.optional(),
+    subject: DomainEventSubjectSchema,
+    payload
+  });
+}
+var DomainEventSchema = createDomainEventSchema(z.unknown());
+
+// src/primitives/audit.ts
+var AuditChangeSchema = z2.object({
+  operation: z2.string().min(1),
+  change: z2.unknown()
+});
+var AuditRecordSchema = createDomainEventSchema(AuditChangeSchema);
+var audit = Object.freeze({
+  record(change) {
+    return Object.freeze({ mode: "record", change });
+  },
+  omit(reason) {
+    if (reason.trim() === "")
+      throw new Error("[stitchkit] audit omission requires a reason");
+    return Object.freeze({ mode: "omit", reason });
+  }
+});
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "safeParse" in value && typeof value.safeParse === "function";
+}
+function endpointAuditPolicy(endpoint) {
+  const policy = endpoint.meta?.audit;
+  if (!policy || typeof policy !== "object" || !("mode" in policy))
+    return;
+  if (policy.mode === "omit" && "reason" in policy && typeof policy.reason === "string") {
+    return audit.omit(policy.reason);
+  }
+  if (policy.mode === "record" && "change" in policy && isZodType(policy.change)) {
+    return { mode: "record", change: policy.change };
+  }
+  return;
+}
+function assertAuditDeclared(contract) {
+  for (const [operation, endpoint] of Object.entries(contract.endpoints)) {
+    if (!endpointAuditPolicy(endpoint)) {
+      throw new Error(`[stitchkit] contract "${contract.meta.prefix}" operation "${operation}" must declare meta.audit`);
+    }
+  }
+}
+function createAuditRecord(input) {
+  const change = input.policy.change.parse(input.change);
+  return AuditRecordSchema.parse({
+    id: input.id,
+    type: "audit.recorded",
+    occurredAt: input.occurredAt,
+    actor: input.actor,
+    subject: input.subject,
+    payload: { operation: input.operation, change }
+  });
+}
+// src/primitives/deadline.ts
+import { z as z3 } from "zod";
+var DAY_MS = 86400000;
+var DeadlineResultSchema = z3.object({
+  dueAt: z3.iso.datetime({ offset: true }),
+  remainingDays: z3.number().int(),
+  overdueDays: z3.number().int().nonnegative(),
+  category: z3.string().min(1)
+});
+function partsInZone(value, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(value);
+  const read = (type) => {
+    const part = parts.find((candidate) => candidate.type === type)?.value;
+    if (!part)
+      throw new Error(`[stitchkit] timezone projection omitted ${type}`);
+    return Number(part);
+  };
+  return {
+    year: read("year"),
+    month: read("month"),
+    day: read("day"),
+    hour: read("hour"),
+    minute: read("minute"),
+    second: read("second")
+  };
+}
+function partsEpoch(parts) {
+  return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+}
+function localPartsToEpoch(parts, timeZone) {
+  const desired = partsEpoch(parts);
+  let candidate = desired;
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    const projected = partsEpoch(partsInZone(new Date(candidate), timeZone));
+    candidate += desired - projected;
+  }
+  return candidate;
+}
+function addCalendarDays(anchor, days, timeZone) {
+  const parts = partsInZone(anchor, timeZone);
+  const shifted = new Date(Date.UTC(parts.year, parts.month - 1, parts.day + days, parts.hour, parts.minute, parts.second));
+  return new Date(localPartsToEpoch(partsInZone(shifted, "UTC"), timeZone));
+}
+function calendarDayKey(value, timeZone) {
+  const parts = partsInZone(value, timeZone);
+  return Date.UTC(parts.year, parts.month - 1, parts.day) / DAY_MS;
+}
+function defineDeadlinePolicy(config) {
+  new Intl.DateTimeFormat("en", { timeZone: config.timeZone }).format(new Date(0));
+  if (!Number.isSafeInteger(config.warningDays) || config.warningDays < 0) {
+    throw new RangeError("warningDays must be a non-negative safe integer");
+  }
+  const addDays = (value, days) => config.boundary === "calendar-day" ? addCalendarDays(value, days, config.timeZone) : new Date(value.getTime() + days * DAY_MS);
+  return Object.freeze({
+    definition: config,
+    evaluate(input) {
+      if (!Number.isSafeInteger(input.durationDays) || input.durationDays < 0) {
+        throw new RangeError("durationDays must be a non-negative safe integer");
+      }
+      const dueAt = addDays(input.anchorAt, input.durationDays);
+      const remainingDays = config.boundary === "calendar-day" ? calendarDayKey(dueAt, config.timeZone) - calendarDayKey(input.now, config.timeZone) : Math.ceil((dueAt.getTime() - input.now.getTime()) / DAY_MS);
+      const category = remainingDays < 0 ? config.categories.overdue : remainingDays <= config.warningDays ? config.categories.warning : config.categories.onTrack;
+      return DeadlineResultSchema.parse({
+        dueAt: dueAt.toISOString(),
+        remainingDays,
+        overdueDays: Math.max(0, -remainingDays),
+        category
+      });
+    },
+    queryBoundary(now) {
+      return Object.freeze({
+        overdueBefore: now.toISOString(),
+        warningBefore: addDays(now, config.warningDays).toISOString()
+      });
+    }
+  });
+}
+// src/primitives/delivery.ts
+import { z as z4 } from "zod";
+var DomainEventDestinationSchema = z4.object({
+  id: z4.string().min(1),
+  transport: z4.string().min(1),
+  address: z4.string().min(1)
+});
+var DomainEventDeliveryOutcomeSchema = z4.discriminatedUnion("outcome", [
+  z4.object({ outcome: z4.literal("delivered"), receipt: z4.string().min(1).optional() }),
+  z4.object({
+    outcome: z4.literal("retryable"),
+    code: z4.string().min(1),
+    retryAt: z4.iso.datetime({ offset: true })
+  }),
+  z4.object({ outcome: z4.literal("terminal"), code: z4.string().min(1) }),
+  z4.object({ outcome: z4.literal("unknown"), code: z4.string().min(1) })
+]);
+var DomainEventDeliveryClaimSchema = z4.object({
+  event: DomainEventSchema,
+  destination: DomainEventDestinationSchema,
+  attempt: z4.number().int().positive()
+});
+function defineDomainEventDelivery(config) {
+  const maxClaims = config.maxClaimsPerDispatch ?? 100;
+  if (!Number.isSafeInteger(maxClaims) || maxClaims <= 0) {
+    throw new RangeError("maxClaimsPerDispatch must be a positive safe integer");
+  }
+  return Object.freeze({
+    plan(eventInput) {
+      const event = DomainEventSchema.parse(eventInput);
+      const destinations = config.routes.filter((route) => route.type === event.type).flatMap((route) => route.destinations(event)).map((destination) => DomainEventDestinationSchema.parse(destination));
+      const ids = new Set;
+      for (const destination of destinations) {
+        if (ids.has(destination.id)) {
+          throw new Error(`[stitchkit] duplicate destination id "${destination.id}"`);
+        }
+        ids.add(destination.id);
+      }
+      return Object.freeze({ event, destinations: Object.freeze(destinations) });
+    },
+    async dispatch(eventId) {
+      let attempts = 0;
+      while (attempts < maxClaims) {
+        const claim = await config.outbox.claim(eventId);
+        if (!claim)
+          return { eventId, attempts, exhausted: false };
+        const parsedClaim = DomainEventDeliveryClaimSchema.parse(claim);
+        if (parsedClaim.event.id !== eventId) {
+          throw new Error("[stitchkit] outbox claim event id does not match dispatch request");
+        }
+        const transport = config.transports[parsedClaim.destination.transport];
+        let outcome;
+        if (!transport) {
+          outcome = { outcome: "unknown", code: "TRANSPORT_NOT_DECLARED" };
+        } else {
+          try {
+            outcome = DomainEventDeliveryOutcomeSchema.parse(await transport.send(parsedClaim.event, parsedClaim.destination));
+          } catch {
+            outcome = { outcome: "unknown", code: "TRANSPORT_FAILED" };
+          }
+        }
+        switch (outcome.outcome) {
+          case "delivered":
+            await config.outbox.delivered(parsedClaim, outcome);
+            break;
+          case "retryable":
+            await config.outbox.retry(parsedClaim, outcome);
+            break;
+          case "terminal":
+            await config.outbox.terminal(parsedClaim, outcome);
+            break;
+          case "unknown":
+            await config.outbox.unknown(parsedClaim, outcome);
+            break;
+        }
+        attempts += 1;
+      }
+      return { eventId, attempts, exhausted: true };
+    }
+  });
+}
+// src/primitives/export-operation.ts
+import { z as z5 } from "zod";
+function createExportResultSchema(operationId) {
+  return z5.discriminatedUnion("state", [
+    z5.object({
+      state: z5.literal("ready"),
+      file: ManagedFileRefSchema.extend({
+        mediaType: z5.string().min(1),
+        name: z5.string().min(1)
+      })
+    }),
+    z5.object({ state: z5.literal("pending"), operationId })
+  ]);
+}
+function defineExportOperation(config) {
+  if (config.mediaType.trim() === "")
+    throw new Error("[stitchkit] export mediaType is required");
+  const result = createExportResultSchema(config.operationId);
+  return Object.freeze({
+    input: config.input,
+    result,
+    ready(inputValue, file) {
+      const input = config.input.parse(inputValue);
+      return result.parse({
+        state: "ready",
+        file: {
+          ...file,
+          mediaType: config.mediaType,
+          name: config.filename(input)
+        }
+      });
+    },
+    pending(operationId) {
+      return result.parse({ state: "pending", operationId });
+    },
+    endpoint(definition) {
+      return {
+        ...definition,
+        input: config.input,
+        output: result
+      };
+    }
+  });
+}
+// src/primitives/lifecycle.ts
+import { z as z6 } from "zod";
+var lifecycleStateBrand = Symbol("stitchkit.lifecycle.state");
+var LifecycleTransitionEventSchema = z6.object({
+  id: z6.string().min(1),
+  type: z6.literal("lifecycle.transitioned"),
+  occurredAt: z6.iso.datetime({ offset: true }),
+  actor: z6.object({ id: z6.string().min(1), role: z6.string().min(1) }),
+  subject: z6.object({ type: z6.string().min(1), id: z6.string().min(1) }),
+  payload: z6.object({
+    lifecycle: z6.string().min(1),
+    transition: z6.string().min(1),
+    from: z6.string().min(1),
+    to: z6.string().min(1),
+    data: z6.unknown()
+  })
+});
+function stateMatches(expected, actual) {
+  return Array.isArray(expected) ? expected.includes(actual) : expected === actual;
+}
+function lifecycleState(value) {
+  const state = { value, [lifecycleStateBrand]: true };
+  return Object.freeze(state);
+}
+function defineLifecycle(config) {
+  const definition = config;
+  return Object.freeze({
+    definition,
+    state(value) {
+      if (!config.states.includes(value)) {
+        throw new Error(`[stitchkit] lifecycle "${config.name}" received an unknown state`);
+      }
+      return lifecycleState(value);
+    },
+    availableTransitions(state, role) {
+      return Object.entries(config.transitions).filter(([, transition]) => stateMatches(transition.from, state.value) && transition.by.includes(role)).map(([name]) => name);
+    },
+    transition(input) {
+      const transition = config.transitions[input.transition];
+      if (!transition) {
+        return {
+          outcome: "transition_not_allowed",
+          transition: input.transition,
+          state: input.state.value
+        };
+      }
+      if (!stateMatches(transition.from, input.state.value)) {
+        return {
+          outcome: "transition_not_allowed",
+          transition: input.transition,
+          state: input.state.value
+        };
+      }
+      if (!transition.by.includes(input.role)) {
+        return {
+          outcome: "role_not_allowed",
+          transition: input.transition,
+          role: input.role
+        };
+      }
+      const parsedPayload = transition.payload?.safeParse(input.payload);
+      if (parsedPayload && !parsedPayload.success) {
+        return {
+          outcome: "invalid_payload",
+          transition: input.transition,
+          issues: parsedPayload.error.issues.map((issue) => issue.message)
+        };
+      }
+      const actor = { id: input.actorId, role: input.role };
+      const event = LifecycleTransitionEventSchema.parse({
+        id: input.eventId,
+        type: "lifecycle.transitioned",
+        occurredAt: input.occurredAt,
+        actor,
+        subject: input.subject,
+        payload: {
+          lifecycle: config.name,
+          transition: input.transition,
+          from: input.state.value,
+          to: transition.to,
+          data: parsedPayload?.data ?? input.payload
+        }
+      });
+      return {
+        outcome: "transitioned",
+        state: lifecycleState(transition.to),
+        event
+      };
+    }
+  });
+}
+// src/primitives/migration-checks.ts
+function lineNumber(text, offset) {
+  return text.slice(0, offset).split(`
+`).length;
+}
+function excerptAt(text, offset) {
+  const start = text.lastIndexOf(`
+`, offset) + 1;
+  const end = text.indexOf(`
+`, offset);
+  return text.slice(start, end === -1 ? undefined : end).trim();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function scanMoneyNumberRisks(sources, identifiers = ["amount", "money", "price", "total"]) {
+  const risks = [];
+  for (const source of sources) {
+    for (const identifier of identifiers) {
+      const pattern = new RegExp(`\\b${escapeRegExp(identifier)}\\b[^\\n;]{0,120}\\.toFixed\\(\\s*2\\s*\\)`, "gi");
+      for (const match of source.text.matchAll(pattern)) {
+        if (match.index === undefined)
+          continue;
+        risks.push({
+          path: source.path,
+          line: lineNumber(source.text, match.index),
+          kind: "money-number",
+          excerpt: excerptAt(source.text, match.index)
+        });
+      }
+    }
+  }
+  return risks;
+}
+function scanOwnerFilterRisks(sources, ownerKeys = ["ownerId"]) {
+  const risks = [];
+  for (const source of sources) {
+    for (const ownerKey of ownerKeys) {
+      const key = escapeRegExp(ownerKey);
+      const pattern = new RegExp(`\\.(?:findMany|findFirst|count|aggregate|groupBy)\\s*\\([^;]{0,500}?\\b${key}\\s*(?::|[,}])`, "g");
+      for (const match of source.text.matchAll(pattern)) {
+        if (match.index === undefined)
+          continue;
+        risks.push({
+          path: source.path,
+          line: lineNumber(source.text, match.index),
+          kind: "manual-owner-filter",
+          excerpt: excerptAt(source.text, match.index)
+        });
+      }
+    }
+  }
+  return risks;
+}
+// src/primitives/money.ts
+import { z as z7 } from "zod";
+var IntegerStringSchema = z7.string().regex(/^-?(?:0|[1-9]\d*)$/);
+function createMoneySchema(currency) {
+  return z7.object({
+    minor: IntegerStringSchema,
+    currency: z7.literal(currency)
+  });
+}
+function parseMinor(value) {
+  return BigInt(IntegerStringSchema.parse(value.minor));
+}
+function assertSameCurrency(left, right) {
+  if (left.currency !== right.currency) {
+    throw new TypeError(`cannot combine "${left.currency}" and "${right.currency}"`);
+  }
+}
+function money(minor, currency) {
+  return Object.freeze({ minor: minor.toString(), currency });
+}
+function addMoney(left, right) {
+  assertSameCurrency(left, right);
+  return money(parseMinor(left) + parseMinor(right), left.currency);
+}
+function subtractMoney(left, right) {
+  assertSameCurrency(left, right);
+  return money(parseMinor(left) - parseMinor(right), left.currency);
+}
+function multiplyMoney(value, quantity) {
+  if (typeof quantity === "number" && !Number.isSafeInteger(quantity)) {
+    throw new RangeError("quantity must be a safe integer");
+  }
+  const multiplier = typeof quantity === "bigint" ? quantity : BigInt(quantity);
+  return money(parseMinor(value) * multiplier, value.currency);
+}
+function shareMoney(value, numerator, denominator) {
+  if (denominator <= 0n)
+    throw new RangeError("denominator must be positive");
+  if (numerator < 0n)
+    throw new RangeError("numerator must be non-negative");
+  const scaled = parseMinor(value) * numerator;
+  return Object.freeze({
+    amount: money(scaled / denominator, value.currency),
+    remainder: Object.freeze({
+      numerator: (scaled % denominator).toString(),
+      denominator: denominator.toString(),
+      currency: value.currency
+    })
+  });
+}
+function splitMoney(value, count) {
+  if (!Number.isSafeInteger(count) || count <= 0) {
+    throw new RangeError("count must be a positive safe integer");
+  }
+  const divisor = BigInt(count);
+  const total = parseMinor(value);
+  return Object.freeze({
+    part: money(total / divisor, value.currency),
+    count,
+    remainder: money(total % divisor, value.currency)
+  });
+}
+function defineMoney(currency) {
+  const schema = createMoneySchema(currency);
+  return Object.freeze({
+    currency,
+    schema,
+    create(minor) {
+      const parsed = schema.parse({ minor: minor.toString(), currency });
+      return Object.freeze(parsed);
+    },
+    add: addMoney,
+    subtract: subtractMoney,
+    multiply: multiplyMoney,
+    share: shareMoney,
+    split: splitMoney
+  });
+}
+// src/primitives/owner-scope.ts
+var ownerScopeBrand = Symbol("stitchkit.owner.scope");
+function scopedOwner(ownerId) {
+  const scope = { kind: "owner", ownerId, [ownerScopeBrand]: true };
+  return Object.freeze(scope);
+}
+function allOwners() {
+  const scope = {
+    kind: "all",
+    permission: "acrossAllOwners",
+    [ownerScopeBrand]: true
+  };
+  return Object.freeze(scope);
+}
+function defineOwnerScope(definition) {
+  return Object.freeze({
+    definition,
+    forIdentity(identity) {
+      const ownerId = definition.ownerId(identity);
+      return ownerId ? { outcome: "resolved", scope: scopedOwner(ownerId) } : { outcome: "owner_missing" };
+    },
+    acrossAllOwners(identity) {
+      return definition.canAccessAll(identity) ? { outcome: "resolved", scope: allOwners() } : { outcome: "across_all_forbidden" };
+    }
+  });
+}
+// src/primitives/permission.ts
+function definePermissionMatrix(config) {
+  if (new Set(config.roles).size !== config.roles.length) {
+    throw new Error("[stitchkit] permission matrix roles must be unique");
+  }
+  if (new Set(config.operations).size !== config.operations.length) {
+    throw new Error("[stitchkit] permission matrix operations must be unique");
+  }
+  for (const role of config.roles) {
+    const declared = Object.keys(config.grants[role]).sort();
+    const expected = [...config.operations].sort();
+    if (declared.length !== expected.length || declared.some((value, index) => value !== expected[index])) {
+      throw new Error(`[stitchkit] permission matrix role "${role}" must decide every operation`);
+    }
+  }
+  const roleSet = new Set(config.roles);
+  const operationSet = new Set(config.operations);
+  const decisions = new Map;
+  for (const role of config.roles) {
+    for (const operation of config.operations) {
+      decisions.set(`${role}\x00${operation}`, config.grants[role][operation]);
+    }
+  }
+  return Object.freeze({
+    definition: config,
+    allows(role, operation) {
+      return config.grants[role][operation];
+    },
+    capabilities(role) {
+      return config.operations.filter((operation) => config.grants[role][operation]);
+    },
+    check(role, operation) {
+      if (!roleSet.has(role))
+        return { outcome: "unknown_role", role };
+      if (!operationSet.has(operation))
+        return { outcome: "unknown_operation", operation };
+      return decisions.get(`${role}\x00${operation}`) ? { outcome: "allowed" } : { outcome: "denied" };
+    }
+  });
+}
+// src/primitives/quantity.ts
+import { z as z8 } from "zod";
+
+// src/primitives/decimal.ts
+var DECIMAL_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function parseDecimal(value) {
+  if (!DECIMAL_PATTERN.test(value))
+    throw new TypeError(`invalid decimal value "${value}"`);
+  const negative = value.startsWith("-");
+  const unsigned = negative ? value.slice(1) : value;
+  const [whole = "0", fraction = ""] = unsigned.split(".");
+  const coefficient = BigInt(`${negative ? "-" : ""}${whole}${fraction}`);
+  return normalizeDecimal({ coefficient, scale: fraction.length });
+}
+function normalizeDecimal(parts) {
+  let coefficient = parts.coefficient;
+  let scale = parts.scale;
+  while (scale > 0 && coefficient % 10n === 0n) {
+    coefficient /= 10n;
+    scale -= 1;
+  }
+  return { coefficient, scale };
+}
+function formatDecimal(parts) {
+  const normalized = normalizeDecimal(parts);
+  const negative = normalized.coefficient < 0n;
+  const digits = (negative ? -normalized.coefficient : normalized.coefficient).toString();
+  if (normalized.scale === 0)
+    return `${negative ? "-" : ""}${digits}`;
+  const padded = digits.padStart(normalized.scale + 1, "0");
+  const point = padded.length - normalized.scale;
+  return `${negative ? "-" : ""}${padded.slice(0, point)}.${padded.slice(point)}`;
+}
+function addDecimal(left, right) {
+  const scale = Math.max(left.scale, right.scale);
+  const leftCoefficient = left.coefficient * 10n ** BigInt(scale - left.scale);
+  const rightCoefficient = right.coefficient * 10n ** BigInt(scale - right.scale);
+  return normalizeDecimal({ coefficient: leftCoefficient + rightCoefficient, scale });
+}
+function multiplyDecimalRatio(value, numerator, denominator) {
+  if (denominator <= 0n)
+    throw new RangeError("conversion denominator must be positive");
+  let coefficient = value.coefficient * numerator;
+  let scale = value.scale;
+  for (let extraScale = 0;extraScale <= 18; extraScale += 1) {
+    if (coefficient % denominator === 0n) {
+      return normalizeDecimal({ coefficient: coefficient / denominator, scale });
+    }
+    coefficient *= 10n;
+    scale += 1;
+  }
+  throw new RangeError("conversion does not have a finite decimal representation");
+}
+
+// src/primitives/quantity.ts
+var DecimalStringSchema = z8.string().refine((value) => {
+  try {
+    return formatDecimal(parseDecimal(value)) === value;
+  } catch {
+    return false;
+  }
+}, "expected a canonical decimal string");
+function createQuantitySchema(unit) {
+  return z8.object({ value: DecimalStringSchema, unit: z8.literal(unit) });
+}
+function quantity(value, unit) {
+  return Object.freeze({ value: formatDecimal(parseDecimal(value)), unit });
+}
+function sameUnit(left, right) {
+  return left === right;
+}
+function addQuantity(left, right) {
+  if (!sameUnit(left.unit, right.unit)) {
+    throw new TypeError(`cannot combine "${left.unit}" and "${right.unit}"`);
+  }
+  return quantity(formatDecimal(addDecimal(parseDecimal(left.value), parseDecimal(right.value))), left.unit);
+}
+var QuantityProjectionSchema = z8.discriminatedUnion("kind", [
+  z8.object({
+    kind: z8.literal("recorded"),
+    quantity: z8.object({ value: DecimalStringSchema, unit: z8.string().min(1) })
+  }),
+  z8.object({
+    kind: z8.literal("derived"),
+    quantity: z8.object({ value: DecimalStringSchema, unit: z8.string().min(1) }),
+    source: z8.object({ value: DecimalStringSchema, unit: z8.string().min(1) }),
+    conversionId: z8.string().min(1)
+  })
+]);
+function defineUnitSystem(config) {
+  const ids = new Set;
+  for (const conversion of config.conversions) {
+    if (ids.has(conversion.id)) {
+      throw new Error(`[stitchkit] duplicate conversion id "${conversion.id}"`);
+    }
+    ids.add(conversion.id);
+    if (!/^-?(?:0|[1-9]\d*)$/.test(conversion.numerator)) {
+      throw new Error(`[stitchkit] conversion "${conversion.id}" numerator must be an integer`);
+    }
+    if (!/^(?:[1-9]\d*)$/.test(conversion.denominator)) {
+      throw new Error(`[stitchkit] conversion "${conversion.id}" denominator must be positive`);
+    }
+  }
+  return Object.freeze({
+    definition: config,
+    create(value, unit) {
+      if (!config.units.includes(unit))
+        throw new Error(`[stitchkit] unknown unit "${unit}"`);
+      return quantity(value, unit);
+    },
+    recorded(value) {
+      return Object.freeze({ kind: "recorded", quantity: value });
+    },
+    convert(source, to) {
+      if (sameUnit(source.unit, to)) {
+        return Object.freeze({
+          kind: "derived",
+          quantity: quantity(source.value, to),
+          source,
+          conversionId: "identity"
+        });
+      }
+      const conversion = config.conversions.find((candidate) => candidate.from === source.unit && candidate.to === to);
+      if (!conversion) {
+        throw new Error(`[stitchkit] no conversion from "${source.unit}" to "${to}"`);
+      }
+      const converted = multiplyDecimalRatio(parseDecimal(source.value), BigInt(conversion.numerator), BigInt(conversion.denominator));
+      return Object.freeze({
+        kind: "derived",
+        quantity: quantity(formatDecimal(converted), to),
+        source,
+        conversionId: conversion.id
+      });
+    }
+  });
+}
+export {
+  subtractMoney,
+  splitMoney,
+  shareMoney,
+  scanOwnerFilterRisks,
+  scanMoneyNumberRisks,
+  multiplyMoney,
+  defineUnitSystem,
+  definePermissionMatrix,
+  defineOwnerScope,
+  defineMoney,
+  defineLifecycle,
+  defineExportOperation,
+  defineDomainEventDelivery,
+  defineDeadlinePolicy,
+  createQuantitySchema,
+  createMoneySchema,
+  createExportResultSchema,
+  createDomainEventSchema,
+  createAuditRecord,
+  audit,
+  assertAuditDeclared,
+  addQuantity,
+  addMoney,
+  QuantityProjectionSchema,
+  LifecycleTransitionEventSchema,
+  DomainEventSubjectSchema,
+  DomainEventSchema,
+  DomainEventDestinationSchema,
+  DomainEventDeliveryOutcomeSchema,
+  DomainEventDeliveryClaimSchema,
+  DomainEventActorSchema,
+  DeadlineResultSchema,
+  AuditRecordSchema
+};