@aglyn/aglyn 1.0.0-beta.221 → 1.0.0-beta.222

package/src/lib/data-transfer/plan.d.ts

@@ -0,0 +1,176 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { FieldDerivation, FieldProblem } from './derive';
+import type { RowMatchOutcome } from './match';
+import type { FieldPolicyOutcome, TransferFieldMode, TransferPolicy, TransferPolicySource, TransferValuesComparator } from './policy';
+import type { TransferField } from './resource';
+/** What a row will do. */
+export type TransferRowVerdict = 'create' | 'update' | 'unchanged' | 'skip' | 'fail';
+export declare const TRANSFER_ROW_VERDICTS: readonly TransferRowVerdict[];
+/** Why a row is skipped or fails. */
+export type TransferRowReason = 'matchedSkipped' | 'newSkipped' | 'skippedByChoice' | 'ambiguousSkipped' | 'ambiguousUnresolved' | 'duplicateInFile' | 'missingRequired' | 'refusedValue' | 'matchedRecordMissing' | 'planLimit' | 'resourceRule';
+/** A class of thing the person is warned about. */
+export type TransferWarningClass = 'derivation' | 'ambiguousDate' | 'unmatchedPicklist' | 'newPicklistValue' | 'unresolvedLookup' | 'ambiguousMatch' | 'duplicateInFile' | 'lockedRule' | 'droppedCell' | 'overwriteNonBlank' | 'clearValue' | 'planLimit'
+/**
+ * What the owning plugin's own checks found in the file — a column, an
+ * address, a count — named in each sample's `detail`. Raised by a
+ * resource's `plan`, never by the core.
+ */
+ | 'screening'
+/**
+ * The owning plugin's finding about one row — a rule no field policy can
+ * say — folded in by `withTransferResourceFindings`; it may refuse the row.
+ */
+ | 'resourceRule';
+export declare const TRANSFER_WARNING_CLASSES: readonly TransferWarningClass[];
+/**
+ * The classes that always need an acknowledgement. `derivation` needs one
+ * only when it holds a flagged guess; every other class is a change to data
+ * or a row held back, and the person says they have seen it.
+ */
+export declare const ACKNOWLEDGED_WARNING_CLASSES: readonly TransferWarningClass[];
+/**
+ * Something an earlier step of the wizard decided about a row: a picklist
+ * value that was added, left blank or refuses the row; a lookup that did
+ * not resolve. `refuse` fails the row.
+ */
+export interface TransferRowNote {
+    class: Extract<TransferWarningClass, 'unmatchedPicklist' | 'newPicklistValue' | 'unresolvedLookup'>;
+    fieldId: string;
+    value: string;
+    refuse?: boolean;
+    detail?: string;
+}
+/** One row as the plan takes it. */
+export interface TransferPlanRow {
+    /** Its index in the file. */
+    index: number;
+    /** Field id → value; `null` for a mapped blank cell; absent for unmapped. */
+    values: Readonly<Record<string, unknown>>;
+    derivations?: readonly FieldDerivation[];
+    problems?: readonly FieldProblem[];
+    notes?: readonly TransferRowNote[];
+}
+/** One field a row changes. */
+export interface TransferFieldChange {
+    fieldId: string;
+    before: unknown;
+    after: unknown;
+    mode: TransferFieldMode;
+    source: TransferPolicySource;
+    rule: FieldPolicyOutcome['rule'];
+}
+/** One row's verdict. */
+export interface PlannedTransferRow {
+    index: number;
+    verdict: TransferRowVerdict;
+    /** The record updated (or `null` for a create). */
+    recordId: string | null;
+    reason?: TransferRowReason;
+    /** Required fields a create lacked. */
+    missing?: string[];
+    /** Fields that change, before → after; on a create, `before` is `null`. */
+    diff: TransferFieldChange[];
+    /** Values the file had that this row will not write because of a locked rule. */
+    heldBack: string[];
+    warnings: TransferWarningClass[];
+    match: RowMatchOutcome;
+}
+/** One example of a warning. */
+export interface TransferWarningSample {
+    /** The row's index in the file; {@link TRANSFER_FILE_SAMPLE_ROW} for something about the whole file. */
+    row: number;
+    fieldId?: string;
+    value?: string;
+    detail?: string;
+}
+/** The `row` of a warning sample about the whole file rather than one row (a column's name). */
+export declare const TRANSFER_FILE_SAMPLE_ROW = -1;
+/** One class of warning, counted. */
+export interface TransferWarning {
+    class: TransferWarningClass;
+    /** Occurrences (a row can raise a class for several fields). */
+    count: number;
+    /** Distinct rows that raised it. */
+    rows: number;
+    fieldIds: string[];
+    samples: TransferWarningSample[];
+    requiresAcknowledgement: boolean;
+}
+export type TransferPlanSummary = Record<TransferRowVerdict, number> & {
+    total: number;
+};
+export interface TransferPlan {
+    rows: PlannedTransferRow[];
+    summary: TransferPlanSummary;
+    warnings: TransferWarning[];
+    /** The classes that must be acknowledged before the plan may be applied. */
+    acknowledgementsRequired: TransferWarningClass[];
+}
+/** Bounds the plan enforces as it goes, from the organization's plan. */
+export interface TransferPlanLimits {
+    /** The most records this import may create. */
+    maxCreates?: number;
+    /** The most records this import may write (creates and updates). */
+    maxWrites?: number;
+}
+export interface BuildTransferPlanInput {
+    fields: readonly TransferField[];
+    rows: readonly TransferPlanRow[];
+    /** One per row, in the same order. */
+    matches: readonly RowMatchOutcome[];
+    /** Record id → its current values by field id. */
+    existing: ReadonlyMap<string, Readonly<Record<string, unknown>>>;
+    policy: TransferPolicy;
+    limits?: TransferPlanLimits;
+    /** Samples kept per warning class; default 5. */
+    sampleSize?: number;
+    /**
+     * The resource's answer to whether a field's value changes (AGL-3548):
+     * a value it folds on write (`Published`, `published`) is not a change.
+     */
+    valuesEqual?: TransferValuesComparator;
+}
+/** The plan for a file (see the block header). */
+export declare function buildTransferPlan(input: BuildTransferPlanInput): TransferPlan;
+/** The classes still to acknowledge before the plan may be applied. */
+export declare function missingAcknowledgements(plan: Pick<TransferPlan, 'acknowledgementsRequired'>, acknowledged: Iterable<TransferWarningClass>): TransferWarningClass[];
+/** Whether the plan may be applied: something to write and every required acknowledgement given. */
+export declare function canApplyTransferPlan(plan: Pick<TransferPlan, 'acknowledgementsRequired' | 'summary'>, acknowledged: Iterable<TransferWarningClass>): boolean;
+/** The rows that will write, in file order — what the job engine applies. */
+export declare function plannedWrites(plan: Pick<TransferPlan, 'rows'>): PlannedTransferRow[];
+/**
+ * One thing the owning plugin found about a planned row that no field policy
+ * can say — a redirect that loops, an off-site destination, a rule its own
+ * write path refuses — raised from the resource's `plan` hook.
+ */
+export interface TransferResourceFinding {
+    row: number;
+    /** What the person should know, in a sentence. */
+    detail: string;
+    fieldId?: string;
+    value?: string;
+    /** Refuse the row (it fails as `resourceRule`) rather than only warn about it. */
+    refuse?: boolean;
+}
+/**
+ * The plan with the plugin's findings folded in: each finding is a
+ * `resourceRule` warning on its row (acknowledged before Apply, like every
+ * class but a plain derivation), and a `refuse` finding fails a row that
+ * would have written. The summary and the acknowledgements follow.
+ */
+export declare function withTransferResourceFindings(plan: TransferPlan, findings: readonly TransferResourceFinding[], sampleSize?: number): TransferPlan;

package/src/lib/data-transfer/plan.js

@@ -0,0 +1,451 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /*==========================================
+ * THE PLAN — what an import WILL do, row by row, before it does anything.
+ *
+ * Given the rows (mapped and derived), each row's match outcome, the
+ * records those matched, and the policy, the plan says for every row:
+ * create, update, unchanged, skip or fail — with the field-by-field diff
+ * (before → after, and which policy decided it) and the warnings it
+ * raised. Nothing is written; the dry run IS this function run on the
+ * server over every row.
+ *
+ * ## Warnings are typed and must be acknowledged
+ *
+ * Every class of thing that could surprise a person — a guessed date
+ * order, a picklist value nobody chose for, a non-blank value about to be
+ * overwritten, a value about to be cleared — is a warning class with a
+ * count and samples. The classes in {@link ACKNOWLEDGED_WARNING_CLASSES}
+ * (and a derivation class holding a flagged guess) must each be
+ * acknowledged before Apply is enabled; {@link missingAcknowledgements}
+ * says which are outstanding.
+ *=========================================*/ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { appendTransferList, applyFieldPolicy, compareTransferValues, isBlankTransferValue, resolveFieldPolicy, resolveRecordPolicy, transferValuesEqual } from "./policy.js";
+import { isTransferFieldWritable } from "./resource.js";
+export const TRANSFER_ROW_VERDICTS = [
+    'create',
+    'update',
+    'unchanged',
+    'skip',
+    'fail'
+];
+export const TRANSFER_WARNING_CLASSES = [
+    'derivation',
+    'ambiguousDate',
+    'unmatchedPicklist',
+    'newPicklistValue',
+    'unresolvedLookup',
+    'ambiguousMatch',
+    'duplicateInFile',
+    'lockedRule',
+    'droppedCell',
+    'overwriteNonBlank',
+    'clearValue',
+    'planLimit',
+    'screening',
+    'resourceRule'
+];
+/**
+ * The classes that always need an acknowledgement. `derivation` needs one
+ * only when it holds a flagged guess; every other class is a change to data
+ * or a row held back, and the person says they have seen it.
+ */ export const ACKNOWLEDGED_WARNING_CLASSES = TRANSFER_WARNING_CLASSES.filter((entry)=>entry !== 'derivation');
+/** The `row` of a warning sample about the whole file rather than one row (a column's name). */ export const TRANSFER_FILE_SAMPLE_ROW = -1;
+let WarningTally = class WarningTally {
+    add(entry, sample, flagged = true) {
+        var _this_byClass_get, _tally;
+        const tally = (_this_byClass_get = this.byClass.get(entry)) != null ? _this_byClass_get : {
+            count: 0,
+            rows: new Set(),
+            fields: new Set(),
+            samples: [],
+            flagged: false
+        };
+        tally.count += 1;
+        tally.rows.add(sample.row);
+        if (sample.fieldId) tally.fields.add(sample.fieldId);
+        if (tally.samples.length < this.sampleSize) tally.samples.push(sample);
+        (_tally = tally).flagged || (_tally.flagged = flagged);
+        this.byClass.set(entry, tally);
+    }
+    list() {
+        return TRANSFER_WARNING_CLASSES.filter((entry)=>this.byClass.has(entry)).map((entry)=>{
+            const tally = this.byClass.get(entry);
+            return {
+                class: entry,
+                count: tally.count,
+                rows: tally.rows.size,
+                fieldIds: [
+                    ...tally.fields
+                ],
+                samples: tally.samples,
+                requiresAcknowledgement: ACKNOWLEDGED_WARNING_CLASSES.includes(entry) || tally.flagged
+            };
+        });
+    }
+    constructor(sampleSize){
+        this.sampleSize = sampleSize;
+        this.byClass = new Map();
+    }
+};
+/** Whether a field's new value carries what the file said (every item, for a list). */ function reflects(after, incoming) {
+    if (Array.isArray(incoming)) return transferValuesEqual(appendTransferList(after, incoming), after);
+    return transferValuesEqual(after, incoming);
+}
+function display(value) {
+    if (value === null || value === undefined) return '';
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+/** The plan for a file (see the block header). */ export function buildTransferPlan(input) {
+    var _input_sampleSize, _input_limits;
+    const byId = new Map(input.fields.map((field)=>[
+            field.id,
+            field
+        ]));
+    const tally = new WarningTally((_input_sampleSize = input.sampleSize) != null ? _input_sampleSize : 5);
+    const limits = (_input_limits = input.limits) != null ? _input_limits : {};
+    let creates = 0;
+    let writes = 0;
+    const rows = input.rows.map((row, position)=>{
+        var _input_matches_position, _row_derivations, _row_problems, _row_notes;
+        const match = (_input_matches_position = input.matches[position]) != null ? _input_matches_position : {
+            kind: 'new'
+        };
+        const warnings = new Set();
+        const warn = (entry, sample, flagged = true)=>{
+            warnings.add(entry);
+            tally.add(entry, _extends({
+                row: row.index
+            }, sample), flagged);
+        };
+        const finish = (verdict, recordId, extra = {})=>_extends({
+                index: row.index,
+                verdict,
+                recordId,
+                diff: [],
+                heldBack: []
+            }, extra, {
+                warnings: [
+                    ...warnings
+                ],
+                match
+            });
+        for (const entry of (_row_derivations = row.derivations) != null ? _row_derivations : []){
+            warn(entry.kind === 'ambiguousDate' ? 'ambiguousDate' : 'derivation', {
+                fieldId: entry.fieldId,
+                value: entry.from,
+                detail: `${entry.note} → ${entry.to}`
+            }, entry.flagged);
+        }
+        for (const problem of (_row_problems = row.problems) != null ? _row_problems : []){
+            warn('droppedCell', {
+                fieldId: problem.fieldId,
+                value: problem.raw,
+                detail: problem.message
+            });
+        }
+        let refused = false;
+        for (const note of (_row_notes = row.notes) != null ? _row_notes : []){
+            warn(note.class, _extends({
+                fieldId: note.fieldId,
+                value: note.value
+            }, note.detail ? {
+                detail: note.detail
+            } : {}));
+            if (note.refuse) refused = true;
+        }
+        if (refused) return finish('fail', null, {
+            reason: 'refusedValue'
+        });
+        const record = resolveRecordPolicy(input.policy, row.index);
+        let target;
+        if (record.action === 'skip') {
+            target = {
+                kind: 'skip',
+                reason: 'skippedByChoice'
+            };
+        } else if (record.action === 'create') {
+            target = {
+                kind: 'create'
+            };
+        } else if (record.recordId) {
+            target = {
+                kind: 'update',
+                recordId: record.recordId
+            };
+        } else if (match.kind === 'duplicateInFile') {
+            warn('duplicateInFile', {
+                value: match.via.value,
+                fieldId: match.via.fieldId,
+                detail: `Same as row ${match.firstRow + 1}`
+            });
+            target = {
+                kind: 'skip',
+                reason: 'duplicateInFile'
+            };
+        } else if (match.kind === 'ambiguous') {
+            warn('ambiguousMatch', {
+                fieldId: match.via.fieldId,
+                value: match.via.value,
+                detail: `${match.recordIds.length} records match`
+            });
+            target = {
+                kind: 'skip',
+                reason: record.onAmbiguous === 'skip' ? 'ambiguousSkipped' : 'ambiguousUnresolved'
+            };
+        } else if (match.kind === 'matched') {
+            var _match_alsoMatched;
+            if ((_match_alsoMatched = match.alsoMatched) == null ? void 0 : _match_alsoMatched.length) {
+                warn('ambiguousMatch', {
+                    fieldId: match.via.fieldId,
+                    value: match.via.value,
+                    detail: `Another key points at ${match.alsoMatched.length} other record(s)`
+                });
+            }
+            if (record.onMatch === 'skip') target = {
+                kind: 'skip',
+                reason: 'matchedSkipped'
+            };
+            else if (record.onMatch === 'duplicate') target = {
+                kind: 'create'
+            };
+            else target = {
+                kind: 'update',
+                recordId: match.recordId
+            };
+        } else {
+            target = record.onNew === 'skip' ? {
+                kind: 'skip',
+                reason: 'newSkipped'
+            } : {
+                kind: 'create'
+            };
+        }
+        if (target.kind === 'skip') return finish('skip', null, {
+            reason: target.reason
+        });
+        const before = target.kind === 'update' ? input.existing.get(target.recordId) : {};
+        if (!before) return finish('fail', target.kind === 'update' ? target.recordId : null, {
+            reason: 'matchedRecordMissing'
+        });
+        const diff = [];
+        const heldBack = [];
+        for (const [fieldId, incoming] of Object.entries(row.values)){
+            const field = byId.get(fieldId);
+            if (!field || !isTransferFieldWritable(field)) continue;
+            const resolved = resolveFieldPolicy(input.policy, row.index, field);
+            const current = target.kind === 'update' ? before[fieldId] : null;
+            const equal = (a, b)=>compareTransferValues(field, a, b, input.valuesEqual);
+            // A new record has nothing to keep, fill around or append to: the
+            // file's value is written unless a locked rule refuses it.
+            const outcome = target.kind === 'create' ? applyFieldPolicy({
+                mode: 'overwrite',
+                blank: 'leave',
+                refuseValues: resolved.refuseValues
+            }, null, incoming, equal) : applyFieldPolicy(resolved, current, incoming, equal);
+            if (resolved.locked && (resolved.refuseValues || resolved.source === 'locked') && !isBlankTransferValue(incoming) && !reflects(outcome.after, incoming)) {
+                heldBack.push(fieldId);
+                warn('lockedRule', {
+                    fieldId,
+                    value: display(incoming),
+                    detail: resolved.locked.reason
+                });
+            }
+            if (!outcome.changed) continue;
+            if (target.kind === 'update') {
+                if (outcome.rule === 'cleared') warn('clearValue', {
+                    fieldId,
+                    value: display(current)
+                });
+                else if (!isBlankTransferValue(current) && outcome.rule !== 'appended') {
+                    warn('overwriteNonBlank', {
+                        fieldId,
+                        value: display(current),
+                        detail: `→ ${display(outcome.after)}`
+                    });
+                }
+            }
+            diff.push({
+                fieldId,
+                before: target.kind === 'update' ? current != null ? current : null : null,
+                after: outcome.after,
+                mode: target.kind === 'create' ? 'overwrite' : resolved.mode,
+                source: resolved.source,
+                rule: outcome.rule
+            });
+        }
+        if (target.kind === 'create') {
+            const missing = input.fields.filter((field)=>{
+                var _diff_find;
+                return field.required && isBlankTransferValue((_diff_find = diff.find((change)=>change.fieldId === field.id)) == null ? void 0 : _diff_find.after);
+            }).map((field)=>field.id);
+            if (missing.length) return finish('fail', null, {
+                reason: 'missingRequired',
+                missing,
+                heldBack
+            });
+            if (limits.maxCreates !== undefined && creates >= limits.maxCreates || limits.maxWrites !== undefined && writes >= limits.maxWrites) {
+                warn('planLimit', {
+                    detail: 'Past what the plan allows'
+                });
+                return finish('fail', null, {
+                    reason: 'planLimit',
+                    heldBack
+                });
+            }
+            creates += 1;
+            writes += 1;
+            return finish('create', null, {
+                diff,
+                heldBack
+            });
+        }
+        if (!diff.length) return finish('unchanged', target.recordId, {
+            heldBack
+        });
+        if (limits.maxWrites !== undefined && writes >= limits.maxWrites) {
+            warn('planLimit', {
+                detail: 'Past what the plan allows'
+            });
+            return finish('fail', target.recordId, {
+                reason: 'planLimit',
+                heldBack
+            });
+        }
+        writes += 1;
+        return finish('update', target.recordId, {
+            diff,
+            heldBack
+        });
+    });
+    const summary = {
+        create: 0,
+        update: 0,
+        unchanged: 0,
+        skip: 0,
+        fail: 0,
+        total: rows.length
+    };
+    for (const row of rows)summary[row.verdict] += 1;
+    const warnings = tally.list();
+    return {
+        rows,
+        summary,
+        warnings,
+        acknowledgementsRequired: warnings.filter((entry)=>entry.requiresAcknowledgement).map((entry)=>entry.class)
+    };
+}
+/** The classes still to acknowledge before the plan may be applied. */ export function missingAcknowledgements(plan, acknowledged) {
+    const seen = new Set(acknowledged);
+    return plan.acknowledgementsRequired.filter((entry)=>!seen.has(entry));
+}
+/** Whether the plan may be applied: something to write and every required acknowledgement given. */ export function canApplyTransferPlan(plan, acknowledged) {
+    return plan.summary.create + plan.summary.update > 0 && missingAcknowledgements(plan, acknowledged).length === 0;
+}
+/** The rows that will write, in file order — what the job engine applies. */ export function plannedWrites(plan) {
+    return plan.rows.filter((row)=>row.verdict === 'create' || row.verdict === 'update');
+}
+/**
+ * The plan with the plugin's findings folded in: each finding is a
+ * `resourceRule` warning on its row (acknowledged before Apply, like every
+ * class but a plain derivation), and a `refuse` finding fails a row that
+ * would have written. The summary and the acknowledgements follow.
+ */ export function withTransferResourceFindings(plan, findings, sampleSize = 5) {
+    var _ref, _ref1, _ref2, _ref3;
+    if (!findings.length) return plan;
+    const byIndex = new Map(plan.rows.map((row)=>[
+            row.index,
+            row
+        ]));
+    const touched = new Map();
+    const rowsRaised = new Set();
+    const fieldIds = new Set();
+    const samples = [];
+    let count = 0;
+    for (const finding of findings){
+        var _touched_get;
+        const original = byIndex.get(finding.row);
+        if (!original) continue;
+        const row = (_touched_get = touched.get(finding.row)) != null ? _touched_get : _extends({}, original, {
+            warnings: [
+                ...original.warnings
+            ]
+        });
+        if (!row.warnings.includes('resourceRule')) row.warnings.push('resourceRule');
+        if (finding.refuse && row.verdict !== 'skip' && row.verdict !== 'fail') {
+            row.verdict = 'fail';
+            row.reason = 'resourceRule';
+            row.diff = [];
+        }
+        touched.set(finding.row, row);
+        count += 1;
+        rowsRaised.add(finding.row);
+        if (finding.fieldId) fieldIds.add(finding.fieldId);
+        if (samples.length < sampleSize) {
+            samples.push(_extends({
+                row: finding.row
+            }, finding.fieldId ? {
+                fieldId: finding.fieldId
+            } : {}, finding.value !== undefined ? {
+                value: finding.value
+            } : {}, {
+                detail: finding.detail
+            }));
+        }
+    }
+    if (!count) return plan;
+    const rows = plan.rows.map((row)=>{
+        var _touched_get;
+        return (_touched_get = touched.get(row.index)) != null ? _touched_get : row;
+    });
+    const summary = {
+        create: 0,
+        update: 0,
+        unchanged: 0,
+        skip: 0,
+        fail: 0,
+        total: rows.length
+    };
+    for (const row of rows)summary[row.verdict] += 1;
+    const prior = plan.warnings.find((entry)=>entry.class === 'resourceRule');
+    const raised = {
+        class: 'resourceRule',
+        count: ((_ref = prior == null ? void 0 : prior.count) != null ? _ref : 0) + count,
+        rows: ((_ref1 = prior == null ? void 0 : prior.rows) != null ? _ref1 : 0) + rowsRaised.size,
+        fieldIds: [
+            ...new Set([
+                ...(_ref2 = prior == null ? void 0 : prior.fieldIds) != null ? _ref2 : [],
+                ...fieldIds
+            ])
+        ],
+        samples: [
+            ...(_ref3 = prior == null ? void 0 : prior.samples) != null ? _ref3 : [],
+            ...samples
+        ].slice(0, sampleSize),
+        requiresAcknowledgement: true
+    };
+    const warnings = TRANSFER_WARNING_CLASSES.flatMap((entry)=>entry === 'resourceRule' ? [
+            raised
+        ] : plan.warnings.filter((warning)=>warning.class === entry));
+    return {
+        rows,
+        summary,
+        warnings,
+        acknowledgementsRequired: warnings.filter((entry)=>entry.requiresAcknowledgement).map((entry)=>entry.class)
+    };
+}
+
+//# sourceMappingURL=plan.js.map