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

package/dist/tooling/cli/installed-on.d.ts

@@ -0,0 +1,83 @@
+import type { DomainRegistry, InstallationUnknownReason, InstanceInstallation } from './registry/index.js';
+/**
+ * One instance known to pin a deployment (INSTALLÉ SUR, DX [.83795]): an instance named with
+ * `--instance`, as its Kernel lists it (CT24). Admin does not say which instances pin a release
+ * (A15 is deferred, AM-241), so an instance is known only when it is asked.
+ */
+export interface InstalledOnV1 {
+    readonly source: 'instance';
+    /** The instance as `--instance` named it. */
+    readonly instance: string;
+    /** The instance Kernel URL that answered. */
+    readonly kernel: string;
+}
+/**
+ * Where INSTALLÉ SUR comes from and what of it is unknown. An instance whose installations are
+ * unknown is partial, never "not installed" (AM-198); an instance is known only when `--instance`
+ * names it ([.59528], AM-241).
+ */
+export interface InstallationSourcesV1 {
+    /**
+     * True when an instance may run a deployment that no source names: an `--instance` that could
+     * not say or whose listing is itself partial (a Kernel lists only what the caller reads, AM-83,
+     * AM-84), or no `--instance` at all. False only when every `--instance` listed all it runs.
+     */
+    readonly partial: boolean;
+    /** One entry per distinct `--instance`, in argument order. */
+    readonly instances: readonly InstanceSourceV1[];
+}
+/**
+ * One `--instance`: what its Kernel answered, why that is unknown, or that it was not asked. A
+ * `read` listing names the deployments it pins; with `partial` (always, from C7) one it does not
+ * name may still run there.
+ */
+export type InstanceSourceV1 = {
+    readonly instance: string;
+    readonly state: 'read';
+    readonly kernel: string;
+    readonly partial: boolean;
+} | {
+    readonly instance: string;
+    readonly state: 'unknown';
+    readonly reason: InstallationUnknownReason;
+    readonly code: string;
+} | {
+    readonly instance: string;
+    readonly state: 'skipped';
+};
+/** What the sources answered, kept to join each listed deployment to the instances that pin it. */
+export interface InstallationsRead {
+    readonly sources: InstallationSourcesV1;
+    readonly instances: readonly {
+        readonly instance: string;
+        readonly kernel: string;
+        readonly installations: readonly InstanceInstallation[];
+    }[];
+}
+/** Nothing was listed: no source is asked. */
+export declare function skippedInstallations(instances: readonly string[]): InstallationsRead;
+/**
+ * Ask every `--instance` whether it pins a deployment of the origin. An instance that cannot tell
+ * is recorded as unknown, with why, and the listing stays partial for it (AM-198); a refusal's
+ * message is never relayed, only its code. Only a stop of `signal`, the one every registry read
+ * follows, fails it: an interrupted listing is never printed as a partial one.
+ */
+export declare function readInstallations(registry: Pick<DomainRegistry, 'instance'>, origin: string, instances: readonly string[], signal: AbortSignal): Promise<InstallationsRead>;
+/**
+ * The instances known to pin the deployment served at `url`: an installation whose Kernel lists
+ * its pin under that deployment URL runs that deployment, since one immutable deployment has one
+ * URL. In `--instance` argument order.
+ */
+export declare function installedOn(url: string, read: InstallationsRead): readonly InstalledOnV1[];
+/**
+ * The INSTALLED ON cell: the instances known to pin the deployment, then `?` when an instance may
+ * run it unnamed (the notices say which); `—` only when every `--instance` listed all it runs and
+ * none pins it.
+ */
+export declare function installedOnCell(installed: readonly InstalledOnV1[], sources: InstallationSourcesV1): string;
+/**
+ * One line for stderr per source that could not tell, or one when no instance was asked: an
+ * unknown instance is partial, never "not installed" (AM-198). Only codes the CLI reported are
+ * named, never its messages.
+ */
+export declare function installationNotices(sources: InstallationSourcesV1): readonly string[];

package/dist/tooling/cli/installed-on.js

@@ -0,0 +1,156 @@
+import { isAdminFailure } from './registry/index.js';
+/** `--instance` listings run at once; each is one CLI process reading one instance Kernel. */
+const INSTANCE_READS = 4;
+/** Nothing was listed: no source is asked. */
+export function skippedInstallations(instances) {
+    return Object.freeze({
+        sources: Object.freeze({
+            partial: false,
+            instances: Object.freeze(distinct(instances).map((instance) => Object.freeze({ instance, state: 'skipped' }))),
+        }),
+        instances: Object.freeze([]),
+    });
+}
+/**
+ * Ask every `--instance` whether it pins a deployment of the origin. An instance that cannot tell
+ * is recorded as unknown, with why, and the listing stays partial for it (AM-198); a refusal's
+ * message is never relayed, only its code. Only a stop of `signal`, the one every registry read
+ * follows, fails it: an interrupted listing is never printed as a partial one.
+ */
+export async function readInstallations(registry, origin, instances, signal) {
+    const listed = await mapBounded(distinct(instances), INSTANCE_READS, async (instance) => {
+        try {
+            return { instance, listing: await registry.instance(instance) };
+        }
+        catch (cause) {
+            if (signal.aborted)
+                throw cause;
+            // The CLI could not run for this instance: unknown, never a failure of the listing.
+            return {
+                instance,
+                listing: {
+                    kind: 'unknown',
+                    reason: 'unavailable',
+                    code: 'REGISTRY_CLI_FAILED',
+                },
+            };
+        }
+    });
+    const instanceSources = [];
+    const read = [];
+    for (const { instance, listing } of listed) {
+        if (listing.kind === 'listed') {
+            instanceSources.push(Object.freeze({
+                instance,
+                state: 'read',
+                kernel: listing.kernel,
+                partial: listing.partial,
+            }));
+            read.push(Object.freeze({
+                instance,
+                kernel: listing.kernel,
+                installations: listing.installations.filter((entry) => entry.origin === origin),
+            }));
+        }
+        else {
+            instanceSources.push(Object.freeze({ instance, state: 'unknown', reason: listing.reason, code: listing.code }));
+        }
+    }
+    const partial = instanceSources.length === 0 ||
+        instanceSources.some((entry) => entry.state === 'unknown' || (entry.state === 'read' && entry.partial));
+    return Object.freeze({
+        sources: Object.freeze({ partial, instances: Object.freeze(instanceSources) }),
+        instances: Object.freeze(read),
+    });
+}
+/**
+ * The instances known to pin the deployment served at `url`: an installation whose Kernel lists
+ * its pin under that deployment URL runs that deployment, since one immutable deployment has one
+ * URL. In `--instance` argument order.
+ */
+export function installedOn(url, read) {
+    const deployment = urlOrigin(url);
+    if (deployment === undefined)
+        return Object.freeze([]);
+    const asked = read.instances
+        .filter((entry) => entry.installations.some((installation) => urlOrigin(installation.url) === deployment))
+        .map((entry) => Object.freeze({
+        source: 'instance',
+        instance: entry.instance,
+        kernel: entry.kernel,
+    }));
+    return Object.freeze(asked);
+}
+/** Names shown before the cell counts the rest; the JSON keeps them all. */
+const CELL_NAMES = 3;
+/**
+ * The INSTALLED ON cell: the instances known to pin the deployment, then `?` when an instance may
+ * run it unnamed (the notices say which); `—` only when every `--instance` listed all it runs and
+ * none pins it.
+ */
+export function installedOnCell(installed, sources) {
+    const names = distinct(installed.map((entry) => entry.instance));
+    const shown = names.length > CELL_NAMES
+        ? `${names.slice(0, CELL_NAMES).join(', ')} +${names.length - CELL_NAMES}`
+        : names.join(', ');
+    if (!sources.partial)
+        return names.length === 0 ? '—' : shown;
+    return names.length === 0 ? '?' : `${shown}, ?`;
+}
+const INSTANCE_REASONS = {
+    timeout: 'it did not answer in time',
+    refused: 'its Kernel refused the read',
+    unavailable: 'it could not be reached',
+    unsupported: 'its Kernel does not list installed releases',
+};
+/**
+ * One line for stderr per source that could not tell, or one when no instance was asked: an
+ * unknown instance is partial, never "not installed" (AM-198). Only codes the CLI reported are
+ * named, never its messages.
+ */
+export function installationNotices(sources) {
+    const notices = [];
+    if (sources.instances.length === 0) {
+        notices.push('INSTALLED ON is unknown: no instance was asked, and Admin does not say which instances ' +
+            'pin a deployment. Ask an instance with --instance <name>.');
+    }
+    for (const entry of sources.instances) {
+        if (entry.state === 'read') {
+            if (entry.partial) {
+                notices.push(`INSTALLED ON is partial: instance ${entry.instance} lists only what its Kernel shows ` +
+                    'this caller, so a deployment it does not list may still run there.');
+            }
+            continue;
+        }
+        if (entry.state !== 'unknown')
+            continue;
+        notices.push(`INSTALLED ON is partial: what instance ${entry.instance} runs is unknown (${entry.code}): ` +
+            (isAdminFailure(entry.code)
+                ? "the Astrale CLI could not read Admin's registry, which names what the instance runs."
+                : `${INSTANCE_REASONS[entry.reason]}.`));
+    }
+    return Object.freeze(notices);
+}
+function urlOrigin(input) {
+    try {
+        return new URL(input).origin;
+    }
+    catch {
+        return undefined;
+    }
+}
+function distinct(values) {
+    return [...new Set(values)];
+}
+async function mapBounded(inputs, limit, map) {
+    const outputs = Array.from({ length: inputs.length });
+    let next = 0;
+    const worker = async () => {
+        while (next < inputs.length) {
+            const index = next++;
+            outputs[index] = await map(inputs[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, inputs.length) }, worker));
+    return outputs;
+}

package/dist/tooling/cli/legacy/deploy-result.d.ts

@@ -0,0 +1,28 @@
+import type { ReadyDeployResult } from '../../../deployment/index.js';
+import type { DeployResultV1 } from '../deploy-result.js';
+/**
+ * The deploy result of a stable target: the legacy direct-mode path (`prepare`/`deploy` adapter
+ * operations) replaces the code its stable target runs in place and serves a v3 Publication, so
+ * the result names no release, no build digest, no provider script, no secrets state and no commit.
+ * Those operations report a provider deployment identifier (a Worker version id, a Services
+ * deployment digest), never the script they replace; that identifier stays on the stderr
+ * `Deployment:` progress line and never fills `deployment.script`. Its URL is the public URL
+ * `astrale domain install` fetches, which differs from the issuer only under adapter-cloudflare
+ * `identityIssuer`.
+ *
+ * @deprecated Stable-target deploy path only. Replacement: `deployResult`, the result of an
+ * immutable deployment. 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 stableTargetDeployResult(input: {
+    readonly environment: string;
+    readonly adapter: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly deployment: ReadyDeployResult;
+}): DeployResultV1;

package/dist/tooling/cli/legacy/deploy-result.js

@@ -0,0 +1,37 @@
+/**
+ * The deploy result of a stable target: the legacy direct-mode path (`prepare`/`deploy` adapter
+ * operations) replaces the code its stable target runs in place and serves a v3 Publication, so
+ * the result names no release, no build digest, no provider script, no secrets state and no commit.
+ * Those operations report a provider deployment identifier (a Worker version id, a Services
+ * deployment digest), never the script they replace; that identifier stays on the stderr
+ * `Deployment:` progress line and never fills `deployment.script`. Its URL is the public URL
+ * `astrale domain install` fetches, which differs from the issuer only under adapter-cloudflare
+ * `identityIssuer`.
+ *
+ * @deprecated Stable-target deploy path only. Replacement: `deployResult`, the result of an
+ * immutable deployment. 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 function stableTargetDeployResult(input) {
+    const { publication, addressing } = input.deployment.release;
+    return Object.freeze({
+        format: 'astrale.deploy-result',
+        version: 1,
+        origin: publication.origin,
+        environment: input.environment,
+        url: addressing.publicUrl,
+        release: null,
+        build: null,
+        schema: Object.freeze({ revision: publication.schema.revision }),
+        deployment: Object.freeze({
+            adapter: `${input.adapter.name}@${input.adapter.version}`,
+            script: null,
+            state: 'replaced',
+        }),
+        commit: null,
+    });
+}

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

@@ -0,0 +1,21 @@
+import type { Adapter, LegacyAdapter } from '../../../deployment/adapter/index.js';
+/**
+ * An adapter that serves the legacy direct-mode path: a `LegacyAdapter`, or an adapter interface
+ * v2 that keeps `prepare` and `deploy` for its direct-mode Environments.
+ *
+ * @deprecated Stable-target deploy path only. Replacement: `deployRelease` of adapter interface
+ * v2. Consumers: `astrale-domain deploy` on 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 type StableTargetAdapter<Parameters extends object = object> = (Adapter<Parameters> | LegacyAdapter<Parameters>) & Pick<LegacyAdapter<Parameters>, 'prepare' | 'deploy'>;
+/**
+ * The adapter of an Environment the stable-target path deploys, with its `prepare` and `deploy`.
+ * An adapter that implements only adapter interface v2 has neither, and this path cannot deploy it.
+ *
+ * @deprecated Stable-target deploy path only; see `StableTargetAdapter`.
+ */
+export declare function stableTargetAdapter<Parameters extends object>(adapter: Adapter<Parameters> | LegacyAdapter<Parameters>): StableTargetAdapter<Parameters>;

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

@@ -0,0 +1,14 @@
+/**
+ * The adapter of an Environment the stable-target path deploys, with its `prepare` and `deploy`.
+ * An adapter that implements only adapter interface v2 has neither, and this path cannot deploy it.
+ *
+ * @deprecated Stable-target deploy path only; see `StableTargetAdapter`.
+ */
+export function stableTargetAdapter(adapter) {
+    if (typeof adapter.prepare !== 'function' || typeof adapter.deploy !== 'function') {
+        throw new TypeError(`Adapter ${adapter.name}@${adapter.version} implements only adapter interface v2 ` +
+            '(deployRelease); this astrale-domain deploys through prepare and deploy, the legacy ' +
+            'direct-mode path, and never calls deployRelease.');
+    }
+    return adapter;
+}

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/legacy/uploaded-build.d.ts

@@ -0,0 +1,11 @@
+import type { Bundle, BuildDigest } from '../../../deployment/index.js';
+/**
+ * What a stable-target deploy prints when its upload does not carry the build digest
+ * `astrale-domain build` gives for the same tree. A stable target never serves a build digest, so
+ * the deployment proceeds with this warning where an immutable deployment refuses the upload.
+ *
+ * @deprecated Stable-target deploy path (`prepare`/`deploy` adapter operations) only. Replacement:
+ * `verifyUploadedBuild`, which refuses the upload of an immutable deployment. Deleted with the
+ * legacy deploy path, once no supported configuration selects it (CT33).
+ */
+export declare function stableTargetBuildWarning(bundle: Bundle, uploaded: BuildDigest): string | undefined;

package/dist/tooling/cli/legacy/uploaded-build.js

@@ -0,0 +1,22 @@
+import { verifyUploadedBuild } from '../../../deployment/index.js';
+import { isBundle } from '../../../deployment/verify/index.js';
+/**
+ * What a stable-target deploy prints when its upload does not carry the build digest
+ * `astrale-domain build` gives for the same tree. A stable target never serves a build digest, so
+ * the deployment proceeds with this warning where an immutable deployment refuses the upload.
+ *
+ * @deprecated Stable-target deploy path (`prepare`/`deploy` adapter operations) only. Replacement:
+ * `verifyUploadedBuild`, which refuses the upload of an immutable deployment. Deleted with the
+ * legacy deploy path, once no supported configuration selects it (CT33).
+ */
+export function stableTargetBuildWarning(bundle, uploaded) {
+    if (!isBundle(bundle))
+        throw new TypeError('Uploaded build check requires an admitted Bundle.');
+    try {
+        verifyUploadedBuild(bundle, uploaded);
+        return undefined;
+    }
+    catch (refusal) {
+        return `${refusal.message} A stable target never serves a build digest, so this deployment proceeds; an immutable deployment refuses this upload.`;
+    }
+}