stitchkit 0.93.0 → 0.94.1

package/dist/primitives.js

@@ -1,754 +0,0 @@
-import"./index-0a349c33.js";
-import"./index-rxfy4cq7.js";
-import {
-  ManagedFileRefSchema
-} from "./index-6k1937bx.js";
-import"./index-2vtcmrj9.js";
-import"./index-kzfs85xp.js";
-import"./index-77fekveh.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
-};