project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-playwright-evidence.js

@@ -1,147 +0,0 @@
-import { collectCases, declaredCaseIds, duplicateCaseInstance, record, same, } from "./long-task-playwright-case-evidence.js";
-import { evidenceRecordsForPlaywrightCases } from "./long-task-playwright-capability-records.js";
-export { designMethodAttachmentName, semanticFactAttachmentName, } from "./long-task-playwright-capability-records.js";
-export function extractPlaywrightEvidence(check, report, exitCode) {
-    const stats = record(report.stats);
-    if (!stats)
-        return invalid("playwright_report_invalid:stats");
-    const expected = integer(stats.expected);
-    const unexpected = integer(stats.unexpected);
-    const skipped = integer(stats.skipped);
-    const flaky = integer(stats.flaky);
-    if ([expected, unexpected, skipped, flaky].some((value) => value === null))
-        return invalid("playwright_report_invalid:counts");
-    const total = expected + unexpected + skipped + flaky;
-    const reportErrors = report.errors;
-    if (reportErrors !== undefined && !Array.isArray(reportErrors))
-        return invalid("playwright_report_invalid:errors");
-    const observations = {
-        "playwright.passed": exitCode === 0,
-        "playwright.expected": expected,
-        "playwright.unexpected": unexpected,
-        "playwright.skipped": skipped,
-        "playwright.flaky": flaky,
-        "playwright.total": total,
-        "playwright.zero_or_all_skipped": total === 0 || skipped === total,
-        "playwright.report_error_count": Array.isArray(reportErrors)
-            ? reportErrors.length
-            : 0,
-    };
-    const collected = collectCases(report, declaredCaseIds(check));
-    if (collected.error)
-        return invalid(collected.error);
-    const instances = collected.cases;
-    observations["playwright.declared_unexpected_instances"] = instances.filter((item) => item.unexpected).length;
-    observations["playwright.unbound_unexpected_instances"] =
-        collected.unbound_unexpected_instances;
-    const duplicate = duplicateCaseInstance(instances);
-    if (duplicate)
-        return invalid(`playwright_ac_id_duplicate:${duplicate.id}:${duplicate.project_id}`);
-    const cases = aggregateCases(instances);
-    for (const item of cases) {
-        const prefix = `playwright.case.${item.id}`;
-        observations[`${prefix}.executed`] = item.executed;
-        observations[`${prefix}.passed`] = item.passed;
-        observations[`${prefix}.skipped`] = item.skipped;
-        observations[`${prefix}.flaky`] = item.flaky;
-        observations[`${prefix}.unexpected`] = item.unexpected;
-        observations[`${prefix}.status`] = item.status;
-        observations[`${prefix}.project_ids`] = item.project_ids;
-        observations[`${prefix}.executed_instances`] = item.executed_instances;
-        observations[`${prefix}.failed_instances`] = item.failed_instances;
-        observations[`${prefix}.skipped_instances`] = item.skipped_instances;
-        observations[`${prefix}.flaky_instances`] = item.flaky_instances;
-        observations[`${prefix}.unexpected_instances`] = item.unexpected_instances;
-        observations[`${prefix}.timed_out_instances`] = item.timed_out_instances;
-        observations[`${prefix}.interrupted_instances`] =
-            item.interrupted_instances;
-    }
-    for (const id of declaredCaseIds(check)) {
-        const prefix = `playwright.case.${id}`;
-        if (!Object.hasOwn(observations, `${prefix}.status`)) {
-            observations[`${prefix}.executed`] = false;
-            observations[`${prefix}.status`] = "missing";
-        }
-    }
-    observations["playwright.case_ids"] = cases.map((item) => item.id).sort();
-    return {
-        observations,
-        evidence_records: evidenceRecordsForPlaywrightCases(check, cases),
-        error: null,
-    };
-}
-function aggregateCases(instances) {
-    const grouped = new Map();
-    for (const instance of instances) {
-        const rows = grouped.get(instance.id) ?? [];
-        rows.push(instance);
-        grouped.set(instance.id, rows);
-    }
-    return [...grouped.entries()]
-        .map(([id, rows]) => {
-        const executedInstances = rows.filter((item) => item.executed).length;
-        const skippedInstances = rows.filter((item) => item.skipped).length;
-        const flakyInstances = rows.filter((item) => item.flaky).length;
-        const unexpectedInstances = rows.filter((item) => item.unexpected).length;
-        const timedOutInstances = rows.filter((item) => item.timed_out).length;
-        const interruptedInstances = rows.filter((item) => item.interrupted).length;
-        const failedInstances = rows.filter((item) => !item.passed && !item.skipped).length;
-        const executed = rows.length > 0 && rows.every((item) => item.executed);
-        const passed = executed &&
-            skippedInstances === 0 &&
-            flakyInstances === 0 &&
-            unexpectedInstances === 0 &&
-            rows.every((item) => item.passed);
-        const status = passed
-            ? "passed"
-            : skippedInstances
-                ? "skipped"
-                : flakyInstances
-                    ? "flaky"
-                    : timedOutInstances
-                        ? "timed_out"
-                        : interruptedInstances
-                            ? "interrupted"
-                            : unexpectedInstances
-                                ? "unexpected"
-                                : "failed";
-        return {
-            id,
-            executed,
-            passed,
-            skipped: skippedInstances > 0,
-            flaky: flakyInstances > 0,
-            unexpected: unexpectedInstances > 0,
-            status,
-            project_ids: rows.map((item) => item.project_id).sort(),
-            executed_instances: executedInstances,
-            failed_instances: failedInstances,
-            skipped_instances: skippedInstances,
-            flaky_instances: flakyInstances,
-            unexpected_instances: unexpectedInstances,
-            timed_out_instances: timedOutInstances,
-            interrupted_instances: interruptedInstances,
-            given_keys: rows.length &&
-                rows.every((row) => same(row.given_keys, rows[0].given_keys))
-                ? rows[0].given_keys
-                : [],
-            action_keys: rows.length &&
-                rows.every((row) => same(row.action_keys, rows[0].action_keys))
-                ? rows[0].action_keys
-                : [],
-            attachment_names: rows.length === 0
-                ? []
-                : rows[0].attachment_names.filter((name) => rows.every((row) => row.attachment_names.includes(name))),
-            attachment_payloads: rows.length === 0
-                ? {}
-                : Object.fromEntries(Object.entries(rows[0].attachment_payloads).filter(([name, value]) => rows.every((row) => row.attachment_payloads[name] === value))),
-        };
-    })
-        .sort((left, right) => left.id.localeCompare(right.id));
-}
-function integer(value) {
-    return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : null;
-}
-function invalid(error) {
-    return { observations: {}, evidence_records: [], error };
-}

package/dist/lib/long-task-process-observation.d.ts

@@ -1,6 +0,0 @@
-import type { CompiledObservationAuthorityV2, PackageProcessObservationV1 } from "./long-task-runtime-types.js";
-export declare const PRODUCT_OBSERVATION_SCHEMA_VERSION: "ty-context-product-observation-v1";
-export declare function decodeProductObservationEnvelope(input: {
-    bytes: Uint8Array;
-    authorities: readonly CompiledObservationAuthorityV2[];
-}): PackageProcessObservationV1;

package/dist/lib/long-task-process-observation.js

@@ -1,117 +0,0 @@
-import { assertJsonTree, decodeUtf8Json, JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, observationErrorMessage, parseJsonWithoutDuplicateKeys, resolveJsonPointer, validateJsonPointerExactLocator, } from "./long-task-json-pointer-observation.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export const PRODUCT_OBSERVATION_SCHEMA_VERSION = "ty-context-product-observation-v1";
-export function decodeProductObservationEnvelope(input) {
-    let artifactSha256;
-    let parsed;
-    try {
-        if (input.bytes.byteLength > JSON_POINTER_EXACT_LIMITS.max_file_bytes)
-            throw new Error("observation_artifact_size_limit");
-        const strict = parseJsonWithoutDuplicateKeys(decodeUtf8Json(input.bytes));
-        assertJsonTree(strict, 0);
-        parsed = record(strict);
-        artifactSha256 = sha256Hex(input.bytes);
-    }
-    catch (error) {
-        throw invalid(`process_observation_decode_invalid:${observationErrorMessage(error)}`);
-    }
-    requireExactKeys(parsed, ["observations", "schema_version"]);
-    if (parsed.schema_version !== PRODUCT_OBSERVATION_SCHEMA_VERSION)
-        throw invalid("process_observation_schema_invalid");
-    const observations = record(parsed.observations);
-    const expectedIdentities = expectedObservationIdentities(input.authorities);
-    const actualIdentities = Object.keys(observations).sort();
-    if (!sameStrings(actualIdentities, expectedIdentities))
-        throw invalid(`process_observation_identity_set_mismatch:expected=${expectedIdentities.join(",")}:actual=${actualIdentities.join(",")}`);
-    if (expectedIdentities.length >
-        JSON_POINTER_EXACT_LIMITS.max_artifacts_per_check)
-        throw invalid("process_observation_identity_count_limit");
-    const valueSha256 = {};
-    const packageObservations = [];
-    for (const observationIdentity of expectedIdentities) {
-        const pointer = observationPointer(observationIdentity);
-        try {
-            validateJsonPointerExactLocator({ kind: "json_pointer", value: pointer });
-        }
-        catch (error) {
-            throw invalid(`process_observation_decode_invalid:${observationErrorMessage(error)}`);
-        }
-        for (const authority of input.authorities)
-            if (authority.observation_identity === observationIdentity &&
-                (authority.authority !== "package_process_json_exact" ||
-                    authority.locator_policy.kind !== "fixed_json_pointer" ||
-                    authority.locator_policy.value !== pointer))
-                throw invalid("process_observation_authority_invalid");
-        let rawValue;
-        try {
-            rawValue = resolveJsonPointer(parsed, pointer);
-        }
-        catch (error) {
-            throw invalid(`process_observation_decode_invalid:${observationErrorMessage(error)}`);
-        }
-        const canonical = canonicalValueJson(rawValue);
-        if (Buffer.byteLength(canonical, "utf8") >
-            JSON_POINTER_EXACT_LIMITS.max_canonical_value_bytes)
-            throw invalid("process_observation_value_size_limit");
-        valueSha256[observationIdentity] = sha256Hex(canonical);
-        for (const authority of input.authorities.filter((candidate) => candidate.observation_identity === observationIdentity))
-            packageObservations.push({
-                authority: "package_process_json_exact",
-                observation_identity: observationIdentity,
-                assertion_ref: authority.assertion_ref,
-                obligation_ref: authority.obligation_ref,
-                method: authority.method,
-                raw_value: rawValue,
-                observation: {
-                    capability: JSON_POINTER_EXACT_CAPABILITY,
-                    artifact_path: "process.stdout.json",
-                    artifact_sha256: artifactSha256,
-                    locator: { kind: "json_pointer", value: pointer },
-                    value_sha256: valueSha256[observationIdentity],
-                    canonical_value_bytes: Buffer.byteLength(canonical, "utf8"),
-                    sensitivity: "plain",
-                },
-                reason: null,
-            });
-    }
-    return {
-        schema_version: PRODUCT_OBSERVATION_SCHEMA_VERSION,
-        artifact_sha256: artifactSha256,
-        observations,
-        value_sha256_by_identity: valueSha256,
-        package_observations: packageObservations,
-    };
-}
-function expectedObservationIdentities(authorities) {
-    if (!authorities.length)
-        throw invalid("process_observation_authority_required");
-    const identities = new Set();
-    for (const authority of authorities) {
-        if (authority.authority !== "package_process_json_exact")
-            throw invalid("process_observation_authority_invalid");
-        if (!authority.observation_identity)
-            throw invalid("process_observation_identity_invalid");
-        identities.add(authority.observation_identity);
-    }
-    return [...identities].sort();
-}
-function record(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw invalid("process_observation_object_required");
-    return value;
-}
-function requireExactKeys(value, expected) {
-    const actual = Object.keys(value).sort();
-    if (!sameStrings(actual, [...expected].sort()))
-        throw invalid("process_observation_envelope_fields_invalid");
-}
-function observationPointer(identityValue) {
-    return `/observations/${identityValue.replace(/~/gu, "~0").replace(/\//gu, "~1")}`;
-}
-function sameStrings(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}
-function invalid(code) {
-    return new Error(code);
-}

package/dist/lib/long-task-process-runtime-closure.d.ts

@@ -1,13 +0,0 @@
-import type { CompiledObservationAuthorityV2, CompiledProcessRuntimeClosureV2, DeliveryCheckV2, ExecutionTargetV2, FrozenRunnerV2, SourceBackedExecutionTargetV2 } from "./long-task-delivery-types.js";
-import type { ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
-export interface CompileProcessRuntimeClosureInput {
-    check: DeliveryCheckV2;
-    runner: FrozenRunnerV2;
-    execution_target: ExecutionTargetV2;
-    observation_authorities: readonly CompiledObservationAuthorityV2[];
-    production_bindings: readonly ScopedDeliveryBindingV2[];
-    production_owner_paths: readonly string[];
-    source_backed_execution_target: SourceBackedExecutionTargetV2 | null;
-    protected_authority_paths: readonly string[];
-}
-export declare function compileProcessRuntimeClosure(input: CompileProcessRuntimeClosureInput): CompiledProcessRuntimeClosureV2 | null;

package/dist/lib/long-task-process-runtime-closure.js

@@ -1,207 +0,0 @@
-import path from "node:path";
-import { matchesRepoPattern, normalizeRepositoryFile, } from "./long-task-paths.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export function compileProcessRuntimeClosure(input) {
-    const processAuthorities = input.observation_authorities.filter((authority) => authority.authority === "package_process_json_exact");
-    if (!processAuthorities.length)
-        return null;
-    const targetRef = input.execution_target.key;
-    const sourceTarget = input.source_backed_execution_target;
-    if (!sourceTarget || sourceTarget.target_ref !== targetRef)
-        fail("process_root_source_binding_required", targetRef);
-    const rootTarget = normalizeRepositoryFile(input.execution_target.root_entrypoint, `${input.check.key}.process_root`);
-    const productionBindings = [...input.production_bindings];
-    requireProductionOwnership(input, rootTarget, targetRef);
-    const rootBindings = bindingsContaining(productionBindings, rootTarget);
-    if (!rootBindings.length)
-        fail("process_root_production_binding_required", `${targetRef}:${rootTarget}`);
-    const rootArgvFiles = argvAttributedRepositoryFiles(input.execution_target.root_argv ?? [], input.runner.resolved_cwd, productionBindings, targetRef);
-    const selectedBindings = new Map();
-    for (const binding of rootBindings)
-        selectBinding(selectedBindings, binding);
-    for (const argvFile of rootArgvFiles) {
-        requireProductionOwnership(input, argvFile, targetRef);
-        const bindings = bindingsContaining(productionBindings, argvFile);
-        if (!bindings.length)
-            fail("process_root_production_binding_required", `${targetRef}:${argvFile}`);
-        for (const binding of bindings)
-            selectBinding(selectedBindings, binding);
-    }
-    const productionCarrierFiles = new Set();
-    for (const carrierRef of processAuthorities.flatMap((authority) => authority.carrier_refs)) {
-        const matchingBindings = productionBindings.filter((scoped) => scoped.binding_ref === carrierRef.binding_ref &&
-            carrierRef.carrier_paths.every((carrierPath) => scoped.binding.carrier_paths.includes(carrierPath)));
-        if (!matchingBindings.length)
-            fail("process_root_production_binding_required", `${targetRef}:${carrierRef.binding_ref}`);
-        for (const binding of matchingBindings) {
-            selectBinding(selectedBindings, binding);
-            for (const carrierPath of carrierRef.carrier_paths) {
-                let carrierFile;
-                try {
-                    carrierFile = normalizeRepositoryFile(carrierPath, `${input.check.key}.process_carrier`);
-                }
-                catch {
-                    fail("process_runtime_carrier_exact_path_required", `${targetRef}:${carrierRef.binding_ref}:${carrierPath}`);
-                }
-                productionCarrierFiles.add(carrierFile);
-            }
-        }
-    }
-    const allowedRuntimeFiles = new Set([rootTarget, ...rootArgvFiles]);
-    for (const file of productionCarrierFiles)
-        allowedRuntimeFiles.add(file);
-    for (const file of allowedRuntimeFiles) {
-        requireProductionOwnership(input, file, targetRef);
-        validateConcreteRoleSeparation(input, file);
-    }
-    const projection = {
-        target_ref: targetRef,
-        source_target: sourceTarget,
-        root_target: rootTarget,
-        root_argv_files: [...new Set(rootArgvFiles)].sort(),
-        production_carrier_files: [...productionCarrierFiles].sort(),
-        allowed_runtime_files: [...allowedRuntimeFiles].sort(),
-        production_binding_refs: [...selectedBindings.keys()].sort(),
-        forbidden_role_matches: [],
-    };
-    return {
-        ...projection,
-        closure_identity: sha256Hex(canonicalValueJson(runtimeExecutionClosureProjection(projection))),
-    };
-}
-function runtimeExecutionClosureProjection(closure) {
-    return {
-        target_ref: closure.target_ref,
-        source_target: closure.source_target,
-        root_target: closure.root_target,
-        root_argv_files: closure.root_argv_files,
-        production_carrier_files: closure.production_carrier_files,
-        allowed_runtime_files: closure.allowed_runtime_files,
-        forbidden_role_matches: closure.forbidden_role_matches,
-    };
-}
-function validateConcreteRoleSeparation(input, file) {
-    const expected = firstMatchingPattern(file, input.protected_authority_paths);
-    if (expected)
-        fail("process_runtime_input_expected_authority_forbidden", `${input.check.key}:${file}:${expected}`);
-    const verification = firstMatchingPattern(file, input.check.verification_inputs);
-    if (verification)
-        fail("process_runtime_input_verification_role_forbidden", `${input.check.key}:${file}:${verification}`);
-    const evidence = firstMatchingPattern(file, [
-        ...input.check.expected_output_paths,
-        ...input.check.artifact_globs,
-    ]);
-    if (evidence)
-        fail("process_runtime_input_evidence_role_forbidden", `${input.check.key}:${file}:${evidence}`);
-}
-function requireProductionOwnership(input, file, targetRef) {
-    if (!input.production_owner_paths.some((pattern) => matchesRepoPattern(file, pattern)))
-        fail("process_root_production_binding_required", `${targetRef}:${file}:production_owner`);
-}
-function bindingsContaining(bindings, file) {
-    return bindings.filter((scoped) => scoped.binding.carrier_paths.some((pattern) => matchesRepoPattern(file, pattern)));
-}
-function selectBinding(selected, scoped) {
-    const existing = selected.get(scoped.binding_ref);
-    if (existing && canonicalValueJson(existing) !== canonicalValueJson(scoped))
-        fail("process_root_production_binding_required", `${scoped.binding_ref}:ambiguous`);
-    selected.set(scoped.binding_ref, scoped);
-}
-function argvAttributedRepositoryFiles(argv, cwd, bindings, targetRef) {
-    const result = new Set();
-    for (const argument of argv) {
-        const classification = classifyRootArgvToken(argument);
-        if (classification.kind === "label")
-            continue;
-        if (classification.kind === "external_reference")
-            fail("process_root_argv_unsafe", `${targetRef}:${argument}:${classification.reason}`);
-        const candidate = path.posix.join(cwd === "." ? "" : cwd, classification.value);
-        let normalized;
-        try {
-            normalized = normalizeRepositoryFile(candidate, "process_root_argv");
-        }
-        catch {
-            fail("process_root_argv_unsafe", `${targetRef}:${argument}:parent_escape`);
-        }
-        if (bindingsContaining(bindings, normalized).length)
-            result.add(normalized);
-    }
-    return [...result].sort();
-}
-function classifyRootArgvToken(argument) {
-    if (!argument)
-        return { kind: "label" };
-    if (hasUnsafeArgvControl(argument))
-        return externalArgvReference("unsupported_compound");
-    if (argument === "--")
-        return { kind: "label" };
-    if (argument.startsWith("--")) {
-        const assignment = /^--[A-Za-z0-9][A-Za-z0-9_-]*=(.*)$/u.exec(argument);
-        if (assignment) {
-            const value = assignment[1];
-            if (!value)
-                return { kind: "label" };
-            if (value.includes("="))
-                return externalArgvReference("unsupported_compound");
-            return classifyRootArgvValue(value);
-        }
-        if (/^--[A-Za-z0-9][A-Za-z0-9_-]*$/u.test(argument))
-            return { kind: "label" };
-        return externalArgvReference("unsupported_compound");
-    }
-    if (/^-[A-Za-z0-9?]$/u.test(argument))
-        return { kind: "label" };
-    if (/^-\d+(?:\.\d+)?$/u.test(argument))
-        return { kind: "label" };
-    if (argument.startsWith("-") || argument.startsWith("@"))
-        return externalArgvReference("unsupported_compound");
-    if (argument.includes("="))
-        return externalArgvReference("unsupported_compound");
-    return classifyRootArgvValue(argument);
-}
-function classifyRootArgvValue(value) {
-    if (!value)
-        return { kind: "label" };
-    if (hasUnsafeArgvControl(value))
-        return externalArgvReference("unsupported_compound");
-    if (/["']/u.test(value))
-        return externalArgvReference("quote_ambiguous");
-    if (value.includes("\\"))
-        return externalArgvReference("platform_ambiguous");
-    if (/^\/[A-Za-z?]$/u.test(value))
-        return externalArgvReference("platform_ambiguous");
-    if (value.startsWith("/"))
-        return externalArgvReference("absolute");
-    if (/^[A-Za-z]:/u.test(value))
-        return externalArgvReference("drive_prefixed");
-    if (value.startsWith("@"))
-        return externalArgvReference("unsupported_compound");
-    if (hasUnsupportedArgvCompound(value))
-        return externalArgvReference("unsupported_compound");
-    if (/^node:\d+(?:\.\d+)?$/u.test(value))
-        return { kind: "label" };
-    if (/^[A-Za-z][A-Za-z0-9+.-]*:/u.test(value))
-        return externalArgvReference("protocol_prefixed");
-    if (value.includes(":"))
-        return /^\d{1,4}:\d{1,4}$/u.test(value)
-            ? { kind: "label" }
-            : externalArgvReference("unsupported_compound");
-    return { kind: "repository_candidate", value };
-}
-function hasUnsafeArgvControl(value) {
-    return /[\u0000-\u001f\u007f]/u.test(value);
-}
-function hasUnsupportedArgvCompound(value) {
-    return (value.trim() !== value ||
-        value.startsWith("~") ||
-        !/^[\p{L}\p{N}._+,: /-]+$/u.test(value));
-}
-function externalArgvReference(reason) {
-    return { kind: "external_reference", reason };
-}
-function firstMatchingPattern(file, patterns) {
-    return patterns.find((pattern) => matchesRepoPattern(file, pattern)) ?? null;
-}
-function fail(code, detail) {
-    throw new Error(`${code}:${detail}`);
-}

package/dist/lib/long-task-process-table.d.ts

@@ -1,12 +0,0 @@
-export interface ProcessInstance {
-    pid: number;
-    parent_pid: number;
-    start_identity: string | null;
-}
-export declare function processInstanceMatches(expected: Pick<ProcessInstance, "pid" | "start_identity">, current: Pick<ProcessInstance, "pid" | "start_identity">): boolean;
-export declare function processSnapshot(): Promise<ProcessInstance[]>;
-export declare function descendantsOf(rootPid: number, snapshot: readonly ProcessInstance[]): ProcessInstance[];
-export declare function liveProcessInstances(candidates: readonly ProcessInstance[], snapshot: readonly ProcessInstance[]): ProcessInstance[];
-export declare function rootProcessAlive(rootPid: number, rootInstance: ProcessInstance | null, snapshot: readonly ProcessInstance[]): boolean;
-export declare function uniqueProcessInstances(instances: readonly ProcessInstance[]): ProcessInstance[];
-export declare function processInstanceKey(instance: ProcessInstance): string;

package/dist/lib/long-task-process-table.js

@@ -1,119 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const PROCESS_TABLE_OUTPUT_LIMIT = 2 * 1024 * 1024;
-const execFileAsync = promisify(execFile);
-export function processInstanceMatches(expected, current) {
-    if (expected.pid !== current.pid)
-        return false;
-    if (expected.start_identity === null || current.start_identity === null)
-        return true;
-    return expected.start_identity === current.start_identity;
-}
-export async function processSnapshot() {
-    let stdout;
-    try {
-        const result = process.platform === "win32"
-            ? await execFileAsync("powershell.exe", [
-                "-NoLogo",
-                "-NoProfile",
-                "-NonInteractive",
-                "-Command",
-                '$rows = Get-CimInstance Win32_Process; foreach ($row in $rows) { $started = if ($null -eq $row.CreationDate) { "unknown" } else { $row.CreationDate.ToUniversalTime().Ticks }; "$($row.ProcessId) $($row.ParentProcessId) $started" }',
-            ], {
-                encoding: "utf8",
-                windowsHide: true,
-                timeout: 5_000,
-                maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT,
-            })
-            : await execFileAsync("ps", ["-A", "-o", "pid=,ppid="], {
-                encoding: "utf8",
-                timeout: 5_000,
-                maxBuffer: PROCESS_TABLE_OUTPUT_LIMIT,
-            });
-        stdout = result.stdout;
-    }
-    catch (error) {
-        throw new Error(`process_observer_process_tree_inspection_unavailable:${message(error)}`);
-    }
-    const rows = [];
-    for (const line of stdout.split(/\r?\n/u)) {
-        const [pidText, parentText, startText] = line.trim().split(/\s+/u);
-        const pid = Number.parseInt(pidText ?? "", 10);
-        const parent = Number.parseInt(parentText ?? "", 10);
-        if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(parent))
-            continue;
-        rows.push({
-            pid,
-            parent_pid: parent,
-            start_identity: process.platform === "win32" && startText ? startText : null,
-        });
-    }
-    return rows;
-}
-export function descendantsOf(rootPid, snapshot) {
-    const children = new Map();
-    for (const processInstance of snapshot) {
-        const row = children.get(processInstance.parent_pid);
-        if (row)
-            row.push(processInstance);
-        else
-            children.set(processInstance.parent_pid, [processInstance]);
-    }
-    const result = [];
-    const pending = [...(children.get(rootPid) ?? [])];
-    const seen = new Set();
-    while (pending.length) {
-        const processInstance = pending.shift();
-        const key = processInstanceKey(processInstance);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        result.push(processInstance);
-        pending.push(...(children.get(processInstance.pid) ?? []));
-    }
-    return result;
-}
-export function liveProcessInstances(candidates, snapshot) {
-    if (process.platform !== "win32")
-        return candidates.filter((candidate) => processIdExists(candidate.pid));
-    const currentByPid = new Map(snapshot.map((entry) => [entry.pid, entry]));
-    return candidates.filter((candidate) => {
-        const current = currentByPid.get(candidate.pid);
-        return current ? processInstanceMatches(candidate, current) : false;
-    });
-}
-export function rootProcessAlive(rootPid, rootInstance, snapshot) {
-    if (process.platform !== "win32")
-        return processIdExists(rootPid);
-    const current = snapshot.find((entry) => entry.pid === rootPid);
-    if (!current)
-        return false;
-    return rootInstance ? processInstanceMatches(rootInstance, current) : true;
-}
-export function uniqueProcessInstances(instances) {
-    return [
-        ...new Map(instances.map((instance) => [processInstanceKey(instance), instance])).values(),
-    ];
-}
-export function processInstanceKey(instance) {
-    return `${instance.pid}:${instance.start_identity ?? "pid-only"}`;
-}
-function processIdExists(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        if (nodeErrorCode(error) === "ESRCH")
-            return false;
-        throw error;
-    }
-}
-function nodeErrorCode(error) {
-    return error && typeof error === "object" && "code" in error
-        ? String(error.code)
-        : null;
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/lib/long-task-process-tree.d.ts

@@ -1,9 +0,0 @@
-export { processInstanceMatches } from "./long-task-process-table.js";
-export interface ProcessTreeObserver {
-    stop(): void;
-    wait(): Promise<void>;
-    terminate(force: boolean): Promise<void>;
-    forceQuiescence(): Promise<void>;
-    assertQuiescent(): Promise<void>;
-}
-export declare function createProcessTreeObserver(rootPid: number): ProcessTreeObserver;