project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-applicability-identity.d.ts

@@ -1,25 +0,0 @@
-import type { ClaimApplicabilityV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function claimApplicabilityProfile(contract: Pick<DeliveryContractV2, "global" | "outcomes">, outcomeKey: string | null, applicabilityRef: string): ClaimApplicabilityV2 | null;
-export declare function canonicalApplicabilityProfile(profile: ClaimApplicabilityV2): {
-    target_ref: string;
-    journey_role: ClaimApplicabilityV2["journey_role"];
-    dimensions: Array<{
-        key: string;
-        value: string;
-    }>;
-    given_refs: string[];
-    when_refs: string[];
-};
-export declare function canonicalApplicabilityIdentity(profile: ClaimApplicabilityV2): string;
-export declare function sameApplicabilityProfile(left: ClaimApplicabilityV2, right: ClaimApplicabilityV2): boolean;
-export interface OutcomeApplicabilityPairV1 {
-    outcome_ref: string;
-    applicability_ref: string;
-}
-export declare function globalCompatibleOutcomeApplicabilityCoverage(contract: Pick<DeliveryContractV2, "outcomes">, globalProfile: ClaimApplicabilityV2): {
-    target_outcome_refs: string[];
-    required_pairs: OutcomeApplicabilityPairV1[];
-    missing_outcome_refs: string[];
-};
-export declare function sameOutcomeApplicabilityCoverage(required: readonly OutcomeApplicabilityPairV1[], actual: readonly OutcomeApplicabilityPairV1[]): boolean;
-export declare function outcomeApplicabilityPairIdentity(pair: OutcomeApplicabilityPairV1): string;

package/dist/lib/long-task-applicability-identity.js

@@ -1,60 +0,0 @@
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export function claimApplicabilityProfile(contract, outcomeKey, applicabilityRef) {
-    const profiles = outcomeKey
-        ? contract.outcomes.find((outcome) => outcome.key === outcomeKey)
-            ?.applicability
-        : contract.global.applicability;
-    return profiles?.find((profile) => profile.key === applicabilityRef) ?? null;
-}
-export function canonicalApplicabilityProfile(profile) {
-    return {
-        target_ref: profile.target_ref,
-        journey_role: profile.journey_role,
-        dimensions: [...profile.dimensions]
-            .sort((left, right) => left.key.localeCompare(right.key) ||
-            left.value.localeCompare(right.value))
-            .map((dimension) => ({
-            key: dimension.key,
-            value: dimension.value,
-        })),
-        given_refs: [...profile.given_refs].sort(),
-        when_refs: [...profile.when_refs],
-    };
-}
-export function canonicalApplicabilityIdentity(profile) {
-    return sha256Hex(canonicalValueJson(canonicalApplicabilityProfile(profile)));
-}
-export function sameApplicabilityProfile(left, right) {
-    return (canonicalApplicabilityIdentity(left) ===
-        canonicalApplicabilityIdentity(right));
-}
-export function globalCompatibleOutcomeApplicabilityCoverage(contract, globalProfile) {
-    const targetOutcomes = contract.outcomes.filter((outcome) => outcome.applicability.some((profile) => profile.target_ref === globalProfile.target_ref));
-    const missing = [];
-    const required = targetOutcomes.flatMap((outcome) => {
-        const compatible = outcome.applicability.filter((profile) => sameApplicabilityProfile(globalProfile, profile));
-        if (!compatible.length)
-            missing.push(outcome.key);
-        return compatible.map((profile) => ({
-            outcome_ref: outcome.key,
-            applicability_ref: profile.key,
-        }));
-    });
-    return {
-        target_outcome_refs: targetOutcomes.map((outcome) => outcome.key).sort(),
-        required_pairs: sortOutcomeApplicabilityPairs(required),
-        missing_outcome_refs: missing.sort(),
-    };
-}
-export function sameOutcomeApplicabilityCoverage(required, actual) {
-    const left = sortOutcomeApplicabilityPairs(required).map(outcomeApplicabilityPairIdentity);
-    const right = sortOutcomeApplicabilityPairs(actual).map(outcomeApplicabilityPairIdentity);
-    return (left.length === right.length &&
-        left.every((identity, index) => identity === right[index]));
-}
-export function outcomeApplicabilityPairIdentity(pair) {
-    return `${pair.outcome_ref}\0${pair.applicability_ref}`;
-}
-function sortOutcomeApplicabilityPairs(pairs) {
-    return [...pairs].sort((left, right) => outcomeApplicabilityPairIdentity(left).localeCompare(outcomeApplicabilityPairIdentity(right)));
-}

package/dist/lib/long-task-applicability-shape.d.ts

@@ -1,4 +0,0 @@
-import type { ApplicableKeyedStatementV2, ClaimApplicabilityV2 } from "./long-task-semantic-contract-types.js";
-export declare function parseClaimApplicability(value: unknown, label: string): ClaimApplicabilityV2[];
-export declare function parseApplicableKeyedStatements(value: unknown, label: string): ApplicableKeyedStatementV2[];
-export declare function parseKeyRefs(value: unknown, label: string): string[];

package/dist/lib/long-task-applicability-shape.js

@@ -1,54 +0,0 @@
-import { array, key, literal, object, semanticRef, string, strings, } from "./long-task-shape-primitives.js";
-const JOURNEY_ROLES = [
-    "success",
-    "degradation",
-    "recovery",
-    "stage_gate",
-    "conformance",
-];
-export function parseClaimApplicability(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "target_ref",
-            "journey_role",
-            "dimensions",
-            "given_refs",
-            "when_refs",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            target_ref: key(row.target_ref, `${itemLabel}.target_ref`),
-            journey_role: literal(row.journey_role, JOURNEY_ROLES, `${itemLabel}.journey_role`),
-            dimensions: array(row.dimensions, `${itemLabel}.dimensions`).map((dimension, dimensionIndex) => {
-                const dimensionLabel = `${itemLabel}.dimensions[${dimensionIndex}]`;
-                const entry = object(dimension, dimensionLabel, ["key", "value"]);
-                return {
-                    key: semanticRef(entry.key, `${dimensionLabel}.key`),
-                    value: semanticRef(entry.value, `${dimensionLabel}.value`),
-                };
-            }),
-            given_refs: parseKeyRefs(row.given_refs, `${itemLabel}.given_refs`),
-            when_refs: parseKeyRefs(row.when_refs, `${itemLabel}.when_refs`),
-        };
-    });
-}
-export function parseApplicableKeyedStatements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "statement",
-            "applicability_refs",
-        ]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-            applicability_refs: parseKeyRefs(row.applicability_refs, `${itemLabel}.applicability_refs`),
-        };
-    });
-}
-export function parseKeyRefs(value, label) {
-    return strings(value, label).map((item, index) => key(item, `${label}[${index}]`));
-}

package/dist/lib/long-task-artifacts.d.ts

@@ -1,6 +0,0 @@
-import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
-export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, admittedObservationKey, classifyObservationCarrier, createJsonPointerExactBudget, extractJsonPointerExactObservation, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, jsonPointerExactLocatorForIdentity, observationAdmissionDecision, prepareAdmittedObservations, } from "./long-task-admitted-observation.js";
-export declare function collectCheckArtifacts(check: CompiledCheckV2, snapshotRoot: string): Promise<{
-    hashes: Record<string, string>;
-    errors: string[];
-}>;

package/dist/lib/long-task-artifacts.js

@@ -1,35 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { sha256Hex } from "./strict-codec.js";
-export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, admittedObservationKey, classifyObservationCarrier, createJsonPointerExactBudget, extractJsonPointerExactObservation, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, jsonPointerExactLocatorForIdentity, observationAdmissionDecision, prepareAdmittedObservations, } from "./long-task-admitted-observation.js";
-export async function collectCheckArtifacts(check, snapshotRoot) {
-    if (!check.artifact_globs.length)
-        return { hashes: {}, errors: [] };
-    const candidates = [];
-    async function visit(directory, relative = "") {
-        for (const entry of await readdir(directory, { withFileTypes: true })) {
-            if (!relative && entry.name === ".git")
-                continue;
-            const next = relative ? `${relative}/${entry.name}` : entry.name;
-            if (entry.isSymbolicLink() || entry.name === "node_modules")
-                continue;
-            if (entry.isDirectory())
-                await visit(path.join(directory, entry.name), next);
-            else if (entry.isFile())
-                candidates.push(next);
-        }
-    }
-    await visit(snapshotRoot);
-    const selected = [
-        ...new Set(check.artifact_globs.flatMap((pattern) => candidates.filter((candidate) => matchesRepoPattern(candidate, pattern)))),
-    ].sort();
-    const hashes = Object.fromEntries(await Promise.all(selected.map(async (relative) => [
-        relative,
-        sha256Hex(await readFile(path.join(snapshotRoot, ...relative.split("/")))),
-    ])));
-    const errors = check.artifact_globs
-        .filter((pattern) => !selected.some((file) => matchesRepoPattern(file, pattern)))
-        .map((pattern) => `artifact_glob_empty:${pattern}`);
-    return { hashes, errors };
-}

package/dist/lib/long-task-assertions-v2.d.ts

@@ -1,22 +0,0 @@
-import type { DeliveryAssertionV2, PopulationRequirementV2 } from "./long-task-delivery-types.js";
-export interface AssertionComparison {
-    comparable: boolean;
-    passed: boolean;
-}
-export interface DeliveryAssertionEvaluation {
-    passed: boolean;
-    status: "passed" | "observation_missing" | "observation_type_mismatch" | "assertion_value_mismatch";
-    expected?: unknown;
-    actual?: unknown;
-}
-export declare function evaluateDeliveryAssertion(assertion: DeliveryAssertionV2, observations: Record<string, unknown>): boolean;
-export declare function evaluateDeliveryAssertionDetailed(assertion: DeliveryAssertionV2, observations: Record<string, unknown>): DeliveryAssertionEvaluation;
-export declare function evaluatePopulation(requirement: PopulationRequirementV2, observations: Record<string, unknown>): {
-    passed: boolean;
-    actual: unknown;
-    reason: string | null;
-};
-export declare function observationValue(observations: Record<string, unknown>, name: string): {
-    found: boolean;
-    value: unknown;
-};

package/dist/lib/long-task-assertions-v2.js

@@ -1,220 +0,0 @@
-import { canonicalValueJson } from "./strict-codec.js";
-export function evaluateDeliveryAssertion(assertion, observations) {
-    return evaluateDeliveryAssertionDetailed(assertion, observations).passed;
-}
-export function evaluateDeliveryAssertionDetailed(assertion, observations) {
-    const { found, value } = observationValue(observations, assertion.observation);
-    if (!found)
-        return {
-            passed: false,
-            status: "observation_missing",
-            expected: assertion.expected,
-        };
-    if (assertion.operator === "exists")
-        return { passed: true, status: "passed", actual: value };
-    const expected = assertion.expected;
-    let comparison;
-    switch (assertion.operator) {
-        case "truthy":
-            return result(Boolean(value), true, value);
-        case "falsy":
-            return result(!value, false, value);
-        case "equals":
-            comparison = comparableEquals(value, expected, false);
-            break;
-        case "not_equals":
-            comparison = comparableEquals(value, expected, true);
-            break;
-        case "contains":
-            comparison = contains(value, expected);
-            break;
-        case "not_contains":
-            comparison = contains(value, expected);
-            comparison = {
-                comparable: comparison.comparable,
-                passed: comparison.comparable && !comparison.passed,
-            };
-            break;
-        case "matches":
-            comparison = matches(value, expected);
-            break;
-        case "not_matches":
-            comparison = matches(value, expected);
-            comparison = {
-                comparable: comparison.comparable,
-                passed: comparison.comparable && !comparison.passed,
-            };
-            break;
-        case "greater_than":
-            comparison = numbers(value, expected, (a, b) => a > b);
-            break;
-        case "greater_or_equal":
-            comparison = numbers(value, expected, (a, b) => a >= b);
-            break;
-        case "less_than":
-            comparison = numbers(value, expected, (a, b) => a < b);
-            break;
-        case "less_or_equal":
-            comparison = numbers(value, expected, (a, b) => a <= b);
-            break;
-        case "set_equals":
-            comparison = sets(value, expected, (a, b) => a.size === b.size && [...a].every((item) => b.has(item)));
-            break;
-        case "subset_of":
-            comparison = sets(value, expected, (a, b) => [...a].every((item) => b.has(item)));
-            break;
-        case "superset_of":
-            comparison = sets(value, expected, (a, b) => [...b].every((item) => a.has(item)));
-            break;
-    }
-    if (!comparison.comparable)
-        return {
-            passed: false,
-            status: "observation_type_mismatch",
-            expected,
-            actual: value,
-        };
-    return result(comparison.passed, expected, value);
-}
-export function evaluatePopulation(requirement, observations) {
-    const universe = observationValue(observations, requirement.observations.universe_ids).value;
-    const eligible = observationValue(observations, requirement.observations.eligible_ids).value;
-    const observed = observationValue(observations, requirement.observations.observed_ids).value;
-    const excluded = observationValue(observations, requirement.observations.excluded_items).value;
-    const actual = {
-        universe_ids: universe,
-        eligible_ids: eligible,
-        observed_ids: observed,
-        excluded_items: excluded,
-    };
-    if (!validIds(universe))
-        return failure(actual, "universe_ids_invalid");
-    if (!validIds(eligible))
-        return failure(actual, "eligible_ids_invalid");
-    if (!validIds(observed))
-        return failure(actual, "observed_ids_invalid");
-    if (!Array.isArray(excluded))
-        return failure(actual, "excluded_items_invalid");
-    const eligibleSet = new Set(eligible);
-    const universeSet = new Set(universe);
-    if (universeSet.size !== eligibleSet.size ||
-        [...universeSet].some((id) => !eligibleSet.has(id)))
-        return failure(actual, "eligible_universe_mismatch");
-    const observedSet = new Set(observed);
-    const excludedIds = [];
-    const rules = new Set(requirement.exclusion_rules.map((item) => item.key));
-    for (const item of excluded) {
-        if (!item ||
-            typeof item !== "object" ||
-            Array.isArray(item) ||
-            typeof item.id !== "string" ||
-            !item.id ||
-            typeof item.rule !== "string")
-            return failure(actual, "excluded_item_invalid");
-        const id = item.id;
-        const rule = item.rule;
-        if (!rules.has(rule))
-            return failure(actual, `exclusion_rule_unknown:${rule}`);
-        excludedIds.push(id);
-    }
-    if (new Set(excludedIds).size !== excludedIds.length)
-        return failure(actual, "excluded_ids_duplicate");
-    const excludedSet = new Set(excludedIds);
-    if (![...observedSet].every((id) => eligibleSet.has(id)))
-        return failure(actual, "observed_not_eligible_subset");
-    if (![...excludedSet].every((id) => eligibleSet.has(id)))
-        return failure(actual, "excluded_not_eligible_subset");
-    if ([...observedSet].some((id) => excludedSet.has(id)))
-        return failure(actual, "observed_excluded_overlap");
-    const covered = new Set([...observedSet, ...excludedSet]);
-    if (covered.size !== eligibleSet.size ||
-        [...eligibleSet].some((id) => !covered.has(id)))
-        return failure(actual, "eligible_population_incomplete");
-    return {
-        passed: true,
-        actual: { ...actual, coverage_percent: 100 },
-        reason: null,
-    };
-}
-export function observationValue(observations, name) {
-    if (Object.hasOwn(observations, name))
-        return { found: true, value: observations[name] };
-    let current = observations;
-    for (const part of name.split(".")) {
-        if (!current ||
-            typeof current !== "object" ||
-            Array.isArray(current) ||
-            !Object.hasOwn(current, part))
-            return { found: false, value: undefined };
-        current = current[part];
-    }
-    return { found: true, value: current };
-}
-function validIds(value) {
-    return (Array.isArray(value) &&
-        value.every((item) => typeof item === "string" && item.length > 0) &&
-        new Set(value).size === value.length);
-}
-function failure(actual, reason) {
-    return { passed: false, actual, reason };
-}
-function contains(value, expected) {
-    if (typeof value === "string" && typeof expected === "string")
-        return { comparable: true, passed: value.includes(expected) };
-    if (Array.isArray(value))
-        return {
-            comparable: true,
-            passed: value.some((item) => canonicalValueJson(item) === canonicalValueJson(expected)),
-        };
-    return { comparable: false, passed: false };
-}
-function comparableEquals(value, expected, negate) {
-    if (valueKind(value) !== valueKind(expected))
-        return { comparable: false, passed: false };
-    const equal = canonicalValueJson(value) === canonicalValueJson(expected);
-    return { comparable: true, passed: negate ? !equal : equal };
-}
-function matches(value, expected) {
-    if (typeof value !== "string" || typeof expected !== "string")
-        return { comparable: false, passed: false };
-    try {
-        return {
-            comparable: true,
-            passed: new RegExp(expected, "u").test(value),
-        };
-    }
-    catch {
-        return { comparable: false, passed: false };
-    }
-}
-function numbers(left, right, compare) {
-    if (typeof left !== "number" ||
-        typeof right !== "number" ||
-        !Number.isFinite(left) ||
-        !Number.isFinite(right))
-        return { comparable: false, passed: false };
-    return { comparable: true, passed: compare(left, right) };
-}
-function sets(left, right, compare) {
-    if (!Array.isArray(left) || !Array.isArray(right))
-        return { comparable: false, passed: false };
-    return {
-        comparable: true,
-        passed: compare(new Set(left.map(canonicalValueJson)), new Set(right.map(canonicalValueJson))),
-    };
-}
-function result(passed, expected, actual) {
-    return {
-        passed,
-        status: passed ? "passed" : "assertion_value_mismatch",
-        expected,
-        actual,
-    };
-}
-function valueKind(value) {
-    if (value === null)
-        return "null";
-    if (Array.isArray(value))
-        return "array";
-    return typeof value;
-}

package/dist/lib/long-task-authoring-authority-preview.d.ts

@@ -1,5 +0,0 @@
-import type { AuthoringPreflightDiagnosticV1, AuthoringRevisionPreviewV1 } from "./long-task-authoring-preflight-types.js";
-import type { ContextAuthoritySnapshotV2, CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-import { type ActiveLongTaskAuthorityV3 } from "./long-task-state.js";
-export declare function loadAuthoringActiveAuthority(repository: string, workdir: string, diagnostics: AuthoringPreflightDiagnosticV1[]): Promise<ActiveLongTaskAuthorityV3 | null>;
-export declare function authoringRevisionPreview(contract: DeliveryContractV2, sourceHashes: Record<string, string> | null, sourceItems: CompiledSourceItemV2[] | null, context: ContextAuthoritySnapshotV2 | null, active: ActiveLongTaskAuthorityV3 | null): AuthoringRevisionPreviewV1;

package/dist/lib/long-task-authoring-authority-preview.js

@@ -1,87 +0,0 @@
-import { computeAuthorityHashes } from "./long-task-authority.js";
-import { computeAuthorityMaterials, compiledAuthorityMaterials, } from "./long-task-authority-materials.js";
-import { addDiagnosticError } from "./long-task-authoring-preflight-diagnostics.js";
-import { loadActiveLongTaskAuthority, } from "./long-task-state.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export async function loadAuthoringActiveAuthority(repository, workdir, diagnostics) {
-    try {
-        const active = (await loadActiveLongTaskAuthority(repository)).authority;
-        if (active && active.workdir !== workdir)
-            diagnostics.push({
-                level: "error",
-                code: "active_task_exists",
-                message: `Another workdir owns Active Authority: ${active.workdir}`,
-            });
-        return active;
-    }
-    catch (error) {
-        addDiagnosticError(diagnostics, error);
-        return null;
-    }
-}
-export function authoringRevisionPreview(contract, sourceHashes, sourceItems, context, active) {
-    if (!active)
-        return {
-            active: false,
-            authority_revision: null,
-            contract_changed: false,
-            source_or_context_changed: false,
-            declared_authority_sections_changed: [],
-        };
-    const hashes = computeAuthorityHashes(contract);
-    const previousDeclaredHashes = computeAuthorityHashes({
-        schema_version: "long-task-delivery-v2",
-        semantic_fact_manifest: active.authority_snapshot.semantic_fact_manifest,
-        task: active.authority_snapshot.task,
-        source_claims: active.authority_snapshot.source_claims,
-        stages: active.authority_snapshot.stages,
-        risk: active.authority_snapshot.risk,
-        global: active.authority_snapshot.global,
-        outcomes: active.authority_snapshot.outcomes,
-    });
-    const declaredChanged = new Set(Object.keys(hashes)
-        .filter((key) => hashes[key] !== previousDeclaredHashes[key])
-        .map((key) => key.replace(/_authority_hash$/u, "")));
-    let sourceChanged = false;
-    let contextChanged = false;
-    if (sourceHashes && sourceItems && context) {
-        const next = computeAuthorityMaterials(contract, sourceHashes, sourceItems, context);
-        const previous = compiledAuthorityMaterials(active.authority_snapshot);
-        sourceChanged =
-            canonicalValueJson({
-                source_hashes: next.source_hashes,
-                source_items: next.source_items,
-            }) !==
-                canonicalValueJson({
-                    source_hashes: previous.source_hashes,
-                    source_items: previous.source_items,
-                });
-        contextChanged =
-            canonicalValueJson({
-                context_snapshot: next.context_snapshot,
-            }) !==
-                canonicalValueJson({
-                    context_snapshot: previous.context_snapshot,
-                });
-        if (sourceChanged)
-            declaredChanged.add("source");
-        if (contextChanged)
-            declaredChanged.add("context");
-    }
-    const sectionOrder = [
-        "source",
-        "product",
-        "technical",
-        "acceptance",
-        "risk",
-        "context",
-    ];
-    return {
-        active: true,
-        authority_revision: active.authority_revision,
-        contract_changed: sha256Hex(canonicalValueJson(contract)) !==
-            active.authority_snapshot.contract_sha256,
-        source_or_context_changed: sourceChanged || contextChanged,
-        declared_authority_sections_changed: sectionOrder.filter((section) => declaredChanged.has(section)),
-    };
-}

package/dist/lib/long-task-authoring-preflight-diagnostics.d.ts

@@ -1,8 +0,0 @@
-import type { ParsedDeliveryContractV2 } from "./long-task-delivery-parser.js";
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { AuthoringPreflightDiagnosticV1, SourceCoverageV1 } from "./long-task-authoring-preflight-types.js";
-export declare function addAuthoringDiagnostics(contract: DeliveryContractV2, parsed: ParsedDeliveryContractV2, diagnostics: AuthoringPreflightDiagnosticV1[]): void;
-export declare function sourceCoverage(contract: DeliveryContractV2): SourceCoverageV1;
-export declare function captureDiagnostic(diagnostics: AuthoringPreflightDiagnosticV1[], action: () => Promise<unknown>): Promise<void>;
-export declare function addDiagnosticError(diagnostics: AuthoringPreflightDiagnosticV1[], error: unknown, outcomeKey?: string | null, checkKey?: string): void;
-export declare function normalizeAuthoringDiagnostics(diagnostics: AuthoringPreflightDiagnosticV1[]): AuthoringPreflightDiagnosticV1[];