@astrale-os/sdk 0.6.0-beta.2 → 0.6.0-beta.21

package/dist/project/define.js

@@ -1,14 +1,18 @@
-import { isApplication } from '../application/index.js';
+import { isDomainDefinition } from '../application/index.js';
 import { isDeployment } from '../deployment/deployment.js';
+import { ENVIRONMENT_NAME } from '../deployment/environment.js';
 import { isTests } from '../testing/index.js';
+import { installCommand } from './install-command.js';
 const admittedProjects = new WeakSet();
-const ENVIRONMENT_NAME = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/u;
 /** Capture one inert Project definition without loading entrypoints or performing effects. */
 export function defineProject(input) {
     const value = record(input, 'Project definition');
-    exact(value, ['application', 'environments'], ['entrypoints', 'tests'], invalid);
-    if (!isApplication(input.application))
-        throw new TypeError('Project Application is not admitted.');
+    if (Object.hasOwn(value, 'application')) {
+        throw new TypeError('Project `application` is now `domain`: defineProject({ domain, environments }).');
+    }
+    exact(value, ['domain', 'environments'], ['entrypoints', 'tests'], invalid);
+    if (!isDomainDefinition(input.domain))
+        throw new TypeError('Project Domain is not admitted.');
     const environments = record(input.environments, 'Project environments');
     if (Reflect.ownKeys(environments).some((key) => typeof key !== 'string')) {
         throw new TypeError('Project Environment names must be strings.');
@@ -16,27 +20,28 @@ export function defineProject(input) {
     const names = Object.keys(environments);
     if (names.length === 0)
         throw new TypeError('Project must declare at least one Environment.');
-    const captured = Object.create(null);
-    for (const name of names) {
+    const declared = names.map((name) => {
         if (!ENVIRONMENT_NAME.test(name)) {
             throw new TypeError(`Project Environment name "${name}" is not normalized.`);
         }
-        const environment = record(environments[name], `Project Environment ${name}`);
-        exact(environment, ['deployment'], ['installation'], () => invalidEnvironment(name));
+        return [name, record(environments[name], `Project Environment ${name}`)];
+    });
+    // One refusal names every Environment that declares installation, each with its own commands.
+    const installations = declared
+        .filter(([, environment]) => Object.hasOwn(environment, 'installation'))
+        .map(([name, environment]) => installationRefusal(environment, name));
+    if (installations.length > 0)
+        throw new TypeError(installations.join('\n'));
+    const captured = Object.create(null);
+    for (const [name, environment] of declared) {
+        exact(environment, ['deployment'], [], () => invalidEnvironment(name));
         if (!isDeployment(environment.deployment)) {
             throw new TypeError(`Project Environment ${name} deployment is not admitted.`);
         }
-        const installation = environment.installation === undefined
-            ? undefined
-            : admitInstallation(environment.installation, name);
         environment.deployment.adapter.admit?.(environment.deployment.parameters, {
             environment: name,
-            ...(installation === undefined ? {} : { installation }),
-        });
-        captured[name] = Object.freeze({
-            deployment: environment.deployment,
-            ...(installation === undefined ? {} : { installation }),
         });
+        captured[name] = Object.freeze({ deployment: environment.deployment });
     }
     const entrypoints = input.entrypoints === undefined ? undefined : admitEntrypoints(input.entrypoints);
     if (input.tests !== undefined && !isTests(input.tests)) {
@@ -44,7 +49,7 @@ export function defineProject(input) {
     }
     const project = Object.freeze({
         kind: 'project',
-        application: input.application,
+        domain: input.domain,
         environments: Object.freeze(captured),
         ...(entrypoints === undefined ? {} : { entrypoints }),
         ...(input.tests === undefined ? {} : { tests: input.tests }),
@@ -68,22 +73,37 @@ function admitEntrypoints(input) {
     }
     return Object.freeze({ runtime: input.runtime });
 }
-function admitInstallation(input, environment) {
-    const value = record(input, `Project Environment ${environment} installation`);
-    exact(value, ['instance'], ['identity'], () => {
-        throw new TypeError(`Project Environment ${environment} installation may contain only instance and identity.`);
-    });
-    const instance = stableCoordinate(value.instance, 'installation instance');
-    const identity = value.identity === undefined
-        ? undefined
-        : stableCoordinate(value.identity, 'installation identity');
-    return Object.freeze({ instance, ...(identity === undefined ? {} : { identity }) });
-}
-function stableCoordinate(input, label) {
-    if (typeof input !== 'string' || input.length === 0 || input.trim() !== input) {
-        throw new TypeError(`Project ${label} must be a non-empty stable string.`);
+/**
+ * A deploy no longer installs (DX [.81399], AM-72): an Environment that still declares
+ * `installation` is refused before any effect, with the commands that replace it. Its only
+ * consumer pins an SDK older than this refusal.
+ *
+ * adapter-astrale deploys on Admin's Services, never through the installation's instance. The
+ * installation's instance and identity move to the install command.
+ */
+function installationRefusal(environment, name) {
+    const declared = environment.installation;
+    if (declared === undefined) {
+        return (`Project Environment ${name} declares \`installation\`, which a deploy no longer reads: a ` +
+            'deploy never installs. Remove the key.');
     }
-    return input;
+    const installation = declared !== null && typeof declared === 'object'
+        ? declared
+        : {};
+    const instance = stable(installation.instance);
+    const identity = stable(installation.identity);
+    return (`Project Environment ${name} declares installation, and a deploy no longer installs. ` +
+        `Remove \`installation\`, run \`astrale-domain deploy ${name}\`, ` +
+        `then install the URL it prints with \`${installCommand(instance, identity)}\`.`);
+}
+/** A declared coordinate worth repeating in guidance: a non-empty single-line trimmed string. */
+function stable(input) {
+    return typeof input === 'string' &&
+        input.length > 0 &&
+        input.trim() === input &&
+        !/[\s`]/u.test(input)
+        ? input
+        : undefined;
 }
 function record(input, label) {
     if (input === null || typeof input !== 'object' || Array.isArray(input)) {
@@ -99,8 +119,8 @@ function exact(input, required, optional, fail) {
     }
 }
 function invalid() {
-    throw new TypeError('Project definition may contain only application, environments, entrypoints, and tests.');
+    throw new TypeError('Project definition may contain only domain, environments, entrypoints, and tests.');
 }
 function invalidEnvironment(name) {
-    throw new TypeError(`Project Environment ${name} may contain only deployment and installation.`);
+    throw new TypeError(`Project Environment ${name} may contain only deployment.`);
 }

package/dist/project/index.d.ts

@@ -1,4 +1,4 @@
 export { admitProjectModule, PROJECT_EXPORT_HINT } from './admit.js';
 export { defineProject, isProject } from './define.js';
 export type { ProjectInput } from './define.js';
-export type { ApplicationOfProject, EnvironmentsOfProject, Project, ProjectEntrypoints, ProjectEnvironment, } from './project.js';
+export type { DomainDefinitionOfProject, EnvironmentsOfProject, Project, ProjectEntrypoints, ProjectEnvironment, } from './project.js';

package/dist/project/install-command.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The command that installs a deployed URL on an instance, as every SDK refusal and help text
+ * names it. A deploy never installs (DX [.81399], AM-72): `astrale-domain deploy <environment>`
+ * prints a URL, and this command installs it.
+ *
+ * `--direct` sends a URL install to the instance Kernel, which the astrale CLI requires today and
+ * accepts until D13. When the CLI retires it, this is the one SDK text to change; the adapter and
+ * scaffold READMEs and templates repeat it as prose.
+ */
+export declare function installCommand(instance?: string, identity?: string): string;

package/dist/project/install-command.js

@@ -0,0 +1,13 @@
+/**
+ * The command that installs a deployed URL on an instance, as every SDK refusal and help text
+ * names it. A deploy never installs (DX [.81399], AM-72): `astrale-domain deploy <environment>`
+ * prints a URL, and this command installs it.
+ *
+ * `--direct` sends a URL install to the instance Kernel, which the astrale CLI requires today and
+ * accepts until D13. When the CLI retires it, this is the one SDK text to change; the adapter and
+ * scaffold READMEs and templates repeat it as prose.
+ */
+export function installCommand(instance = '<instance>', identity) {
+    return (`astrale domain install <url> --direct -i ${instance}` +
+        (identity === undefined ? '' : ` --as ${identity}`));
+}

package/dist/project/project.d.ts

@@ -1,24 +1,26 @@
-import type { ApplicationIdentity } from '../application/index.js';
-import type { InstallationTarget } from '../deployment/adapter/index.js';
+import type { DomainDefinitionIdentity } from '../application/index.js';
 import type { Tests } from '../testing/index.js';
 export interface ProjectEntrypoints {
     readonly runtime: string;
 }
+/**
+ * One Environment of a Project: where and how its deployments are made. It never names an
+ * instance: a deploy installs nothing, and `astrale domain install <url>` installs a deployment.
+ */
 export interface ProjectEnvironment<DeploymentValue = unknown> {
     readonly deployment: DeploymentValue;
-    readonly installation?: InstallationTarget;
 }
 /** The complete independently executable software-product definition in astrale.config.ts. */
-export interface Project<ApplicationValue extends ApplicationIdentity = ApplicationIdentity, EnvironmentsValue extends Readonly<Record<string, ProjectEnvironment>> = Readonly<Record<string, ProjectEnvironment>>, TestsValue extends Tests | undefined = undefined> {
+export interface Project<DomainDefinitionValue extends DomainDefinitionIdentity = DomainDefinitionIdentity, EnvironmentsValue extends Readonly<Record<string, ProjectEnvironment>> = Readonly<Record<string, ProjectEnvironment>>, TestsValue extends Tests | undefined = undefined> {
     readonly kind: 'project';
-    readonly application: ApplicationValue;
+    readonly domain: DomainDefinitionValue;
     readonly environments: EnvironmentsValue;
     readonly entrypoints?: ProjectEntrypoints;
     readonly tests?: TestsValue;
 }
-export type ApplicationOfProject<Value> = Value extends {
-    readonly application: infer ApplicationValue;
-} ? Extract<ApplicationValue, ApplicationIdentity> : never;
+export type DomainDefinitionOfProject<Value> = Value extends {
+    readonly domain: infer DomainDefinitionValue;
+} ? Extract<DomainDefinitionValue, DomainDefinitionIdentity> : never;
 export type EnvironmentsOfProject<Value> = Value extends {
     readonly environments: infer EnvironmentsValue;
 } ? EnvironmentsValue : never;

package/dist/testing/dataset/builder.d.ts

@@ -1,6 +1,6 @@
 import type { Edge } from '../../platform/graph/edge/index.js';
 import type { Node, NodeId } from '../../platform/graph/node/index.js';
-import type { PropertyInputOf, ResolvedClass, schema } from '../../platform/schema/index.js';
+import type { ResolvedClass, schema, StoredPropertyInputOf } from '../../platform/schema/index.js';
 import type { DatasetNode, DatasetReferences } from './dataset.js';
 import { type DatasetReferenceInput } from './references.js';
 /** Resolved Classes of the exact authored Schema, keyed by their authored names. */
@@ -10,11 +10,11 @@ export type DatasetEndpoint = Node | NodeId | string;
 export interface DatasetNodeInput<Class extends ResolvedClass<'node'>> {
     /** Stable identity within the Dataset; derived from the Class name and insertion order when omitted. */
     readonly id?: string;
-    readonly props?: PropertyInputOf<Class>;
+    readonly props?: StoredPropertyInputOf<Class>;
 }
 export interface DatasetEdgeInput<Class extends ResolvedClass<'edge'>> {
     readonly slug?: string;
-    readonly props?: PropertyInputOf<Class>;
+    readonly props?: StoredPropertyInputOf<Class>;
 }
 /** Graph authoring surface handed to one Dataset definition. Facts are canonical Kernel values. */
 export interface DatasetGraph<Schema extends schema.DomainSchema> {

package/dist/testing/dataset/define.d.ts

@@ -7,7 +7,7 @@ export type AuthoredDatasetVariables = DatasetVariables | void;
 /** The exact variables record retained by a Dataset for one authored return type. */
 export type DatasetVariablesOf<Value> = [Value] extends [void] ? Readonly<Record<never, never>> : Value extends DatasetVariables ? Value : never;
 export interface DatasetInput<Schema extends schemaLanguage.DomainSchema, Variables extends AuthoredDatasetVariables> {
-    /** Stable lowercase identity, unique within one Application. */
+    /** Stable lowercase identity, unique within one Domain. */
     readonly id: string;
     readonly title?: string;
     readonly description?: string;

package/dist/testing/load.js

@@ -21,7 +21,7 @@ export async function loadDataset(reference, load, source) {
         throw new TypeError(`Dataset module ${reference.path} default export is not an admitted Dataset.`);
     }
     if (dataset.schema !== source) {
-        throw new TypeError(`Dataset ${dataset.id} (${reference.path}) targets Schema ${dataset.schema.origin}, not the exact Application Schema.`);
+        throw new TypeError(`Dataset ${dataset.id} (${reference.path}) targets Schema ${dataset.schema.origin}, not the exact Domain Schema.`);
     }
     return Object.freeze({ reference, dataset });
 }

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

@@ -1,19 +1,24 @@
 import type { LintReportFormat } from '../linter/index.js';
-export declare const COMMANDS: readonly ['dev', 'build', 'deploy', 'test', 'lint', 'package', 'upgrade'];
+import { type Version } from '../../platform/versioning/index.js';
+export declare const COMMANDS: readonly ['build', 'deploy', 'diff', 'list', 'publish', 'test', 'lint', 'package', 'upgrade', 'yank'];
 export type Command = (typeof COMMANDS)[number];
 export interface ParsedArgs {
     readonly command: Command;
     readonly env: string;
     readonly fix?: boolean;
     readonly format?: LintReportFormat;
-    readonly deployOnly?: boolean;
     readonly identity?: string;
-    readonly credentialFile?: string;
     readonly suite?: string;
-    readonly sessionFile?: string;
-    readonly secretsFile?: string;
     readonly channel?: string;
     readonly check?: boolean;
+    readonly json?: boolean;
+    /** `yank`: the published version it names. */
+    readonly version?: Version;
+    /** `yank --undo`: restore the version instead of yanking it. */
+    readonly undo?: boolean;
+    readonly allowDirty?: boolean;
+    /** `list`: instances to ask what they run, in argument order. */
+    readonly instances?: readonly string[];
 }
 /** Parse the frozen `astrale-domain` command grammar without performing effects. */
 export declare function parseArgs(argv: readonly string[]): ParsedArgs;

package/dist/tooling/cli/arguments.js

@@ -1,5 +1,17 @@
-import { isAbsolute, normalize } from 'node:path';
-export const COMMANDS = ['dev', 'build', 'deploy', 'test', 'lint', 'package', 'upgrade'];
+import { acceptVersion } from '../../platform/versioning/index.js';
+import { installCommand } from '../../project/install-command.js';
+export const COMMANDS = [
+    'build',
+    'deploy',
+    'diff',
+    'list',
+    'publish',
+    'test',
+    'lint',
+    'package',
+    'upgrade',
+    'yank',
+];
 /** Parse the frozen `astrale-domain` command grammar without performing effects. */
 export function parseArgs(argv) {
     const [command, ...rest] = argv;
@@ -7,35 +19,18 @@ export function parseArgs(argv) {
         return parseUpgrade(rest);
     const fix = rest.includes('--fix');
     const deployOnly = rest.includes('--deploy-only');
-    let sessionFile;
-    let secretsFile;
-    let credentialFile;
+    const json = rest.includes('--json');
+    const undo = rest.includes('--undo');
+    const allowDirty = rest.includes('--allow-dirty');
     let identity;
     let suite;
     let format;
     let environment;
+    const instances = [];
     const cleaned = [];
     for (let index = 0; index < rest.length; index += 1) {
         const argument = rest[index];
-        if (argument === '--session-file') {
-            sessionFile = absoluteFilePath('--session-file', rest[++index]);
-        }
-        else if (argument.startsWith('--session-file=')) {
-            sessionFile = absoluteFilePath('--session-file', argument.slice('--session-file='.length));
-        }
-        else if (argument === '--credential-file') {
-            credentialFile = absoluteFilePath('--credential-file', rest[++index]);
-        }
-        else if (argument.startsWith('--credential-file=')) {
-            credentialFile = absoluteFilePath('--credential-file', argument.slice('--credential-file='.length));
-        }
-        else if (argument === '--secrets-file') {
-            secretsFile = absoluteFilePath('--secrets-file', rest[++index]);
-        }
-        else if (argument.startsWith('--secrets-file=')) {
-            secretsFile = absoluteFilePath('--secrets-file', argument.slice('--secrets-file='.length));
-        }
-        else if (argument === '--as') {
+        if (argument === '--as') {
             identity = requiredValue('--as', rest[++index]);
         }
         else if (argument.startsWith('--as=')) {
@@ -53,13 +48,24 @@ export function parseArgs(argv) {
         else if (argument.startsWith('--environment=')) {
             environment = requiredValue('--environment', argument.slice('--environment='.length));
         }
+        else if (command === 'list' && argument === '--instance') {
+            // Only `list` asks instances; elsewhere `--instance` stays unknown, as deploy removed it.
+            instances.push(requiredValue('--instance', rest[++index]));
+        }
+        else if (command === 'list' && argument.startsWith('--instance=')) {
+            instances.push(requiredValue('--instance', argument.slice('--instance='.length)));
+        }
         else if (argument === '--suite') {
             suite = requiredValue('--suite', rest[++index]);
         }
         else if (argument.startsWith('--suite=')) {
             suite = requiredValue('--suite', argument.slice('--suite='.length));
         }
-        else if (argument === '--fix' || argument === '--deploy-only') {
+        else if (argument === '--fix' ||
+            argument === '--deploy-only' ||
+            argument === '--json' ||
+            argument === '--undo' ||
+            argument === '--allow-dirty') {
             continue;
         }
         else if (argument.startsWith('-')) {
@@ -71,23 +77,37 @@ export function parseArgs(argv) {
     }
     if (fix && command !== 'lint')
         throw new Error('`--fix` is only valid for `lint`.');
-    if (format !== undefined && command !== 'lint') {
-        throw new Error('`--format` is only valid for `lint`.');
+    if (json &&
+        command !== 'build' &&
+        command !== 'deploy' &&
+        command !== 'diff' &&
+        command !== 'list' &&
+        command !== 'publish' &&
+        command !== 'yank') {
+        throw new Error('`--json` is only valid for `build`, `deploy`, `diff`, `list`, `publish` or `yank`.');
     }
-    if ((sessionFile !== undefined || credentialFile !== undefined || secretsFile !== undefined) &&
-        command !== 'dev') {
-        throw new Error('`--session-file`, `--credential-file`, and `--secrets-file` are only valid for `dev`.');
+    if (allowDirty && command !== 'publish') {
+        throw new Error('`--allow-dirty` is only valid for `publish`.');
     }
-    if (identity !== undefined && credentialFile !== undefined) {
-        throw new Error('Choose either `--as` or `--credential-file`, not both.');
+    if (undo && command !== 'yank')
+        throw new Error('`--undo` is only valid for `yank`.');
+    if (format !== undefined && command !== 'lint') {
+        throw new Error('`--format` is only valid for `lint`.');
     }
-    if ((deployOnly || identity !== undefined) && command !== 'dev' && command !== 'deploy') {
-        throw new Error('`--deploy-only` and `--as` are only valid for `dev` or `deploy`.');
+    if (deployOnly && command !== 'deploy')
+        refuseDeployOnly(undefined);
+    if (identity !== undefined &&
+        command !== 'deploy' &&
+        command !== 'diff' &&
+        command !== 'list' &&
+        command !== 'publish') {
+        throw new Error('`--as` is only valid for `deploy`, `diff`, `list` or `publish`.');
     }
-    if (environment !== undefined && command !== 'dev' && command !== 'deploy') {
-        if (command !== 'test') {
-            throw new Error('`--environment` is only valid for `dev`, `deploy`, or `test`.');
-        }
+    if (environment !== undefined &&
+        command !== 'deploy' &&
+        command !== 'list' &&
+        command !== 'test') {
+        throw new Error('`--environment` is only valid for `deploy`, `list` or `test`.');
     }
     if (suite !== undefined && command !== 'test') {
         throw new Error('`--suite` is only valid for `test`.');
@@ -97,31 +117,65 @@ export function parseArgs(argv) {
         throw new Error('Choose either a positional Environment or `--environment`, not both.');
     }
     switch (command) {
-        case 'dev':
         case 'deploy': {
             if (positionals.length > 1) {
                 throw new Error(`\`${command}\` accepts exactly one Environment.`);
             }
-            const env = environment ?? positionals[0] ?? (command === 'dev' ? 'development' : undefined);
+            const env = environment ?? positionals[0];
             if (!env) {
                 throw new Error(`\`${command}\` requires an Environment, e.g. \`${command} development\`.`);
             }
+            if (deployOnly)
+                refuseDeployOnly(command, env);
             return {
                 command,
                 env,
-                ...(deployOnly ? { deployOnly: true } : {}),
+                ...(json ? { json: true } : {}),
                 ...(identity === undefined ? {} : { identity }),
-                ...(credentialFile === undefined ? {} : { credentialFile }),
-                ...(sessionFile === undefined ? {} : { sessionFile }),
-                ...(secretsFile === undefined ? {} : { secretsFile }),
             };
         }
+        case 'list':
+            // Every Environment of the Project, or the one `--environment` names.
+            if (positionals.length > 0) {
+                throw new Error('`list` does not accept positional arguments; use `--environment`.');
+            }
+            return {
+                command: 'list',
+                env: environment ?? '',
+                ...(json ? { json: true } : {}),
+                ...(identity === undefined ? {} : { identity }),
+                ...(instances.length === 0 ? {} : { instances: [...new Set(instances)] }),
+            };
         case 'build':
         case 'package':
             if (positionals.length > 0) {
                 throw new Error(`\`${command}\` does not accept positional arguments.`);
             }
-            return { command, env: '' };
+            return { command, env: '', ...(json ? { json: true } : {}) };
+        case 'diff':
+            // The version is package.json's: no command takes a version number (tech Versioning).
+            if (positionals.length > 0) {
+                throw new Error('`diff` does not accept positional arguments; it reads package.json.');
+            }
+            return {
+                command: 'diff',
+                env: '',
+                ...(json ? { json: true } : {}),
+                ...(identity === undefined ? {} : { identity }),
+            };
+        case 'publish': {
+            // The version is package.json's: the one positional names the Environment (tech Versioning).
+            if (positionals.length !== 1) {
+                throw new Error('`publish` takes exactly one Environment, e.g. `publish production`; it reads the version from package.json.');
+            }
+            return {
+                command: 'publish',
+                env: positionals[0],
+                ...(json ? { json: true } : {}),
+                ...(allowDirty ? { allowDirty: true } : {}),
+                ...(identity === undefined ? {} : { identity }),
+            };
+        }
         case 'test':
             if (positionals.length > 0) {
                 throw new Error('`test` does not accept positional arguments; use `--environment`.');
@@ -131,6 +185,18 @@ export function parseArgs(argv) {
                 env: environment ?? '',
                 ...(suite === undefined ? {} : { suite }),
             };
+        case 'yank': {
+            if (positionals.length !== 1) {
+                throw new Error('`yank` takes exactly one published version, e.g. `yank 1.5.0`.');
+            }
+            return {
+                command: 'yank',
+                env: '',
+                version: acceptVersion(positionals[0]),
+                ...(undo ? { undo: true } : {}),
+                ...(json ? { json: true } : {}),
+            };
+        }
         case 'lint':
             if (positionals.length > 0)
                 throw new Error('`lint` does not accept positional arguments.');
@@ -144,6 +210,18 @@ export function parseArgs(argv) {
             throw new Error(command ? `Unknown command "${command}".` : 'Missing command.');
     }
 }
+/**
+ * `--deploy-only` suppressed the installation a deploy used to make. A deploy never installs
+ * (DX [.81399], AM-72), so the flag is refused before any effect, naming the commands that
+ * replace it. Its only consumer pins an SDK older than this refusal.
+ */
+function refuseDeployOnly(command, environment) {
+    const refusal = '`--deploy-only` is no longer accepted: a deploy never installs.';
+    if (command === undefined || environment === undefined)
+        throw new Error(refusal);
+    throw new Error(`${refusal} Run \`astrale-domain ${command} ${environment}\` without it, then install the ` +
+        `URL it prints with \`${installCommand()}\`.`);
+}
 function parseUpgrade(args) {
     let channel = 'beta';
     let check = false;
@@ -173,10 +251,3 @@ function requiredValue(flag, input) {
         throw new Error(`${flag} needs a value.`);
     return input;
 }
-function absoluteFilePath(flag, input) {
-    const value = requiredValue(flag, input);
-    if (!isAbsolute(value) || normalize(value) !== value) {
-        throw new Error(`${flag} needs a normalized absolute path, got "${value}"`);
-    }
-    return value;
-}

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

@@ -0,0 +1,55 @@
+import type { Build, BuildDigest, BuildManifestV1, Bundle, Bundler, ResolvedRuntimeReference } from '../../deployment/index.js';
+import type { LoadedProject } from './project.js';
+/** `astrale-domain build --json`: the build digest of every distinct bundler of the Project. */
+export interface BuildResultV1 {
+    readonly format: 'astrale.build-result';
+    readonly version: 1;
+    readonly origin: string;
+    readonly schema: {
+        readonly revision: BuildManifestV1['schema']['revision'];
+    };
+    readonly builds: readonly {
+        readonly bundler: {
+            readonly id: string;
+            readonly version: string;
+        };
+        readonly digest: BuildDigest;
+    }[];
+}
+/** One bundler a Project declares, with the Environments whose adapters declare it. */
+export interface ProjectBundler {
+    readonly bundler: Bundler;
+    readonly environments: readonly {
+        readonly name: string;
+        /** `<adapter name>@<adapter version>` */
+        readonly adapter: string;
+    }[];
+}
+/**
+ * The distinct bundlers of a Project's Environments, in declaration order. Environments whose
+ * adapters declare one bundler object share its build. Two copies of one bundler (two installed
+ * versions of its package) are two bundlers even under one id and version, since their code can
+ * differ.
+ */
+export declare function projectBundlers(project: LoadedProject): readonly ProjectBundler[];
+/** Bundle one Build without any Environment and identify the bytes by their build digest. */
+export declare function bundleBuild<const BuildValue extends Build>(input: {
+    readonly bundler: Bundler;
+    readonly projectDir: string;
+    readonly build: BuildValue;
+    readonly runtime: ResolvedRuntimeReference;
+    readonly signal: AbortSignal;
+}): Promise<Bundle<BuildValue>>;
+/**
+ * One entry per distinct build: copies of one bundler that produced the same bytes give one entry,
+ * copies that produced different bytes give one entry each.
+ */
+export declare function buildResult(build: Build, bundles: readonly Bundle[]): BuildResultV1;
+/**
+ * A warning for every bundler id and version whose copies produced different bytes: each copy's
+ * Environments deploy their own build, so the Project has more than one build for that bundler.
+ */
+export declare function bundlerCopyWarnings(built: readonly {
+    readonly source: ProjectBundler;
+    readonly bundle: Bundle;
+}[]): readonly string[];