project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-authoring-preflight-repair-order.js

@@ -1,98 +0,0 @@
-import { canonicalJson, sha256Hex } from "./strict-codec.js";
-const STRUCTURAL_BLOCKERS = new Set([
-    "requirement_key_duplicate",
-    "control_key_duplicate",
-    "obligation_key_duplicate",
-    "forbidden_shortcut_key_duplicate",
-]);
-const COVERAGE_FOLLOW_UPS = new Set([
-    "product_claim_uncovered",
-    "product_claim_required_surfaces_missing",
-    "global_claim_uncovered",
-]);
-/**
- * Adds repair-order metadata only when a structural duplicate makes the
- * identity of an uncovered Claim ambiguous. The structural diagnostic must be
- * reviewed first, but the coverage finding is never treated as automatically
- * resolved. No diagnostic is hidden, merged, reclassified or removed.
- */
-export function applyDiagnosticRepairOrder(diagnostics) {
-    const groups = diagnostics.map((diagnostic) => ({
-        diagnostic,
-        entity: repairEntity(diagnostic),
-    }));
-    const blockersByEntity = new Map();
-    for (const [index, item] of groups.entries()) {
-        if (!item.entity || !STRUCTURAL_BLOCKERS.has(item.diagnostic.code))
-            continue;
-        const blockers = blockersByEntity.get(item.entity) ?? [];
-        blockers.push({ index, id: stableDiagnosticId(item.diagnostic) });
-        blockersByEntity.set(item.entity, blockers);
-    }
-    const linkedBlockerIndexes = new Set();
-    const dependencies = new Map();
-    for (const [index, item] of groups.entries()) {
-        if (!item.entity || !COVERAGE_FOLLOW_UPS.has(item.diagnostic.code))
-            continue;
-        const blockers = blockersByEntity.get(item.entity);
-        if (!blockers?.length)
-            continue;
-        blockers.forEach((blocker) => linkedBlockerIndexes.add(blocker.index));
-        dependencies.set(index, [...new Set(blockers.map((blocker) => blocker.id))].sort());
-    }
-    return diagnostics.map((diagnostic, index) => {
-        const blockedBy = dependencies.get(index);
-        if (blockedBy)
-            return {
-                ...diagnostic,
-                diagnostic_id: stableDiagnosticId(diagnostic),
-                repair_group: groups[index].entity,
-                repair_priority: "dependent",
-                blocked_by: blockedBy,
-            };
-        if (linkedBlockerIndexes.has(index))
-            return {
-                ...diagnostic,
-                diagnostic_id: stableDiagnosticId(diagnostic),
-                repair_group: groups[index].entity,
-                repair_priority: "primary",
-            };
-        return diagnostic;
-    });
-}
-function stableDiagnosticId(diagnostic) {
-    return `diag-${sha256Hex(canonicalJson({
-        level: diagnostic.level,
-        code: diagnostic.code,
-        message: diagnostic.message,
-        outcome_key: diagnostic.outcome_key ?? null,
-        check_key: diagnostic.check_key ?? null,
-        refs: diagnostic.refs ?? [],
-        repair_hint: diagnostic.repair_hint ?? null,
-    })).slice(0, 16)}`;
-}
-function repairEntity(diagnostic) {
-    const refs = diagnostic.refs ?? [];
-    switch (diagnostic.code) {
-        case "requirement_key_duplicate":
-            return scopedClaim(refs, "requirement");
-        case "control_key_duplicate":
-            return scopedClaim(refs, "control");
-        case "obligation_key_duplicate":
-            return scopedClaim(refs, "obligation");
-        case "forbidden_shortcut_key_duplicate":
-            return scopedClaim(refs, "forbidden_shortcut");
-        case "product_claim_uncovered":
-            return refs.length === 1 ? refs[0] : null;
-        case "product_claim_required_surfaces_missing":
-            return (refs.find((ref) => /^[a-z0-9][a-z0-9-]*\.(?:result|requirement\.|control\.|control_relation\.|non_completing\.|obligation\.|forbidden_shortcut\.)/u.test(ref)) ?? null);
-        case "global_claim_uncovered":
-            return refs.length === 1 ? refs[0] : null;
-        default:
-            return null;
-    }
-}
-function scopedClaim(refs, kind) {
-    const [scope, key] = refs;
-    return scope && key ? `${scope}.${kind}.${key}` : null;
-}

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

@@ -1,46 +0,0 @@
-import type { ClaimCoverageSummaryV2 } from "./long-task-delivery-types.js";
-export interface AuthoringPreflightDiagnosticV1 {
-    level: "error" | "decision_required" | "warning" | "info";
-    code: string;
-    message: string;
-    outcome_key?: string;
-    check_key?: string;
-    refs?: string[];
-    repair_hint?: string;
-    occurrences?: number;
-    diagnostic_id?: string;
-    repair_group?: string;
-    repair_priority?: "primary" | "dependent";
-    blocked_by?: string[];
-}
-export interface SourceCoverageV1 {
-    total: number;
-    resolved: number;
-    mapped_to_product_claims: number;
-    mapped_to_acceptance: number;
-    mapped_to_outcome_results: number;
-    mapped_to_global_constraints: number;
-    mapped_to_risk_facts: number;
-    mapped_to_external_confirmations: number;
-    decision_required: number;
-    unresolved: string[];
-}
-export interface AuthoringRevisionPreviewV1 {
-    active: boolean;
-    authority_revision: number | null;
-    contract_changed: boolean;
-    source_or_context_changed: boolean;
-    declared_authority_sections_changed: string[];
-}
-export interface AuthoringPreflightResultV1 {
-    schema_version: "long-task-authoring-preflight-v1";
-    status: "ready" | "not_ready";
-    would_create_authority_lock: boolean;
-    outcomes: string[];
-    source_coverage: SourceCoverageV1;
-    claim_coverage: ClaimCoverageSummaryV2;
-    revision_preview: AuthoringRevisionPreviewV1;
-    diagnostics: AuthoringPreflightDiagnosticV1[];
-}
-export declare function emptyClaimCoverage(): ClaimCoverageSummaryV2;
-export declare function emptyPreflightResult(diagnostics: AuthoringPreflightDiagnosticV1[]): AuthoringPreflightResultV1;

package/dist/lib/long-task-authoring-preflight-types.js

@@ -1,38 +0,0 @@
-export function emptyClaimCoverage() {
-    return {
-        claims_total: 0,
-        claims_covered: 0,
-        uncovered_claims: [],
-        claims_by_global: {},
-        claims_by_outcome: {},
-    };
-}
-export function emptyPreflightResult(diagnostics) {
-    return {
-        schema_version: "long-task-authoring-preflight-v1",
-        status: "not_ready",
-        would_create_authority_lock: false,
-        outcomes: [],
-        source_coverage: {
-            total: 0,
-            resolved: 0,
-            mapped_to_product_claims: 0,
-            mapped_to_acceptance: 0,
-            mapped_to_outcome_results: 0,
-            mapped_to_global_constraints: 0,
-            mapped_to_risk_facts: 0,
-            mapped_to_external_confirmations: 0,
-            decision_required: 0,
-            unresolved: [],
-        },
-        claim_coverage: emptyClaimCoverage(),
-        revision_preview: {
-            active: false,
-            authority_revision: null,
-            contract_changed: false,
-            source_or_context_changed: false,
-            declared_authority_sections_changed: [],
-        },
-        diagnostics,
-    };
-}

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

@@ -1,3 +0,0 @@
-import { type AuthoringPreflightResultV1 } from "./long-task-authoring-preflight-types.js";
-export type { AuthoringPreflightDiagnosticV1, AuthoringPreflightResultV1, SourceCoverageV1, } from "./long-task-authoring-preflight-types.js";
-export declare function preflightDeliveryContract(workdirInput: string, projectRootInput?: string): Promise<AuthoringPreflightResultV1>;

package/dist/lib/long-task-authoring-preflight.js

@@ -1,86 +0,0 @@
-import path from "node:path";
-import { authoringRevisionPreview, loadAuthoringActiveAuthority, } from "./long-task-authoring-authority-preview.js";
-import { addAuthoringDiagnostics, addDiagnosticError, normalizeAuthoringDiagnostics, sourceCoverage, } from "./long-task-authoring-preflight-diagnostics.js";
-import { emptyClaimCoverage, emptyPreflightResult, } from "./long-task-authoring-preflight-types.js";
-import { validateContractForActivation } from "./long-task-activation-validation.js";
-import { parseDeliveryContractBundle } from "./long-task-delivery-parser.js";
-import { changedWorkspacePaths, changedWorkspacePathsFromHead, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
-import { classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, workspaceScopeErrors, } from "./long-task-workspace-scope.js";
-export async function preflightDeliveryContract(workdirInput, projectRootInput = process.cwd()) {
-    const diagnostics = [];
-    const repository = await repositoryRoot(projectRootInput);
-    const workdir = path.resolve(workdirInput);
-    let parsed;
-    try {
-        parsed = await parseDeliveryContractBundle(workdir, repository, {
-            validate_structure: false,
-        });
-    }
-    catch (error) {
-        addDiagnosticError(diagnostics, error);
-        return emptyPreflightResult(normalizeAuthoringDiagnostics(diagnostics));
-    }
-    const contract = parsed.contract;
-    addAuthoringDiagnostics(contract, parsed, diagnostics);
-    const activeDiagnostics = [];
-    const [validation, active] = await Promise.all([
-        validateContractForActivation({
-            repository,
-            workdir,
-            contract,
-            mode: "collect",
-            diagnostics,
-        }),
-        loadAuthoringActiveAuthority(repository, workdir, activeDiagnostics),
-    ]);
-    diagnostics.push(...activeDiagnostics);
-    if (validation.workspace)
-        try {
-            const changedPaths = active?.workdir === workdir
-                ? changedWorkspacePaths(active.initial_task_base.workspace_manifest, validation.workspace)
-                : await changedWorkspacePathsFromHead(repository, workdir);
-            const contractFiles = Object.fromEntries(Object.entries(parsed.contract_files).map(([relative, hash]) => [
-                repoRelative(repository, path.join(workdir, ...relative.split("/"))),
-                hash,
-            ]));
-            const checks = [
-                ...validation.global_checks,
-                ...validation.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-            ];
-            const declaredVerificationInputs = [
-                ...contract.global.acceptance.checks,
-                ...contract.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-            ].flatMap((check) => check.verification_inputs);
-            const firstLockManagedPaths = active?.workdir === workdir
-                ? []
-                : await firstLockManagedWorkspacePaths(repository, changedPaths);
-            const classification = classifyWorkspaceScope(contract, changedPaths, protectedWorkspacePaths({
-                contract_files: contractFiles,
-                source_hashes: validation.source_hashes,
-                context_hashes: validation.context_snapshot?.sha256,
-                checks,
-                additional_files: [
-                    ...contract.task.source_paths,
-                    ...declaredVerificationInputs,
-                    ...firstLockManagedPaths,
-                ],
-            }));
-            for (const error of workspaceScopeErrors(classification))
-                addDiagnosticError(diagnostics, new Error(error));
-        }
-        catch (error) {
-            addDiagnosticError(diagnostics, error);
-        }
-    const normalizedDiagnostics = normalizeAuthoringDiagnostics(diagnostics);
-    const ready = !normalizedDiagnostics.some((item) => item.level === "error" || item.level === "decision_required");
-    return {
-        schema_version: "long-task-authoring-preflight-v1",
-        status: ready ? "ready" : "not_ready",
-        would_create_authority_lock: active === null,
-        outcomes: contract.outcomes.map((outcome) => outcome.key),
-        source_coverage: sourceCoverage(contract),
-        claim_coverage: validation.claims?.summary ?? emptyClaimCoverage(),
-        revision_preview: authoringRevisionPreview(contract, validation.source_hashes, validation.source_items, validation.context_snapshot, active),
-        diagnostics: normalizedDiagnostics,
-    };
-}

package/dist/lib/long-task-authority-material-diff.d.ts

@@ -1,17 +0,0 @@
-import type { CompiledDeliveryContractV2, DeliveryContractV2, NextAuthorityMaterialsV2, SourceClaimV2 } from "./long-task-delivery-types.js";
-export interface AuthorityMaterialRevisionDiffV2 {
-    product_semantics_changed: string[];
-    global_semantics_changed: string[];
-    source_files_added: string[];
-    source_files_removed: string[];
-    source_files_changed: string[];
-    context_snapshot_mode_changed: boolean;
-    context_topology_changed: boolean;
-    context_files_added: string[];
-    context_files_removed: string[];
-    context_files_changed: string[];
-    reduction_reasons: string[];
-}
-export declare function authorityMaterialRevisionDiff(previous: CompiledDeliveryContractV2, nextMaterials: NextAuthorityMaterialsV2): AuthorityMaterialRevisionDiffV2;
-export declare function sourceClaimAdditions(beforeClaims: SourceClaimV2[], afterClaims: SourceClaimV2[]): string[];
-export declare function changedProductClaimSemantics(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): string[];

package/dist/lib/long-task-authority-material-diff.js

@@ -1,221 +0,0 @@
-import { compiledAuthorityMaterials } from "./long-task-authority-materials.js";
-import { contextAuthorityChanged } from "./long-task-context-authority.js";
-import { canonicalValueJson } from "./strict-codec.js";
-export function authorityMaterialRevisionDiff(previous, nextMaterials) {
-    const previousMaterials = compiledAuthorityMaterials(previous);
-    const productSemanticsChanged = changedProjectionFields(flattenProductSemantics(previousMaterials.product_semantics), flattenProductSemantics(nextMaterials.product_semantics));
-    const globalSemanticsChanged = changedProjectionFields(flattenGlobalSemantics(previousMaterials.global_semantics), flattenGlobalSemantics(nextMaterials.global_semantics));
-    const sourceFilesAdded = recordKeysAdded(previousMaterials.source_hashes, nextMaterials.source_hashes);
-    const sourceFilesRemoved = recordKeysRemoved(previousMaterials.source_hashes, nextMaterials.source_hashes);
-    const sourceFilesChanged = recordValuesChanged(previousMaterials.source_hashes, nextMaterials.source_hashes);
-    const contextSnapshotModeChanged = previousMaterials.context_snapshot.mode !==
-        nextMaterials.context_snapshot.mode;
-    const contextTopologyChanged = previousMaterials.context_snapshot.topology_sha256 !==
-        nextMaterials.context_snapshot.topology_sha256;
-    const contextFilesAdded = recordKeysAdded(previousMaterials.context_snapshot.sha256, nextMaterials.context_snapshot.sha256);
-    const contextFilesRemoved = recordKeysRemoved(previousMaterials.context_snapshot.sha256, nextMaterials.context_snapshot.sha256);
-    const contextFilesChanged = recordValuesChanged(previousMaterials.context_snapshot.sha256, nextMaterials.context_snapshot.sha256);
-    const controllingContextChanged = contextAuthorityChanged(previousMaterials.context_snapshot, nextMaterials.context_snapshot);
-    return {
-        product_semantics_changed: productSemanticsChanged,
-        global_semantics_changed: globalSemanticsChanged,
-        source_files_added: sourceFilesAdded,
-        source_files_removed: sourceFilesRemoved,
-        source_files_changed: sourceFilesChanged,
-        context_snapshot_mode_changed: contextSnapshotModeChanged,
-        context_topology_changed: contextTopologyChanged,
-        context_files_added: contextFilesAdded,
-        context_files_removed: contextFilesRemoved,
-        context_files_changed: contextFilesChanged,
-        reduction_reasons: [
-            ...(productSemanticsChanged.length ? ["product_semantics_changed"] : []),
-            ...(globalSemanticsChanged.length ? ["global_semantics_changed"] : []),
-            ...(sourceFilesAdded.length ||
-                sourceFilesRemoved.length ||
-                sourceFilesChanged.length
-                ? ["source_file_content_changed"]
-                : []),
-            ...(controllingContextChanged ? ["context_authority_changed"] : []),
-        ],
-    };
-}
-export function sourceClaimAdditions(beforeClaims, afterClaims) {
-    const before = new Set(beforeClaims.map((claim) => claim.key));
-    return afterClaims
-        .filter((claim) => !before.has(claim.key))
-        .map((claim) => `${claim.key}:added`)
-        .sort();
-}
-export function changedProductClaimSemantics(previous, next) {
-    const before = productClaimSemantics(previous);
-    const after = productClaimSemantics(next);
-    return [...before.keys()]
-        .filter((claim) => after.has(claim) &&
-        canonicalValueJson(before.get(claim)) !==
-            canonicalValueJson(after.get(claim)))
-        .sort();
-}
-function productClaimSemantics(contract) {
-    const result = new Map();
-    for (const outcome of contract.outcomes) {
-        result.set(`${outcome.key}.result`, outcome.product.observable_result);
-        for (const item of outcome.product.requirements)
-            result.set(`${outcome.key}.requirement.${item.key}`, {
-                statement: item.statement,
-                required_proof_surfaces: [...item.required_proof_surfaces].sort(),
-            });
-        for (const control of outcome.product.controls)
-            for (const [field, value] of [
-                ["surface", control.surface],
-                ["region", control.region],
-                ["location", control.location],
-                ["control_type", control.control_type],
-                ["label_content", control.label_content],
-                ["user_task", control.user_task],
-                ["visibility", control.visibility],
-                ["availability", control.availability],
-                ["trigger", control.trigger],
-                ["input", control.input],
-                ["validation", control.validation],
-                ["default_value", control.default_value],
-                ["interaction", control.interaction],
-                ["navigation_result", control.navigation_result],
-                ["loading", control.loading_state],
-                ["empty", control.empty_state],
-                ["success", control.success_state],
-                ["failure", control.failure_state],
-                ["recovery", control.recovery],
-                ["permission", control.permission],
-                ["feedback", control.feedback],
-                ["accessibility", control.accessibility],
-            ])
-                if (value.trim())
-                    result.set(`${outcome.key}.control.${control.key}.${field}`, value);
-        for (const item of outcome.product.non_completing_outcomes)
-            result.set(`${outcome.key}.non_completing.${item.key}`, item.statement);
-        for (const item of outcome.technical.obligations)
-            result.set(`${outcome.key}.obligation.${item.key}`, item.statement);
-        for (const item of outcome.technical.forbidden_shortcuts)
-            result.set(`${outcome.key}.forbidden_shortcut.${item.key}`, item.statement);
-    }
-    return result;
-}
-function flattenProductSemantics(projection) {
-    const fields = new Map([
-        ["task.goal", projection.task_goal],
-        ["task.target_profile.key", projection.target_profile.key],
-        ["task.target_profile.description", projection.target_profile.description],
-        [
-            "task.target_profile.required_state",
-            projection.target_profile.required_state,
-        ],
-        [
-            "task.target_profile.required_target_refs",
-            [...projection.target_profile.required_target_refs].sort(),
-        ],
-    ]);
-    for (const target of projection.execution_targets) {
-        const prefix = `task.execution_targets.${target.key}`;
-        fields.set(`${prefix}.description`, target.description);
-        fields.set(`${prefix}.role`, target.role);
-        fields.set(`${prefix}.runtime_family`, target.runtime_family);
-        fields.set(`${prefix}.root_entrypoint`, target.root_entrypoint);
-        fields.set(`${prefix}.root_argv`, target.root_argv ?? null);
-    }
-    for (const stage of projection.stages) {
-        const prefix = `stages.${stage.key}`;
-        fields.set(`${prefix}.title`, stage.title);
-        fields.set(`${prefix}.depends_on`, [...stage.depends_on].sort());
-        fields.set(`${prefix}.gate_outcome`, stage.gate_outcome);
-    }
-    for (const item of projection.global_non_goals)
-        fields.set(`global.product.non_goals.${item.key}`, item.statement);
-    for (const outcome of projection.outcomes) {
-        const prefix = `outcomes.${outcome.key}`;
-        fields.set(`${prefix}.title`, outcome.title);
-        fields.set(`${prefix}.stage`, outcome.stage);
-        fields.set(`${prefix}.observable_result`, outcome.observable_result);
-        fields.set(`${prefix}.success_path_required`, outcome.success_path_required);
-        fields.set(`${prefix}.degradation_path_required`, outcome.degradation_path_required);
-        fields.set(`${prefix}.owner.label`, outcome.owner.label);
-        fields.set(`${prefix}.owner.owner_surfaces`, outcome.owner.owner_surfaces);
-        for (const requirement of outcome.requirements) {
-            fields.set(`${prefix}.requirements.${requirement.key}`, requirement.statement);
-            fields.set(`${prefix}.requirements.${requirement.key}.required_proof_surfaces`, requirement.required_proof_surfaces);
-        }
-        for (const control of outcome.controls)
-            for (const field of [
-                "surface",
-                "region",
-                "location",
-                "control_type",
-                "label_content",
-                "user_task",
-                "visibility",
-                "availability",
-                "trigger",
-                "input",
-                "validation",
-                "default_value",
-                "interaction",
-                "navigation_result",
-                "loading_state",
-                "empty_state",
-                "success_state",
-                "failure_state",
-                "recovery",
-                "permission",
-                "feedback",
-                "accessibility",
-            ])
-                fields.set(`${prefix}.controls.${control.key}.${field}`, control[field]);
-        for (const binding of outcome.surface_bindings ?? []) {
-            const bindingPrefix = `${prefix}.surface_bindings.${binding.key}`;
-            fields.set(`${bindingPrefix}.surface_ref`, binding.surface_ref);
-            fields.set(`${bindingPrefix}.target_ref`, binding.target_ref);
-            fields.set(`${bindingPrefix}.control_refs`, binding.control_refs);
-            fields.set(`${bindingPrefix}.route_binding_ref`, binding.route_binding_ref);
-            fields.set(`${bindingPrefix}.component_binding_refs`, binding.component_binding_refs);
-            fields.set(`${bindingPrefix}.root_journey_check_ref`, binding.root_journey_check_ref);
-            fields.set(`${bindingPrefix}.entry_action_ref`, binding.entry_action_ref);
-            for (const target of binding.design_targets)
-                fields.set(`${bindingPrefix}.design_targets.${target.key}`, target);
-            for (const blocker of binding.acceptance_blockers)
-                fields.set(`${bindingPrefix}.acceptance_blockers.${blocker.key}`, blocker);
-        }
-        for (const item of outcome.non_completing_outcomes)
-            fields.set(`${prefix}.non_completing.${item.key}`, item.statement);
-    }
-    return fields;
-}
-function flattenGlobalSemantics(projection) {
-    const fields = new Map();
-    for (const item of projection.constraints)
-        fields.set(`global.technical.constraints.${item.key}`, item.statement);
-    for (const item of projection.forbidden_shortcuts)
-        fields.set(`global.technical.forbidden_shortcuts.${item.key}`, item.statement);
-    return fields;
-}
-function changedProjectionFields(previous, next) {
-    return [...new Set([...previous.keys(), ...next.keys()])]
-        .filter((field) => !previous.has(field) ||
-        !next.has(field) ||
-        canonicalValueJson(previous.get(field)) !==
-            canonicalValueJson(next.get(field)))
-        .sort();
-}
-function recordKeysAdded(previous, next) {
-    return Object.keys(next)
-        .filter((key) => !(key in previous))
-        .sort();
-}
-function recordKeysRemoved(previous, next) {
-    return Object.keys(previous)
-        .filter((key) => !(key in next))
-        .sort();
-}
-function recordValuesChanged(previous, next) {
-    return Object.keys(previous)
-        .filter((key) => key in next && previous[key] !== next[key])
-        .sort();
-}

package/dist/lib/long-task-authority-materials.d.ts

@@ -1,7 +0,0 @@
-import type { AuthorityMaterialHashesV2, CompiledDeliveryContractV2, CompiledSourceItemV2, ContextAuthoritySnapshotV2, DeliveryContractV2, GlobalSemanticProjectionV2, NextAuthorityMaterialsV2, ProductSemanticProjectionV2 } from "./long-task-delivery-types.js";
-export declare function computeAuthorityMaterials(contract: Pick<DeliveryContractV2, "task" | "global" | "outcomes" | "stages">, sourceHashes: Record<string, string>, sourceItems: CompiledSourceItemV2[], contextSnapshot: ContextAuthoritySnapshotV2): NextAuthorityMaterialsV2;
-export declare function compiledAuthorityMaterials(compiled: CompiledDeliveryContractV2): NextAuthorityMaterialsV2;
-export declare function authorityMaterialHashes(materials: NextAuthorityMaterialsV2): AuthorityMaterialHashesV2;
-export declare function authorityMaterialsChanged(previous: NextAuthorityMaterialsV2, next: NextAuthorityMaterialsV2): boolean;
-export declare function projectProductSemantics(contract: Pick<DeliveryContractV2, "task" | "global" | "outcomes" | "stages">): ProductSemanticProjectionV2;
-export declare function projectGlobalSemantics(contract: Pick<DeliveryContractV2, "global">): GlobalSemanticProjectionV2;