niceeval 0.12.2-canary.31 → 0.13.0

package/dist/report/execution/model.cjs

@@ -1,483 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeReportExecution = exports.REPORT_DOWNLOAD_FILE_BYTES_MAX = exports.REPORT_DOWNLOAD_FILES_MAX = exports.REPORT_PAGES_MAX = void 0;
-exports.reportExecution = reportExecution;
-exports.isReportExecution = isReportExecution;
-const effect_1 = require("effect");
-const identity_ts_1 = require("../author/identity.cjs");
-const document_ts_1 = require("../semantic/document.cjs");
-const problems_ts_1 = require("./problems.cjs");
-const results_ts_1 = require("./results.cjs");
-const reportExecutionTypeId = Symbol("@niceeval/report/ReportExecution");
+exports.REPORT_STATIC_ASSET_BYTES_MAX = exports.REPORT_SOURCE_DIFF_ASSET_BYTES_MAX = exports.REPORT_DIFF_ASSET_BYTES_MAX = exports.REPORT_SOURCE_ASSET_BYTES_MAX = exports.REPORT_DOWNLOAD_FILE_BYTES_MAX = exports.REPORT_DOWNLOAD_FILES_MAX = exports.REPORT_BUILD_RSS_BYTES_MAX = exports.REPORT_BUILD_TIME_MS_MAX = exports.REPORT_SITE_HTML_BYTES_MAX = exports.REPORT_PAGE_HTML_BYTES_MAX = exports.REPORT_DOCUMENT_DEPTH_MAX = exports.REPORT_DOCUMENT_NODES_MAX = exports.REPORT_PAGES_MAX = void 0;
+exports.reportBuildBudgetExceeded = reportBuildBudgetExceeded;
+exports.makeClosedSiteRevision = makeClosedSiteRevision;
+exports.closedSiteRevisionData = closedSiteRevisionData;
+exports.isClosedSiteRevision = isClosedSiteRevision;
+exports.compareUtf8 = compareUtf8;
+/** Full-site budgets fixed by docs/feature/reports/architecture.md. */
 exports.REPORT_PAGES_MAX = 20000;
+exports.REPORT_DOCUMENT_NODES_MAX = 20000;
+exports.REPORT_DOCUMENT_DEPTH_MAX = 32;
+exports.REPORT_PAGE_HTML_BYTES_MAX = 16777216;
+exports.REPORT_SITE_HTML_BYTES_MAX = 268435456;
+exports.REPORT_BUILD_TIME_MS_MAX = 120000;
+exports.REPORT_BUILD_RSS_BYTES_MAX = 1342177280;
 exports.REPORT_DOWNLOAD_FILES_MAX = 1000;
 exports.REPORT_DOWNLOAD_FILE_BYTES_MAX = 33554432;
-const executions = new WeakMap();
-const encoder = new TextEncoder();
-/**
- * Materializes an already-computed execution into canonical immutable values.
- * It does not read a Record, invoke author callbacks, render, or write files.
- */
-function reportExecution(input) {
-    try {
-        if (!(0, identity_ts_1.isReportId)(input.reportId)) {
-            throw invalid("reportId", "an execution must have a valid ReportId");
-        }
-        if (typeof input.sample !== "object" || input.sample === null) {
-            throw invalid("sample", "an execution must have an AnalysisSample");
-        }
-        if (!(0, problems_ts_1.isReportProblemTable)(input.problemTable)) {
-            throw invalid("problemTable", "an execution must use a host-owned problem table");
-        }
-        const projections = copyProjections(input.projections ?? [], input.problemTable);
-        const calculations = copyCalculations(input.calculations ?? [], input.problemTable);
-        const families = copyFamilies(input.families ?? [], input.problemTable);
-        const downloads = copyDownloads(input.downloads ?? [], input.problemTable);
-        const routes = routesFromPages(input.pages ?? []);
-        assertStaticClosure(routes, downloads.paths);
-        const pages = copyPages(input.pages ?? [], input.problemTable, routes, downloads.paths);
-        if (pages.length > exports.REPORT_PAGES_MAX) {
-            throw limit("pages", exports.REPORT_PAGES_MAX, pages.length);
-        }
-        const execution = Object.freeze({
-            reportId: input.reportId,
-            sample: freezeSample(input.sample),
-            projections,
-            calculations,
-            families,
-            pages,
-            downloads: downloads.results,
-            problemTable: input.problemTable,
-            [reportExecutionTypeId]: () => undefined,
-        });
-        executions.set(execution, true);
-        return effect_1.Either.right(execution);
-    }
-    catch (error) {
-        if (error instanceof ExecutionValueError) {
-            return effect_1.Either.left(error.value);
-        }
-        throw error;
-    }
-}
-exports.makeReportExecution = reportExecution;
-function isReportExecution(value) {
-    return typeof value === "object" && value !== null && executions.has(value);
-}
-function copyProjections(value, table) {
-    if (!Array.isArray(value)) {
-        throw invalid("projections", "projections must be an array");
-    }
-    const copied = value.map((summary, index) => {
-        if (typeof summary !== "object" || summary === null) {
-            throw invalid(`projections.${index}`, "a projection summary must be an object");
-        }
-        if (!(0, results_ts_1.isReportProjectionId)(summary.projectionId)) {
-            throw invalid(`projections.${index}.projectionId`, "a projection ID must be a bounded uint32");
-        }
-        if (!isInputKey(summary.inputKey)) {
-            throw invalid(`projections.${index}.inputKey`, "a projection input key is invalid");
-        }
-        return Object.freeze({
-            projectionId: summary.projectionId,
-            inputKey: summary.inputKey,
-            coverage: copyCoverage(summary.coverage, `projections.${index}.coverage`),
-            problemIds: problemIds(summary.problemIds, table, false, `projections.${index}.problemIds`),
-        });
-    });
-    copied.sort((left, right) => left.projectionId - right.projectionId);
-    copied.forEach((summary, index) => {
-        if (summary.projectionId !== index) {
-            throw invalid("projections", "projection IDs must be consecutive from zero in canonical order");
-        }
-    });
-    return Object.freeze(copied);
-}
-function copyCalculations(value, table) {
-    if (!Array.isArray(value)) {
-        throw invalid("calculations", "calculations must be an array");
-    }
-    const copied = value.map((result, index) => copyCalculation(result, table, `calculations.${index}`));
-    copied.sort((left, right) => compareText(left.calculationId, right.calculationId));
-    assertDistinctComponents(copied, "calculationId", "calculations");
-    return Object.freeze(copied);
-}
-function copyCalculation(value, table, path) {
-    if (typeof value !== "object" || value === null || !(0, identity_ts_1.isReportComponentId)(value.calculationId)) {
-        throw invalid(path, "a Calculation result must name a ReportComponentId");
-    }
-    switch (value.state) {
-        case "available":
-            return Object.freeze({
-                state: "available",
-                calculationId: value.calculationId,
-                value: value.value,
-                inputState: copyDataState(value.inputState, `${path}.inputState`),
-                problemIds: problemIds(value.problemIds, table, false, `${path}.problemIds`),
-            });
-        case "data-unavailable":
-        case "execution-failed":
-            return Object.freeze({
-                state: value.state,
-                calculationId: value.calculationId,
-                problemIds: problemIds(value.problemIds, table, true, `${path}.problemIds`),
-            });
-        default:
-            throw invalid(`${path}.state`, "a Calculation result state is not recognized");
-    }
-}
-function copyFamilies(value, table) {
-    if (!Array.isArray(value)) {
-        throw invalid("families", "families must be an array");
-    }
-    const copied = value.map((result, index) => {
-        const path = `families.${index}`;
-        if (typeof result !== "object" ||
-            result === null ||
-            !(0, identity_ts_1.isReportComponentId)(result.familyId) ||
-            !isCount(result.instanceCount)) {
-            throw invalid(path, "a PageFamily result is invalid");
-        }
-        if (result.state === "expanded") {
-            return Object.freeze({
-                state: "expanded",
-                familyId: result.familyId,
-                instanceCount: result.instanceCount,
-                problemIds: problemIds(result.problemIds, table, false, `${path}.problemIds`),
-            });
-        }
-        if (result.state === "data-unavailable" || result.state === "execution-failed") {
-            return Object.freeze({
-                state: result.state,
-                familyId: result.familyId,
-                instanceCount: result.instanceCount,
-                problemIds: problemIds(result.problemIds, table, true, `${path}.problemIds`),
-            });
-        }
-        throw invalid(`${path}.state`, "a PageFamily result state is not recognized");
-    });
-    copied.sort((left, right) => compareText(left.familyId, right.familyId));
-    assertDistinctComponents(copied, "familyId", "families");
-    return Object.freeze(copied);
-}
-function routesFromPages(value) {
-    if (!Array.isArray(value)) {
-        throw invalid("pages", "pages must be an array");
-    }
-    const routes = new Set();
-    value.forEach((page, index) => {
-        if (typeof page !== "object" || page === null || !(0, identity_ts_1.isReportComponentId)(page.pageId)) {
-            throw invalid(`pages.${index}`, "a Page result must name a ReportComponentId");
-        }
-        if (page.route !== undefined) {
-            if (!(0, identity_ts_1.isReportRoute)(page.route)) {
-                throw invalid(`pages.${index}.route`, "a Page route is invalid");
-            }
-        }
-        if (page.state === "rendered" && page.route === undefined) {
-            throw invalid(`pages.${index}.route`, "a rendered Page needs a route");
-        }
-        if (page.state === "rendered" && page.route !== undefined) {
-            if (routes.has(page.route)) {
-                throw invalid("pages", "two rendered pages cannot share a route");
-            }
-            routes.add(page.route);
-        }
-    });
-    return routes;
-}
-function copyPages(value, table, routes, downloads) {
-    const copied = value.map((result, index) => {
-        const path = `pages.${index}`;
-        if (typeof result !== "object" || result === null || !(0, identity_ts_1.isReportComponentId)(result.pageId)) {
-            throw invalid(path, "a Page result must name a ReportComponentId");
-        }
-        switch (result.state) {
-            case "rendered": {
-                if (!(0, identity_ts_1.isReportRoute)(result.route)) {
-                    throw invalid(`${path}.route`, "a rendered Page needs a valid route");
-                }
-                const validation = (0, document_ts_1.validateReportDocument)(result.document, { routes, downloads });
-                if (!validation.valid) {
-                    throw invalid(`${path}.document`, "a rendered Page must contain a valid closed semantic document");
-                }
-                return Object.freeze({
-                    state: "rendered",
-                    pageId: result.pageId,
-                    route: result.route,
-                    document: (0, document_ts_1.freezeReportDocument)(result.document),
-                    problemIds: problemIds(result.problemIds, table, false, `${path}.problemIds`),
-                });
-            }
-            case "data-unavailable":
-            case "execution-failed":
-                return Object.freeze({
-                    state: result.state,
-                    pageId: result.pageId,
-                    ...(result.route === undefined ? {} : { route: requireReportRoute(result.route, `${path}.route`) }),
-                    problemIds: problemIds(result.problemIds, table, true, `${path}.problemIds`),
-                });
-            default:
-                throw invalid(`${path}.state`, "a Page result state is not recognized");
-        }
+exports.REPORT_SOURCE_ASSET_BYTES_MAX = 8388608;
+exports.REPORT_DIFF_ASSET_BYTES_MAX = 4194304;
+exports.REPORT_SOURCE_DIFF_ASSET_BYTES_MAX = 134217728;
+exports.REPORT_STATIC_ASSET_BYTES_MAX = 268435456;
+function reportBuildBudgetExceeded(budget, maximum, observedAtLeast, target) {
+    return Object.freeze({
+        code: "report-build-budget-exceeded",
+        budget,
+        maximum,
+        observedAtLeast,
+        ...(target === undefined ? {} : target),
     });
-    copied.sort(comparePages);
-    return Object.freeze(copied);
 }
-function copyDownloads(value, table) {
-    if (!Array.isArray(value)) {
-        throw invalid("downloads", "downloads must be an array");
+const closedSiteRevisionTypeId = Symbol.for("niceeval.report.closed-site-revision/v1");
+function makeClosedSiteRevision(input) {
+    if (typeof input.contentHash !== "string" || input.contentHash.length === 0) {
+        throw new TypeError("ClosedSiteRevision requires a non-empty content hash");
     }
     const paths = new Set();
-    let fileCount = 0;
-    const copied = value.map((result, index) => {
-        const path = `downloads.${index}`;
-        if (typeof result !== "object" || result === null || !(0, identity_ts_1.isReportComponentId)(result.downloadId)) {
-            throw invalid(path, "a Download result must name a ReportComponentId");
-        }
-        if (result.state === "built") {
-            const inputFiles = result.files;
-            if (!Array.isArray(inputFiles)) {
-                throw invalid(`${path}.files`, "a built Download must contain files");
-            }
-            const files = inputFiles.map((file, fileIndex) => {
-                fileCount += 1;
-                if (fileCount > exports.REPORT_DOWNLOAD_FILES_MAX) {
-                    throw limit("download-files", exports.REPORT_DOWNLOAD_FILES_MAX, fileCount);
-                }
-                const filePath = `${path}.files.${fileIndex}`;
-                const copiedFile = copyDownloadFile(file, filePath);
-                if (paths.has(copiedFile.path)) {
-                    throw invalid("downloads", "download file paths must be unique across an execution");
-                }
-                paths.add(copiedFile.path);
-                return copiedFile;
-            });
-            return Object.freeze({
-                state: "built",
-                downloadId: result.downloadId,
-                files: Object.freeze(files),
-                problemIds: problemIds(result.problemIds, table, false, `${path}.problemIds`),
-            });
-        }
-        if (result.state === "data-unavailable" || result.state === "execution-failed") {
-            return Object.freeze({
-                state: result.state,
-                downloadId: result.downloadId,
-                problemIds: problemIds(result.problemIds, table, true, `${path}.problemIds`),
-            });
-        }
-        throw invalid(`${path}.state`, "a Download result state is not recognized");
-    });
-    copied.sort((left, right) => compareText(left.downloadId, right.downloadId));
-    assertDistinctComponents(copied, "downloadId", "downloads");
-    return Object.freeze({ results: Object.freeze(copied), paths });
-}
-function copyDownloadFile(value, path) {
-    if (typeof value !== "object" || value === null || !(0, identity_ts_1.isReportDownloadPath)(value.path)) {
-        throw invalid(path, "a Download file must use a valid ReportDownloadPath");
-    }
-    if (typeof value.mediaType !== "string" ||
-        value.mediaType.length === 0 ||
-        !hasOnlyUnicodeScalars(value.mediaType)) {
-        throw invalid(`${path}.mediaType`, "a Download media type must be a non-empty Unicode string");
-    }
-    if (!(value.bytes instanceof Uint8Array)) {
-        throw invalid(`${path}.bytes`, "Download bytes must be a Uint8Array");
-    }
-    if (value.bytes.byteLength > exports.REPORT_DOWNLOAD_FILE_BYTES_MAX) {
-        throw limit("download-file-bytes", exports.REPORT_DOWNLOAD_FILE_BYTES_MAX, value.bytes.byteLength);
-    }
-    return Object.freeze({
-        path: value.path,
-        mediaType: value.mediaType,
-        bytes: new Uint8Array(value.bytes),
+    const files = input.files.map((file) => {
+        if (!isPortablePath(file.path) || typeof file.mediaType !== "string" || file.mediaType.length === 0 ||
+            !(file.bytes instanceof Uint8Array)) {
+            throw new TypeError("ClosedSiteRevision files must contain a portable path, media type, and bytes");
+        }
+        if (paths.has(file.path))
+            throw new TypeError(`ClosedSiteRevision repeats file path ${JSON.stringify(file.path)}`);
+        paths.add(file.path);
+        return Object.freeze({
+            path: file.path,
+            mediaType: file.mediaType,
+            bytes: new Uint8Array(file.bytes),
+        });
     });
-}
-function assertStaticClosure(routes, downloads) {
-    const paths = [
-        ...[...routes].map(identity_ts_1.staticPathForReportRoute),
-        ...[...downloads].map(identity_ts_1.staticPathForReportDownload),
-    ];
-    for (let left = 0; left < paths.length; left += 1) {
-        for (let right = left + 1; right < paths.length; right += 1) {
-            if ((0, identity_ts_1.reportStaticPathConflict)(paths[left], paths[right]) !== undefined) {
-                throw invalid("closure", "route and download outputs cannot collide on supported filesystems");
-            }
-        }
-    }
-}
-function copyCoverage(value, path) {
-    if (typeof value !== "object" || value === null) {
-        throw invalid(path, "a projection summary needs coverage");
-    }
-    const sample = value.sample;
-    const entries = value.entries;
-    const attachments = value.attachments;
-    if (!countRecord(sample, ["denominator", "totalSlots", "included", "notRecorded", "coreInvalid", "excluded"]) ||
-        !countRecord(entries, ["total", "attachmentResult", "notRecorded", "coreInvalid", "excluded"]) ||
-        !countRecord(attachments, ["available", "unavailable", "migrationRequired", "migrationUnavailable", "unsupported", "invalid"])) {
-        throw invalid(path, "projection coverage must contain non-negative finite counts");
-    }
-    return Object.freeze({
-        sample: Object.freeze({
-            denominator: sample.denominator,
-            totalSlots: sample.totalSlots,
-            included: sample.included,
-            notRecorded: sample.notRecorded,
-            coreInvalid: sample.coreInvalid,
-            excluded: sample.excluded,
-        }),
-        entries: Object.freeze({
-            total: entries.total,
-            attachmentResult: entries.attachmentResult,
-            notRecorded: entries.notRecorded,
-            coreInvalid: entries.coreInvalid,
-            excluded: entries.excluded,
-        }),
-        attachments: Object.freeze({
-            available: attachments.available,
-            unavailable: attachments.unavailable,
-            migrationRequired: attachments.migrationRequired,
-            migrationUnavailable: attachments.migrationUnavailable,
-            unsupported: attachments.unsupported,
-            invalid: attachments.invalid,
+    files.sort((left, right) => compareUtf8(left.path, right.path));
+    const sourceRoutes = [...new Set(input.routes)];
+    const routes = [...sourceRoutes].sort(compareUtf8);
+    const defaultRoute = input.defaultRoute ?? sourceRoutes[0];
+    if (defaultRoute !== undefined && !routes.includes(defaultRoute)) {
+        throw new TypeError("ClosedSiteRevision default route must belong to its routes");
+    }
+    const revision = {
+        identity: Object.freeze({
+            format: "niceeval.report-site-revision/v1",
+            renderer: "niceeval.report-ssg/v1",
+            contentHash: input.contentHash,
         }),
+        files: Object.freeze(files),
+        routes: Object.freeze(routes),
+        ...(defaultRoute === undefined ? {} : { defaultRoute }),
+        problems: Object.freeze([...(input.problems ?? [])]),
+    };
+    Object.defineProperty(revision, closedSiteRevisionTypeId, {
+        value: true,
+        enumerable: false,
+        configurable: false,
+        writable: false,
     });
+    return Object.freeze(revision);
 }
-function countRecord(value, keys) {
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    const record = value;
-    return keys.every((key) => isCount(record[key]));
-}
-function copyDataState(value, path) {
-    if (typeof value !== "object" || value === null || (value.state !== "complete" && value.state !== "partial")) {
-        throw invalid(path, "a Calculation input state must be complete or partial");
-    }
-    return Object.freeze({ state: value.state });
-}
-function problemIds(value, table, required, path) {
-    if (!Array.isArray(value) || (required && value.length === 0)) {
-        throw invalid(path, required ? "this result requires at least one problem ID" : "problem IDs must be an array");
-    }
-    const copied = [];
-    const seen = new Set();
-    for (const id of value) {
-        if (!(0, problems_ts_1.isReportProblemId)(id) || table[id] === undefined || table[id].id !== id) {
-            throw invalid(path, "every problem ID must reference the execution problem table");
-        }
-        if (seen.has(id)) {
-            throw invalid(path, "a result cannot repeat a problem ID");
-        }
-        seen.add(id);
-        copied.push(id);
-    }
-    return Object.freeze(copied);
-}
-function requireReportRoute(value, path) {
-    if (!(0, identity_ts_1.isReportRoute)(value)) {
-        throw invalid(path, "a route is invalid");
-    }
+/** @internal The only way transports inspect an opaque revision. */
+function closedSiteRevisionData(value) {
+    if (!isClosedSiteRevision(value))
+        throw new TypeError("value is not a ClosedSiteRevision");
     return value;
 }
-function assertDistinctComponents(values, key, path) {
-    const ids = new Set();
-    for (const value of values) {
-        if (ids.has(value[key])) {
-            throw invalid(path, "component result IDs must be unique in canonical result tables");
-        }
-        ids.add(value[key]);
-    }
+function isClosedSiteRevision(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const brand = Object.getOwnPropertyDescriptor(value, closedSiteRevisionTypeId);
+    return brand !== undefined && "value" in brand && brand.value === true &&
+        Array.isArray(value.files) &&
+        typeof value.identity?.contentHash === "string";
 }
-function comparePages(left, right) {
-    const leftRoute = left.route;
-    const rightRoute = right.route;
-    if (leftRoute !== undefined && rightRoute !== undefined) {
-        const routeComparison = compareText(leftRoute, rightRoute);
-        return routeComparison === 0 ? compareText(left.pageId, right.pageId) : routeComparison;
-    }
-    if (leftRoute !== undefined) {
-        return -1;
-    }
-    if (rightRoute !== undefined) {
-        return 1;
-    }
-    return compareText(left.pageId, right.pageId);
+function isPortablePath(value) {
+    return value.length > 0 && !value.startsWith("/") && !value.endsWith("/") &&
+        !value.includes("\\") && !value.includes("\u0000") &&
+        value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
 }
-function compareText(left, right) {
-    if (left === right) {
+const encoder = new TextEncoder();
+function compareUtf8(left, right) {
+    if (left === right)
         return 0;
-    }
-    return left < right ? -1 : 1;
-}
-function isInputKey(value) {
-    return typeof value === "string" &&
-        /^[a-z][a-z0-9_-]*$/.test(value) &&
-        encoder.encode(value).byteLength <= 64;
-}
-function isCount(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-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 freezeSample(sample) {
-    try {
-        return deepFreeze(structuredClone(sample));
-    }
-    catch {
-        throw invalid("sample", "an AnalysisSample must be a cloneable pure value");
-    }
-}
-function deepFreeze(value, seen = new Set()) {
-    if (typeof value !== "object" || value === null || seen.has(value)) {
-        return value;
-    }
-    seen.add(value);
-    for (const key of Reflect.ownKeys(value)) {
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
-        if (descriptor !== undefined && "value" in descriptor) {
-            deepFreeze(descriptor.value, seen);
-        }
-    }
-    Object.freeze(value);
-    return value;
-}
-class ExecutionValueError extends Error {
-    value;
-    constructor(value) {
-        super(value.code);
-        this.value = value;
-    }
-}
-function invalid(path, reason) {
-    return new ExecutionValueError(Object.freeze({
-        code: "report-execution-invalid",
-        path: Object.freeze(path.split(".")),
-        reason,
-    }));
-}
-function limit(limitName, maximum, observedAtLeast) {
-    return new ExecutionValueError(Object.freeze({
-        code: "report-limit-exceeded",
-        limit: limitName,
-        maximum,
-        observedAtLeast,
-    }));
+    const leftBytes = encoder.encode(left);
+    const rightBytes = encoder.encode(right);
+    const length = Math.min(leftBytes.length, rightBytes.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = leftBytes[index] - rightBytes[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return leftBytes.length - rightBytes.length;
 }
 //# sourceMappingURL=model.cjs.map