@astrale-os/sdk 0.6.0-beta.22 → 0.6.0-beta.24

package/dist/tooling/cli/deploy-mode.js

@@ -1,135 +1,59 @@
-import { installCommand } from '../../project/install-command.js';
-/** The adapter names of the first-party adapters whose parameters CT33 classifies. */
-const CLOUDFLARE = 'cloudflare';
-const ASTRALE = 'astrale';
-/** The parameters that named the stable Service of adapter-astrale's removed instance mode. */
-const ASTRALE_SERVICE_PARAMETERS = ['serviceKey', 'name'];
-const CLOUDFLARE_DIRECT_PARAMETERS = [
-    'route',
-    'workerName',
-    'identityIssuer',
-    'addressing',
-    'signingIdentity',
-];
-/**
- * Select the deploy mode of one Environment (CT33). It reads the configuration and the command
- * only, and has no effect.
- *
- * A refusal wins over every other reason. adapter-astrale deploys immutable deployments only
- * (`deployRelease`): its removed instance mode's `instance` and `signingIdentity` are refused
- * before any effect, since their one consumer pins an older SDK (AM-72). Otherwise the Environment
- * is on the legacy direct-mode path when adapter-cloudflare names a direct-mode parameter or no
- * `namespace`, or when its adapter declares no `deployRelease`. Everything else is canonical,
- * and `publish` refuses the legacy direct-mode path: a stable target serves no release, so no
- * version can name it.
- *
- * Within canonical adapter-cloudflare (with `namespace`), a direct-mode parameter is refused
- * rather than silently selecting either mode, and so is `wrangler.triggers`: an immutable
- * deployment runs no cron of its own (D13). The bundling-affecting `wrangler` keys are refused by
- * adapter-cloudflare itself for every Environment (AM-51).
- */
+/** Inspect one Environment's deployment contract without building or changing any provider. */
 export function selectDeployMode(input) {
-    const { command, environment, definition } = input;
-    const { adapter } = definition.deployment;
-    const parameters = definition.deployment.parameters;
+    const { adapter, parameters } = input.definition.deployment;
+    const values = parameters;
     const refusals = [];
-    const reasons = [];
-    const releases = 'deployRelease' in adapter && typeof adapter.deployRelease === 'function';
-    if (adapter.name === ASTRALE && releases) {
-        if (declares(parameters, 'instance')) {
+    if (typeof adapter.deployRelease !== 'function') {
+        refusals.push({
+            reason: 'unsupported-adapter',
+            guidance: `Adapter ${adapter.name} must implement configure, placement and deployRelease for immutable deployments.`,
+        });
+    }
+    if (adapter.name === 'cloudflare') {
+        if (values.namespace === undefined) {
             refusals.push({
-                reason: 'astrale-instance',
-                guidance: astraleInstanceGuidance(parameters, environment),
+                reason: 'missing-namespace',
+                guidance: 'cloudflare requires namespace: { name, routingDomain }. Use astrale() for managed deployments.',
             });
         }
-        if (declares(parameters, 'signingIdentity')) {
+        const allowed = [
+            'namespace',
+            'secrets',
+            'vars',
+            'maximumRequestBytes',
+            'invocationTimeoutMs',
+            'tokenExchange',
+            'durable',
+            'wrangler',
+            'router',
+        ];
+        const unknown = Reflect.ownKeys(values).filter((key) => typeof key !== 'string' || !allowed.includes(key));
+        if (unknown.length > 0)
+            refusals.push({
+                reason: 'invalid-parameters',
+                guidance: `Cloudflare Environment ${input.environment} declares unknown parameters ${unknown.map(String).join(', ')}.`,
+            });
+        const wrangler = values.wrangler;
+        if (wrangler !== undefined && Object.hasOwn(wrangler, 'triggers')) {
             refusals.push({
-                reason: 'astrale-signing-identity',
-                guidance: 'astrale({ signingIdentity }) is no longer accepted: each deployment gets a signing key ' +
-                    'generated when it is deployed. Remove `signingIdentity`.',
+                reason: 'scheduled-triggers',
+                guidance: 'Immutable deployments run no cron of their own. Remove wrangler.triggers.',
             });
         }
     }
-    if (adapter.name === CLOUDFLARE) {
-        const direct = CLOUDFLARE_DIRECT_PARAMETERS.filter((name) => declares(parameters, name));
-        if (declares(parameters, 'namespace')) {
-            if (direct.length > 0) {
-                refusals.push({
-                    reason: 'mixed-parameters',
-                    guidance: `cloudflare({ namespace }) deploys immutable deployments and cannot also name ` +
-                        `${direct.join(', ')}, which select the legacy direct mode. Keep \`namespace\` and ` +
-                        `remove ${direct.join(', ')}, or remove \`namespace\` to stay on the direct mode.`,
-                });
-            }
-            const wrangler = parameters.wrangler;
-            if (wrangler !== undefined && declares(wrangler, 'triggers')) {
-                refusals.push({
-                    reason: 'scheduled-triggers',
-                    guidance: 'cloudflare({ namespace }) refuses `wrangler.triggers`: an immutable deployment runs ' +
-                        'no cron of its own. Remove `wrangler.triggers`, or keep the cron on a direct-mode ' +
-                        'Environment.',
-                });
-            }
-        }
-        else {
-            reasons.push(...direct.map((parameter) => ({ reason: 'direct-parameter', parameter })), { reason: 'no-namespace' });
-        }
+    if (adapter.name === 'astrale') {
+        const allowed = ['admin', 'secrets', 'vars', 'maximumRequestBytes', 'tokenExchange', 'durable'];
+        const unknown = Reflect.ownKeys(values).filter((key) => typeof key !== 'string' || !allowed.includes(key));
+        if (unknown.length > 0)
+            refusals.push({
+                reason: 'invalid-parameters',
+                guidance: `Astrale Environment ${input.environment} declares unknown parameters ${unknown.map(String).join(', ')}.`,
+            });
     }
-    if (!releases)
-        reasons.push({ reason: 'no-deploy-release' });
-    if (refusals.length > 0)
-        return Object.freeze({ kind: 'refused', refusals: freeze(refusals) });
-    if (reasons.length > 0 && command === 'publish') {
-        return Object.freeze({
+    return refusals.length === 0
+        ? Object.freeze({ kind: 'canonical' })
+        : Object.freeze({
             kind: 'refused',
-            refusals: freeze([
-                { reason: 'publish-legacy-direct', guidance: publishGuidance(environment, reasons) },
-            ]),
+            refusals: Object.freeze(refusals.map((r) => Object.freeze(r))),
         });
-    }
-    if (reasons.length > 0)
-        return Object.freeze({ kind: 'legacy-direct', reasons: freeze(reasons) });
-    return Object.freeze({ kind: 'canonical' });
-}
-/**
- * How an adapter-astrale Environment of the removed instance mode deploys now: without `instance`
- * (nor `serviceKey` and `name`, which named its stable Service), then installed by URL on the
- * instance it used to deploy through.
- */
-function astraleInstanceGuidance(parameters, environment) {
-    const instance = String(parameters.instance);
-    const service = ASTRALE_SERVICE_PARAMETERS.filter((name) => declares(parameters, name));
-    const removed = service.length === 0
-        ? 'Remove `instance`'
-        : `Remove \`instance\` with ${service.map((name) => `\`${name}\``).join(' and ')}, ` +
-            `which named its stable Service`;
-    return (`astrale({ instance: '${instance}' }) deployed through that instance's Services, which no ` +
-        `longer hosts deployments. ${removed}: \`astrale-domain deploy ${environment}\` ` +
-        `makes an immutable deployment on Admin's Services, and \`${installCommand(instance)}\` ` +
-        'installs it.');
-}
-/**
- * Why a legacy direct-mode Environment cannot be published, and the configuration that makes it
- * publishable: a version names an immutable deployment's release, which a stable target never
- * serves.
- */
-function publishGuidance(environment, reasons) {
-    const deploys = `\`astrale-domain publish ${environment}\` names an immutable deployment's release, and ${environment} deploys`;
-    if (reasons.some(({ reason }) => reason === 'no-deploy-release')) {
-        return (`${deploys} through an adapter without deployRelease, which replaces a stable target in ` +
-            'place and serves no release. Use an adapter that implements deployRelease (adapter ' +
-            "interface v2), such as astrale() on Admin's Services.");
-    }
-    const direct = reasons.flatMap((reason) => reason.reason === 'direct-parameter' ? [reason.parameter] : []);
-    return (`${deploys} on cloudflare()'s legacy direct mode, which serves no release. Deploy it into a ` +
-        'dispatch namespace with cloudflare({ namespace })' +
-        (direct.length === 0 ? '' : ` and remove ${direct.join(', ')}`) +
-        ", or on Admin's Services with astrale().");
-}
-/** A parameter is declared when its value is not `undefined`, as optional adapter parameters read. */
-function declares(parameters, name) {
-    return Object.hasOwn(parameters, name) && parameters[name] !== undefined;
-}
-function freeze(values) {
-    return Object.freeze(values.map((value) => Object.freeze(value)));
 }

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

@@ -15,23 +15,21 @@ export interface DeployResultV1 {
     readonly environment: string;
     /**
      * The URL `astrale domain install <url>` takes: an immutable deployment's URL, which is also its
-     * issuer, or the public URL of a stable target.
+     * issuer.
      */
     readonly url: string;
     /**
-     * The digest of the `DomainRelease` v4 the deployment serves at `release.json`. `null` for a
-     * stable target, which serves a v3 Publication and no release.
+     * The digest of the DomainRelease v4 served at release.json.
      */
     readonly release: {
         readonly digest: ReleaseDigest;
-    } | null;
+    };
     /**
-     * The build digest of the code the deployment runs, as `astrale-domain build` prints it. `null`
-     * for a stable target, which never serves a build digest.
+     * The build digest of the code the deployment runs, as astrale-domain build prints it.
      */
     readonly build: {
         readonly digest: BuildDigest;
-    } | null;
+    };
     readonly schema: {
         readonly revision: Revision;
     };
@@ -40,24 +38,21 @@ export interface DeployResultV1 {
         readonly adapter: string;
         /**
          * The provider script that serves this deployment: an immutable deployment's label, which is
-         * also the first label of its URL. `null` for a stable target, whose legacy adapter operations
-         * never report the script they replace.
+         * also the first label of its URL.
          */
-        readonly script: string | null;
+        readonly script: string;
         /**
          * `created`: a new immutable deployment. `reused`: the immutable deployment of this exact
-         * release already existed. `replaced`: a stable target now runs this code in place of what it
-         * ran, if anything (the legacy direct-mode path cannot tell a first deploy from a later one);
-         * only that path replaces.
+         * release already existed.
          */
-        readonly state: 'created' | 'reused' | 'replaced';
+        readonly state: 'created' | 'reused';
     };
     /**
      * Immutable deployments only: the environment's current secrets were `bound` to a new
      * deployment, or `updated` or left `unchanged` in place on the reused one. A deploy never writes
      * the secrets of any other deployment.
      */
-    readonly secrets?: {
+    readonly secrets: {
         readonly state: DeploymentSecretsState;
     };
     /**

package/dist/tooling/cli/help.js

@@ -101,16 +101,11 @@ Behavior:
   does, loads declared secrets, and deploys through the selected adapter. It never
   installs the Domain: install the URL it prints with
   ${installCommand()}.
-  The Environment's configuration selects how it deploys. An adapter that implements
-  deployRelease makes one immutable deployment per release and calls no instance: the
-  SDK seals the release for the deployment's URL, records the commit it was built
-  from, and the adapter creates that deployment or reuses it (adapter-astrale on
-  Admin's Services, through astrale call --admin). A new deployment binds the
-  Environment's current secrets; a reused one has its own secrets updated in place,
-  served once propagated; no other deployment's secrets change. Any other Environment
-  replaces its stable target in place (legacy direct mode, deprecated), warns on
-  stderr, serves a v3 Publication only, and warns when the uploaded code has another
-  build digest than the Bundle.
+  Each Environment deploys one immutable release through configure, placement and
+  deployRelease. The SDK seals the release at the deployment URL and records the
+  source commit. Its adapter creates that deployment or reuses it. A new deployment
+  binds the Environment's current secrets; reuse updates only that deployment's
+  secrets. Cloudflare requires a dispatch namespace; astrale() uses Admin's Services.
   With --json, stdout holds only one DeployResultV1: the deployment's URL, which
   astrale domain install takes, its digests, adapter and state. Exit status: 0 deployed,
   1 failed or refused, 2 usage error; a failed run prints nothing on stdout.
@@ -131,8 +126,7 @@ Options:
 Behavior:
   Asks the adapter of each Environment that deploys immutable deployments for the
   deployments its host keeps for the caller, and prints each one's release, its version
-  or name, Environment and state, the instances it is installed on, its last call and
-  its expiry, and the URL ${installCommand()} takes.
+  or name, Environment and state, the instances it is installed on, and the URL ${installCommand()} takes.
   A deployment is named by the registry's version of its release (1.5.0) or of its build
   (1.5.0 · staging), else from its record's commit, such as 1.4.2 + 7 commits · a1b2c3d ·
   staging. Names are computed, never stored, and printed whole.
@@ -144,11 +138,10 @@ Behavior:
   The registry and the instances are read through the Astrale CLI (${MINIMUM_INSTALLATIONS_CLI_VERSION} or
   newer) with the caller's identity, only once a deployment is listed.
   A registry that cannot be read fails the listing; an unknown instance never does.
-  Admin's Services and a Cloudflare dispatch namespace keep every deployment until its
-  owner retires it, and report no last call or expiry; LAST CALL and EXPIRES show one
-  only when an older adapter reports it.
+  Admin's Services and a Cloudflare dispatch namespace keep deployments until their
+  owner retires them.
   Listing changes nothing, at any host, registry or instance.
-  An Environment in legacy direct mode, refused by deploy, or whose adapter lists no
+  An Environment refused by deploy, or whose adapter lists no
   deployments is reported on stderr and, with --json, under unlisted. A deployment
   whose record this SDK does not admit is still listed, from what its host knows.
   With --json, each deployment carries its installedOn and its call target: the path of

package/dist/tooling/cli/immutable-deployment.d.ts

@@ -1,5 +1,5 @@
-import type { DeploymentCommitV1, FrozenConfigurationV1 } from '../../deployment/address/index.js';
-import type { Adapter, Build, Bundle, LegacyAdapter, Placement, Release, ResolvedRuntimeReference } from '../../deployment/index.js';
+import type { DeploymentCommitV1, DeploymentConfiguration } from '../../deployment/address/index.js';
+import type { Adapter, Build, Bundle, Placement, Release, ResolvedRuntimeReference } from '../../deployment/index.js';
 import type { DeployResultV1 } from './deploy-result.js';
 /**
  * Everything the deploy of one canonical Environment derives before its only effectful call: the
@@ -15,7 +15,7 @@ export interface ImmutableDeploymentPlan {
     readonly identity?: string;
     readonly bundle: Bundle;
     readonly secrets: Readonly<Record<string, string>>;
-    readonly configuration: FrozenConfigurationV1;
+    readonly configuration: DeploymentConfiguration;
     readonly placement: Placement;
     /** `<line>-<content>`: the deployment's DNS label and provider script. */
     readonly label: string;
@@ -37,7 +37,7 @@ export declare function planImmutableDeployment(input: {
     readonly projectDir: string;
     readonly environment: string;
     /** A canonical Environment's adapter (CT33), which implements adapter interface v2. */
-    readonly adapter: Adapter<object> | LegacyAdapter<object>;
+    readonly adapter: Adapter<object>;
     readonly parameters: object;
     readonly build: Build;
     readonly runtime: ResolvedRuntimeReference;
@@ -73,7 +73,7 @@ export declare function deployImmutable(input: {
     readonly projectDir: string;
     readonly environment: string;
     /** A canonical Environment's adapter (CT33), which implements adapter interface v2. */
-    readonly adapter: Adapter<object> | LegacyAdapter<object>;
+    readonly adapter: Adapter<object>;
     readonly parameters: object;
     readonly build: Build;
     readonly runtime: ResolvedRuntimeReference;

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

@@ -20,5 +20,5 @@ export type { InstallationSourcesV1, InstallationUnknownReason, InstalledOnV1, I
 export type { PublishReportV1 } from './publish/index.js';
 export type { YankReportV1 } from './yank.js';
 export { selectDeployMode } from './deploy-mode.js';
-export type { CloudflareDirectParameter, DeployMode, DeployModeCommand, DeployRefusal, LegacyDirectReason, } from './deploy-mode.js';
+export type { DeployMode, DeployModeCommand, DeployRefusal } from './deploy-mode.js';
 export { loadDeclaredSecrets } from './dotenv.js';

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

@@ -29,8 +29,7 @@ export interface ListResultV1 {
  * and its adapter, its computed name, and its call target. Admin's Services (adapter-astrale) keeps
  * every deployment until it is retired: its rows are `published` and say whether their Service
  * serves them (`current`). A Cloudflare dispatch namespace (adapter-cloudflare) keeps no
- * retention, and knows a deployment's creation instant and key only while its script exists. A
- * last call and an expiry are printed only when an older adapter still reports them.
+ * retention, and knows a deployment's creation instant and key only while its script exists.
  */
 export type ListedDeploymentV1 = Omit<DeploymentSummaryV1, 'record'> & {
     /** The Project Environment whose line holds the deployment, as its host listed it. */
@@ -75,14 +74,13 @@ export type ListedDeploymentV1 = Omit<DeploymentSummaryV1, 'record'> & {
 };
 /**
  * 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';
+    readonly reason: 'refused' | 'unsupported';
 }
 /** What a listing found, beside the result: what to tell a person, and what failed. */
 export interface DeploymentListing {
@@ -145,10 +143,10 @@ export declare function listDeployments(input: {
     readonly instances?: readonly string[];
 }): Promise<DeploymentListing>;
 /**
- * The listing as a table for a person, at `now`: each deployment's release, its name as computed
+ * The listing as a table for a person: each deployment's release, its name as computed
  * (never shortened, AM-57), its Environment and state (`active (current)` for the deployment its
  * Service serves), the instances known to pin it (`?` when a source could not tell, AM-198), 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
+ * 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[];
+export declare function renderDeploymentList(result: ListResultV1, failed?: boolean): readonly string[];

package/dist/tooling/cli/list.js

@@ -38,11 +38,8 @@ export async function listDeployments(input) {
                 adapter: name,
                 reason: mode.kind,
             }));
-            notices.push(mode.kind === 'legacy-direct'
-                ? `Environment ${environment} is not listed: it deploys in legacy direct mode, replacing ` +
-                    'one stable target in place, and has no immutable deployments.'
-                : `Environment ${environment} is not listed: deploy refuses its configuration. ` +
-                    mode.refusals.map((refusal) => refusal.guidance).join(' '));
+            notices.push(`Environment ${environment} is not listed: deploy refuses its configuration. ` +
+                mode.refusals.map((refusal) => refusal.guidance).join(' '));
             continue;
         }
         if (!('list' in adapter) || typeof adapter.list !== 'function') {
@@ -191,8 +188,6 @@ function listedDeployment(hosted, publications, installations) {
         state: deployment.state,
         ...(deployment.retention === undefined ? {} : { retention: deployment.retention }),
         ...(deployment.createdAt === undefined ? {} : { createdAt: deployment.createdAt }),
-        ...(deployment.lastCallAt === undefined ? {} : { lastCallAt: deployment.lastCallAt }),
-        ...(deployment.expiresAt === undefined ? {} : { expiresAt: deployment.expiresAt }),
         ...(deployment.retiredAt === undefined ? {} : { retiredAt: deployment.retiredAt }),
         ...(deployment.retirement === undefined ? {} : { retirement: deployment.retirement }),
         ...(deployment.signingKeyId === undefined ? {} : { signingKeyId: deployment.signingKeyId }),
@@ -263,20 +258,16 @@ function admitListed(deployment, adapter) {
         if (!text(value[key]))
             invalid(key);
     }
-    for (const key of ['createdAt', 'signingKeyId', 'lastCallAt', 'expiresAt', 'retiredAt']) {
+    for (const key of ['createdAt', 'signingKeyId', 'retiredAt']) {
         if (value[key] !== undefined && !text(value[key]))
             invalid(key);
     }
     if (!STATES.includes(value.state))
         invalid('state');
-    if (value.retention !== undefined &&
-        value.retention !== 'preview' &&
-        value.retention !== 'published') {
+    if (value.retention !== undefined && value.retention !== 'published') {
         invalid('retention');
     }
-    if (value.retirement !== undefined &&
-        value.retirement !== 'expired' &&
-        value.retirement !== 'withdrawn') {
+    if (value.retirement !== undefined && value.retirement !== 'withdrawn') {
         invalid('retirement');
     }
     if (value.current !== undefined && typeof value.current !== 'boolean')
@@ -301,27 +292,15 @@ function members(input) {
         ? input
         : undefined;
 }
-const COLUMNS = [
-    'RELEASE',
-    'VERSION',
-    'ENV',
-    'STATE',
-    'INSTALLED ON',
-    'LAST CALL',
-    'EXPIRES',
-    'URL',
-];
-const MINUTE = 60_000;
-const HOUR = 60 * MINUTE;
-const DAY = 24 * HOUR;
+const COLUMNS = ['RELEASE', 'VERSION', 'ENV', 'STATE', 'INSTALLED ON', 'URL'];
 /**
- * The listing as a table for a person, at `now`: each deployment's release, its name as computed
+ * The listing as a table for a person: each deployment's release, its name as computed
  * (never shortened, AM-57), its Environment and state (`active (current)` for the deployment its
  * Service serves), the instances known to pin it (`?` when a source could not tell, AM-198), 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
+ * 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 function renderDeploymentList(result, now, failed = false) {
+export function renderDeploymentList(result, failed = false) {
     if (result.deployments.length === 0) {
         if (failed)
             return Object.freeze([]);
@@ -338,10 +317,6 @@ export function renderDeploymentList(result, now, failed = false) {
         deployment.environment,
         deployment.current === true ? `${deployment.state} (current)` : deployment.state,
         installedOnCell(deployment.installedOn, result.installations),
-        deployment.lastCallAt === undefined
-            ? '—'
-            : `${elapsed(now - Date.parse(deployment.lastCallAt))} ago`,
-        expiry(deployment, now),
         deployment.url,
     ]);
     const widths = COLUMNS.map((column, index) => Math.max(column.length, ...rows.map((row) => row[index].length)));
@@ -354,30 +329,3 @@ export function renderDeploymentList(result, now, failed = false) {
 function shortDigest(digest) {
     return `${digest.slice(0, 'sha256:'.length + 7)}…`;
 }
-/**
- * When a deployment stops serving: `never` once published, else the expiry an older adapter
- * reports (`due` once that instant passed), else `—` (a dispatch namespace keeps a deployment
- * until its owner retires it); for a retired deployment, why it was retired.
- */
-function expiry(deployment, now) {
-    if (deployment.state === 'retiring')
-        return 'retiring';
-    if (deployment.state === 'retired')
-        return deployment.retirement ?? 'retired';
-    if (deployment.retention === 'published')
-        return 'never';
-    if (deployment.expiresAt === undefined)
-        return '—';
-    const remaining = Date.parse(deployment.expiresAt) - now;
-    return remaining > 0 ? `in ${elapsed(remaining)}` : 'due';
-}
-/** A duration as a person reads it in a listing: minutes, then hours, then days. */
-function elapsed(milliseconds) {
-    if (!(milliseconds >= MINUTE))
-        return '< 1 min';
-    if (milliseconds < HOUR)
-        return `${Math.floor(milliseconds / MINUTE)} min`;
-    if (milliseconds < DAY)
-        return `${Math.floor(milliseconds / HOUR)} h`;
-    return `${Math.floor(milliseconds / DAY)} d`;
-}

package/dist/tooling/cli/orchestrate.js

@@ -7,11 +7,9 @@ import { parseArgs } from './arguments.js';
 import { buildResult, bundleBuild, bundlerCopyWarnings, projectBundlers } from './build.js';
 import { BunRequiredError } from './bun.js';
 import { selectDeployMode } from './deploy-mode.js';
-import { deprecationWarnings } from './deprecations.js';
 import { runDiff } from './diff/index.js';
 import { ERROR_USAGE, helpRequest, helpText } from './help.js';
 import { deployImmutable } from './immutable-deployment.js';
-import { deployStableTarget } from './legacy/stable-target-deploy.js';
 import { listDeployments, renderDeploymentList } from './list.js';
 import { error, info, progress, warn } from './log.js';
 import { importModule, loadProject, runtimeEntrypoint, selectEnvironment, } from './project.js';
@@ -103,8 +101,6 @@ export async function run(argv) {
         });
     }
     const build = compile(project.domain);
-    for (const warning of deprecationWarnings(build))
-        warn(warning);
     const resolved = await resolveRuntime(runtimeEntrypoint(project), (path) => importModule(resolve(dirname(configPath), path)));
     admitRuntime({ runtime: build.runtime }, resolved);
     if (parsed.command === 'diff') {
@@ -214,17 +210,11 @@ export async function run(argv) {
             signal: lifecycle.signal,
             report,
         };
-        const deployed = mode.kind === 'canonical'
-            ? await deployImmutable({
-                ...deployment,
-                adapter: environment.deployment.adapter,
-                parameters: environment.deployment.parameters,
-            })
-            : await deployStableTarget({
-                ...deployment,
-                definition: environment,
-                reasons: mode.reasons,
-            });
+        const deployed = await deployImmutable({
+            ...deployment,
+            adapter: environment.deployment.adapter,
+            parameters: environment.deployment.parameters,
+        });
         if (deployed === undefined)
             return 1;
         if (parsed.json === true)
@@ -284,7 +274,7 @@ async function list(parsed, project, projectDir) {
             return 0;
         }
         const failed = listing.failures.length > 0;
-        for (const line of renderDeploymentList(listing.result, Date.now(), failed)) {
+        for (const line of renderDeploymentList(listing.result, failed)) {
             process.stdout.write(`${line}\n`);
         }
         return failed ? 1 : 0;

package/dist/tooling/cli/publish/index.d.ts

@@ -1,11 +1,11 @@
-import type { Adapter, Build, LegacyAdapter, Release, ResolvedRuntimeReference } from '../../../deployment/index.js';
+import type { Adapter, Build, Release, ResolvedRuntimeReference } from '../../../deployment/index.js';
 import type { DomainRegistry } from '../registry/index.js';
 export type { PublishReportV1 } from './report.js';
 export interface PublishCommandInput {
     readonly projectDir: string;
     readonly environment: string;
     /** The adapter of a canonical Environment (CT33): `publish` refuses every other one before. */
-    readonly adapter: Adapter<object> | LegacyAdapter<object>;
+    readonly adapter: Adapter<object>;
     readonly parameters: object;
     readonly build: Build;
     readonly runtime: ResolvedRuntimeReference;

package/dist/tooling/cli/registry/client.js

@@ -1,5 +1,5 @@
 import * as artifact from '@astrale-os/kernel-protocol/artifact';
-import { BUNDLE_MEDIA_TYPE } from '@astrale-os/kernel-protocol/release/bundle';
+import { BUNDLE_MEDIA_TYPE } from '@astrale-os/kernel-protocol/release';
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';

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

@@ -1,9 +1,9 @@
 import type { Runtime } from '../../application/runtime/index.js';
-import type { Adapter, LegacyAdapter } from '../../deployment/adapter/index.js';
+import type { Adapter } from '../../deployment/adapter/index.js';
 /**
  * The secrets one Environment's deployment binds: the values of the secrets file its adapter
  * declares. An Integration-free Runtime has no Providers and therefore no author-owned secrets, so
  * its file may be absent; adapter-owned secrets, such as a signing identity, are the adapter's to
  * resolve and never make this file required.
  */
-export declare function environmentSecrets(adapter: Adapter<object> | LegacyAdapter<object>, parameters: object, projectDir: string, runtime: Runtime): Readonly<Record<string, string>>;
+export declare function environmentSecrets(adapter: Adapter<object>, parameters: object, projectDir: string, runtime: Runtime): Readonly<Record<string, string>>;

package/dist/tooling/linter/implementations/source/global.js

@@ -506,7 +506,6 @@ export const globalRules = [
                 { layer: 'queries', name: 'defineQuery', members: [undefined] },
                 { layer: 'queries', name: 'defineCompositeQuery', members: [undefined] },
                 { layer: 'mutations', name: 'defineMutation', members: [undefined] },
-                { layer: 'migrations', name: 'defineMigration', members: [undefined] },
             ];
             for (const definition of definitions) {
                 for (const file of production(project, definition.layer)) {

package/dist/tooling/linter/implementations/source/verifiers.js

@@ -2,7 +2,6 @@ import { actionRules } from './actions.js';
 import { dependencyRules } from './dependencies.js';
 import { globalRules } from './global.js';
 import { integrationRules } from './integrations.js';
-import { migrationRules } from './migrations.js';
 import { mutationRules } from './mutations.js';
 import { providerRules } from './providers.js';
 import { queryRules } from './queries.js';
@@ -23,7 +22,6 @@ export const sourceRuleVerifiers = Object.freeze([
     ...mutationRules,
     ...workflowRules,
     ...dependencyRules,
-    ...migrationRules,
     ...integrationRules,
     ...actionRules,
     ...providerRules,