project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,225 +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(),
-        ],
-        [
-            "task.target_profile.completion_authority",
-            projection.target_profile.completion_authority,
-        ],
-    ]);
-    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;

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

@@ -1,185 +0,0 @@
-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,
-        target_profile: contract.task.target_profile,
-        execution_targets: [...contract.task.execution_targets].sort(keyOrder),
-        stages: [...contract.stages].sort(keyOrder),
-        global_non_goals: applicableStatements(contract.global.product.non_goals),
-        outcomes: [...contract.outcomes].sort(keyOrder).map((outcome) => ({
-            key: outcome.key,
-            title: outcome.title,
-            stage: outcome.stage,
-            applicability: [...outcome.applicability].sort(keyOrder).map((item) => ({
-                ...item,
-                given_refs: [...item.given_refs],
-                when_refs: [...item.when_refs],
-            })),
-            observable_result: outcome.product.observable_result,
-            result_applicability_refs: [
-                ...outcome.product.result_applicability_refs,
-            ].sort(),
-            success_path_required: outcome.product.success_path_required,
-            degradation_path_required: outcome.product.degradation_path_required,
-            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(),
-                applicability_refs: [...requirement.applicability_refs].sort(),
-            })),
-            controls: [...outcome.product.controls].sort(keyOrder).map((control) => ({
-                key: control.key,
-                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_state: control.loading_state,
-                empty_state: control.empty_state,
-                success_state: control.success_state,
-                failure_state: control.failure_state,
-                recovery: control.recovery,
-                permission: control.permission,
-                feedback: control.feedback,
-                accessibility: control.accessibility,
-                field_coverage: [...control.field_coverage].map((entry) => ({
-                    ...entry,
-                    fields: [...entry.fields].sort(),
-                    applicability_refs: [...entry.applicability_refs].sort(),
-                })),
-            })),
-            control_relation_closure: outcome.product.control_relation_closure,
-            control_relations: [...outcome.product.control_relations]
-                .sort(keyOrder)
-                .map((relation) => ({
-                ...relation,
-                control_refs: [...relation.control_refs].sort(),
-                required_proof_surfaces: [...relation.required_proof_surfaces].sort(),
-                applicability_refs: [...relation.applicability_refs].sort(),
-            })),
-            surface_bindings: [...(outcome.product.surface_bindings ?? [])]
-                .sort(keyOrder)
-                .map((binding) => ({
-                ...binding,
-                control_refs: [...binding.control_refs].sort(),
-                component_binding_refs: [...binding.component_binding_refs].sort(),
-                design_targets: [...binding.design_targets]
-                    .sort(keyOrder)
-                    .map((target) => ({
-                    ...target,
-                    source_paths: [...target.source_paths].sort(),
-                    condition_keys: [...target.condition_keys].sort(),
-                    claim_refs: [...target.claim_refs].sort(),
-                })),
-                acceptance_blockers: [...binding.acceptance_blockers]
-                    .sort(keyOrder)
-                    .map((blocker) => ({
-                    ...blocker,
-                    refs: [...blocker.refs].sort(),
-                    source_item_refs: [...blocker.source_item_refs].sort(),
-                    verification_methods: [...blocker.verification_methods].sort(),
-                    required_capabilities: [...blocker.required_capabilities].sort(),
-                })),
-            })),
-            non_completing_outcomes: applicableStatements(outcome.product.non_completing_outcomes),
-        })),
-    };
-}
-export function projectGlobalSemantics(contract) {
-    return {
-        applicability: [...contract.global.applicability]
-            .sort(keyOrder)
-            .map((item) => ({
-            ...item,
-            given_refs: [...item.given_refs],
-            when_refs: [...item.when_refs],
-        })),
-        semantic_fact_bindings: contract.global.semantic_fact_bindings
-            ? {
-                manifest_ref: contract.global.semantic_fact_bindings.manifest_ref,
-                obligations: [...contract.global.semantic_fact_bindings.obligations]
-                    .sort((left, right) => globalSemanticObligationKey(left).localeCompare(globalSemanticObligationKey(right)))
-                    .map((item) => ({ ...item })),
-            }
-            : null,
-        constraints: applicableStatements(contract.global.technical.constraints),
-        forbidden_shortcuts: applicableStatements(contract.global.technical.forbidden_shortcuts),
-    };
-}
-function globalSemanticObligationKey(item) {
-    return [
-        item.claim_ref,
-        item.applicability_ref,
-        item.target_ref,
-        item.outcome_ref,
-        item.fact_ref,
-        item.proof_ref,
-        item.method,
-    ].join("\0");
-}
-function keyedStatements(values) {
-    return [...values]
-        .sort(keyOrder)
-        .map(({ key, statement }) => ({ key, statement }));
-}
-function applicableStatements(values) {
-    return [...values]
-        .sort(keyOrder)
-        .map(({ key, statement, applicability_refs }) => ({
-        key,
-        statement,
-        applicability_refs: [...applicability_refs].sort(),
-    }));
-}
-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));
-}