@hyperscale0/udl 2.6.1 → 3.0.0

package/dist/evolution.js

@@ -1,636 +1,32 @@
-import { UDL_LIMITS } from "./limits.js";
-import { deriveUdlActionEffects } from "./effects.js";
-import { udlClauseVocabulary } from "./schema.js";
-import { UdlError } from "./validation.js";
 import { issue } from "./diagnostics.js";
-/** Project an open .udl instrument into the evolution engine's exact semantic shape. */
-export function snapshotUdlInstrument(instrument) {
-    const required = new Set(instrument.required);
-    return {
-        templateBinding: instrument.templateBinding ?? null,
-        allocation: instrument.allocation ?? null,
-        contributions: instrument.contributions ?? null,
-        dateOrder: instrument.dateOrder ?? [],
-        actionOrder: [...instrument.actionOrder],
-        aggregateInvariants: (instrument.aggregateInvariants ?? []).map(aggregateInvariantKey),
-        callerParkedStates: instrument.callerParkedStates ?? {},
-        derivedAmounts: (instrument.derivedAmounts ?? []).map((amount) => amount.rule.kind === "minimum"
-            ? `${amount.field}=min(${amount.sourceField},${amount.rule.capField})`
-            : `${amount.field}=floor(${amount.sourceField}*${typeof amount.rule.bps === "number" ? amount.rule.bps : `fields.${amount.rule.bps.field}`}/10000)`),
-        dials: instrument.dials ?? [],
-        ...(instrument.distinctParties ? { distinctParties: true } : {}),
-        ...(instrument.feeRules
-            ? {
-                feeRules: instrument.feeRules.map((fee) => ({
-                    ...fee,
-                    rule: fee.rule.kind === "tiered"
-                        ? {
-                            ...fee.rule,
-                            tiers: fee.rule.tiers.map((tier) => ({
-                                ...tier,
-                                rule: { ...tier.rule },
-                            })),
-                        }
-                        : { ...fee.rule },
-                })),
-            }
-            : {}),
-        fields: Object.fromEntries(Object.entries(instrument.fields).map(([field, schema]) => [
-            field,
-            { required: required.has(field), schema: withoutProse(schema) },
-        ])),
-        id: instrument.id,
-        idPrefix: instrument.idPrefix,
-        initial: instrument.lifecycle.initial,
-        nav: instrument.nav ?? [],
-        parties: compactStringRecord(instrument.parties),
-        partitions: (instrument.partitions ?? []).map((partition) => `${partition.totalField} = ${[...partition.pieceFields].sort().join(" + ")}`),
-        states: [...instrument.lifecycle.states],
-        subjects: instrument.subject ? [...instrument.subject.kinds] : [],
-        subjectExtensible: instrument.subject?.extensible ?? false,
-        surfaceVisibility: instrument.surfaceVisibility ?? null,
-        templateId: instrument.templateId ?? null,
-        transitions: Object.fromEntries(Object.entries(instrument.lifecycle.transitions).map(([action, transition]) => [
-            action,
-            { from: [...transition.from], to: transition.to },
-        ])),
-        quotes: Object.fromEntries(Object.entries(instrument.actions)
-            .filter(([, action]) => action.quote)
-            .map(([name, action]) => [name, action.quote])),
-        updateFields: instrument.update?.fields ?? [],
-        updateExamples: instrument.update?.examples ?? null,
-        updateStates: instrument.update?.states ?? [],
-        actions: Object.fromEntries(instrument.actionOrder.map((action) => [
-            action,
-            snapshotUdlAction(instrument.actions[action]),
-        ])),
-    };
-}
-/**
- * Compare two product definitions under the append-only evolution law.
- *
- * Both documents must already have passed `validateUdl`. The diff walks
- * straight into `stableStringify`, so an unvalidated document with a cycle in
- * it throws a RangeError out of here where the validator would have returned a
- * clean `resource_limit` issue: parse first, then diff.
- */
-export function diffValidatedUdlEvolution(previous, next) {
-    return diffValidatedUdlEvolutionMessages(previous, next).map((message) => {
-        const instrumentId = /^([^:]+): /.exec(message)?.[1];
-        const instrumentIndex = previous.instruments.findIndex((instrument) => instrument.id === instrumentId);
-        const base = instrumentIndex < 0
-            ? "$.instruments"
-            : `$.instruments[${instrumentIndex}]`;
-        return evolutionIssue(message, base);
-    });
-}
-function diffValidatedUdlEvolutionMessages(previous, next) {
-    const violations = [];
-    if (previous.product !== next.product) {
-        violations.push(`product id changed from ${previous.product} to ${next.product}`);
-    }
-    if (next.version < previous.version) {
-        violations.push(`product version moved backward from ${previous.version} to ${next.version}`);
-    }
-    let semanticChange = false;
-    const previousSubjects = new Map(previous.subjects.map((subject) => [subject.kind, subject]));
-    const nextSubjects = new Map(next.subjects.map((subject) => [subject.kind, subject]));
-    for (const [kind, subject] of previousSubjects) {
-        const current = nextSubjects.get(kind);
-        if (!current) {
-            semanticChange = true;
-            violations.push(`subject kind ${kind} was removed or renamed`);
-        }
-        else if (stableStringify(subject) !== stableStringify(current)) {
-            semanticChange = true;
-            violations.push(`subject kind ${kind} changed after becoming live`);
-        }
-    }
-    for (const kind of nextSubjects.keys()) {
-        if (!previousSubjects.has(kind))
-            semanticChange = true;
-    }
-    const previousInstruments = new Map(previous.instruments.map((instrument) => [instrument.id, snapshotUdlInstrument(instrument)]));
-    const nextInstruments = new Map(next.instruments.map((instrument) => [instrument.id, snapshotUdlInstrument(instrument)]));
-    for (const [id, instrument] of previousInstruments) {
-        const current = nextInstruments.get(id);
-        if (!current) {
-            semanticChange = true;
-            violations.push(`${id}: live instrument was removed from the product`);
-            continue;
-        }
-        if (stableStringify(instrument) !== stableStringify(current)) {
-            semanticChange = true;
-        }
-        violations.push(...diffInstrumentEvolutionMessages(instrument, current));
-    }
-    for (const id of nextInstruments.keys()) {
-        if (!previousInstruments.has(id))
-            semanticChange = true;
-    }
-    if (semanticChange && next.version <= previous.version) {
-        violations.push(`product definition changed without increasing version ${previous.version}`);
-    }
-    return violations;
-}
-/** Diff one instrument snapshot. An empty result means the change is additive. */
-export function diffInstrumentEvolution(previous, next) {
-    return diffInstrumentEvolutionMessages(previous, next).map((message) => evolutionIssue(message, "$.instruments"));
-}
-function diffInstrumentEvolutionMessages(previous, next) {
-    if (previous.id !== next.id) {
-        return [`instrument id changed from ${previous.id} to ${next.id}`];
-    }
-    const violations = [];
-    if (previous.idPrefix !== next.idPrefix) {
-        violations.push(`instance id prefix changed from ${previous.idPrefix} to ${next.idPrefix}`);
-    }
-    if (previous.initial !== next.initial) {
-        violations.push(`initial lifecycle state changed from ${previous.initial} to ${next.initial}`);
-    }
-    violations.push(...removedSetEntries(previous.states, next.states, (state) => `lifecycle state ${state} was removed or renamed`));
-    for (const [action, transition] of Object.entries(previous.transitions)) {
-        const current = next.transitions[action];
-        if (!current) {
-            violations.push(`transition for action ${action} was removed or renamed`);
-            continue;
-        }
-        if (transition.to !== current.to) {
-            violations.push(`transition for action ${action} changed its target state from ${transition.to} to ${current.to}`);
-        }
-        violations.push(...removedSetEntries(transition.from, current.from, (state) => `transition for action ${action} no longer fires from state ${state}`));
-    }
-    violations.push(...diffFields(previous.fields, next.fields));
-    if (Boolean(previous.distinctParties) !== Boolean(next.distinctParties)) {
-        violations.push("distinct-party admission changed after becoming live");
-    }
-    if (previous.actionOrder) {
-        const previousActions = new Set(previous.actionOrder);
-        const retainedActionOrder = (next.actionOrder ?? []).filter((action) => previousActions.has(action));
-        if (stableStringify(previous.actionOrder) !==
-            stableStringify(retainedActionOrder)) {
-            violations.push("instrument action order changed after becoming live");
-        }
-    }
-    violations.push(...diffActions(previous.actions, next.actions));
-    violations.push(...diffParties(previous.parties, next.parties));
-    for (const key of [
-        "allocation",
-        "contributions",
-        "dateOrder",
-        "templateBinding",
-    ]) {
-        if (stableStringify(previous[key] ?? (key === "dateOrder" ? [] : null)) !==
-            stableStringify(next[key] ?? (key === "dateOrder" ? [] : null)))
-            violations.push(`${key} contract changed`);
-    }
-    violations.push(...diffAggregates(previous, next));
-    if (stableStringify(Object.keys(previous.callerParkedStates ?? {}).sort()) !==
-        stableStringify(Object.keys(next.callerParkedStates ?? {}).sort())) {
-        violations.push("caller-parked state annotations changed");
-    }
-    if (stableStringify(previous.dials ?? []) !== stableStringify(next.dials ?? [])) {
-        violations.push("instrument dials changed after becoming live");
-    }
-    if ((previous.surfaceVisibility ?? null) !== (next.surfaceVisibility ?? null)) {
-        violations.push("instrument surface visibility changed after becoming live");
-    }
-    if ((previous.templateId ?? null) !== (next.templateId ?? null)) {
-        violations.push("instrument archetype template changed after becoming live");
-    }
-    if (previous.subjectExtensible && !next.subjectExtensible) {
-        violations.push("tenant-defined subject kinds are no longer accepted");
-    }
-    if (stableStringify(previous.derivedAmounts ?? []) !==
-        stableStringify(next.derivedAmounts ?? [])) {
-        violations.push("derived amount rules changed; derived money arithmetic is frozen once live");
-    }
-    if (stableStringify(previous.feeRules ?? []) !==
-        stableStringify(next.feeRules ?? [])) {
-        violations.push("feeRules changed; fee calculation and settlement funding are frozen once live");
-    }
-    violations.push(...removedSetEntries(previous.partitions, next.partitions, (law) => `partition law [${law}] was removed`), ...next.partitions
-        .filter((law) => !previous.partitions.includes(law))
-        .map((law) => `partition law [${law}] was added, which can reject existing callers`));
-    violations.push(...diffQuotes(previous.quotes, next.quotes));
-    violations.push(...removedSetEntries(previous.subjects, next.subjects, (kind) => `subject kind ${kind} was removed, rejecting linked instances`), ...removedSetEntries(previous.updateFields, next.updateFields, (field) => `update policy no longer permits field ${field}`), ...removedSetEntries(previous.updateStates, next.updateStates, (state) => `update policy no longer permits state ${state}`));
-    return violations.map((violation) => `${next.id}: ${violation}`);
-}
-function evolutionIssue(message, instrumentBase) {
-    if (message.startsWith("product id changed"))
-        return issue("UDL7001", "$.product", message);
-    if (message.startsWith("product version moved backward"))
-        return issue("UDL7001", "$.version", message);
-    if (message.startsWith("product definition changed"))
-        return issue("UDL7002", "$.version", message);
-    if (message.startsWith("subject kind "))
-        return issue("UDL7001", "$.subjects", message);
-    const instrumentMatch = /^([^:]+): (.*)$/.exec(message);
-    const detail = instrumentMatch?.[2] ?? message;
-    const transitionAction = /^transition for action ([a-z][a-z0-9_]*)/.exec(detail)?.[1];
-    if (transitionAction)
-        return issue("UDL7001", `${instrumentBase}.lifecycle.transitions.${transitionAction}`, message);
-    const action = /^action ([a-z][a-z0-9_]*)/.exec(detail)?.[1];
-    if (action)
-        return issue("UDL7001", `${instrumentBase}.actions.${action}`, message);
-    if (detail.includes("instrument id"))
-        return issue("UDL7001", instrumentBase, message);
-    if (detail.includes("id prefix") ||
-        detail.includes("lifecycle") ||
-        detail.includes("transition") ||
-        detail.includes("initial") ||
-        detail.includes("live instrument was removed"))
-        return issue("UDL7001", `${instrumentBase}.lifecycle`, message);
-    if (detail.startsWith("field "))
-        return issue("UDL7001", `${instrumentBase}.fields`, message);
-    if (detail.includes("move") ||
-        detail.includes("payout") ||
-        detail.includes("fee") ||
-        detail.includes("quote") ||
-        detail.includes("derived amount") ||
-        detail.includes("partition") ||
-        detail.includes("distribution") ||
-        detail.includes("signed child sum") ||
-        detail.includes("earnable"))
-        return issue("UDL7001", `${instrumentBase}.actions`, message);
-    if (detail.includes("gate") ||
-        detail.includes("check prerequisite") ||
-        detail.includes("reconcile expectation") ||
-        detail.includes("drained-account") ||
-        detail.includes("exposure") ||
-        detail.includes("aggregate"))
-        return issue("UDL7001", `${instrumentBase}.actions`, message);
-    if (detail.startsWith("action ") ||
-        detail.includes("action order") ||
-        detail.includes("step count"))
-        return issue("UDL7001", `${instrumentBase}.actions`, message);
-    return issue("UDL7001", instrumentBase, message);
-}
-function snapshotUdlAction(definition) {
-    return {
-        requiresInput: definition.requiresInput ?? null,
-        engineOwned: definition.engineOwned ?? null,
-        captureEngine: definition.captureEngine ?? null,
-        requiresAllocation: definition.requiresAllocation ?? null,
-        allocate: definition.allocate ?? null,
-        contributionStage: definition.contributionStage ?? null,
-        transitionsRefs: definition.transitionsRefs ?? [],
-        captureInput: definition.captureInput ?? null,
-        commit: definition.commit ?? null,
-        deadline: definition.deadline ?? null,
-        decision: definition.decision ?? null,
-        principal: definition.principal ?? null,
-        remainder: definition.remainder ?? null,
-        requiresChecks: definition.requiresChecks ?? [],
-        sandboxFailurePoint: definition.sandboxFailurePoint ?? null,
-        updates: definition.updates ?? [],
-        distribute: definition.distribute ?? null,
-        due: definition.due ?? null,
-        earnable: definition.earnable ?? false,
-        effects: definition.effects ??
-            deriveUdlActionEffects(definition, udlClauseVocabulary),
-        eventName: definition.eventName ?? null,
-        input: definition.input ? snapshotJsonSchemaFields(definition.input) : null,
-        inputConstraints: definition.input
-            ? snapshotJsonSchemaConstraints(definition.input)
-            : null,
-        payout: definition.payout ?? null,
-        port: definition.port ?? null,
-        publicAction: definition.publicAction ?? null,
-        setsAt: definition.setsAt ?? null,
-        signedSum: definition.signedSum ?? null,
-        cascade: definition.cascade
-            ? definition.cascade.map((entry) => ({ ...entry }))
-            : null,
-        moves: definition.moves.map((move) => ({
-            bind: move.bind,
-            capture: move.capture ?? {},
-            key: move.key,
-            operation: move.operation,
-        })),
-        requiresAggregate: definition.requiresAggregate ?? [],
-        requiresDrainedAccount: definition.requiresDrainedAccount ?? null,
-        requiresExposure: definition.requiresExposure ?? [],
-        unique: definition.unique ?? null,
-        requiresRefs: definition.requiresRefs ?? [],
-        reconcile: definition.reconcile ?? null,
-        steps: definition.steps.map((step) => ({
-            bind: step.bind,
-            capture: step.capture ?? {},
-            operation: step.operation,
-        })),
-    };
-}
-function snapshotJsonSchemaFields(schema) {
-    const properties = recordValue(schema.properties);
-    const required = new Set(Array.isArray(schema.required)
-        ? schema.required.filter((value) => typeof value === "string")
-        : []);
-    return Object.fromEntries(Object.entries(properties).map(([field, fieldSchema]) => [
-        field,
-        { required: required.has(field), schema: withoutProse(fieldSchema) },
-    ]));
-}
-/**
- * Descriptions are prose for readers, not shape: a wording fix in a std
- * template must land on a live flow as an extension, never as a refusal.
- */
-function withoutProse(value, depth = 1) {
-    if (depth > UDL_LIMITS.maxDepth)
-        throw nestingExceeded();
-    if (Array.isArray(value)) {
-        return value.map((item) => withoutProse(item, depth + 1));
-    }
-    if (value === null || typeof value !== "object")
-        return value;
-    return Object.fromEntries(Object.entries(value)
-        .filter(([key]) => key !== "description")
-        .map(([key, entry]) => [key, withoutProse(entry, depth + 1)]));
-}
-function nestingExceeded() {
-    return new UdlError([
-        issue("UDL1004", "$", `UDL nesting exceeds ${UDL_LIMITS.maxDepth} levels`),
-    ]);
-}
-function snapshotJsonSchemaConstraints(schema) {
-    const { properties: _properties, required: _required, ...constraints } = schema;
-    return constraints;
-}
-function diffFields(previous, next) {
-    const violations = [];
-    for (const [field, descriptor] of Object.entries(previous)) {
-        const current = next[field];
-        if (!current) {
-            violations.push(`field ${field} was removed or renamed`);
-            continue;
-        }
-        if (!descriptor.required && current.required) {
-            violations.push(`field ${field} became required, tightening the schema`);
-        }
-        if (stableStringify(descriptor.schema) !== stableStringify(current.schema)) {
-            violations.push(`field ${field} schema changed; a live field schema is frozen`);
-        }
-    }
-    for (const [field, descriptor] of Object.entries(next)) {
-        if (!previous[field] && descriptor.required) {
-            violations.push(`field ${field} was added as required, which rejects existing instances (only optional fields are additive)`);
-        }
-    }
-    return violations;
-}
-function diffActions(previous, next) {
-    const violations = [];
-    for (const [action, descriptor] of Object.entries(previous)) {
-        const current = next[action];
-        if (!current) {
-            violations.push(`action ${action} was removed or renamed`);
-            continue;
-        }
-        if (descriptor.moves.length !== current.moves.length) {
-            violations.push(`action ${action} changed its move count from ${descriptor.moves.length} to ${current.moves.length}; money movement is frozen once live`);
-        }
-        else {
-            descriptor.moves.forEach((move, index) => {
-                const nextMove = current.moves[index];
-                if (stableStringify(move) !== stableStringify(nextMove)) {
-                    violations.push(`action ${action} changed move ${move.key} at index ${index}; money movement is frozen once live`);
-                }
-            });
-        }
-        if (descriptor.steps.length !== current.steps.length) {
-            violations.push(`action ${action} changed its step count from ${descriptor.steps.length} to ${current.steps.length}; a live action's steps are frozen`);
-        }
-        else {
-            descriptor.steps.forEach((step, index) => {
-                const nextStep = current.steps[index];
-                if (stableStringify(step) === stableStringify(nextStep))
-                    return;
-                violations.push(`action ${action} changed step ${index} (${step.operation}); a live action's steps are frozen`);
-            });
-        }
-        violations.push(...diffInput(action, descriptor.input ?? {}, current.input ?? {}));
-        // A action gaining its first input is additive (per-field checks still catch
-        // added-as-required); once an input is live, its schema envelope is frozen.
-        if (descriptor.input !== null &&
-            stableStringify(descriptor.inputConstraints) !==
-                stableStringify(current.inputConstraints)) {
-            violations.push(`action ${action} changed its input schema beyond declared fields; a live action input is frozen`);
-        }
-        if (stableStringify(descriptor.requiresRefs) !==
-            stableStringify(current.requiresRefs)) {
-            violations.push(`action ${action} changed its cross-instrument gates`);
-        }
-        if (stableStringify(descriptor.requiresAggregate) !==
-            stableStringify(current.requiresAggregate)) {
-            violations.push(`action ${action} changed its aggregate admission gates`);
-        }
-        if (stableStringify(descriptor.requiresDrainedAccount) !==
-            stableStringify(current.requiresDrainedAccount)) {
-            violations.push(`action ${action} changed its drained-account gate`);
-        }
-        if (stableStringify(descriptor.unique ?? null) !==
-            stableStringify(current.unique ?? null)) {
-            violations.push(`action ${action} changed its subject uniqueness claim`);
-        }
-        if (descriptor.requiresExposure !== undefined &&
-            stableStringify(descriptor.requiresExposure) !==
-                stableStringify(current.requiresExposure)) {
-            violations.push(`action ${action} changed its exposure admission gates`);
-        }
-        if (descriptor.reconcile !== undefined &&
-            stableStringify(descriptor.reconcile) !==
-                stableStringify(current.reconcile)) {
-            violations.push(`action ${action} changed its reconcile expectations`);
-        }
-        if (stableStringify(descriptor.payout ?? null) !==
-            stableStringify(current.payout ?? null)) {
-            violations.push(`action ${action} changed its payout intent`);
-        }
-        for (const key of [
-            "requiresInput",
-            "engineOwned",
-            "captureEngine",
-            "requiresAllocation",
-            "allocate",
-            "contributionStage",
-            "transitionsRefs",
-        ]) {
-            if (stableStringify(descriptor[key] ?? (key === "transitionsRefs" ? [] : null)) !==
-                stableStringify(current[key] ?? (key === "transitionsRefs" ? [] : null)))
-                violations.push(`action ${action} changed its ${key} contract`);
-        }
-        if (descriptor.earnable !== current.earnable) {
-            violations.push(`action ${action} changed its earnable flag`);
-        }
-        if (descriptor.effects !== undefined &&
-            stableStringify(descriptor.effects) !== stableStringify(current.effects)) {
-            violations.push(`action ${action} changed its derived effects`);
-        }
-        if (descriptor.eventName !== current.eventName) {
-            violations.push(`action ${action} changed its event name`);
-        }
-        if (stableStringify(descriptor.due) !== stableStringify(current.due)) {
-            violations.push(`action ${action} changed its due condition`);
-        }
-        if (stableStringify(descriptor.deadline) !== stableStringify(current.deadline)) {
-            violations.push(`action ${action} changed its admission deadline`);
-        }
-        if (stableStringify(descriptor.decision) !== stableStringify(current.decision)) {
-            violations.push(`action ${action} changed its provider decision`);
-        }
-        if ((descriptor.principal ?? null) !== (current.principal ?? null)) {
-            violations.push(`action ${action} changed its caller principal`);
-        }
-        if (stableStringify(descriptor.remainder ?? null) !==
-            stableStringify(current.remainder ?? null)) {
-            violations.push(`action ${action} changed its remainder rule`);
-        }
-        if (stableStringify(descriptor.requiresChecks ?? []) !==
-            stableStringify(current.requiresChecks ?? [])) {
-            violations.push(`action ${action} changed its check prerequisites`);
-        }
-        // A failure point only adds a sandbox refusal for one documented amount, so
-        // declaring one on an action that had none is additive; changing or
-        // removing a declared one rewrites what a sandbox integration relies on.
-        if (descriptor.sandboxFailurePoint &&
-            descriptor.sandboxFailurePoint !== (current.sandboxFailurePoint ?? null)) {
-            violations.push(`action ${action} changed its sandbox failure point`);
-        }
-        if (stableStringify(descriptor.updates ?? []) !==
-            stableStringify(current.updates ?? [])) {
-            violations.push(`action ${action} changed its field updates`);
-        }
-        if (stableStringify(descriptor.distribute) !==
-            stableStringify(current.distribute)) {
-            violations.push(`action ${action} changed its distribution rule; money distribution is frozen once live`);
-        }
-        if (descriptor.captureInput !== undefined &&
-            stableStringify(descriptor.captureInput) !==
-                stableStringify(current.captureInput)) {
-            violations.push(`action ${action} changed its captured receipt input`);
-        }
-        if (stableStringify(descriptor.port) !== stableStringify(current.port)) {
-            violations.push(`action ${action} changed its decision port`);
-        }
-        if (descriptor.publicAction != null &&
-            descriptor.publicAction !== current.publicAction) {
-            violations.push(`action ${action} changed its public action`);
-        }
-        if (stableStringify(descriptor.setsAt) !== stableStringify(current.setsAt)) {
-            violations.push(`action ${action} changed its computed timestamp`);
-        }
-        if (descriptor.signedSum !== undefined &&
-            stableStringify(descriptor.signedSum) !==
-                stableStringify(current.signedSum)) {
-            violations.push(`action ${action} changed its signed child sum`);
-        }
-        if (descriptor.cascade !== undefined &&
-            stableStringify(descriptor.cascade) !== stableStringify(current.cascade)) {
-            violations.push(`action ${action} changed its cascade rules`);
-        }
-    }
-    for (const [action, descriptor] of Object.entries(next)) {
-        if (previous[action] || descriptor.payout == null)
-            continue;
-        violations.push(`action ${action} added a payout intent; external money movement is frozen once live`);
-    }
-    return violations;
-}
-function diffInput(action, previous, next) {
-    const violations = [];
-    for (const [field, descriptor] of Object.entries(previous)) {
-        const current = next[field];
-        if (!current) {
-            // Compiled action inputs are strict objects, so a removed field starts
-            // rejecting every caller that still sends it -- same law as instrument fields.
-            violations.push(`action ${action} input field ${field} was removed or renamed`);
-            continue;
-        }
-        if (!descriptor.required && current.required) {
-            violations.push(`action ${action} input field ${field} became required, tightening the action input`);
-        }
-        if (stableStringify(descriptor.schema) !== stableStringify(current.schema)) {
-            violations.push(`action ${action} input field ${field} schema changed; a live action input schema is frozen`);
-        }
-    }
-    for (const [field, descriptor] of Object.entries(next)) {
-        if (!previous[field] && descriptor.required) {
-            violations.push(`action ${action} input field ${field} was added as required, tightening the action input`);
-        }
-    }
-    return violations;
-}
-function diffParties(previous, next) {
-    const violations = [];
-    for (const [role, field] of Object.entries(previous)) {
-        const current = next[role];
-        if (!current)
-            violations.push(`party role ${role} was removed or renamed`);
-        else if (current !== field) {
-            violations.push(`party role ${role} moved from field ${field} to ${current}`);
-        }
-    }
-    return violations;
-}
-function diffAggregates(previous, next) {
-    return [
-        ...removedSetEntries(previous.aggregateInvariants, next.aggregateInvariants, (key) => `aggregate invariant [${key}] was removed`),
-        ...next.aggregateInvariants
-            .filter((key) => !previous.aggregateInvariants.includes(key))
-            .map((key) => `aggregate invariant [${key}] was added, which can reject existing instances`),
-    ];
-}
-function diffQuotes(previous, next) {
-    if (previous === null || previous === undefined)
-        return [];
-    if (next === null || next === undefined)
-        return ["quote policy was removed"];
-    return stableStringify(previous) === stableStringify(next)
-        ? []
-        : [
-            "quote policy changed; the charge schedule, the frozen fields, and the refund destination are frozen once live",
-        ];
-}
-function aggregateInvariantKey(invariant) {
-    const measure = "childField" in invariant
-        ? invariant.childField
-        : `count${invariant.window ? `[${invariant.window.field} per ${invariant.window.days}d]` : ""}`;
-    return `${invariant.childInstrumentId}.${measure} within ${invariant.parentField} via ${invariant.childRefField} while ${[...invariant.childStatuses].sort().join(",")}`;
-}
-function removedSetEntries(previous, next, message) {
-    const current = new Set(next);
-    return previous.filter((entry) => !current.has(entry)).map(message);
-}
-function compactStringRecord(value) {
-    return Object.fromEntries(Object.entries(value ?? {}).filter((entry) => typeof entry[1] === "string"));
-}
-function recordValue(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
-/**
- * The comparison key every diff above is written against. It recurses, so it
- * carries the same depth budget the validator applies to a document: a
- * snapshot is never deeper than the document it came from, and the deepest
- * conformance document reaches 12 of the 24 levels. A cycle is infinite depth
- * and lands here rather than exhausting the call stack.
- */
-function stableStringify(value, depth = 1) {
-    if (depth > UDL_LIMITS.maxDepth)
-        throw nestingExceeded();
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value) ?? "null";
-    }
-    if (Array.isArray(value)) {
-        // An arrow, not a bare reference: `map` would pass the index as the depth.
-        return `[${value.map((item) => stableStringify(item, depth + 1)).join(",")}]`;
-    }
-    const entries = Object.entries(value)
-        .filter(([, entry]) => entry !== undefined)
-        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
-    return `{${entries
-        .map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry, depth + 1)}`)
-        .join(",")}}`;
+function stable(value) {
+    if (Array.isArray(value))
+        return "[" + value.map(stable).join(",") + "]";
+    if (value && typeof value === "object")
+        return ("{" +
+            Object.entries(value)
+                .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+                .map(([key, entry]) => JSON.stringify(key) + ":" + stable(entry))
+                .join(",") +
+            "}");
+    return JSON.stringify(value) ?? "undefined";
+}
+/** Existing instruments are frozen; a live document may add independent instruments. */
+export function diffValidatedUdlEvolution(live, next) {
+    const issues = [];
+    const refuse = (path, message) => issues.push(issue("UDL7001", path, message));
+    if (live.product !== next.product || live.currency !== next.currency)
+        refuse("$", "product identity and currency are immutable");
+    for (const [name, party] of Object.entries(live.parties))
+        if (stable(party) !== stable(next.parties[name]))
+            refuse(`$.parties.${name}`, "a live party cannot change or disappear");
+    for (const instrument of live.instruments) {
+        const updated = next.instruments.find((i) => i.id === instrument.id);
+        if (!updated || stable(instrument) !== stable(updated))
+            refuse(`$.instruments.${instrument.id}`, "a live instrument cannot change or disappear; recreate development estates");
+    }
+    if (stable(live) !== stable(next) && next.version <= live.version)
+        issues.push(issue("UDL7002", "$.version", "a changed document needs a higher version"));
+    return issues;
 }
 //# sourceMappingURL=evolution.js.map