@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/external-adapter.js

@@ -0,0 +1,265 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { withinRoot } from "./inventory.js";
+const sha256 = z.string().regex(/^[a-f0-9]{64}$/);
+const identifier = z.string().regex(/^[a-z][a-z0-9-]{0,63}$/);
+const relativePath = z
+    .string()
+    .min(1)
+    .max(4096)
+    .refine((value) => !path.posix.isAbsolute(value) &&
+    path.posix.normalize(value) === value &&
+    value !== "." &&
+    value !== ".." &&
+    !value.startsWith("../") &&
+    [...value].every((character) => character.charCodeAt(0) >= 32 &&
+        character.charCodeAt(0) !== 127 &&
+        character !== "\\"));
+export const externalReferenceSchema = z.strictObject({
+    path: z
+        .string()
+        .min(1)
+        .max(4096)
+        .refine((value) => path.isAbsolute(value) && !value.includes("\0")),
+    sha256,
+});
+export const externalReferencesSchema = z.array(externalReferenceSchema).max(8);
+export const externalIdentitySchema = z.strictObject({
+    id: z.string().regex(/^external\.[a-z][a-z0-9-]{0,63}$/),
+    version: z
+        .string()
+        .regex(/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/)
+        .max(128),
+    sha256,
+});
+export const externalManifestSchema = z.strictObject({
+    schemaVersion: z.literal(1),
+    id: externalIdentitySchema.shape.id,
+    version: externalIdentitySchema.shape.version,
+    description: z.string().min(1).max(4096),
+    runtime: z.enum(["node", "python3", "php", "native"]),
+    entry: relativePath,
+    files: z
+        .array(z.strictObject({ path: relativePath, sha256 }))
+        .min(1)
+        .max(512),
+    markers: z
+        .array(z
+        .string()
+        .regex(/^[A-Za-z0-9_.-]{1,128}$/)
+        .refine((value) => value !== "." && value !== ".."))
+        .min(1)
+        .max(32),
+    checks: z
+        .array(z.strictObject({
+        id: identifier,
+        kind: z.enum(["analysis", "syntax", "format", "test"]),
+        description: z.string().min(1).max(4096),
+        failOn: z.enum(["error", "warning"]),
+        scope: z.strictObject({
+            extensions: z
+                .array(z.string().regex(/^\.[A-Za-z0-9_.-]{1,64}$/))
+                .max(32),
+            names: z.array(z.string().regex(/^[A-Za-z0-9_.-]{1,128}$/)).max(32),
+        }),
+    }))
+        .min(1)
+        .max(32),
+});
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+export async function loadExternalAdapter(input, retainBytes = false) {
+    const reference = externalReferenceSchema.parse(input);
+    const directory = await realpath(path.dirname(reference.path));
+    const manifestFile = path.join(directory, path.basename(reference.path));
+    const manifestInfo = await lstat(manifestFile);
+    if (!manifestInfo.isFile() || manifestInfo.size > 256 * 1024)
+        throw new Error("External adapter manifest must be a regular file within 256 KiB");
+    const bytes = await readFile(manifestFile);
+    if (bytes.length > 256 * 1024 || hash(bytes) !== reference.sha256)
+        throw new Error("External adapter manifest integrity mismatch");
+    const manifest = externalManifestSchema.parse(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)));
+    if (new Set(manifest.files.map((file) => file.path)).size !==
+        manifest.files.length ||
+        new Set(manifest.markers).size !== manifest.markers.length ||
+        new Set(manifest.checks.map((check) => check.id)).size !==
+            manifest.checks.length)
+        throw new Error("Duplicate external adapter declarations");
+    if (!manifest.files.some((file) => file.path === manifest.entry))
+        throw new Error("External adapter entry must be a pinned file");
+    for (const check of manifest.checks) {
+        if (!check.scope.extensions.length && !check.scope.names.length)
+            throw new Error("External checks require an explicit nonempty scope selector");
+        if (new Set(check.scope.extensions).size !== check.scope.extensions.length ||
+            new Set(check.scope.names).size !== check.scope.names.length)
+            throw new Error("Duplicate external scope selector");
+    }
+    const contents = new Map();
+    let total = 0;
+    for (const file of manifest.files) {
+        const resolved = await withinRoot(directory, file.path);
+        if (resolved !== path.resolve(directory, file.path) ||
+            resolved === manifestFile)
+            throw new Error("External adapter files must be separate regular files without symbolic links");
+        const info = await lstat(resolved);
+        if (!info.isFile() || info.size > 32 * 1024 * 1024)
+            throw new Error("External adapter file exceeds 32 MiB");
+        const content = await readFile(resolved);
+        total += content.length;
+        if (content.length > 32 * 1024 * 1024 || total > 128 * 1024 * 1024)
+            throw new Error("External adapter bundle exceeds byte limits");
+        if (hash(content) !== file.sha256)
+            throw new Error("External adapter file integrity mismatch");
+        if (retainBytes)
+            contents.set(file.path, content);
+    }
+    return {
+        reference: { path: manifestFile, sha256: reference.sha256 },
+        manifest,
+        identity: {
+            id: manifest.id,
+            version: manifest.version,
+            sha256: reference.sha256,
+        },
+        contents,
+    };
+}
+export async function loadExternalAdapters(inputs = []) {
+    const result = [];
+    for (const reference of externalReferencesSchema.parse(inputs)) {
+        const adapter = await loadExternalAdapter(reference);
+        if (result.some((item) => item.identity.id === adapter.identity.id))
+            throw new Error("Duplicate external adapter identity");
+        result.push(adapter);
+    }
+    return result;
+}
+export function externalPolicyFingerprint(policy, adapters) {
+    return adapters.length
+        ? hash(JSON.stringify([
+            policy,
+            adapters
+                .map((item) => item.identity)
+                .sort((a, b) => a.id.localeCompare(b.id, "en")),
+        ]))
+        : policy;
+}
+export function externalScope(project, check) {
+    return project.files.filter((file) => check.scope.names.includes(path.posix.basename(file)) ||
+        check.scope.extensions.some((extension) => file.endsWith(extension)));
+}
+export const externalInvocationSchema = z.strictObject({
+    reference: externalReferenceSchema,
+    identity: externalIdentitySchema,
+    project: z.string(),
+    runtime: z.enum(["node", "python3", "php", "native"]),
+    checkId: z.string(),
+    kind: z.enum(["analysis", "syntax", "format", "test"]),
+    failOn: z.enum(["error", "warning"]),
+    scope: z
+        .array(relativePath)
+        .min(1)
+        .max(20_000)
+        .refine((files) => new Set(files).size === files.length),
+    sourceFingerprint: sha256,
+});
+export const externalRequestSchema = externalInvocationSchema
+    .omit({ reference: true })
+    .extend({ protocolVersion: z.literal(1), root: z.string() });
+export function externalChecks(source, project, adapter) {
+    return adapter.manifest.checks.map((definition) => {
+        const scope = externalScope(project, definition);
+        const check = {
+            id: `${adapter.identity.id}.${definition.id}`,
+            adapter: adapter.identity.id,
+            project: project.path,
+            scope,
+            kind: definition.kind,
+            parser: "external-json",
+            external: adapter.identity,
+            reason: definition.description,
+            commands: [],
+        };
+        try {
+            const invocation = JSON.stringify(externalInvocationSchema.parse({
+                reference: adapter.reference,
+                identity: adapter.identity,
+                runtime: adapter.manifest.runtime,
+                project: project.path,
+                checkId: check.id,
+                kind: definition.kind,
+                failOn: definition.failOn,
+                scope,
+                sourceFingerprint: source.fingerprint,
+            }));
+            if (Buffer.byteLength(invocation) > 100 * 1024)
+                throw new Error("External adapter invocation exceeds 100 KiB");
+            check.commands.push({
+                temporaryDirectory: true,
+                executable: process.execPath,
+                args: [
+                    fileURLToPath(new URL("./external-runner.js", import.meta.url)),
+                    source.root,
+                    invocation,
+                ],
+                cwd: project.path,
+                env: {
+                    PATH: process.env.PATH ?? "",
+                    NODE_OPTIONS: "",
+                    CHECKTRAIL_TEMP: "",
+                },
+            });
+        }
+        catch (error) {
+            check.unavailableReason =
+                error instanceof Error
+                    ? error.message
+                    : "External adapter scope could not be prepared";
+        }
+        return check;
+    });
+}
+const count = z.number().int().nonnegative().max(10_000_000);
+const testCounts = z.strictObject({
+    total: count,
+    passed: count,
+    failed: count,
+    skipped: count,
+});
+export const externalResultSchema = z.strictObject({
+    protocolVersion: z.literal(1),
+    identity: externalIdentitySchema,
+    checkId: z.string(),
+    sourceFingerprint: sha256,
+    files: z
+        .array(z.strictObject({
+        path: relativePath,
+        status: z.enum(["checked", "skipped", "unavailable"]),
+        tests: testCounts.optional(),
+    }))
+        .max(20_000),
+    findingsComplete: z.boolean(),
+    findings: z
+        .array(z.strictObject({
+        ruleId: z.string().min(1).max(256),
+        level: z.enum(["error", "warning", "note"]),
+        message: z.string().min(1).max(8192),
+        file: relativePath.optional(),
+        line: z.number().int().positive().optional(),
+    }))
+        .max(2000),
+    tools: z
+        .array(z.strictObject({
+        name: z.string().regex(/^[A-Za-z0-9_.-]{1,128}$/),
+        version: z
+            .string()
+            .min(1)
+            .max(256)
+            .refine((value) => [...value].every((character) => character.charCodeAt(0) >= 32 &&
+            character.charCodeAt(0) !== 127)),
+    }))
+        .min(1)
+        .max(32),
+});

package/dist/src/external-evidence.d.ts

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

package/dist/src/external-evidence.js

@@ -0,0 +1,127 @@
+import path from "node:path";
+import { z } from "zod";
+import { externalInvocationSchema, externalResultSchema, } from "./external-adapter.js";
+const envelopeSchema = z.strictObject({
+    exitCode: z.number().int(),
+    stdout: z.string(),
+    stderr: z.string(),
+});
+export function externalEvidence(check, processes) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "External adapter evidence is malformed, contradictory or incomplete",
+        findingsComplete: false,
+    };
+    if (processes.length !== 1)
+        return incomplete;
+    const process = processes[0];
+    if (process.exitCode === 3 && !process.stderr) {
+        try {
+            z.strictObject({ unavailable: z.literal("external-runtime") }).parse(JSON.parse(process.stdout));
+            return {
+                status: "unavailable",
+                reason: "The external adapter runtime is unavailable",
+                findingsComplete: false,
+            };
+        }
+        catch {
+            return incomplete;
+        }
+    }
+    if (process.exitCode !== 0 || process.stderr)
+        return {
+            status: "error",
+            reason: "External adapter execution did not complete",
+            findingsComplete: false,
+        };
+    try {
+        const envelope = envelopeSchema.parse(JSON.parse(process.stdout));
+        if (![0, 1].includes(envelope.exitCode))
+            return {
+                status: "error",
+                reason: "External adapter reported a tool or runtime error",
+                findingsComplete: false,
+            };
+        const result = externalResultSchema.parse(JSON.parse(envelope.stdout));
+        const invocation = externalInvocationSchema.parse(JSON.parse(check.commands[0].args[2]));
+        if (JSON.stringify(result.identity) !== JSON.stringify(check.external) ||
+            JSON.stringify(result.identity) !== JSON.stringify(invocation.identity) ||
+            result.checkId !== check.id ||
+            invocation.kind !== check.kind ||
+            result.sourceFingerprint !== invocation.sourceFingerprint ||
+            JSON.stringify(invocation.scope) !== JSON.stringify(check.scope))
+            return incomplete;
+        const expected = new Set(check.scope);
+        if (!expected.size ||
+            result.files.length !== expected.size ||
+            new Set(result.files.map((file) => file.path)).size !== expected.size ||
+            result.files.some((file) => !expected.has(file.path)) ||
+            result.findings.some((finding) => (finding.file && !expected.has(finding.file)) ||
+                (finding.line && !finding.file)) ||
+            new Set(result.tools.map((tool) => tool.name)).size !==
+                result.tools.length)
+            return incomplete;
+        const tests = { total: 0, passed: 0, failed: 0, skipped: 0 };
+        let complete = result.findingsComplete &&
+            result.files.every((file) => file.status === "checked");
+        for (const file of result.files) {
+            if (check.kind !== "test") {
+                if (file.tests)
+                    return incomplete;
+                continue;
+            }
+            if (!file.tests)
+                return incomplete;
+            const counts = file.tests;
+            if (counts.total !== counts.passed + counts.failed + counts.skipped)
+                return incomplete;
+            if (!counts.total ||
+                counts.skipped ||
+                counts.passed + counts.failed === 0)
+                complete = false;
+            for (const key of ["total", "passed", "failed", "skipped"])
+                tests[key] += counts[key];
+        }
+        const failed = tests.failed > 0 ||
+            result.findings.some((finding) => finding.level === "error" ||
+                (invocation.failOn === "warning" && finding.level === "warning"));
+        if (envelope.exitCode !== (failed ? 1 : 0))
+            return incomplete;
+        const evidence = {
+            external: {
+                ...result.identity,
+                tools: result.tools.map((tool) => ({
+                    ...tool,
+                    source: "adapter-reported",
+                })),
+            },
+            findings: result.findings.map((finding) => ({
+                ruleId: `${check.id}/${finding.ruleId}`,
+                level: finding.level,
+                message: finding.message,
+                ...(finding.line ? { line: finding.line } : {}),
+                ...(finding.file
+                    ? { file: path.posix.join(check.project, finding.file) }
+                    : {}),
+            })),
+            findingsComplete: complete,
+            ...(check.kind === "test" ? { tests } : {}),
+        };
+        if (failed)
+            return {
+                ...evidence,
+                status: "failed",
+                reason: "The trusted external adapter reported failing diagnostics or tests",
+            };
+        if (!complete)
+            return { ...evidence, ...incomplete };
+        return {
+            ...evidence,
+            status: "passed",
+            reason: "The trusted external adapter accounted for every planned file and completed its declared check",
+        };
+    }
+    catch {
+        return incomplete;
+    }
+}

package/dist/src/external-runner.d.ts

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

package/dist/src/external-runner.js

@@ -0,0 +1,122 @@
+import { spawnSync } from "node:child_process";
+import { chmod, mkdir, mkdtemp, realpath, rm, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { externalInvocationSchema, externalReferenceSchema, externalRequestSchema, externalScope, loadExternalAdapter, } from "./external-adapter.js";
+import { inventory, withinRoot } from "./inventory.js";
+async function main() {
+    if (process.argv[2] === "--version") {
+        const adapter = await loadExternalAdapter(externalReferenceSchema.parse(JSON.parse(process.argv[3])));
+        process.stdout.write(`${adapter.identity.version}\n`);
+        return;
+    }
+    const invocation = externalInvocationSchema.parse(JSON.parse(process.argv[3]));
+    const adapter = await loadExternalAdapter(invocation.reference, true);
+    if (JSON.stringify(adapter.identity) !== JSON.stringify(invocation.identity) ||
+        adapter.manifest.runtime !== invocation.runtime)
+        throw new Error("External adapter identity changed");
+    const definition = adapter.manifest.checks.find((check) => `${adapter.identity.id}.${check.id}` === invocation.checkId);
+    if (!definition ||
+        definition.kind !== invocation.kind ||
+        definition.failOn !== invocation.failOn)
+        throw new Error("External check definition changed");
+    const source = await inventory(process.argv[2]);
+    if (source.fingerprint !== invocation.sourceFingerprint)
+        throw new Error("External check source changed before execution");
+    const cwd = await withinRoot(source.root, invocation.project);
+    if (cwd !== (await realpath(process.cwd())))
+        throw new Error("External adapter project does not match its working directory");
+    for (const file of invocation.scope) {
+        const relative = path.posix.join(invocation.project, file);
+        if (!source.files.includes(relative) ||
+            (await withinRoot(source.root, relative)) !==
+                path.resolve(source.root, relative))
+            throw new Error("External scope contains missing or symbolic-link inputs");
+    }
+    if (JSON.stringify(externalScope({
+        path: invocation.project,
+        adapter: adapter.identity.id,
+        markers: [],
+        files: invocation.scope,
+    }, definition)) !== JSON.stringify(invocation.scope))
+        throw new Error("External scope does not match its declared selectors");
+    const temporary = process.env.CHECKTRAIL_TEMP ||
+        (await mkdtemp(path.join(tmpdir(), "checktrail-external-")));
+    try {
+        const bundle = path.join(temporary, "bundle");
+        for (const [file, content] of adapter.contents) {
+            const output = path.join(bundle, file);
+            await mkdir(path.dirname(output), { recursive: true });
+            await writeFile(output, content, { flag: "wx", mode: 0o600 });
+        }
+        const entry = path.join(bundle, adapter.manifest.entry);
+        const request = path.join(temporary, "request.json");
+        await writeFile(request, JSON.stringify(externalRequestSchema.parse({
+            protocolVersion: 1,
+            root: source.root,
+            identity: invocation.identity,
+            project: invocation.project,
+            runtime: invocation.runtime,
+            checkId: invocation.checkId,
+            kind: invocation.kind,
+            failOn: invocation.failOn,
+            scope: invocation.scope,
+            sourceFingerprint: invocation.sourceFingerprint,
+        })), { mode: 0o600 });
+        let executable;
+        let args;
+        switch (adapter.manifest.runtime) {
+            case "node":
+                executable = process.execPath;
+                args = [entry, request];
+                break;
+            case "python3":
+                executable = "python3";
+                args = ["-I", "-B", entry, request];
+                break;
+            case "php":
+                executable = "php";
+                args = ["-n", entry, request];
+                break;
+            case "native":
+                executable = entry;
+                args = [request];
+                await chmod(entry, 0o700);
+                break;
+        }
+        const result = spawnSync(executable, args, {
+            cwd,
+            env: { ...process.env, NODE_OPTIONS: "" },
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+        });
+        if (result.error &&
+            result.error.code === "ENOENT") {
+            process.stdout.write(JSON.stringify({ unavailable: "external-runtime" }));
+            process.exitCode = 3;
+            return;
+        }
+        if (result.error ||
+            result.signal ||
+            result.status === null ||
+            Buffer.byteLength(result.stdout) + Buffer.byteLength(result.stderr) >
+                1024 * 1024)
+            throw new Error("External adapter process did not complete within evidence bounds");
+        await loadExternalAdapter(invocation.reference);
+        if ((await inventory(source.root)).fingerprint !==
+            invocation.sourceFingerprint)
+            throw new Error("External check source changed during execution");
+        process.stdout.write(JSON.stringify({
+            exitCode: result.status,
+            stdout: result.stdout,
+            stderr: result.stderr,
+        }));
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+main().catch(() => {
+    process.stderr.write("External adapter evidence collection could not complete\n");
+    process.exitCode = 2;
+});

package/dist/src/fastapi-evidence.d.ts

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

package/dist/src/fastapi-evidence.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { runtimeInventorySchema } from "./runtime-inventory.js";
+const count = z.number().int().nonnegative();
+const schema = z.strictObject({
+    version: z.literal(1),
+    versions: z.strictObject({
+        fastapi: z.literal("0.141.1"),
+        starlette: z.literal("1.6.0"),
+    }),
+    totalRoutes: count,
+    supportedRoutes: count,
+    applicationRoutes: count,
+    entryRouteIndices: z.array(count),
+    runtime: runtimeInventorySchema,
+});
+const attributesSchema = z.strictObject({
+    protocol: z.enum(["http", "websocket"]),
+    method: z.string().regex(/^[A-Z]+$/),
+    path: z.string().startsWith("/"),
+    handler: z.string().min(1),
+    name: z.string(),
+    dependencies: z.array(z.string().min(1)),
+    includeInSchema: z.boolean(),
+});
+export function fastapiEvidence(check, processes) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "FastAPI runtime routes are unsupported, empty, malformed or incomplete.",
+    };
+    if (processes.length !== 1)
+        return incomplete;
+    if (processes[0].exitCode === 3) {
+        try {
+            z.strictObject({
+                unavailable: z.literal("fastapi-runtime"),
+                reason: z.enum(["missing-package", "unsupported-version"]),
+            }).parse(JSON.parse(processes[0].stdout));
+            return {
+                status: "unavailable",
+                reason: "The pinned FastAPI/Starlette runtime profile is not installed.",
+            };
+        }
+        catch {
+            return incomplete;
+        }
+    }
+    if (processes[0].exitCode !== 0)
+        return {
+            status: "error",
+            reason: "FastAPI application, lifespan or supported collector could not complete.",
+        };
+    try {
+        const result = schema.parse(JSON.parse(processes[0].stdout));
+        const profile = JSON.parse(check.commands[0].args[2]);
+        const routes = result.runtime.collections[0];
+        if (result.runtime.sourceFingerprint !== check.commands[0]?.args[3] ||
+            result.runtime.collections.length !== 1 ||
+            routes?.kind !== "routes" ||
+            !routes.ordered ||
+            routes.complete !== (result.supportedRoutes === result.totalRoutes) ||
+            result.supportedRoutes > result.totalRoutes ||
+            result.applicationRoutes > result.supportedRoutes ||
+            routes.entries.length < result.supportedRoutes ||
+            result.entryRouteIndices.length !== routes.entries.length ||
+            new Set(result.entryRouteIndices).size !== result.supportedRoutes ||
+            result.entryRouteIndices.some((index) => index >= result.totalRoutes) ||
+            result.entryRouteIndices.some((index, offset) => offset > 0 && index < result.entryRouteIndices[offset - 1]) ||
+            result.runtime.producer.name !== "checktrail.fastapi-routes" ||
+            result.runtime.producer.version !== "1.0.0" ||
+            result.runtime.assembly.name !== profile.assembly ||
+            result.runtime.assembly.environment !== profile.environment ||
+            !result.applicationRoutes)
+            return incomplete;
+        const identities = new Set();
+        let duplicates = 0;
+        const registrations = new Map();
+        const signatures = new Map();
+        for (const [index, entry] of routes.entries.entries()) {
+            const attributes = attributesSchema.parse(entry.attributes);
+            const key = attributes.protocol === "http"
+                ? `HTTP ${attributes.method} ${attributes.path}`
+                : `WEBSOCKET ${attributes.path}`;
+            if (entry.key !== key ||
+                (attributes.protocol === "websocket" &&
+                    attributes.method !== "WEBSOCKET"))
+                return incomplete;
+            const registration = result.entryRouteIndices[index];
+            const methods = registrations.get(registration) ?? new Set();
+            if (methods.has(attributes.method))
+                return incomplete;
+            const signature = JSON.stringify([
+                attributes.protocol,
+                attributes.path,
+                attributes.handler,
+                attributes.name,
+                attributes.dependencies,
+                attributes.includeInSchema,
+            ]);
+            if (signatures.has(registration) &&
+                signatures.get(registration) !== signature)
+                return incomplete;
+            signatures.set(registration, signature);
+            methods.add(attributes.method);
+            registrations.set(registration, methods);
+            if (identities.has(entry.key))
+                duplicates++;
+            identities.add(entry.key);
+        }
+        if (duplicates)
+            return {
+                status: "failed",
+                reason: "FastAPI registered exact duplicate method/path routes; inspect the captured runtime inventory.",
+                runtime: result.runtime,
+            };
+        if (!routes.complete)
+            return { ...incomplete, runtime: result.runtime };
+        return {
+            status: "passed",
+            reason: "FastAPI lifespan completed and the supported flat route inventory has no exact duplicate method/path registrations.",
+            runtime: result.runtime,
+        };
+    }
+    catch {
+        return incomplete;
+    }
+}

package/dist/src/fastapi-runner.d.ts

@@ -0,0 +1 @@
+export declare const fastapiRunner: string;