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

package/README.md

@@ -5,6 +5,11 @@ single-step Actions, explicit multi-step Workflows, provider-neutral Integration
 authoring, Domain composition, Deployment, and Execution without exposing DSL callable
 topology in implementation files.
 
+This draft moves the Domain name and entrypoint into its root Schema. The source is rebased on
+current SDK main, but the required canonical Kernel Schema contract is not yet published in the
+pinned dependency cohort. See [the migration and qualification boundary](docs/domain-schema-migration.md)
+before using or releasing this branch.
+
 [![CI](https://github.com/astrale-os/sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/astrale-os/sdk/actions/workflows/ci.yml)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
 
@@ -46,31 +51,12 @@ Run the project's checks and validate on development.
 Nothing is committed or deployed. A Shell update also requires checking the installed Shell revision.
 Rerunning an upgrade synchronizes installation even when the manifest versions are already current.
 
-## Move a runtime without changing its Domain identity
-
-A Domain issuer is retained across installation upgrades. To deploy a new Cloudflare runtime for
-selected instances, keep the existing signing identity and issuer while selecting a new public origin:
-
-```ts
-cloudflare({
-  route: 'services-v2.example.com',
-  workerName: 'services-v2',
-  identityIssuer: 'https://services.example.com',
-  signingIdentity: '.astrale/identity.json',
-})
-```
-
-The new Publication places its Bundle, Delivery, callables, Views and routes at the new origin.
-Install that public URL on each intended instance. The Kernel verifies its Delivery against the
-retained issuer's keys and preserves the Domain installation identity and owned data. Keep the
-original issuer discovery endpoints and keys available; unadopted instances continue to use their
-previous bindings. Deployment readiness checks the exact new Worker version separately from issuer
-discovery. No uninstall or identity rotation is involved.
+## Immutable deployments
 
-At the provider-neutral release boundary, this stable-target path uses
-`addressing('https://services.example.com', { publicUrl: 'https://services-v2.example.com' })` with
-`legacy.assemble`. That split is deprecated with direct mode and goes with it: an immutable
-deployment's URL is its issuer, so `assemble(build, buildDigest, url)` takes the URL alone.
+A deployment serves one `DomainRelease` v4 at its immutable URL, which is also its issuer.
+`assemble(build, buildDigest, url)` seals the document from the exact Build and running bytes.
+Cloudflare deployments require a dispatch namespace; `astrale()` hosts them on Admin's Services.
+Install the URL printed by `astrale-domain deploy` on each intended instance.
 
 ## Handler authority and dependencies
 
@@ -141,11 +127,8 @@ for an Identity in the Domain's local Core. `subject` is the resolved Core Node;
 must request at least one capability. The top-level `functions`, `classes`, and `authority` members
 describe capabilities for the Domain principal.
 
-This replaces `requirements.profiles`. Rename that property to `core` and imported
-`CapabilityProfileRequirement` / `CapabilityProfileRequirementInput` types to `CoreRequirement` /
-`CoreRequirementInput`. Builds emit `requirements.capabilities.core`; new releases use Publication
-v3 and require a Kernel that supports it. That Kernel can restore historical v2 Publications and
-installation ledgers without changing their existing authority or integrity evidence.
+Builds emit `requirements.capabilities.core`; the release declares those requirements for the
+Domain principal and local Core identities. Installation verifies the Release and its exact Bundle.
 
 ### Prerequisites
 
@@ -262,13 +245,12 @@ NodePath and its Dataset Node ID through encoding and decoding. Matching propert
 not create that association. Studio uses it when simulating `sameNode` and reference endpoints;
 a missing association makes that simulation unavailable.
 
-## Kernel publication discovery
+## Kernel release discovery
 
-Use `session.publication()` when a consumer needs the intrinsic Kernel's published identity or
-endpoints without its schema bundle or Views. It revalidates through the Client's existing issuer,
-URL, size, and ETag checks. Concurrent publication and snapshot observations share acquisition;
-cancelling one observer does not cancel another. `session.snapshot()` remains the complete,
-coherent Publication, bundle, and View catalog observation.
+Use `session.release()` for the intrinsic Kernel's Release without its schema bundle or Views.
+It revalidates issuer, URL, size and ETag. Concurrent release and snapshot observations share
+acquisition; cancelling one observer does not cancel another. `session.snapshot()` returns one
+coherent Release, Bundle and View catalog observation.
 
 ## Headless scripts and Domain callables
 
@@ -366,6 +348,18 @@ recomputes an address tests against them.
 
 Apache License 2.0 — see [LICENSE](LICENSE) for details.
 
+## Domain icon
+
+```ts
+import { classIcon } from '@astrale-os/sdk/schema'
+import { Building2 } from '@astrale-os/sdk/schema/icons'
+
+export const domain = defineDomain({ schema, runtime, icon: classIcon.lucide(Building2) })
+```
+
+The release publishes the icon as `manifest.logo`. Use `classIcon.svg(...)` for a self-contained
+inline SVG, or omit `icon` and the release carries no manifest.
+
 ## View host requirements
 
 A frontend route can declare the exact external origins its View needs to open:
@@ -383,7 +377,7 @@ routes: {
 }
 ```
 
-These requirements are publication metadata, so changing them updates the publication ETag without
+These requirements belong to the Release, so changing them updates its digest without
 changing the Domain's business Schema. They require the `shell` handshake. Origins must use
 HTTPS without credentials, paths, queries, fragments, or wildcards; authoring normalizes and sorts
 them. Supporting hosts admit them per mount and execute the existing `browser.openExternal`

package/dist/application/define.d.ts

@@ -1,4 +1,4 @@
-import type { schema } from '../platform/schema/index.js';
+import type { ClassIcon, schema } from '../platform/schema/index.js';
 import type { DomainDefinition } from './domain.js';
 import type { Requirements } from './requirements/index.js';
 import type { Routes } from './routes/index.js';
@@ -10,6 +10,8 @@ export interface DomainDefinitionInput<Schema extends schema.DomainSchema, Runti
     readonly frontend?: FrontendValue;
     readonly routes?: RoutesValue;
     readonly requirements?: RequirementsValue;
+    /** The application's icon, made with `classIcon.svg(...)` or `classIcon.lucide(...)`. */
+    readonly icon?: ClassIcon;
 }
 /** Capture one inert authored Domain without resolving, compiling, loading, or deploying it. */
 export declare function defineDomain<const Schema extends schema.DomainSchema, const RuntimeValue extends Runtime<Schema>, const FrontendValue extends Frontend<Schema> | undefined = undefined, const RoutesValue extends Routes | undefined = undefined, const RequirementsValue extends Requirements | undefined = undefined>(input: DomainDefinitionInput<Schema, RuntimeValue, FrontendValue, RoutesValue, RequirementsValue>): DomainDefinition<Schema, RuntimeValue, FrontendValue, RoutesValue, RequirementsValue>;

package/dist/application/define.js

@@ -1,3 +1,4 @@
+import { admitClassIconSvg } from '../platform/schema/class-icon-svg.js';
 import { isRequirements } from './requirements/index.js';
 import { isRoutes } from './routes/index.js';
 import { isRuntime } from './runtime/index.js';
@@ -7,9 +8,19 @@ const admittedDomainDefinitions = new WeakSet();
 export function defineDomain(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input))
         invalid();
-    const allowed = new Set(['schema', 'runtime', 'frontend', 'routes', 'requirements']);
+    const allowed = new Set([
+        'schema',
+        'runtime',
+        'frontend',
+        'routes',
+        'requirements',
+        'icon',
+    ]);
     if (Reflect.ownKeys(input).some((key) => !allowed.has(key)))
         invalid();
+    if (typeof input.schema?.name !== 'string') {
+        throw new TypeError(`Domain Schema ${String(input.schema?.origin)} must declare its name: defineSchema(origin, { name, ... }).`);
+    }
     if (!isRuntime(input.runtime))
         throw new TypeError('Domain Runtime is not admitted.');
     if (input.frontend !== undefined &&
@@ -22,12 +33,15 @@ export function defineDomain(input) {
     if (input.requirements !== undefined && !isRequirements(input.requirements)) {
         throw new TypeError('Domain requirements are not admitted.');
     }
+    // The same admission as a Node Class icon: one self-contained inline SVG.
+    const icon = input.icon === undefined ? undefined : admitClassIconSvg(input.icon);
     const domain = Object.freeze({
         schema: input.schema,
         runtime: input.runtime,
         ...(input.frontend === undefined ? {} : { frontend: input.frontend }),
         ...(input.routes === undefined ? {} : { routes: input.routes }),
         ...(input.requirements === undefined ? {} : { requirements: input.requirements }),
+        ...(icon === undefined ? {} : { icon }),
     });
     admittedDomainDefinitions.add(domain);
     return domain;
@@ -36,5 +50,5 @@ export function isDomainDefinition(input) {
     return input !== null && typeof input === 'object' && admittedDomainDefinitions.has(input);
 }
 function invalid() {
-    throw new TypeError('Domain definition may contain only schema, runtime, frontend, routes, and requirements.');
+    throw new TypeError('Domain definition may contain only schema, runtime, frontend, routes, requirements, and icon.');
 }

package/dist/application/domain.d.ts

@@ -1,4 +1,4 @@
-import type { schema } from '../platform/schema/index.js';
+import type { ClassIcon, schema } from '../platform/schema/index.js';
 import type { Requirements } from './requirements/index.js';
 import type { Routes } from './routes/index.js';
 import type { Runtime, SchemaOfRuntime as RuntimeSchemaOf } from './runtime/index.js';
@@ -16,6 +16,8 @@ export interface DomainDefinition<Schema extends schema.DomainSchema = schema.Do
     readonly frontend?: FrontendValue;
     readonly routes?: RoutesValue;
     readonly requirements?: RequirementsValue;
+    /** The application's icon. */
+    readonly icon?: ClassIcon;
     readonly [DOMAIN_DEFINITION_SCHEMA]: (schema: Schema) => Schema;
 }
 export type SchemaOfDomainDefinition<Value> = Value extends {

package/dist/application/index.d.ts

@@ -5,5 +5,5 @@ export type { AuthorityRequirements, AuthorityRequirementsInput, ClassOperation,
 export { route, routes } from './routes/index.js';
 export type { Route, RouteInput, RouteTarget, Routes } from './routes/index.js';
 export { defineFrontend, external, vite } from './view/index.js';
-export type { Frontend, FrontendInput, FrontendSource, IframeRequirements, ViewHostRequirements, } from './view/index.js';
+export type { Frontend, FrontendInput, FrontendSource, ViewHostRequirements } from './view/index.js';
 export type { DomainDefinition, DomainDefinitionIdentity, RuntimeOfDomainDefinition, SchemaOfDomainDefinition, SchemaOfRuntime, } from './domain.js';

package/dist/application/mutation/index.d.ts

@@ -5,4 +5,4 @@ export type { Mutation, MutationDefinition, MutationInputOf, MutationOutputOf }
 export type { CreatedNode, EdgeSelector, ExistingEndpoint, MutationEndpoint, QueryPrecondition, RichMutationBuilder, RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName, } from './authoring/index.js';
 /** Canonical low-level Mutation documents remain available as the explicit escape hatch. */
 export * from '@astrale-os/kernel-core/graph/mutate';
-export type { LocalAlias, LocalBinding } from '../../platform/graph/alias.js';
+export type { LocalAlias } from '../../platform/graph/alias.js';

package/dist/application/query/composite/plan.d.ts

@@ -7,10 +7,6 @@ export declare const QUERY_COMPOSITION_LIMITS: Readonly<{
     maximumDependencyDepth: 8;
 }>;
 export interface QueryPlanAnalysis {
-    /** @deprecated Use physicalQueries. */
-    readonly queries: number;
-    /** @deprecated Use dependencyDepth. */
-    readonly depth: number;
     readonly logicalQueries: number;
     readonly physicalQueries: number;
     readonly dependencyDepth: number;

package/dist/application/query/composite/plan.js

@@ -53,8 +53,6 @@ export function analyzeQueryPlan(plan) {
         throw new QueryCompositionError('QUERY_COMPOSITION_LIMIT', `Composite Query exceeds ${QUERY_COMPOSITION_LIMITS.maximumPhysicalQueries} physical Queries or dependency depth ${QUERY_COMPOSITION_LIMITS.maximumDependencyDepth}.`);
     }
     return Object.freeze({
-        queries: physicalKeys.size,
-        depth: maximumDepth,
         logicalQueries,
         physicalQueries: physicalKeys.size,
         dependencyDepth: maximumDepth,

package/dist/application/view/define.js

@@ -5,7 +5,10 @@ import { isFrontendSource } from './source.js';
 export function defineFrontend(input) {
     if (input === null || typeof input !== 'object' || Array.isArray(input))
         invalid();
-    if (Reflect.ownKeys(input).some((key) => key !== 'schema' && key !== 'source' && key !== 'routes' && key !== 'entrypoint')) {
+    if (Object.hasOwn(input, 'entrypoint')) {
+        throw new TypeError('Frontend entrypoint is removed: declare it with defineSchema(origin, { entrypoint }).');
+    }
+    if (Reflect.ownKeys(input).some((key) => key !== 'schema' && key !== 'source' && key !== 'routes')) {
         invalid();
     }
     const names = Object.keys(input.schema.views).sort(compare);
@@ -18,10 +21,6 @@ export function defineFrontend(input) {
     const unknown = Reflect.ownKeys(authored).find((name) => typeof name !== 'string' || !names.includes(name));
     if (unknown !== undefined)
         throw new TypeError(`Frontend route ${String(unknown)} is unknown.`);
-    const entrypoint = input.entrypoint ?? (names.length === 1 ? names[0] : undefined);
-    if (entrypoint === undefined || !names.includes(entrypoint)) {
-        throw new TypeError('Frontend entrypoint must name one Schema View.');
-    }
     const paths = new Set();
     const routes = {};
     for (const name of names) {
@@ -36,7 +35,6 @@ export function defineFrontend(input) {
         schema: input.schema,
         source,
         routes: Object.freeze(routes),
-        entrypoint: entrypoint,
     }));
 }
 function admitSource(input) {

package/dist/application/view/frontend.d.ts

@@ -8,12 +8,12 @@ export interface FrontendInput<Schema extends schema.DomainSchema> {
     readonly schema: Schema;
     readonly source: FrontendSource;
     readonly routes?: FrontendRouteInputs<Schema>;
-    readonly entrypoint?: ViewName<Schema>;
+    /** Removed: the Schema declares its entrypoint with `defineSchema(origin, { entrypoint })`. */
+    readonly entrypoint?: never;
 }
 export interface Frontend<Schema extends schema.DomainSchema = schema.DomainSchema> {
     readonly kind: 'frontend';
     readonly schema: Schema;
     readonly source: FrontendSource;
     readonly routes: FrontendRoutes<Schema>;
-    readonly entrypoint: ViewName<Schema>;
 }

package/dist/application/view/index.d.ts

@@ -1,6 +1,6 @@
 export { isFrontend } from './admission.js';
 export { defineFrontend } from './define.js';
 export type { Frontend, FrontendInput, FrontendRouteInputs, FrontendRoutes, ViewName, } from './frontend.js';
-export type { FrontendHandshake, FrontendRoute, FrontendRouteInput, IframeRequirements, ViewHostRequirements, } from './route.js';
+export type { FrontendHandshake, FrontendRoute, FrontendRouteInput, ViewHostRequirements, } from './route.js';
 export { external, isFrontendSource, vite } from './source.js';
 export type { ExternalSource, FrontendSource, ViteSource } from './source.js';

package/dist/application/view/route.d.ts

@@ -1,30 +1,16 @@
 import { type ViewHostRequirements } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
 export type { ViewHostRequirements } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
 export type FrontendHandshake = 'shell' | 'none';
-/**
- * @deprecated Every trusted View receives the Shell's shared browser profile: requirements within
- * it are redundant, and Astrale hosts refuse any beyond it. Declare none.
- */
-export interface IframeRequirements {
-    readonly sandbox?: readonly string[];
-    readonly allow?: readonly string[];
-}
 export type FrontendRouteInput = string | {
     readonly path?: string;
     readonly document?: string;
     readonly handshake?: FrontendHandshake;
-    /**
-     * @deprecated Every trusted View receives the Shell's shared browser profile: requirements
-     * within it are redundant, and Astrale hosts refuse any beyond it. Remove this field.
-     */
-    readonly iframe?: IframeRequirements;
     readonly host?: ViewHostRequirements;
 };
 export interface FrontendRoute {
     readonly path: string;
     readonly document: string;
     readonly handshake: FrontendHandshake;
-    readonly iframe?: IframeRequirements;
     readonly host?: ViewHostRequirements;
 }
 export declare function normalizeRoute(input: FrontendRouteInput | undefined, fallback: string): FrontendRoute;

package/dist/application/view/route.js

@@ -1,16 +1,10 @@
 import { acceptViewHostRequirements, } from '@astrale-os/kernel-core/schema/kernel/syscalls/view-resolution';
-const TOKEN = /^[a-z][a-z0-9-]*$/u;
-const BASELINES = Object.freeze({
-    none: iframeRequirements(['allow-scripts'], []),
-    shell: iframeRequirements(['allow-same-origin', 'allow-scripts'], ['clipboard-write']),
-});
 export function normalizeRoute(input, fallback) {
     if (typeof input === 'string') {
         return Object.freeze({ path: routePath(input), document: 'index.html', handshake: 'shell' });
     }
     const value = plainRecord(input ?? {});
-    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' ||
-        !['path', 'document', 'handshake', 'iframe', 'host'].includes(key))) {
+    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' || !['path', 'document', 'handshake', 'host'].includes(key))) {
         invalid();
     }
     const authoredHandshake = dataValue(value, 'handshake');
@@ -20,59 +14,14 @@ export function normalizeRoute(input, fallback) {
         invalid();
     }
     const handshake = authoredHandshake ?? 'shell';
-    const iframe = normalizeIframeRequirements(dataValue(value, 'iframe'), handshake);
     const host = acceptViewHostRequirements(dataValue(value, 'host'), handshake, true);
     return Object.freeze({
         path: routePath(dataValue(value, 'path') ?? fallback),
         document: filePath(dataValue(value, 'document') ?? 'index.html'),
         handshake,
-        ...(iframe === undefined ? {} : { iframe }),
         ...(host === undefined ? {} : { host }),
     });
 }
-function normalizeIframeRequirements(input, handshake) {
-    if (input === undefined)
-        return undefined;
-    const value = plainRecord(input);
-    if (Reflect.ownKeys(value).some((key) => key !== 'sandbox' && key !== 'allow'))
-        invalid();
-    const authored = iframeRequirements(tokenArray(dataValue(value, 'sandbox')), tokenArray(dataValue(value, 'allow')));
-    assertSandboxRelationships(authored.sandbox);
-    const baseline = BASELINES[handshake];
-    const sandbox = authored.sandbox.filter((token) => !baseline.sandbox.includes(token));
-    const allow = authored.allow.filter((feature) => !baseline.allow.includes(feature));
-    return sandbox.length === 0 && allow.length === 0 ? undefined : iframeRequirements(sandbox, allow);
-}
-function iframeRequirements(sandbox, allow) {
-    return Object.freeze({
-        sandbox: Object.freeze([...new Set(sandbox)].sort()),
-        allow: Object.freeze([...new Set(allow)].sort()),
-    });
-}
-function tokenArray(input) {
-    if (input === undefined)
-        return [];
-    if (!Array.isArray(input))
-        invalid();
-    const descriptors = Object.getOwnPropertyDescriptors(input);
-    const result = [];
-    for (let index = 0; index < input.length; index += 1) {
-        const descriptor = descriptors[String(index)];
-        if (descriptor === undefined || !('value' in descriptor))
-            invalid();
-        if (typeof descriptor.value !== 'string' || !TOKEN.test(descriptor.value))
-            invalid();
-        result.push(descriptor.value);
-    }
-    for (const key of Reflect.ownKeys(descriptors)) {
-        if (key === 'length')
-            continue;
-        if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/u.test(key) || Number(key) >= input.length) {
-            invalid();
-        }
-    }
-    return result;
-}
 function plainRecord(input) {
     if (typeof input !== 'object' || input === null || Array.isArray(input))
         invalid();
@@ -89,18 +38,6 @@ function dataValue(input, key) {
         invalid();
     return descriptor.value;
 }
-function assertSandboxRelationships(sandbox) {
-    const tokens = new Set(sandbox);
-    if (tokens.has('allow-popups-to-escape-sandbox') && !tokens.has('allow-popups'))
-        invalid();
-    if (tokens.has('allow-top-navigation') && tokens.has('allow-top-navigation-by-user-activation')) {
-        invalid();
-    }
-    if (tokens.has('allow-top-navigation-to-custom-protocols') &&
-        (tokens.has('allow-top-navigation') || tokens.has('allow-popups'))) {
-        invalid();
-    }
-}
 export function defaultRoute(name) {
     return routePath(`/${name
         .replace(/([a-z0-9])([A-Z])/gu, '$1-$2')

package/dist/deployment/adapter/adapter.d.ts

@@ -1,6 +1,5 @@
-import type { FrozenConfigurationV1 } from '../address/index.js';
+import type { DeploymentConfiguration } from '../address/index.js';
 import type { Bundler } from './bundle/index.js';
-import type { ArtifactSource, DeployContext, DeployResult, PrepareContext } from './legacy/index.js';
 import type { AdapterCommand, ConfigureContext, ListContext, ListedDeployment, Placement, PlacementContext, ReleaseDeployContext, ReleaseDeployResult, RetainContext } from './release/index.js';
 /** What `admit` receives when `defineProject` binds an adapter to one Environment. */
 export interface AdapterEnvironmentContext {
@@ -12,8 +11,6 @@ export interface AdapterEnvironmentContext {
  * deploys one sealed release as one immutable deployment, created or reused. It never installs:
  * `astrale domain install <url>` installs a deployment by its URL.
  *
- * `prepare` and `deploy` remain only for an adapter that also serves Environments on the legacy
- * direct-mode path (CT33); an adapter declares both or neither.
  */
 export interface Adapter<Parameters extends object = object> {
     readonly kind: 'adapter';
@@ -26,8 +23,12 @@ export interface Adapter<Parameters extends object = object> {
     readonly bundler: Bundler;
     /** Refuse parameters that cannot serve this Environment, before any effect. */
     admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
-    /** Freeze what a deployment of this Environment binds beside its build. Pure. */
-    configure(parameters: Parameters, context: ConfigureContext): FrozenConfigurationV1;
+    /**
+     * Freeze what a deployment of this Environment binds beside its build: a `FrozenConfigurationV1`
+     * for a host that binds a generated Worker's settings itself, a `WorkerConfigurationV1` for a
+     * Worker host that binds only what it is asked (Admin's Services). Pure.
+     */
+    configure(parameters: Parameters, context: ConfigureContext): DeploymentConfiguration;
     /** Where the host places this Environment's deployments. No effect at the host. */
     placement(parameters: Parameters, context: PlacementContext): Promise<Placement>;
     /** Create, or reuse, the immutable deployment of one sealed release. */
@@ -39,7 +40,7 @@ export interface Adapter<Parameters extends object = object> {
     list?(parameters: Parameters, context: ListContext): Promise<readonly ListedDeployment[]>;
     /**
      * Keep one published deployment where the host has no registry principal to mark it (a platform
-     * namespace). Called only after its Publication commits. Rejects with a `RetainRefusal` when the
+     * namespace). Called only after its registry publication commits. Rejects with a `RetainRefusal` when the
      * host can no longer keep it (absent or retired), which no rerun changes; any other rejection is
      * transient. Absent: the registry marks it (Admin's Services).
      */
@@ -50,17 +51,7 @@ export interface Adapter<Parameters extends object = object> {
      * host on the operator's own account). Every effect is the adapter's; the CLI only routes.
      */
     readonly commands?: Readonly<Record<string, AdapterCommand<Parameters>>>;
-    /**
-     * @deprecated Legacy direct-mode path (CT33) only: place a build at a stable target. Replacement:
-     * `bundler`, `configure` and `placement`. Deleted with the legacy path (D10).
-     */
-    prepare?(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
-    /**
-     * @deprecated Legacy direct-mode path (CT33) only: replace a stable target's code in place.
-     * Replacement: `deployRelease`. Deleted with the legacy path (D10).
-     */
-    deploy?(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
-    readonly secretsFile?: (parameters: Parameters) => string | undefined;
+    secretsFile?(parameters: Parameters): string | undefined;
 }
 /** What `defineAdapter` admits for an `Adapter` (adapter interface v2). */
 export interface AdapterInput<Parameters extends object> {
@@ -68,15 +59,11 @@ export interface AdapterInput<Parameters extends object> {
     readonly version: string;
     readonly bundler: Bundler;
     admit?(parameters: Parameters, context: AdapterEnvironmentContext): void;
-    configure(parameters: Parameters, context: ConfigureContext): FrozenConfigurationV1;
+    configure(parameters: Parameters, context: ConfigureContext): DeploymentConfiguration;
     placement(parameters: Parameters, context: PlacementContext): Promise<Placement>;
     deployRelease(parameters: Parameters, context: ReleaseDeployContext): Promise<ReleaseDeployResult>;
     list?(parameters: Parameters, context: ListContext): Promise<readonly ListedDeployment[]>;
     retain?(parameters: Parameters, context: RetainContext): Promise<void>;
     readonly commands?: Readonly<Record<string, AdapterCommand<Parameters>>>;
-    /** @deprecated Legacy direct-mode path (CT33) only. Replacement: `configure`, `placement`. */
-    prepare?(parameters: Parameters, context: PrepareContext): Promise<ArtifactSource>;
-    /** @deprecated Legacy direct-mode path (CT33) only. Replacement: `deployRelease`. */
-    deploy?(parameters: Parameters, context: DeployContext): Promise<DeployResult>;
-    readonly secretsFile?: (parameters: Parameters) => string | undefined;
+    secretsFile?(parameters: Parameters): string | undefined;
 }

package/dist/deployment/adapter/bundle/file.d.ts

@@ -1,4 +1,4 @@
-/** One file a bundler or a legacy preparation produced, before admission. */
+/** One file a bundler produced, before admission. */
 export interface ArtifactFile {
     readonly path: string;
     readonly content: Uint8Array;

package/dist/deployment/adapter/define.d.ts

@@ -1,29 +1,8 @@
 import type { Deployment } from '../deployment.js';
 import type { Adapter, AdapterInput } from './adapter.js';
-import type { LegacyAdapter, LegacyAdapterInput } from './legacy/index.js';
-/**
- * Capture one receiver-bound provider adapter (adapter interface v2): a required `bundler`,
- * `configure`, `placement` and `deployRelease`, optionally `list`, `retain` and provider `commands`, and `prepare` with
- * `deploy` only while it also serves the legacy direct-mode path.
- */
+/** Capture one receiver-bound adapter that deploys immutable DomainRelease v4 deployments. */
 export declare function defineAdapter<Parameters extends object>(input: AdapterInput<Parameters>): Adapter<Parameters>;
-/**
- * Capture one receiver-bound adapter on the contract before interface v2: its required `bundler`,
- * `prepare` and `deploy`.
- *
- * @deprecated Every Environment such an adapter deploys is on the legacy direct-mode path (CT33).
- * Declare adapter interface v2 instead: `configure`, `placement` and `deployRelease` beside the
- * same `bundler`.
- */
-export declare function defineAdapter<Parameters extends object>(input: LegacyAdapterInput<Parameters>): LegacyAdapter<Parameters>;
-/** Bind one provider adapter to the parameters of one Project Environment. */
+/** Bind one admitted adapter to the parameters of one Project Environment. */
 export declare function defineDeployment<const Parameters extends object>(adapter: Adapter<Parameters>, parameters: Parameters): Deployment<Parameters, Adapter<Parameters>>;
-/**
- * Bind one adapter on the contract before interface v2 to the parameters of one Environment.
- *
- * @deprecated The Environment is on the legacy direct-mode path (CT33). Replacement: an adapter
- * that implements adapter interface v2.
- */
-export declare function defineDeployment<const Parameters extends object>(adapter: LegacyAdapter<Parameters>, parameters: Parameters): Deployment<Parameters, LegacyAdapter<Parameters>>;
-/** Whether `defineAdapter` admitted this value, on either contract. */
-export declare function isAdapter(input: unknown): input is Adapter | LegacyAdapter;
+/** Whether defineAdapter admitted this immutable-deployment adapter. */
+export declare function isAdapter(input: unknown): input is Adapter;

package/dist/deployment/adapter/define.js

@@ -1,7 +1,7 @@
 import { captureDeployment } from '../deployment.js';
 const admittedAdapters = new WeakSet();
 const admittedBundlers = new WeakMap();
-/** Every field an adapter definition may declare, in either contract. */
+/** Every field an immutable-deployment adapter may declare. */
 const FIELDS = [
     'name',
     'version',
@@ -13,46 +13,29 @@ const FIELDS = [
     'list',
     'retain',
     'commands',
-    'prepare',
-    'deploy',
     'secretsFile',
 ];
-/** The operations that make a definition adapter interface v2. */
 const RELEASE_OPERATIONS = ['configure', 'placement', 'deployRelease'];
-const OPTIONAL_RELEASE_OPERATIONS = ['list', 'retain'];
-/** The operations of the legacy direct-mode path. */
-const STABLE_TARGET_OPERATIONS = ['prepare', 'deploy'];
-/** Every operation an adapter may declare, in the order an admitted adapter lists them. */
-const OPERATIONS = FIELDS.filter((key) => key !== 'name' && key !== 'version' && key !== 'bundler' && key !== 'commands');
-/** A provider command name, `astrale-domain <adapter> <command>`, and an option name. */
+const OPERATIONS = ['admit', ...RELEASE_OPERATIONS, 'list', 'retain', 'secretsFile'];
 const COMMAND_NAME = /^[a-z][a-z0-9-]{0,31}$/u;
+/** Capture one receiver-bound adapter that deploys immutable DomainRelease v4 deployments. */
 export function defineAdapter(input) {
     const value = record(input, 'Adapter definition');
     if (Reflect.ownKeys(value).some((key) => !FIELDS.includes(key))) {
         invalidFields();
     }
-    const declared = (key) => value[key] !== undefined;
-    const release = [...RELEASE_OPERATIONS, ...OPTIONAL_RELEASE_OPERATIONS].some(declared);
-    // A legacy definition names both operations, as it always had to; v2 treats undefined as absent.
-    const stableTarget = STABLE_TARGET_OPERATIONS.filter((key) => release ? declared(key) : Object.hasOwn(value, key));
-    if (!release && stableTarget.length !== STABLE_TARGET_OPERATIONS.length)
-        invalidFields();
     const name = stableName(input.name);
     const version = stableName(input.version);
-    if (release)
-        admitRelease(name, value, stableTarget.length);
+    const missing = RELEASE_OPERATIONS.filter((key) => value[key] === undefined);
+    if (missing.length > 0) {
+        throw new TypeError(`Adapter ${name} must declare ${missing.join(', ')} to deploy immutable releases.`);
+    }
     if (value.bundler === undefined)
         missingBundler(name);
     const bundler = admitBundler(input.bundler);
     const receiver = Object.freeze({ ...input });
-    const required = new Set([...(release ? RELEASE_OPERATIONS : []), ...stableTarget]);
-    const operations = Object.fromEntries(OPERATIONS.filter((key) => required.has(key) || declared(key)).map((key) => [
-        key,
-        capture(receiver, key),
-    ]));
-    if (value.commands !== undefined && !release) {
-        throw new TypeError(`Adapter ${name} declares commands without adapter interface v2.`);
-    }
+    const operations = Object.fromEntries(OPERATIONS.filter((key) => RELEASE_OPERATIONS.includes(key) ||
+        value[key] !== undefined).map((key) => [key, capture(receiver, key)]));
     const adapter = Object.freeze({
         kind: 'adapter',
         name,
@@ -64,22 +47,7 @@ export function defineAdapter(input) {
     admittedAdapters.add(adapter);
     return adapter;
 }
-/**
- * An adapter interface v2 definition implements configure, placement and deployRelease, and keeps
- * prepare with deploy, or neither.
- */
-function admitRelease(name, value, stableTargetOperations) {
-    const missing = RELEASE_OPERATIONS.filter((key) => value[key] === undefined);
-    if (missing.length > 0) {
-        throw new TypeError(`Adapter ${name} declares part of adapter interface v2 without ${missing.join(', ')}: ` +
-            'an adapter that deploys immutable deployments implements configure, placement and ' +
-            'deployRelease.');
-    }
-    if (stableTargetOperations === 1) {
-        throw new TypeError(`Adapter ${name} declares only one of prepare and deploy: an adapter that keeps the legacy ` +
-            'direct-mode path declares both.');
-    }
-}
+/** Bind one admitted adapter to the parameters of one Project Environment. */
 export function defineDeployment(adapter, parameters) {
     if (!isAdapter(adapter))
         throw new TypeError('Deployment Adapter is not admitted.');
@@ -88,7 +56,7 @@ export function defineDeployment(adapter, parameters) {
     }
     return captureDeployment(adapter, Object.freeze({ ...parameters }));
 }
-/** Whether `defineAdapter` admitted this value, on either contract. */
+/** Whether defineAdapter admitted this immutable-deployment adapter. */
 export function isAdapter(input) {
     return input !== null && typeof input === 'object' && admittedAdapters.has(input);
 }
@@ -130,7 +98,7 @@ function record(input, label) {
     }
     return input;
 }
-/** Every adapter, on either contract, declares the bundler of the bytes it deploys. */
+/** Every adapter declares the bundler of the bytes it deploys. */
 function missingBundler(name) {
     throw new TypeError(`Adapter ${name} declares no bundler. ` +
         'Every adapter declares `bundler`: the bundler of the environment-free bytes ' +