@astrale-os/sdk 0.5.0-beta.99 → 0.6.0-beta.0

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.js

@@ -16,6 +16,9 @@ export class DevelopmentLifecycle {
         // 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;
@@ -34,6 +37,7 @@ export class DevelopmentLifecycle {
         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

@@ -1,13 +1,12 @@
+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 {
-    readonly path: string;
-    readonly recovered: boolean;
-    release(): Promise<void>;
+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;

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

@@ -1,7 +1,6 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, open, readFile, realpath, rmdir, stat, unlink } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-const LOCK_VERSION = 1;
+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';
@@ -10,101 +9,27 @@ export class ProjectLockError extends Error {
         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}`;
-    const directory = join(root, '.astrale', 'development', environment);
-    const path = join(directory, 'session.lock');
-    const recovery = `${path}.reclaim`;
-    const sessionId = input.sessionId ?? randomUUID();
-    const alive = input.processAlive ?? processAlive;
-    await mkdir(directory, { recursive: true });
-    if (await exists(recovery))
-        throw locked(coordinate);
-    const owner = Object.freeze({
-        version: LOCK_VERSION,
-        pid: input.pid ?? process.pid,
-        sessionId,
-        projectRoot: root,
-        environment,
-        acquiredAt: new Date().toISOString(),
-    });
     try {
-        await create(path, owner);
-        return handle(path, coordinate, sessionId, false);
-    }
-    catch (cause) {
-        if (errorCode(cause) !== 'EEXIST')
-            throw cause;
-    }
-    const observed = await readOwner(path, coordinate);
-    if (observed === undefined ||
-        alive(observed.pid) ||
-        observed.projectRoot !== root ||
-        observed.environment !== environment) {
-        throw locked(coordinate, observed);
-    }
-    let recoveryHandle;
-    try {
-        recoveryHandle = await open(recovery, 'wx', 0o600);
-        await recoveryHandle.writeFile(`${sessionId}\n`, 'utf8');
-        await recoveryHandle.sync();
+        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 (errorCode(cause) === 'EEXIST')
-            throw locked(coordinate);
-        throw cause;
-    }
-    finally {
-        await recoveryHandle?.close();
-    }
-    try {
-        const current = await readOwner(path, coordinate);
-        if (current === undefined ||
-            current.sessionId !== observed.sessionId ||
-            current.pid !== observed.pid ||
-            alive(current.pid)) {
-            throw locked(coordinate, current);
-        }
-        await unlink(path);
-        try {
-            await create(path, owner);
-        }
-        catch (cause) {
-            if (errorCode(cause) === 'EEXIST')
-                throw locked(coordinate, await readOwner(path, coordinate));
-            throw cause;
+        if (cause instanceof DevelopmentLeaseError) {
+            throw new ProjectLockError('PROJECT_ENVIRONMENT_LOCKED', cause.message, { cause });
         }
-        return handle(path, coordinate, sessionId, true);
-    }
-    finally {
-        await unlink(recovery).catch((cause) => {
-            if (errorCode(cause) !== 'ENOENT')
-                throw cause;
-        });
+        throw cause;
     }
 }
-function handle(path, coordinate, sessionId, recovered) {
-    return Object.freeze({
-        path,
-        recovered,
-        async release() {
-            const current = await readOwner(path, coordinate);
-            if (current !== undefined && current.sessionId === sessionId) {
-                await unlink(path);
-                await removeEmpty(dirname(path));
-                await removeEmpty(dirname(dirname(path)));
-            }
-        },
-    });
-}
-async function removeEmpty(path) {
-    await rmdir(path).catch((cause) => {
-        if (!['ENOENT', 'ENOTEMPTY'].includes(errorCode(cause) ?? ''))
-            throw cause;
-    });
-}
 function admitEnvironment(input) {
     if (typeof input !== 'string' ||
         input === '.' ||
@@ -114,80 +39,3 @@ function admitEnvironment(input) {
     }
     return input;
 }
-function processAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (cause) {
-        return errorCode(cause) !== 'ESRCH';
-    }
-}
-async function exists(path) {
-    try {
-        await stat(path);
-        return true;
-    }
-    catch (cause) {
-        if (errorCode(cause) === 'ENOENT')
-            return false;
-        throw cause;
-    }
-}
-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 new ProjectLockError('PROJECT_ENVIRONMENT_LOCKED', `Development lock for ${coordinate} is unreadable; refusing unsafe recovery.`, { cause });
-    }
-    if (!isOwner(value)) {
-        throw new ProjectLockError('PROJECT_ENVIRONMENT_LOCKED', `Development lock for ${coordinate} has invalid owner evidence; refusing unsafe recovery.`);
-    }
-    return value;
-}
-function isOwner(input) {
-    if (input === null || typeof input !== 'object' || Array.isArray(input))
-        return false;
-    const owner = input;
-    return (owner.version === LOCK_VERSION &&
-        Number.isInteger(owner.pid) &&
-        (owner.pid ?? 0) > 0 &&
-        typeof owner.sessionId === 'string' &&
-        owner.sessionId.length > 0 &&
-        typeof owner.projectRoot === 'string' &&
-        typeof owner.environment === 'string' &&
-        typeof owner.acquiredAt === 'string');
-}
-function locked(coordinate, owner) {
-    const detail = owner === undefined ? '' : ` by PID ${owner.pid} (session ${owner.sessionId})`;
-    return new ProjectLockError('PROJECT_ENVIRONMENT_LOCKED', `Development session ${coordinate} is already locked${detail}.`);
-}
-function errorCode(input) {
-    return input !== null && typeof input === 'object' && 'code' in input
-        ? String(Reflect.get(input, 'code'))
-        : undefined;
-}

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;

package/dist/tooling/cli/development/release-evidence.js

@@ -0,0 +1,10 @@
+/** Project installed evidence projected into the stable development-session representation. */
+export function developmentReleaseEvidence(installation) {
+    return Object.freeze({
+        origin: installation.origin,
+        revision: installation.revision,
+        issuer: installation.issuer,
+        etag: installation.etag,
+        generation: installation.generation,
+    });
+}

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

@@ -0,0 +1,6 @@
+import type { Adapter, ReadyDeployResult } from '../../../deployment/adapter/index.js';
+import type { InstallationEvidence } from '../installation/index.js';
+export declare function reportDevelopmentDeployment(deployed: ReadyDeployResult, installation: InstallationEvidence | undefined, adapter: Adapter<object>, input: {
+    readonly environment: string;
+    readonly deployOnly: boolean;
+}): void;

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

@@ -0,0 +1,14 @@
+import { info } from '../log.js';
+export function reportDevelopmentDeployment(deployed, installation, adapter, input) {
+    info(`Environment: ${input.environment}`);
+    info(`Adapter: ${adapter.name}@${adapter.version}`);
+    info(`Deployment: ${deployed.progress.provider.evidence.deployment}`);
+    if (deployed.progress.provider.evidence.preflight !== undefined) {
+        info(`Preflight: ${deployed.progress.provider.evidence.preflight}; public readiness verified`);
+    }
+    info(`Public: ${deployed.release.addressing.publicUrl}`);
+    info(`Publication: ${deployed.release.publication.schema.revision} · ${deployed.release.publication.etag}`);
+    info(installation === undefined
+        ? `Installation: skipped${input.deployOnly ? ' (--deploy-only)' : ''}`
+        : `Installation: ${installation.instance} · ${installation.status}`);
+}

package/dist/tooling/cli/development/source-watch.js

@@ -10,6 +10,7 @@ export function watchSources(input) {
     const config = resolve(input.configPath);
     let configFingerprint = fingerprint(config);
     let sourceFingerprints = fingerprints(sources);
+    const directoryWatchers = new Map();
     const watcher = watch(input.projectDir, { recursive: true }, () => {
         if (closed)
             return;
@@ -36,11 +37,39 @@ export function watchSources(input) {
         }
         if (!changed)
             return;
+        schedule();
+    });
+    watcher.on('error', input.onError);
+    syncDirectoryWatchers();
+    function schedule() {
         if (timer !== undefined)
             clearTimeout(timer);
         timer = setTimeout(flush, input.debounceMs ?? 80);
-    });
-    watcher.on('error', input.onError);
+    }
+    function syncDirectoryWatchers() {
+        const directories = new Set([...sourceFingerprints]
+            .filter(([, value]) => value.startsWith('directory:'))
+            .map(([path]) => path));
+        for (const [path, owned] of directoryWatchers) {
+            if (directories.has(path))
+                continue;
+            owned.off('error', input.onError);
+            owned.close();
+            directoryWatchers.delete(path);
+        }
+        for (const path of directories) {
+            if (directoryWatchers.has(path))
+                continue;
+            const owned = watch(path, () => {
+                if (closed)
+                    return;
+                dirty = true;
+                schedule();
+            });
+            owned.on('error', input.onError);
+            directoryWatchers.set(path, owned);
+        }
+    }
     function flush() {
         timer = undefined;
         if (closed)
@@ -54,8 +83,22 @@ export function watchSources(input) {
     }
     return Object.freeze({
         update(next) {
-            sources = canonicalSources(next);
-            sourceFingerprints = fingerprints(sources);
+            const nextSources = canonicalSources(next);
+            const nextFingerprints = fingerprints(nextSources);
+            // A completed build does not prove it consumed the current file contents.
+            // Retain edits that raced its commit, even if the OS event is still queued.
+            let changed = false;
+            for (const [path, value] of nextFingerprints) {
+                if (sourceFingerprints.has(path) && sourceFingerprints.get(path) !== value) {
+                    dirty = true;
+                    changed = true;
+                }
+            }
+            sources = nextSources;
+            sourceFingerprints = nextFingerprints;
+            syncDirectoryWatchers();
+            if (changed)
+                schedule();
         },
         async stop() {
             if (closed)
@@ -65,6 +108,11 @@ export function watchSources(input) {
                 clearTimeout(timer);
             watcher.off('error', input.onError);
             watcher.close();
+            for (const owned of directoryWatchers.values()) {
+                owned.off('error', input.onError);
+                owned.close();
+            }
+            directoryWatchers.clear();
         },
     });
 }
@@ -77,7 +125,7 @@ function fingerprints(paths) {
 function fingerprint(path) {
     try {
         const value = statSync(path, { bigint: true });
-        return `${value.size}:${value.mtimeNs}:${value.ctimeNs}`;
+        return `${value.isDirectory() ? 'directory' : 'file'}:${value.size}:${value.mtimeNs}:${value.ctimeNs}`;
     }
     catch (cause) {
         if (errorCode(cause) === 'ENOENT')

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

@@ -0,0 +1,7 @@
+/** Own the canonical project-local files and directories that invalidate a candidate. */
+export declare class DevelopmentSources {
+    #private;
+    constructor(projectDir: string);
+    record: (path: string) => void;
+    snapshot(): ReadonlySet<string>;
+}

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

@@ -0,0 +1,48 @@
+import { realpathSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+/** Own the canonical project-local files and directories that invalidate a candidate. */
+export class DevelopmentSources {
+    #declaredProjectDir;
+    #projectDir;
+    #sources = new Set();
+    constructor(projectDir) {
+        this.#declaredProjectDir = resolve(projectDir);
+        try {
+            this.#projectDir = realpathSync.native(this.#declaredProjectDir);
+        }
+        catch {
+            this.#projectDir = this.#declaredProjectDir;
+        }
+    }
+    record = (path) => {
+        if (typeof path !== 'string' || path.length === 0 || path.includes('\0')) {
+            throw new TypeError('An adapter reported an invalid preparation source path.');
+        }
+        const declared = isAbsolute(path) ? resolve(path) : resolve(this.#declaredProjectDir, path);
+        let absolute;
+        try {
+            absolute = realpathSync.native(declared);
+        }
+        catch (cause) {
+            if (errorCode(cause) !== 'ENOENT')
+                throw cause;
+            absolute = declared.startsWith(`${this.#declaredProjectDir}${sep}`)
+                ? resolve(this.#projectDir, relative(this.#declaredProjectDir, declared))
+                : declared;
+        }
+        if (!absolute.startsWith(`${this.#projectDir}${sep}`))
+            return;
+        const topLevel = relative(this.#projectDir, absolute).split(sep)[0];
+        if (topLevel === '.astrale' || topLevel === '.git' || topLevel === 'node_modules')
+            return;
+        this.#sources.add(absolute);
+    };
+    snapshot() {
+        return new Set(this.#sources);
+    }
+}
+function errorCode(input) {
+    return input !== null && typeof input === 'object' && 'code' in input
+        ? String(Reflect.get(input, 'code'))
+        : undefined;
+}

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

@@ -0,0 +1,16 @@
+import type { DevelopmentLease } from './lease.js';
+export declare class DevelopmentTargetLockError extends Error {
+    readonly code: 'DEVELOPMENT_TARGET_LOCKED' | 'DEVELOPMENT_TARGET_LOCK_LOST';
+    readonly name = "DevelopmentTargetLockError";
+    constructor(code: 'DEVELOPMENT_TARGET_LOCKED' | 'DEVELOPMENT_TARGET_LOCK_LOST', message: string, options?: ErrorOptions);
+}
+/** Exclude local sessions targeting one installed Domain across separate checkouts. */
+export declare function acquireDevelopmentTargetLock(input: {
+    readonly issuer: string;
+    readonly origin: string;
+}, dependencies?: {
+    readonly root?: string;
+    readonly pid?: number;
+    readonly sessionId?: string;
+    readonly processAlive?: (pid: number) => boolean;
+}): Promise<DevelopmentLease>;