@stsepelin/checktrail 0.1.0-alpha.1

package/dist/src/jest-runner.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+import { withinRoot } from "./inventory.js";
+async function main() {
+    const [entry, root, ...files] = process.argv.slice(2);
+    if (!entry || !root || !files.length)
+        throw new Error("Invalid Jest runner arguments");
+    const tool = await withinRoot(root, path.relative(root, entry));
+    const { runCLI } = createRequire(import.meta.url)(tool);
+    const paths = [];
+    for (const file of files)
+        paths.push(await withinRoot(root, path.relative(root, path.resolve(file))));
+    const { results } = await runCLI({
+        $0: "checktrail",
+        _: paths,
+        ci: true,
+        runInBand: true,
+        runTestsByPath: true,
+        watch: false,
+        watchAll: false,
+        updateSnapshot: false,
+        cache: false,
+        collectTests: false,
+        listTests: false,
+        passWithNoTests: false,
+        onlyChanged: false,
+        onlyFailures: false,
+        findRelatedTests: false,
+        testNamePattern: "",
+        testResultsProcessor: "",
+        filter: "",
+        bail: 0,
+        json: false,
+        useStderr: true,
+        reporters: ["default"],
+        runner: "jest-runner",
+        testRunner: "jest-circus/runner",
+    }, [process.cwd()]);
+    const evidence = { ...results, coverageMap: undefined };
+    process.stdout.write(`${JSON.stringify(evidence)}\n`);
+    process.exitCode = results.success ? 0 : 1;
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : "Jest execution failed"}\n`);
+    process.exitCode = 2;
+});

package/dist/src/jest.d.ts

@@ -0,0 +1,2 @@
+import type { Check, Inventory, Project } from "./types.js";
+export declare function jestCheck(source: Inventory, project: Project): Promise<Check>;

package/dist/src/jest.js

@@ -0,0 +1,36 @@
+import { fileURLToPath } from "node:url";
+import { localTool } from "./local-tool.js";
+export async function jestCheck(source, project) {
+    const files = project.files.filter((file) => /(?:\.(?:test|spec)\.(?:[cm]?[jt]s|[jt]sx)$|(?:^|\/)__tests__\/.*\.(?:[cm]?[jt]s|[jt]sx)$)/.test(file));
+    const tool = await localTool(source.root, project.path, "jest/build/index.js");
+    const check = {
+        id: "javascript.jest",
+        adapter: project.adapter,
+        project: project.path,
+        scope: files,
+        kind: "test",
+        parser: "jest-json",
+        reason: "Run installed Jest once and account for every planned test file; require passing non-skipped assertions and consistent native JSON evidence.",
+        commands: tool
+            ? [
+                {
+                    executable: process.execPath,
+                    args: [
+                        fileURLToPath(new URL("./jest-runner.js", import.meta.url)),
+                        tool,
+                        source.root,
+                        ...files,
+                    ],
+                    cwd: project.path,
+                    env: { CI: "1" },
+                },
+            ]
+            : [],
+    };
+    if (!files.length)
+        check.unavailableReason = "No .test or .spec JS/TS files were inventoried.";
+    else if (!tool)
+        check.unavailableReason =
+            "Jest is not installed within the configured root.";
+    return check;
+}

package/dist/src/junit.d.ts

@@ -0,0 +1,18 @@
+import type { TestEvidence } from "./types.js";
+export interface JUnitCase {
+    name: string;
+    file?: string;
+    status: "passed" | "failed" | "skipped";
+    assertions?: number;
+}
+export interface JUnitImport {
+    schemaVersion: 1;
+    engineVersion: string;
+    format: "junit";
+    provenance: "imported-report";
+    outcome: "passed" | "failed" | "incomplete";
+    reason: string;
+    tests?: TestEvidence;
+    cases?: JUnitCase[];
+}
+export declare function importJUnit(xml: string): JUnitImport;

package/dist/src/junit.js

@@ -0,0 +1,157 @@
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+import { VERSION } from "./types.js";
+function object(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("Expected XML element");
+    return value;
+}
+const array = (value) => value === undefined ? [] : Array.isArray(value) ? value : [value];
+function count(value) {
+    if (typeof value !== "string" ||
+        !/^\d+$/.test(value) ||
+        !Number.isSafeInteger(Number(value)))
+        throw new Error("Invalid JUnit counter");
+    return Number(value);
+}
+export function importJUnit(xml) {
+    const base = {
+        schemaVersion: 1,
+        engineVersion: VERSION,
+        format: "junit",
+        provenance: "imported-report",
+        outcome: "incomplete",
+        reason: "JUnit evidence is malformed, inconsistent, empty, or entirely skipped; an import does not establish execution freshness.",
+    };
+    if (Buffer.byteLength(xml) > 8 * 1024 * 1024 ||
+        /<!\s*(?:DOCTYPE|ENTITY)/i.test(xml))
+        return base;
+    try {
+        if (XMLValidator.validate(xml) !== true)
+            return base;
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            parseAttributeValue: false,
+            parseTagValue: false,
+            ignoreDeclaration: true,
+            processEntities: true,
+            htmlEntities: false,
+        });
+        const root = object(parser.parse(xml));
+        if (Object.keys(root).length !== 1 ||
+            !("testsuite" in root || "testsuites" in root))
+            return base;
+        const cases = [];
+        const identities = new Set();
+        const walk = (value, depth, trail, wrapper = false) => {
+            if (depth > 32)
+                throw new Error("JUnit nesting limit");
+            const suite = object(value);
+            if (wrapper && suite.testcase !== undefined)
+                throw new Error("Test case outside suite");
+            if (Object.keys(suite).some((key) => !key.startsWith("@_") &&
+                ![
+                    "testsuite",
+                    "testcase",
+                    "properties",
+                    "system-out",
+                    "system-err",
+                ].includes(key)))
+                throw new Error("Unknown JUnit suite element");
+            const names = [
+                ...trail,
+                typeof suite["@_name"] === "string" ? suite["@_name"] : "",
+            ];
+            const counts = { total: 0, failures: 0, errors: 0, skipped: 0 };
+            for (const value of array(suite.testcase)) {
+                if (cases.length >= 100_000)
+                    throw new Error("JUnit case limit");
+                const entry = object(value);
+                if (Object.keys(entry).some((key) => !key.startsWith("@_") &&
+                    ![
+                        "failure",
+                        "error",
+                        "skipped",
+                        "properties",
+                        "system-out",
+                        "system-err",
+                    ].includes(key)))
+                    throw new Error("Unknown JUnit case element");
+                if (typeof entry["@_name"] !== "string" || !entry["@_name"].length)
+                    throw new Error("Missing test name");
+                const identity = JSON.stringify([
+                    names,
+                    entry["@_file"],
+                    entry["@_classname"],
+                    entry["@_class"],
+                    entry["@_name"],
+                ]);
+                if (identities.has(identity))
+                    throw new Error("Duplicate JUnit case");
+                identities.add(identity);
+                const failures = array(entry.failure).length;
+                const errors = array(entry.error).length;
+                const skipped = array(entry.skipped).length;
+                if (failures + errors + skipped > 1)
+                    throw new Error("Contradictory JUnit case states");
+                const item = {
+                    name: entry["@_name"],
+                    status: failures || errors ? "failed" : skipped ? "skipped" : "passed",
+                };
+                if (entry["@_file"] !== undefined) {
+                    if (typeof entry["@_file"] !== "string" || !entry["@_file"].length)
+                        throw new Error("Invalid JUnit file");
+                    item.file = entry["@_file"];
+                }
+                if (entry["@_assertions"] !== undefined)
+                    item.assertions = count(entry["@_assertions"]);
+                cases.push(item);
+                counts.total++;
+                counts.failures += failures;
+                counts.errors += errors;
+                counts.skipped += skipped;
+            }
+            for (const child of array(suite.testsuite)) {
+                const nested = walk(child, depth + 1, names);
+                for (const key of ["total", "failures", "errors", "skipped"])
+                    counts[key] += nested[key];
+            }
+            for (const [attribute, key] of [
+                ["tests", "total"],
+                ["failures", "failures"],
+                ["errors", "errors"],
+                ["skipped", "skipped"],
+            ]) {
+                const declared = suite[`@_${attribute}`];
+                if (declared !== undefined && count(declared) !== counts[key])
+                    throw new Error("JUnit counts disagree");
+                if (!wrapper && attribute === "tests" && declared === undefined)
+                    throw new Error("Missing suite count");
+            }
+            return counts;
+        };
+        const value = "testsuites" in root
+            ? walk(root.testsuites, 0, [], true)
+            : walk(root.testsuite, 0, []);
+        const tests = {
+            total: value.total,
+            passed: value.total - value.failures - value.errors - value.skipped,
+            failed: value.failures + value.errors,
+            skipped: value.skipped,
+        };
+        const outcome = tests.failed
+            ? "failed"
+            : tests.passed
+                ? "passed"
+                : "incomplete";
+        return {
+            ...base,
+            outcome,
+            tests,
+            cases,
+            reason: "Imported JUnit counts describe this report only; source identity, scope and execution freshness are not established.",
+        };
+    }
+    catch {
+        return base;
+    }
+}

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

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

package/dist/src/laravel-evidence.js

@@ -0,0 +1,175 @@
+import { z } from "zod";
+import { runtimeInventorySchema } from "./runtime-inventory.js";
+import { laravelConfigSchema } from "./laravel.js";
+const text = z.string();
+const hash = text.regex(/^[a-f0-9]{64}$/);
+const attributes = {
+    routes: z.strictObject({
+        domain: text.nullable(),
+        method: text.min(1),
+        uri: text.min(1),
+        name: text.nullable(),
+        handler: text.min(1),
+        middleware: z.array(text),
+        constraintsHash: hash,
+        defaultsHash: hash,
+    }),
+    middleware: z.discriminatedUnion("type", [
+        z.strictObject({
+            type: z.enum(["global", "priority"]),
+            stack: z.array(text),
+        }),
+        z.strictObject({
+            type: z.literal("group"),
+            name: text,
+            stack: z.array(text),
+        }),
+        z.strictObject({ type: z.literal("alias"), name: text, target: text }),
+    ]),
+    listeners: z.strictObject({
+        type: z.enum(["exact", "wildcard"]),
+        event: text,
+        listener: text,
+    }),
+    schedules: z.strictObject({
+        type: z.enum(["callback", "command"]),
+        target: text,
+        expression: text,
+        repeatSeconds: z.number().int().nullable(),
+        user: text.nullable(),
+        environments: z.array(text),
+        evenInMaintenanceMode: z.boolean(),
+        evenWhenPaused: z.boolean(),
+        withoutOverlapping: z.boolean(),
+        releaseOnTerminationSignals: z.boolean(),
+        onOneServer: z.boolean(),
+        expiresAt: z.number().int(),
+        runInBackground: z.boolean(),
+        description: text.nullable(),
+        output: text,
+        shouldAppendOutput: z.boolean(),
+        timezone: text.nullable(),
+        parametersHash: hash,
+        filters: z.array(text),
+        rejects: z.array(text),
+        beforeCallbacks: z.array(text),
+        afterCallbacks: z.array(text),
+        mutex: text,
+        mutexNameResolver: text.nullable(),
+        attributesHash: hash,
+    }),
+    bindings: z.discriminatedUnion("type", [
+        z.strictObject({
+            type: z.literal("factory"),
+            abstract: text,
+            target: text,
+            shared: z.boolean(),
+            scoped: z.boolean(),
+        }),
+        z.strictObject({
+            type: z.enum(["alias", "instance"]),
+            abstract: text,
+            target: text,
+        }),
+        z.strictObject({
+            type: z.literal("contextual"),
+            consumer: text,
+            abstract: text,
+            target: text,
+        }),
+    ]),
+};
+const schema = z.strictObject({
+    version: z.literal(1),
+    laravelVersion: z.literal("13.32.0"),
+    entryCount: z.number().int().nonnegative().max(20_000),
+    runtime: runtimeInventorySchema,
+});
+export function laravelEvidence(check, processes) {
+    const incomplete = {
+        status: "inconclusive",
+        reason: "Laravel assembly projection is unsupported, malformed, empty or incomplete.",
+    };
+    if (processes.length !== 1)
+        return incomplete;
+    if (processes[0].exitCode === 3) {
+        try {
+            z.strictObject({
+                unavailable: z.literal("laravel-runtime"),
+                reason: z.literal("unsupported-version"),
+            }).parse(JSON.parse(processes[0].stdout));
+            return {
+                status: "unavailable",
+                reason: "The pinned Laravel runtime profile is not installed.",
+            };
+        }
+        catch {
+            return incomplete;
+        }
+    }
+    if (processes[0].exitCode !== 0)
+        return {
+            status: "error",
+            reason: "Laravel bootstrap or runtime collector failed.",
+        };
+    try {
+        const result = schema.parse(JSON.parse(processes[0].stdout));
+        const profile = laravelConfigSchema.parse(JSON.parse(check.commands[0].args[3]));
+        const runtime = result.runtime;
+        if (runtime.sourceFingerprint !== check.commands[0].args[4] ||
+            runtime.producer.name !== "checktrail.laravel-runtime" ||
+            runtime.producer.version !== "1.0.0" ||
+            runtime.assembly.name !== profile.assembly ||
+            runtime.assembly.environment !== profile.environment ||
+            runtime.collections.length !== 5 ||
+            new Set(runtime.collections.map((item) => item.kind)).size !== 5 ||
+            runtime.collections.reduce((sum, item) => sum + item.entries.length, 0) !== result.entryCount)
+            return incomplete;
+        for (const collection of runtime.collections) {
+            if (collection.ordered !== (collection.kind !== "bindings"))
+                return incomplete;
+            for (const entry of collection.entries) {
+                const value = attributes[collection.kind].parse(entry.attributes);
+                if (collection.kind === "routes") {
+                    const route = attributes.routes.parse(value);
+                    if (JSON.stringify(JSON.parse(entry.key)) !==
+                        JSON.stringify([route.domain, route.method, route.uri]))
+                        return incomplete;
+                }
+                else {
+                    const record = value;
+                    const expected = collection.kind === "listeners"
+                        ? `${record.type}:${record.event}`
+                        : collection.kind === "schedules"
+                            ? `${record.type}:${record.target}`
+                            : collection.kind === "bindings"
+                                ? record.type === "contextual"
+                                    ? `contextual:${record.consumer}:${record.abstract}`
+                                    : `${record.type}:${record.abstract}`
+                                : record.type === "global" || record.type === "priority"
+                                    ? record.type
+                                    : `${record.type}:${record.name}`;
+                    if (entry.key !== expected)
+                        return incomplete;
+                }
+            }
+        }
+        if (!runtime.collections.find((item) => item.kind === "routes").entries
+            .length ||
+            !runtime.collections.find((item) => item.kind === "bindings").entries
+                .length ||
+            ["global", "priority"].some((key) => runtime.collections
+                .find((item) => item.kind === "middleware")
+                .entries.filter((entry) => entry.key === key).length !== 1) ||
+            runtime.collections.some((item) => !item.complete))
+            return { ...incomplete, runtime };
+        return {
+            status: "passed",
+            reason: "Laravel testing bootstrap completed and all five declared assembly projections were captured; compare inventories to evaluate wiring changes.",
+            runtime,
+        };
+    }
+    catch {
+        return incomplete;
+    }
+}

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

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

package/dist/src/laravel-runner.js

@@ -0,0 +1,168 @@
+export const laravelRunner = String.raw `
+function rv_property(object $object, string $property): mixed {
+    return (new ReflectionProperty($object, $property))->getValue($object);
+}
+function rv_identity(mixed $value): string {
+    static $sources = [];
+    static $sourceBytes = 0;
+    if (is_string($value)) return $value;
+    if (is_array($value) && count($value) === 2 && isset($value[0], $value[1]) && is_string($value[1])) {
+        return (is_object($value[0]) ? get_class($value[0]) : $value[0]).'@'.$value[1];
+    }
+    if ($value instanceof Closure) {
+        $reflection = new ReflectionFunction($value);
+        $file = $reflection->getFileName();
+        if (!$file || !is_file($file)) throw new RuntimeException('Unsupported closure source');
+        $prefix = getcwd().DIRECTORY_SEPARATOR;
+        $vendor = dirname($GLOBALS['rv_autoload']).DIRECTORY_SEPARATOR;
+        $location = str_starts_with($file, $prefix) ? substr($file, strlen($prefix)) : (str_starts_with($file, $vendor) ? 'vendor/'.substr($file, strlen($vendor)) : null);
+        if ($location === null) throw new RuntimeException('Closure source outside project and local vendor');
+        if (!isset($sources[$file])) {
+            $bytes = file_get_contents($file, false, null, 0, 8 * 1024 * 1024 + 1);
+            $sourceBytes += strlen($bytes);
+            if (strlen($bytes) > 8 * 1024 * 1024 || $sourceBytes > 64 * 1024 * 1024) throw new RuntimeException('Closure source limit exceeded');
+            $sources[$file] = explode("\n", $bytes);
+        }
+        $lines = $sources[$file];
+        $source = implode("\n", array_slice($lines, $reflection->getStartLine() - 1, $reflection->getEndLine() - $reflection->getStartLine() + 1));
+        return 'closure:'.$location.':'.$reflection->getStartLine().':'.$reflection->getEndLine().':'.hash('sha256', $source);
+    }
+    if (is_object($value)) return get_class($value).'@__invoke';
+    throw new RuntimeException('Unsupported callable registration');
+}
+function rv_scalar_hash(mixed $value, int $depth = 0): string {
+    $walk = function (mixed $value, int $depth) use (&$walk): mixed {
+        if ($depth > 32) throw new RuntimeException('Registration data too deep');
+        if (is_array($value)) {
+            $result = [];
+            foreach ($value as $key => $item) $result[$key] = $walk($item, $depth + 1);
+            return $result;
+        }
+        if (is_null($value) || is_scalar($value)) return $value;
+        throw new RuntimeException('Unsupported registration data');
+    };
+    return hash('sha256', json_encode($walk($value, $depth), JSON_THROW_ON_ERROR));
+}
+function rv_collect(string $kind, bool $ordered, callable $read): array {
+    $entries = [];
+    try {
+        $read($entries);
+        return ['kind' => $kind, 'complete' => true, 'ordered' => $ordered, 'entries' => $entries];
+    } catch (Throwable $error) {
+        fwrite(STDERR, $kind.': '.get_class($error).': '.$error->getMessage().PHP_EOL);
+        return ['kind' => $kind, 'complete' => false, 'ordered' => $ordered, 'entries' => $entries];
+    }
+}
+function rv_add(array &$entries, string $key, array $attributes): void {
+    if (++$GLOBALS['rv_count'] > 20000) throw new RuntimeException('Assembly entry limit exceeded');
+    $entries[] = ['key' => $key, 'attributes' => (object) $attributes];
+}
+$rv_count = 0;
+$rv_temporary = null;
+$rv_autoload = $argv[1];
+ob_start(function ($text) { fwrite(STDERR, $text); return ''; }, 1);
+try {
+    require $rv_autoload;
+    if (!class_exists(Illuminate\Foundation\Application::class) || Illuminate\Foundation\Application::VERSION !== '13.32.0') {
+        fwrite(STDOUT, json_encode(['unavailable' => 'laravel-runtime', 'reason' => 'unsupported-version']));
+        exit(3);
+    }
+    $config = json_decode($argv[2], true, flags: JSON_THROW_ON_ERROR);
+    $rv_temporary = sys_get_temp_dir().'/checktrail-laravel-'.bin2hex(random_bytes(16));
+    if (!mkdir($rv_temporary, 0700)) throw new RuntimeException('Cannot create temporary cache directory');
+    register_shutdown_function(function () use ($rv_temporary) {
+        foreach (glob($rv_temporary.'/*') as $file) if (is_file($file) || is_link($file)) @unlink($file);
+        @rmdir($rv_temporary);
+    });
+    $cachePaths = [];
+    foreach (['CONFIG', 'ROUTES', 'EVENTS', 'SERVICES', 'PACKAGES'] as $kind) {
+        $key = 'APP_'.$kind.'_CACHE';
+        $cachePaths[$kind] = $rv_temporary.'/'.strtolower($kind).'.php';
+        putenv($key.'='.$cachePaths[$kind]);
+        $_ENV[$key] = $_SERVER[$key] = $cachePaths[$kind];
+    }
+    $app = require getcwd().'/bootstrap/app.php';
+    if (!$app instanceof Illuminate\Foundation\Application || realpath($app->basePath()) !== getcwd() || $app->hasBeenBootstrapped()) throw new RuntimeException('Unsupported application bootstrap');
+    $app->useEnvironmentPath($rv_temporary)->loadEnvironmentFrom('.env');
+    $http = $app->make(Illuminate\Contracts\Http\Kernel::class);
+    $console = $app->make(Illuminate\Contracts\Console\Kernel::class);
+    $console->bootstrap();
+    $console->all();
+    $http->bootstrap();
+    if ($app->environment() !== 'testing') throw new RuntimeException('Expected isolated testing environment');
+    foreach (['CONFIG' => 'getCachedConfigPath', 'ROUTES' => 'getCachedRoutesPath', 'EVENTS' => 'getCachedEventsPath', 'SERVICES' => 'getCachedServicesPath', 'PACKAGES' => 'getCachedPackagesPath'] as $kind => $method) {
+        if ($app->$method() !== $cachePaths[$kind]) throw new RuntimeException('Application changed protected cache paths');
+    }
+    $router = $app->make('router');
+    $dispatcher = $app->make('events');
+    $schedule = $app->make(Illuminate\Console\Scheduling\Schedule::class);
+    $collections = [];
+    $collections[] = rv_collect('routes', true, function (&$entries) use ($router) {
+        if (get_class($router) !== Illuminate\Routing\Router::class || get_class($router->getRoutes()) !== Illuminate\Routing\RouteCollection::class) throw new RuntimeException('Unsupported router or cached route collection');
+        foreach ($router->getRoutes() as $route) {
+            if (get_class($route) !== Illuminate\Routing\Route::class) throw new RuntimeException('Unsupported route class');
+            $middleware = array_map('rv_identity', $router->gatherRouteMiddleware($route));
+            foreach ($route->methods() as $method) {
+                rv_add($entries, json_encode([$route->getDomain(), $method, $route->uri()], JSON_THROW_ON_ERROR), [
+                    'domain' => $route->getDomain(), 'method' => $method, 'uri' => $route->uri(),
+                    'name' => $route->getName(), 'handler' => rv_identity($route->getAction('uses')),
+                    'middleware' => array_values($middleware), 'constraintsHash' => rv_scalar_hash($route->wheres), 'defaultsHash' => rv_scalar_hash($route->defaults),
+                ]);
+            }
+        }
+        if (!$entries) throw new RuntimeException('No served routes');
+    });
+    $collections[] = rv_collect('middleware', true, function (&$entries) use ($http) {
+        foreach (['global' => $http->getGlobalMiddleware(), 'priority' => $http->getMiddlewarePriority()] as $kind => $values) rv_add($entries, $kind, ['type' => $kind, 'stack' => array_values(array_map('rv_identity', $values))]);
+        foreach ($http->getMiddlewareGroups() as $name => $values) rv_add($entries, 'group:'.$name, ['type' => 'group', 'name' => $name, 'stack' => array_values(array_map('rv_identity', $values))]);
+        foreach ($http->getMiddlewareAliases() as $name => $value) rv_add($entries, 'alias:'.$name, ['type' => 'alias', 'name' => $name, 'target' => rv_identity($value)]);
+    });
+    $collections[] = rv_collect('listeners', true, function (&$entries) use ($dispatcher) {
+        if (get_class($dispatcher) !== Illuminate\Events\Dispatcher::class) throw new RuntimeException('Unsupported event dispatcher');
+        foreach (['exact' => $dispatcher->getRawListeners(), 'wildcard' => rv_property($dispatcher, 'wildcards')] as $kind => $events) {
+            foreach ($events as $event => $listeners) foreach ($listeners as $listener) rv_add($entries, $kind.':'.$event, ['type' => $kind, 'event' => $event, 'listener' => rv_identity($listener)]);
+        }
+    });
+    $collections[] = rv_collect('schedules', true, function (&$entries) use ($schedule) {
+        if (get_class($schedule) !== Illuminate\Console\Scheduling\Schedule::class) throw new RuntimeException('Unsupported scheduler');
+        foreach ($schedule->events() as $event) {
+            if (!in_array(get_class($event), [Illuminate\Console\Scheduling\Event::class, Illuminate\Console\Scheduling\CallbackEvent::class], true)) throw new RuntimeException('Unsupported scheduled event');
+            $callback = $event instanceof Illuminate\Console\Scheduling\CallbackEvent;
+            $target = $callback ? rv_identity(rv_property($event, 'callback')) : $event->command;
+            $attributes = ['type' => $callback ? 'callback' : 'command', 'target' => $target];
+            foreach (['expression', 'repeatSeconds', 'user', 'environments', 'evenInMaintenanceMode', 'evenWhenPaused', 'withoutOverlapping', 'releaseOnTerminationSignals', 'onOneServer', 'expiresAt', 'runInBackground', 'description', 'output', 'shouldAppendOutput'] as $field) $attributes[$field] = $event->$field;
+            $attributes['timezone'] = $event->timezone instanceof DateTimeZone ? $event->timezone->getName() : $event->timezone;
+            $attributes['parametersHash'] = rv_scalar_hash($callback ? rv_property($event, 'parameters') : []);
+            foreach (['filters', 'rejects', 'beforeCallbacks', 'afterCallbacks'] as $field) $attributes[$field] = array_values(array_map('rv_identity', rv_property($event, $field)));
+            $attributes['mutex'] = get_class($event->mutex);
+            $attributes['mutexNameResolver'] = $event->mutexNameResolver === null ? null : rv_identity($event->mutexNameResolver);
+            $attributes['attributesHash'] = rv_scalar_hash($event->attributes);
+            rv_add($entries, ($callback ? 'callback:' : 'command:').$target, $attributes);
+        }
+    });
+    $collections[] = rv_collect('bindings', false, function (&$entries) use ($app) {
+        $factoryMethod = new ReflectionMethod(Illuminate\Container\Container::class, 'getClosure');
+        $scoped = rv_property($app, 'scopedInstances');
+        foreach ($app->getBindings() as $abstract => $binding) {
+            $factory = $binding['concrete'];
+            $identity = rv_identity($factory);
+            if ($factory instanceof Closure) {
+                $reflection = new ReflectionFunction($factory);
+                if ($reflection->getFileName() === $factoryMethod->getFileName() && $reflection->getStartLine() >= $factoryMethod->getStartLine() && $reflection->getEndLine() <= $factoryMethod->getEndLine()) $identity = $reflection->getStaticVariables()['concrete'];
+            }
+            rv_add($entries, 'factory:'.$abstract, ['type' => 'factory', 'abstract' => $abstract, 'target' => $identity, 'shared' => $binding['shared'], 'scoped' => in_array($abstract, $scoped, true)]);
+        }
+        foreach (rv_property($app, 'aliases') as $alias => $abstract) rv_add($entries, 'alias:'.$alias, ['type' => 'alias', 'abstract' => $alias, 'target' => $abstract]);
+        foreach ($app->contextual as $consumer => $bindings) foreach ($bindings as $abstract => $value) rv_add($entries, 'contextual:'.$consumer.':'.$abstract, ['type' => 'contextual', 'consumer' => $consumer, 'abstract' => $abstract, 'target' => rv_identity($value)]);
+        foreach (rv_property($app, 'instances') as $abstract => $instance) rv_add($entries, 'instance:'.$abstract, ['type' => 'instance', 'abstract' => $abstract, 'target' => is_object($instance) ? get_class($instance) : 'scalar:'.rv_scalar_hash($instance)]);
+    });
+    $result = ['version' => 1, 'laravelVersion' => Illuminate\Foundation\Application::VERSION, 'entryCount' => array_sum(array_map(fn ($collection) => count($collection['entries']), $collections)), 'runtime' => [
+        'schemaVersion' => 1, 'format' => 'runtime-inventory', 'producer' => ['name' => 'checktrail.laravel-runtime', 'version' => '1.0.0'],
+        'assembly' => ['name' => $config['assembly'], 'environment' => $config['environment']], 'sourceFingerprint' => $argv[3], 'capturedAt' => gmdate('Y-m-d\TH:i:s\Z'), 'collections' => $collections,
+    ]];
+    fwrite(STDOUT, json_encode($result, JSON_THROW_ON_ERROR | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
+} catch (Throwable $error) {
+    fwrite(STDERR, get_class($error).': '.$error->getMessage().PHP_EOL);
+    exit(2);
+}
+`;

package/dist/src/laravel.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { Check, Inventory, Project } from "./types.js";
+export declare const laravelConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    assembly: z.ZodString;
+    environment: z.ZodLiteral<"testing">;
+}, z.core.$strict>;
+export declare function laravelCheck(source: Inventory, project: Project): Promise<Check>;