project-tiny-context-harness 0.2.85 → 0.6.0

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

@@ -0,0 +1,152 @@
+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 [
+                ["location", control.location],
+                ["trigger", control.trigger],
+                ["input", control.input],
+                ["loading", control.loading_state],
+                ["empty", control.empty_state],
+                ["success", control.success_state],
+                ["failure", control.failure_state],
+                ["feedback", control.feedback],
+            ])
+                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],
+    ]);
+    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}.observable_result`, outcome.observable_result);
+        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 [
+                "location",
+                "trigger",
+                "input",
+                "loading_state",
+                "empty_state",
+                "success_state",
+                "failure_state",
+                "feedback",
+            ])
+                fields.set(`${prefix}.controls.${control.key}.${field}`, control[field]);
+        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

@@ -0,0 +1,7 @@
+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">, 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">): ProductSemanticProjectionV2;
+export declare function projectGlobalSemantics(contract: Pick<DeliveryContractV2, "global">): GlobalSemanticProjectionV2;

package/dist/lib/long-task-authority-materials.js

@@ -0,0 +1,83 @@
+import { normalizeContextAuthoritySnapshot } from "./long-task-context-authority.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function computeAuthorityMaterials(contract, sourceHashes, sourceItems, contextSnapshot) {
+    return {
+        source_hashes: sortRecord(sourceHashes),
+        source_items: [...sourceItems].sort((left, right) => left.key.localeCompare(right.key)),
+        context_snapshot: normalizeContextAuthoritySnapshot(contextSnapshot),
+        product_semantics: projectProductSemantics(contract),
+        global_semantics: projectGlobalSemantics(contract),
+    };
+}
+export function compiledAuthorityMaterials(compiled) {
+    const stored = compiled.authority_materials;
+    return (stored ??
+        computeAuthorityMaterials(compiled, compiled.source_hashes, compiled.source_items, compiled.context_snapshot));
+}
+export function authorityMaterialHashes(materials) {
+    return {
+        source_hashes_sha256: hash(materials.source_hashes),
+        context_snapshot_sha256: hash(materials.context_snapshot),
+        product_semantics_sha256: hash(materials.product_semantics),
+        global_semantics_sha256: hash(materials.global_semantics),
+    };
+}
+export function authorityMaterialsChanged(previous, next) {
+    return canonicalValueJson(previous) !== canonicalValueJson(next);
+}
+export function projectProductSemantics(contract) {
+    return {
+        task_goal: contract.task.goal,
+        global_non_goals: keyedStatements(contract.global.product.non_goals),
+        outcomes: [...contract.outcomes].sort(keyOrder).map((outcome) => ({
+            key: outcome.key,
+            title: outcome.title,
+            observable_result: outcome.product.observable_result,
+            owner: {
+                label: outcome.product.owner.label,
+                owner_surfaces: [...outcome.product.owner_surfaces].sort(),
+            },
+            requirements: [...outcome.product.requirements]
+                .sort(keyOrder)
+                .map((requirement) => ({
+                key: requirement.key,
+                statement: requirement.statement,
+                required_proof_surfaces: [
+                    ...requirement.required_proof_surfaces,
+                ].sort(),
+            })),
+            controls: [...outcome.product.controls].sort(keyOrder).map((control) => ({
+                key: control.key,
+                location: control.location,
+                trigger: control.trigger,
+                input: control.input,
+                loading_state: control.loading_state,
+                empty_state: control.empty_state,
+                success_state: control.success_state,
+                failure_state: control.failure_state,
+                feedback: control.feedback,
+            })),
+            non_completing_outcomes: keyedStatements(outcome.product.non_completing_outcomes),
+        })),
+    };
+}
+export function projectGlobalSemantics(contract) {
+    return {
+        constraints: keyedStatements(contract.global.technical.constraints),
+        forbidden_shortcuts: keyedStatements(contract.global.technical.forbidden_shortcuts),
+    };
+}
+function keyedStatements(values) {
+    return [...values]
+        .sort(keyOrder)
+        .map(({ key, statement }) => ({ key, statement }));
+}
+function keyOrder(left, right) {
+    return left.key.localeCompare(right.key);
+}
+function sortRecord(value) {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
+}
+function hash(value) {
+    return sha256Hex(canonicalValueJson(value));
+}

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

@@ -0,0 +1,168 @@
+export type AuthorityFieldPolicy = "identity" | "semantic_user_review" | "proof_additive" | "runner_authority" | "input_coverage" | "output_requirement" | "scope" | "readiness_only" | "descriptive_non_authoritative";
+export declare const CHECK_AUTHORITY_POLICY: {
+    key: "identity";
+    proof_surface: "semantic_user_review";
+    runner: "runner_authority";
+    verification_inputs: "proof_additive";
+    input_paths: "input_coverage";
+    expected_output_paths: "output_requirement";
+    artifact_globs: "proof_additive";
+    positive_assertions: "proof_additive";
+    negative_assertions: "proof_additive";
+    environment_requirements: "proof_additive";
+};
+export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
+    readonly task: {
+        id: "identity";
+        title: "descriptive_non_authoritative";
+        goal: "semantic_user_review";
+        source_paths: "scope";
+        context_refs: "scope";
+        context_snapshot_mode: "scope";
+    };
+    readonly source_claim: {
+        key: "identity";
+        source_ref: "scope";
+        statement: "semantic_user_review";
+        disposition: "semantic_user_review";
+    };
+    readonly risk: {
+        requested_level: "semantic_user_review";
+        facts: "semantic_user_review";
+    };
+    readonly global_product: {
+        non_goals: "semantic_user_review";
+    };
+    readonly global_technical: {
+        constraints: "semantic_user_review";
+        forbidden_paths: "scope";
+        forbidden_shortcuts: "semantic_user_review";
+    };
+    readonly global_acceptance: {
+        checks: "proof_additive";
+        counterfactual_controls: "proof_additive";
+        external_confirmations: "semantic_user_review";
+    };
+    readonly outcome: {
+        key: "identity";
+        title: "descriptive_non_authoritative";
+        depends_on: "readiness_only";
+        product: "semantic_user_review";
+        technical: "semantic_user_review";
+        acceptance: "proof_additive";
+    };
+    readonly outcome_product: {
+        observable_result: "semantic_user_review";
+        owner: "semantic_user_review";
+        requirements: "semantic_user_review";
+        owner_surfaces: "semantic_user_review";
+        controls: "semantic_user_review";
+        non_completing_outcomes: "semantic_user_review";
+    };
+    readonly requirement: {
+        key: "identity";
+        statement: "semantic_user_review";
+        required_proof_surfaces: "proof_additive";
+    };
+    readonly owner: {
+        label: "identity";
+        context_refs: "scope";
+        path_globs: "scope";
+    };
+    readonly control: {
+        key: "identity";
+        location: "semantic_user_review";
+        trigger: "semantic_user_review";
+        input: "semantic_user_review";
+        loading_state: "semantic_user_review";
+        empty_state: "semantic_user_review";
+        success_state: "semantic_user_review";
+        failure_state: "semantic_user_review";
+        feedback: "semantic_user_review";
+    };
+    readonly outcome_technical: {
+        obligations: "semantic_user_review";
+        expected_change_paths: "scope";
+        allowed_support_paths: "scope";
+        forbidden_paths: "scope";
+        bindings: "semantic_user_review";
+        forbidden_shortcuts: "semantic_user_review";
+        rollback_and_recovery: "semantic_user_review";
+    };
+    readonly obligation: {
+        key: "identity";
+        statement: "semantic_user_review";
+        required_proof_surfaces: "proof_additive";
+    };
+    readonly binding: {
+        key: "identity";
+        kind: "semantic_user_review";
+        target: "semantic_user_review";
+        carrier_paths: "scope";
+        existence: "semantic_user_review";
+        verification_check_key: "proof_additive";
+    };
+    readonly rollback: {
+        rollback: "semantic_user_review";
+        recovery: "semantic_user_review";
+        verification_check_keys: "proof_additive";
+    };
+    readonly outcome_acceptance: {
+        checks: "proof_additive";
+        population: "proof_additive";
+        counterfactual_controls: "proof_additive";
+    };
+    readonly check: {
+        key: "identity";
+        proof_surface: "semantic_user_review";
+        runner: "runner_authority";
+        verification_inputs: "proof_additive";
+        input_paths: "input_coverage";
+        expected_output_paths: "output_requirement";
+        artifact_globs: "proof_additive";
+        positive_assertions: "proof_additive";
+        negative_assertions: "proof_additive";
+        environment_requirements: "proof_additive";
+    };
+    readonly assertion: {
+        key: "identity";
+        criterion: "semantic_user_review";
+        claims: "proof_additive";
+        observation: "proof_additive";
+        operator: "proof_additive";
+        expected: "proof_additive";
+    };
+    readonly runner: {
+        type: "runner_authority";
+        target: "runner_authority";
+        argv: "runner_authority";
+        cwd: "runner_authority";
+        timeout_ms: "runner_authority";
+        effect: "runner_authority";
+        retry_policy: "runner_authority";
+        idempotent: "runner_authority";
+    };
+    readonly population: {
+        check_key: "proof_additive";
+        claims: "proof_additive";
+        observations: "proof_additive";
+        exclusion_rules: "proof_additive";
+    };
+    readonly counterfactual: {
+        key: "identity";
+        binding_key: "proof_additive";
+        claims: "proof_additive";
+        check_key: "proof_additive";
+        mutation: "proof_additive";
+        expected_assertion_failures: "proof_additive";
+    };
+    readonly global_counterfactual: {
+        key: "identity";
+        binding_ref: "proof_additive";
+        claims: "proof_additive";
+        check_key: "proof_additive";
+        mutation: "proof_additive";
+        expected_assertion_failures: "proof_additive";
+    };
+};
+export declare function projectFieldsByPolicy<T extends object>(value: T, policy: Record<keyof T, AuthorityFieldPolicy>, included: ReadonlySet<AuthorityFieldPolicy>): Partial<T>;

package/dist/lib/long-task-authority-policy.js

@@ -0,0 +1,181 @@
+const TASK_AUTHORITY_POLICY = {
+    id: "identity",
+    title: "descriptive_non_authoritative",
+    goal: "semantic_user_review",
+    source_paths: "scope",
+    context_refs: "scope",
+    context_snapshot_mode: "scope",
+};
+const SOURCE_CLAIM_AUTHORITY_POLICY = {
+    key: "identity",
+    source_ref: "scope",
+    statement: "semantic_user_review",
+    disposition: "semantic_user_review",
+};
+const RISK_AUTHORITY_POLICY = {
+    requested_level: "semantic_user_review",
+    facts: "semantic_user_review",
+};
+const GLOBAL_PRODUCT_AUTHORITY_POLICY = {
+    non_goals: "semantic_user_review",
+};
+const GLOBAL_TECHNICAL_AUTHORITY_POLICY = {
+    constraints: "semantic_user_review",
+    forbidden_paths: "scope",
+    forbidden_shortcuts: "semantic_user_review",
+};
+const GLOBAL_ACCEPTANCE_AUTHORITY_POLICY = {
+    checks: "proof_additive",
+    counterfactual_controls: "proof_additive",
+    external_confirmations: "semantic_user_review",
+};
+const OUTCOME_AUTHORITY_POLICY = {
+    key: "identity",
+    title: "descriptive_non_authoritative",
+    depends_on: "readiness_only",
+    product: "semantic_user_review",
+    technical: "semantic_user_review",
+    acceptance: "proof_additive",
+};
+const OUTCOME_PRODUCT_AUTHORITY_POLICY = {
+    observable_result: "semantic_user_review",
+    owner: "semantic_user_review",
+    requirements: "semantic_user_review",
+    owner_surfaces: "semantic_user_review",
+    controls: "semantic_user_review",
+    non_completing_outcomes: "semantic_user_review",
+};
+const REQUIREMENT_AUTHORITY_POLICY = {
+    key: "identity",
+    statement: "semantic_user_review",
+    required_proof_surfaces: "proof_additive",
+};
+const OWNER_AUTHORITY_POLICY = {
+    label: "identity",
+    context_refs: "scope",
+    path_globs: "scope",
+};
+const CONTROL_AUTHORITY_POLICY = {
+    key: "identity",
+    location: "semantic_user_review",
+    trigger: "semantic_user_review",
+    input: "semantic_user_review",
+    loading_state: "semantic_user_review",
+    empty_state: "semantic_user_review",
+    success_state: "semantic_user_review",
+    failure_state: "semantic_user_review",
+    feedback: "semantic_user_review",
+};
+const OUTCOME_TECHNICAL_AUTHORITY_POLICY = {
+    obligations: "semantic_user_review",
+    expected_change_paths: "scope",
+    allowed_support_paths: "scope",
+    forbidden_paths: "scope",
+    bindings: "semantic_user_review",
+    forbidden_shortcuts: "semantic_user_review",
+    rollback_and_recovery: "semantic_user_review",
+};
+const OBLIGATION_AUTHORITY_POLICY = {
+    key: "identity",
+    statement: "semantic_user_review",
+    required_proof_surfaces: "proof_additive",
+};
+const BINDING_AUTHORITY_POLICY = {
+    key: "identity",
+    kind: "semantic_user_review",
+    target: "semantic_user_review",
+    carrier_paths: "scope",
+    existence: "semantic_user_review",
+    verification_check_key: "proof_additive",
+};
+const ROLLBACK_AUTHORITY_POLICY = {
+    rollback: "semantic_user_review",
+    recovery: "semantic_user_review",
+    verification_check_keys: "proof_additive",
+};
+const OUTCOME_ACCEPTANCE_AUTHORITY_POLICY = {
+    checks: "proof_additive",
+    population: "proof_additive",
+    counterfactual_controls: "proof_additive",
+};
+export const CHECK_AUTHORITY_POLICY = {
+    key: "identity",
+    proof_surface: "semantic_user_review",
+    runner: "runner_authority",
+    verification_inputs: "proof_additive",
+    input_paths: "input_coverage",
+    expected_output_paths: "output_requirement",
+    artifact_globs: "proof_additive",
+    positive_assertions: "proof_additive",
+    negative_assertions: "proof_additive",
+    environment_requirements: "proof_additive",
+};
+const ASSERTION_AUTHORITY_POLICY = {
+    key: "identity",
+    criterion: "semantic_user_review",
+    claims: "proof_additive",
+    observation: "proof_additive",
+    operator: "proof_additive",
+    expected: "proof_additive",
+};
+const RUNNER_AUTHORITY_POLICY = {
+    type: "runner_authority",
+    target: "runner_authority",
+    argv: "runner_authority",
+    cwd: "runner_authority",
+    timeout_ms: "runner_authority",
+    effect: "runner_authority",
+    retry_policy: "runner_authority",
+    idempotent: "runner_authority",
+};
+const POPULATION_AUTHORITY_POLICY = {
+    check_key: "proof_additive",
+    claims: "proof_additive",
+    observations: "proof_additive",
+    exclusion_rules: "proof_additive",
+};
+const COUNTERFACTUAL_AUTHORITY_POLICY = {
+    key: "identity",
+    binding_key: "proof_additive",
+    claims: "proof_additive",
+    check_key: "proof_additive",
+    mutation: "proof_additive",
+    expected_assertion_failures: "proof_additive",
+};
+const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
+    key: "identity",
+    binding_ref: "proof_additive",
+    claims: "proof_additive",
+    check_key: "proof_additive",
+    mutation: "proof_additive",
+    expected_assertion_failures: "proof_additive",
+};
+export const AUTHORITY_FIELD_POLICY_REGISTRIES = {
+    task: TASK_AUTHORITY_POLICY,
+    source_claim: SOURCE_CLAIM_AUTHORITY_POLICY,
+    risk: RISK_AUTHORITY_POLICY,
+    global_product: GLOBAL_PRODUCT_AUTHORITY_POLICY,
+    global_technical: GLOBAL_TECHNICAL_AUTHORITY_POLICY,
+    global_acceptance: GLOBAL_ACCEPTANCE_AUTHORITY_POLICY,
+    outcome: OUTCOME_AUTHORITY_POLICY,
+    outcome_product: OUTCOME_PRODUCT_AUTHORITY_POLICY,
+    requirement: REQUIREMENT_AUTHORITY_POLICY,
+    owner: OWNER_AUTHORITY_POLICY,
+    control: CONTROL_AUTHORITY_POLICY,
+    outcome_technical: OUTCOME_TECHNICAL_AUTHORITY_POLICY,
+    obligation: OBLIGATION_AUTHORITY_POLICY,
+    binding: BINDING_AUTHORITY_POLICY,
+    rollback: ROLLBACK_AUTHORITY_POLICY,
+    outcome_acceptance: OUTCOME_ACCEPTANCE_AUTHORITY_POLICY,
+    check: CHECK_AUTHORITY_POLICY,
+    assertion: ASSERTION_AUTHORITY_POLICY,
+    runner: RUNNER_AUTHORITY_POLICY,
+    population: POPULATION_AUTHORITY_POLICY,
+    counterfactual: COUNTERFACTUAL_AUTHORITY_POLICY,
+    global_counterfactual: GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY,
+};
+export function projectFieldsByPolicy(value, policy, included) {
+    return Object.fromEntries(Object.keys(policy)
+        .filter((key) => included.has(policy[key]))
+        .map((key) => [key, value[key]]));
+}

package/dist/lib/long-task-authority-revision-details.d.ts

@@ -0,0 +1,19 @@
+import type { CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, DeliveryContractV2, DeliveryOutcomeV2, SourceClaimV2 } from "./long-task-delivery-types.js";
+export declare function checkIndex(globalChecks: CompiledCheckV2[], outcomes: CompiledOutcomeV2[]): Map<string, CompiledCheckV2>;
+export declare function changedRunnerFields(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
+export declare function removedOrReplacedVerificationInputs(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
+export declare function removedOrNarrowedInputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
+export declare function removedOrWeakenedExpectedOutputPaths(identity: string, before: CompiledCheckV2, after: CompiledCheckV2): string[];
+export declare function sourceClaimReductions(beforeClaims: SourceClaimV2[], afterClaims: SourceClaimV2[]): string[];
+export declare function removedGlobalForbiddenPaths(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): string[];
+export declare function bindingReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
+export declare function obligationReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
+export declare function rollbackReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
+export declare function counterfactualReductions(before: CompiledOutcomeV2, after: DeliveryOutcomeV2): string[];
+export declare function globalCounterfactualReductions(before: CompiledDeliveryContractV2, after: DeliveryContractV2): string[];
+export declare function expandedPatterns(label: string, before: string[], after: string[]): string[];
+export declare function removedExactValues(label: string, before: string[], after: string[]): string[];
+export declare function removedStructuredValues(label: string, before: unknown[], after: unknown[]): string[];
+export declare function removedValues(before: Set<string>, after: Set<string>): string[];
+export declare function addedValues(before: Set<string>, after: Set<string>): string[];
+export declare function same(left: unknown, right: unknown): boolean;