@things-factory/ops-master 10.1.33 → 10.1.35

package/dist-server/service/recipe/recipe-revision-service.js

@@ -0,0 +1,591 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipeRefusal = void 0;
+exports.recipeSubmissionHash = recipeSubmissionHash;
+exports.recipeApprovalInput = recipeApprovalInput;
+exports.assertRecipeApprovalInput = assertRecipeApprovalInput;
+exports.createRecipeDraft = createRecipeDraft;
+exports.editRecipeDraft = editRecipeDraft;
+exports.freezeRecipeDraft = freezeRecipeDraft;
+exports.bindRecipeApproval = bindRecipeApproval;
+exports.publishRecipeRevision = publishRecipeRevision;
+exports.publishUnregulatedRecipe = publishUnregulatedRecipe;
+exports.resolveRecipe = resolveRecipe;
+exports.recipeRevisionForBasis = recipeRevisionForBasis;
+exports.captureRecipeBasis = captureRecipeBasis;
+exports.recipeRevisionOverview = recipeRevisionOverview;
+exports.effectiveRecipe = effectiveRecipe;
+const node_crypto_1 = require("node:crypto");
+const typeorm_1 = require("typeorm");
+const shell_1 = require("@things-factory/shell");
+const master_change_policy_1 = require("../master-change-policy");
+const recipe_definition_1 = require("./recipe-definition");
+const recipe_revision_line_1 = require("./recipe-revision-line");
+const material_definition_1 = require("../material/material-definition");
+const operation_definition_1 = require("../operation/operation-definition");
+const route_definition_1 = require("./route-definition");
+const recipe_revision_content_1 = require("./recipe-revision-content");
+const recipe_revision_1 = require("./recipe-revision");
+async function saveLines(manager, domainId, recipeId, revisionId, inputs, outputs) {
+    const header = await manager.findOneByOrFail(recipe_revision_1.RecipeRevision, { id: revisionId, domain: { id: domainId } });
+    const route = header.route ? await manager.findOneBy(route_definition_1.RouteDefinition, { domain: { id: domainId }, name: header.route }) : null;
+    if (header.route && !route)
+        refuse('INVALID_RECIPE_REFERENCE', 'Route not found in this domain.');
+    for (const [entity, lines] of [[recipe_revision_line_1.RecipeRevisionInput, inputs], [recipe_revision_line_1.RecipeRevisionOutput, outputs]]) {
+        for (const [position, line] of lines.entries()) {
+            const material = await manager.findOneBy(material_definition_1.MaterialDefinition, { domain: { id: domainId }, name: line.material });
+            if (!material)
+                refuse('INVALID_RECIPE_REFERENCE', `Material not found: ${line.material}`);
+            const operation = line.operation ? await manager.findOneBy(operation_definition_1.OperationDefinition, { domain: { id: domainId }, name: line.operation }) : null;
+            if (line.operation && (!operation || !route?.steps.includes(line.operation)))
+                refuse('INVALID_RECIPE_REFERENCE', 'Input operation must exist in the selected route.');
+            const values = {
+                domain: { id: domainId }, recipe: { id: recipeId }, revision: { id: revisionId },
+                materialDefinition: { id: material.id }, material: material.name,
+                lineKey: line.lineKey, position, qty: line.qty
+            };
+            if (entity === recipe_revision_line_1.RecipeRevisionInput) {
+                await manager.save(recipe_revision_line_1.RecipeRevisionInput, manager.create(recipe_revision_line_1.RecipeRevisionInput, {
+                    ...values, operationDefinition: operation ? { id: operation.id } : null, operation: operation?.name ?? null
+                }));
+            }
+            else {
+                await manager.save(recipe_revision_line_1.RecipeRevisionOutput, manager.create(recipe_revision_line_1.RecipeRevisionOutput, values));
+            }
+        }
+    }
+}
+async function headerReferences(manager, domainId, content) {
+    const primaryMaterial = await manager.findOneBy(material_definition_1.MaterialDefinition, { domain: { id: domainId }, name: content.materialDefinitionName });
+    const routeDefinition = content.route ? await manager.findOneBy(route_definition_1.RouteDefinition, { domain: { id: domainId }, name: content.route }) : null;
+    if (!primaryMaterial || (content.route && !routeDefinition))
+        refuse('INVALID_RECIPE_REFERENCE');
+    return { primaryMaterial: { id: primaryMaterial.id }, routeDefinition: routeDefinition ? { id: routeDefinition.id } : null };
+}
+class RecipeRefusal extends shell_1.Refusal {
+    constructor(code, detail) {
+        super(code, {}, detail ?? RECIPE_REFUSALS[code] ?? 'The recipe change could not be applied.');
+    }
+}
+exports.RecipeRefusal = RecipeRefusal;
+const RECIPE_REFUSALS = {
+    TRANSACTION_REQUIRED: 'This change requires a transaction.',
+    INVALID_INSTANT: 'Enter a valid date and time including its time zone.',
+    INVALID_CONTENT: 'The proposed recipe content is invalid.',
+    INVALID_RECIPE_REFERENCE: 'A recipe material, operation or route is invalid in this domain.',
+    RECIPE_NOT_FOUND: 'The recipe does not exist in this domain.',
+    REVISION_NOT_FOUND: 'The revision does not exist in this domain.',
+    INVALID_BASE_REVISION: 'The proposed change is based on a different revision.',
+    DRAFT_NOT_OWNED: 'Only the draft author can edit or submit it.',
+    REVISION_FROZEN: 'This submitted revision cannot be edited. Create another draft.',
+    DRAFT_CONFLICT: 'The draft changed. Reload it before saving.',
+    PLAN_CONFLICT: 'The approved schedule changed. Review and submit a new draft.',
+    INVALID_SUBMISSION: 'The submitted content does not match the frozen revision.',
+    AUTHOR_CANNOT_APPROVE: 'The author cannot approve their own change.',
+    RETROACTIVE_IMPACT: 'This change would alter a recipe already used by a recorded execution.',
+    FUTURE_PLAN_CONFLICT: 'This change conflicts with an approved future schedule.',
+    NO_EFFECTIVE_REVISION: 'There is no published revision effective at the execution time.',
+    AMBIGUOUS_EFFECTIVITY: 'More than one revision is effective at the execution time.',
+    REVISION_INTEGRITY_FAILURE: 'The stored revision does not match its signed content.',
+    BASIS_CONFLICT: 'This execution already has a different recipe or execution time.',
+    APPROVAL_LINE_REQUIRED: 'Configure an approval line before submitting this change.',
+    REVISION_REQUIRED: 'Change the recipe through a revision draft.'
+};
+function refuse(code, detail) {
+    throw new RecipeRefusal(code, detail);
+}
+function transaction(manager) {
+    if (!manager.queryRunner?.isTransactionActive)
+        refuse('TRANSACTION_REQUIRED');
+}
+/** Current reads are required after waiting for the subject lock, including MySQL REPEATABLE READ. */
+function currentLock(manager) {
+    const driver = manager.connection.options.type;
+    return manager.queryRunner?.isTransactionActive && !['sqlite', 'better-sqlite3', 'sqljs'].includes(driver)
+        ? { lock: { mode: 'pessimistic_write' } }
+        : {};
+}
+function instant(value) {
+    if (!(value instanceof Date) && (typeof value !== 'string' || !/(Z|[+-]\d{2}:\d{2})$/.test(value)))
+        refuse('INVALID_INSTANT');
+    const result = new Date(value);
+    if (!Number.isFinite(result.getTime()))
+        refuse('INVALID_INSTANT');
+    return result;
+}
+function text(value, field) {
+    if (typeof value !== 'string' || !value.trim())
+        refuse('INVALID_CONTENT', field);
+    return value.trim();
+}
+/** Sorted object keys, ordered arrays, ISO instants. This is the v1 submission encoding. */
+function canonical(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return '[' + value.map(canonical).join(',') + ']';
+    return ('{' +
+        Object.keys(value)
+            .sort()
+            .map(key => JSON.stringify(key) + ':' + canonical(value[key]))
+            .join(',') +
+        '}');
+}
+function recipeSubmissionHash(revision) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(canonical({
+        schemaVersion: 1,
+        revisionNumber: revision.revisionNumber,
+        policyId: revision.policyId,
+        domainId: revision.domainId,
+        recipeId: revision.recipeId,
+        primaryMaterialId: revision.primaryMaterialId,
+        routeDefinitionId: revision.routeDefinitionId,
+        baseRevisionId: revision.baseRevisionId,
+        baseGeneration: revision.baseGeneration,
+        ...(0, recipe_revision_content_1.recipeContentValues)(revision),
+        inputReferences: revision.inputs.map(line => [line.lineKey, line.materialDefinitionId, line.operationDefinitionId]),
+        outputReferences: revision.outputs.map(line => [line.lineKey, line.materialDefinitionId]),
+        effectiveFrom: revision.effectiveFrom.toISOString(),
+        reason: revision.reason
+    }))
+        .digest('hex');
+}
+/** Display values are a checked projection of the frozen revision, never a second editable source. */
+async function recipeApprovalInput(manager, domainId, revisionId) {
+    const draft = await revision(manager, domainId, revisionId);
+    if (!draft.frozenAt || draft.contentHash !== recipeSubmissionHash(draft))
+        refuse('INVALID_SUBMISSION');
+    const recipe = await subject(manager, domainId, draft.recipeId);
+    const base = draft.baseRevisionId ? await revision(manager, domainId, draft.baseRevisionId) : null;
+    const plan = base ? await manager.findOneBy(recipe_revision_1.RecipePlan, {
+        domain: { id: domainId }, recipe: { id: draft.recipeId }, generation: draft.baseGeneration
+    }) : null;
+    const segment = plan && base ? await manager.findOneBy(recipe_revision_1.RecipeSegment, {
+        domain: { id: domainId }, plan: { id: plan.id }, revision: { id: base.id }
+    }) : null;
+    const values = (row) => ({
+        revisionNumber: row.revisionNumber, ...(0, recipe_revision_content_1.recipeContentValues)(row),
+        detail: {
+            revisionId: row.id, createdAt: row.createdAt.toISOString(), frozenAt: row.frozenAt?.toISOString(),
+            effectiveFrom: row.effectiveFrom.toISOString(), reason: row.reason,
+            ...(row.id === base?.id && segment ? { validFrom: segment.validFrom.toISOString(), validTo: segment.validTo?.toISOString() ?? null } : {})
+        }
+    });
+    return {
+        headline: recipe.name,
+        reason: draft.reason,
+        effectiveFrom: draft.effectiveFrom.toISOString(),
+        before: base ? values(base) : null,
+        after: values(draft),
+        revision: {
+            revisionId: draft.id,
+            hash: draft.contentHash,
+            recipeId: draft.recipeId,
+            baseGeneration: draft.baseGeneration
+        }
+    };
+}
+async function assertRecipeApprovalInput(manager, domainId, input) {
+    const reference = input?.revision;
+    if (typeof reference?.revisionId !== 'string')
+        refuse('INVALID_SUBMISSION');
+    const expected = await recipeApprovalInput(manager, domainId, reference.revisionId);
+    for (const key of Object.keys(expected)) {
+        if (canonical(input[key]) !== canonical(expected[key]))
+            refuse('INVALID_SUBMISSION');
+    }
+}
+async function subject(manager, domainId, recipeId) {
+    const recipe = await manager.findOne(recipe_definition_1.RecipeDefinition, {
+        where: { id: recipeId, domain: { id: domainId } },
+        ...currentLock(manager)
+    });
+    if (!recipe)
+        refuse('RECIPE_NOT_FOUND');
+    return recipe;
+}
+async function revision(manager, domainId, revisionId, locked = true) {
+    const found = await manager.findOne(recipe_revision_1.RecipeRevision, {
+        where: { id: revisionId, domain: { id: domainId } },
+        relations: { inputs: true, outputs: true },
+        ...(locked ? currentLock(manager) : {})
+    });
+    if (!found)
+        refuse('REVISION_NOT_FOUND');
+    found.inputs.sort((a, b) => a.position - b.position);
+    found.outputs.sort((a, b) => a.position - b.position);
+    return found;
+}
+/** A write lock valid on every supported SQL backend, including SQLite (no SELECT FOR UPDATE). */
+async function lockSubject(manager, domainId, recipeId) {
+    transaction(manager);
+    const locked = await manager
+        .createQueryBuilder()
+        .update(recipe_definition_1.RecipeDefinition)
+        .set({ revisionLock: () => 'revision_lock + 1' })
+        .where({ id: recipeId, domain: { id: domainId } })
+        .execute();
+    if (locked.affected !== 1)
+        refuse('RECIPE_NOT_FOUND');
+    return subject(manager, domainId, recipeId);
+}
+async function createRecipeDraft(manager, domainId, creatorId, asked) {
+    transaction(manager);
+    const accepted = (0, recipe_revision_content_1.readRecipeContent)(asked.content);
+    const policy = await (0, master_change_policy_1.masterChangePolicy)(manager, domainId, 'recipeDefinition');
+    let recipe;
+    if (asked.recipeId) {
+        recipe = await lockSubject(manager, domainId, asked.recipeId);
+    }
+    else {
+        recipe = await manager.save(recipe_definition_1.RecipeDefinition, manager.create(recipe_definition_1.RecipeDefinition, {
+            domain: { id: domainId },
+            name: text(asked.name, 'name'),
+            materialDefinitionName: accepted.materialDefinitionName,
+            inputs: [],
+            outputs: [],
+            planGeneration: 0,
+            revisionLock: 0,
+            creator: { id: creatorId },
+            updater: { id: creatorId }
+        }));
+    }
+    const previous = await manager.findOne(recipe_revision_1.RecipeRevision, {
+        where: { domain: { id: domainId }, recipe: { id: recipe.id } }, order: { revisionNumber: 'DESC' },
+        ...currentLock(manager)
+    });
+    const revisionNumber = (previous?.revisionNumber ?? 0) + 1;
+    let baseRevisionId = null;
+    if (recipe.planGeneration > 0) {
+        baseRevisionId = (await resolveRecipe(manager, domainId, recipe.id, accepted.effectiveFrom)).revision.id;
+    }
+    if (asked.baseRevisionId && asked.baseRevisionId !== baseRevisionId)
+        refuse('INVALID_BASE_REVISION');
+    const { inputs, outputs, ...header } = accepted;
+    const saved = await manager.save(recipe_revision_1.RecipeRevision, manager.create(recipe_revision_1.RecipeRevision, {
+        ...header,
+        ...await headerReferences(manager, domainId, accepted),
+        policy: { id: policy.id },
+        domain: { id: domainId },
+        recipe: { id: recipe.id },
+        baseRevision: baseRevisionId ? { id: baseRevisionId } : null,
+        baseGeneration: recipe.planGeneration,
+        revisionNumber,
+        editGeneration: 0,
+        creator: { id: creatorId },
+        createdAt: new Date(),
+        frozenAt: null,
+        contentHash: null,
+        activityInstanceId: null
+    }));
+    await saveLines(manager, domainId, recipe.id, saved.id, inputs, outputs);
+    return revision(manager, domainId, saved.id);
+}
+async function editRecipeDraft(manager, domainId, actorId, revisionId, expectedEditGeneration, input) {
+    transaction(manager);
+    const accepted = (0, recipe_revision_content_1.readRecipeContent)(input);
+    const initial = await revision(manager, domainId, revisionId, false);
+    const recipe = await lockSubject(manager, domainId, initial.recipeId);
+    const draft = await revision(manager, domainId, revisionId);
+    if (draft.creatorId !== actorId)
+        refuse('DRAFT_NOT_OWNED');
+    if (draft.frozenAt)
+        refuse('REVISION_FROZEN');
+    if (draft.baseGeneration !== recipe.planGeneration)
+        refuse('PLAN_CONFLICT');
+    // Moving the effective date across a scheduled boundary changes the before-image.
+    const baseRevisionId = recipe.planGeneration > 0
+        ? (await resolveRecipe(manager, domainId, recipe.id, accepted.effectiveFrom)).revision.id
+        : null;
+    const { inputs, outputs, ...header } = accepted;
+    const updated = await manager
+        .createQueryBuilder()
+        .update(recipe_revision_1.RecipeRevision)
+        .set({
+        ...header,
+        ...await headerReferences(manager, domainId, accepted),
+        baseRevision: baseRevisionId ? { id: baseRevisionId } : null,
+        editGeneration: expectedEditGeneration + 1
+    })
+        .where({
+        id: revisionId,
+        domain: { id: domainId },
+        creator: { id: actorId },
+        editGeneration: expectedEditGeneration
+    })
+        .andWhere('frozen_at IS NULL')
+        .execute();
+    if (updated.affected !== 1)
+        refuse('DRAFT_CONFLICT');
+    await manager.delete(recipe_revision_line_1.RecipeRevisionInput, { revision: { id: revisionId }, domain: { id: domainId } });
+    await manager.delete(recipe_revision_line_1.RecipeRevisionOutput, { revision: { id: revisionId }, domain: { id: domainId } });
+    await saveLines(manager, domainId, recipe.id, revisionId, inputs, outputs);
+    return revision(manager, domainId, revisionId);
+}
+/** Product calls this in the same transaction as issuing its worklist approval. */
+async function freezeRecipeDraft(manager, domainId, actorId, revisionId, expectedEditGeneration) {
+    const initial = await revision(manager, domainId, revisionId, false);
+    const recipe = await lockSubject(manager, domainId, initial.recipeId);
+    const draft = await revision(manager, domainId, revisionId);
+    if (draft.creatorId !== actorId)
+        refuse('DRAFT_NOT_OWNED');
+    if (draft.frozenAt)
+        refuse('REVISION_FROZEN');
+    if (draft.editGeneration !== expectedEditGeneration)
+        refuse('DRAFT_CONFLICT');
+    if (draft.baseGeneration !== recipe.planGeneration)
+        refuse('PLAN_CONFLICT');
+    const policy = await (0, master_change_policy_1.masterChangePolicy)(manager, domainId, 'recipeDefinition');
+    if (draft.policyId !== policy.id)
+        refuse('PLAN_CONFLICT');
+    (0, recipe_revision_content_1.readRecipeContent)(draft);
+    const contentHash = recipeSubmissionHash(draft);
+    await manager.update(recipe_revision_1.RecipeRevision, { id: revisionId, domain: { id: domainId } }, { frozenAt: new Date(), contentHash });
+    return revision(manager, domainId, revisionId);
+}
+async function bindRecipeApproval(manager, domainId, revisionId, activityInstanceId) {
+    transaction(manager);
+    const initial = await revision(manager, domainId, revisionId, false);
+    await lockSubject(manager, domainId, initial.recipeId);
+    const draft = await revision(manager, domainId, revisionId);
+    if (!draft.frozenAt || draft.activityInstanceId)
+        refuse('INVALID_SUBMISSION');
+    await manager.update(recipe_revision_1.RecipeRevision, { id: revisionId, domain: { id: domainId } }, { activityInstanceId: text(activityInstanceId, 'activityInstanceId') });
+}
+/** Internal completion callback only. Never expose this as an approved=true mutation. */
+async function publishRecipeRevision(manager, domainId, revisionId, decision) {
+    return publishRevision(manager, domainId, revisionId, {
+        kind: 'approved',
+        activityInstanceId: decision.activityInstanceId,
+        actorId: decision.approverId,
+        submissionHash: decision.submissionHash
+    });
+}
+async function publishUnregulatedRecipe(manager, domainId, actorId, revisionId, editGeneration) {
+    transaction(manager);
+    const initial = await revision(manager, domainId, revisionId, false);
+    await lockSubject(manager, domainId, initial.recipeId);
+    const policy = await (0, master_change_policy_1.masterChangePolicy)(manager, domainId, 'recipeDefinition');
+    if (policy.approvalRequired)
+        throw new shell_1.Refusal('MASTER_APPROVAL_REQUIRED', {}, 'This change requires product approval.');
+    const prior = await manager.findOneBy(recipe_revision_1.RecipePlan, {
+        domain: { id: domainId },
+        publishedRevision: { id: revisionId },
+        releaseKind: 'policy'
+    });
+    if (prior) {
+        if (prior.publisherId !== actorId)
+            refuse('DRAFT_NOT_OWNED');
+        return prior;
+    }
+    const frozen = await freezeRecipeDraft(manager, domainId, actorId, revisionId, editGeneration);
+    return publishRevision(manager, domainId, revisionId, { kind: 'policy', actorId, submissionHash: frozen.contentHash });
+}
+async function publishRevision(manager, domainId, revisionId, decision) {
+    const initial = await revision(manager, domainId, revisionId, false);
+    const recipe = await lockSubject(manager, domainId, initial.recipeId);
+    const draft = await revision(manager, domainId, revisionId);
+    if (!draft.frozenAt ||
+        (decision.kind === 'approved'
+            ? draft.activityInstanceId !== decision.activityInstanceId
+            : !!draft.activityInstanceId) ||
+        draft.contentHash !== decision.submissionHash ||
+        recipeSubmissionHash(draft) !== decision.submissionHash)
+        refuse('INVALID_SUBMISSION');
+    const policy = await (0, master_change_policy_1.masterChangePolicy)(manager, domainId, 'recipeDefinition');
+    if (draft.policyId !== policy.id)
+        refuse('PLAN_CONFLICT');
+    if (policy.approvalRequired !== (decision.kind === 'approved'))
+        throw new shell_1.Refusal('MASTER_APPROVAL_POLICY_MISMATCH', {}, 'Use the publication path required by the domain policy.');
+    if (decision.kind === 'approved' && draft.creatorId === decision.actorId)
+        refuse('AUTHOR_CANNOT_APPROVE');
+    text(decision.actorId, 'publisher');
+    const previousDecision = await manager.findOne(recipe_revision_1.RecipePlan, {
+        where: { domain: { id: domainId }, publishedRevision: { id: revisionId } },
+        ...currentLock(manager)
+    });
+    if (previousDecision)
+        return previousDecision;
+    if (draft.baseGeneration !== recipe.planGeneration)
+        refuse('PLAN_CONFLICT');
+    // Only replacement from effectiveFrom onward is supported in this slice, not arbitrary rescheduling.
+    if (await manager.findOne(recipe_revision_1.RecipeBasis, {
+        where: { domain: { id: domainId }, recipe: { id: recipe.id }, businessTime: (0, typeorm_1.MoreThanOrEqual)(draft.effectiveFrom) },
+        ...currentLock(manager)
+    }))
+        refuse('RETROACTIVE_IMPACT');
+    const oldPlan = await manager.findOne(recipe_revision_1.RecipePlan, {
+        where: { domain: { id: domainId }, recipe: { id: recipe.id }, generation: recipe.planGeneration },
+        ...currentLock(manager)
+    });
+    if (recipe.planGeneration > 0 && !oldPlan)
+        refuse('PLAN_CONFLICT');
+    const oldSegments = oldPlan
+        ? await manager.find(recipe_revision_1.RecipeSegment, {
+            where: { domain: { id: domainId }, recipe: { id: recipe.id }, plan: { id: oldPlan.id } },
+            order: { validFrom: 'ASC' },
+            ...currentLock(manager)
+        })
+        : [];
+    // Do not silently erase an already approved future appointment.
+    if (oldSegments.some(segment => segment.validFrom >= draft.effectiveFrom))
+        refuse('FUTURE_PLAN_CONFLICT');
+    const recordedAt = new Date();
+    const plan = await manager.save(recipe_revision_1.RecipePlan, manager.create(recipe_revision_1.RecipePlan, {
+        domain: { id: domainId },
+        recipe: { id: recipe.id },
+        generation: recipe.planGeneration + 1,
+        recordedAt,
+        activityInstanceId: decision.activityInstanceId ?? null,
+        submissionHash: decision.submissionHash,
+        approver: decision.kind === 'approved' ? { id: decision.actorId } : null,
+        publisher: { id: decision.actorId },
+        releaseKind: decision.kind,
+        publishedRevision: { id: revisionId },
+        policy: { id: policy.id }
+    }));
+    for (const old of oldSegments) {
+        await manager.save(recipe_revision_1.RecipeSegment, manager.create(recipe_revision_1.RecipeSegment, {
+            domain: { id: domainId },
+            recipe: { id: recipe.id },
+            plan: { id: plan.id },
+            revision: { id: old.revisionId },
+            validFrom: old.validFrom,
+            validTo: !old.validTo || old.validTo > draft.effectiveFrom ? draft.effectiveFrom : old.validTo
+        }));
+    }
+    await manager.save(recipe_revision_1.RecipeSegment, manager.create(recipe_revision_1.RecipeSegment, {
+        domain: { id: domainId },
+        recipe: { id: recipe.id },
+        plan: { id: plan.id },
+        revision: { id: revisionId },
+        validFrom: draft.effectiveFrom,
+        validTo: null
+    }));
+    const advanced = await manager.update(recipe_definition_1.RecipeDefinition, { id: recipe.id, domain: { id: domainId }, planGeneration: recipe.planGeneration }, { planGeneration: plan.generation });
+    if (advanced.affected !== 1)
+        refuse('PLAN_CONFLICT');
+    return plan;
+}
+async function resolveRecipe(manager, domainId, recipeId, businessTime, knownAt = new Date()) {
+    const at = instant(businessTime);
+    const known = instant(knownAt);
+    const plan = await manager.findOne(recipe_revision_1.RecipePlan, {
+        where: { domain: { id: domainId }, recipe: { id: recipeId }, recordedAt: (0, typeorm_1.LessThanOrEqual)(known) },
+        order: { generation: 'DESC' },
+        ...currentLock(manager)
+    });
+    if (!plan)
+        refuse('NO_EFFECTIVE_REVISION');
+    const query = manager
+        .createQueryBuilder(recipe_revision_1.RecipeSegment, 'segment')
+        .where({ domain: { id: domainId }, recipe: { id: recipeId }, plan: { id: plan.id } })
+        .andWhere('segment.validFrom <= :at', { at })
+        .andWhere('(segment.validTo IS NULL OR segment.validTo > :at)', { at });
+    if (currentLock(manager).lock)
+        query.setLock('pessimistic_write');
+    const segments = await query.getMany();
+    if (segments.length !== 1)
+        refuse(segments.length ? 'AMBIGUOUS_EFFECTIVITY' : 'NO_EFFECTIVE_REVISION');
+    const selected = await revision(manager, domainId, segments[0].revisionId);
+    if (!selected.frozenAt || selected.contentHash !== recipeSubmissionHash(selected))
+        refuse('REVISION_INTEGRITY_FAILURE');
+    return { revision: selected, plan, segment: segments[0] };
+}
+/** Replay reads verify the captured digest too, not only the currently effective schedule. */
+async function recipeRevisionForBasis(manager, domainId, basis) {
+    if (basis.domainId !== domainId)
+        refuse('BASIS_CONFLICT');
+    const selected = await revision(manager, domainId, basis.revisionId);
+    if (selected.recipeId !== basis.recipeId || !selected.frozenAt || selected.contentHash !== basis.contentHash || recipeSubmissionHash(selected) !== basis.contentHash) {
+        refuse('REVISION_INTEGRITY_FAILURE');
+    }
+    if (selected.routeDefinitionId ? (basis.routeSnapshot?.id !== selected.routeDefinitionId ||
+        basis.routeHash !== (0, node_crypto_1.createHash)('sha256').update(canonical(basis.routeSnapshot)).digest('hex')) : (basis.routeSnapshot !== null || basis.routeHash !== null))
+        refuse('REVISION_INTEGRITY_FAILURE');
+    return selected;
+}
+/** Must run inside the transaction that writes the execution result. */
+async function captureRecipeBasis(manager, domainId, recipeId, recordKey, businessTime) {
+    const at = instant(businessTime);
+    await lockSubject(manager, domainId, recipeId);
+    const existing = await manager.findOne(recipe_revision_1.RecipeBasis, {
+        where: { domain: { id: domainId }, recordKey },
+        ...currentLock(manager)
+    });
+    if (existing) {
+        if (existing.recipeId !== recipeId || existing.businessTime.getTime() !== at.getTime())
+            refuse('BASIS_CONFLICT');
+        await recipeRevisionForBasis(manager, domainId, existing);
+        return existing;
+    }
+    const resolvedAt = new Date();
+    const selected = await resolveRecipe(manager, domainId, recipeId, at, resolvedAt);
+    const route = selected.revision.routeDefinitionId ? await manager.findOne(route_definition_1.RouteDefinition, {
+        where: { id: selected.revision.routeDefinitionId, domain: { id: domainId } }, ...currentLock(manager)
+    }) : null;
+    if (selected.revision.routeDefinitionId && (!route ||
+        (route.effectiveStart && route.effectiveStart > at) || (route.effectiveEnd && route.effectiveEnd <= at)))
+        refuse('INVALID_RECIPE_REFERENCE', 'The referenced route is not effective at execution time.');
+    if (selected.revision.inputs.some(line => line.operation && !route?.steps.includes(line.operation)))
+        refuse('INVALID_RECIPE_REFERENCE', 'The current route no longer contains a required input operation.');
+    const routeSnapshot = route ? {
+        id: route.id, name: route.name, steps: route.steps, procedure: route.procedure ?? null
+    } : null;
+    const saved = await manager.save(recipe_revision_1.RecipeBasis, manager.create(recipe_revision_1.RecipeBasis, {
+        domain: { id: domainId },
+        recipe: { id: recipeId },
+        recordKey: text(recordKey, 'recordKey'),
+        businessTime: at,
+        resolvedAt,
+        routeSnapshot,
+        routeHash: routeSnapshot ? (0, node_crypto_1.createHash)('sha256').update(canonical(routeSnapshot)).digest('hex') : null,
+        revision: { id: selected.revision.id },
+        contentHash: selected.revision.contentHash,
+        plan: { id: selected.plan.id }
+    }));
+    return manager.findOneByOrFail(recipe_revision_1.RecipeBasis, { id: saved.id, domain: { id: domainId } });
+}
+async function recipeRevisionOverview(manager, domainId, recipeId, at = new Date()) {
+    const recipe = await subject(manager, domainId, recipeId);
+    const revisions = await manager.find(recipe_revision_1.RecipeRevision, {
+        where: { domain: { id: domainId }, recipe: { id: recipeId } },
+        relations: { inputs: true, outputs: true },
+        order: { createdAt: 'ASC', id: 'ASC' }
+    });
+    const plan = await manager.findOne(recipe_revision_1.RecipePlan, {
+        where: { domain: { id: domainId }, recipe: { id: recipeId }, generation: recipe.planGeneration }
+    });
+    const schedule = plan
+        ? await manager.find(recipe_revision_1.RecipeSegment, {
+            where: { domain: { id: domainId }, recipe: { id: recipeId }, plan: { id: plan.id } },
+            order: { validFrom: 'ASC' }
+        })
+        : [];
+    return {
+        recipeId,
+        name: recipe.name,
+        generation: recipe.planGeneration,
+        at: at.toISOString(),
+        schedule: schedule.map(segment => ({
+            ...segment,
+            state: segment.validFrom > at ? 'scheduled' : segment.validTo && segment.validTo <= at ? 'expired' : 'current'
+        })),
+        revisions: revisions.map(item => ({ ...item,
+            inputs: item.inputs.sort((a, b) => a.position - b.position),
+            outputs: item.outputs.sort((a, b) => a.position - b.position),
+            state: item.frozenAt ? 'frozen' : 'draft' }))
+    };
+}
+/** Read-time projection, never a clock-driven rewrite of the identity row. */
+async function effectiveRecipe(manager, domainId, recipe, at = new Date()) {
+    const selected = await resolveRecipe(manager, domainId, recipe.id, at);
+    return Object.assign(new recipe_definition_1.RecipeDefinition(), recipe, {
+        description: selected.revision.description,
+        ...(0, recipe_revision_content_1.recipeContentValues)(selected.revision),
+        effectiveStart: selected.segment.validFrom,
+        effectiveEnd: selected.segment.validTo ?? undefined
+    });
+}
+//# sourceMappingURL=recipe-revision-service.js.map