@astrale-os/sdk 0.5.0-beta.13 → 0.5.0-beta.130

package/dist/tooling/cli/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@astrale-os/sdk/cli` — the `astrale-domain` CLI
+ * (dev | build | deploy | test | lint | package), explicit dotenv boundary, and admitted
+ * development-session file representation.
+ *
+ * Node-only: the CLI imports `node:fs`/`node:module`/`node:url` and runs under
+ * Bun (it imports the project's `astrale.config.ts` directly). This subpath is
+ * deliberately NOT re-exported from the package barrel — pulling it into the
+ * isomorphic `.` entry would poison browser/worker bundlers that traverse every
+ * re-export (the same rule that keeps `./server` and `./deploy` off the barrel).
+ * The bin lives at `./bin`.
+ */
+export { run } from './run.js';
+export { loadDeclaredSecrets } from './dotenv.js';
+export { DEVELOPMENT_SESSION_FILE_VERSION, acceptDevelopmentSessionFileV1, } from './development/session-file.js';
+export type { DevelopmentSessionFileV1, DevelopmentSessionPhaseV1, DevelopmentSessionProjectV1, DevelopmentSessionReleaseV1, } from './development/session-file.js';

package/dist/tooling/cli/index.js

@@ -0,0 +1,15 @@
+/**
+ * `@astrale-os/sdk/cli` — the `astrale-domain` CLI
+ * (dev | build | deploy | test | lint | package), explicit dotenv boundary, and admitted
+ * development-session file representation.
+ *
+ * Node-only: the CLI imports `node:fs`/`node:module`/`node:url` and runs under
+ * Bun (it imports the project's `astrale.config.ts` directly). This subpath is
+ * deliberately NOT re-exported from the package barrel — pulling it into the
+ * isomorphic `.` entry would poison browser/worker bundlers that traverse every
+ * re-export (the same rule that keeps `./server` and `./deploy` off the barrel).
+ * The bin lives at `./bin`.
+ */
+export { run } from './run.js';
+export { loadDeclaredSecrets } from './dotenv.js';
+export { DEVELOPMENT_SESSION_FILE_VERSION, acceptDevelopmentSessionFileV1, } from './development/session-file.js';

package/dist/tooling/cli/installation/index.d.ts

@@ -0,0 +1,2 @@
+export { reconcileInstallation } from './reconcile.js';
+export type { AstraleCommandResult, InstallationDependencies, InstallationEvidence, } from './reconcile.js';

package/dist/tooling/cli/installation/index.js

@@ -0,0 +1 @@
+export { reconcileInstallation } from './reconcile.js';

package/dist/tooling/cli/installation/observation.d.ts

@@ -0,0 +1,10 @@
+export interface InstallationObservation {
+    readonly origin: string;
+    readonly revision: string;
+    readonly issuer: string;
+    readonly generation: string;
+    readonly etag: string;
+}
+/** Admit exact installed Release evidence returned by Kernel introspection. */
+export declare function decodeInstallationObservation(input: string): InstallationObservation;
+export declare function canonicalIssuer(input: string): string;

package/dist/tooling/cli/installation/observation.js

@@ -0,0 +1,44 @@
+/** Admit exact installed Release evidence returned by Kernel introspection. */
+export function decodeInstallationObservation(input) {
+    let decoded;
+    try {
+        decoded = JSON.parse(input);
+    }
+    catch (cause) {
+        throw new TypeError('Astrale introspection did not return one JSON value.', { cause });
+    }
+    const root = record(decoded);
+    const publication = record(root.publication);
+    const identity = record(publication.identity);
+    if (typeof root.origin !== 'string' ||
+        typeof root.revision !== 'string' ||
+        typeof root.generation !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/u.test(root.generation) ||
+        publication.origin !== root.origin ||
+        publication.revision !== root.revision ||
+        typeof identity.issuer !== 'string' ||
+        typeof publication.etag !== 'string' ||
+        !/^sha256:[0-9a-f]{64}$/u.test(publication.etag)) {
+        throw new TypeError('Astrale introspection returned invalid installed Domain evidence.');
+    }
+    return Object.freeze({
+        origin: root.origin,
+        revision: root.revision,
+        issuer: canonicalIssuer(identity.issuer),
+        generation: root.generation,
+        etag: publication.etag,
+    });
+}
+export function canonicalIssuer(input) {
+    const url = new URL(input);
+    if (url.href !== url.origin && url.href !== `${url.origin}/`) {
+        throw new TypeError('Release issuer must be one canonical origin.');
+    }
+    return url.origin;
+}
+function record(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('Astrale introspection returned invalid installed Domain evidence.');
+    }
+    return input;
+}

package/dist/tooling/cli/installation/reconcile.d.ts

@@ -0,0 +1,32 @@
+import type { InstallationTarget } from '../../../deployment/adapter/index.js';
+import type { Release } from '../../../deployment/release/index.js';
+import type { AstraleProcessResult } from '../astrale/process.js';
+export interface InstallationEvidence {
+    readonly status: 'unchanged' | 'installed' | 'upgraded';
+    readonly instance: string;
+    readonly origin: string;
+    readonly issuer: string;
+    readonly revision: string;
+    readonly generation: string;
+    readonly etag: string;
+}
+export type AstraleCommandResult = AstraleProcessResult;
+export interface InstallationDependencies {
+    run(input: {
+        readonly executable: string;
+        readonly args: readonly string[];
+        readonly projectDir: string;
+        readonly signal: AbortSignal;
+        readonly timeoutMs: number;
+    }): Promise<AstraleCommandResult>;
+}
+/** Reconcile one observed Release without ever replacing a different issuer. */
+export declare function reconcileInstallation(input: {
+    readonly projectDir: string;
+    readonly target: InstallationTarget;
+    readonly executable: string;
+    readonly identity?: string;
+    readonly credential?: string;
+    readonly release: Release;
+    readonly signal: AbortSignal;
+}, dependencies?: InstallationDependencies): Promise<InstallationEvidence>;

package/dist/tooling/cli/installation/reconcile.js

@@ -0,0 +1,122 @@
+import { astraleAuthorityArguments } from '../astrale/authority.js';
+import { AstraleCliError, isDomainNotInstalledFailure, astraleFailure } from '../astrale/failure.js';
+import { runAstrale } from '../astrale/process.js';
+import { canonicalIssuer, decodeInstallationObservation } from './observation.js';
+/** Reconcile one observed Release without ever replacing a different issuer. */
+export async function reconcileInstallation(input, dependencies = {
+    run: runAstrale,
+}) {
+    const origin = input.release.publication.origin;
+    const revision = input.release.publication.schema.revision;
+    const issuer = canonicalIssuer(input.release.addressing.issuer);
+    const etag = input.release.publication.etag;
+    const identity = input.identity ?? input.target.identity;
+    const authority = astraleAuthorityArguments({
+        ...(identity === undefined ? {} : { identity }),
+        ...(input.credential === undefined ? {} : { credential: input.credential }),
+    });
+    const executable = input.executable;
+    const before = await observe(input, origin, authority, executable, dependencies);
+    if (before !== undefined) {
+        assertIdentity(before, { origin, issuer });
+        if (before.revision === revision && before.etag === etag) {
+            return evidence('unchanged', input.target.instance, before);
+        }
+    }
+    let installationFailure;
+    try {
+        const installed = await dependencies.run({
+            executable,
+            projectDir: input.projectDir,
+            signal: input.signal,
+            timeoutMs: 250_000,
+            args: [
+                '--ci',
+                '--no-prompt',
+                'domain',
+                'install',
+                issuer,
+                '--direct',
+                '--allow-identity-override',
+                '-i',
+                input.target.instance,
+                '--json',
+                '--timeout',
+                '240000',
+                ...authority,
+            ],
+        });
+        if (installed.code !== 0)
+            installationFailure = astraleFailure('domain install', installed);
+    }
+    catch (cause) {
+        installationFailure = cause;
+    }
+    let after;
+    try {
+        after = await observe(input, origin, authority, executable, dependencies);
+    }
+    catch (cause) {
+        throw installationError(installationFailure === undefined ? [cause] : [installationFailure, cause], 'Domain installation outcome is unknown because reconciliation failed.');
+    }
+    if (installationFailure !== undefined && after === undefined) {
+        throw installationError([installationFailure], 'Domain installation failed and no installed Release was observed.');
+    }
+    if (after === undefined)
+        throw new TypeError('Installed Domain was absent after installation.');
+    try {
+        assertIdentity(after, { origin, issuer });
+        if (after.revision !== revision || after.etag !== etag) {
+            throw new TypeError('Installed Domain evidence differs from the deployed Release.');
+        }
+    }
+    catch (cause) {
+        if (installationFailure === undefined)
+            throw cause;
+        throw installationError([installationFailure, cause], 'Domain installation failed with a different observed Release.');
+    }
+    return evidence(before === undefined ? 'installed' : 'upgraded', input.target.instance, after);
+}
+function installationError(causes, message) {
+    const diagnostics = causes
+        .filter((cause) => cause instanceof AstraleCliError)
+        .map((cause) => cause.message);
+    return new AggregateError(causes, [message, ...diagnostics].join(' '));
+}
+async function observe(input, origin, authority, executable, dependencies) {
+    const result = await dependencies.run({
+        executable,
+        projectDir: input.projectDir,
+        signal: input.signal,
+        timeoutMs: 70_000,
+        args: [
+            '--ci',
+            '--no-prompt',
+            'introspect',
+            origin,
+            '-i',
+            input.target.instance,
+            '--json',
+            '--timeout',
+            '60000',
+            ...authority,
+        ],
+    });
+    if (result.code !== 0) {
+        if (isDomainNotInstalledFailure(result.stderr))
+            return undefined;
+        throw astraleFailure(`introspect ${origin}`, result);
+    }
+    return decodeInstallationObservation(result.stdout);
+}
+function assertIdentity(observed, expected) {
+    if (observed.origin !== expected.origin) {
+        throw new TypeError('Installed Domain evidence has a different origin.');
+    }
+    if (observed.issuer !== expected.issuer) {
+        throw new TypeError(`Installed Domain issuer ${observed.issuer} differs from deployment issuer ${expected.issuer}; refusing replacement.`);
+    }
+}
+function evidence(status, instance, observed) {
+    return Object.freeze({ status, instance, ...observed });
+}

package/dist/tooling/cli/log.d.ts

@@ -0,0 +1,10 @@
+/** CLI output helpers and ANSI colours for the one project command owner. */
+export declare const GREEN = "\u001B[32m";
+export declare const DIM = "\u001B[2m";
+export declare const BOLD = "\u001B[1m";
+export declare const YELLOW = "\u001B[33m";
+export declare const RED = "\u001B[31m";
+export declare const RESET = "\u001B[0m";
+export declare function info(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;

package/dist/tooling/cli/log.js

@@ -0,0 +1,16 @@
+/** CLI output helpers and ANSI colours for the one project command owner. */
+export const GREEN = '\x1b[32m';
+export const DIM = '\x1b[2m';
+export const BOLD = '\x1b[1m';
+export const YELLOW = '\x1b[33m';
+export const RED = '\x1b[31m';
+export const RESET = '\x1b[0m';
+export function info(msg) {
+    process.stdout.write(`${DIM}›${RESET} ${msg}\n`);
+}
+export function warn(msg) {
+    process.stderr.write(`${YELLOW}!${RESET} ${msg}\n`);
+}
+export function error(msg) {
+    process.stderr.write(`${RED}✗${RESET} ${msg}\n`);
+}

package/dist/tooling/cli/orchestrate.d.ts

@@ -0,0 +1,7 @@
+import { type ParsedArgs } from './arguments.js';
+import { develop } from './development/develop.js';
+export declare function run(argv: readonly string[]): Promise<number>;
+export declare function executeDevelopmentCommand(parsed: ParsedArgs, input: {
+    readonly configPath: string;
+    readonly projectDir: string;
+}, execute?: typeof develop): Promise<number>;

package/dist/tooling/cli/orchestrate.js

@@ -0,0 +1,198 @@
+import { existsSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { admitRuntime, compile, resolveRuntime, verifyDeployment, verifyPreflight, } from '../../deployment/index.js';
+import { packageDomain } from '../packaging/index.js';
+import { parseArgs } from './arguments.js';
+import { resolveCompatibleAstrale } from './astrale/version.js';
+import { BunRequiredError } from './bun.js';
+import { develop } from './development/develop.js';
+import { loadDeclaredSecrets } from './dotenv.js';
+import { reconcileEnvironmentRelease } from './environment-release.js';
+import { ERROR_USAGE, helpRequest, helpText } from './help.js';
+import { error, info } from './log.js';
+import { importModule, loadProject, runtimeEntrypoint, selectEnvironment } from './project.js';
+import { executeTests } from './test.js';
+const CONFIG_NAMES = ['astrale.config.ts', 'astrale.config.js', 'astrale.config.mjs'];
+export async function run(argv) {
+    const requestedHelp = helpRequest(argv);
+    if (requestedHelp !== undefined) {
+        process.stdout.write(helpText(requestedHelp.command));
+        return 0;
+    }
+    let parsed;
+    try {
+        parsed = parseArgs(argv);
+    }
+    catch (cause) {
+        usage(cause instanceof Error ? cause.message : String(cause));
+        return 2;
+    }
+    if (parsed.command === 'lint')
+        return lint(parsed);
+    if (parsed.command === 'package') {
+        const result = await packageDomain({ projectDir: process.cwd() });
+        info(`Packaged ${result.declarations} public declarations (${result.replacements} references normalized).`);
+        return 0;
+    }
+    if (parsed.command === 'test' && parsed.env === '') {
+        return executeTests(parsed.suite === undefined ? {} : { suite: parsed.suite });
+    }
+    if (!process.versions.bun) {
+        throw new BunRequiredError();
+    }
+    const projectDir = process.cwd();
+    const configPath = findConfig(projectDir);
+    if (configPath === undefined) {
+        error(`No astrale.config.ts found in ${projectDir}.`);
+        return 1;
+    }
+    if (parsed.command === 'dev') {
+        return executeDevelopmentCommand(parsed, { configPath, projectDir });
+    }
+    const project = await loadProject(configPath);
+    if (parsed.command === 'test') {
+        selectEnvironment(project, parsed.env);
+        return executeTests({
+            environment: parsed.env,
+            ...(parsed.suite === undefined ? {} : { suite: parsed.suite }),
+        });
+    }
+    const build = compile(project.application);
+    const resolved = await resolveRuntime(runtimeEntrypoint(project), (path) => importModule(resolve(dirname(configPath), path)));
+    admitRuntime({ runtime: build.runtime }, resolved);
+    if (parsed.command === 'build') {
+        info(`Built ${build.schema.compiled.root.origin} (${build.schema.compiled.root.revision}).`);
+        return 0;
+    }
+    const environment = selectEnvironment(project, parsed.env);
+    const adapter = environment.deployment.adapter;
+    const parameters = environment.deployment.parameters;
+    const lifecycle = deploymentLifecycle();
+    try {
+        const source = await adapter.prepare(parameters, {
+            projectDir,
+            environment: parsed.env,
+            ...(environment.installation === undefined ? {} : { installation: environment.installation }),
+            mode: 'release',
+            signal: lifecycle.signal,
+            build,
+            runtime: resolved,
+        });
+        const artifact = verifyPreflight({ build, runtime: resolved, source });
+        const secrets = secretsFor(adapter, parameters, projectDir, resolved.runtime);
+        const installationExecutable = environment.installation === undefined || parsed.deployOnly
+            ? undefined
+            : await resolveCompatibleAstrale({ projectDir, signal: lifecycle.signal });
+        const deployed = await adapter.deploy(parameters, {
+            projectDir,
+            environment: parsed.env,
+            ...(environment.installation === undefined ? {} : { installation: environment.installation }),
+            ...(parsed.identity === undefined ? {} : { identity: parsed.identity }),
+            secrets,
+            artifact,
+            signal: lifecycle.signal,
+        });
+        const result = verifyDeployment(artifact, deployed);
+        if (result.status === 'failed') {
+            error(`Deployment failed during ${result.phase}: ${result.error.message}`);
+            return 1;
+        }
+        info(`Domain: ${result.release.publication.origin}`);
+        info(`Environment: ${parsed.env}`);
+        info(`Adapter: ${adapter.name}@${adapter.version}`);
+        info(`Deployment: ${result.progress.provider.evidence.deployment}`);
+        if (result.progress.provider.evidence.preflight !== undefined) {
+            info(`Preflight: ${result.progress.provider.evidence.preflight}; public readiness verified`);
+        }
+        info(`Public: ${result.release.addressing.issuer}`);
+        info(`Publication: ${result.release.publication.schema.revision} · ${result.release.publication.etag}`);
+        const installed = await reconcileEnvironmentRelease({
+            projectDir,
+            environment: parsed.env,
+            adapter,
+            deployment: result,
+            ...(environment.installation === undefined ? {} : { installation: environment.installation }),
+            deployOnly: parsed.deployOnly ?? false,
+            ...(installationExecutable === undefined ? {} : { installationExecutable }),
+            ...(parsed.identity === undefined ? {} : { identity: parsed.identity }),
+            signal: lifecycle.signal,
+        });
+        if (installed === undefined) {
+            info('Installation: skipped');
+        }
+        else {
+            info(`Installation: ${installed.instance} · ${installed.status}`);
+        }
+        info('Ready: deployment verified');
+        return 0;
+    }
+    finally {
+        lifecycle.dispose();
+    }
+}
+export function executeDevelopmentCommand(parsed, input, execute = develop) {
+    if (parsed.command !== 'dev')
+        throw new TypeError('Development execution requires the dev command.');
+    return execute({
+        configPath: input.configPath,
+        projectDir: input.projectDir,
+        environment: parsed.env,
+        deployOnly: parsed.deployOnly ?? false,
+        ...(parsed.identity === undefined ? {} : { identity: parsed.identity }),
+        ...(parsed.credentialFile === undefined ? {} : { credentialFile: parsed.credentialFile }),
+        ...(parsed.sessionFile === undefined ? {} : { sessionFile: parsed.sessionFile }),
+        ...(parsed.secretsFile === undefined ? {} : { secretsFile: parsed.secretsFile }),
+    });
+}
+async function lint(parsed) {
+    const { formatLintResult, lintDomain, LinterToolError } = await import('../linter/index.js');
+    try {
+        const result = await lintDomain({
+            root: process.cwd(),
+            fix: parsed.fix ?? false,
+        });
+        process.stdout.write(formatLintResult(result, parsed.format));
+        return result.exitCode;
+    }
+    catch (cause) {
+        if (cause instanceof LinterToolError) {
+            error(cause.message);
+            return cause.exitCode;
+        }
+        throw cause;
+    }
+}
+function secretsFor(adapter, parameters, projectDir, runtime) {
+    const file = adapter.secretsFile?.(parameters);
+    if (file === undefined)
+        return Object.freeze({});
+    const path = isAbsolute(file) ? file : join(projectDir, file);
+    // An Integration-free Runtime has no Providers and therefore no author-owned
+    // environment secrets. Adapter-owned secrets, such as the signing identity,
+    // are resolved separately by the adapter and must not make this file required.
+    if (Object.keys(runtime.integrations).length === 0 && !existsSync(path)) {
+        return Object.freeze({});
+    }
+    return Object.freeze(loadDeclaredSecrets(path, file));
+}
+function findConfig(projectDir) {
+    return CONFIG_NAMES.map((name) => join(projectDir, name)).find(existsSync);
+}
+function deploymentLifecycle() {
+    const controller = new AbortController();
+    const stop = () => controller.abort(new Error('Deployment interrupted.'));
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+    return Object.freeze({
+        signal: controller.signal,
+        dispose() {
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+        },
+    });
+}
+function usage(message) {
+    if (message !== undefined)
+        error(message);
+    process.stderr.write(ERROR_USAGE);
+}

package/dist/tooling/cli/project.d.ts

@@ -0,0 +1,17 @@
+import type { Application } from '../../application/index.js';
+import type { Requirements } from '../../application/requirements/index.js';
+import type { Routes } from '../../application/routes/index.js';
+import type { Runtime } from '../../application/runtime/index.js';
+import type { Frontend } from '../../application/view/index.js';
+import type { Deployment } from '../../deployment/index.js';
+import type { schema } from '../../platform/schema/index.js';
+import type { Project, ProjectEnvironment } from '../../project/index.js';
+import type { Tests } from '../../testing/index.js';
+export type LoadedApplication = Application<schema.DomainSchema, Runtime, Frontend<schema.DomainSchema> | undefined, Routes | undefined, Requirements | undefined>;
+export type LoadedDeployment = Deployment<object>;
+export type LoadedEnvironment = ProjectEnvironment<LoadedDeployment>;
+export type LoadedProject = Project<LoadedApplication, Readonly<Record<string, LoadedEnvironment>>, Tests | undefined>;
+export declare function loadProject(path: string): Promise<LoadedProject>;
+export declare function selectEnvironment(project: LoadedProject, name: string): LoadedEnvironment;
+export declare function runtimeEntrypoint(project: LoadedProject): import("../../deployment/index.js").RuntimeReference;
+export declare function importModule(path: string): Promise<unknown>;

package/dist/tooling/cli/project.js

@@ -0,0 +1,18 @@
+import { pathToFileURL } from 'node:url';
+import { runtime } from '../../deployment/index.js';
+import { admitProjectModule } from '../../project/index.js';
+export async function loadProject(path) {
+    return admitProjectModule(await importModule(path));
+}
+export function selectEnvironment(project, name) {
+    if (Object.hasOwn(project.environments, name))
+        return project.environments[name];
+    const known = Object.keys(project.environments).sort();
+    throw new TypeError(`Project has no Environment ${name}; known Environments: ${known.join(', ') || '(none)'}.`);
+}
+export function runtimeEntrypoint(project) {
+    return runtime(project.entrypoints?.runtime ?? './runtime.ts');
+}
+export function importModule(path) {
+    return import(`${pathToFileURL(path).href}?sdk=${Date.now()}`);
+}

package/dist/tooling/cli/run.d.ts

@@ -0,0 +1 @@
+export { run } from './orchestrate.js';

package/dist/tooling/cli/run.js

@@ -0,0 +1 @@
+export { run } from './orchestrate.js';

package/dist/tooling/cli/source.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import './bin.js';

package/dist/tooling/cli/source.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import './bin.js';

package/dist/tooling/cli/test.d.ts

@@ -0,0 +1,12 @@
+import { spawn } from 'node:child_process';
+export interface TestExecution {
+    readonly environment?: string;
+    readonly suite?: string;
+}
+interface TestRunner {
+    readonly executable: string;
+    readonly arguments: readonly string[];
+}
+/** Run the Project's ordinary test runner, optionally targeting one observed Environment. */
+export declare function executeTests(input: TestExecution, start?: typeof spawn, runner?: TestRunner): Promise<number>;
+export {};

package/dist/tooling/cli/test.js

@@ -0,0 +1,47 @@
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+/** Run the Project's ordinary test runner, optionally targeting one observed Environment. */
+export function executeTests(input, start = spawn, runner = projectVitest()) {
+    const arguments_ = ['run', '--config', 'vitest.config.ts'];
+    if (input.suite !== undefined)
+        arguments_.push('--project', input.suite);
+    const environment = { ...process.env };
+    if (input.environment === undefined)
+        delete environment.ASTRALE_PROJECT_ENVIRONMENT;
+    else
+        environment.ASTRALE_PROJECT_ENVIRONMENT = input.environment;
+    return new Promise((resolve, reject) => {
+        const child = start(runner.executable, [...runner.arguments, ...arguments_], {
+            stdio: 'inherit',
+            env: environment,
+        });
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            if (signal !== null) {
+                reject(new Error(`Project tests stopped by ${signal}.`));
+            }
+            else {
+                resolve(code ?? 1);
+            }
+        });
+    });
+}
+function projectVitest() {
+    const projectRequire = createRequire(join(process.cwd(), 'package.json'));
+    const manifestPath = projectRequire.resolve('vitest/package.json');
+    const manifest = projectRequire(manifestPath);
+    const relative = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.vitest;
+    if (relative === undefined ||
+        relative.length === 0 ||
+        isAbsolute(relative) ||
+        relative.split(/[\\/]/u).includes('..')) {
+        throw new TypeError('Project Vitest package has no contained executable.');
+    }
+    return Object.freeze({
+        executable: process.versions.bun === undefined
+            ? process.execPath
+            : (process.env.npm_node_execpath ?? 'node'),
+        arguments: Object.freeze([resolve(dirname(manifestPath), relative)]),
+    });
+}

package/dist/tooling/linter/adapters/typescript/discover.d.ts

@@ -0,0 +1,3 @@
+import type { DomainPolicy } from '../../policy/index.js';
+import type { SourceProject } from './index.js';
+export declare function discoverProject(root: string, policy: DomainPolicy, signal?: AbortSignal): Promise<SourceProject>;