project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,322 +0,0 @@
-import { parseGlobalCounterfactuals } from "./long-task-acceptance-shape.js";
-import { parseSemanticFactGlobalBindings } from "./long-task-semantic-fact-shape.js";
-import { parseCheck } from "./long-task-check-shape.js";
-import { array, boolean, EVIDENCE_CAPABILITIES, key, literal, object, parseApplicableKeyedStatements, parseClaimApplicability, parseKeyedPaths, repositoryFile, 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"], ["completion_authority"]);
-    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}]`)),
-            completion_authority: Object.hasOwn(targetProfile, "completion_authority")
-                ? literal(targetProfile.completion_authority, ["machine_only", "declared_authorities"], "task.target_profile.completion_authority")
-                : "machine_only",
-        },
-        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",
-        "semantic_fact_bindings",
-        "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")
-            : [],
-        ...(Object.hasOwn(row, "semantic_fact_bindings")
-            ? {
-                semantic_fact_bindings: parseSemanticFactGlobalBindings(row.semantic_fact_bindings, "global.semantic_fact_bindings"),
-            }
-            : {}),
-        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",
-                    ], [
-                        "actor",
-                        "target_ref",
-                        "environment_identity",
-                        "scenario",
-                        "evidence_requirements",
-                        "obligations",
-                    ]);
-                    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`),
-                        ...(Object.hasOwn(entry, "actor")
-                            ? { actor: parseExternalActor(entry.actor, `${label}.actor`) }
-                            : {}),
-                        ...(Object.hasOwn(entry, "target_ref")
-                            ? { target_ref: key(entry.target_ref, `${label}.target_ref`) }
-                            : {}),
-                        ...(Object.hasOwn(entry, "environment_identity")
-                            ? {
-                                environment_identity: string(entry.environment_identity, `${label}.environment_identity`),
-                            }
-                            : {}),
-                        ...(Object.hasOwn(entry, "scenario")
-                            ? {
-                                scenario: parseExternalScenario(entry.scenario, `${label}.scenario`),
-                            }
-                            : {}),
-                        ...(Object.hasOwn(entry, "evidence_requirements")
-                            ? {
-                                evidence_requirements: parseExternalStatements(entry.evidence_requirements, `${label}.evidence_requirements`),
-                            }
-                            : {}),
-                        ...(Object.hasOwn(entry, "obligations")
-                            ? {
-                                obligations: parseExternalObligations(entry.obligations, `${label}.obligations`),
-                            }
-                            : {}),
-                    };
-                })
-                : [],
-        },
-    };
-}
-function parseExternalActor(value, label) {
-    const row = object(value, label, ["id", "role", "authority_kind"], ["identity_assurance"]);
-    return {
-        id: string(row.id, `${label}.id`),
-        role: string(row.role, `${label}.role`),
-        authority_kind: literal(row.authority_kind, ["human", "expert", "external_system"], `${label}.authority_kind`),
-        ...(Object.hasOwn(row, "identity_assurance")
-            ? {
-                identity_assurance: parseExternalIdentityAssurance(row.identity_assurance, `${label}.identity_assurance`),
-            }
-            : {}),
-    };
-}
-function parseExternalIdentityAssurance(value, label) {
-    const tagged = object(value, label, ["scheme"], ["key_id", "public_key_ref"]);
-    const scheme = literal(tagged.scheme, ["ed25519", "declared_only"], `${label}.scheme`);
-    if (scheme === "declared_only") {
-        object(value, label, ["scheme"]);
-        return { scheme };
-    }
-    const row = object(value, label, ["scheme", "key_id", "public_key_ref"]);
-    return {
-        scheme,
-        key_id: key(row.key_id, `${label}.key_id`),
-        public_key_ref: repositoryFile(row.public_key_ref, `${label}.public_key_ref`),
-    };
-}
-function parseExternalScenario(value, label) {
-    const row = object(value, label, ["given", "when"]);
-    return {
-        given: parseExternalStatements(row.given, `${label}.given`),
-        when: parseExternalStatements(row.when, `${label}.when`),
-    };
-}
-function parseExternalStatements(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "statement"]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            statement: string(row.statement, `${itemLabel}.statement`),
-        };
-    });
-}
-function parseExternalObligations(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, [
-            "key",
-            "claim_ref",
-            "applicability_ref",
-            "fact_ref",
-            "proof_ref",
-            "method",
-            "proof_surface",
-            "evidence_capabilities",
-            "expected_authority_ref",
-            "result_kind",
-        ], ["judgment_basis"]);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            claim_ref: string(row.claim_ref, `${itemLabel}.claim_ref`),
-            applicability_ref: key(row.applicability_ref, `${itemLabel}.applicability_ref`),
-            fact_ref: row.fact_ref === null
-                ? null
-                : string(row.fact_ref, `${itemLabel}.fact_ref`),
-            proof_ref: row.proof_ref === null
-                ? null
-                : string(row.proof_ref, `${itemLabel}.proof_ref`),
-            method: string(row.method, `${itemLabel}.method`),
-            proof_surface: literal(row.proof_surface, [
-                "ui_browser",
-                "runtime_behavior",
-                "api_contract",
-                "data_state",
-                "security_boundary",
-                "population_coverage",
-                "implementation_structure",
-            ], `${itemLabel}.proof_surface`),
-            evidence_capabilities: strings(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
-            expected_authority_ref: string(row.expected_authority_ref, `${itemLabel}.expected_authority_ref`),
-            result_kind: literal(row.result_kind, ["actual", "judgment"], `${itemLabel}.result_kind`),
-            ...(Object.hasOwn(row, "judgment_basis")
-                ? {
-                    judgment_basis: parseExternalJudgmentBasis(row.judgment_basis, `${itemLabel}.judgment_basis`),
-                }
-                : {}),
-        };
-    });
-}
-function parseExternalJudgmentBasis(value, label) {
-    const row = object(value, label, ["kind", "source_ref"]);
-    return {
-        kind: literal(row.kind, ["subjective_preference", "expert_assessment", "authorization"], `${label}.kind`),
-        source_ref: key(row.source_ref, `${label}.source_ref`),
-    };
-}

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,5 +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";
-import type { CheckProofAdequacyV2 } from "./long-task-proof-adequacy.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[], proofAdequacy?: CheckProofAdequacyV2, externalDesignObligationRefs?: ReadonlySet<string>, externalClaimObligationRefsByAssertion?: ReadonlyMap<string, string>): Promise<CompiledCheckV2>;
-export declare function playwrightConfigArgument(argv: readonly string[]): string | null;