niceeval 0.12.2-canary.31 → 0.13.0

package/dist/report/host/execute.cjs

@@ -1,1287 +1,506 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeReport = executeReport;
+exports.executeReportTarget = executeReportTarget;
+exports.executeReportSite = executeReportSite;
+exports.startReportBuildBudget = startReportBuildBudget;
+exports.reportDefinitionIdentity = reportDefinitionIdentity;
+exports.closedPageTitle = closedPageTitle;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
 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 react_1 = require("react");
+const server_1 = require("react-dom/server");
+const index_ts_1 = require("../../analysis/index.cjs");
+const capability_ts_1 = require("../../sample/capability.cjs");
+const report_ts_1 = require("../definition/report.cjs");
+const tree_ts_1 = require("../definition/tree.cjs");
+const downloads_ts_1 = require("../definition/primitives/downloads.cjs");
+const primitives_tsx_1 = require("../definition/primitives.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");
+const paths_ts_1 = require("../execution/paths.cjs");
+const assets_ts_1 = require("../extension/assets.cjs");
+const locale_ts_1 = require("../model/locale.cjs");
+const show_target_ts_1 = require("./show-target.cjs");
+const target_route_ts_1 = require("./target-route.cjs");
+const machine_ts_1 = require("../execution/machine.cjs");
+const TEXT_WIDTH = 80;
+const WEB_LOCALES = ["en", "zh-CN"];
 /**
- * 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.
+ * Executes exactly one selected route. It intentionally delegates selection to
+ * show-target.ts, whose parameterized branch never calls enumerate().
  */
-function executeReport(input) {
+function executeReportTarget(input) {
+    const request = (0, target_route_ts_1.showTargetRequestForRoute)(input.report, input.route);
+    if ((0, target_route_ts_1.isReportTargetRouteInvalid)(request))
+        return effect_1.Effect.fail(request);
     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 capture = yield* (0, capability_ts_1.captureAnalysisIssues)(input.sample);
+        return yield* effect_1.Effect.ensuring(effect_1.Effect.flatMap(
+        // show keeps the exact author declaration and never enumerates an
+        // unselected parameterized Page.
+        executeTarget({
+            ...input,
+            pages: input.report.pages,
+            request,
+            capture,
+        }), (page) => {
+            const costs = capturedProjectionCosts(capture, page.target.route, page.target.pageId);
+            const pricingProfile = reportPricingProfileJson(input.report);
+            const failure = (0, machine_ts_1.reportProjectionFailure)({ pricingProfile, costs });
+            if (failure !== undefined)
+                return effect_1.Effect.fail(failure);
+            return effect_1.Effect.succeed(Object.freeze({
+                page,
+                // Every cost entry captured during this one Page execution binds
+                // to that route/page and retains Analysis's measure/row/profile.
+                projections: (0, machine_ts_1.buildReportProjections)({
+                    pricingProfile,
+                    costs,
+                }),
+                problems: analysisProblems(capture.issues(), page.target.pageId),
             }));
-            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,
-        };
+        }), effect_1.Effect.sync(() => capture.close()));
     });
 }
-function executePageFamily(input) {
+/** Enumerates and closes every page instance exactly once for view/static. */
+function executeReportSite(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([]),
-                });
+        const { startedAtMs, baselineRssBytes } = input.budget;
+        // The outer capture covers enumerate()/params encode phases for generic
+        // Analysis issues only. Cost projections belong only to actual Page
+        // executions, where the Host can bind a real route/pageId.
+        const outerCapture = yield* (0, capability_ts_1.captureAnalysisIssues)(input.sample);
+        return yield* effect_1.Effect.ensuring(effect_1.Effect.gen(function* () {
+            const pages = [];
+            const routeOwners = new Map();
+            const siteIssues = [];
+            const projectionCosts = [];
+            const pricingProfile = reportPricingProfileJson(input.report);
+            // The Report declaration is the only page owner. A custom Report that
+            // wants official drill-down Pages composes those exported Pages
+            // explicitly; the Host never merges another Report by id.
+            const definitions = input.report.pages;
+            const plainCount = definitions.filter((page) => page.params === undefined).length;
+            if (plainCount > model_ts_1.REPORT_PAGES_MAX) {
+                return yield* effect_1.Effect.fail((0, model_ts_1.reportBuildBudgetExceeded)("pages", model_ts_1.REPORT_PAGES_MAX, plainCount));
             }
-            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",
+            for (const definition of definitions) {
+                yield* checkBuildBudgets(input.budget);
+                if (definition.params === undefined) {
+                    const { page, projectionCosts: pageCosts, issues } = yield* executePageWithCapture({
+                        ...input,
+                        pages: definitions,
+                        request: { kind: "page", pageId: definition.id },
+                        capturePage: (capture) => capturedProjectionCosts(capture, definition.path, definition.id),
                     });
-                return Object.freeze({
-                    result: failedFamily({
-                        familyId: input.descriptor.id,
-                        problemIds: uniqueProblemIds([...prepared.dataProblemIds, problemId]),
-                    }),
-                    pages: Object.freeze([]),
-                });
+                    yield* addSitePage(pages, routeOwners, page, definition.navigation);
+                    yield* registerProjectionCosts(pricingProfile, projectionCosts, pageCosts);
+                    siteIssues.push(...issues);
+                    continue;
+                }
+                const values = yield* invokeAuthor(definition.id, "enumerate", outerCapture, () => definition.params.enumerate(input.sample));
+                if (values === null || values === undefined || typeof values[Symbol.iterator] !== "function") {
+                    return yield* effect_1.Effect.fail(pageFailure(definition.id, "enumerate", "params.enumerate() must return a finite Iterable"));
+                }
+                for (const params of values) {
+                    if (pages.length >= model_ts_1.REPORT_PAGES_MAX) {
+                        return yield* effect_1.Effect.fail((0, model_ts_1.reportBuildBudgetExceeded)("pages", model_ts_1.REPORT_PAGES_MAX, pages.length + 1));
+                    }
+                    const key = yield* invokeAuthor(definition.id, "params-encode", outerCapture, () => definition.params.encode(params));
+                    const invalidKey = typeof key === "string" ? (0, paths_ts_1.validateParameterKey)(key) : undefined;
+                    if (typeof key !== "string" || invalidKey !== undefined) {
+                        return yield* effect_1.Effect.fail(pageFailure(definition.id, "params-encode", invalidKey?.reason ?? "params.encode() must return a canonical parameter key"));
+                    }
+                    const route = (0, paths_ts_1.routeWithParameterKey)(definition.path, key);
+                    const routeIssue = (0, paths_ts_1.validateReportRoute)(route);
+                    if (routeIssue !== undefined) {
+                        return yield* effect_1.Effect.fail(pageFailure(definition.id, "params-encode", routeIssue.reason));
+                    }
+                    // executeShowTarget supplies the required decode -> encode
+                    // canonical round trip, but does not enumerate this page again.
+                    const { page, projectionCosts: pageCosts, issues } = yield* executePageWithCapture({
+                        ...input,
+                        pages: definitions,
+                        request: {
+                            kind: "parameterized-page",
+                            pageId: definition.id,
+                            key,
+                            route,
+                        },
+                        capturePage: (capture) => capturedProjectionCosts(capture, route, definition.id),
+                    });
+                    yield* addSitePage(pages, routeOwners, page, false);
+                    yield* registerProjectionCosts(pricingProfile, projectionCosts, pageCosts);
+                    siteIssues.push(...issues);
+                    yield* checkBuildBudgets(input.budget);
+                }
             }
-            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",
-                },
+            siteIssues.push(...outerCapture.issues());
+            return Object.freeze({
+                startedAtMs,
+                baselineRssBytes,
+                sampleIdentity: input.sample.snapshot.identity.id,
+                reportIdentity: reportDefinitionIdentity(input.report),
+                title: (0, report_ts_1.resolveReportTitle)(input.report),
+                ...(input.report.theme === undefined ? {} : { theme: input.report.theme }),
+                pages: Object.freeze(pages),
+                projections: (0, machine_ts_1.buildReportProjections)({
+                    pricingProfile,
+                    costs: projectionCosts,
+                }),
+                problems: analysisProblems(mergeAnalysisIssues(siteIssues)),
             });
-            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),
-        });
+        }), effect_1.Effect.sync(() => outerCapture.close()));
     });
 }
-function executeDownload(input) {
+/** One Page execution with its own capture: page, bound projection costs, and issues. */
+function executePageWithCapture(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,
-        };
+        const capture = yield* (0, capability_ts_1.captureAnalysisIssues)(input.sample);
+        return yield* effect_1.Effect.ensuring(effect_1.Effect.map(executeTarget({ ...input, capture }), (page) => Object.freeze({
+            page,
+            projectionCosts: Object.freeze(input.capturePage(capture)),
+            issues: capture.issues(),
+        })), effect_1.Effect.sync(() => capture.close()));
     });
 }
-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,
-    });
+/**
+ * Validates one Page's capture before retaining it. Route ownership makes
+ * capture keys page-local, so re-closing every prior Page here would only
+ * repeat canonical JSON work quadratically; the final site closure performs
+ * the one whole-site canonicalization.
+ */
+function registerProjectionCosts(pricingProfile, output, costs) {
+    const failure = (0, machine_ts_1.reportProjectionFailure)({ pricingProfile, costs });
+    if (failure !== undefined)
+        return effect_1.Effect.fail(failure);
+    output.push(...costs);
+    return effect_1.Effect.void;
 }
-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),
-    });
+/**
+ * Reads the cost entries an Analysis execution capture recorded and binds them
+ * to one Page execution.  The Host never rebuilds a projection from a
+ * MetricValue.value or from the built-in show data.
+ */
+function capturedProjectionCosts(capture, route, pageId) {
+    return capture.costEntries().map((entry) => Object.freeze({
+        page: Object.freeze({ pageId, route }),
+        measureId: entry.measureId,
+        row: Object.freeze({ key: entry.row.key, dimensions: entry.row.dimensions }),
+        profileIdentity: entry.profileIdentity,
+        projection: entry.projection,
+    }));
 }
-function emptyPreparedInputs() {
-    return Object.freeze({
-        inputs: Object.freeze({}),
-        partial: false,
-        dataProblemIds: Object.freeze([]),
-        projectionProblemIds: Object.freeze([]),
-    });
+/** The closed JSON form of the Report's PricingProfile, or null without one. */
+function reportPricingProfileJson(report) {
+    return report.pricing === null ? null : (0, machine_ts_1.closePricingProfileJson)(report.pricing);
 }
-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,
-                    });
-            }
-        }
+/** Merges per-Page issue captures into the site-wide problem table input. */
+function mergeAnalysisIssues(issues) {
+    const unique = new Map();
+    for (const issue of issues) {
+        const key = `${issue.code}\u0000${issue.message}\u0000${issue.refs
+            .map((ref) => ref.identity.locator).sort(compareUtf8).join("\u0001")}`;
+        if (!unique.has(key))
+            unique.set(key, issue);
     }
+    return Object.freeze([...unique.values()].sort((left, right) => compareUtf8(left.code, right.code) || compareUtf8(left.message, right.message)));
 }
-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({
+function executeTarget(input) {
+    return (0, show_target_ts_1.executeShowTarget)({
+        definition: { pages: input.pages },
         sample: input.sample,
-        inputs: input.prepared.inputs,
-        calculations: calculationContextValues(input.references, input.calculationResults),
+        request: input.request,
+        evidence: (locator) => (0, index_ts_1.query)(input.sample, {
+            kind: "domain-view",
+            view: index_ts_1.attemptEvidenceView,
+            locator,
+        }),
+        runAuthor: input.capture.run,
+        close: (rendered, context) => closeRenderedPage({
+            rendered: rendered,
+            sample: input.sample,
+            report: input.report,
+            capture: input.capture,
+            hrefPages: input.pages,
+            page: context.page,
+            route: context.target.route,
+        }),
     });
 }
-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,
+function closeRenderedPage(input) {
+    return effect_1.Effect.tryPromise({
+        try: () => input.capture.run(async () => {
+            const resolved = await (0, tree_ts_1.resolveReportTree)(input.rendered, {
+                scope: input.sample,
+                page: input.page,
+                report: (0, report_ts_1.buildReportMeta)(input.report),
             });
-        case "data-unavailable":
-            return Object.freeze({
-                state: "data-unavailable",
-                problemIds: result.problemIds,
+            (0, tree_ts_1.validateReportTree)(resolved);
+            assertDocumentBudget(resolved, input.page.id, input.page.path);
+            const text = WEB_LOCALES.map((locale) => {
+                const pageDimensions = (0, tree_ts_1.collectPageDimensions)(resolved, input.report.dimensionPins, "text");
+                const context = (0, tree_ts_1.createTextContext)({
+                    width: TEXT_WIDTH,
+                    locale,
+                    pageDimensions,
+                    command: (target) => commandForTarget(input.hrefPages, target),
+                });
+                return Object.freeze({
+                    locale,
+                    width: TEXT_WIDTH,
+                    text: (0, tree_ts_1.renderNodeToText)(resolved, context),
+                });
+            });
+            const web = WEB_LOCALES.map((locale) => {
+                const pageDimensions = (0, tree_ts_1.collectPageDimensions)(resolved, input.report.dimensionPins, "web");
+                const context = (0, tree_ts_1.withPageDimensions)({
+                    locale,
+                    href: (target) => hrefForTarget(input.hrefPages, input.route, target),
+                    dimension: () => {
+                        throw new Error("a Report web face queried an undeclared dimension");
+                    },
+                }, pageDimensions);
+                const html = (0, tree_ts_1.runWithWebContext)(Object.freeze(context), () => (0, server_1.renderToStaticMarkup)((0, react_1.createElement)(react_1.Fragment, null, resolved)));
+                return Object.freeze({ locale, html });
             });
-        case "execution-failed":
+            const downloads = (0, downloads_ts_1.collectDownloads)(resolved).map((download) => Object.freeze({
+                id: download.path,
+                path: download.path,
+                mediaType: download.mediaType,
+                bytes: download.bytes,
+            }));
+            const rendererAssets = await (0, assets_ts_1.materializeRendererAssets)((0, assets_ts_1.collectRendererAssetDeclarations)(resolved), async (path) => new Uint8Array(await (0, promises_1.readFile)(path)));
+            const assets = [
+                ...rendererAssets.styles.map((asset) => Object.freeze({
+                    kind: "style",
+                    path: asset.path,
+                    mediaType: "text/css; charset=utf-8",
+                    bytes: asset.content,
+                    sha256: asset.hash,
+                })),
+                ...rendererAssets.scripts.map((asset) => Object.freeze({
+                    kind: "script",
+                    path: asset.path,
+                    mediaType: "text/javascript; charset=utf-8",
+                    bytes: asset.content,
+                    sha256: asset.hash,
+                })),
+            ];
             return Object.freeze({
-                state: "execution-failed",
-                problemIds: result.problemIds,
+                title: input.page.title,
+                head: input.report.head,
+                text: Object.freeze(text),
+                web: Object.freeze(web),
+                downloads: Object.freeze(downloads),
+                assets: Object.freeze(assets),
             });
-    }
-}
-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),
+        }),
+        catch: (cause) => pageFailure(input.page.id, classifyCloseFailure(cause), boundedReason(cause)),
     });
 }
-function failedDownload(input) {
-    return Object.freeze({
-        kind: "failed",
-        state: input.state,
-        downloadId: input.downloadId,
-        problemIds: requireProblemIds(input.problemIds),
+function invokeAuthor(pageId, phase, capture, callback) {
+    return effect_1.Effect.tryPromise({
+        try: () => new Promise((resolve) => resolve(capture.run(callback))),
+        catch: (cause) => pageFailure(pageId, phase, boundedReason(cause)),
     });
 }
-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),
+function addSitePage(pages, routeOwners, page, navigation) {
+    const owner = routeOwners.get(page.target.route);
+    if (owner !== undefined) {
+        return effect_1.Effect.fail(Object.freeze({
+            code: "report-site-route-conflict",
+            route: page.target.route,
+            pageIds: Object.freeze([owner, page.target.pageId]),
         }));
     }
-    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",
-        });
+    if (pages.length >= model_ts_1.REPORT_PAGES_MAX) {
+        return effect_1.Effect.fail((0, model_ts_1.reportBuildBudgetExceeded)("pages", model_ts_1.REPORT_PAGES_MAX, pages.length + 1));
     }
+    routeOwners.set(page.target.route, page.target.pageId);
+    pages.push(Object.freeze({ page, navigation }));
+    return effect_1.Effect.void;
 }
-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;
+/** Starts the budget before Record selection opens the fixed Sample. */
+function startReportBuildBudget() {
+    return Object.freeze({
+        startedAtMs: Date.now(),
+        baselineRssBytes: process.memoryUsage().rss,
+    });
 }
-function validateCandidateDocument(document, routes, downloads) {
+function checkBuildBudgets(anchor) {
+    const elapsed = Date.now() - anchor.startedAtMs;
+    if (elapsed > model_ts_1.REPORT_BUILD_TIME_MS_MAX) {
+        return effect_1.Effect.fail((0, model_ts_1.reportBuildBudgetExceeded)("build-time", model_ts_1.REPORT_BUILD_TIME_MS_MAX, elapsed));
+    }
+    const rssGrowth = Math.max(0, process.memoryUsage().rss - anchor.baselineRssBytes);
+    if (rssGrowth > model_ts_1.REPORT_BUILD_RSS_BYTES_MAX) {
+        return effect_1.Effect.fail((0, model_ts_1.reportBuildBudgetExceeded)("build-rss", model_ts_1.REPORT_BUILD_RSS_BYTES_MAX, rssGrowth));
+    }
+    return effect_1.Effect.void;
+}
+function assertDocumentBudget(node, pageId, route) {
+    const observed = countDocument(node, 0);
+    if (observed.nodes > model_ts_1.REPORT_DOCUMENT_NODES_MAX) {
+        throw (0, model_ts_1.reportBuildBudgetExceeded)("document-nodes", model_ts_1.REPORT_DOCUMENT_NODES_MAX, observed.nodes, { pageId, route });
+    }
+    if (observed.depth > model_ts_1.REPORT_DOCUMENT_DEPTH_MAX) {
+        throw (0, model_ts_1.reportBuildBudgetExceeded)("document-depth", model_ts_1.REPORT_DOCUMENT_DEPTH_MAX, observed.depth, { pageId, route });
+    }
+}
+function countDocument(node, depth) {
+    if (node === null || node === undefined || typeof node === "boolean")
+        return { nodes: 0, depth };
+    if (Array.isArray(node)) {
+        return node.reduce((total, child) => {
+            const counted = countDocument(child, depth);
+            return { nodes: total.nodes + counted.nodes, depth: Math.max(total.depth, counted.depth) };
+        }, { nodes: 0, depth });
+    }
+    if (!isElement(node))
+        return { nodes: 1, depth: depth + 1 };
+    const currentDepth = depth + 1;
+    if (node.type !== tree_ts_1.Fragment && typeof node.type === "function" &&
+        node.type[tree_ts_1.COMPONENT_RAW_CHILDREN] === true) {
+        return { nodes: 1, depth: currentDepth };
+    }
+    const child = countDocument(node.props.children, currentDepth);
+    return { nodes: child.nodes + 1, depth: Math.max(currentDepth, child.depth) };
+}
+function isElement(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const candidate = value;
+    return typeof candidate.$$typeof === "symbol" &&
+        (candidate.$$typeof === Symbol.for("react.element") || candidate.$$typeof === Symbol.for("react.transitional.element")) &&
+        typeof candidate.props === "object" && candidate.props !== null;
+}
+function routeForTarget(pages, target) {
+    const page = pages.find((candidate) => candidate.id === target.page);
+    if (page === undefined)
+        return undefined;
+    if (page.params === undefined)
+        return target.params === undefined ? page.path : undefined;
+    if (target.params === undefined)
+        return undefined;
     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)),
-        });
+        const key = page.params.encode(target.params);
+        return (0, paths_ts_1.validateParameterKey)(key) === undefined ? (0, paths_ts_1.routeWithParameterKey)(page.path, key) : undefined;
     }
     catch {
-        return Object.freeze({ state: "invalid" });
+        return undefined;
     }
 }
-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;
-        }
+function hrefForTarget(pages, sourceRoute, target) {
+    const source = (0, paths_ts_1.staticPathForRoute)(sourceRoute).posix;
+    if (target.page === primitives_tsx_1.DOWNLOAD_TARGET_PAGE) {
+        const path = isJsonRecord(target.params) ? target.params.path : undefined;
+        if (typeof path !== "string" || (0, paths_ts_1.validateDownloadPath)(path) !== undefined)
+            return undefined;
+        return relativeHref(source, (0, paths_ts_1.staticPathForDownload)(path).posix);
+    }
+    const route = routeForTarget(pages, target);
+    return route === undefined ? undefined : relativeHref(source, (0, paths_ts_1.staticPathForRoute)(route).posix);
+}
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function relativeHref(sourceFile, targetFile) {
+    const sourceSegments = sourceFile.split("/");
+    sourceSegments.pop();
+    const targetSegments = targetFile.split("/");
+    let common = 0;
+    while (common < sourceSegments.length && common < targetSegments.length &&
+        sourceSegments[common] === targetSegments[common])
+        common += 1;
+    const relative = [
+        ...sourceSegments.slice(common).map(() => ".."),
+        ...targetSegments.slice(common),
+    ].join("/");
+    return relative || "./";
+}
+function commandForTarget(pages, target) {
+    const route = routeForTarget(pages, target);
+    return route === undefined ? undefined : `niceeval show --page ${shellQuote(route)}`;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function analysisProblems(issues, pageId) {
+    return Object.freeze(issues.map((issue) => Object.freeze({
+        code: `analysis-${issue.code}`,
+        path: Object.freeze(pageId === undefined ? [] : ["page", pageId]),
+        refs: Object.freeze(issue.refs.map((reference) => String(reference.identity.locator)).sort(compareUtf8)),
+        summary: issue.message,
+    })));
+}
+function reportDefinitionIdentity(report) {
+    const closed = {
+        title: (0, report_ts_1.resolveReportTitle)(report),
+        head: report.head,
+        theme: report.theme ?? null,
+        // The Analysis-computed pricing content identity joins the definition
+        // identity, so a Profile change is a new Report execution.
+        pricing: report.pricing === null ? null : report.pricing.contentIdentity,
+        pages: report.pages.map((page) => ({
+            id: page.id,
+            path: page.path,
+            title: page.title,
+            navigation: page.navigation,
+            parameterized: page.params !== undefined,
+            load: page.load?.toString() ?? null,
+            render: page.render.toString(),
+            params: page.params === undefined
+                ? null
+                : {
+                    encode: page.params.encode.toString(),
+                    decode: page.params.decode.toString(),
+                    enumerate: page.params.enumerate.toString(),
+                },
+        })),
     };
-    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);
-    }
+    return (0, node_crypto_1.createHash)("sha256").update(canonicalJson(closed)).digest("hex");
+}
+function canonicalJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number")
+        return Number.isFinite(value) ? JSON.stringify(Object.is(value, -0) ? 0 : value) : "null";
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value === "object") {
+        return `{${Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => compareUtf8(left, right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+    }
+    return JSON.stringify(String(value));
+}
+function classifyCloseFailure(cause) {
+    const message = boundedReason(cause).toLowerCase();
+    if (message.includes("asset") || message.includes("enoent"))
+        return "assets";
+    if (message.includes("text"))
+        return "text";
+    if (message.includes("web") || message.includes("react"))
+        return "web";
+    return "resolve";
+}
+function pageFailure(pageId, phase, reason) {
+    return Object.freeze({ code: "report-page-execution-failed", pageId, phase, reason });
+}
+function boundedReason(cause) {
+    const raw = cause instanceof Error ? cause.message : typeof cause === "object" && cause !== null &&
+        typeof Reflect.get(cause, "code") === "string"
+        ? String(Reflect.get(cause, "code"))
+        : String(cause);
+    return raw.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 512).trim() || "Report callback failed";
+}
+function compareUtf8(left, right) {
+    return Buffer.compare(Buffer.from(left), Buffer.from(right));
+}
+/** Used by the site shell without re-running any author callback. */
+function closedPageTitle(page, locale) {
+    return (0, locale_ts_1.resolveLocalizedText)(page.title, locale);
 }
 //# sourceMappingURL=execute.cjs.map