@astrale-os/sdk 0.6.0-beta.13 → 0.6.0-beta.15

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

@@ -0,0 +1,142 @@
+import { rm, rmdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { deprecationWarnings } from '../../deprecations.js';
+import { error, info, warn } from '../../log.js';
+import { DevelopmentCandidateBuilder, discoverRuntimePath, sameDeploymentCandidate, sameEnvironment, } from './candidate.js';
+import { loadPrivateCredentialFile } from './credential.js';
+import { deployDevelopmentCandidate } from './deployment.js';
+import { DevelopmentLifecycle } from './lifecycle.js';
+import { acquireProjectLock } from './project-lock.js';
+import { LatestRebuild } from './rebuild.js';
+import { reportDevelopmentDeployment } from './report.js';
+import { loadPrivateSecretsFile } from './secrets-file.js';
+import { watchSources } from './source-watch.js';
+/**
+ * Watch one Project Environment and serialize complete remote deployment generations. Each
+ * generation replaces the Environment's stable target in place; none installs anything.
+ *
+ * @deprecated Deploy the Environment with `astrale-domain deploy`, then install the printed URL
+ * with `astrale domain install <url> --direct -i <instance>`.
+ */
+export async function develop(input) {
+    const lifecycle = new DevelopmentLifecycle();
+    let lock;
+    let sourceWatch;
+    let rebuild;
+    let current;
+    let failure;
+    const cleanup = [];
+    try {
+        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);
+        info(`Domain: ${current.artifact.build.schema.compiled.root.origin}`);
+        for (const warning of deprecationWarnings(current.artifact.build))
+            warn(warning);
+        const first = await deployDevelopmentCandidate(current, { ...input, ...(credential === undefined ? {} : { credential }) }, lifecycle.signal);
+        reportDevelopmentDeployment(first, current.adapter, input);
+        let restartReported = false;
+        rebuild = new LatestRebuild({
+            async prepare(_ignored, signal) {
+                info(`Rebuilding: ${input.environment}`);
+                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;
+                    sourceWatch?.update(candidate.sources);
+                    return;
+                }
+                const deployed = await deployDevelopmentCandidate(candidate, { ...input, ...(credential === undefined ? {} : { credential }) }, signal);
+                current = candidate;
+                sourceWatch?.update(candidate.sources);
+                info(`Updated: ${candidate.artifact.build.schema.compiled.root.revision}`);
+                reportDevelopmentDeployment(deployed, candidate.adapter, input);
+            },
+            async failed(cause) {
+                error(cause instanceof Error ? cause.message : String(cause));
+            },
+        });
+        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);
+    for (const operation of [
+        () => sourceWatch?.stop(),
+        () => rebuild?.stop(failure),
+        () => rm(join(input.projectDir, '.astrale', 'development', input.environment, 'source'), {
+            recursive: true,
+            force: true,
+        }),
+        () => 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);
+        }
+    }
+    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;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * `astrale-domain dev` (legacy, deprecated).
+ *
+ * Development is not a command of the deployment model: a developer, or an agent, iterates with
+ * `astrale-domain deploy development`, then `astrale domain install <url> --direct -i <instance>`. This
+ * folder keeps the watch loop that updates one deployment per Domain origin and Environment in
+ * place and its private file boundaries, exactly as before. Every run warns with that replacement
+ * on stderr.
+ *
+ * Short-term consumers: the `dev` scripts of the Domain packages that still deploy in place,
+ * namely the domains repository's ai-gateway, closing, grc, integrations, issues, organization and
+ * services packages, the Shell, and ui's Domain, and of the Projects create-astrale-domain
+ * scaffolds while its template still declares `dev`. Projects that pin an SDK release older than
+ * this folder never reach it.
+ *
+ * Deletion: once none of those packages runs `astrale-domain dev`, a separate breaking release
+ * deletes this folder with the `dev` command and its `--credential-file` and `--secrets-file`
+ * flags.
+ */
+export { develop } from './develop.js';
+export { developmentDeprecation } from './deprecation.js';

package/dist/tooling/cli/legacy/development/index.js

@@ -0,0 +1,21 @@
+/**
+ * `astrale-domain dev` (legacy, deprecated).
+ *
+ * Development is not a command of the deployment model: a developer, or an agent, iterates with
+ * `astrale-domain deploy development`, then `astrale domain install <url> --direct -i <instance>`. This
+ * folder keeps the watch loop that updates one deployment per Domain origin and Environment in
+ * place and its private file boundaries, exactly as before. Every run warns with that replacement
+ * on stderr.
+ *
+ * Short-term consumers: the `dev` scripts of the Domain packages that still deploy in place,
+ * namely the domains repository's ai-gateway, closing, grc, integrations, issues, organization and
+ * services packages, the Shell, and ui's Domain, and of the Projects create-astrale-domain
+ * scaffolds while its template still declares `dev`. Projects that pin an SDK release older than
+ * this folder never reach it.
+ *
+ * Deletion: once none of those packages runs `astrale-domain dev`, a separate breaking release
+ * deletes this folder with the `dev` command and its `--credential-file` and `--secrets-file`
+ * flags.
+ */
+export { develop } from './develop.js';
+export { developmentDeprecation } from './deprecation.js';

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

@@ -0,0 +1,7 @@
+import type { ReadyDeployResult } from '../../../../deployment/adapter/index.js';
+export declare function reportDevelopmentDeployment(deployed: ReadyDeployResult, adapter: {
+    readonly name: string;
+    readonly version: string;
+}, input: {
+    readonly environment: string;
+}): void;

package/dist/tooling/cli/{development → legacy/development}/report.js

@@ -1,5 +1,5 @@
-import { info } from '../log.js';
-export function reportDevelopmentDeployment(deployed, installation, adapter, input) {
+import { info } from '../../log.js';
+export function reportDevelopmentDeployment(deployed, adapter, input) {
     info(`Environment: ${input.environment}`);
     info(`Adapter: ${adapter.name}@${adapter.version}`);
     info(`Deployment: ${deployed.progress.provider.evidence.deployment}`);
@@ -8,7 +8,4 @@ export function reportDevelopmentDeployment(deployed, installation, adapter, inp
     }
     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/legacy/development/secrets-file.d.ts

@@ -0,0 +1,2 @@
+/** Load one explicit development-session secret snapshot without following a leaf symlink. */
+export declare function loadPrivateSecretsFile(path: string, platform?: NodeJS.Platform): Record<string, string>;

package/dist/tooling/cli/legacy/development/secrets-file.js

@@ -0,0 +1,33 @@
+import { closeSync, constants, fstatSync, openSync, readFileSync } from 'node:fs';
+import { parseDotenv } from '../../dotenv.js';
+/** Load one explicit development-session secret snapshot without following a leaf symlink. */
+export function loadPrivateSecretsFile(path, platform = process.platform) {
+    if (platform === 'win32') {
+        throw new Error('--secrets-file is unavailable on Windows until private no-reparse file admission is supported.');
+    }
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    }
+    catch (cause) {
+        if (cause instanceof Error && 'code' in cause && cause.code === 'ENOENT') {
+            throw new Error(`Secrets file '${path}' is missing.`, { cause });
+        }
+        if (cause instanceof Error && 'code' in cause && cause.code === 'ELOOP') {
+            throw new Error(`Secrets file '${path}' must be a regular file and not a symlink.`, { cause });
+        }
+        throw cause;
+    }
+    try {
+        const info = fstatSync(descriptor);
+        if (!info.isFile())
+            throw new Error(`Secrets file '${path}' must be a regular file.`);
+        if ((info.mode & 0o077) !== 0) {
+            throw new Error(`Secrets file '${path}' must not be accessible by group or other users.`);
+        }
+        return parseDotenv(readFileSync(descriptor, 'utf8'));
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}

package/dist/tooling/cli/legacy/stable-target-adapter.d.ts

@@ -5,9 +5,11 @@ import type { Adapter, LegacyAdapter } from '../../../deployment/adapter/index.j
  *
  * @deprecated Stable-target deploy path only. Replacement: `deployRelease` of adapter interface
  * v2. Consumers: `astrale-domain deploy` and `astrale-domain dev` on the direct-mode
- * configurations of domains ai-gateway, closing, grc, integrations and issues (until SV15), shell
- * (until SH2), the Services `development` environment (until SV9) and ui:domain (until UI1).
- * Deleted with the legacy deploy path (D10), once no supported configuration selects it (CT33).
+ * configurations of domains ai-gateway, closing, grc, integrations and issues (until SV15), domains
+ * organization (until it leaves direct mode, AM-147), the Services `beta` and `prod` (until SV12),
+ * `development` (until SV9) and frozen `admin-beta` (until D19) environments, shell (until SH2)
+ * and its frozen `legacy-v3` (until D22), and ui:domain (until UI1). Deleted with the legacy
+ * deploy path (D10), once no configuration on any repository's main selects it (CT33, AM-147).
  */
 export type StableTargetAdapter<Parameters extends object = object> = (Adapter<Parameters> | LegacyAdapter<Parameters>) & Pick<LegacyAdapter<Parameters>, 'prepare' | 'deploy'>;
 /**

package/dist/tooling/cli/legacy/stable-target-deploy.d.ts

@@ -0,0 +1,40 @@
+import type { Build, ResolvedRuntimeReference } from '../../../deployment/index.js';
+import type { LegacyDirectReason } from '../deploy-mode.js';
+import type { DeployResultV1 } from '../deploy-result.js';
+import type { LoadedEnvironment } from '../project.js';
+/**
+ * What a direct-mode deploy prints on stderr before any effect (AM-59): its Environment replaces
+ * one stable target in place and serves a v3 Publication only, which the deployment model
+ * replaces with one immutable deployment per release.
+ *
+ * @deprecated Stable-target deploy path only; see `deployStableTarget`.
+ */
+export declare function directModeDeprecation(environment: string, reasons: readonly LegacyDirectReason[]): string;
+/**
+ * Deploy one Environment on the legacy direct-mode path (CT33): bundle exactly as
+ * `astrale-domain build` does, let `prepare` place that Bundle at the Environment's stable target
+ * and `deploy` replace the code it runs, then verify the v3 Publication it serves. It warns first,
+ * then behaves exactly as before. The SDK never installs the deployed Domain here and makes no
+ * Kernel call of its own.
+ *
+ * Returns the deploy result, or nothing once a failure is reported on stderr.
+ *
+ * @deprecated Stable-target deploy path only. Replacement: `deployImmutable`, the immutable
+ * deployment of one sealed release through `deployRelease`. Consumers: the direct-mode
+ * configurations of domains ai-gateway, closing, grc, integrations and issues (until SV15), domains
+ * organization (until it leaves direct mode, AM-147), the Services `beta` and `prod` (until SV12),
+ * `development` (until SV9) and frozen `admin-beta` (until D19) environments, shell (until SH2)
+ * and its frozen `legacy-v3` (until D22), and ui:domain (until UI1). Deleted with the legacy deploy
+ * path (D10), once no configuration on any repository's main selects it (CT33, AM-147).
+ */
+export declare function deployStableTarget(input: {
+    readonly projectDir: string;
+    readonly environment: string;
+    readonly definition: LoadedEnvironment;
+    readonly reasons: readonly LegacyDirectReason[];
+    readonly build: Build;
+    readonly runtime: ResolvedRuntimeReference;
+    readonly identity?: string;
+    readonly signal: AbortSignal;
+    readonly report: (line: string) => void;
+}): Promise<DeployResultV1 | undefined>;

package/dist/tooling/cli/legacy/stable-target-deploy.js

@@ -0,0 +1,102 @@
+import { verifyDeployment, verifyPreflight } from '../../../deployment/index.js';
+import { bundleBuild } from '../build.js';
+import { error, warn } from '../log.js';
+import { environmentSecrets } from '../secrets.js';
+import { stableTargetDeployResult } from './deploy-result.js';
+import { stableTargetAdapter } from './stable-target-adapter.js';
+import { stableTargetBuildWarning } from './uploaded-build.js';
+/**
+ * What a direct-mode deploy prints on stderr before any effect (AM-59): its Environment replaces
+ * one stable target in place and serves a v3 Publication only, which the deployment model
+ * replaces with one immutable deployment per release.
+ *
+ * @deprecated Stable-target deploy path only; see `deployStableTarget`.
+ */
+export function directModeDeprecation(environment, reasons) {
+    const selected = reasons.map((reason) => {
+        if (reason.reason === 'direct-parameter')
+            return reason.parameter;
+        return reason.reason === 'no-namespace' ? 'no namespace' : 'no deployRelease';
+    });
+    return (`Environment ${environment} deploys in direct mode (${selected.join(', ')}), which is ` +
+        'deprecated and will be removed: it replaces one stable target in place and serves a v3 ' +
+        'Publication only. Its replacement deploys one immutable deployment per release, through an ' +
+        'adapter that implements deployRelease.');
+}
+/**
+ * Deploy one Environment on the legacy direct-mode path (CT33): bundle exactly as
+ * `astrale-domain build` does, let `prepare` place that Bundle at the Environment's stable target
+ * and `deploy` replace the code it runs, then verify the v3 Publication it serves. It warns first,
+ * then behaves exactly as before. The SDK never installs the deployed Domain here and makes no
+ * Kernel call of its own.
+ *
+ * Returns the deploy result, or nothing once a failure is reported on stderr.
+ *
+ * @deprecated Stable-target deploy path only. Replacement: `deployImmutable`, the immutable
+ * deployment of one sealed release through `deployRelease`. Consumers: the direct-mode
+ * configurations of domains ai-gateway, closing, grc, integrations and issues (until SV15), domains
+ * organization (until it leaves direct mode, AM-147), the Services `beta` and `prod` (until SV12),
+ * `development` (until SV9) and frozen `admin-beta` (until D19) environments, shell (until SH2)
+ * and its frozen `legacy-v3` (until D22), and ui:domain (until UI1). Deleted with the legacy deploy
+ * path (D10), once no configuration on any repository's main selects it (CT33, AM-147).
+ */
+export async function deployStableTarget(input) {
+    const { build, signal, report } = input;
+    warn(directModeDeprecation(input.environment, input.reasons));
+    const adapter = stableTargetAdapter(input.definition.deployment.adapter);
+    const parameters = input.definition.deployment.parameters;
+    // `deploy` rebuilds exactly as `build` does; preparation then only places that Bundle.
+    const bundle = await bundleBuild({
+        bundler: adapter.bundler,
+        projectDir: input.projectDir,
+        build,
+        runtime: input.runtime,
+        signal,
+    });
+    const source = await adapter.prepare(parameters, {
+        projectDir: input.projectDir,
+        environment: input.environment,
+        mode: 'release',
+        signal,
+        build,
+        runtime: input.runtime,
+        bundle,
+    });
+    const artifact = verifyPreflight({ build, runtime: input.runtime, source });
+    const secrets = environmentSecrets(adapter, parameters, input.projectDir, input.runtime.runtime);
+    const deployed = await adapter.deploy(parameters, {
+        projectDir: input.projectDir,
+        environment: input.environment,
+        ...(input.identity === undefined ? {} : { identity: input.identity }),
+        secrets,
+        artifact,
+        signal,
+    });
+    const result = verifyDeployment(artifact, deployed);
+    if (result.status === 'failed') {
+        error(`Deployment failed during ${result.phase}: ${result.error.message}`);
+        return undefined;
+    }
+    const uploaded = result.progress.provider.evidence.build;
+    if (uploaded !== undefined) {
+        // prepare/deploy places a stable target: a differing upload only warns.
+        const warning = stableTargetBuildWarning(bundle, uploaded);
+        if (warning !== undefined)
+            warn(warning);
+    }
+    report(`Domain: ${result.release.publication.origin}`);
+    report(`Environment: ${input.environment}`);
+    report(`Adapter: ${adapter.name}@${adapter.version}`);
+    report(`Deployment: ${result.progress.provider.evidence.deployment}`);
+    if (result.progress.provider.evidence.preflight !== undefined) {
+        report(`Preflight: ${result.progress.provider.evidence.preflight}; public readiness verified`);
+    }
+    report(`Public: ${result.release.addressing.publicUrl}`);
+    report(`Publication: ${result.release.publication.schema.revision} · ${result.release.publication.etag}`);
+    report('Ready: deployment verified');
+    return stableTargetDeployResult({
+        environment: input.environment,
+        adapter,
+        deployment: result,
+    });
+}

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

@@ -0,0 +1,114 @@
+import type { DeploymentRecordV1, DeploymentSummaryV1 } from '../../deployment/address/index.js';
+import type { DeploymentCallTarget, ListedDeployment } from '../../deployment/index.js';
+import type { LoadedEnvironment } from './project.js';
+/**
+ * `astrale-domain list --json` on stdout: the deployments of the Project's Environments that their
+ * hosts keep for the caller, each with its computed name and where it is called. It changes
+ * nothing, at any host or instance.
+ */
+export interface ListResultV1 {
+    readonly format: 'astrale.deployment-list';
+    readonly version: 1;
+    readonly origin: string;
+    /** Environment by Environment in the Project's order, each in its host's order. */
+    readonly deployments: readonly ListedDeploymentV1[];
+    /**
+     * The selected Environments whose deployments are not in `deployments`, and why: the listing is
+     * complete exactly when this is empty.
+     */
+    readonly unlisted: readonly UnlistedEnvironmentV1[];
+}
+/**
+ * One deployment: what its host knows (`DeploymentSummaryV1`), the Environment it was listed for
+ * and its adapter, its computed name, and its call target. `lastCallAt` and a preview's `expiresAt`
+ * are as of the listing: an adapter reads the calls its host counted since it last recorded them
+ * (adapter-astrale: `CloudflareDeployment.lastCalls`), or every call from the calls dataset of a
+ * platform namespace (adapter-cloudflare), which omits both without Account Analytics Read.
+ */
+export type ListedDeploymentV1 = Omit<DeploymentSummaryV1, 'record'> & {
+    /** The Project Environment whose line holds the deployment, as its host listed it. */
+    readonly environment: string;
+    /** `<adapter name>@<adapter version>` */
+    readonly adapter: string;
+    /**
+     * The deployment's name (`deploymentName`, CT28), computed from its record and never stored:
+     * `1.4.2 + 7 commits · a1b2c3d · staging`. Print it as it is, environment included (AM-57).
+     */
+    readonly name: string;
+    /**
+     * The record its deployer declared, as `acceptDeploymentRecord` admits it. `null` when there is
+     * no admitted record: the host returns a record this SDK refuses or one that describes another
+     * deployment, or keeps none (the adapter lists it without a record, as a platform namespace lists
+     * a deployment it has not activated). The deployment is then listed from what its host knows, and
+     * named in the listed Environment, from the commit of that record only when the record names this
+     * deployment, origin and Environment.
+     */
+    readonly record: DeploymentRecordV1 | null;
+    /**
+     * Why there is no admitted record: the refusal of the stored one, or that its host keeps none;
+     * present exactly when `record` is `null`.
+     */
+    readonly recordRefusal?: string;
+    /** Where to call this deployment alone, such as to rotate one of its secrets in place. */
+    readonly callTarget: DeploymentCallTarget;
+};
+/**
+ * An Environment the listing did not list:
+ * - `legacy-direct`: it replaces one stable target in place and makes no immutable deployment;
+ * - `refused`: `deploy` refuses its configuration, so it deploys nothing;
+ * - `unsupported`: its adapter deploys immutable deployments but lists none.
+ */
+export interface UnlistedEnvironmentV1 {
+    readonly environment: string;
+    readonly adapter: string;
+    readonly reason: 'legacy-direct' | 'refused' | 'unsupported';
+}
+/** What a listing found, beside the result: what to tell a person, and what failed. */
+export interface DeploymentListing {
+    readonly result: ListResultV1;
+    /** One line for each Environment not listed and each record not admitted, for stderr. */
+    readonly notices: readonly string[];
+    /** Environments whose host could not be listed: their deployments are missing from the result. */
+    readonly failures: readonly {
+        readonly environment: string;
+        readonly adapter: string;
+        readonly error: Error;
+    }[];
+}
+/**
+ * List the deployments of the selected Environments, one adapter `list` call each.
+ *
+ * Only an Environment that deploys immutable deployments (CT33 canonical) is listed; the others are
+ * `unlisted`, with the reason. A record the host returns but `acceptDeploymentRecord` refuses never
+ * fails the listing: that deployment is listed from what its host knows, its record `null`. This
+ * covers a host whose SDK still admits a record this SDK refuses; a host that refuses a stored
+ * record itself may fail its own list (Admin's Services does, AM-152). An Environment whose host
+ * cannot be listed, or whose adapter answers anything but deployments, is a failure, and the others
+ * are still listed.
+ */
+export declare function listDeployments(input: {
+    readonly origin: string;
+    /** The selected Environments, in the Project's order. */
+    readonly environments: readonly (readonly [string, LoadedEnvironment])[];
+    readonly identity?: string;
+    readonly signal: AbortSignal;
+}): Promise<DeploymentListing>;
+/**
+ * One listed deployment, its record admitted when it describes exactly this deployment of this
+ * origin and Environment. Its name comes from the admitted record; otherwise it is named in the
+ * listed Environment, with the commit of the stored record only when that record names this
+ * deployment, origin and Environment, as `deploymentName` reads a commit.
+ */
+export declare function listedDeployment(deployment: ListedDeployment, listing: {
+    readonly origin: string;
+    readonly environment: string;
+    readonly adapter: string;
+}): ListedDeploymentV1;
+/**
+ * The listing as a table for a person, at `now`: each deployment's release, its name as computed
+ * (never shortened, AM-57), its Environment and state, its last call and its expiry, and the URL
+ * `astrale domain install` takes. Without deployments, it says so only for what was listed: nothing
+ * when a host `failed` (stderr says which), and that some Environments were not listed when any
+ * was not.
+ */
+export declare function renderDeploymentList(result: ListResultV1, now: number, failed?: boolean): readonly string[];