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

package/dist/tooling/cli/development/develop.js

@@ -0,0 +1,240 @@
+import { rm, rmdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { resolveAstraleInstanceIssuer } from '../astrale/instance.js';
+import { resolveCompatibleAstrale } from '../astrale/version.js';
+import { loadPrivateCredentialFile } from '../credential.js';
+import { loadPrivateSecretsFile } from '../dotenv.js';
+import { error, info } from '../log.js';
+import { DevelopmentCandidateBuilder, discoverRuntimePath, sameDeploymentCandidate, sameEnvironment, } from './candidate.js';
+import { deployDevelopmentCandidate } from './deployment.js';
+import { DevelopmentLifecycle } from './lifecycle.js';
+import { acquireProjectLock } from './project-lock.js';
+import { LatestRebuild } from './rebuild.js';
+import { developmentReleaseEvidence } from './release-evidence.js';
+import { reportDevelopmentDeployment } from './report.js';
+import { DevelopmentSessionFileWriter } from './session-file.js';
+import { watchSources } from './source-watch.js';
+import { acquireDevelopmentTargetLock } from './target-lock.js';
+import { DevelopmentView } from './view.js';
+/** Watch one Project Environment and serialize complete remote deployment generations. */
+export async function develop(input) {
+    const lifecycle = new DevelopmentLifecycle();
+    let sessionFile;
+    let lock;
+    let targetLock;
+    let view;
+    let installationExecutable;
+    let installationIssuer;
+    let sourceWatch;
+    let rebuild;
+    let current;
+    let lastEvidence;
+    let failure;
+    const cleanup = [];
+    try {
+        if (input.sessionFile !== undefined) {
+            sessionFile = await DevelopmentSessionFileWriter.create(input.sessionFile);
+        }
+        lock = await acquireProjectLock({
+            projectRoot: input.projectDir,
+            environment: input.environment,
+        });
+        const overrideSecrets = input.secretsFile === undefined
+            ? undefined
+            : Object.freeze(loadPrivateSecretsFile(input.secretsFile));
+        const credential = input.credentialFile === undefined
+            ? undefined
+            : loadPrivateCredentialFile(input.credentialFile);
+        const runtimePath = await discoverRuntimePath(input.configPath);
+        const builder = new DevelopmentCandidateBuilder({
+            ...input,
+            runtimePath,
+            overrideSecrets,
+        });
+        current = await builder.prepare(lifecycle.signal);
+        if (credential !== undefined && current.installation?.identity !== undefined) {
+            throw new TypeError('--credential-file cannot be combined with the Environment installation identity.');
+        }
+        if (sessionFile !== undefined && (current.installation === undefined || input.deployOnly)) {
+            throw new TypeError('--session-file requires an Environment installation that is active for this development session.');
+        }
+        info(`Domain: ${current.artifact.build.schema.compiled.root.origin}`);
+        if (current.installation !== undefined && !input.deployOnly) {
+            installationExecutable = await resolveCompatibleAstrale({
+                projectDir: input.projectDir,
+                signal: lifecycle.signal,
+            });
+            installationIssuer = await resolveAstraleInstanceIssuer({
+                executable: installationExecutable,
+                projectDir: input.projectDir,
+                instance: current.installation.instance,
+                signal: lifecycle.signal,
+            });
+            targetLock = await acquireDevelopmentTargetLock({
+                issuer: installationIssuer,
+                origin: current.artifact.build.schema.compiled.root.origin,
+            });
+            view = new DevelopmentView({
+                executable: installationExecutable,
+                projectDir: input.projectDir,
+                instance: current.installation.instance,
+                ...(credential === undefined
+                    ? { identity: input.identity ?? current.installation.identity }
+                    : { credential }),
+            });
+            if (current.artifact.build.frontend !== undefined)
+                await view.prepare(lifecycle.signal);
+        }
+        const first = await deployDevelopmentCandidate(current, { ...input, credential, installationExecutable }, lifecycle.signal);
+        lastEvidence =
+            first.installation === undefined ? undefined : developmentReleaseEvidence(first.installation);
+        await sessionFile?.transition('ready', lastEvidence);
+        reportDevelopmentDeployment(first.deployment, first.installation, current.adapter, input);
+        await refreshView(view, first.deployment.release, lifecycle.signal);
+        let restartReported = false;
+        rebuild = new LatestRebuild({
+            async prepare(_ignored, signal) {
+                info(`Rebuilding: ${input.environment}`);
+                if (lastEvidence !== undefined)
+                    await sessionFile?.transition('updating', lastEvidence);
+                return builder.prepare(signal);
+            },
+            async commit(candidate, signal) {
+                if (!sameEnvironment(current, candidate)) {
+                    restartReported = true;
+                    throw new Error('Project Environment configuration changed; restart pnpm dev to apply it.');
+                }
+                if (sameDeploymentCandidate(current, candidate)) {
+                    current = candidate;
+                    await sessionFile?.transition('ready', lastEvidence);
+                    sourceWatch?.update(candidate.sources);
+                    return;
+                }
+                if (installationIssuer !== undefined && candidate.installation !== undefined) {
+                    await resolveAstraleInstanceIssuer({
+                        executable: installationExecutable,
+                        projectDir: input.projectDir,
+                        instance: candidate.installation.instance,
+                        expectedIssuer: installationIssuer,
+                        signal,
+                    });
+                }
+                if (candidate.artifact.build.frontend !== undefined)
+                    await view?.prepare(signal);
+                const deployed = await deployDevelopmentCandidate(candidate, { ...input, credential, installationExecutable }, signal);
+                current = candidate;
+                lastEvidence =
+                    deployed.installation === undefined
+                        ? undefined
+                        : developmentReleaseEvidence(deployed.installation);
+                await sessionFile?.transition('ready', lastEvidence);
+                sourceWatch?.update(candidate.sources);
+                info(`Updated: ${candidate.artifact.build.schema.compiled.root.revision}`);
+                reportDevelopmentDeployment(deployed.deployment, deployed.installation, candidate.adapter, input);
+                await refreshView(view, deployed.deployment.release, signal);
+            },
+            async failed(cause) {
+                error(cause instanceof Error ? cause.message : String(cause));
+                if (lastEvidence === undefined)
+                    return;
+                try {
+                    await sessionFile?.transition('recovering', lastEvidence);
+                }
+                catch (sessionCause) {
+                    const terminal = new AggregateError([cause, sessionCause], 'Development rebuild failed and session evidence could not be recovered.');
+                    failure ??= terminal;
+                    lifecycle.stop(terminal);
+                }
+            },
+        });
+        sourceWatch = watchSources({
+            projectDir: input.projectDir,
+            configPath: input.configPath,
+            sources: current.sources,
+            onInvalidate: () => rebuild.invalidate(),
+            onRestartRequired: () => {
+                if (restartReported)
+                    return;
+                restartReported = true;
+                error('Project Environment configuration changed; restart pnpm dev to apply it.');
+            },
+            onError: (cause) => {
+                failure = cause;
+                lifecycle.stop(cause);
+            },
+        });
+        info('Ready: watching for remote deployments');
+        // Edits made while the first build/deployment was in flight predate this watcher.
+        // Catch up once; artifact deduplication prevents an unchanged second deployment.
+        rebuild.invalidate();
+        await lifecycle.stopped;
+    }
+    catch (cause) {
+        failure = cause;
+    }
+    lifecycle.stop(failure);
+    try {
+        await sessionFile?.transition('stopping', lastEvidence);
+    }
+    catch (cause) {
+        failure ??= cause;
+    }
+    for (const operation of [
+        () => sourceWatch?.stop(),
+        () => rebuild?.stop(failure),
+        () => view?.close(AbortSignal.timeout(30_000)),
+        () => rm(join(input.projectDir, '.astrale', 'development', input.environment, 'source'), {
+            recursive: true,
+            force: true,
+        }),
+        () => targetLock?.release(),
+        () => lock?.release(),
+    ]) {
+        try {
+            await operation();
+        }
+        catch (cause) {
+            cleanup.push(cause);
+        }
+    }
+    for (const directory of [
+        join(input.projectDir, '.astrale', 'development', input.environment),
+        join(input.projectDir, '.astrale', 'development'),
+    ]) {
+        try {
+            await rmdir(directory);
+        }
+        catch (cause) {
+            const code = cause.code;
+            if (code !== 'ENOENT' && code !== 'ENOTEMPTY' && code !== 'EEXIST')
+                cleanup.push(cause);
+        }
+    }
+    try {
+        await sessionFile?.transition(failure === undefined && cleanup.length === 0 ? 'stopped' : 'failed');
+    }
+    catch (cause) {
+        cleanup.push(cause);
+    }
+    lifecycle.dispose();
+    if (failure !== undefined) {
+        if (cleanup.length > 0)
+            error(new AggregateError(cleanup, 'Development cleanup failed.').message);
+        throw failure;
+    }
+    if (cleanup.length > 0)
+        throw new AggregateError(cleanup, 'Development cleanup failed.');
+    return 0;
+}
+async function refreshView(view, release, signal) {
+    if (view === undefined)
+        return;
+    try {
+        const pageUrl = await view.refresh(release, signal);
+        if (pageUrl !== undefined)
+            info(`View: ${pageUrl}`);
+    }
+    catch (cause) {
+        error(`View unavailable: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}

package/dist/tooling/cli/development/lease.d.ts

@@ -0,0 +1,18 @@
+export declare class DevelopmentLeaseError extends Error {
+    readonly code: 'DEVELOPMENT_LEASE_LOCKED' | 'DEVELOPMENT_LEASE_LOST';
+    readonly name = "DevelopmentLeaseError";
+    constructor(code: 'DEVELOPMENT_LEASE_LOCKED' | 'DEVELOPMENT_LEASE_LOST', message: string, options?: ErrorOptions);
+}
+export interface DevelopmentLease {
+    readonly path: string;
+    readonly recovered: boolean;
+    release(): Promise<void>;
+}
+/** One fail-closed filesystem lease engine for every local development coordinate. */
+export declare function acquireDevelopmentLease(input: {
+    readonly directory: string;
+    readonly coordinate: string;
+    readonly pid?: number;
+    readonly sessionId?: string;
+    readonly processAlive?: (pid: number) => boolean;
+}): Promise<DevelopmentLease>;

package/dist/tooling/cli/development/lease.js

@@ -0,0 +1,163 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+const LOCK_VERSION = 1;
+export class DevelopmentLeaseError extends Error {
+    code;
+    name = 'DevelopmentLeaseError';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+/** One fail-closed filesystem lease engine for every local development coordinate. */
+export async function acquireDevelopmentLease(input) {
+    const path = join(input.directory, 'session.lock');
+    const recovery = `${path}.reclaim`;
+    const sessionId = input.sessionId ?? randomUUID();
+    const alive = input.processAlive ?? processAlive;
+    const owner = Object.freeze({
+        version: LOCK_VERSION,
+        pid: input.pid ?? process.pid,
+        sessionId,
+        coordinate: input.coordinate,
+        acquiredAt: new Date().toISOString(),
+    });
+    await mkdir(input.directory, { recursive: true, mode: 0o700 });
+    try {
+        await create(path, owner);
+        return handle(path, input.coordinate, owner, false);
+    }
+    catch (cause) {
+        if (errorCode(cause) !== 'EEXIST')
+            throw cause;
+    }
+    let recoveryHandle;
+    try {
+        recoveryHandle = await open(recovery, 'wx', 0o600);
+        await recoveryHandle.writeFile(`${sessionId}\n`, 'utf8');
+        await recoveryHandle.sync();
+    }
+    catch (cause) {
+        if (errorCode(cause) === 'EEXIST')
+            throw locked(input.coordinate);
+        throw cause;
+    }
+    finally {
+        await recoveryHandle?.close();
+    }
+    try {
+        const observed = await readOwner(path, input.coordinate);
+        if (observed === undefined || alive(observed.pid))
+            throw locked(input.coordinate, observed);
+        const current = await readOwner(path, input.coordinate);
+        if (!sameOwner(current, observed) || alive(observed.pid)) {
+            throw locked(input.coordinate, current);
+        }
+        await unlink(path);
+        try {
+            await create(path, owner);
+        }
+        catch (cause) {
+            if (errorCode(cause) === 'EEXIST')
+                throw locked(input.coordinate);
+            throw cause;
+        }
+        return handle(path, input.coordinate, owner, true);
+    }
+    finally {
+        await unlink(recovery).catch((cause) => {
+            if (errorCode(cause) !== 'ENOENT')
+                throw cause;
+        });
+    }
+}
+function handle(path, coordinate, owner, recovered) {
+    let released = false;
+    return Object.freeze({
+        path,
+        recovered,
+        async release() {
+            if (released)
+                return;
+            const current = await readOwner(path, coordinate);
+            if (!sameOwner(current, owner)) {
+                throw new DevelopmentLeaseError('DEVELOPMENT_LEASE_LOST', `Development lease ownership changed for ${coordinate}; refusing to remove it.`);
+            }
+            await unlink(path);
+            released = true;
+        },
+    });
+}
+async function create(path, owner) {
+    const file = await open(path, 'wx', 0o600);
+    try {
+        await file.writeFile(`${JSON.stringify(owner)}\n`, 'utf8');
+        await file.sync();
+    }
+    catch (cause) {
+        await file.close();
+        await unlink(path).catch(() => undefined);
+        throw cause;
+    }
+    await file.close();
+}
+async function readOwner(path, coordinate) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (cause) {
+        if (errorCode(cause) === 'ENOENT')
+            return undefined;
+        throw cause;
+    }
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (cause) {
+        throw locked(coordinate, undefined, cause);
+    }
+    if (!isOwner(value) || value.coordinate !== coordinate)
+        throw locked(coordinate);
+    return value;
+}
+function isOwner(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        return false;
+    const owner = input;
+    return (Reflect.ownKeys(owner).every((key) => ['version', 'pid', 'sessionId', 'coordinate', 'acquiredAt'].includes(String(key))) &&
+        owner.version === LOCK_VERSION &&
+        Number.isSafeInteger(owner.pid) &&
+        (owner.pid ?? 0) > 0 &&
+        typeof owner.sessionId === 'string' &&
+        owner.sessionId.length > 0 &&
+        typeof owner.coordinate === 'string' &&
+        owner.coordinate.length > 0 &&
+        typeof owner.acquiredAt === 'string');
+}
+function sameOwner(left, right) {
+    return (left?.version === right.version &&
+        left.pid === right.pid &&
+        left.sessionId === right.sessionId &&
+        left.coordinate === right.coordinate);
+}
+function locked(coordinate, owner, cause) {
+    const detail = owner === undefined ? '' : ` by PID ${owner.pid} (session ${owner.sessionId})`;
+    return new DevelopmentLeaseError('DEVELOPMENT_LEASE_LOCKED', `Development coordinate ${coordinate} is already locked${detail}.`, cause === undefined ? undefined : { cause });
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (cause) {
+        return errorCode(cause) !== 'ESRCH';
+    }
+}
+function errorCode(input) {
+    return input !== null && typeof input === 'object' && 'code' in input
+        ? String(Reflect.get(input, 'code'))
+        : undefined;
+}

package/dist/tooling/cli/development/lifecycle.d.ts

@@ -0,0 +1,9 @@
+/** Own process signals for exactly one foreground development command. */
+export declare class DevelopmentLifecycle {
+    #private;
+    constructor();
+    get signal(): AbortSignal;
+    get stopped(): Promise<void>;
+    stop(reason?: unknown): void;
+    dispose(): void;
+}

package/dist/tooling/cli/development/lifecycle.js

@@ -0,0 +1,43 @@
+/** Own process signals for exactly one foreground development command. */
+export class DevelopmentLifecycle {
+    #controller = new AbortController();
+    #stopped;
+    #resolveStopped;
+    #disposed = false;
+    constructor() {
+        let resolveStopped;
+        this.#stopped = new Promise((resolve) => {
+            resolveStopped = resolve;
+        });
+        this.#resolveStopped = resolveStopped;
+        // Keep handlers installed throughout cleanup. This covers direct Bun
+        // invocation and any duplicate signal forwarding by an older launcher:
+        // repeated interrupts remain idempotent stop requests instead of reverting
+        // to the runtime's immediate default termination.
+        process.on('SIGINT', this.#interrupt);
+        process.on('SIGTERM', this.#interrupt);
+        // The terminal's session leader can exit before asynchronous cleanup finishes.
+        // Its hangup must request the same stop, not terminate the remaining View owner.
+        process.on('SIGHUP', this.#interrupt);
+    }
+    get signal() {
+        return this.#controller.signal;
+    }
+    get stopped() {
+        return this.#stopped;
+    }
+    stop(reason = new Error('Development interrupted.')) {
+        if (!this.#controller.signal.aborted)
+            this.#controller.abort(reason);
+        this.#resolveStopped();
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        process.off('SIGINT', this.#interrupt);
+        process.off('SIGTERM', this.#interrupt);
+        process.off('SIGHUP', this.#interrupt);
+    }
+    #interrupt = () => this.stop();
+}

package/dist/tooling/cli/development/project-imports.d.ts

@@ -0,0 +1,22 @@
+interface ProjectImportResolver {
+    resolveSync(specifier: string, importer: string): string;
+}
+interface ProjectImportResolution {
+    readonly path: string;
+    readonly external?: boolean;
+}
+interface ProjectImportBuilder {
+    onResolve(options: {
+        readonly filter: RegExp;
+    }, resolve: (input: {
+        readonly path: string;
+        readonly importer: string;
+    }) => ProjectImportResolution | undefined): void;
+}
+export interface ProjectImportPlugin {
+    readonly name: string;
+    setup(builder: ProjectImportBuilder): void;
+}
+/** Bundle project-local bare imports while leaving actual dependencies external. */
+export declare function projectImportPlugin(projectDir: string, resolver: ProjectImportResolver): ProjectImportPlugin;
+export {};

package/dist/tooling/cli/development/project-imports.js

@@ -0,0 +1,39 @@
+import { realpathSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+/** Bundle project-local bare imports while leaving actual dependencies external. */
+export function projectImportPlugin(projectDir, resolver) {
+    return Object.freeze({
+        name: 'astrale-project-imports',
+        setup(builder) {
+            builder.onResolve({ filter: /^[^./]/u }, (input) => {
+                let path;
+                try {
+                    path = resolver.resolveSync(input.path, input.importer);
+                }
+                catch {
+                    return Object.freeze({ path: input.path, external: true });
+                }
+                return projectLocal(projectDir, path)
+                    ? Object.freeze({ path })
+                    : Object.freeze({ path: input.path, external: true });
+            });
+        },
+    });
+}
+function projectLocal(projectDir, path) {
+    if (!isAbsolute(path))
+        return false;
+    const local = relative(canonical(projectDir), canonical(path));
+    return (local !== '..' &&
+        !local.startsWith(`..${sep}`) &&
+        !isAbsolute(local) &&
+        !local.split(sep).includes('node_modules'));
+}
+function canonical(path) {
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}

package/dist/tooling/cli/development/project-lock.d.ts

@@ -0,0 +1,16 @@
+import type { DevelopmentLease } from './lease.js';
+export declare class ProjectLockError extends Error {
+    readonly code: 'INVALID_ENVIRONMENT' | 'PROJECT_ENVIRONMENT_LOCKED';
+    readonly name = "ProjectLockError";
+    constructor(code: 'INVALID_ENVIRONMENT' | 'PROJECT_ENVIRONMENT_LOCKED', message: string, options?: ErrorOptions);
+}
+export interface ProjectLock extends DevelopmentLease {
+}
+/** Exclude concurrent writers of one checkout's generated Environment state. */
+export declare function acquireProjectLock(input: {
+    readonly projectRoot: string;
+    readonly environment: string;
+    readonly pid?: number;
+    readonly sessionId?: string;
+    readonly processAlive?: (pid: number) => boolean;
+}): Promise<ProjectLock>;

package/dist/tooling/cli/development/project-lock.js

@@ -0,0 +1,41 @@
+import { realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+import { acquireDevelopmentLease, DevelopmentLeaseError } from './lease.js';
+export class ProjectLockError extends Error {
+    code;
+    name = 'ProjectLockError';
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+/** Exclude concurrent writers of one checkout's generated Environment state. */
+export async function acquireProjectLock(input) {
+    const root = await realpath(input.projectRoot);
+    const environment = admitEnvironment(input.environment);
+    const coordinate = `${root}#${environment}`;
+    try {
+        return await acquireDevelopmentLease({
+            directory: join(root, '.astrale', 'development', environment),
+            coordinate,
+            ...(input.pid === undefined ? {} : { pid: input.pid }),
+            ...(input.sessionId === undefined ? {} : { sessionId: input.sessionId }),
+            ...(input.processAlive === undefined ? {} : { processAlive: input.processAlive }),
+        });
+    }
+    catch (cause) {
+        if (cause instanceof DevelopmentLeaseError) {
+            throw new ProjectLockError('PROJECT_ENVIRONMENT_LOCKED', cause.message, { cause });
+        }
+        throw cause;
+    }
+}
+function admitEnvironment(input) {
+    if (typeof input !== 'string' ||
+        input === '.' ||
+        input === '..' ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(input)) {
+        throw new ProjectLockError('INVALID_ENVIRONMENT', 'Development environment must be one non-traversing path segment.');
+    }
+    return input;
+}

package/dist/tooling/cli/development/rebuild.d.ts

@@ -0,0 +1,13 @@
+export interface RebuildOperations<Input, Candidate> {
+    prepare(input: Input, signal: AbortSignal): Promise<Candidate>;
+    commit(candidate: Candidate, signal: AbortSignal): Promise<void>;
+    failed(cause: unknown): void | Promise<void>;
+}
+/** Serialize rebuilds while retaining only the newest pending invalidation. */
+export declare class LatestRebuild<Input, Candidate> {
+    #private;
+    constructor(operations: RebuildOperations<Input, Candidate>);
+    invalidate(input: Input): void;
+    idle(): Promise<void>;
+    stop(reason?: unknown): Promise<void>;
+}

package/dist/tooling/cli/development/rebuild.js

@@ -0,0 +1,58 @@
+/** Serialize rebuilds while retaining only the newest pending invalidation. */
+export class LatestRebuild {
+    #operations;
+    #generation = 0;
+    #pending;
+    #running;
+    #current;
+    #stopped = false;
+    constructor(operations) {
+        this.#operations = operations;
+    }
+    invalidate(input) {
+        if (this.#stopped)
+            return;
+        this.#pending = { generation: ++this.#generation, input };
+        this.#running ??= this.#drain();
+    }
+    async idle() {
+        await this.#running;
+    }
+    async stop(reason = new Error('Development rebuild stopped.')) {
+        if (this.#stopped)
+            return this.idle();
+        this.#stopped = true;
+        this.#pending = undefined;
+        this.#current?.abort(reason);
+        await this.idle();
+    }
+    async #drain() {
+        try {
+            while (!this.#stopped && this.#pending !== undefined) {
+                const work = this.#pending;
+                this.#pending = undefined;
+                const controller = new AbortController();
+                this.#current = controller;
+                try {
+                    const candidate = await this.#operations.prepare(work.input, controller.signal);
+                    if (this.#stopped || work.generation !== this.#generation)
+                        continue;
+                    await this.#operations.commit(candidate, controller.signal);
+                }
+                catch (cause) {
+                    if (!controller.signal.aborted)
+                        await this.#operations.failed(cause);
+                }
+                finally {
+                    if (this.#current === controller)
+                        this.#current = undefined;
+                }
+            }
+        }
+        finally {
+            this.#running = undefined;
+            if (!this.#stopped && this.#pending !== undefined)
+                this.#running = this.#drain();
+        }
+    }
+}

package/dist/tooling/cli/development/release-evidence.d.ts

@@ -0,0 +1,4 @@
+import type { InstallationEvidence } from '../installation/index.js';
+import type { DevelopmentSessionReleaseEvidenceV1 } from './session-file.js';
+/** Project installed evidence projected into the stable development-session representation. */
+export declare function developmentReleaseEvidence(installation: InstallationEvidence): DevelopmentSessionReleaseEvidenceV1;