project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-semantic-mutation.js

@@ -1,81 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { canonicalValueJson } from "./strict-codec.js";
-export async function applyNarrowSemanticMutation(root, mutation) {
-    const target = path.join(root, ...mutation.path.split("/"));
-    const current = await readFile(target, "utf8");
-    const next = mutateSemanticText(current, mutation, false);
-    await writeFile(target, next, "utf8");
-}
-export function mutateSemanticText(current, mutation, requireChange = true) {
-    if (mutation.type === "replace_text") {
-        if (requireChange && mutation.match === mutation.replacement)
-            throw new Error("counterfactual_replacement_must_change_carrier");
-        const count = occurrences(current, mutation.match);
-        if (count !== 1)
-            throw new Error(`counterfactual_text_match_count:${count}`);
-        return current.replace(mutation.match, mutation.replacement);
-    }
-    let value;
-    try {
-        value = JSON.parse(current);
-    }
-    catch {
-        throw new Error("counterfactual_json_invalid");
-    }
-    const segments = mutation.pointer
-        .slice(1)
-        .split("/")
-        .map((segment) => segment.replace(/~1/gu, "/").replace(/~0/gu, "~"));
-    let owner = value;
-    for (const segment of segments.slice(0, -1))
-        owner = child(owner, segment, mutation.pointer);
-    const leaf = segments.at(-1);
-    if (!owner || typeof owner !== "object")
-        throw new Error(`counterfactual_json_pointer_unknown:${mutation.pointer}`);
-    if (Array.isArray(owner)) {
-        const index = arrayIndex(leaf, owner.length, mutation.pointer);
-        if (requireChange &&
-            canonicalValueJson(owner[index]) === canonicalValueJson(mutation.value))
-            throw new Error("counterfactual_replacement_must_change_carrier");
-        owner[index] = mutation.value;
-    }
-    else {
-        const record = owner;
-        if (!Object.hasOwn(record, leaf))
-            throw new Error(`counterfactual_json_pointer_unknown:${mutation.pointer}`);
-        if (requireChange &&
-            canonicalValueJson(record[leaf]) === canonicalValueJson(mutation.value))
-            throw new Error("counterfactual_replacement_must_change_carrier");
-        record[leaf] = mutation.value;
-    }
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-function child(value, segment, pointer) {
-    if (!value || typeof value !== "object")
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    if (Array.isArray(value))
-        return value[arrayIndex(segment, value.length, pointer)];
-    if (!Object.hasOwn(value, segment))
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    return value[segment];
-}
-function arrayIndex(value, length, pointer) {
-    if (!/^(?:0|[1-9][0-9]*)$/u.test(value))
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    const index = Number(value);
-    if (!Number.isSafeInteger(index) || index >= length)
-        throw new Error(`counterfactual_json_pointer_unknown:${pointer}`);
-    return index;
-}
-function occurrences(value, search) {
-    let count = 0;
-    let offset = 0;
-    while (true) {
-        const index = value.indexOf(search, offset);
-        if (index < 0)
-            return count;
-        count += 1;
-        offset = index + search.length;
-    }
-}

package/dist/lib/long-task-semantic-proof-adequacy.d.ts

@@ -1,2 +0,0 @@
-import type { SemanticFactManifestV1 } from "./long-task-delivery-types.js";
-export declare function validateSemanticFactProofFloors(manifest: SemanticFactManifestV1): void;

package/dist/lib/long-task-semantic-proof-adequacy.js

@@ -1,19 +0,0 @@
-import { semanticFactProofCapabilityFloor, validateSemanticFactProofProfileClosure, } from "./long-task-semantic-proof-profile.js";
-export function validateSemanticFactProofFloors(manifest) {
-    validateSemanticFactProofProfileClosure(manifest);
-    const facts = new Map(manifest.facts.map((fact) => [fact.key, fact]));
-    for (const proof of manifest.proof_obligations) {
-        const fact = facts.get(proof.fact_ref);
-        const required = semanticFactProofCapabilityFloor(manifest, fact, proof);
-        const missing = [...required].filter((capability) => !proof.evidence_capabilities.includes(capability));
-        if (missing.length)
-            fail("semantic_fact_proof_adequacy_capability_missing", `${proof.key}:${missing.sort().join(",")}`);
-        if (required.has("population_coverage") &&
-            proof.comparison.comparator !== "set_equality" &&
-            proof.method !== "population_set_equality")
-            fail("semantic_fact_population_set_equality_required", proof.key);
-    }
-}
-function fail(code, detail) {
-    throw new Error(`delivery_contract_invalid:${code}:${detail}`);
-}

package/dist/lib/long-task-semantic-proof-profile.d.ts

@@ -1,5 +0,0 @@
-import type { EvidenceCapabilityV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function semanticFactCustomPropertyHasClosedStandardProfile(property: SemanticFactManifestV1["property_dispositions"][number]): boolean;
-export declare function validateSemanticFactProofProfileClosure(manifest: SemanticFactManifestV1): void;
-export declare function semanticFactProofCapabilityFloor(manifest: SemanticFactManifestV1, fact: SemanticFactManifestV1["facts"][number], proof: SemanticFactManifestV1["proof_obligations"][number]): Set<EvidenceCapabilityV2>;

package/dist/lib/long-task-semantic-proof-profile.js

@@ -1,187 +0,0 @@
-import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
-import { isCustomSemanticFactName, SEMANTIC_FACT_PROOF_METHODS, SEMANTIC_FACT_STANDARD_PROPERTIES, } from "./semantic-fact-catalog.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-const STANDARD_PROPERTY_CATALOG_SHA256 = "dd71ac2bb67144bd0e9df30c69a0231cc6ba71a72cd202a7e400cd59a3ab7d02";
-const METHOD_CAPABILITY_FLOORS = {
-    exact_value: ["semantic_fact"],
-    schema_contract: ["semantic_fact"],
-    decision_table: ["semantic_fact"],
-    formula_evaluation: ["semantic_fact"],
-    invariant: ["semantic_fact"],
-    transition_trace: ["semantic_fact", "interaction_trace", "state_delta"],
-    sequence_trace: ["semantic_fact", "interaction_trace"],
-    durable_roundtrip: ["semantic_fact", "data_state", "durable_readback"],
-    boundary_invocation: [
-        "semantic_fact",
-        "boundary_invocation",
-        "actual_provenance",
-    ],
-    external_side_effect: [
-        "semantic_fact",
-        "boundary_invocation",
-        "actual_provenance",
-        "external_side_effect",
-        "state_delta",
-    ],
-    population_set_equality: ["semantic_fact", "population_coverage"],
-    concurrency_schedule: ["semantic_fact", "input_variation", "state_delta"],
-    idempotency_repetition: ["semantic_fact", "input_variation", "state_delta"],
-    fault_injection: ["semantic_fact", "failure_injection"],
-    recovery_drill: ["semantic_fact", "failure_injection", "recovery"],
-    migration: ["semantic_fact", "data_state", "durable_readback"],
-    compatibility: ["semantic_fact", "input_variation"],
-    performance: ["semantic_fact", "target_runtime"],
-    capacity: ["semantic_fact", "target_runtime"],
-    security: ["semantic_fact", "target_runtime", "data_state"],
-    privacy: ["semantic_fact", "data_state"],
-    audit: ["semantic_fact", "data_state", "durable_readback"],
-    observability: ["semantic_fact", "target_runtime"],
-    deployment: ["semantic_fact", "presence", "target_runtime"],
-    implementation_structure: ["semantic_fact", "presence"],
-};
-const PROPERTY_CLASS_CAPABILITIES = {
-    durable: ["data_state", "durable_readback"],
-    boundary: ["boundary_invocation", "actual_provenance"],
-    identity: ["distinct_identity", "data_state", "target_runtime"],
-    transition: ["interaction_trace", "state_delta"],
-    recovery: ["failure_injection", "recovery"],
-    population: ["population_coverage"],
-    visual: ["visual_render", "design_conformance"],
-};
-const PROPERTY_CLASSES = {
-    durable: new Set([
-        "persistence_cache_search.persistence",
-        "persistence_cache_search.archive",
-        "persistence_cache_search.retention",
-        "persistence_cache_search.deletion",
-        "transaction_consistency_concurrency_idempotency.durability",
-        "reliability_slo.durability",
-        "event_message_job.retention",
-        "backup_restore_disaster_recovery.backup_scope",
-        "commercial_billing.audit",
-    ]),
-    boundary: new Set([
-        "api_protocol.operation_identity",
-        "api_protocol.request_body",
-        "api_protocol.callback_webhook",
-        "external_integration.provider_protocol_identity",
-        "external_integration.request_contract",
-        "external_integration.callback_contract",
-        "external_integration.side_effect_observation",
-        "commercial_billing.processor_confirmation",
-    ]),
-    identity: new Set([
-        "actor_role_tenant_entitlement.identity",
-        "actor_role_tenant_entitlement.impersonation",
-        "actor_role_tenant_entitlement.isolation_boundary",
-        "data_model.identity",
-        "security.authentication",
-        "security.identity_proofing",
-        "security.authorization",
-        "security.tenant_isolation",
-        "api_protocol.authentication",
-        "api_protocol.authorization",
-    ]),
-    transition: new Set([
-        "operation_workflow.trigger",
-        "operation_workflow.ordered_step",
-        "operation_workflow.state_transition",
-        "operation_workflow.synchronous_effect",
-        "operation_workflow.asynchronous_effect",
-        "state_machine.transition",
-        "state_machine.illegal_transition",
-        "state_machine.reentry",
-        "state_machine.interruption",
-        "commercial_billing.payment_state",
-    ]),
-    recovery: new Set([
-        "state_machine.recovery",
-        "state_machine.restoration",
-        "input_validation.lossless_recovery",
-        "output_error.recovery",
-        "fault_degradation_recovery.recovery_trigger",
-        "fault_degradation_recovery.restoration_point",
-        "fault_degradation_recovery.data_loss_prevention",
-        "backup_restore_disaster_recovery.restore_procedure",
-        "backup_restore_disaster_recovery.restore_verification",
-        "backup_restore_disaster_recovery.drill_evidence",
-        "compatibility_migration_rollout.failure_recovery",
-        "reliability_slo.recovery_response",
-        "architecture_ownership.recovery",
-    ]),
-    population: new Set([
-        "data_model.cardinality",
-        "performance_capacity_cost.dataset_cardinality",
-        "reliability_slo.population",
-        "ai_ml.evaluation_population",
-    ]),
-    visual: new Set([
-        "architecture_ownership.selected_design",
-        "notification_file_media.dimensions",
-        "notification_file_media.accessibility_alternative",
-    ]),
-};
-export function semanticFactCustomPropertyHasClosedStandardProfile(property) {
-    return (!property.standard &&
-        isCustomSemanticFactName(property.property) &&
-        property.required_methods.length > 0 &&
-        property.required_methods.every((method) => Object.hasOwn(METHOD_CAPABILITY_FLOORS, method)));
-}
-export function validateSemanticFactProofProfileClosure(manifest) {
-    const digest = sha256Hex(canonicalValueJson(SEMANTIC_FACT_STANDARD_PROPERTIES));
-    if (digest !== STANDARD_PROPERTY_CATALOG_SHA256)
-        semanticFactClosureInvalid("standard_property_profile_catalog_changed", `${digest}:${STANDARD_PROPERTY_CATALOG_SHA256}`);
-    if (Object.keys(METHOD_CAPABILITY_FLOORS).length !==
-        SEMANTIC_FACT_PROOF_METHODS.length ||
-        SEMANTIC_FACT_PROOF_METHODS.some((method) => !Object.hasOwn(METHOD_CAPABILITY_FLOORS, method)))
-        semanticFactClosureInvalid("standard_proof_method_profile_incomplete", SEMANTIC_FACT_PROOF_METHODS.join(","));
-    const families = new Map(manifest.family_dispositions.map((family) => [family.key, family.family]));
-    for (const property of manifest.property_dispositions) {
-        const family = families.get(property.family_ref);
-        if (!family)
-            semanticFactClosureInvalid("proof_profile_property_family_unknown", property.key);
-        const catalog = SEMANTIC_FACT_STANDARD_PROPERTIES[family];
-        const catalogStandard = Boolean(catalog?.includes(property.property));
-        if (property.standard !== catalogStandard)
-            semanticFactClosureInvalid("proof_profile_property_standard_mismatch", `${property.key}:${family}.${property.property}`);
-    }
-    const known = new Set(Object.entries(SEMANTIC_FACT_STANDARD_PROPERTIES).flatMap(([family, properties]) => properties.map((property) => `${family}.${property}`)));
-    for (const [className, members] of Object.entries(PROPERTY_CLASSES))
-        for (const member of members)
-            if (!known.has(member))
-                semanticFactClosureInvalid("proof_profile_property_member_unknown", `${className}:${member}`);
-}
-export function semanticFactProofCapabilityFloor(manifest, fact, proof) {
-    const property = manifest.property_dispositions.find((row) => row.key === fact.property_ref);
-    if (!property)
-        semanticFactClosureInvalid("proof_profile_fact_property_unknown", `${fact.key}:${fact.property_ref}`);
-    const standardMethod = Object.hasOwn(METHOD_CAPABILITY_FLOORS, proof.method);
-    if (proof.authority === "machine" &&
-        (!standardMethod ||
-            (!property.standard &&
-                !semanticFactCustomPropertyHasClosedStandardProfile(property))))
-        semanticFactClosureInvalid("semantic_fact_custom_machine_authority_forbidden", `${proof.key}:${property.property}:${proof.method}`);
-    const result = new Set(["semantic_fact"]);
-    if (standardMethod)
-        for (const capability of METHOD_CAPABILITY_FLOORS[proof.method])
-            result.add(capability);
-    for (const capability of property.required_evidence_capabilities)
-        result.add(capability);
-    const family = manifest.family_dispositions.find((row) => row.key === fact.family_ref)?.family;
-    const propertyIdentity = `${family}.${property.property}`;
-    for (const [className, members] of Object.entries(PROPERTY_CLASSES))
-        if (members.has(propertyIdentity))
-            for (const capability of PROPERTY_CLASS_CAPABILITIES[className])
-                result.add(capability);
-    if (fact.observation_scope === "implementation_structure")
-        result.add("presence");
-    if (fact.observation_scope === "data_boundary")
-        result.add("data_state");
-    if (fact.observation_scope === "external_boundary") {
-        result.add("boundary_invocation");
-        result.add("actual_provenance");
-    }
-    if (fact.quantifier.kind !== "one")
-        result.add("population_coverage");
-    return result;
-}

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

@@ -1,21 +0,0 @@
-export type Shape = Record<string, unknown>;
-export declare function object(value: unknown, label: string, required: string[], optional?: string[]): Shape;
-export declare function array(value: unknown, label: string): unknown[];
-export declare function string(value: unknown, label: string): string;
-export declare function text(value: unknown, label: string): string;
-export declare function boolean(value: unknown, label: string): boolean;
-export declare function strings(value: unknown, label: string): string[];
-export declare function repositoryFile(value: unknown, label: string): string;
-export declare function repositoryFiles(value: unknown, label: string): string[];
-export declare function repositoryPattern(value: unknown, label: string): string;
-export declare function repositoryPatterns(value: unknown, label: string): string[];
-export declare function repositoryCwd(value: unknown, label: string): string;
-export declare function repositorySourceRef(value: unknown, label: string): string;
-export declare function literal<T extends string>(value: unknown, allowed: readonly T[], label: string): T;
-export declare function key(value: unknown, label: string): string;
-export declare function semanticRef(value: unknown, label: string): string;
-export declare function nullable<T>(value: unknown, parser: (value: unknown) => T): T | null;
-export declare const PROOF_SURFACES: readonly ["ui_browser", "runtime_behavior", "api_contract", "data_state", "security_boundary", "population_coverage", "implementation_structure"];
-export declare const JOURNEY_ROLES: readonly ["success", "degradation", "recovery", "stage_gate", "conformance"];
-export declare const EVIDENCE_CAPABILITIES: readonly ["presence", "interaction_trace", "state_delta", "cross_surface_consistency", "durable_readback", "boundary_invocation", "actual_provenance", "external_side_effect", "distinct_identity", "data_state", "population_coverage", "failure_injection", "recovery", "visual_render", "design_conformance", "design_method", "design_symbolic_certificate", "semantic_fact", "target_runtime", "input_variation"];
-export declare function fail(label: string, message: string): never;

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

@@ -1,121 +0,0 @@
-import { normalizeRepositoryCwd, normalizeRepositoryFile, parseRepositoryPattern, } from "./long-task-paths.js";
-export function object(value, label, required, optional = []) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        fail(label, "must be an object");
-    const row = value;
-    const allowed = new Set([...required, ...optional]);
-    const unknown = Object.keys(row).filter((name) => !allowed.has(name));
-    if (unknown.length)
-        fail(label, `unknown keys: ${unknown.join(",")}`);
-    const missing = required.filter((name) => !(name in row));
-    if (missing.length)
-        fail(label, `missing keys: ${missing.join(",")}`);
-    return row;
-}
-export function array(value, label) {
-    if (!Array.isArray(value))
-        fail(label, "must be an array");
-    return value;
-}
-export function string(value, label) {
-    if (typeof value !== "string" || !value.trim())
-        fail(label, "must be a non-empty string");
-    return value;
-}
-export function text(value, label) {
-    if (typeof value !== "string")
-        fail(label, "must be a string");
-    return value;
-}
-export function boolean(value, label) {
-    if (typeof value !== "boolean")
-        fail(label, "must be a boolean");
-    return value;
-}
-export function strings(value, label) {
-    return array(value, label).map((item, index) => string(item, `${label}[${index}]`));
-}
-export function repositoryFile(value, label) {
-    return normalizeRepositoryFile(string(value, label), label);
-}
-export function repositoryFiles(value, label) {
-    return array(value, label).map((item, index) => repositoryFile(item, `${label}[${index}]`));
-}
-export function repositoryPattern(value, label) {
-    return parseRepositoryPattern(string(value, label), label).normalized;
-}
-export function repositoryPatterns(value, label) {
-    return array(value, label).map((item, index) => repositoryPattern(item, `${label}[${index}]`));
-}
-export function repositoryCwd(value, label) {
-    return normalizeRepositoryCwd(string(value, label), label);
-}
-export function repositorySourceRef(value, label) {
-    const sourceRef = string(value, label);
-    const [file, anchor, ...extra] = sourceRef.split("#");
-    if (!file || extra.length || (anchor !== undefined && !anchor))
-        fail(label, "source_claim_ref_invalid");
-    const normalized = normalizeRepositoryFile(file, `${label}.file`);
-    return anchor === undefined ? normalized : `${normalized}#${anchor}`;
-}
-export function literal(value, allowed, label) {
-    if (typeof value !== "string" || !allowed.includes(value))
-        fail(label, `must be one of ${allowed.join(",")}`);
-    return value;
-}
-export function key(value, label) {
-    const result = string(value, label);
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(result))
-        fail(label, "must match ^[a-z0-9][a-z0-9-]*$");
-    return result;
-}
-export function semanticRef(value, label) {
-    const result = string(value, label);
-    if (!/^[a-z0-9][a-z0-9._:-]*$/u.test(result))
-        fail(label, "must be a stable lowercase semantic reference");
-    return result;
-}
-export function nullable(value, parser) {
-    return value === null ? null : parser(value);
-}
-export const PROOF_SURFACES = [
-    "ui_browser",
-    "runtime_behavior",
-    "api_contract",
-    "data_state",
-    "security_boundary",
-    "population_coverage",
-    "implementation_structure",
-];
-export const JOURNEY_ROLES = [
-    "success",
-    "degradation",
-    "recovery",
-    "stage_gate",
-    "conformance",
-];
-export const EVIDENCE_CAPABILITIES = [
-    "presence",
-    "interaction_trace",
-    "state_delta",
-    "cross_surface_consistency",
-    "durable_readback",
-    "boundary_invocation",
-    "actual_provenance",
-    "external_side_effect",
-    "distinct_identity",
-    "data_state",
-    "population_coverage",
-    "failure_injection",
-    "recovery",
-    "visual_render",
-    "design_conformance",
-    "design_method",
-    "design_symbolic_certificate",
-    "semantic_fact",
-    "target_runtime",
-    "input_variation",
-];
-export function fail(label, message) {
-    throw new Error(`delivery_contract_invalid:${label}:${message}`);
-}

package/dist/lib/long-task-source-anchors.d.ts

@@ -1,10 +0,0 @@
-import type { MaterialSourceFragmentV2, SemanticSourceAnchorV2 } from "./long-task-source-authority-types.js";
-export type SemanticModalPolarity = "positive" | "negative";
-export interface SemanticModalOccurrenceV2 {
-    value: string;
-    polarity: SemanticModalPolarity;
-}
-export declare function semanticSourceAnchorRef(anchor: Pick<SemanticSourceAnchorV2, "fragment_ref" | "kind" | "value_sha256">): string;
-export declare function deriveSemanticSourceAnchors(fragment: MaterialSourceFragmentV2): SemanticSourceAnchorV2[];
-export declare function semanticModalOccurrences(text: string): SemanticModalOccurrenceV2[];
-export declare function semanticModalPolarity(value: string): SemanticModalPolarity | null;

package/dist/lib/long-task-source-anchors.js

@@ -1,102 +0,0 @@
-import { sha256Hex } from "./strict-codec.js";
-const POSITIVE_MODAL_TERMS = [
-    "must",
-    "shall",
-    "required",
-    "必须",
-    "应当",
-];
-const NEGATIVE_MODAL_TERMS = [
-    "must not",
-    "shall not",
-    "forbidden",
-    "never",
-    "不得",
-    "禁止",
-    "不可",
-    "只能",
-    "仅可",
-];
-export function semanticSourceAnchorRef(anchor) {
-    return `${anchor.fragment_ref}#anchor:${anchor.kind}:${anchor.value_sha256.slice(0, 16)}`;
-}
-export function deriveSemanticSourceAnchors(fragment) {
-    const found = [];
-    collectMatches(found, fragment.normalized_text, "code_mark", /`([^`\n]+)`/gu, 1);
-    collectMatches(found, fragment.normalized_text, "exact_quote", /["“”'‘’]([^"“”'‘’\n]{2,})["“”'‘’]/gu, 1);
-    collectMatches(found, fragment.normalized_text, "api_path", /(?:^|[\s`"'(])((?:\/[A-Za-z0-9._~!$&*+,;=:@%{}-]*[A-Za-z0-9_~!$&*+=@%{}-])+)(?=$|[\s`"'),.;:])/gu, 1);
-    collectMatches(found, fragment.normalized_text, "version", /\bv?\d+\.\d+(?:\.\d+)?(?:[-+][A-Za-z0-9.-]+)?\b/gu);
-    collectMatches(found, fragment.normalized_text, "symbol", /\b[A-Z][A-Z0-9_]{2,}\b/gu);
-    collectMatches(found, fragment.normalized_text, "frozen_identifier", /(?:\b(?:[Pp]rovider|[Pp]rotocol)\b|(?:提供商|供应商|协议))\s*(?:(?:[:：=]|is\b|named\b|called\b|为|是|采用|使用)\s*)?([A-Z][A-Za-z0-9]*(?:[-._][A-Za-z0-9]+)*)/gu, 1);
-    collectMatches(found, fragment.normalized_text, "file_or_schema_key", /\b[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)+\b/gu);
-    collectMatches(found, fragment.normalized_text, "file_or_schema_key", /\b([A-Za-z_][\w.-]*)\s*(?=[:=])/gu, 1);
-    collectMatches(found, fragment.normalized_text, "number_or_unit", /\b\d+(?:\.\d+)?(?:\s*(?:-|–|—|\.\.)\s*\d+(?:\.\d+)?)?(?:\s*(?:ms|s|sec|seconds?|min|minutes?|h|hours?|bytes?|KB|MB|GB|%|px|rem|em|rps|qps))?\b/giu);
-    addModalAnchors(found, fragment.normalized_text);
-    return materializeAnchors(fragment, found);
-}
-function addModalAnchors(found, text) {
-    for (const occurrence of semanticModalOccurrences(text))
-        found.push({ kind: "modal_term", value: occurrence.value });
-}
-export function semanticModalOccurrences(text) {
-    const alternatives = [...NEGATIVE_MODAL_TERMS, ...POSITIVE_MODAL_TERMS].sort((left, right) => right.length - left.length);
-    const pattern = new RegExp(`(?:^|[^a-z])(${alternatives
-        .filter((term) => !/[\u3400-\u9fff]/u.test(term))
-        .map(escapeRegex)
-        .join("|")})(?=$|[^a-z])|(${alternatives
-        .filter((term) => /[\u3400-\u9fff]/u.test(term))
-        .map(escapeRegex)
-        .join("|")})`, "giu");
-    const negative = new Set(NEGATIVE_MODAL_TERMS);
-    return [...text.matchAll(pattern)].map((match) => {
-        const value = (match[1] ?? match[2]).toLocaleLowerCase("en-US");
-        return {
-            value,
-            polarity: negative.has(value) ? "negative" : "positive",
-        };
-    });
-}
-export function semanticModalPolarity(value) {
-    const normalized = value.toLocaleLowerCase("en-US");
-    if (NEGATIVE_MODAL_TERMS.includes(normalized))
-        return "negative";
-    if (POSITIVE_MODAL_TERMS.includes(normalized))
-        return "positive";
-    return null;
-}
-function materializeAnchors(fragment, found) {
-    const seen = new Set();
-    return found
-        .map(({ kind, value }) => ({ kind, value: value.trim() }))
-        .filter(({ kind, value }) => {
-        if (!value)
-            return false;
-        const identity = `${kind}\0${value}`;
-        if (seen.has(identity))
-            return false;
-        seen.add(identity);
-        return true;
-    })
-        .map(({ kind, value }) => {
-        const valueSha256 = sha256Hex(value);
-        const base = {
-            fragment_ref: fragment.key,
-            source_item_ref: fragment.source_item_ref,
-            authority_source_item_refs: [...fragment.authority_source_item_refs],
-            authority_domain: fragment.authority_domain,
-            kind,
-            value,
-            value_sha256: valueSha256,
-        };
-        return { ...base, key: semanticSourceAnchorRef(base) };
-    })
-        .sort((left, right) => left.key.localeCompare(right.key));
-}
-function collectMatches(result, value, kind, pattern, group = 0) {
-    for (const match of value.matchAll(pattern))
-        if (match[group])
-            result.push({ kind, value: match[group] });
-}
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}

package/dist/lib/long-task-source-authority-types.d.ts

@@ -1,61 +0,0 @@
-import type { RiskFactName } from "./long-task-risk-types.js";
-export type SourceItemKind = "outcome_result" | "requirement" | "control" | "acceptance" | "technical_obligation" | "non_completing" | "non_goal" | "forbidden_shortcut" | "risk_fact" | "external_confirmation" | "decision";
-export type SourceItemAspect = "architecture";
-export type SourceAuthorityDomain = "product" | "technical" | "design" | "acceptance" | "external";
-export type MaterialSourceFragmentKind = "heading" | "paragraph" | "list_item" | "table_row" | "blockquote" | "given_when_then" | "fenced_code" | "structured_config_line" | "textual_html";
-export interface MaterialTextInputV2 {
-    input_key: string;
-    input_kind: "source_item" | "attachment" | "canonical_spec" | "repository_preservation" | "external_constraint" | "delegated_instruction" | "design_resource";
-    source_ref: string;
-    sha256: string;
-    authority_source_item_refs: string[];
-    authority_domain: SourceAuthorityDomain;
-    normalized_text: string;
-}
-export interface MaterialFragmentCoverageV2 {
-    material_nonblank_lines: number[];
-    covered_lines: number[];
-    excluded_separator_lines: number[];
-}
-export interface MaterialFragmentScanResultV2 {
-    fragments: MaterialSourceFragmentV2[];
-    coverage: MaterialFragmentCoverageV2;
-}
-export type SemanticAnchorKind = "code_mark" | "api_path" | "version" | "symbol" | "frozen_identifier" | "file_or_schema_key" | "number_or_unit" | "exact_quote" | "modal_term";
-export interface MaterialSourceFragmentV2 {
-    key: string;
-    input_key: string;
-    source_item_ref: string;
-    authority_source_item_refs: string[];
-    source_path: string;
-    authority_domain: SourceAuthorityDomain;
-    kind: MaterialSourceFragmentKind;
-    ordinal: number;
-    start_line: number;
-    end_line: number;
-    normalized_text: string;
-    text_sha256: string;
-}
-export interface SemanticSourceAnchorV2 {
-    key: string;
-    fragment_ref: string;
-    source_item_ref: string;
-    authority_source_item_refs: string[];
-    authority_domain: SourceAuthorityDomain;
-    kind: SemanticAnchorKind;
-    value: string;
-    value_sha256: string;
-}
-export type SemanticFactClassV2 = "delivery_semantic" | "source_integrity";
-export interface CompiledSourceItemV2 {
-    key: string;
-    kind: SourceItemKind;
-    aspect?: SourceItemAspect;
-    source_path: string;
-    normalized_text: string;
-    text_sha256: string;
-    risk_semantics?: {
-        fact: RiskFactName;
-        affected_outcome: string;
-    };
-}

package/dist/lib/long-task-source-authority-types.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/long-task-source-claim-validation.d.ts

@@ -1,5 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { compileProductClaimCoverage } from "./long-task-claims.js";
-export declare function validateSourceClaimMappings(contract: DeliveryContractV2, compiledClaims: ReturnType<typeof compileProductClaimCoverage>, report?: ValidationReporter): void;
-type ValidationReporter = (message: string) => void;
-export {};