project-tiny-context-harness 0.11.0 → 0.12.0

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,9 +0,0 @@
-export interface ProcessInstance {
-    pid: number;
-    parent_pid: number;
-}
-export declare function processSnapshot(): Promise<ProcessInstance[]>;
-export declare function descendantsOf(rootPid: number, snapshot: readonly ProcessInstance[]): ProcessInstance[];
-export declare function liveProcessInstances(candidates: readonly ProcessInstance[]): ProcessInstance[];
-export declare function rootProcessAlive(rootPid: number): boolean;
-export declare function uniqueProcessInstances(instances: readonly ProcessInstance[]): ProcessInstance[];

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

@@ -1,87 +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 async function processSnapshot() {
-    assertNonWindowsProcessTree();
-    let stdout;
-    try {
-        const result = 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] = 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 });
-    }
-    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();
-        if (seen.has(processInstance.pid))
-            continue;
-        seen.add(processInstance.pid);
-        result.push(processInstance);
-        pending.push(...(children.get(processInstance.pid) ?? []));
-    }
-    return result;
-}
-export function liveProcessInstances(candidates) {
-    assertNonWindowsProcessTree();
-    return candidates.filter((candidate) => processIdExists(candidate.pid));
-}
-export function rootProcessAlive(rootPid) {
-    assertNonWindowsProcessTree();
-    return processIdExists(rootPid);
-}
-export function uniqueProcessInstances(instances) {
-    return [
-        ...new Map(instances.map((instance) => [instance.pid, instance])).values(),
-    ];
-}
-function processIdExists(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        if (nodeErrorCode(error) === "ESRCH")
-            return false;
-        throw error;
-    }
-}
-function assertNonWindowsProcessTree() {
-    if (process.platform === "win32")
-        throw new Error("process_observer_windows_job_required");
-}
-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,8 +0,0 @@
-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;

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

@@ -1,108 +0,0 @@
-import { descendantsOf, liveProcessInstances, processSnapshot, rootProcessAlive, uniqueProcessInstances, } from "./long-task-process-table.js";
-const PROCESS_TREE_GRACE_MS = 1_000;
-export function createProcessTreeObserver(rootPid) {
-    if (process.platform === "win32")
-        throw new Error("process_observer_windows_job_required");
-    let stopped = false;
-    const observed = new Map();
-    const monitor = observe();
-    return {
-        stop() {
-            stopped = true;
-        },
-        wait() {
-            return monitor;
-        },
-        terminate(force) {
-            return terminateProcessTree(rootPid, force, [...observed.values()], true);
-        },
-        forceQuiescence() {
-            return forceProcessTreeQuiescence(rootPid, observed);
-        },
-        assertQuiescent() {
-            return assertProcessTreeQuiescent(rootPid, observed);
-        },
-    };
-    async function observe() {
-        do {
-            const snapshot = await processSnapshot();
-            if (snapshot.some((entry) => entry.pid === rootPid))
-                for (const descendant of descendantsOf(rootPid, snapshot))
-                    observed.set(descendant.pid, descendant);
-            if (stopped)
-                return;
-            await delay(25);
-        } while (!stopped);
-    }
-}
-async function forceProcessTreeQuiescence(rootPid, observed) {
-    await terminateProcessTree(rootPid, true, [...observed.values()], true);
-    const deadline = Date.now() + PROCESS_TREE_GRACE_MS;
-    while (Date.now() < deadline) {
-        const rootAlive = rootProcessAlive(rootPid);
-        const descendantsAlive = liveProcessInstances([
-            ...observed.values(),
-        ]).length;
-        const groupAlive = processGroupExists(rootPid);
-        if (!rootAlive && descendantsAlive === 0 && !groupAlive)
-            return;
-        await delay(25);
-    }
-    throw new Error("process_observer_descendant_process_alive");
-}
-async function assertProcessTreeQuiescent(rootPid, observed) {
-    const snapshot = await processSnapshot();
-    const finalDescendants = snapshot.some((entry) => entry.pid === rootPid)
-        ? descendantsOf(rootPid, snapshot)
-        : [];
-    const candidates = uniqueProcessInstances([
-        ...observed.values(),
-        ...finalDescendants,
-    ]);
-    const descendants = liveProcessInstances(candidates);
-    if (!descendants.length && !processGroupExists(rootPid))
-        return;
-    await terminateProcessTree(rootPid, true, descendants, false);
-    throw new Error("process_observer_descendant_process_alive");
-}
-async function terminateProcessTree(rootPid, force, knownDescendants, includeRoot) {
-    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
-        return;
-    const signal = force ? "SIGKILL" : "SIGTERM";
-    if (includeRoot)
-        try {
-            process.kill(-rootPid, signal);
-        }
-        catch (error) {
-            if (nodeErrorCode(error) !== "ESRCH")
-                throw error;
-        }
-    const descendants = liveProcessInstances(knownDescendants);
-    for (const descendant of descendants.reverse())
-        try {
-            process.kill(descendant.pid, signal);
-        }
-        catch (error) {
-            if (nodeErrorCode(error) !== "ESRCH")
-                throw error;
-        }
-}
-function processGroupExists(rootPid) {
-    try {
-        process.kill(-rootPid, 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 delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}

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

@@ -1,8 +0,0 @@
-import type { DeliveryControlRelationClosureV2, DeliveryControlRelationV2, DeliveryControlV2, DeliveryObligationV2, DeliveryOwnerV2, KeyedPathV2, KeyedStatementV2 } from "./long-task-delivery-types.js";
-export declare function parseKeyedStatements(value: unknown, label: string): KeyedStatementV2[];
-export declare function parseKeyedPaths(value: unknown, label: string): KeyedPathV2[];
-export declare function parseControls(value: unknown, label: string): DeliveryControlV2[];
-export declare function parseControlRelations(value: unknown, label: string): DeliveryControlRelationV2[];
-export declare function parseControlRelationClosure(value: unknown, label: string): DeliveryControlRelationClosureV2;
-export declare function parseOwner(value: unknown, label: string): DeliveryOwnerV2;
-export declare function parseObligations(value: unknown, label: string): DeliveryObligationV2[];