project-tiny-context-harness 0.8.13 → 0.8.17

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

@@ -110,62 +110,94 @@ function selectBinding(selected, scoped) {
 function argvAttributedRepositoryFiles(argv, cwd, bindings, targetRef) {
     const result = new Set();
     for (const argument of argv) {
-        const value = rootArgvPathValue(argument);
-        if (!value)
+        const classification = classifyRootArgvToken(argument);
+        if (classification.kind === "label")
             continue;
-        if (unsafeArgvPathValue(value))
-            fail("process_root_argv_unsafe", `${targetRef}:${argument}`);
-        const candidate = path.posix.join(cwd === "." ? "" : cwd, value);
+        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}`);
+            fail("process_root_argv_unsafe", `${targetRef}:${argument}:parent_escape`);
         }
         if (bindingsContaining(bindings, normalized).length)
             result.add(normalized);
     }
     return [...result].sort();
 }
-function rootArgvPathValue(argument) {
-    const parsedArgument = unwrapCompleteQuoteLayer(argument.replace(/\\/gu, "/"));
-    const portable = parsedArgument.value;
-    if (!portable)
-        return null;
-    // A compound shell command is not one finite argv file token. In
-    // particular, do not search inside it for a path-shaped substring.
-    if (!parsedArgument.quoted && /\s/u.test(portable))
-        return null;
-    // A single-letter slash switch is an argv label (for example cmd.exe /d),
-    // not a repository path. Longer slash-prefixed values remain absolute and
-    // fail closed below.
-    if (/^\/[A-Za-z?]$/u.test(portable))
-        return null;
-    if (!portable.startsWith("--"))
-        return portable;
-    const separator = portable.indexOf("=");
-    if (separator <= 2 || separator === portable.length - 1)
-        return null;
-    const parsedValue = unwrapCompleteQuoteLayer(portable.slice(separator + 1));
-    if (!parsedValue.value)
-        return null;
-    if (!parsedValue.quoted && /\s/u.test(parsedValue.value))
-        return null;
-    return parsedValue.value;
+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 unwrapCompleteQuoteLayer(value) {
-    const quote = value[0];
-    if ((quote === '"' || quote === "'") && value.at(-1) === quote)
-        return { value: value.slice(1, -1), quoted: true };
-    return { value, quoted: false };
+function hasUnsupportedArgvCompound(value) {
+    return (value.trim() !== value ||
+        value.startsWith("~") ||
+        !/^[\p{L}\p{N}._+,: /-]+$/u.test(value));
 }
-function unsafeArgvPathValue(value) {
-    return (/["']/u.test(value) ||
-        value.startsWith("/") ||
-        /^[A-Za-z]:\//u.test(value) ||
-        /^file:/iu.test(value) ||
-        /^[A-Za-z][A-Za-z0-9+.-]*:\/\//u.test(value));
+function externalArgvReference(reason) {
+    return { kind: "external_reference", reason };
 }
 function firstMatchingPattern(file, patterns) {
     return patterns.find((pattern) => matchesRepoPattern(file, pattern)) ?? null;

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,9 @@
+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;

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

@@ -0,0 +1,138 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { descendantsOf, liveProcessInstances, processInstanceKey, processInstanceMatches, processSnapshot, rootProcessAlive, uniqueProcessInstances, } from "./long-task-process-table.js";
+export { processInstanceMatches } from "./long-task-process-table.js";
+const PROCESS_TREE_GRACE_MS = 1_000;
+const execFileAsync = promisify(execFile);
+export function createProcessTreeObserver(rootPid) {
+    let stopped = false;
+    let rootInstance = null;
+    const observed = new Map();
+    const monitor = observe();
+    return {
+        stop() {
+            stopped = true;
+        },
+        wait() {
+            return monitor;
+        },
+        terminate(force) {
+            return terminateProcessTree(rootPid, rootInstance, force, [...observed.values()], true);
+        },
+        forceQuiescence() {
+            return forceProcessTreeQuiescence(rootPid, rootInstance, observed);
+        },
+        assertQuiescent() {
+            return assertProcessTreeQuiescent(rootPid, rootInstance, observed);
+        },
+    };
+    async function observe() {
+        do {
+            const snapshot = await processSnapshot();
+            const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
+            if (currentRoot &&
+                (!rootInstance || processInstanceMatches(rootInstance, currentRoot))) {
+                rootInstance ??= currentRoot;
+                for (const descendant of descendantsOf(rootPid, snapshot))
+                    observed.set(processInstanceKey(descendant), descendant);
+            }
+            if (stopped)
+                return;
+            await delay(process.platform === "win32" ? 100 : 25);
+        } while (!stopped);
+    }
+}
+async function forceProcessTreeQuiescence(rootPid, rootInstance, observed) {
+    await terminateProcessTree(rootPid, rootInstance, true, [...observed.values()], true);
+    const deadline = Date.now() + PROCESS_TREE_GRACE_MS;
+    while (Date.now() < deadline) {
+        const snapshot = await processSnapshot();
+        const rootAlive = rootProcessAlive(rootPid, rootInstance, snapshot);
+        const descendantsAlive = liveProcessInstances([...observed.values()], snapshot).length;
+        const groupAlive = process.platform !== "win32" && processGroupExists(rootPid);
+        if (!rootAlive && descendantsAlive === 0 && !groupAlive)
+            return;
+        await delay(process.platform === "win32" ? 100 : 25);
+    }
+    throw new Error("process_observer_descendant_process_alive");
+}
+async function assertProcessTreeQuiescent(rootPid, rootInstance, observed) {
+    const snapshot = await processSnapshot();
+    const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
+    const finalDescendants = currentRoot &&
+        (!rootInstance || processInstanceMatches(rootInstance, currentRoot))
+        ? descendantsOf(rootPid, snapshot)
+        : [];
+    const candidates = uniqueProcessInstances([
+        ...observed.values(),
+        ...finalDescendants,
+    ]);
+    const descendants = liveProcessInstances(candidates, snapshot);
+    const processGroupAlive = process.platform !== "win32" && processGroupExists(rootPid);
+    if (!descendants.length && !processGroupAlive)
+        return;
+    await terminateProcessTree(rootPid, rootInstance, true, descendants, false);
+    throw new Error("process_observer_descendant_process_alive");
+}
+async function terminateProcessTree(rootPid, rootInstance, force, knownDescendants, includeRoot) {
+    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
+        return;
+    if (process.platform === "win32") {
+        const snapshot = await processSnapshot();
+        const currentRoot = snapshot.find((entry) => entry.pid === rootPid);
+        const rootTarget = includeRoot &&
+            currentRoot &&
+            (!rootInstance || processInstanceMatches(rootInstance, currentRoot))
+            ? currentRoot
+            : null;
+        const currentDescendants = rootTarget
+            ? descendantsOf(rootPid, snapshot)
+            : [];
+        const descendants = liveProcessInstances(uniqueProcessInstances([...knownDescendants, ...currentDescendants]), snapshot).reverse();
+        const targets = rootTarget ? [...descendants, rootTarget] : descendants;
+        for (const target of targets)
+            await execFileAsync("taskkill.exe", ["/PID", String(target.pid), "/T", "/F"], {
+                windowsHide: true,
+                timeout: PROCESS_TREE_GRACE_MS,
+            }).catch(() => undefined);
+        return;
+    }
+    const signal = force ? "SIGKILL" : "SIGTERM";
+    if (includeRoot)
+        try {
+            process.kill(-rootPid, signal);
+        }
+        catch (error) {
+            if (nodeErrorCode(error) !== "ESRCH")
+                throw error;
+        }
+    const snapshot = await processSnapshot();
+    const descendants = liveProcessInstances(knownDescendants, snapshot);
+    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-protected-files.d.ts

@@ -1 +1 @@
-export { assertProtectedRepositoryFile } from "./repository-path-safety.js";
+export { assertProtectedRepositoryDirectory, assertProtectedRepositoryFile, } from "./repository-path-safety.js";

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

@@ -1 +1 @@
-export { assertProtectedRepositoryFile } from "./repository-path-safety.js";
+export { assertProtectedRepositoryDirectory, assertProtectedRepositoryFile, } from "./repository-path-safety.js";

package/dist/lib/long-task-ui-surface-policy.d.ts

@@ -1,4 +1,5 @@
 import type { CompiledClaimsV2 } from "./long-task-claims.js";
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
 import { type Reporter } from "./long-task-ui-surface-validation.js";
-export declare function validateUiSurfaceBindings(contract: DeliveryContractV2, claims: CompiledClaimsV2, report?: Reporter): void;
+import type { DeliveryContractStructureValidationOptions } from "./long-task-delivery-validation.js";
+export declare function validateUiSurfaceBindings(contract: DeliveryContractV2, claims: CompiledClaimsV2, report?: Reporter, options?: DeliveryContractStructureValidationOptions): void;

package/dist/lib/long-task-ui-surface-policy.js

@@ -1,6 +1,6 @@
 import { validateUiDesignBinding } from "./long-task-ui-design-policy.js";
 import { bindingCarriers, controlClaims, expectedControlProofSurface, issue, unique, validateCarrierInputs, validateRootJourney, validateTargetLocalClaimProof, } from "./long-task-ui-surface-validation.js";
-export function validateUiSurfaceBindings(contract, claims, report) {
+export function validateUiSurfaceBindings(contract, claims, report, options = {}) {
     const targets = new Map(contract.task.execution_targets.map((target) => [target.key, target]));
     const requiredTargets = new Set(contract.task.target_profile.required_target_refs);
     const confirmations = new Map(contract.global.acceptance.external_confirmations.map((item) => [
@@ -8,9 +8,9 @@ export function validateUiSurfaceBindings(contract, claims, report) {
         item,
     ]));
     for (const outcome of contract.outcomes)
-        validateOutcomeBindings(outcome, claims, targets, requiredTargets, confirmations, report);
+        validateOutcomeBindings(outcome, claims, targets, requiredTargets, confirmations, report, options);
 }
-function validateOutcomeBindings(outcome, claims, targets, requiredTargets, confirmations, report) {
+function validateOutcomeBindings(outcome, claims, targets, requiredTargets, confirmations, report, options = {}) {
     const surfaceBindings = outcome.product.surface_bindings ?? [];
     if (outcome.product.controls.length && !surfaceBindings.length)
         issue(report, "ui_surface_binding_required", outcome.key);
@@ -39,7 +39,10 @@ function validateOutcomeBindings(outcome, claims, targets, requiredTargets, conf
         if (!requiredTargets.has(binding.target_ref))
             issue(report, "ui_surface_binding_required_target_required", `${label}:${binding.target_ref}`);
         validateBoundControls(binding, controls, boundControls, boundControlTargets, label, report);
-        const carriers = bindingCarriers(binding.route_binding_ref, binding.component_binding_refs, technicalBindings, label, report);
+        const carriers = bindingCarriers(binding.route_binding_ref, binding.component_binding_refs, technicalBindings, label, report, {
+            allowEmptyComponentRefs: options.allowDeferredDesignComponentBindingClosure === true &&
+                binding.design_targets.length > 0,
+        });
         const rootCheck = checks.get(binding.root_journey_check_ref);
         if (!rootCheck)
             issue(report, "ui_surface_binding_root_check_unknown", `${label}:${binding.root_journey_check_ref}`);

package/dist/lib/long-task-ui-surface-validation.d.ts

@@ -1,7 +1,9 @@
 import type { CompiledClaimsV2 } from "./long-task-claims.js";
 import type { DeliveryCheckV2, DeliveryOutcomeV2, ProductClaimV2, ProofSurface } from "./long-task-delivery-types.js";
 export type Reporter = (message: string) => void;
-export declare function bindingCarriers(routeRef: string, componentRefs: string[], bindings: Map<string, DeliveryOutcomeV2["technical"]["bindings"][number]>, label: string, report?: Reporter): string[];
+export declare function bindingCarriers(routeRef: string, componentRefs: string[], bindings: Map<string, DeliveryOutcomeV2["technical"]["bindings"][number]>, label: string, report?: Reporter, options?: {
+    allowEmptyComponentRefs?: boolean;
+}): string[];
 export declare function validateRootJourney(binding: DeliveryOutcomeV2["product"]["surface_bindings"][number], check: DeliveryCheckV2, label: string, report?: Reporter): void;
 export declare function validateTargetLocalClaimProof(outcome: DeliveryOutcomeV2, claim: ProductClaimV2, targetRef: string, expectedSurface: ProofSurface | null, claims: CompiledClaimsV2, checks: Map<string, DeliveryCheckV2>, label: string, report?: Reporter): void;
 export declare function expectedControlProofSurface(runtimeFamily: string | undefined): ProofSurface;

package/dist/lib/long-task-ui-surface-validation.js

@@ -1,6 +1,6 @@
 import { proveRepositoryPatternSubset } from "./long-task-paths.js";
-export function bindingCarriers(routeRef, componentRefs, bindings, label, report) {
-    if (!componentRefs.length)
+export function bindingCarriers(routeRef, componentRefs, bindings, label, report, options = {}) {
+    if (!componentRefs.length && !options.allowEmptyComponentRefs)
         issue(report, "ui_surface_binding_component_ref_required", label);
     unique(componentRefs, "ui_surface_binding_component_ref_duplicate", label, report);
     const carriers = [];

package/dist/lib/long-task-verifier-authority.js

@@ -37,6 +37,8 @@ function changedVerifierFiles(previous, next) {
         ...Object.keys(next.bundle_files),
     ]);
     const changed = [...files].filter((file) => previous.bundle_files[file] !== next.bundle_files[file]);
+    if (previous.bundle_sha256 !== next.bundle_sha256)
+        changed.push("<bundle>");
     if (previous.schema_sha256 !== next.schema_sha256)
         changed.push("<schema>");
     if (previous.hook_sha256 !== next.hook_sha256)

package/dist/lib/long-task-workspace-manifest.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceFingerprintV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function captureWorkspaceFingerprint(rootInput: string, excludedPrefixes?: string[]): Promise<WorkspaceFingerprintV2>;
+export declare function captureWorkspaceManifest(rootInput: string, workdirInput: string, _copyRoot?: string, additionalExcludedWorkdirs?: string[]): Promise<WorkspaceManifestV2>;
+export declare function changedWorkspacePaths(baseline: WorkspaceManifestV2, current: WorkspaceManifestV2): string[];
+export declare function changedWorkspacePathsFromHead(rootInput: string, workdirInput: string, additionalExcludedWorkdirs?: string[]): Promise<string[]>;
+export declare function workspaceFingerprintExcludedPrefixes(root: string, workdirs: string[]): string[];
+export declare function workspaceSnapshotExcludedPrefixes(root: string, workdirs: string[]): string[];
+export declare function workspacePathExcluded(relative: string, excluded: string[]): boolean;