@astrale-os/sdk 0.6.0-beta.4 → 0.6.0-beta.41

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

@@ -1,243 +0,0 @@
-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 { deprecationWarnings } from '../deprecations.js';
-import { loadPrivateSecretsFile } from '../dotenv.js';
-import { error, info, warn } 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}`);
-        for (const warning of deprecationWarnings(current.artifact.build))
-            warn(warning);
-        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

@@ -1,18 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,9 +0,0 @@
-/** 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

@@ -1,43 +0,0 @@
-/** 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

@@ -1,22 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,58 +0,0 @@
-/** 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

@@ -1,4 +0,0 @@
-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;