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

package/dist/tooling/cli/commit.js

@@ -0,0 +1,216 @@
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { isVersion } from '../../platform/versioning/version.js';
+/** A commit as `DeploymentCommitV1` holds it: the full SHA-1 git prints, in lower case. */
+const SHA = /^[0-9a-f]{40}$/u;
+/** `git describe --long` output: `<tag>-<commits since the tag>-g<abbreviated commit>`. */
+const DESCRIBED = /^(?<tag>.+)-(?<distance>\d+)-g[0-9a-f]+$/u;
+/** A tag prefix this module can hand to `git describe --match` without escaping a glob. */
+const LITERAL_PREFIX = /^[^*?[\]\\\s]*$/u;
+/** The configuration files release-please reads at a repository root, the dotted name first. */
+const RELEASE_PLEASE_CONFIGS = ['.release-please-config.json', 'release-please-config.json'];
+const GIT_TIMEOUT_MS = 30_000;
+/**
+ * The commit provenance a canonical deploy declares in its deployment record (CT18 `commit`): the
+ * commit of the repository the Project lives in, whether the working tree holds changes that
+ * commit does not, and the last release of the Domain before it, as `git describe` finds it.
+ *
+ * - `dirty` covers tracked changes and untracked files, over the whole working tree; ignored files
+ *   never count. Unlike `git describe --dirty`, an untracked file counts, since a build can import
+ *   it.
+ * - `base` is the nearest release tag of the package the Domain is released from: the
+ *   release-please package that holds the Domain's runtime module (see {@link releaseTagPrefixes}).
+ *   The tag prefix is stripped, and a tag whose rest is not a canonical SemVer version is left
+ *   out, so the record never carries a base a deployment name would refuse (AM-57). A Domain no
+ *   release line holds declares no base: it is never given another package's version.
+ * - Outside a git repository, without git, or in a repository whose commits are not SHA-1, the
+ *   deploy declares no commit (`null`); a deploy never fails for want of provenance.
+ */
+export async function deploymentCommit(input) {
+    const head = await git(input.projectDir, input.signal, ['rev-parse', '--verify', 'HEAD']);
+    if (head === undefined || !SHA.test(head))
+        return null;
+    const status = await git(input.projectDir, input.signal, [
+        'status',
+        '--porcelain',
+        '--untracked-files=normal',
+    ]);
+    if (status === undefined)
+        return null;
+    const prefixes = await releaseTagPrefixes(input);
+    const base = prefixes === undefined ? undefined : await describedBase(input, prefixes);
+    return Object.freeze({
+        sha: head,
+        dirty: status.length > 0,
+        ...(base === undefined ? {} : { base }),
+    });
+}
+/**
+ * The prefixes of the release tags of the package the Domain is released from, or nothing when
+ * no release line holds the Domain.
+ *
+ * In a repository with a release-please configuration at its root, that package is the configured
+ * package whose path is the nearest one holding the runtime module's directory, unless one of its
+ * `exclude-paths` holds it. Its tags are named as release-please names them: `<component>`, its
+ * `tag-separator` (`-`) and `v` before the version, without the component when
+ * `include-component-in-tag` is false and without the `v` when `include-v-in-tag` is false; the
+ * component is the package's `component`, else its unscoped `package-name`, else the unscoped name
+ * in its `package.json`. Root-level options are the packages' defaults, as in release-please.
+ *
+ * Without a configuration, the tags are those `npm version` writes (`v<version>`) and
+ * `<name>-v<version>`, where the name is the unscoped one in the Project's `package.json`.
+ */
+async function releaseTagPrefixes(input) {
+    const root = await git(input.projectDir, input.signal, ['rev-parse', '--show-toplevel']);
+    if (root === undefined)
+        return undefined;
+    const config = await releasePleaseConfig(root);
+    if (config === undefined) {
+        const name = unscoped(await packageName(input.projectDir));
+        return literal(['v', ...(name === undefined ? [] : [`${name}-v`])]);
+    }
+    // Git names the module's directory relative to its repository, symbolic links resolved.
+    const located = await git(dirname(input.runtimeModule), input.signal, [
+        'rev-parse',
+        '--show-toplevel',
+        '--show-prefix',
+    ]);
+    const [moduleRoot, prefix = ''] = located?.split('\n') ?? [];
+    if (moduleRoot !== root)
+        return undefined;
+    const path = prefix.replace(/\/$/u, '');
+    const found = releasePackage(config, path);
+    if (found === undefined)
+        return undefined;
+    const option = (key) => found.options[key] ?? config[key];
+    const v = option('include-v-in-tag') === false ? '' : 'v';
+    if (option('include-component-in-tag') === false)
+        return literal([v]);
+    const separator = option('tag-separator') ?? '-';
+    const component = option('component') ??
+        unscoped(option('package-name')) ??
+        unscoped(await packageName(join(root, found.path)));
+    if (typeof component !== 'string' || component.length === 0 || typeof separator !== 'string') {
+        return undefined;
+    }
+    return literal([`${component}${separator}${v}`]);
+}
+/**
+ * The configured package that holds `path` (relative to the repository root, `''` for the root),
+ * the nearest one first, or nothing when none holds it or its `exclude-paths` do.
+ */
+function releasePackage(config, path) {
+    const packages = config.packages;
+    if (packages === null || typeof packages !== 'object' || Array.isArray(packages))
+        return undefined;
+    let found;
+    for (const [key, options] of Object.entries(packages)) {
+        if (options === null || typeof options !== 'object' || Array.isArray(options))
+            continue;
+        const packagePath = key === '.' ? '' : key.replace(/^\.\//u, '').replace(/\/$/u, '');
+        if (!holds(packagePath, path))
+            continue;
+        if (found === undefined || packagePath.length > found.path.length) {
+            found = { path: packagePath, options: options };
+        }
+    }
+    if (found === undefined)
+        return undefined;
+    const excluded = found.options['exclude-paths'] ?? config['exclude-paths'];
+    if (Array.isArray(excluded)) {
+        for (const exclusion of excluded) {
+            if (typeof exclusion !== 'string')
+                continue;
+            const relative = exclusion.replace(/^\.\//u, '').replace(/\/$/u, '');
+            if (holds(found.path === '' ? relative : `${found.path}/${relative}`, path))
+                return undefined;
+        }
+    }
+    return found;
+}
+/** Whether the directory `outer` holds `inner`, both relative to the repository root. */
+function holds(outer, inner) {
+    return outer === '' || inner === outer || inner.startsWith(`${outer}/`);
+}
+/** The canonical version and distance of the nearest tag with one of these prefixes, or nothing. */
+async function describedBase(input, prefixes) {
+    const described = await git(input.projectDir, input.signal, [
+        'describe',
+        '--tags',
+        '--long',
+        '--abbrev=40',
+        ...prefixes.flatMap((prefix) => ['--match', `${prefix}[0-9]*`]),
+        'HEAD',
+    ]);
+    const match = described === undefined ? null : DESCRIBED.exec(described);
+    if (match?.groups === undefined)
+        return undefined;
+    const tag = match.groups.tag;
+    const distance = Number(match.groups.distance);
+    const version = prefixes
+        .filter((prefix) => tag.startsWith(prefix))
+        .map((prefix) => tag.slice(prefix.length))
+        .find((rest) => isVersion(rest));
+    if (version === undefined || !Number.isSafeInteger(distance))
+        return undefined;
+    return Object.freeze({ version, distance });
+}
+/** The repository's release-please configuration, if its root has one that is a JSON object. */
+async function releasePleaseConfig(root) {
+    for (const name of RELEASE_PLEASE_CONFIGS) {
+        const config = await readJson(join(root, name));
+        if (config !== undefined)
+            return config;
+    }
+    return undefined;
+}
+/** The `name` of the `package.json` in a directory, if it has one. */
+async function packageName(directory) {
+    return (await readJson(join(directory, 'package.json')))?.name;
+}
+/** A package name without its npm scope, as release-please makes a component of it. */
+function unscoped(name) {
+    if (typeof name !== 'string' || name.length === 0)
+        return undefined;
+    return name.startsWith('@') ? name.slice(name.indexOf('/') + 1) || undefined : name;
+}
+/** The prefixes, unless one would be read as a glob by `git describe --match`. */
+function literal(prefixes) {
+    return prefixes.every((prefix) => LITERAL_PREFIX.test(prefix)) ? prefixes : undefined;
+}
+async function readJson(path) {
+    let value;
+    try {
+        value = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/**
+ * Run one read-only git command in a directory and return its trimmed stdout, or nothing when git
+ * is missing or the command fails. An interrupted deploy still stops here.
+ */
+function git(cwd, signal, args) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        execFile('git', [...args], {
+            cwd,
+            // Never take the index lock: a deploy only reads the repository.
+            env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+            signal,
+            timeout: GIT_TIMEOUT_MS,
+            windowsHide: true,
+        }, (error, stdout) => {
+            if (signal.aborted) {
+                reject(signal.reason);
+                return;
+            }
+            resolve(error === null ? stdout.trim() : undefined);
+        });
+    });
+}

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

@@ -8,8 +8,12 @@ import type { LoadedEnvironment } from './project.js';
  *   `deployRelease`, with a key generated for it, and zero Kernel calls.
  * - `legacy-direct`: today's stable target, replaced in place through `prepare` and `deploy`, which
  *   serves a v3 Publication only. Its `reasons` name what selected it.
- * - `refused`: a shape whose only consumer pins an older SDK, refused before any effect. Each
- *   refusal carries the configuration or command to write instead.
+ * - `refused`: a shape no deploy of this SDK serves, refused before any effect. Each refusal
+ *   carries the configuration or command to write instead.
+ *
+ * A deploy never installs, so two shapes are refused before a mode is selected at all: an
+ * Environment that declares `installation` by `defineProject`, and `--deploy-only` by the
+ * command-line parser (AM-72).
  */
 export type DeployMode = {
     readonly kind: 'canonical';
@@ -31,28 +35,32 @@ export type LegacyDirectReason =
  | {
     readonly reason: 'no-namespace';
 }
-/** An adapter that declares no `deployRelease` (the contract before adapter interface v2). */
+/**
+ * An adapter that declares no `deployRelease` (the contract before adapter interface v2),
+ * adapter-astrale's instance mode among them until adapter-astrale implements it.
+ */
  | {
     readonly reason: 'no-deploy-release';
 };
 export type CloudflareDirectParameter = 'route' | 'workerName' | 'identityIssuer' | 'addressing' | 'signingIdentity';
 export interface DeployRefusal {
-    readonly reason: 'installation' | 'deploy-only' | 'astrale-instance' | 'astrale-signing-identity' | 'mixed-parameters' | 'scheduled-triggers' | 'development-canonical';
+    readonly reason: 'astrale-instance' | 'astrale-signing-identity' | 'mixed-parameters' | 'scheduled-triggers' | 'development-canonical';
     /** The configuration or command to write instead, for the author. */
     readonly guidance: string;
 }
 /** The commands that select a deploy mode. `publish` refuses every Environment that is not canonical. */
 export type DeployModeCommand = 'deploy' | 'dev';
 /**
- * Select the deploy mode of one Environment (CT33). It reads the configuration and the command line
+ * 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: an `installation` field, `--deploy-only`, and
- * adapter-astrale `instance` or `signingIdentity` reach only the SDK, whose one consumer of them
- * pins an older SDK, so they are refused before any effect (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, except
- * under `dev`, which serves the legacy direct-mode path only.
+ * A refusal wins over every other reason. Once adapter-astrale deploys immutable deployments
+ * (`deployRelease`), its `instance` and `signingIdentity` are refused before any effect: their one
+ * consumer pins an older SDK (AM-72). Until then they select its instance mode, on the legacy path
+ * with every adapter that declares no `deployRelease`. 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, except under `dev`,
+ * which serves the legacy direct-mode path only.
  *
  * 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
@@ -63,5 +71,4 @@ export declare function selectDeployMode(input: {
     readonly command: DeployModeCommand;
     readonly environment: string;
     readonly definition: LoadedEnvironment;
-    readonly deployOnly: boolean;
 }): DeployMode;

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

@@ -1,3 +1,4 @@
+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';
@@ -9,15 +10,16 @@ const CLOUDFLARE_DIRECT_PARAMETERS = [
     'signingIdentity',
 ];
 /**
- * Select the deploy mode of one Environment (CT33). It reads the configuration and the command line
+ * 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: an `installation` field, `--deploy-only`, and
- * adapter-astrale `instance` or `signingIdentity` reach only the SDK, whose one consumer of them
- * pins an older SDK, so they are refused before any effect (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, except
- * under `dev`, which serves the legacy direct-mode path only.
+ * A refusal wins over every other reason. Once adapter-astrale deploys immutable deployments
+ * (`deployRelease`), its `instance` and `signingIdentity` are refused before any effect: their one
+ * consumer pins an older SDK (AM-72). Until then they select its instance mode, on the legacy path
+ * with every adapter that declares no `deployRelease`. 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, except under `dev`,
+ * which serves the legacy direct-mode path only.
  *
  * 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
@@ -30,34 +32,15 @@ export function selectDeployMode(input) {
     const parameters = definition.deployment.parameters;
     const refusals = [];
     const reasons = [];
-    const installation = definition.installation;
-    if (installation !== undefined) {
-        refusals.push({
-            reason: 'installation',
-            guidance: `Environment ${environment} declares installation, and a deploy no longer installs. ` +
-                'Remove `installation` from the Environment, run ' +
-                `\`astrale-domain deploy ${environment}\`, then install the URL it prints with ` +
-                `\`astrale domain install <url> -i ${installation.instance}` +
-                `${installation.identity === undefined ? '' : ` --as ${installation.identity}`}\`.`,
-        });
-    }
-    if (input.deployOnly) {
-        refusals.push({
-            reason: 'deploy-only',
-            guidance: '`--deploy-only` is no longer accepted: a deploy never installs. Run ' +
-                `\`astrale-domain ${command} ${environment}\` without it, then ` +
-                '`astrale domain install <url> -i <instance>`.',
-        });
-    }
-    if (adapter.name === ASTRALE) {
+    const releases = 'deployRelease' in adapter && typeof adapter.deployRelease === 'function';
+    if (adapter.name === ASTRALE && releases) {
         if (declares(parameters, 'instance')) {
             refusals.push({
                 reason: 'astrale-instance',
                 guidance: `astrale({ instance: '${String(parameters.instance)}' }) deployed through that ` +
                     "instance's Services, which no longer hosts deployments. Remove `instance`: " +
                     `\`astrale-domain deploy ${environment}\` makes an immutable deployment on Admin's ` +
-                    'Services, and `astrale domain install <url> -i ' +
-                    `${String(parameters.instance)}\` installs it.`,
+                    `Services, and \`${installCommand(String(parameters.instance))}\` installs it.`,
             });
         }
         if (declares(parameters, 'signingIdentity')) {
@@ -93,9 +76,8 @@ export function selectDeployMode(input) {
             reasons.push(...direct.map((parameter) => ({ reason: 'direct-parameter', parameter })), { reason: 'no-namespace' });
         }
     }
-    if (!('deployRelease' in adapter) || typeof adapter.deployRelease !== 'function') {
+    if (!releases)
         reasons.push({ reason: 'no-deploy-release' });
-    }
     if (refusals.length > 0)
         return Object.freeze({ kind: 'refused', refusals: freeze(refusals) });
     if (reasons.length > 0)
@@ -108,7 +90,7 @@ export function selectDeployMode(input) {
                     reason: 'development-canonical',
                     guidance: `\`astrale-domain dev\` serves only legacy direct-mode Environments, and ${environment} ` +
                         `deploys immutable deployments. Run \`astrale-domain deploy ${environment}\`, then ` +
-                        '`astrale domain install <url> -i <instance>`.',
+                        `\`${installCommand()}\`.`,
                 },
             ]),
         });

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

@@ -6,9 +6,7 @@ export type { DeploymentSecretsState } from '../../deployment/index.js';
 /**
  * `astrale-domain deploy <environment> --json` on stdout: the one deployment the deploy made or
  * reused, which CI installs by its URL. Progress and warnings go to stderr. It names no instance
- * and no version: a deploy numbers nothing, and the deploy of an immutable deployment installs
- * nothing. A legacy environment that declares `installation` still installs while it deploys and
- * reports that outcome on stderr only.
+ * and no version: a deploy numbers nothing and installs nothing.
  */
 export interface DeployResultV1 {
     readonly format: 'astrale.deploy-result';
@@ -62,14 +60,19 @@ export interface DeployResultV1 {
     readonly secrets?: {
         readonly state: DeploymentSecretsState;
     };
-    /** The commit the deployment was built from, as its deployment record declares it. */
+    /**
+     * The commit the deployment was built from, as its deployment record declares it: the commit of
+     * the deploy that created it. A reused deployment keeps its record, so this can be an earlier
+     * commit than the one the deploy ran from; the label covers the release, never the commit.
+     */
     readonly commit: DeploymentCommitV1 | null;
 }
 /**
  * The deploy result of one immutable deployment, from the ready result of the adapter's
- * `deployRelease`. Its release, build, Schema revision and URL are those of the release the SDK
- * sealed before deploying; the deployment record the adapter returned must declare exactly that
- * release at that URL, so the result never names a release the deployment does not serve.
+ * `deployRelease`. Its release, build, Schema revision and URL are those the SDK sealed before
+ * deploying; the deployment record the adapter returned must declare exactly that release at that
+ * URL, so the result never names a release the deployment does not serve. Its commit is the
+ * record's, which a reused deployment kept from the deploy that created it.
  */
 export declare function deployResult(input: {
     readonly environment: string;

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

@@ -6,9 +6,10 @@ const SECRETS_BY_STATE = Object.freeze({
 });
 /**
  * The deploy result of one immutable deployment, from the ready result of the adapter's
- * `deployRelease`. Its release, build, Schema revision and URL are those of the release the SDK
- * sealed before deploying; the deployment record the adapter returned must declare exactly that
- * release at that URL, so the result never names a release the deployment does not serve.
+ * `deployRelease`. Its release, build, Schema revision and URL are those the SDK sealed before
+ * deploying; the deployment record the adapter returned must declare exactly that release at that
+ * URL, so the result never names a release the deployment does not serve. Its commit is the
+ * record's, which a reused deployment kept from the deploy that created it.
  */
 export function deployResult(input) {
     const { release, deployment } = input;

package/dist/tooling/cli/development/candidate.d.ts

@@ -1,9 +1,8 @@
-import type { InstallationTarget, PreparedArtifact } from '../../../deployment/adapter/index.js';
+import type { PreparedArtifact } from '../../../deployment/adapter/index.js';
 import type { StableTargetAdapter } from '../legacy/stable-target-adapter.js';
 export interface DevelopmentCandidate {
     readonly adapter: StableTargetAdapter<object>;
     readonly parameters: object;
-    readonly installation?: InstallationTarget;
     readonly artifact: PreparedArtifact;
     readonly secrets: Readonly<Record<string, string>>;
     readonly sources: ReadonlySet<string>;
@@ -22,5 +21,5 @@ export declare class DevelopmentCandidateBuilder {
 }
 export declare function discoverRuntimePath(configPath: string): Promise<string>;
 export declare function sameEnvironment(current: DevelopmentCandidate, candidate: DevelopmentCandidate): boolean;
-/** Identify a rebuilt candidate that cannot change provider or installation state. */
+/** Identify a rebuilt candidate that cannot change provider state. */
 export declare function sameDeploymentCandidate(current: DevelopmentCandidate, candidate: DevelopmentCandidate): boolean;

package/dist/tooling/cli/development/candidate.js

@@ -84,9 +84,6 @@ export class DevelopmentCandidateBuilder {
             const source = await adapter.prepare(parameters, {
                 projectDir: this.#projectDir,
                 environment: this.#environment,
-                ...(environment.installation === undefined
-                    ? {}
-                    : { installation: environment.installation }),
                 mode: 'release',
                 recordSource: sources.record,
                 signal,
@@ -102,9 +99,6 @@ export class DevelopmentCandidateBuilder {
             return Object.freeze({
                 adapter,
                 parameters,
-                ...(environment.installation === undefined
-                    ? {}
-                    : { installation: environment.installation }),
                 artifact,
                 secrets: declared.values,
                 sources: sources.snapshot(),
@@ -125,10 +119,9 @@ export function sameEnvironment(current, candidate) {
         candidate.adapter.version === current.adapter.version &&
         candidate.artifact.build.schema.compiled.root.origin ===
             current.artifact.build.schema.compiled.root.origin &&
-        stable(candidate.parameters) === stable(current.parameters) &&
-        stable(candidate.installation) === stable(current.installation));
+        stable(candidate.parameters) === stable(current.parameters));
 }
-/** Identify a rebuilt candidate that cannot change provider or installation state. */
+/** Identify a rebuilt candidate that cannot change provider state. */
 export function sameDeploymentCandidate(current, candidate) {
     return (sameEnvironment(current, candidate) &&
         candidate.artifact.build.schema.compiled.root.revision ===

package/dist/tooling/cli/development/deployment.d.ts

@@ -1,16 +1,10 @@
 import type { ReadyDeployResult } from '../../../deployment/adapter/index.js';
-import type { InstallationEvidence } from '../installation/index.js';
 import type { DevelopmentCandidate } from './candidate.js';
 export interface DevelopmentDeploymentInput {
     readonly projectDir: string;
     readonly environment: string;
-    readonly deployOnly: boolean;
     readonly identity?: string;
     readonly credential?: string;
-    readonly installationExecutable?: string;
 }
-/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
-export declare function deployDevelopmentCandidate(candidate: DevelopmentCandidate, input: DevelopmentDeploymentInput, signal: AbortSignal): Promise<{
-    readonly deployment: ReadyDeployResult;
-    readonly installation?: InstallationEvidence;
-}>;
+/** Commit and verify one complete remote candidate. A development deployment installs nothing. */
+export declare function deployDevelopmentCandidate(candidate: DevelopmentCandidate, input: DevelopmentDeploymentInput, signal: AbortSignal): Promise<ReadyDeployResult>;

package/dist/tooling/cli/development/deployment.js

@@ -1,11 +1,9 @@
 import { verifyDeployment } from '../../../deployment/index.js';
-import { reconcileEnvironmentRelease } from '../environment-release.js';
-/** Commit and verify one complete remote candidate, then reconcile its optional installation. */
+/** Commit and verify one complete remote candidate. A development deployment installs nothing. */
 export async function deployDevelopmentCandidate(candidate, input, signal) {
     const deployed = await candidate.adapter.deploy(candidate.parameters, {
         projectDir: input.projectDir,
         environment: input.environment,
-        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
         ...(input.identity === undefined ? {} : { identity: input.identity }),
         ...(input.credential === undefined ? {} : { credential: input.credential }),
         secrets: candidate.secrets,
@@ -18,22 +16,5 @@ export async function deployDevelopmentCandidate(candidate, input, signal) {
             cause: verified.error,
         });
     }
-    const installation = await reconcileEnvironmentRelease({
-        projectDir: input.projectDir,
-        environment: input.environment,
-        adapter: candidate.adapter,
-        deployment: verified,
-        ...(candidate.installation === undefined ? {} : { installation: candidate.installation }),
-        deployOnly: input.deployOnly,
-        ...(input.installationExecutable === undefined
-            ? {}
-            : { installationExecutable: input.installationExecutable }),
-        ...(input.identity === undefined ? {} : { identity: input.identity }),
-        ...(input.credential === undefined ? {} : { credential: input.credential }),
-        signal,
-    });
-    return Object.freeze({
-        deployment: verified,
-        ...(installation === undefined ? {} : { installation }),
-    });
+    return verified;
 }

package/dist/tooling/cli/development/develop.d.ts

@@ -1,11 +1,12 @@
-/** Watch one Project Environment and serialize complete remote deployment generations. */
+/**
+ * Watch one Project Environment and serialize complete remote deployment generations. Each
+ * generation replaces the Environment's stable target in place; none installs anything.
+ */
 export declare function develop(input: {
     readonly configPath: string;
     readonly projectDir: string;
     readonly environment: string;
-    readonly deployOnly: boolean;
     readonly identity?: string;
     readonly credentialFile?: string;
-    readonly sessionFile?: string;
     readonly secretsFile?: string;
 }): Promise<number>;