@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/rust.d.ts

@@ -0,0 +1,7 @@
+import type { Check, Inventory, Project } from "./types.js";
+export declare const rustEnvironment: {
+    CARGO_NET_OFFLINE: string;
+    CARGO_INCREMENTAL: string;
+    RUSTUP_AUTO_INSTALL: string;
+};
+export declare function rustCheck(source: Inventory, project: Project): Check;

package/dist/src/rust.js

@@ -0,0 +1,39 @@
+import { fileURLToPath } from "node:url";
+export const rustEnvironment = {
+    CARGO_NET_OFFLINE: "true",
+    CARGO_INCREMENTAL: "0",
+    RUSTUP_AUTO_INSTALL: "0",
+};
+export function rustCheck(source, project) {
+    const scope = project.files.filter((file) => file.endsWith(".rs"));
+    const check = {
+        id: "rust.cargo-check",
+        adapter: project.adapter,
+        project: project.path,
+        scope,
+        kind: "analysis",
+        parser: "rust-json",
+        reason: "Check all native Cargo targets offline with locked dependencies, fresh temporary build output and Rust dep-info source accounting.",
+        commands: [
+            {
+                executable: process.execPath,
+                args: [
+                    fileURLToPath(new URL("./rust-runner.js", import.meta.url)),
+                    source.root,
+                    ...scope,
+                ],
+                cwd: project.path,
+                env: rustEnvironment,
+            },
+        ],
+    };
+    if (!scope.length)
+        check.unavailableReason = "No Rust source was inventoried.";
+    else if (!project.files.includes("Cargo.lock"))
+        check.unavailableReason =
+            "This profile requires an existing project-local Cargo.lock; validation never generates a lockfile.";
+    else if ([source.root, project.path, ...scope].some((file) => /[\r\n\\$#:]/.test(file)))
+        check.unavailableReason =
+            "This Rust dep-info profile does not support newline, backslash, dollar, hash or colon in source paths.";
+    return check;
+}

package/dist/src/sarif.d.ts

@@ -0,0 +1,86 @@
+export declare function exportSarif(input: unknown): {
+    $schema: string;
+    version: string;
+    runs: {
+        tool: {
+            driver: {
+                name: string;
+                version: string;
+                rules: {
+                    id: string;
+                    name: string;
+                }[];
+            };
+        };
+        invocations: {
+            executionSuccessful: boolean;
+            toolExecutionNotifications: {
+                level: string;
+                message: {
+                    text: string;
+                };
+            }[];
+        }[];
+        results: {
+            locations?: {
+                physicalLocation: {
+                    region?: {
+                        startLine: number;
+                    };
+                    artifactLocation: {
+                        uri: string;
+                        uriBaseId: string;
+                    };
+                };
+            }[];
+            ruleId: string;
+            ruleIndex: number;
+            level: "error" | "warning" | "note";
+            message: {
+                text: string;
+            };
+        }[];
+        properties: {
+            tools?: {
+                name: string;
+                version: string | null;
+                status: "unavailable" | "inconclusive" | "identified";
+                source: "engine-runtime" | "package-metadata" | "version-command";
+            }[];
+            environment?: {
+                names: string[];
+                fingerprint: string;
+            };
+            tests?: {
+                total: number;
+                passed: number;
+                failed: number;
+                skipped: number;
+            };
+            checkId?: string;
+            project?: string;
+            status?: "error" | "passed" | "failed" | "skipped" | "unavailable" | "inconclusive";
+            normalizedFindingsAvailable?: boolean;
+            outcome: "passed" | "failed" | "incomplete";
+            sourceFingerprint: string;
+            finalSourceFingerprint: string | null;
+            policyFingerprint: string;
+            sourceChanged: boolean;
+            sourceError: boolean;
+            selection?: {
+                mode: "full" | "affected";
+                reason: string;
+                changedFiles: string[];
+                selectedProjects: string[];
+                git?: {
+                    baseCommit: string;
+                    headCommit: string;
+                    version: string;
+                    worktreeId: string;
+                    indexFingerprint: string;
+                } | undefined;
+            };
+            runId: string;
+        };
+    }[];
+};

package/dist/src/sarif.js

@@ -0,0 +1,113 @@
+import path from "node:path";
+import { validatedReport } from "./report-validation.js";
+function uri(file) {
+    if (!file ||
+        path.posix.isAbsolute(file) ||
+        path.win32.isAbsolute(file) ||
+        file.includes("\\") ||
+        file.split("/").some((part) => !part || part === "." || part === ".."))
+        throw new Error("SARIF requires normalized repository-relative finding paths");
+    return file.split("/").map(encodeURIComponent).join("/");
+}
+const message = (text) => ({ text: text.replace(/[{}]/g, "$&$&") });
+export function exportSarif(input) {
+    const report = validatedReport(input);
+    const checks = report.checks
+        .length
+        ? report.checks
+        : [undefined];
+    return {
+        $schema: "https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/sarif-schema-2.1.0.json",
+        version: "2.1.0",
+        runs: checks.map((check) => {
+            const findings = check?.findings ?? [];
+            const ruleIds = [...new Set(findings.map((finding) => finding.ruleId))];
+            const ruleId = (nativeId) => `${encodeURIComponent(check.id)}/${encodeURIComponent(nativeId)}`;
+            const complete = Boolean(check &&
+                !report.sourceChanged &&
+                !report.sourceError &&
+                (check.status === "passed" ||
+                    (check.status === "failed" &&
+                        check.findingsComplete === true &&
+                        findings.length > 0)));
+            const notification = !check
+                ? "No checks were executed."
+                : report.sourceChanged || report.sourceError
+                    ? "Source changed or could not be verified after execution; findings are not current-source validation."
+                    : check.status === "failed" && findings.length === 0
+                        ? "The check failed without exportable source diagnostics. Consult the complete validation report."
+                        : check.reason;
+            return {
+                tool: {
+                    driver: {
+                        name: "checktrail",
+                        version: report.engineVersion,
+                        rules: ruleIds.map((id) => ({ id: ruleId(id), name: id })),
+                    },
+                },
+                invocations: [
+                    {
+                        executionSuccessful: complete,
+                        toolExecutionNotifications: [
+                            {
+                                level: complete ? "note" : "error",
+                                message: message(notification),
+                            },
+                        ],
+                    },
+                ],
+                results: findings.map((finding) => ({
+                    ruleId: ruleId(finding.ruleId),
+                    ruleIndex: ruleIds.indexOf(finding.ruleId),
+                    level: finding.level,
+                    message: message(finding.message),
+                    ...(finding.file
+                        ? {
+                            locations: [
+                                {
+                                    physicalLocation: {
+                                        artifactLocation: {
+                                            uri: uri(finding.file),
+                                            uriBaseId: "%SRCROOT%",
+                                        },
+                                        ...(finding.line
+                                            ? { region: { startLine: finding.line } }
+                                            : {}),
+                                    },
+                                },
+                            ],
+                        }
+                        : {}),
+                })),
+                properties: {
+                    runId: report.runId,
+                    ...(report.selection ? { selection: report.selection } : {}),
+                    outcome: report.outcome,
+                    sourceFingerprint: report.sourceFingerprint,
+                    finalSourceFingerprint: report.finalSourceFingerprint,
+                    policyFingerprint: report.policyFingerprint,
+                    sourceChanged: report.sourceChanged,
+                    sourceError: report.sourceError,
+                    ...(check
+                        ? {
+                            checkId: check.id,
+                            project: check.project,
+                            status: check.status,
+                            normalizedFindingsAvailable: check.findings !== undefined,
+                            ...(check.tests ? { tests: check.tests } : {}),
+                            ...(check.environment
+                                ? { environment: check.environment }
+                                : {}),
+                            tools: check.tools?.map(({ name, version, status, source }) => ({
+                                name,
+                                version,
+                                status,
+                                source,
+                            })) ?? [],
+                        }
+                        : {}),
+                },
+            };
+        }),
+    };
+}

package/dist/src/schemas.d.ts

@@ -0,0 +1,393 @@
+export { externalManifestSchema, externalReferenceSchema, externalRequestSchema, externalResultSchema, } from "./external-adapter.js";
+export { actionlintConfigSchema } from "./actionlint.js";
+export { dotnetConfigSchema } from "./dotnet.js";
+export { javaConfigSchema } from "./java.js";
+export { clangDatabaseSchema } from "./clang.js";
+export { dependencyGraphSchema, architecturePolicySchema, architectureReportSchema, architectureSummarySchema, } from "./architecture.js";
+export { laravelConfigSchema } from "./laravel.js";
+import { z } from "zod";
+export { fastapiConfigSchema } from "./fastapi.js";
+export { djangoConfigSchema } from "./django.js";
+export { vueRouterConfigSchema } from "./vue-router.js";
+export { contractBundleSchema, contractReportSchema, contractSummarySchema, } from "./contract-schema.js";
+export { runtimeInventorySchema, runtimeComparisonSchema, runtimeComparisonSummarySchema, } from "./runtime-inventory.js";
+export { configSchema } from "./config.js";
+export { policyPackSchema } from "./policy-pack.js";
+export declare const reportSchema: z.ZodObject<{
+    selection: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            full: "full";
+            affected: "affected";
+        }>;
+        reason: z.ZodString;
+        changedFiles: z.ZodArray<z.ZodString>;
+        selectedProjects: z.ZodArray<z.ZodString>;
+        git: z.ZodOptional<z.ZodObject<{
+            baseCommit: z.ZodString;
+            headCommit: z.ZodString;
+            version: z.ZodString;
+            worktreeId: z.ZodString;
+            indexFingerprint: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    startedAt: z.ZodISODateTime;
+    sourceFingerprint: z.ZodString;
+    finalSourceFingerprint: z.ZodNullable<z.ZodString>;
+    policyFingerprint: z.ZodString;
+    excluded: z.ZodArray<z.ZodString>;
+    checks: z.ZodArray<z.ZodObject<{
+        external: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            sha256: z.ZodString;
+            tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+                source: z.ZodLiteral<"adapter-reported">;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        adapter: z.ZodString;
+        project: z.ZodString;
+        scope: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            error: "error";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+            unavailable: "unavailable";
+            inconclusive: "inconclusive";
+        }>;
+        reason: z.ZodString;
+        processes: z.ZodArray<z.ZodObject<{
+            command: z.ZodObject<{
+                temporaryDirectory: z.ZodOptional<z.ZodBoolean>;
+                executable: z.ZodString;
+                args: z.ZodArray<z.ZodString>;
+                cwd: z.ZodString;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>;
+            exitCode: z.ZodNullable<z.ZodNumber>;
+            signal: z.ZodNullable<z.ZodString>;
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            durationMs: z.ZodNumber;
+            timedOut: z.ZodBoolean;
+            cancelled: z.ZodBoolean;
+            truncated: z.ZodBoolean;
+            errorCode: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tests: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            skipped: z.ZodNumber;
+        }, z.core.$strict>>;
+        findingsComplete: z.ZodOptional<z.ZodBoolean>;
+        runtime: z.ZodOptional<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>>;
+        findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            level: z.ZodEnum<{
+                error: "error";
+                warning: "warning";
+                note: "note";
+            }>;
+            message: z.ZodString;
+            file: z.ZodOptional<z.ZodString>;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        environment: z.ZodOptional<z.ZodObject<{
+            names: z.ZodArray<z.ZodString>;
+            fingerprint: z.ZodString;
+        }, z.core.$strict>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            source: z.ZodEnum<{
+                "engine-runtime": "engine-runtime";
+                "package-metadata": "package-metadata";
+                "version-command": "version-command";
+            }>;
+            version: z.ZodNullable<z.ZodString>;
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                inconclusive: "inconclusive";
+                identified: "identified";
+            }>;
+            process: z.ZodOptional<z.ZodObject<{
+                command: z.ZodObject<{
+                    temporaryDirectory: z.ZodOptional<z.ZodBoolean>;
+                    executable: z.ZodString;
+                    args: z.ZodArray<z.ZodString>;
+                    cwd: z.ZodString;
+                    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                }, z.core.$strict>;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+                signal: z.ZodNullable<z.ZodString>;
+                stdout: z.ZodString;
+                stderr: z.ZodString;
+                durationMs: z.ZodNumber;
+                timedOut: z.ZodBoolean;
+                cancelled: z.ZodBoolean;
+                truncated: z.ZodBoolean;
+                errorCode: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    runId: z.ZodString;
+    outcome: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        incomplete: "incomplete";
+    }>;
+    durationMs: z.ZodNumber;
+    sourceChanged: z.ZodBoolean;
+    sourceError: z.ZodBoolean;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+}, z.core.$strict>;
+export declare const reportSummarySchema: z.ZodObject<{
+    selection: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            full: "full";
+            affected: "affected";
+        }>;
+        reason: z.ZodString;
+        projectCount: z.ZodNumber;
+        changedFileCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+            unavailable: "unavailable";
+            inconclusive: "inconclusive";
+        }>;
+        tests: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            skipped: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    runId: z.ZodString;
+    outcome: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        incomplete: "incomplete";
+    }>;
+    durationMs: z.ZodNumber;
+    sourceChanged: z.ZodBoolean;
+    sourceError: z.ZodBoolean;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+}, z.core.$strict>;
+export declare const planSchema: z.ZodObject<{
+    selection: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            full: "full";
+            affected: "affected";
+        }>;
+        reason: z.ZodString;
+        changedFiles: z.ZodArray<z.ZodString>;
+        selectedProjects: z.ZodArray<z.ZodString>;
+        git: z.ZodOptional<z.ZodObject<{
+            baseCommit: z.ZodString;
+            headCommit: z.ZodString;
+            version: z.ZodString;
+            worktreeId: z.ZodString;
+            indexFingerprint: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        complete: z.ZodBoolean;
+        dependencies: z.ZodArray<z.ZodObject<{
+            consumer: z.ZodString;
+            producer: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    sourceFingerprint: z.ZodString;
+    policyFingerprint: z.ZodString;
+    excluded: z.ZodArray<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        adapter: z.ZodString;
+        markers: z.ZodArray<z.ZodString>;
+        files: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    checks: z.ZodArray<z.ZodObject<{
+        external: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        adapter: z.ZodString;
+        project: z.ZodString;
+        scope: z.ZodArray<z.ZodString>;
+        kind: z.ZodEnum<{
+            format: "format";
+            analysis: "analysis";
+            syntax: "syntax";
+            test: "test";
+            unsupported: "unsupported";
+        }>;
+        parser: z.ZodEnum<{
+            "external-json": "external-json";
+            "vue-router-json": "vue-router-json";
+            "nuxt-json": "nuxt-json";
+            exit: "exit";
+            empty: "empty";
+            "node-events": "node-events";
+            unittest: "unittest";
+            "go-scope-test": "go-scope-test";
+            "go-scope-analysis": "go-scope-analysis";
+            "golangci-json": "golangci-json";
+            "staticcheck-json": "staticcheck-json";
+            "go-json": "go-json";
+            "typescript-build-json": "typescript-build-json";
+            "tsc-files": "tsc-files";
+            "eslint-json": "eslint-json";
+            "vitest-json": "vitest-json";
+            "playwright-json": "playwright-json";
+            "jest-json": "jest-json";
+            "pytest-json": "pytest-json";
+            "fastapi-json": "fastapi-json";
+            "django-json": "django-json";
+            "laravel-json": "laravel-json";
+            "rust-json": "rust-json";
+            "clang-json": "clang-json";
+            "java-json": "java-json";
+            "dotnet-json": "dotnet-json";
+            "actionlint-json": "actionlint-json";
+            "ruby-syntax": "ruby-syntax";
+            "silent-syntax": "silent-syntax";
+            "ruff-json": "ruff-json";
+            "mypy-json": "mypy-json";
+            "phpstan-json": "phpstan-json";
+            "phpunit-junit": "phpunit-junit";
+            "pint-json": "pint-json";
+        }>;
+        commands: z.ZodArray<z.ZodObject<{
+            temporaryDirectory: z.ZodOptional<z.ZodBoolean>;
+            executable: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+            cwd: z.ZodString;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>>;
+        reason: z.ZodString;
+        unavailableReason: z.ZodOptional<z.ZodString>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            name: z.ZodLiteral<"node">;
+            source: z.ZodLiteral<"engine-runtime">;
+        }, z.core.$strict>, z.ZodObject<{
+            name: z.ZodString;
+            source: z.ZodLiteral<"package-metadata">;
+            path: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            name: z.ZodString;
+            source: z.ZodLiteral<"version-command">;
+            command: z.ZodObject<{
+                temporaryDirectory: z.ZodOptional<z.ZodBoolean>;
+                executable: z.ZodString;
+                args: z.ZodArray<z.ZodString>;
+                cwd: z.ZodString;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "source">>>;
+        environment: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+}, z.core.$strict>;
+export declare const planSummarySchema: z.ZodObject<{
+    selection: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            full: "full";
+            affected: "affected";
+        }>;
+        reason: z.ZodString;
+        projectCount: z.ZodNumber;
+        changedFileCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    projectCount: z.ZodNumber;
+    adapters: z.ZodArray<z.ZodString>;
+    excludedCount: z.ZodNumber;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            format: "format";
+            analysis: "analysis";
+            syntax: "syntax";
+            test: "test";
+            unsupported: "unsupported";
+        }>;
+        ready: z.ZodBoolean;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+}, z.core.$strict>;
+export declare const junitImportSchema: z.ZodObject<{
+    format: z.ZodLiteral<"junit">;
+    provenance: z.ZodLiteral<"imported-report">;
+    outcome: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        incomplete: "incomplete";
+    }>;
+    reason: z.ZodString;
+    tests: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        skipped: z.ZodNumber;
+    }, z.core.$strict>>;
+    cases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        assertions: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    schemaVersion: z.ZodLiteral<1>;
+    engineVersion: z.ZodString;
+}, z.core.$strict>;
+export { findingBaselineSchema, findingComparisonSchema, findingComparisonSummarySchema, } from "./finding-policy-schema.js";
+export { guidanceContextSchema, guidanceReportSchema, guidanceSummarySchema, } from "./guidance.js";
+export { mutationRecipeSchema, mutationReportSchema, mutationSummarySchema, } from "./mutation.js";
+export { nuxtConfigSchema } from "./nuxt.js";
+export { reviewSelectionSchema, reviewContextSchema, reviewContextSummarySchema, reviewAssessmentSchema, reviewReceiptSchema, reviewReceiptSummarySchema, } from "./review.js";