@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/vue-router-capture.d.ts

@@ -0,0 +1,42 @@
+export interface RouteRecord {
+    path: unknown;
+    name?: unknown;
+    aliasOf?: RouteRecord;
+    components?: Record<string, unknown>;
+    children: unknown[];
+    meta: unknown;
+    redirect?: unknown;
+    beforeEnter?: unknown;
+}
+export interface Router {
+    getRoutes(): RouteRecord[];
+    resolve(value: string): {
+        matched: RouteRecord[];
+    };
+}
+export declare function vueRecordIdentity(record: RouteRecord): {
+    path: string;
+    name: string | null;
+};
+export declare function captureVueRecords(records: RouteRecord[], config: {
+    strict: boolean;
+    sensitive: boolean;
+}): {
+    entries: {
+        key: string;
+        attributes: {
+            path: string;
+            name: string | null;
+            aliasPath: string | null;
+            aliasName: string | null;
+            views: string[];
+            meta: string;
+            redirect: string;
+            beforeEnter: string[];
+            children: number;
+            globalStrict: boolean;
+            globalSensitive: boolean;
+        };
+    }[];
+    indices: number[];
+};

package/dist/src/vue-router-capture.js

@@ -0,0 +1,87 @@
+import { vueRouteIdentitySchema } from "./vue-router.js";
+import { vueRouteAttributesSchema, vueRouteKey, } from "./vue-router-protocol.js";
+function data(value, depth = 0, budget = { remaining: 1024 }) {
+    if (depth > 8 || --budget.remaining < 0)
+        throw new Error("Route data nesting exceeds limits");
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value)))
+        return value;
+    if (Array.isArray(value) && value.length <= 64) {
+        if (Reflect.ownKeys(value).some((key) => key !== "length" &&
+            (typeof key !== "string" ||
+                String(Number(key)) !== key ||
+                !Number.isInteger(Number(key)) ||
+                Number(key) < 0 ||
+                Number(key) >= value.length)))
+            throw new Error("Array metadata contains non-JSON properties");
+        return Array.from({ length: value.length }, (_, index) => {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (!descriptor || !("value" in descriptor))
+                throw new Error("Sparse or computed array metadata is unsupported");
+            return data(descriptor.value, depth + 1, budget);
+        });
+    }
+    if (value &&
+        typeof value === "object" &&
+        [Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+        if (Reflect.ownKeys(value).some((key) => typeof key !== "string"))
+            throw new Error("Symbol metadata is outside the JSON projection");
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        if (Object.values(descriptors).some((descriptor) => !descriptor.enumerable || !("value" in descriptor)))
+            throw new Error("Computed or hidden metadata is unsupported");
+        const entries = Object.entries(descriptors)
+            .map(([key, descriptor]) => [key, descriptor.value])
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+        if (entries.length > 64)
+            throw new Error("Route metadata exceeds limits");
+        return Object.fromEntries(entries.map(([key, item]) => [key, data(item, depth + 1, budget)]));
+    }
+    throw new Error("Route data is not a supported JSON value");
+}
+export function vueRecordIdentity(record) {
+    return vueRouteIdentitySchema.parse({
+        path: record.path,
+        name: record.name ?? null,
+    });
+}
+export function captureVueRecords(records, config) {
+    const entries = [];
+    const indices = [];
+    for (const [index, record] of records.entries()) {
+        try {
+            const guards = record.beforeEnter === undefined
+                ? []
+                : Array.isArray(record.beforeEnter)
+                    ? record.beforeEnter
+                    : [record.beforeEnter];
+            if (guards.some((guard) => typeof guard !== "function"))
+                throw new Error("Unsupported route guard");
+            const attributes = vueRouteAttributesSchema.parse({
+                ...vueRecordIdentity(record),
+                aliasPath: record.aliasOf
+                    ? vueRecordIdentity(record.aliasOf).path
+                    : null,
+                aliasName: record.aliasOf
+                    ? vueRecordIdentity(record.aliasOf).name
+                    : null,
+                views: Object.keys(record.components ?? {}).sort(),
+                meta: JSON.stringify(data(record.meta)),
+                redirect: record.redirect === undefined
+                    ? "null"
+                    : JSON.stringify(data(record.redirect)),
+                beforeEnter: guards.map((guard) => guard.name),
+                children: record.children.length,
+                globalStrict: config.strict,
+                globalSensitive: config.sensitive,
+            });
+            entries.push({ key: vueRouteKey(attributes), attributes });
+            indices.push(index);
+        }
+        catch {
+            continue;
+        }
+    }
+    return { entries, indices };
+}

package/dist/src/vue-router-evidence.d.ts

@@ -0,0 +1,2 @@
+import type { Check, CheckResult, ProcessResult } from "./types.js";
+export declare function vueRouterEvidence(check: Check, processes: ProcessResult[]): Partial<CheckResult>;

package/dist/src/vue-router-evidence.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import path from "node:path";
+import { vueRouterConfigSchema } from "./vue-router.js";
+import { vueRouteAttributesSchema, vueRouteKey, vueRouterResultSchema, } from "./vue-router-protocol.js";
+export function vueRouterEvidence(check, processes) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "Vue Router capture or route probe coverage is empty, malformed or incomplete.",
+        findingsComplete: false,
+    };
+    if (processes.length !== 1)
+        return incomplete;
+    const execution = processes[0];
+    if (execution.exitCode === 3) {
+        try {
+            z.strictObject({
+                unavailable: z.literal("vue-router-runtime"),
+                reason: z.literal("unsupported-version"),
+            }).parse(JSON.parse(execution.stdout));
+            return {
+                status: "unavailable",
+                reason: "The verified Vue Router/Vue versions are not installed.",
+                findingsComplete: false,
+            };
+        }
+        catch {
+            return incomplete;
+        }
+    }
+    if (execution.exitCode !== 0)
+        return {
+            status: "error",
+            reason: "Vue Router startup or capture failed.",
+            findingsComplete: false,
+        };
+    try {
+        const result = vueRouterResultSchema.parse(JSON.parse(execution.stdout));
+        const config = vueRouterConfigSchema.parse(JSON.parse(check.commands[0].args[4]));
+        const collection = result.runtime.collections[0];
+        if (result.runtime.sourceFingerprint !== check.commands[0].args[5] ||
+            result.runtime.producer.name !== "checktrail.vue-router" ||
+            result.runtime.producer.version !== "1.0.0" ||
+            result.runtime.assembly.name !== config.assembly ||
+            result.runtime.assembly.environment !== config.environment ||
+            result.runtime.collections.length !== 1 ||
+            collection.kind !== "routes" ||
+            !collection.ordered ||
+            collection.complete !== (result.supportedRoutes === result.totalRoutes) ||
+            result.supportedRoutes !== collection.entries.length ||
+            result.indices.length !== result.supportedRoutes ||
+            new Set(result.indices).size !== result.supportedRoutes ||
+            result.indices.some((index, offset) => index >= result.totalRoutes ||
+                (offset > 0 && index <= result.indices[offset - 1])) ||
+            result.coveredIndices.some((index, offset) => index >= result.totalRoutes ||
+                (offset > 0 && index <= result.coveredIndices[offset - 1])) ||
+            result.probes.length !== config.probes.length ||
+            !result.totalRoutes)
+            return incomplete;
+        const records = new Map();
+        for (const [offset, entry] of collection.entries.entries()) {
+            const attributes = vueRouteAttributesSchema.parse(entry.attributes);
+            if (entry.key !== vueRouteKey(attributes) ||
+                attributes.globalStrict !== config.strict ||
+                attributes.globalSensitive !== config.sensitive)
+                return incomplete;
+            records.set(result.indices[offset], {
+                path: attributes.path,
+                name: attributes.name,
+            });
+        }
+        const observed = new Set();
+        const findings = [];
+        for (const [index, probe] of result.probes.entries()) {
+            if (probe.path !== config.probes[index].path)
+                return incomplete;
+            const nonnull = probe.indices.filter((value) => value !== null);
+            if (probe.indices.length !== probe.matched.length ||
+                new Set(nonnull).size !== nonnull.length)
+                return incomplete;
+            for (const [offset, recordIndex] of probe.indices.entries()) {
+                if (recordIndex === null)
+                    continue;
+                if (recordIndex >= result.totalRoutes ||
+                    (records.has(recordIndex) &&
+                        JSON.stringify(records.get(recordIndex)) !==
+                            JSON.stringify(probe.matched[offset])))
+                    return incomplete;
+                observed.add(recordIndex);
+            }
+            if (JSON.stringify(probe.matched) !==
+                JSON.stringify(config.probes[index].matched))
+                findings.push({
+                    ruleId: "vue-router/probe-mismatch",
+                    level: "error",
+                    message: `Route probe ${probe.path} did not resolve to its expected matched route chain.`,
+                    file: path.posix.join(check.project, "checktrail.vue-router.json"),
+                });
+        }
+        if (JSON.stringify([...observed].sort((a, b) => a - b)) !==
+            JSON.stringify(result.coveredIndices))
+            return incomplete;
+        const complete = collection.complete &&
+            result.coveredIndices.length === result.totalRoutes;
+        const evidence = {
+            runtime: result.runtime,
+            findings,
+            findingsComplete: complete,
+        };
+        if (findings.length)
+            return {
+                ...evidence,
+                status: "failed",
+                reason: "Native Vue Router resolution differs from the declared route contract.",
+            };
+        if (!complete)
+            return { ...evidence, ...incomplete };
+        return {
+            ...evidence,
+            status: "passed",
+            reason: "Every native route record participated in a probe and all resolved route chains matched the declared contract.",
+        };
+    }
+    catch {
+        return incomplete;
+    }
+}

package/dist/src/vue-router-protocol.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export declare const vueRouteAttributesSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    aliasPath: z.ZodNullable<z.ZodString>;
+    aliasName: z.ZodNullable<z.ZodString>;
+    views: z.ZodArray<z.ZodString>;
+    meta: z.ZodString;
+    redirect: z.ZodString;
+    beforeEnter: z.ZodArray<z.ZodString>;
+    children: z.ZodNumber;
+    globalStrict: z.ZodBoolean;
+    globalSensitive: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const vueRouterResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    versions: z.ZodObject<{
+        router: z.ZodLiteral<"5.3.1">;
+        vue: z.ZodLiteral<"3.5.43">;
+    }, z.core.$strict>;
+    totalRoutes: z.ZodNumber;
+    supportedRoutes: z.ZodNumber;
+    indices: z.ZodArray<z.ZodNumber>;
+    coveredIndices: z.ZodArray<z.ZodNumber>;
+    runtime: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        format: z.ZodLiteral<"runtime-inventory">;
+        producer: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        assembly: z.ZodObject<{
+            name: z.ZodString;
+            environment: z.ZodString;
+        }, z.core.$strict>;
+        sourceFingerprint: z.ZodString;
+        capturedAt: z.ZodISODateTime;
+        collections: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                routes: "routes";
+                listeners: "listeners";
+                middleware: "middleware";
+                schedules: "schedules";
+                bindings: "bindings";
+            }>;
+            complete: z.ZodBoolean;
+            ordered: z.ZodBoolean;
+            entries: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                attributes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    probes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        matched: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        indices: z.ZodArray<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare function vueRouteKey(attributes: z.infer<typeof vueRouteAttributesSchema>): string;

package/dist/src/vue-router-protocol.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { runtimeInventorySchema } from "./runtime-inventory.js";
+import { vueRouteIdentitySchema } from "./vue-router.js";
+const count = z.number().int().nonnegative().max(2048);
+export const vueRouteAttributesSchema = z.strictObject({
+    path: z.string().regex(/^\//).max(4096),
+    name: z.string().max(256).nullable(),
+    aliasPath: z.string().max(4096).nullable(),
+    aliasName: z.string().max(256).nullable(),
+    views: z.array(z.string().max(256)).max(32),
+    meta: z.string().max(4096),
+    redirect: z.string().max(4096),
+    beforeEnter: z.array(z.string().max(256)).max(32),
+    children: count,
+    globalStrict: z.boolean(),
+    globalSensitive: z.boolean(),
+});
+export const vueRouterResultSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    versions: z.strictObject({
+        router: z.literal("5.3.1"),
+        vue: z.literal("3.5.43"),
+    }),
+    totalRoutes: count,
+    supportedRoutes: count,
+    indices: z.array(count).max(2048),
+    coveredIndices: z.array(count).max(2048),
+    runtime: runtimeInventorySchema,
+    probes: z
+        .array(z.strictObject({
+        path: z.string(),
+        matched: z.array(vueRouteIdentitySchema).max(32),
+        indices: z.array(count.nullable()).max(32),
+    }))
+        .max(256),
+});
+export function vueRouteKey(attributes) {
+    return JSON.stringify([
+        attributes.path,
+        attributes.name,
+        attributes.aliasPath,
+        attributes.aliasName,
+    ]);
+}

package/dist/src/vue-router-runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/vue-router-runner.js

@@ -0,0 +1,88 @@
+import { captureVueRecords, vueRecordIdentity, } from "./vue-router-capture.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { vueRouterConfigSchema } from "./vue-router.js";
+import { vueRouterResultSchema } from "./vue-router-protocol.js";
+async function main() {
+    const [routerEntry, vueMetadata, moduleEntry, encoded, fingerprint] = process.argv.slice(2);
+    const config = vueRouterConfigSchema.parse(JSON.parse(encoded));
+    const routerVersion = JSON.parse(await readFile(path.join(path.dirname(routerEntry), "package.json"), "utf8")).version;
+    const vueVersion = JSON.parse(await readFile(vueMetadata, "utf8")).version;
+    if (routerVersion !== "5.3.1" || vueVersion !== "3.5.43") {
+        process.stdout.write(JSON.stringify({
+            unavailable: "vue-router-runtime",
+            reason: "unsupported-version",
+        }));
+        process.exitCode = 3;
+        return;
+    }
+    const native = (await import(pathToFileURL(routerEntry).href));
+    const router = native.createRouter({
+        history: native.createMemoryHistory(),
+        routes: [],
+        strict: config.strict,
+        sensitive: config.sensitive,
+    });
+    const routes = router.getRoutes.bind(router);
+    const resolve = router.resolve.bind(router);
+    const startup = await import(pathToFileURL(moduleEntry).href);
+    const configure = startup[config.attribute];
+    if (typeof configure !== "function")
+        throw new Error("Missing route startup function");
+    await configure(router);
+    const records = routes();
+    if (records.length > 2048)
+        throw new Error("Route inventory exceeds limits");
+    const { entries, indices } = captureVueRecords(records, config);
+    const covered = new Set();
+    const probes = config.probes.map((probe) => {
+        const matched = resolve(probe.path).matched;
+        for (const record of matched) {
+            const index = records.indexOf(record);
+            if (index >= 0)
+                covered.add(index);
+        }
+        return {
+            path: probe.path,
+            matched: matched.map(vueRecordIdentity),
+            indices: matched.map((record) => {
+                const index = records.indexOf(record);
+                return index >= 0 ? index : null;
+            }),
+        };
+    });
+    if (routes().length !== records.length ||
+        routes().some((record, index) => record !== records[index]))
+        throw new Error("Route assembly changed during capture");
+    const result = vueRouterResultSchema.parse({
+        schemaVersion: 1,
+        versions: { router: routerVersion, vue: vueVersion },
+        totalRoutes: records.length,
+        supportedRoutes: entries.length,
+        indices,
+        coveredIndices: [...covered].sort((a, b) => a - b),
+        probes,
+        runtime: {
+            schemaVersion: 1,
+            format: "runtime-inventory",
+            producer: { name: "checktrail.vue-router", version: "1.0.0" },
+            assembly: { name: config.assembly, environment: config.environment },
+            sourceFingerprint: fingerprint,
+            capturedAt: new Date().toISOString(),
+            collections: [
+                {
+                    kind: "routes",
+                    complete: entries.length === records.length,
+                    ordered: true,
+                    entries,
+                },
+            ],
+        },
+    });
+    process.stdout.write(JSON.stringify(result));
+}
+main().catch(() => {
+    process.stderr.write("Vue Router startup or runtime capture could not complete\n");
+    process.exitCode = 2;
+});

package/dist/src/vue-router.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { Check, Inventory, Project } from "./types.js";
+export declare const vueRouteIdentitySchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const vueRouterConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    module: z.ZodString;
+    attribute: z.ZodString;
+    assembly: z.ZodString;
+    environment: z.ZodLiteral<"test">;
+    strict: z.ZodBoolean;
+    sensitive: z.ZodBoolean;
+    probes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        matched: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare function vueRouterCheck(source: Inventory, project: Project): Promise<Check>;

package/dist/src/vue-router.js

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { readProjectFile, withinRoot } from "./inventory.js";
+import { localTool } from "./local-tool.js";
+const routePath = z.string().regex(/^\//).max(4096);
+export const vueRouteIdentitySchema = z.strictObject({
+    path: routePath,
+    name: z.string().max(256).nullable(),
+});
+export const vueRouterConfigSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    module: z
+        .string()
+        .min(1)
+        .max(4096)
+        .refine((value) => path.posix.normalize(value) === value &&
+        !path.posix.isAbsolute(value) &&
+        !value.startsWith("../") &&
+        !value.includes("\\") &&
+        !value.includes("\0") &&
+        /\.[cm]?js$/.test(value)),
+    attribute: z
+        .string()
+        .regex(/^[A-Za-z_$][\w$]*$/)
+        .max(128),
+    assembly: z.string().min(1).max(256),
+    environment: z.literal("test"),
+    strict: z.boolean(),
+    sensitive: z.boolean(),
+    probes: z
+        .array(z.strictObject({
+        path: z
+            .string()
+            .regex(/^\/(?!\/)/)
+            .max(4096),
+        matched: z.array(vueRouteIdentitySchema).max(32),
+    }))
+        .min(1)
+        .max(256),
+});
+export async function vueRouterCheck(source, project) {
+    const check = {
+        id: "javascript.vue-router",
+        adapter: project.adapter,
+        project: project.path,
+        kind: "analysis",
+        parser: "vue-router-json",
+        scope: [],
+        commands: [],
+        reason: "Capture native Vue Router records after configured startup and verify declared route probes with complete record participation.",
+    };
+    if (!project.files.includes("checktrail.vue-router.json")) {
+        check.unavailableReason =
+            "Vue Router checks require an explicit checktrail.vue-router.json profile.";
+        return check;
+    }
+    const config = vueRouterConfigSchema.parse(JSON.parse(await readProjectFile(source.root, path.posix.join(project.path, "checktrail.vue-router.json"))));
+    if (new Set(config.probes.map((probe) => probe.path)).size !==
+        config.probes.length ||
+        !config.probes.some((probe) => probe.matched.length))
+        throw new Error("Vue Router probes require unique paths and at least one expected route match");
+    if (!project.files.includes(config.module)) {
+        check.unavailableReason =
+            "Vue Router startup must be an inventoried Node-compatible module in this project.";
+        return check;
+    }
+    check.scope = [config.module];
+    const router = await localTool(source.root, project.path, "vue-router/vue-router.node.mjs");
+    let vue;
+    if (router) {
+        try {
+            const resolved = createRequire(router).resolve("vue/package.json");
+            vue = await withinRoot(source.root, path.relative(source.root, resolved));
+        }
+        catch {
+            vue = undefined;
+        }
+    }
+    if (!router || !vue) {
+        check.unavailableReason =
+            "Vue Router and Vue must be installed inside the configured root.";
+        return check;
+    }
+    const entry = await withinRoot(source.root, path.posix.join(project.path, config.module));
+    if (entry !== path.resolve(source.root, project.path, config.module))
+        throw new Error("Vue Router startup cannot traverse symbolic links");
+    const encoded = JSON.stringify(config);
+    if (Buffer.byteLength(encoded) > 64 * 1024)
+        throw new Error("Vue Router profile exceeds 64 KiB");
+    check.commands = [
+        {
+            executable: process.execPath,
+            args: [
+                fileURLToPath(new URL("./vue-router-runner.js", import.meta.url)),
+                router,
+                vue,
+                entry,
+                encoded,
+                source.fingerprint,
+            ],
+            cwd: project.path,
+            env: { NODE_ENV: "test", NODE_OPTIONS: "" },
+        },
+    ];
+    return check;
+}

package/dist/src/vue-tsc-runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/vue-tsc-runner.js

@@ -0,0 +1,24 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { withinRoot } from "./inventory.js";
+async function main() {
+    const [entry, root, ...args] = process.argv.slice(2);
+    if (!entry || !root)
+        throw new Error("Invalid Vue compiler arguments");
+    const tool = await withinRoot(root, path.relative(root, entry));
+    const load = createRequire(tool);
+    const resolve = async (name) => withinRoot(root, path.relative(root, load.resolve(name)));
+    const ts = load(await resolve("typescript"));
+    const core = load(await resolve("@vue/language-core"));
+    const config = core.createParsedCommandLine(ts, ts.sys, path.resolve("tsconfig.json"));
+    if (config.vueOptions.skipTemplateCodegen)
+        throw new Error("Vue template checking is disabled by skipTemplateCodegen");
+    const compiler = load(tool);
+    const tsc = await resolve("typescript/lib/tsc.js");
+    process.argv = [process.execPath, tool, ...args];
+    compiler.run(tsc);
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : "Vue type checking failed"}\n`);
+    process.exitCode = 2;
+});

package/dist/src/workspace.d.ts

@@ -0,0 +1,7 @@
+import type { Workspace } from "./types.js";
+export declare function validateWorkspace(workspace: Workspace, projects: string[]): void;
+export declare function affectedProjects(projects: string[], files: string[], workspace?: Workspace): {
+    projects: string[];
+    reason: string;
+    affected: boolean;
+};