project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,137 +0,0 @@
-import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
-const STRICT_FACTS = new Set([
-    "public_api_or_schema_change",
-    "persistent_data_change",
-    "data_migration",
-    "security_boundary_change",
-    "permission_boundary_change",
-    "irreversible_external_effect",
-    "full_population_operation",
-    "multi_repository_change",
-]);
-export function classifyLongTaskRisk(contract) {
-    const outcomeKeys = new Set(contract.outcomes.map((outcome) => outcome.key));
-    const reasonsByOutcome = Object.fromEntries(contract.outcomes.map((outcome) => [outcome.key, []]));
-    for (const [fact, outcomes] of Object.entries(contract.risk.facts)) {
-        for (const outcome of outcomes) {
-            if (!outcomeKeys.has(outcome))
-                throw new Error(`risk_outcome_unknown:${fact}:${outcome}`);
-            reasonsByOutcome[outcome].push(fact);
-        }
-    }
-    if (contract.risk.facts.multi_repository_change.length)
-        throw new Error("multi_repository_delivery_not_supported_v2");
-    const reasons = Object.entries(reasonsByOutcome)
-        .flatMap(([outcome, facts]) => facts
-        .filter((fact) => STRICT_FACTS.has(fact))
-        .map((fact) => `${fact}:${outcome}`))
-        .concat(contract.outcomes
-        .filter((outcome) => contract.risk.facts.critical_user_path.includes(outcome.key) &&
-        contract.risk.facts.weak_observability.includes(outcome.key))
-        .map((outcome) => `critical_user_path_with_weak_observability:${outcome.key}`));
-    const minimum = reasons.length ? "strict" : "standard";
-    if (contract.risk.requested_level === "standard" && minimum === "strict")
-        throw new Error(`risk_level_below_required:${reasons.join(",")}`);
-    return {
-        minimum_level: minimum,
-        effective_level: contract.risk.requested_level === "strict" ? "strict" : minimum,
-        reasons,
-        reasons_by_outcome: reasonsByOutcome,
-    };
-}
-export function validateRiskProof(contract, decision) {
-    const errors = [];
-    if (!contract.outcomes.length)
-        errors.push("outcome_required");
-    for (const check of contract.global.acceptance.checks)
-        validateCheck(check, "global", errors);
-    for (const outcome of contract.outcomes)
-        validateOutcome(contract, outcome, errors);
-    if (decision.effective_level === "strict")
-        validateStrict(contract, decision, errors);
-    if (errors.length)
-        throw new Error(`delivery_contract_preflight_failed:\n${errors.join("\n")}`);
-}
-function validateOutcome(contract, outcome, errors) {
-    const checks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
-    const resultExternallyBlocked = outcomeResultExternallyBlocked(contract, outcome.key);
-    if (!checks.size && !resultExternallyBlocked)
-        errors.push(`outcome_without_executable_check:${outcome.key}`);
-    if (!outcome.technical.expected_change_paths.length)
-        errors.push(`expected_change_paths_empty:${outcome.key}`);
-    for (const check of checks.values())
-        validateCheck(check, outcome.key, errors);
-    if ((outcome.product.owner_surfaces.length ||
-        outcome.product.controls.length) &&
-        !resultExternallyBlocked &&
-        ![...checks.values()].some((check) => check.proof_surface === "ui_browser"))
-        errors.push(`ui_outcome_requires_ui_browser_proof:${outcome.key}`);
-    const referenced = [
-        ...(outcome.acceptance.population
-            ? [outcome.acceptance.population.check_key]
-            : []),
-        ...outcome.acceptance.counterfactual_controls.map((control) => control.check_key),
-        ...(outcome.technical.rollback_and_recovery?.verification_check_keys ?? []),
-        ...outcome.technical.bindings.flatMap((binding) => binding.verification_check_key ? [binding.verification_check_key] : []),
-    ];
-    for (const checkKey of referenced)
-        if (!checks.has(checkKey))
-            errors.push(`outcome_check_reference_unknown:${outcome.key}:${checkKey}`);
-}
-function validateStrict(contract, decision, errors) {
-    const explicitStrictWithoutFacts = contract.risk.requested_level === "strict" && decision.reasons.length === 0;
-    for (const outcome of contract.outcomes) {
-        if (outcomeResultExternallyBlocked(contract, outcome.key))
-            continue;
-        const facts = new Set(decision.reasons_by_outcome[outcome.key]);
-        const checks = outcome.acceptance.checks;
-        const hasNegative = checks.some((check) => check.negative_assertions.length > 0);
-        const hasCounterfactual = outcome.acceptance.counterfactual_controls.length > 0;
-        if (explicitStrictWithoutFacts) {
-            if (!hasNegative)
-                errors.push(`strict_negative_assertion_required:${outcome.key}`);
-            if (!hasCounterfactual)
-                errors.push(`strict_counterfactual_control_required:${outcome.key}`);
-        }
-        if (facts.has("security_boundary_change") ||
-            facts.has("permission_boundary_change"))
-            requireStrictProof(outcome, "security_boundary", hasNegative, hasCounterfactual, errors);
-        if (facts.has("public_api_or_schema_change"))
-            requireStrictProof(outcome, "api_contract", hasNegative, hasCounterfactual, errors);
-        if (facts.has("persistent_data_change") || facts.has("data_migration")) {
-            requireStrictProof(outcome, "data_state", hasNegative, hasCounterfactual, errors);
-            if (!outcome.technical.rollback_and_recovery)
-                errors.push(`strict_rollback_and_recovery_required:${outcome.key}`);
-        }
-        if (facts.has("irreversible_external_effect") &&
-            !outcome.technical.rollback_and_recovery)
-            errors.push(`strict_rollback_and_recovery_required:${outcome.key}`);
-        if (facts.has("full_population_operation")) {
-            if (!checks.some((check) => check.proof_surface === "population_coverage"))
-                errors.push(`strict_population_coverage_proof_required:${outcome.key}`);
-            if (!outcome.acceptance.population)
-                errors.push(`strict_population_declaration_required:${outcome.key}`);
-        }
-        if (facts.has("critical_user_path") &&
-            facts.has("weak_observability") &&
-            !checks.some((check) => check.proof_surface === "ui_browser" ||
-                check.proof_surface === "runtime_behavior"))
-            errors.push(`strict_critical_path_observable_proof_required:${outcome.key}`);
-    }
-}
-function requireStrictProof(outcome, surface, hasNegative, hasCounterfactual, errors) {
-    if (!outcome.acceptance.checks.some((check) => check.proof_surface === surface))
-        errors.push(`strict_${surface}_proof_required:${outcome.key}`);
-    if (!hasNegative)
-        errors.push(`strict_negative_assertion_required:${outcome.key}`);
-    if (!hasCounterfactual)
-        errors.push(`strict_counterfactual_control_required:${outcome.key}`);
-}
-function validateCheck(check, owner, errors) {
-    if (!check.verification_inputs.length)
-        errors.push(`verification_inputs_empty:${owner}:${check.key}`);
-    if (check.runner.retry_policy === "transient_once" &&
-        (!check.runner.idempotent ||
-            !["read_only", "test_sandbox"].includes(check.runner.effect)))
-        errors.push(`unsafe_retry_policy:${owner}:${check.key}`);
-}

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

@@ -1,5 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function parseTask(value: unknown): DeliveryContractV2["task"];
-export declare function parseStages(value: unknown): DeliveryContractV2["stages"];
-export declare function parseRisk(value: unknown): DeliveryContractV2["risk"];
-export declare function parseGlobal(value: unknown): DeliveryContractV2["global"];

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

@@ -1,182 +0,0 @@
-import { parseGlobalCounterfactuals } from "./long-task-acceptance-shape.js";
-import { parseCheck } from "./long-task-check-shape.js";
-import { array, boolean, key, literal, object, parseApplicableKeyedStatements, parseClaimApplicability, parseKeyedPaths, repositoryFiles, string, strings, } from "./long-task-delivery-shape.js";
-import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
-const RISK_FACTS = [
-    "public_api_or_schema_change",
-    "persistent_data_change",
-    "data_migration",
-    "security_boundary_change",
-    "permission_boundary_change",
-    "irreversible_external_effect",
-    "critical_user_path",
-    "full_population_operation",
-    "multi_repository_change",
-    "weak_observability",
-];
-export function parseTask(value) {
-    const row = object(value, "task", [
-        "id",
-        "title",
-        "goal",
-        "target_profile",
-        "execution_targets",
-        "source_paths",
-        "context_refs",
-    ], ["context_snapshot_mode"]);
-    const targetProfile = object(row.target_profile, "task.target_profile", [
-        "key",
-        "description",
-        "required_state",
-        "required_target_refs",
-    ]);
-    return {
-        id: key(row.id, "task.id"),
-        title: string(row.title, "task.title"),
-        goal: string(row.goal, "task.goal"),
-        target_profile: {
-            key: key(targetProfile.key, "task.target_profile.key"),
-            description: string(targetProfile.description, "task.target_profile.description"),
-            required_state: literal(targetProfile.required_state, [
-                "implementation_complete",
-                "target_profile_usable",
-                "production_release_ready",
-            ], "task.target_profile.required_state"),
-            required_target_refs: strings(targetProfile.required_target_refs, "task.target_profile.required_target_refs").map((item, index) => key(item, `task.target_profile.required_target_refs[${index}]`)),
-        },
-        execution_targets: array(row.execution_targets, "task.execution_targets").map((item, index) => {
-            const label = `task.execution_targets[${index}]`;
-            const target = object(item, label, [
-                "key",
-                "description",
-                "role",
-                "runtime_family",
-                "root_entrypoint",
-                "capabilities",
-            ], ["root_argv"]);
-            return {
-                key: key(target.key, `${label}.key`),
-                description: string(target.description, `${label}.description`),
-                role: literal(target.role, ["product", "support", "observer"], `${label}.role`),
-                runtime_family: literal(target.runtime_family, [
-                    "browser",
-                    "native",
-                    "desktop",
-                    "service",
-                    "process",
-                    "external",
-                ], `${label}.runtime_family`),
-                root_entrypoint: string(target.root_entrypoint, `${label}.root_entrypoint`),
-                ...(Object.hasOwn(target, "root_argv")
-                    ? {
-                        root_argv: strings(target.root_argv, `${label}.root_argv`).map((argument, argumentIndex) => {
-                            if (argument.includes("\0"))
-                                throw new Error(`delivery_contract_invalid:execution_target_root_argv_invalid:${label}:${argumentIndex}`);
-                            return argument;
-                        }),
-                    }
-                    : {}),
-                capabilities: strings(target.capabilities, `${label}.capabilities`).map((item, capabilityIndex) => literal(item, EXECUTION_TARGET_CAPABILITIES, `${label}.capabilities[${capabilityIndex}]`)),
-            };
-        }),
-        source_paths: repositoryFiles(row.source_paths, "task.source_paths"),
-        context_refs: repositoryFiles(row.context_refs, "task.context_refs"),
-        context_snapshot_mode: Object.hasOwn(row, "context_snapshot_mode")
-            ? literal(row.context_snapshot_mode, ["referenced", "full"], "task.context_snapshot_mode")
-            : "full",
-    };
-}
-export function parseStages(value) {
-    return array(value, "stages").map((item, index) => {
-        const label = `stages[${index}]`;
-        const row = object(item, label, [
-            "key",
-            "title",
-            "depends_on",
-            "gate_outcome",
-        ]);
-        return {
-            key: key(row.key, `${label}.key`),
-            title: string(row.title, `${label}.title`),
-            depends_on: strings(row.depends_on, `${label}.depends_on`).map((entry, dependencyIndex) => key(entry, `${label}.depends_on[${dependencyIndex}]`)),
-            gate_outcome: key(row.gate_outcome, `${label}.gate_outcome`),
-        };
-    });
-}
-export function parseRisk(value) {
-    const row = object(value, "risk", ["facts"], ["requested_level"]);
-    const facts = object(row.facts, "risk.facts", [], [...RISK_FACTS]);
-    return {
-        requested_level: Object.hasOwn(row, "requested_level")
-            ? literal(row.requested_level, ["auto", "standard", "strict"], "risk.requested_level")
-            : "auto",
-        facts: Object.fromEntries(RISK_FACTS.map((name) => [
-            name,
-            Object.hasOwn(facts, name)
-                ? strings(facts[name], `risk.facts.${name}`).map((item, index) => key(item, `risk.facts.${name}[${index}]`))
-                : [],
-        ])),
-    };
-}
-export function parseGlobal(value) {
-    const row = object(value, "global", [], ["applicability", "product", "technical", "acceptance"]);
-    const product = object(Object.hasOwn(row, "product") ? row.product : {}, "global.product", [], ["non_goals"]);
-    const technical = object(Object.hasOwn(row, "technical") ? row.technical : {}, "global.technical", [], ["constraints", "forbidden_paths", "forbidden_shortcuts"]);
-    const acceptance = object(Object.hasOwn(row, "acceptance") ? row.acceptance : {}, "global.acceptance", [], ["checks", "counterfactual_controls", "external_confirmations"]);
-    return {
-        applicability: Object.hasOwn(row, "applicability")
-            ? parseClaimApplicability(row.applicability, "global.applicability")
-            : [],
-        product: {
-            non_goals: Object.hasOwn(product, "non_goals")
-                ? parseApplicableKeyedStatements(product.non_goals, "global.product.non_goals")
-                : [],
-        },
-        technical: {
-            constraints: Object.hasOwn(technical, "constraints")
-                ? parseApplicableKeyedStatements(technical.constraints, "global.technical.constraints")
-                : [],
-            forbidden_paths: Object.hasOwn(technical, "forbidden_paths")
-                ? parseKeyedPaths(technical.forbidden_paths, "global.technical.forbidden_paths")
-                : [],
-            forbidden_shortcuts: Object.hasOwn(technical, "forbidden_shortcuts")
-                ? parseApplicableKeyedStatements(technical.forbidden_shortcuts, "global.technical.forbidden_shortcuts")
-                : [],
-        },
-        acceptance: {
-            checks: Object.hasOwn(acceptance, "checks")
-                ? array(acceptance.checks, "global.acceptance.checks").map((item, index) => parseCheck(item, `global.acceptance.checks[${index}]`))
-                : [],
-            counterfactual_controls: Object.hasOwn(acceptance, "counterfactual_controls")
-                ? parseGlobalCounterfactuals(acceptance.counterfactual_controls, "global.acceptance.counterfactual_controls")
-                : [],
-            external_confirmations: Object.hasOwn(acceptance, "external_confirmations")
-                ? array(acceptance.external_confirmations, "global.acceptance.external_confirmations").map((item, index) => {
-                    const label = `global.acceptance.external_confirmations[${index}]`;
-                    const entry = object(item, label, [
-                        "key",
-                        "description",
-                        "owner",
-                        "kind",
-                        "impact_claims",
-                        "blocks_target",
-                    ]);
-                    return {
-                        key: key(entry.key, `${label}.key`),
-                        description: string(entry.description, `${label}.description`),
-                        owner: string(entry.owner, `${label}.owner`),
-                        kind: literal(entry.kind, [
-                            "functional_prerequisite",
-                            "field_validation",
-                            "production_release_gate",
-                            "commercial_activation",
-                            "expert_authority",
-                        ], `${label}.kind`),
-                        impact_claims: strings(entry.impact_claims, `${label}.impact_claims`),
-                        blocks_target: boolean(entry.blocks_target, `${label}.blocks_target`),
-                    };
-                })
-                : [],
-        },
-    };
-}

package/dist/lib/long-task-runner-environment.d.ts

@@ -1,7 +0,0 @@
-import type { EnvironmentRequirementV2 } from "./long-task-delivery-types.js";
-export declare function runnerEnvironment(requirements: EnvironmentRequirementV2[], mode?: "legacy_check" | "product_observation"): NodeJS.ProcessEnv;
-export declare function declaredEnvironmentValues(requirements: EnvironmentRequirementV2[]): string[];
-export declare function outputContainsDeclaredEnvironmentValue(raw: {
-    stdout: Buffer;
-    stderr: Buffer;
-}, values: string[]): boolean;

package/dist/lib/long-task-runner-environment.js

@@ -1,57 +0,0 @@
-const BASE_ENVIRONMENT_KEYS = [
-    "PATH",
-    "PATHEXT",
-    "SystemRoot",
-    "WINDIR",
-    "ComSpec",
-    "TEMP",
-    "TMP",
-    "TMPDIR",
-    "HOME",
-    "USERPROFILE",
-    "HOMEDRIVE",
-    "HOMEPATH",
-    "APPDATA",
-    "LOCALAPPDATA",
-    "LANG",
-    "LC_ALL",
-    "TZ",
-    "CI",
-    "TERM",
-    "NO_COLOR",
-    "FORCE_COLOR",
-];
-export function runnerEnvironment(requirements, mode = "legacy_check") {
-    const environment = {};
-    if (mode === "legacy_check")
-        environment.TY_CONTEXT_CHECK_PROTOCOL = "long-task-check-result-v3";
-    for (const key of BASE_ENVIRONMENT_KEYS)
-        copyEnvironmentValue(environment, key);
-    for (const requirement of requirements)
-        if (requirement.kind === "env_var")
-            copyEnvironmentValue(environment, requirement.target);
-    return environment;
-}
-export function declaredEnvironmentValues(requirements) {
-    const values = [];
-    for (const requirement of requirements) {
-        if (requirement.kind !== "env_var")
-            continue;
-        const value = process.env[requirement.target];
-        if (value)
-            values.push(value);
-    }
-    return values;
-}
-export function outputContainsDeclaredEnvironmentValue(raw, values) {
-    if (!values.length)
-        return false;
-    const stdout = raw.stdout.toString("utf8");
-    const stderr = raw.stderr.toString("utf8");
-    return values.some((value) => stdout.includes(value) || stderr.includes(value));
-}
-function copyEnvironmentValue(environment, key) {
-    const value = process.env[key];
-    if (value !== undefined)
-        environment[key] = value;
-}

package/dist/lib/long-task-runner-files.d.ts

@@ -1,3 +0,0 @@
-export declare function nearestRunnerFile(start: string, repository: string, name: string): Promise<string | null>;
-export declare function npmCliPath(): Promise<string>;
-export declare function npxCliPath(): Promise<string>;

package/dist/lib/long-task-runner-files.js

@@ -1,39 +0,0 @@
-import { stat } from "node:fs/promises";
-import path from "node:path";
-export async function nearestRunnerFile(start, repository, name) {
-    let current = path.resolve(start);
-    const root = path.resolve(repository);
-    for (;;) {
-        const candidate = path.join(current, name);
-        if ((await stat(candidate).catch(() => null))?.isFile())
-            return candidate;
-        if (current === root)
-            return null;
-        const parent = path.dirname(current);
-        if (parent === current || !parent.startsWith(root))
-            return null;
-        current = parent;
-    }
-}
-export async function npmCliPath() {
-    const candidates = [
-        process.env.npm_execpath,
-        path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),
-    ].filter((candidate) => Boolean(candidate));
-    for (const candidate of candidates)
-        if ((await stat(candidate).catch(() => null))?.isFile())
-            return candidate;
-    throw new Error("npm_cli_not_found_for_package_script_runner");
-}
-export async function npxCliPath() {
-    const candidates = [
-        process.env.npm_execpath
-            ? path.join(path.dirname(process.env.npm_execpath), "npx-cli.js")
-            : null,
-        path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", "npx-cli.js"),
-    ].filter((candidate) => Boolean(candidate));
-    for (const candidate of candidates)
-        if ((await stat(candidate).catch(() => null))?.isFile())
-            return candidate;
-    throw new Error("npx_cli_not_found_for_playwright_runner");
-}

package/dist/lib/long-task-runner-freeze.d.ts

@@ -1,4 +0,0 @@
-import type { CompiledCheckV2, CompiledDesignTargetV2, DeliveryCheckV2, ExecutionTargetV2, SemanticFactExpectationV2, SourceBackedExecutionTargetV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-import type { ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
-export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[], semanticFactExpectations: SemanticFactExpectationV2[], productionBindings: ScopedDeliveryBindingV2[], productionOwnerPaths: string[], sourceBackedExecutionTarget: SourceBackedExecutionTargetV2 | null, protectedAuthorityPaths?: readonly string[]): Promise<CompiledCheckV2>;
-export declare function playwrightConfigArgument(argv: readonly string[]): string | null;