project-tiny-context-harness 0.2.85 → 0.6.0

package/dist/lib/long-task-acceptance-reference.js

@@ -0,0 +1,46 @@
+export function parseAcceptanceReference(ref) {
+    const parts = ref.split(".");
+    if (parts.length !== 3 || parts.some((part) => !part))
+        throw new Error(`acceptance_reference_invalid:${ref}`);
+    const [owner, checkKey, assertionKey] = parts;
+    return owner === "GLOBAL"
+        ? {
+            scope: "global",
+            check_key: checkKey,
+            assertion_key: assertionKey,
+        }
+        : {
+            scope: "outcome",
+            outcome_key: owner,
+            check_key: checkKey,
+            assertion_key: assertionKey,
+        };
+}
+export function resolveAcceptanceAssertion(contract, ref) {
+    let reference;
+    try {
+        reference = parseAcceptanceReference(ref);
+    }
+    catch {
+        return null;
+    }
+    const contractLike = contract;
+    const checks = reference.scope === "global"
+        ? contractLike.global.acceptance.checks
+        : contractLike.outcomes.find((outcome) => outcome.key === reference.outcome_key)?.acceptance.checks;
+    const check = checks?.find((item) => item.key === reference.check_key);
+    const assertion = check
+        ? [...check.positive_assertions, ...check.negative_assertions].find((item) => item.key === reference.assertion_key)
+        : null;
+    if (!check || !assertion)
+        return null;
+    return {
+        ref,
+        scope: reference.scope,
+        outcome_key: reference.scope === "outcome" ? reference.outcome_key : null,
+        check_key: reference.check_key,
+        assertion_key: reference.assertion_key,
+        check,
+        assertion,
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { CounterfactualControlV2, EnvironmentRequirementV2, GlobalCounterfactualControlV2, PopulationRequirementV2 } from "./long-task-delivery-types.js";
+export declare function parseCounterfactuals(value: unknown, label: string): CounterfactualControlV2[];
+export declare function parseGlobalCounterfactuals(value: unknown, label: string): GlobalCounterfactualControlV2[];
+export declare function parsePopulation(value: unknown, label: string): PopulationRequirementV2;
+export declare function parseEnvironmentRequirements(value: unknown, label: string): EnvironmentRequirementV2[];

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

@@ -0,0 +1,131 @@
+import { parseKeyedStatements } from "./long-task-product-shape.js";
+import { array, fail, key, literal, object, repositoryFile, repositoryFiles, string, strings, } from "./long-task-shape-primitives.js";
+export function parseCounterfactuals(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "binding_key",
+            "claims",
+            "check_key",
+            "mutation",
+            "expected_assertion_failures",
+        ]);
+        const mutation = object(row.mutation, `${itemLabel}.mutation`, ["type"], ["paths", "path", "fixture_path"]);
+        const type = literal(mutation.type, ["remove_paths", "replace_file"], `${itemLabel}.mutation.type`);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            binding_key: key(row.binding_key, `${itemLabel}.binding_key`),
+            claims: strings(row.claims, `${itemLabel}.claims`),
+            check_key: key(row.check_key, `${itemLabel}.check_key`),
+            mutation: type === "remove_paths"
+                ? {
+                    type,
+                    paths: repositoryFiles(mutation.paths, `${itemLabel}.mutation.paths`),
+                }
+                : {
+                    type,
+                    path: repositoryFile(mutation.path, `${itemLabel}.mutation.path`),
+                    fixture_path: repositoryFile(mutation.fixture_path, `${itemLabel}.mutation.fixture_path`),
+                },
+            expected_assertion_failures: strings(row.expected_assertion_failures, `${itemLabel}.expected_assertion_failures`).map((item, assertionIndex) => key(item, `${itemLabel}.expected_assertion_failures[${assertionIndex}]`)),
+        };
+    });
+}
+export function parseGlobalCounterfactuals(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "binding_ref",
+            "claims",
+            "check_key",
+            "mutation",
+            "expected_assertion_failures",
+        ]);
+        const bindingRef = string(row.binding_ref, `${itemLabel}.binding_ref`);
+        if (!/^[a-z0-9][a-z0-9-]*\.[a-z0-9][a-z0-9-]*$/u.test(bindingRef))
+            fail(`${itemLabel}.binding_ref`, "must be <outcome-key>.<binding-key>");
+        const claims = strings(row.claims, `${itemLabel}.claims`);
+        if (!claims.length)
+            fail(`${itemLabel}.claims`, "must not be empty");
+        const failures = strings(row.expected_assertion_failures, `${itemLabel}.expected_assertion_failures`).map((entry, assertionIndex) => key(entry, `${itemLabel}.expected_assertion_failures[${assertionIndex}]`));
+        if (!failures.length)
+            fail(`${itemLabel}.expected_assertion_failures`, "must not be empty");
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            binding_ref: bindingRef,
+            claims,
+            check_key: key(row.check_key, `${itemLabel}.check_key`),
+            mutation: parseCounterfactualMutation(row.mutation, `${itemLabel}.mutation`),
+            expected_assertion_failures: failures,
+        };
+    });
+}
+function parseCounterfactualMutation(value, label) {
+    const mutation = object(value, label, ["type"], ["paths", "path", "fixture_path"]);
+    const type = literal(mutation.type, ["remove_paths", "replace_file"], `${label}.type`);
+    return type === "remove_paths"
+        ? {
+            type,
+            paths: repositoryFiles(mutation.paths, `${label}.paths`),
+        }
+        : {
+            type,
+            path: repositoryFile(mutation.path, `${label}.path`),
+            fixture_path: repositoryFile(mutation.fixture_path, `${label}.fixture_path`),
+        };
+}
+export function parsePopulation(value, label) {
+    const row = object(value, label, [
+        "check_key",
+        "claims",
+        "observations",
+        "exclusion_rules",
+    ]);
+    const observations = object(row.observations, `${label}.observations`, [
+        "eligible_ids",
+        "observed_ids",
+        "excluded_items",
+    ]);
+    return {
+        check_key: key(row.check_key, `${label}.check_key`),
+        claims: strings(row.claims, `${label}.claims`),
+        observations: {
+            eligible_ids: string(observations.eligible_ids, `${label}.observations.eligible_ids`),
+            observed_ids: string(observations.observed_ids, `${label}.observations.observed_ids`),
+            excluded_items: string(observations.excluded_items, `${label}.observations.excluded_items`),
+        },
+        exclusion_rules: parseKeyedStatements(row.exclusion_rules, `${label}.exclusion_rules`),
+    };
+}
+export function parseEnvironmentRequirements(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const base = object(item, itemLabel, ["key", "kind"], ["target", "host", "port", "timeout_ms"]);
+        const kindValue = literal(base.kind, ["executable", "file", "directory", "env_var", "loopback_tcp"], `${itemLabel}.kind`);
+        const requirementKey = key(base.key, `${itemLabel}.key`);
+        if (kindValue !== "loopback_tcp")
+            return {
+                key: requirementKey,
+                kind: kindValue,
+                target: kindValue === "file" || kindValue === "directory"
+                    ? repositoryFile(base.target, `${itemLabel}.target`)
+                    : string(base.target, `${itemLabel}.target`),
+            };
+        const host = literal(base.host, ["127.0.0.1", "::1", "localhost"], `${itemLabel}.host`);
+        const port = Number(base.port);
+        const timeout = Number(base.timeout_ms);
+        if (!Number.isInteger(port) || port < 1 || port > 65535)
+            fail(`${itemLabel}.port`, "must be an integer from 1 to 65535");
+        if (!Number.isInteger(timeout) || timeout < 10 || timeout > 60_000)
+            fail(`${itemLabel}.timeout_ms`, "must be an integer from 10 to 60000");
+        return {
+            key: requirementKey,
+            kind: kindValue,
+            host,
+            port,
+            timeout_ms: timeout,
+        };
+    });
+}

package/dist/lib/long-task-activation-validation.d.ts

@@ -0,0 +1,21 @@
+import type { AuthoringPreflightDiagnosticV1 } from "./long-task-authoring-preflight-types.js";
+import { type CompiledClaimsV2 } from "./long-task-claims.js";
+import type { CompiledCheckV2, CompiledOutcomeV2, CompiledSourceItemV2, ContextAuthoritySnapshotV2, DeliveryContractV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import { type RiskDecisionV2 } from "./long-task-risk.js";
+export interface ActivationValidationResult {
+    claims: CompiledClaimsV2 | null;
+    risk: RiskDecisionV2 | null;
+    source_hashes: Record<string, string> | null;
+    source_items: CompiledSourceItemV2[] | null;
+    context_snapshot: ContextAuthoritySnapshotV2 | null;
+    workspace: WorkspaceManifestV2 | null;
+    global_checks: CompiledCheckV2[];
+    outcomes: CompiledOutcomeV2[];
+}
+export declare function validateContractForActivation(options: {
+    contract: DeliveryContractV2;
+    repository: string;
+    workdir: string;
+    mode: "collect" | "fail_fast";
+    diagnostics?: AuthoringPreflightDiagnosticV1[];
+}): Promise<ActivationValidationResult>;

package/dist/lib/long-task-activation-validation.js

@@ -0,0 +1,136 @@
+import { captureContextGraphSnapshot } from "./context-graph-snapshot.js";
+import { addDiagnosticError } from "./long-task-authoring-preflight-diagnostics.js";
+import { compileProductClaimCoverage, } from "./long-task-claims.js";
+import { hashDeclaredFiles, validateCounterfactualPaths, validateTechnicalPaths, validateVerificationInputSeparation, } from "./long-task-delivery-preflight.js";
+import { validateClaimEvidenceSensitivity } from "./long-task-evidence-sensitivity-policy.js";
+import { deliveryContractStructureDiagnostics, validateDeliveryContractStructure, } from "./long-task-delivery-validation.js";
+import { validateRawExecutionObservationOwnership } from "./long-task-observation-ownership.js";
+import { freezeDeliveryCheck } from "./long-task-runner-freeze.js";
+import { classifyLongTaskRisk, validateRiskProof, } from "./long-task-risk.js";
+import { validateSourceContinuity } from "./long-task-source-continuity.js";
+import { compileSourceInventory } from "./long-task-source-inventory.js";
+import { validateSourceTargetContinuity } from "./long-task-source-target-continuity.js";
+import { validateSourceAnchors } from "./long-task-source-validation.js";
+import { captureWorkspaceManifest, repoRelative, } from "./long-task-workspace.js";
+export async function validateContractForActivation(options) {
+    const { contract, repository, workdir, mode } = options;
+    const diagnostics = options.diagnostics ?? [];
+    if (mode === "collect")
+        for (const error of deliveryContractStructureDiagnostics(contract))
+            addDiagnosticError(diagnostics, error);
+    else
+        validateDeliveryContractStructure(contract);
+    const claims = await attempt(mode, diagnostics, () => compileProductClaimCoverage(contract));
+    if (mode === "fail_fast") {
+        const decisions = contract.source_claims
+            .filter((claim) => claim.disposition.type === "decision_required")
+            .map((claim) => claim.key);
+        if (decisions.length)
+            throw new Error(`source_claim_decision_required:${decisions.join(",")}`);
+    }
+    const sourceHashes = await attempt(mode, diagnostics, () => hashDeclaredFiles(repository, contract.task.source_paths, "source"));
+    await attempt(mode, diagnostics, () => validateSourceAnchors(repository, contract.source_claims));
+    const sourceItems = await attempt(mode, diagnostics, async () => {
+        const items = await compileSourceInventory(repository, contract.task.source_paths);
+        validateSourceContinuity(contract, items, mode === "collect"
+            ? (error) => addDiagnosticError(diagnostics, new Error(error))
+            : undefined);
+        validateSourceTargetContinuity(contract, items, mode === "collect"
+            ? (error) => addDiagnosticError(diagnostics, new Error(error))
+            : undefined);
+        return items;
+    });
+    const risk = await attempt(mode, diagnostics, () => {
+        const decision = classifyLongTaskRisk(contract);
+        validateRiskProof(contract, decision);
+        return decision;
+    });
+    const context = await attempt(mode, diagnostics, () => captureContextGraphSnapshot(repository, contract.task.context_refs, contract.task.context_snapshot_mode));
+    const workdirRelative = repoRelative(repository, workdir);
+    const workspace = await attempt(mode, diagnostics, async () => {
+        const manifest = await captureWorkspaceManifest(repository, workdir);
+        validateTechnicalPaths(contract, repository, workdirRelative, manifest);
+        return manifest;
+    });
+    if (!workspace)
+        return emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context);
+    const globalChecks = [];
+    for (const check of contract.global.acceptance.checks) {
+        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace), null, check.key);
+        if (frozen)
+            globalChecks.push(frozen);
+    }
+    const outcomes = [];
+    for (const outcome of contract.outcomes) {
+        const checks = [];
+        for (const check of outcome.acceptance.checks) {
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace), outcome.key, check.key);
+            if (frozen)
+                checks.push(frozen);
+        }
+        outcomes.push({
+            ...outcome,
+            internal_id: `OUT.${outcome.key}`,
+            generated_claims: claims?.by_outcome[outcome.key] ?? [],
+            risk_reasons: risk?.reasons_by_outcome[outcome.key] ?? [],
+            acceptance: { ...outcome.acceptance, checks },
+        });
+    }
+    const allChecks = [
+        ...globalChecks,
+        ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
+    ];
+    await attempt(mode, diagnostics, () => validateVerificationInputSeparation(contract, allChecks, workdirRelative));
+    await attempt(mode, diagnostics, () => validateRawExecutionObservationOwnership(allChecks));
+    if (allGlobalChecksFrozen(contract, globalChecks) &&
+        allOutcomeChecksFrozen(contract, outcomes)) {
+        await attempt(mode, diagnostics, () => validateCounterfactualPaths(contract, globalChecks, outcomes, repository, workdirRelative, [
+            ...contract.task.source_paths,
+            ...(context?.files ?? contract.task.context_refs),
+        ]));
+        await attempt(mode, diagnostics, () => validateClaimEvidenceSensitivity(contract, globalChecks, outcomes, mode === "collect"
+            ? (error) => addDiagnosticError(diagnostics, new Error(error))
+            : undefined));
+    }
+    return {
+        claims,
+        risk,
+        source_hashes: sourceHashes,
+        source_items: sourceItems,
+        context_snapshot: context,
+        workspace,
+        global_checks: globalChecks,
+        outcomes,
+    };
+}
+async function attempt(mode, diagnostics, action, outcomeKey, checkKey) {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (mode === "fail_fast")
+            throw error;
+        addDiagnosticError(diagnostics, error, outcomeKey, checkKey);
+        return null;
+    }
+}
+function emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context) {
+    return {
+        claims,
+        risk,
+        source_hashes: sourceHashes,
+        source_items: sourceItems,
+        context_snapshot: context,
+        workspace: null,
+        global_checks: [],
+        outcomes: [],
+    };
+}
+function allGlobalChecksFrozen(contract, checks) {
+    return checks.length === contract.global.acceptance.checks.length;
+}
+function allOutcomeChecksFrozen(contract, outcomes) {
+    return outcomes.every((outcome) => outcome.acceptance.checks.length ===
+        contract.outcomes.find((item) => item.key === outcome.key).acceptance
+            .checks.length);
+}

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

@@ -0,0 +1,5 @@
+import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
+export declare function collectCheckArtifacts(check: CompiledCheckV2, snapshotRoot: string): Promise<{
+    hashes: Record<string, string>;
+    errors: string[];
+}>;

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

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

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

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

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

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

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

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