niceeval 0.12.1 → 0.12.2-canary.31

package/dist/report/host/execute.cjs

@@ -0,0 +1,1287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeReport = executeReport;
+const effect_1 = require("effect");
+const runtime_ts_1 = require("../../projection/runtime.cjs");
+const analysis_ts_1 = require("../../sample/analysis.cjs");
+const internal_ts_1 = require("../author/internal.cjs");
+const identity_ts_1 = require("../author/identity.cjs");
+const model_ts_1 = require("../execution/model.cjs");
+const problems_ts_1 = require("../execution/problems.cjs");
+const results_ts_1 = require("../execution/results.cjs");
+const document_ts_1 = require("../semantic/document.cjs");
+/**
+ * Executes a complete in-process Report while the supplied Sample handle is
+ * still live. All Record I/O is confined to declared projections; callbacks
+ * only receive self-contained projected and calculated values.
+ */
+function executeReport(input) {
+    return effect_1.Effect.gen(function* () {
+        const compiled = yield* compileReportEffect(input.report);
+        // Validate even Reports with no projected inputs. A pure or copied Sample
+        // must never be enough to enter the host.
+        const bound = yield* (0, analysis_ts_1.resolveAnalysisSampleHandle)(input.sampleHandle);
+        const problems = new ProblemCollector();
+        const projectionOutcomes = new Map();
+        for (const projection of compiled.projections) {
+            const outcome = yield* executeProjection({
+                sampleHandle: input.sampleHandle,
+                projection,
+                problems,
+            });
+            projectionOutcomes.set(projection, outcome);
+        }
+        const calculationResults = new Map();
+        for (const calculation of compiled.calculations) {
+            const prepared = yield* effect_1.Effect.sync(() => prepareInputs({
+                plan: calculation.inputs,
+                outcomes: projectionOutcomes,
+                consumerId: calculation.descriptor.id,
+                problems,
+            }));
+            const result = yield* executeCalculation({
+                calculation,
+                sample: bound.sample,
+                prepared,
+                problems,
+            });
+            calculationResults.set(calculation.calculation, result);
+        }
+        const pages = [];
+        const families = [];
+        for (const member of compiled.pages) {
+            if (member.descriptor.kind === "page") {
+                const page = yield* executeFixedPage({
+                    descriptor: member.descriptor,
+                    inputs: member.inputs,
+                    sample: bound.sample,
+                    projectionOutcomes,
+                    calculationResults,
+                    problems,
+                });
+                pages.push(page);
+            }
+            else {
+                const family = yield* executePageFamily({
+                    descriptor: member.descriptor,
+                    inputs: member.inputs,
+                    sample: bound.sample,
+                    projectionOutcomes,
+                    calculationResults,
+                    problems,
+                    priorPageCount: pages.length,
+                });
+                families.push(family.result);
+                pages.push(...family.pages);
+            }
+            if (pages.length > model_ts_1.REPORT_PAGES_MAX) {
+                return yield* effect_1.Effect.fail(reportLimit("pages", model_ts_1.REPORT_PAGES_MAX, pages.length));
+            }
+        }
+        let downloadFileCount = 0;
+        const downloads = [];
+        for (const download of compiled.downloads) {
+            const result = yield* executeDownload({
+                descriptor: download.descriptor,
+                inputs: download.inputs,
+                sample: bound.sample,
+                projectionOutcomes,
+                calculationResults,
+                problems,
+                priorFileCount: downloadFileCount,
+            });
+            if (result.kind === "built") {
+                downloadFileCount += result.files.length;
+            }
+            downloads.push(result);
+        }
+        yield* effect_1.Effect.sync(() => resolveStaticConflicts(pages, downloads, problems));
+        const documentLimit = yield* effect_1.Effect.sync(() => validateDocuments({ pages, downloads, problems }));
+        if (documentLimit !== undefined) {
+            return yield* effect_1.Effect.fail(documentLimit);
+        }
+        return yield* finalizeExecution({
+            compiled,
+            sample: bound.sample,
+            projectionOutcomes,
+            calculationResults,
+            families,
+            pages,
+            downloads,
+            problems,
+        });
+    });
+}
+function compileReportEffect(report) {
+    return effect_1.Effect.try({
+        try: () => compileReport(report),
+        catch: () => reportAuthoringInvalid(),
+    });
+}
+function compileReport(report) {
+    const graph = (0, internal_ts_1.reportGraphDescriptor)(report);
+    const projections = [];
+    const projectionsByIdentity = new Map();
+    const plans = new Map();
+    const compilePlan = (plan, consumerId) => {
+        const existing = plans.get(plan);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const descriptor = (0, internal_ts_1.reportDataPlanDescriptor)(plan);
+        const compiled = compileDataPlan({
+            descriptor,
+            consumerId,
+            projections,
+            projectionsByIdentity,
+        });
+        plans.set(plan, compiled);
+        return compiled;
+    };
+    const calculations = graph.calculationsById
+        .map((calculation) => {
+        const descriptor = (0, internal_ts_1.reportCalculationDescriptor)(calculation);
+        return Object.freeze({
+            calculation,
+            descriptor,
+            inputs: compilePlan(descriptor.inputs, descriptor.id),
+        });
+    })
+        .sort((left, right) => compareText(left.descriptor.id, right.descriptor.id));
+    const pages = graph.pages
+        .map((page) => {
+        const descriptor = (0, internal_ts_1.reportPageMemberDescriptor)(page);
+        return Object.freeze({
+            descriptor,
+            ...(descriptor.inputs === undefined
+                ? {}
+                : { inputs: compilePlan(descriptor.inputs, descriptor.id) }),
+        });
+    })
+        .sort((left, right) => compareText(left.descriptor.id, right.descriptor.id));
+    const downloads = graph.downloads
+        .map((download) => {
+        const descriptor = (0, internal_ts_1.reportDownloadDescriptor)(download);
+        return Object.freeze({
+            descriptor,
+            ...(descriptor.inputs === undefined
+                ? {}
+                : { inputs: compilePlan(descriptor.inputs, descriptor.id) }),
+        });
+    })
+        .sort((left, right) => compareText(left.descriptor.id, right.descriptor.id));
+    return Object.freeze({
+        graph,
+        calculations: Object.freeze(calculations),
+        pages: Object.freeze(pages),
+        downloads: Object.freeze(downloads),
+        projections: Object.freeze(projections),
+    });
+}
+function compileDataPlan(input) {
+    const declarations = input.descriptor.declarations.map((declaration) => {
+        const identity = declaration.projection;
+        let projection = input.projectionsByIdentity.get(identity);
+        if (projection === undefined) {
+            const parsed = (0, results_ts_1.reportProjectionId)(input.projections.length);
+            if (effect_1.Either.isLeft(parsed)) {
+                throw new Error("Report projection IDs exceeded the supported range");
+            }
+            projection = Object.freeze({
+                projectionId: parsed.right,
+                inputKey: declaration.key,
+                projection: declaration.projection,
+                consumerId: input.consumerId,
+            });
+            input.projections.push(projection);
+            input.projectionsByIdentity.set(identity, projection);
+        }
+        return Object.freeze({ key: declaration.key, projection });
+    });
+    return Object.freeze({ declarations: Object.freeze(declarations) });
+}
+function executeProjection(input) {
+    return (0, runtime_ts_1.projectAnalysisSample)({
+        sampleHandle: input.sampleHandle,
+        projection: input.projection.projection,
+    }).pipe(effect_1.Effect.map((value) => Object.freeze({ state: "projected", value })), effect_1.Effect.catchAllDefect(() => effect_1.Effect.succeed(Object.freeze({
+        state: "execution-failed",
+        problemId: input.problems.execution({
+            code: "projection-callback-defect",
+            consumerId: input.projection.consumerId,
+            summary: "the RecordAttachment projector callback threw",
+        }),
+    }))));
+}
+function executeCalculation(input) {
+    const { calculation, sample, prepared, problems } = input;
+    const problemIds = uniqueProblemIds([
+        ...prepared.dataProblemIds,
+        ...prepared.projectionProblemIds,
+    ]);
+    if (prepared.projectionProblemIds.length > 0) {
+        return effect_1.Effect.succeed(Object.freeze({
+            state: "execution-failed",
+            calculationId: calculation.descriptor.id,
+            problemIds: requireProblemIds(problemIds),
+        }));
+    }
+    if (calculation.descriptor.completeness === "require-complete" && prepared.partial) {
+        return effect_1.Effect.succeed(Object.freeze({
+            state: "data-unavailable",
+            calculationId: calculation.descriptor.id,
+            problemIds: requireProblemIds(problemIds),
+        }));
+    }
+    return invokeCallback({
+        callback: () => calculation.descriptor.calculate(calculationContext(sample, prepared.inputs)),
+        problems,
+        problem: {
+            code: "calculation-callback-defect",
+            consumerId: calculation.descriptor.id,
+            summary: "the Calculation callback threw",
+        },
+    }).pipe(effect_1.Effect.map((outcome) => {
+        if (outcome.state === "failed") {
+            return Object.freeze({
+                state: "execution-failed",
+                calculationId: calculation.descriptor.id,
+                problemIds: requireProblemIds(uniqueProblemIds([...problemIds, outcome.problemId])),
+            });
+        }
+        return Object.freeze({
+            state: "available",
+            calculationId: calculation.descriptor.id,
+            value: outcome.value,
+            inputState: dataState(prepared.partial),
+            problemIds,
+        });
+    }));
+}
+function executeFixedPage(input) {
+    return effect_1.Effect.gen(function* () {
+        const prepared = yield* effect_1.Effect.sync(() => prepareComponentInputs({
+            references: input.descriptor,
+            consumerId: input.descriptor.id,
+            plan: input.inputs,
+            outcomes: input.projectionOutcomes,
+            problems: input.problems,
+        }));
+        const blocked = blockedPage({
+            pageId: input.descriptor.id,
+            route: input.descriptor.route,
+            completeness: input.descriptor.completeness,
+            prepared,
+        });
+        if (blocked !== undefined) {
+            return blocked;
+        }
+        const context = yield* effect_1.Effect.sync(() => componentContext({
+            sample: input.sample,
+            prepared,
+            references: input.descriptor,
+            calculationResults: input.calculationResults,
+        }));
+        const outcome = yield* invokeCallback({
+            callback: () => input.descriptor.render(context),
+            problems: input.problems,
+            problem: {
+                code: "page-execution-failed",
+                consumerId: input.descriptor.id,
+                summary: "the Page render callback threw",
+            },
+        });
+        if (outcome.state === "failed") {
+            return failedPage({
+                state: "execution-failed",
+                pageId: input.descriptor.id,
+                route: input.descriptor.route,
+                problemIds: uniqueProblemIds([...prepared.dataProblemIds, outcome.problemId]),
+            });
+        }
+        return {
+            kind: "candidate",
+            pageId: input.descriptor.id,
+            route: input.descriptor.route,
+            document: outcome.value,
+            problemIds: prepared.dataProblemIds,
+        };
+    });
+}
+function executePageFamily(input) {
+    return effect_1.Effect.gen(function* () {
+        const prepared = yield* effect_1.Effect.sync(() => prepareComponentInputs({
+            references: input.descriptor,
+            consumerId: input.descriptor.id,
+            plan: input.inputs,
+            outcomes: input.projectionOutcomes,
+            problems: input.problems,
+        }));
+        const blocked = blockedFamily({
+            familyId: input.descriptor.id,
+            completeness: input.descriptor.completeness,
+            prepared,
+        });
+        if (blocked !== undefined) {
+            return Object.freeze({ result: blocked, pages: Object.freeze([]) });
+        }
+        const context = yield* effect_1.Effect.sync(() => componentContext({
+            sample: input.sample,
+            prepared,
+            references: input.descriptor,
+            calculationResults: input.calculationResults,
+        }));
+        const iterable = yield* invokeCallback({
+            callback: () => input.descriptor.instances(context),
+            problems: input.problems,
+            problem: {
+                code: "page-family-instances-defect",
+                consumerId: input.descriptor.id,
+                summary: "the PageFamily instances callback threw",
+            },
+        });
+        if (iterable.state === "failed") {
+            return Object.freeze({
+                result: failedFamily({
+                    familyId: input.descriptor.id,
+                    problemIds: uniqueProblemIds([...prepared.dataProblemIds, iterable.problemId]),
+                }),
+                pages: Object.freeze([]),
+            });
+        }
+        // A family is an arbitrary iterable, so apply the global page budget while
+        // consuming it rather than materializing an unbounded author collection.
+        const collected = yield* invokeCallback({
+            callback: () => collectInstances(iterable.value, input.priorPageCount),
+            problems: input.problems,
+            problem: {
+                code: "page-family-instances-defect",
+                consumerId: input.descriptor.id,
+                summary: "the PageFamily instances callback threw",
+            },
+        });
+        if (collected.state === "failed") {
+            return Object.freeze({
+                result: failedFamily({
+                    familyId: input.descriptor.id,
+                    problemIds: uniqueProblemIds([...prepared.dataProblemIds, collected.problemId]),
+                }),
+                pages: Object.freeze([]),
+            });
+        }
+        if (collected.value.state === "limit") {
+            return yield* effect_1.Effect.fail(collected.value.error);
+        }
+        const instances = collected.value.values;
+        const bindings = [];
+        const keys = new Set();
+        for (const instance of instances) {
+            const key = yield* invokeCallback({
+                callback: () => input.descriptor.key(instance),
+                problems: input.problems,
+                problem: {
+                    code: "page-family-key-defect",
+                    consumerId: input.descriptor.id,
+                    summary: "the PageFamily key callback threw or returned an invalid key",
+                },
+            });
+            if (key.state === "failed" || !(0, identity_ts_1.isReportInstanceKey)(key.value)) {
+                const problemId = key.state === "failed"
+                    ? key.problemId
+                    : input.problems.execution({
+                        code: "page-family-key-defect",
+                        consumerId: input.descriptor.id,
+                        summary: "the PageFamily key callback threw or returned an invalid key",
+                    });
+                return Object.freeze({
+                    result: failedFamily({
+                        familyId: input.descriptor.id,
+                        problemIds: uniqueProblemIds([...prepared.dataProblemIds, problemId]),
+                    }),
+                    pages: Object.freeze([]),
+                });
+            }
+            if (keys.has(key.value)) {
+                const problemId = input.problems.execution({
+                    code: "page-family-key-conflict",
+                    consumerId: input.descriptor.id,
+                    summary: "the PageFamily produced duplicate instance keys",
+                });
+                return Object.freeze({
+                    result: failedFamily({
+                        familyId: input.descriptor.id,
+                        problemIds: uniqueProblemIds([...prepared.dataProblemIds, problemId]),
+                    }),
+                    pages: Object.freeze([]),
+                });
+            }
+            keys.add(key.value);
+            const route = yield* invokeCallback({
+                callback: () => input.descriptor.route(instance),
+                problems: input.problems,
+                problem: {
+                    code: "page-family-key-defect",
+                    consumerId: input.descriptor.id,
+                    summary: "the PageFamily route callback threw or returned an invalid route",
+                },
+            });
+            if (route.state === "failed" || !(0, identity_ts_1.isReportRoute)(route.value)) {
+                const problemId = route.state === "failed"
+                    ? route.problemId
+                    : input.problems.execution({
+                        code: "page-family-key-defect",
+                        consumerId: input.descriptor.id,
+                        summary: "the PageFamily route callback threw or returned an invalid route",
+                    });
+                return Object.freeze({
+                    result: failedFamily({
+                        familyId: input.descriptor.id,
+                        problemIds: uniqueProblemIds([...prepared.dataProblemIds, problemId]),
+                    }),
+                    pages: Object.freeze([]),
+                });
+            }
+            bindings.push(Object.freeze({ instance, key: key.value, route: route.value }));
+        }
+        const pages = [];
+        for (const binding of bindings) {
+            const rendered = yield* invokeCallback({
+                callback: () => input.descriptor.render(Object.freeze({ ...context, instance: binding.instance })),
+                problems: input.problems,
+                problem: {
+                    code: "page-execution-failed",
+                    consumerId: input.descriptor.id,
+                    summary: "a PageFamily Page render callback threw",
+                },
+            });
+            if (rendered.state === "failed") {
+                pages.push(failedPage({
+                    state: "execution-failed",
+                    pageId: input.descriptor.id,
+                    route: binding.route,
+                    problemIds: uniqueProblemIds([...prepared.dataProblemIds, rendered.problemId]),
+                }));
+            }
+            else {
+                pages.push({
+                    kind: "candidate",
+                    pageId: input.descriptor.id,
+                    route: binding.route,
+                    document: rendered.value,
+                    problemIds: prepared.dataProblemIds,
+                });
+            }
+        }
+        return Object.freeze({
+            result: Object.freeze({
+                state: "expanded",
+                familyId: input.descriptor.id,
+                instanceCount: bindings.length,
+                problemIds: prepared.dataProblemIds,
+            }),
+            pages: Object.freeze(pages),
+        });
+    });
+}
+function executeDownload(input) {
+    return effect_1.Effect.gen(function* () {
+        const prepared = yield* effect_1.Effect.sync(() => prepareComponentInputs({
+            references: input.descriptor,
+            consumerId: input.descriptor.id,
+            plan: input.inputs,
+            outcomes: input.projectionOutcomes,
+            problems: input.problems,
+        }));
+        const blocked = blockedDownload({
+            downloadId: input.descriptor.id,
+            completeness: input.descriptor.completeness,
+            prepared,
+        });
+        if (blocked !== undefined) {
+            return blocked;
+        }
+        const context = yield* effect_1.Effect.sync(() => componentContext({
+            sample: input.sample,
+            prepared,
+            references: input.descriptor,
+            calculationResults: input.calculationResults,
+        }));
+        const built = yield* invokeCallback({
+            callback: () => buildDownloadFiles(input.descriptor.build(context), input.priorFileCount),
+            problems: input.problems,
+            problem: {
+                code: "download-execution-failed",
+                consumerId: input.descriptor.id,
+                summary: "the Download build callback returned invalid files or threw",
+            },
+        });
+        if (built.state === "failed") {
+            return failedDownload({
+                state: "execution-failed",
+                downloadId: input.descriptor.id,
+                problemIds: uniqueProblemIds([...prepared.dataProblemIds, built.problemId]),
+            });
+        }
+        if (built.value.state === "limit") {
+            return yield* effect_1.Effect.fail(built.value.error);
+        }
+        return {
+            kind: "built",
+            downloadId: input.descriptor.id,
+            files: built.value.files,
+            problemIds: prepared.dataProblemIds,
+        };
+    });
+}
+function prepareComponentInputs(input) {
+    if (input.references.inputs === undefined) {
+        return emptyPreparedInputs();
+    }
+    if (input.plan === undefined) {
+        throw new Error("a Report component lost its compiled input plan");
+    }
+    return prepareInputs({
+        plan: input.plan,
+        outcomes: input.outcomes,
+        consumerId: input.consumerId,
+        problems: input.problems,
+    });
+}
+function prepareInputs(input) {
+    const values = Object.create(null);
+    const dataProblemIds = [];
+    const projectionProblemIds = [];
+    let partial = false;
+    for (const declaration of input.plan.declarations) {
+        const outcome = input.outcomes.get(declaration.projection);
+        if (outcome === undefined) {
+            throw new Error("a compiled projection did not execute");
+        }
+        if (outcome.state === "execution-failed") {
+            projectionProblemIds.push(outcome.problemId);
+            partial = true;
+            continue;
+        }
+        Object.defineProperty(values, declaration.key, {
+            value: outcome.value,
+            enumerable: true,
+            writable: false,
+            configurable: false,
+        });
+        for (const entry of outcome.value.entries) {
+            const problem = recordedDataProblem({
+                entry,
+                consumerId: input.consumerId,
+                inputKey: declaration.key,
+            });
+            if (problem !== undefined) {
+                partial = true;
+                dataProblemIds.push(input.problems.add(problem));
+            }
+        }
+    }
+    return Object.freeze({
+        inputs: Object.freeze(values),
+        partial,
+        dataProblemIds: uniqueProblemIds(dataProblemIds),
+        projectionProblemIds: uniqueProblemIds(projectionProblemIds),
+    });
+}
+function emptyPreparedInputs() {
+    return Object.freeze({
+        inputs: Object.freeze({}),
+        partial: false,
+        dataProblemIds: Object.freeze([]),
+        projectionProblemIds: Object.freeze([]),
+    });
+}
+function recordedDataProblem(input) {
+    const location = "slot" in input.entry
+        ? { slotId: input.entry.slot.slotId, runId: input.entry.slot.runId }
+        : { runId: input.entry.run.runId };
+    switch (input.entry.state) {
+        case "excluded":
+            return undefined;
+        case "not-recorded":
+        case "core-invalid":
+            return recordedProblem({
+                code: "unavailable",
+                consumerId: input.consumerId,
+                inputKey: input.inputKey,
+                ...location,
+            });
+        case "attachment-result": {
+            switch (input.entry.attachment.state) {
+                case "available":
+                    return undefined;
+                case "unavailable":
+                case "migration-required":
+                case "migration-unavailable":
+                case "unsupported":
+                case "invalid":
+                    return recordedProblem({
+                        code: input.entry.attachment.state,
+                        consumerId: input.consumerId,
+                        inputKey: input.inputKey,
+                        ...location,
+                    });
+            }
+        }
+    }
+}
+function recordedProblem(input) {
+    return Object.freeze({
+        category: "recorded-data",
+        code: input.code,
+        consumerId: input.consumerId,
+        inputKey: input.inputKey,
+        ...(input.slotId === undefined ? {} : { slotId: input.slotId }),
+        ...(input.runId === undefined ? {} : { runId: input.runId }),
+    });
+}
+function calculationContext(sample, inputs) {
+    return Object.freeze({ sample, inputs });
+}
+function componentContext(input) {
+    return Object.freeze({
+        sample: input.sample,
+        inputs: input.prepared.inputs,
+        calculations: calculationContextValues(input.references, input.calculationResults),
+    });
+}
+function calculationContextValues(references, calculationResults) {
+    const values = Object.create(null);
+    for (const key of Object.keys(references.calculations).sort(compareText)) {
+        const calculation = references.calculations[key];
+        if (calculation === undefined) {
+            throw new Error("a Report Calculation mapping lost its value");
+        }
+        const result = calculationResults.get(calculation);
+        if (result === undefined) {
+            throw new Error("a component referenced a Calculation that did not execute");
+        }
+        Object.defineProperty(values, key, {
+            value: callbackCalculationResult(result),
+            enumerable: true,
+            writable: false,
+            configurable: false,
+        });
+    }
+    return Object.freeze(values);
+}
+function callbackCalculationResult(result) {
+    switch (result.state) {
+        case "available":
+            return Object.freeze({
+                state: "available",
+                value: result.value,
+                inputState: result.inputState,
+            });
+        case "data-unavailable":
+            return Object.freeze({
+                state: "data-unavailable",
+                problemIds: result.problemIds,
+            });
+        case "execution-failed":
+            return Object.freeze({
+                state: "execution-failed",
+                problemIds: result.problemIds,
+            });
+    }
+}
+function blockedPage(input) {
+    const allProblems = uniqueProblemIds([
+        ...input.prepared.dataProblemIds,
+        ...input.prepared.projectionProblemIds,
+    ]);
+    if (input.prepared.projectionProblemIds.length > 0) {
+        return failedPage({
+            state: "execution-failed",
+            pageId: input.pageId,
+            route: input.route,
+            problemIds: allProblems,
+        });
+    }
+    if (input.completeness === "require-complete" && input.prepared.partial) {
+        return failedPage({
+            state: "data-unavailable",
+            pageId: input.pageId,
+            route: input.route,
+            problemIds: allProblems,
+        });
+    }
+    return undefined;
+}
+function blockedFamily(input) {
+    const allProblems = uniqueProblemIds([
+        ...input.prepared.dataProblemIds,
+        ...input.prepared.projectionProblemIds,
+    ]);
+    if (input.prepared.projectionProblemIds.length > 0) {
+        return failedFamily({ familyId: input.familyId, problemIds: allProblems });
+    }
+    if (input.completeness === "require-complete" && input.prepared.partial) {
+        return Object.freeze({
+            state: "data-unavailable",
+            familyId: input.familyId,
+            instanceCount: 0,
+            problemIds: requireProblemIds(allProblems),
+        });
+    }
+    return undefined;
+}
+function blockedDownload(input) {
+    const allProblems = uniqueProblemIds([
+        ...input.prepared.dataProblemIds,
+        ...input.prepared.projectionProblemIds,
+    ]);
+    if (input.prepared.projectionProblemIds.length > 0) {
+        return failedDownload({
+            state: "execution-failed",
+            downloadId: input.downloadId,
+            problemIds: allProblems,
+        });
+    }
+    if (input.completeness === "require-complete" && input.prepared.partial) {
+        return failedDownload({
+            state: "data-unavailable",
+            downloadId: input.downloadId,
+            problemIds: allProblems,
+        });
+    }
+    return undefined;
+}
+function failedPage(input) {
+    return Object.freeze({
+        kind: "failed",
+        state: input.state,
+        pageId: input.pageId,
+        ...(input.route === undefined ? {} : { route: input.route }),
+        problemIds: requireProblemIds(input.problemIds),
+    });
+}
+function failedFamily(input) {
+    return Object.freeze({
+        state: "execution-failed",
+        familyId: input.familyId,
+        instanceCount: 0,
+        problemIds: requireProblemIds(input.problemIds),
+    });
+}
+function failedDownload(input) {
+    return Object.freeze({
+        kind: "failed",
+        state: input.state,
+        downloadId: input.downloadId,
+        problemIds: requireProblemIds(input.problemIds),
+    });
+}
+function invokeCallback(input) {
+    return effect_1.Effect.sync(input.callback).pipe(effect_1.Effect.map((value) => Object.freeze({ state: "succeeded", value })), 
+    // This boundary deliberately converts only author defects. Typed failures
+    // do not exist in synchronous author callbacks, and interruption remains a
+    // Cause rather than a Report problem.
+    effect_1.Effect.catchAllDefect(() => effect_1.Effect.succeed(Object.freeze({
+        state: "failed",
+        problemId: input.problems.execution(input.problem),
+    }))));
+}
+function collectInstances(value, priorPageCount) {
+    const values = [];
+    for (const instance of value) {
+        const observed = priorPageCount + values.length + 1;
+        if (observed > model_ts_1.REPORT_PAGES_MAX) {
+            return Object.freeze({
+                state: "limit",
+                error: reportLimit("pages", model_ts_1.REPORT_PAGES_MAX, observed),
+            });
+        }
+        values.push(instance);
+    }
+    return Object.freeze({ state: "collected", values: Object.freeze(values) });
+}
+function buildDownloadFiles(value, priorFileCount) {
+    const files = [];
+    const paths = new Set();
+    for (const file of value) {
+        const observed = priorFileCount + files.length + 1;
+        if (observed > model_ts_1.REPORT_DOWNLOAD_FILES_MAX) {
+            return Object.freeze({
+                state: "limit",
+                error: reportLimit("download-files", model_ts_1.REPORT_DOWNLOAD_FILES_MAX, observed),
+            });
+        }
+        if (typeof file !== "object" || file === null || !(0, identity_ts_1.isReportDownloadPath)(file.path)) {
+            throw new TypeError("a Download file must use a valid ReportDownloadPath");
+        }
+        if (typeof file.mediaType !== "string" ||
+            file.mediaType.length === 0 ||
+            !hasOnlyUnicodeScalars(file.mediaType)) {
+            throw new TypeError("a Download file must use a non-empty Unicode media type");
+        }
+        if (!(file.bytes instanceof Uint8Array)) {
+            throw new TypeError("a Download file must use Uint8Array bytes");
+        }
+        if (file.bytes.byteLength > model_ts_1.REPORT_DOWNLOAD_FILE_BYTES_MAX) {
+            return Object.freeze({
+                state: "limit",
+                error: reportLimit("download-file-bytes", model_ts_1.REPORT_DOWNLOAD_FILE_BYTES_MAX, file.bytes.byteLength),
+            });
+        }
+        if (paths.has(file.path)) {
+            throw new TypeError("a Download cannot produce duplicate file paths");
+        }
+        paths.add(file.path);
+        files.push(Object.freeze({
+            path: file.path,
+            mediaType: file.mediaType,
+            bytes: new Uint8Array(file.bytes),
+        }));
+    }
+    files.sort((left, right) => compareText(left.path, right.path));
+    return Object.freeze({ state: "built", files: Object.freeze(files) });
+}
+function resolveStaticConflicts(pages, downloads, problems) {
+    const outputs = [];
+    for (const page of pages) {
+        if (page.kind === "candidate") {
+            outputs.push({ kind: "page", page });
+        }
+    }
+    for (const download of downloads) {
+        if (download.kind === "built") {
+            for (const file of download.files) {
+                outputs.push({ kind: "download", download, path: file.path });
+            }
+        }
+    }
+    for (let left = 0; left < outputs.length; left += 1) {
+        const current = outputs[left];
+        if (current === undefined)
+            continue;
+        for (let right = left + 1; right < outputs.length; right += 1) {
+            const next = outputs[right];
+            if (next === undefined)
+                continue;
+            const currentPath = current.kind === "page"
+                ? (0, identity_ts_1.staticPathForReportRoute)(current.page.route)
+                : (0, identity_ts_1.staticPathForReportDownload)(current.path);
+            const nextPath = next.kind === "page"
+                ? (0, identity_ts_1.staticPathForReportRoute)(next.page.route)
+                : (0, identity_ts_1.staticPathForReportDownload)(next.path);
+            if ((0, identity_ts_1.reportStaticPathConflict)(currentPath, nextPath) === undefined) {
+                continue;
+            }
+            markStaticConflict(current, problems);
+            markStaticConflict(next, problems);
+        }
+    }
+}
+function markStaticConflict(output, problems) {
+    if (output.kind === "page") {
+        if (output.page.conflictProblemId === undefined) {
+            output.page.conflictProblemId = problems.execution({
+                code: "route-conflict",
+                consumerId: output.page.pageId,
+                summary: "the Page route conflicts with another Report output",
+            });
+        }
+        return;
+    }
+    if (output.download.conflictProblemId === undefined) {
+        output.download.conflictProblemId = problems.execution({
+            code: "route-conflict",
+            consumerId: output.download.downloadId,
+            summary: "a Download path conflicts with another Report output",
+        });
+    }
+}
+function validateDocuments(input) {
+    const candidates = input.pages.filter((page) => page.kind === "candidate" && page.conflictProblemId === undefined);
+    const routes = new Set(candidates.map((page) => page.route));
+    const downloads = new Set();
+    for (const download of input.downloads) {
+        if (download.kind === "built" && download.conflictProblemId === undefined) {
+            for (const file of download.files) {
+                downloads.add(file.path);
+            }
+        }
+    }
+    const reverseLinks = new Map();
+    const invalidRoutes = [];
+    for (const page of candidates) {
+        const validation = validateCandidateDocument(page.document, routes, downloads);
+        if (validation.state === "limit") {
+            return validation.error;
+        }
+        if (validation.state === "invalid") {
+            markSemanticProblem(page, input.problems);
+            invalidRoutes.push(page.route);
+            continue;
+        }
+        page.document = validation.document;
+        for (const route of validation.routes) {
+            const linked = reverseLinks.get(route);
+            if (linked === undefined) {
+                reverseLinks.set(route, [page]);
+            }
+            else {
+                linked.push(page);
+            }
+        }
+    }
+    for (let index = 0; index < invalidRoutes.length; index += 1) {
+        const invalidRoute = invalidRoutes[index];
+        if (invalidRoute === undefined)
+            continue;
+        for (const dependent of reverseLinks.get(invalidRoute) ?? []) {
+            if (dependent.semanticProblemId !== undefined)
+                continue;
+            markSemanticProblem(dependent, input.problems);
+            invalidRoutes.push(dependent.route);
+        }
+    }
+    return undefined;
+}
+function validateCandidateDocument(document, routes, downloads) {
+    try {
+        const validation = (0, document_ts_1.validateReportDocument)(document, { routes, downloads });
+        const limit = reportDocumentLimit(validation);
+        if (limit !== undefined) {
+            return Object.freeze({ state: "limit", error: limit });
+        }
+        if (!validation.valid) {
+            return Object.freeze({ state: "invalid" });
+        }
+        const frozen = (0, document_ts_1.freezeReportDocument)(document);
+        return Object.freeze({
+            state: "valid",
+            document: frozen,
+            routes: Object.freeze(routeLinks(frozen)),
+        });
+    }
+    catch {
+        return Object.freeze({ state: "invalid" });
+    }
+}
+function reportDocumentLimit(validation) {
+    for (const issue of validation.issues) {
+        if (issue.code !== "limit")
+            continue;
+        if (issue.reason.includes("nodes deep")) {
+            return reportLimit("document-depth", document_ts_1.REPORT_DOCUMENT_DEPTH_MAX, document_ts_1.REPORT_DOCUMENT_DEPTH_MAX + 1);
+        }
+        return reportLimit("document-nodes", document_ts_1.REPORT_DOCUMENT_NODES_MAX, validation.nodeCount);
+    }
+    return undefined;
+}
+function markSemanticProblem(page, problems) {
+    if (page.semanticProblemId === undefined) {
+        page.semanticProblemId = problems.execution({
+            code: "semantic-document-invalid",
+            consumerId: page.pageId,
+            summary: "the Page returned an invalid semantic document",
+        });
+    }
+}
+function routeLinks(document) {
+    const routes = [];
+    const visitInline = (inline) => {
+        switch (inline.type) {
+            case "text":
+            case "code":
+                return;
+            case "emphasis":
+                inline.children.forEach(visitInline);
+                return;
+            case "link":
+                inline.label.forEach(visitInline);
+                if (inline.target.kind === "route")
+                    routes.push(inline.target.route);
+                return;
+        }
+    };
+    const visitBlock = (block) => {
+        switch (block.type) {
+            case "section":
+                block.children.forEach(visitBlock);
+                return;
+            case "paragraph":
+                block.children.forEach(visitInline);
+                return;
+            case "list":
+                block.items.forEach((item) => item.forEach(visitBlock));
+                return;
+            case "status":
+                block.detail?.forEach(visitInline);
+                return;
+            case "table":
+            case "metric":
+            case "code-block":
+            case "chart":
+                return;
+        }
+    };
+    document.children.forEach(visitBlock);
+    return routes;
+}
+function finalizeExecution(input) {
+    return effect_1.Effect.gen(function* () {
+        const table = input.problems.table();
+        if (effect_1.Either.isLeft(table)) {
+            return yield* effect_1.Effect.fail(table.left);
+        }
+        const projections = projectionSummaries(input.compiled.projections, input.projectionOutcomes, input.sample);
+        const calculations = input.compiled.calculations.map(({ calculation }) => {
+            const result = input.calculationResults.get(calculation);
+            if (result === undefined) {
+                throw new Error("a Calculation did not retain its execution result");
+            }
+            return result;
+        });
+        const execution = (0, model_ts_1.reportExecution)({
+            reportId: input.compiled.graph.id,
+            sample: input.sample,
+            projections,
+            calculations,
+            families: input.families.map(familyResult),
+            pages: input.pages.map(pageResult),
+            downloads: input.downloads.map(downloadResult),
+            problemTable: table.right,
+        });
+        if (effect_1.Either.isLeft(execution)) {
+            if (execution.left.code === "report-limit-exceeded") {
+                return yield* effect_1.Effect.fail(execution.left);
+            }
+            throw executionInvariant(execution.left);
+        }
+        return execution.right;
+    });
+}
+function projectionSummaries(projections, outcomes, sample) {
+    return projections.map((projection) => {
+        const outcome = outcomes.get(projection);
+        if (outcome === undefined) {
+            throw new Error("a compiled projection did not retain its outcome");
+        }
+        return Object.freeze({
+            projectionId: projection.projectionId,
+            inputKey: projection.inputKey,
+            coverage: outcome.state === "projected"
+                ? outcome.value.coverage
+                : failedProjectionCoverage(sample, projection.projection.access),
+            problemIds: outcome.state === "projected"
+                ? Object.freeze([])
+                : Object.freeze([outcome.problemId]),
+        });
+    });
+}
+function familyResult(value) {
+    if (value.state === "expanded") {
+        return Object.freeze({
+            state: "expanded",
+            familyId: value.familyId,
+            instanceCount: value.instanceCount,
+            problemIds: value.problemIds,
+        });
+    }
+    return Object.freeze({
+        state: value.state,
+        familyId: value.familyId,
+        instanceCount: value.instanceCount,
+        problemIds: requireProblemIds(value.problemIds),
+    });
+}
+function pageResult(value) {
+    if (value.kind === "failed") {
+        return Object.freeze({
+            state: value.state,
+            pageId: value.pageId,
+            ...(value.route === undefined ? {} : { route: value.route }),
+            problemIds: value.problemIds,
+        });
+    }
+    const problemIds = uniqueProblemIds([
+        ...value.problemIds,
+        ...(value.conflictProblemId === undefined ? [] : [value.conflictProblemId]),
+        ...(value.semanticProblemId === undefined ? [] : [value.semanticProblemId]),
+    ]);
+    if (value.conflictProblemId !== undefined || value.semanticProblemId !== undefined) {
+        return Object.freeze({
+            state: "execution-failed",
+            pageId: value.pageId,
+            route: value.route,
+            problemIds: requireProblemIds(problemIds),
+        });
+    }
+    return Object.freeze({
+        state: "rendered",
+        pageId: value.pageId,
+        route: value.route,
+        document: value.document,
+        problemIds,
+    });
+}
+function downloadResult(value) {
+    if (value.kind === "failed") {
+        return Object.freeze({
+            state: value.state,
+            downloadId: value.downloadId,
+            problemIds: value.problemIds,
+        });
+    }
+    const problemIds = uniqueProblemIds([
+        ...value.problemIds,
+        ...(value.conflictProblemId === undefined ? [] : [value.conflictProblemId]),
+    ]);
+    if (value.conflictProblemId !== undefined) {
+        return Object.freeze({
+            state: "execution-failed",
+            downloadId: value.downloadId,
+            problemIds: requireProblemIds(problemIds),
+        });
+    }
+    return Object.freeze({
+        state: "built",
+        downloadId: value.downloadId,
+        files: value.files,
+        problemIds,
+    });
+}
+function failedProjectionCoverage(sample, access) {
+    let included = 0;
+    let notRecorded = 0;
+    let coreInvalid = 0;
+    let excluded = 0;
+    for (const slot of sample.slots) {
+        switch (slot.state) {
+            case "included":
+                included += 1;
+                break;
+            case "not-recorded":
+                notRecorded += 1;
+                break;
+            case "core-invalid":
+                coreInvalid += 1;
+                break;
+            case "excluded":
+                excluded += 1;
+                break;
+        }
+    }
+    const slotAccess = access !== "selected-run";
+    return Object.freeze({
+        sample: Object.freeze({
+            denominator: sample.denominator,
+            totalSlots: sample.slots.length,
+            included,
+            notRecorded,
+            coreInvalid,
+            excluded,
+        }),
+        entries: Object.freeze({
+            total: slotAccess ? sample.slots.length : sample.runs.length,
+            attachmentResult: 0,
+            notRecorded: slotAccess ? notRecorded : 0,
+            coreInvalid: slotAccess ? coreInvalid : 0,
+            excluded: slotAccess ? excluded : 0,
+        }),
+        attachments: Object.freeze({
+            available: 0,
+            unavailable: 0,
+            migrationRequired: 0,
+            migrationUnavailable: 0,
+            unsupported: 0,
+            invalid: 0,
+        }),
+    });
+}
+function dataState(partial) {
+    return Object.freeze({ state: partial ? "partial" : "complete" });
+}
+function uniqueProblemIds(ids) {
+    const unique = [];
+    const seen = new Set();
+    for (const id of ids) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        unique.push(id);
+    }
+    return Object.freeze(unique);
+}
+function requireProblemIds(ids) {
+    if (ids.length === 0) {
+        throw new Error("a failed Report result must reference a problem");
+    }
+    return Object.freeze([...ids]);
+}
+function reportLimit(limit, maximum, observedAtLeast) {
+    return Object.freeze({
+        code: "report-limit-exceeded",
+        limit,
+        maximum,
+        observedAtLeast,
+    });
+}
+function reportAuthoringInvalid() {
+    return Object.freeze({
+        code: "report-definition-invalid",
+        issues: Object.freeze(["the Report must be created by NiceEval author constructors"]),
+    });
+}
+function compareText(left, right) {
+    if (left === right)
+        return 0;
+    return left < right ? -1 : 1;
+}
+function hasOnlyUnicodeScalars(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function executionInvariant(error) {
+    return new Error(`Report host produced an invalid execution: ${error.code}`);
+}
+class ProblemCollector {
+    problems = [];
+    ids = new Map();
+    add(problem) {
+        const known = this.ids.get(problem);
+        if (known !== undefined)
+            return known;
+        const id = this.problems.length;
+        this.problems.push(problem);
+        this.ids.set(problem, id);
+        return id;
+    }
+    execution(problem) {
+        return this.add(Object.freeze({
+            category: "execution",
+            code: problem.code,
+            consumerId: problem.consumerId,
+            summary: problem.summary,
+        }));
+    }
+    table() {
+        if (this.problems.length > problems_ts_1.REPORT_PROBLEM_TABLE_MAX) {
+            return effect_1.Either.left({
+                code: "report-problem-table-limit",
+                maximum: problems_ts_1.REPORT_PROBLEM_TABLE_MAX,
+                observedAtLeast: this.problems.length,
+            });
+        }
+        return (0, problems_ts_1.reportProblemTable)(this.problems);
+    }
+}
+//# sourceMappingURL=execute.cjs.map