@things-factory/ops-master 10.1.247 → 10.1.248

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

@@ -1,754 +0,0 @@
-"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.standRecipeBaselines = standRecipeBaselines;
-exports.recipeRevisionForBasis = recipeRevisionForBasis;
-exports.captureRecipeBasis = captureRecipeBasis;
-exports.recipeRevisionOverview = recipeRevisionOverview;
-exports.effectiveRecipe = effectiveRecipe;
-exports.saveAndPublishRecipe = saveAndPublishRecipe;
-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");
-const approval_input_1 = require("../master-change-approval/approval-input");
-const row_lock_1 = require("../row-lock");
-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');
-}
-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;
-    /*
-     * How the base was published (2026-10-20) — the approval screen names a baseline base in plain words. Only the
-     * base carries it: it was published before this draft existed and never changes, so the snapshot stays pinned.
-     * The proposal is unpublished here and would read differently once published.
-     */
-    const basePlan = base ? await manager.findOneBy(recipe_revision_1.RecipePlan, { domain: { id: domainId }, publishedRevision: { 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 ? { releaseKind: basePlan?.releaseKind ?? null } : {}),
-            ...(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);
-    if (!(0, approval_input_1.approvalInputMatches)(input, expected))
-        refuse('INVALID_SUBMISSION');
-}
-async function subject(manager, domainId, recipeId) {
-    const recipe = await manager.findOne(recipe_definition_1.RecipeDefinition, {
-        where: { id: recipeId, domain: { id: domainId } },
-        ...(0, row_lock_1.writeLockOn)(manager, recipe_definition_1.RecipeDefinition)
-    });
-    if (!recipe)
-        refuse('RECIPE_NOT_FOUND');
-    // Compare the current head and latest persisted plan in one SQL snapshot. A historical
-    // knownAt query must not compare its selected old plan with the current head.
-    const head = await manager.createQueryBuilder(recipe_definition_1.RecipeDefinition, 'head')
-        .leftJoin(recipe_revision_1.RecipePlan, 'plan', 'plan.recipe = head.id AND plan.domain = head.domain')
-        .select('head.planGeneration', 'generation')
-        .addSelect('MAX(plan.generation)', 'latest')
-        .where({ id: recipeId, domain: { id: domainId } })
-        .groupBy('head.id').addGroupBy('head.planGeneration')
-        .getRawOne();
-    if (!head || Number(head.generation) !== Number(head.latest ?? 0)) {
-        throw new shell_1.Refusal('PLAN_INTEGRITY_FAILURE', {}, 'The current plan generation does not match the latest published plan. Contact an administrator.');
-    }
-    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 ? (0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipeRevision) : {})
-    });
-    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' },
-        ...(0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipeRevision)
-    });
-    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 } },
-        ...(0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipePlan)
-    });
-    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) },
-        ...(0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipeBasis)
-    }))
-        refuse('RETROACTIVE_IMPACT');
-    const oldPlan = await manager.findOne(recipe_revision_1.RecipePlan, {
-        where: { domain: { id: domainId }, recipe: { id: recipe.id }, generation: recipe.planGeneration },
-        ...(0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipePlan)
-    });
-    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' },
-            ...(0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipeSegment)
-        })
-        : [];
-    // 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' },
-        ...(0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipePlan)
-    });
-    if (!plan)
-        refuse('NO_EFFECTIVE_REVISION');
-    await subject(manager, domainId, recipeId);
-    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 });
-    (0, row_lock_1.lockRowsOf)(manager, query);
-    const segments = await query.getMany();
-    if (!segments.length)
-        await refuseBeforeBaseline(manager, domainId, recipeId, at);
-    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] };
-}
-/** 기준선보다 앞선 시각은 모른다고 말한다 — 검사 명세의 같은 자리를 보라(2026-09-24). */
-async function refuseBeforeBaseline(manager, domainId, recipeId, at) {
-    const first = await manager.findOneBy(recipe_revision_1.RecipePlan, {
-        domain: { id: domainId }, recipe: { id: recipeId }, generation: 1, releaseKind: 'baseline'
-    });
-    if (!first)
-        return;
-    const recorded = await manager.findOneBy(recipe_revision_1.RecipeRevision, { domain: { id: domainId }, id: first.publishedRevisionId });
-    if (recorded && at < recorded.effectiveFrom)
-        throw new shell_1.Refusal('BEFORE_BASELINE', { baselineAt: recorded.effectiveFrom.toISOString() }, `This master was first recorded at ${recorded.effectiveFrom.toISOString()}; nothing is known about it before then.`);
-}
-/**
- * **개정본이 하나도 없는 제조법**마다 지금 서 있는 행을 첫 개정본으로 적는다 — 기준선(2026-09-24).
- * 규칙은 검사 명세의 `standTestSpecificationBaselines` 와 같다. 제조법만의 것 둘:
- *
- * - 옛 행의 줄에는 `lineKey` 가 없다. **자리로 붙인다** — `input-1` · `output-1`. plant 시드가 쓰는 규칙과
- *   같고, 줄의 차례가 뜻을 가지는 모델이라 자리에서 온 키는 내용을 바꾸지 않는다.
- * - 품목 · 공정 · 경로는 이름으로 가리킨다. **쓰기 전에 전부 대조한다** — 줄을 쓰다가 거절되면 반쯤 쓴
- *   개정본이 트랜잭션에 남는다. 없는 것을 가리키는 행은 세우지 않고 까닭을 남긴다.
- */
-async function standRecipeBaselines(manager, domainId, at, edition) {
-    transaction(manager);
-    const roots = await manager
-        .createQueryBuilder(recipe_definition_1.RecipeDefinition, 'recipe')
-        .leftJoin(recipe_revision_1.RecipeRevision, 'rev', 'rev.recipe_id = recipe.id AND rev.domain_id = recipe.domain_id')
-        .where('recipe.domain_id = :domainId', { domainId })
-        .andWhere('rev.id IS NULL')
-        .getMany();
-    const outcome = { stood: 0, unreadable: [] };
-    if (!roots.length)
-        return outcome;
-    const policy = await (0, master_change_policy_1.masterChangePolicy)(manager, domainId, 'recipeDefinition');
-    const where = { where: { domain: { id: domainId } } };
-    const materials = new Set((await manager.find(material_definition_1.MaterialDefinition, where)).map(one => one.name));
-    const operations = new Set((await manager.find(operation_definition_1.OperationDefinition, where)).map(one => one.name));
-    const routes = new Map((await manager.find(route_definition_1.RouteDefinition, where)).map(one => [one.name, one]));
-    const keyed = (rows, side) => Array.isArray(rows) ? rows.map((row, index) => ({ ...row, lineKey: row?.lineKey ?? `${side}-${index + 1}` })) : rows;
-    for (const root of roots) {
-        if (root.planGeneration !== 0) {
-            outcome.unreadable.push({ name: root.name, problem: 'plan without revision' });
-            continue;
-        }
-        let read;
-        try {
-            read = (0, recipe_revision_content_1.recipeContentValues)({
-                materialDefinitionName: root.materialDefinitionName,
-                description: root.description ?? null,
-                route: root.route ?? null,
-                inputs: keyed(root.inputs, 'input'),
-                outputs: keyed(root.outputs, 'output')
-            });
-        }
-        catch (error) {
-            outcome.unreadable.push({ name: root.name, problem: error?.message ?? String(error) });
-            continue;
-        }
-        const route = read.route ? routes.get(read.route) : null;
-        const missing = [
-            ...(materials.has(read.materialDefinitionName) ? [] : [`material ${read.materialDefinitionName}`]),
-            ...(read.route && !route ? [`route ${read.route}`] : []),
-            ...[...read.inputs, ...read.outputs].filter(line => !materials.has(line.material)).map(line => `material ${line.material}`),
-            ...read.inputs
-                .filter(line => line.operation && (!operations.has(line.operation) || !route?.steps.includes(line.operation)))
-                .map(line => `operation ${line.operation} in route ${read.route ?? '(none)'}`)
-        ];
-        if (missing.length) {
-            outcome.unreadable.push({ name: root.name, problem: 'points at what this domain does not have: ' + [...new Set(missing)].join(', ') });
-            continue;
-        }
-        const validFrom = root.effectiveStart && root.effectiveStart > at ? root.effectiveStart : at;
-        const validTo = root.effectiveEnd ?? null;
-        const { inputs, outputs, ...header } = read;
-        const saved = await manager.save(recipe_revision_1.RecipeRevision, manager.create(recipe_revision_1.RecipeRevision, {
-            ...header,
-            effectiveFrom: validFrom,
-            reason: `baseline: the row as it stood, recorded by ${edition}`,
-            ...await headerReferences(manager, domainId, read),
-            policy: { id: policy.id },
-            domain: { id: domainId },
-            recipe: { id: root.id },
-            baseRevision: null,
-            baseGeneration: 0,
-            revisionNumber: 1,
-            editGeneration: 0,
-            creator: null,
-            createdAt: at,
-            frozenAt: at,
-            contentHash: null,
-            activityInstanceId: null
-        }));
-        await saveLines(manager, domainId, root.id, saved.id, inputs, outputs);
-        const stood = await revision(manager, domainId, saved.id);
-        const contentHash = recipeSubmissionHash(stood);
-        await manager.update(recipe_revision_1.RecipeRevision, { id: stood.id, domain: { id: domainId } }, { contentHash });
-        const plan = await manager.save(recipe_revision_1.RecipePlan, manager.create(recipe_revision_1.RecipePlan, {
-            domain: { id: domainId },
-            recipe: { id: root.id },
-            generation: 1,
-            recordedAt: at,
-            activityInstanceId: null,
-            submissionHash: contentHash,
-            approver: null,
-            publisher: null,
-            releaseKind: 'baseline',
-            publishedRevision: { id: stood.id },
-            policy: { id: policy.id }
-        }));
-        if (!validTo || validTo > validFrom) {
-            await manager.save(recipe_revision_1.RecipeSegment, manager.create(recipe_revision_1.RecipeSegment, {
-                domain: { id: domainId },
-                recipe: { id: root.id },
-                plan: { id: plan.id },
-                revision: { id: stood.id },
-                validFrom,
-                validTo
-            }));
-        }
-        const advanced = await manager.update(recipe_definition_1.RecipeDefinition, { id: root.id, domain: { id: domainId }, planGeneration: 0 }, { planGeneration: 1 });
-        if (advanced.affected !== 1)
-            refuse('PLAN_CONFLICT');
-        outcome.stood++;
-    }
-    return outcome;
-}
-/** 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 },
-        ...(0, row_lock_1.writeLockOn)(manager, recipe_revision_1.RecipeBasis)
-    });
-    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 } }, ...(0, row_lock_1.writeLockOn)(manager, route_definition_1.RouteDefinition)
-    }) : 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' }
-        })
-        : [];
-    /*
-     * 개정본마다 **어떻게 발행됐는지**(`releaseKind`)를 함께 싣는다 — 발행한 적용계획의 값 그대로(2026-10-20).
-     * 화면은 이것으로 기준선을 알아보고 사람의 말(「최초 기록」)로 적는다. 기준선의 사유는 서버가 쓴 기록
-     * 문장인데 해시에 들어가 바꿀 수 없고, 문구로 알아보면 깨지기 쉽다. 발행 전 개정본은 null.
-     */
-    const kindOf = (0, approval_input_1.releaseKinds)(await manager.findBy(recipe_revision_1.RecipePlan, { domain: { id: domainId }, recipe: { id: recipeId } }));
-    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',
-            releaseKind: kindOf(item.id) }))
-    };
-}
-/** 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
-    });
-}
-/**
- * **비규제 사업장의 「저장」 한 번** — 초안을 만들고 바로 발행한다, 한 트랜잭션에서(ADR-0086 09-22 보탬).
- * 비규제면 사람이 누를 것은 저장 하나다. 두 걸음(초안 저장 → 발행)이 구조상 필연인 것처럼 보이게 하지 않는다.
- * 이 축이 승인제면 발행이 `MASTER_APPROVAL_REQUIRED` 로 거절되고, 같은 트랜잭션이라 초안도 함께 물러난다 —
- * 반쯤 저장된 것이 남지 않는다. 개정본 · 적용계획 · 구간은 두 걸음 때와 똑같이 선다.
- */
-async function saveAndPublishRecipe(manager, domainId, actorId, asked) {
-    // Reuse the owned draft and its concurrency guard; publishing failure rolls back the edit too.
-    if (asked.revisionId && !Number.isInteger(asked.editGeneration))
-        refuse('DRAFT_CONFLICT');
-    const draft = asked.revisionId
-        ? await editRecipeDraft(manager, domainId, actorId, asked.revisionId, asked.editGeneration, asked.content)
-        : await createRecipeDraft(manager, domainId, actorId, asked);
-    const plan = await publishUnregulatedRecipe(manager, domainId, actorId, draft.id, draft.editGeneration);
-    return { revision: await revision(manager, domainId, draft.id, false), plan };
-}
-//# sourceMappingURL=recipe-revision-service.js.map