@prisma/composer 0.6.0-dev.2 → 0.6.0-dev.20

package/dist/{app-config-Cbv_lA38-BHJsd1DF.d.mts → app-config-aIrriqVU-Dpj1RqnY.d.mts}

@@ -1,11 +1,11 @@
-import { F as ResourceNode, M as ProvisionNeed, U as ServiceNode, d as Graph, n as Config, t as BuildAdapter, w as NodeId, x as ModuleNode } from "./graph-types-C3FOaaXm-C6_rGzfn.mjs";
-import "./graph-DDpXh7S8-b-93BcHn.mjs";
+import { F as ResourceNode, M as ProvisionNeed, U as ServiceNode, d as Graph, n as Config, t as BuildAdapter, w as NodeId, x as ModuleNode } from "./graph-types-N6brq1zY-1VMNwtkJ.mjs";
+import "./graph-DqklX5Sf-BNS2aO1j.mjs";
 import * as Alchemy from "alchemy";
 import { Input, StackServices } from "alchemy";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { State } from "alchemy/State/State";
-//#region ../../0-framework/1-core/core/dist/app-config-Cbv_lA38.d.mts
+//#region ../../0-framework/1-core/core/dist/app-config-aIrriqVU.d.mts
 //#region src/container-transport.d.ts
 /**
  * Carries resolved containers from the CLI process into the alchemy process
@@ -36,23 +36,42 @@ interface ContainerInstance {
   /** Serialize to a non-empty string for the process transport above. The format is the extension's own; only its `deserialize` reads it. */
   serialize(): string;
 }
+/**
+ * What the caller has already authenticated, handed to one container
+ * lifecycle call. A caller that holds neither omits the argument, and the
+ * extension falls back to whatever credential protocol it defines for
+ * itself (for Prisma Cloud, its env vars — which is how the alchemy child
+ * process still resolves containers).
+ *
+ * `C` is the extension's own platform-client type, left as a type parameter
+ * because this shared-plane module must not import a platform SDK; the
+ * framework only carries the value, never calls it. The framework stores the
+ * erased `C = unknown` form and the extension recovers its concrete client
+ * through the same method bivariance that erases `I` below.
+ */
+interface ContainerCredentials<C = unknown> {
+  /** The workspace the container lives in. `undefined` when the caller has no workspace to name — the extension decides whether it can proceed. */
+  readonly workspaceId: string | undefined;
+  /** An already-authenticated platform API client. Present means the extension must not build its own from the environment. */
+  readonly client?: C | undefined;
+}
 /**
  * The platform containers an app deploys into, as one lifecycle. `I` is
  * the extension's own instance type — the same descriptor produces and
  * consumes it, so the extension gets full typing internally while the
- * framework stores the erased form. METHOD SYNTAX REQUIRED on all four
- * members: the erased assignment into ExtensionDescriptor compiles only
- * through method bivariance; property-arrow members are checked
- * contravariantly and the assignment fails (same rule as
- * ServiceLowering<P, S> — ADR-0033).
+ * framework stores the erased form; `C` erases the same way. METHOD SYNTAX
+ * REQUIRED on all four members: the erased assignment into
+ * ExtensionDescriptor compiles only through method bivariance;
+ * property-arrow members are checked contravariantly and the assignment
+ * fails (same rule as ServiceLowering<P, S> — ADR-0033).
  */
-interface ContainerDescriptor<I extends ContainerInstance = ContainerInstance> {
+interface ContainerDescriptor<I extends ContainerInstance = ContainerInstance, C = unknown> {
   /** Resolve the container for (appName, stage), creating anything absent. Called by `deploy`. */
-  ensure(input: LocateContainerInput): Promise<I>;
+  ensure(input: LocateContainerInput, credentials?: ContainerCredentials<C>): Promise<I>;
   /** Find the container for (appName, stage); `undefined` when nothing exists. Called by `destroy` — never creates. */
-  locate(input: LocateContainerInput): Promise<I | undefined>;
+  locate(input: LocateContainerInput, credentials?: ContainerCredentials<C>): Promise<I | undefined>;
   /** Remove the container after a successful destroy, after every extension's `teardown` has run. Failure policy is the extension's. */
-  remove(instance: I): Promise<void>;
+  remove(instance: I, credentials?: ContainerCredentials<C>): Promise<void>;
   /** Reconstruct an instance from its own `serialize()` output — the far end of the framework's parent→child transport. */
   deserialize(serialized: string): I;
 }
@@ -348,8 +367,13 @@ interface ExtensionDescriptor {
    * runs. A target uses it to verify platform prerequisites (e.g. that every
    * secret env var in the provision manifest exists for the resolved stage) and
    * throws to abort the deploy. Async: it talks to the platform (ADR-0029).
+   *
+   * METHOD SYNTAX REQUIRED, for the same reason ContainerDescriptor's members
+   * need it: the framework hands over the erased `PreflightInput<unknown>`,
+   * and an extension that types the input against its own client type only
+   * assigns here through method bivariance.
    */
-  readonly preflight?: (input: PreflightInput) => Promise<void>;
+  preflight?(input: PreflightInput): Promise<void>;
   /**
    * Destroy-time cleanup — the CLI runs it once, after `alchemy destroy`
    * succeeds and BEFORE the stage's Project/Branch are removed. A target uses
@@ -391,14 +415,16 @@ interface StateDescriptor {
   /** Build the state layer. `container` is the owning extension's resolved instance; `undefined` when it declared no container descriptor. */
   create(container: ContainerInstance | undefined): AlchemyStateLayer;
 }
-/** The resolved deploy context handed to an extension's `preflight` hook. */
-interface PreflightInput {
+/** The resolved deploy context handed to an extension's `preflight` hook. `C` erases to `unknown` at the framework boundary — see ContainerCredentials. */
+interface PreflightInput<C = unknown> {
   /** The loaded application graph — the manifest of prerequisites is read from it (`provisionManifest`). */
   readonly graph: Graph;
   /** The calling extension's own resolved container; `undefined` when it declares no container descriptor. Narrow with the extension's guard. */
   readonly container: ContainerInstance | undefined;
   /** The stage name (`--stage`), or `undefined` for the default stage — for diagnostics/scope. */
   readonly stage: string | undefined;
+  /** What the caller has already authenticated, for the platform calls preflight makes. Absent means the extension falls back to its own credential protocol. */
+  readonly credentials?: ContainerCredentials<C> | undefined;
 }
 /** The resolved destroy context handed to an extension's `teardown` hook. */
 interface TeardownInput {
@@ -493,5 +519,5 @@ interface PrismaAppConfig {
 /** Typed identity — exists so `prisma-composer.config.ts` gets checked against PrismaAppConfig where it is written. */
 declare function defineConfig(config: PrismaAppConfig): PrismaAppConfig;
 //#endregion
-export { ProvisionerDescriptor as A, joinDeployment as B, Lowering as C, PreflightInput as D, PackageInput as E, containerEnv as F, lowering as H, containerEnvVarName as I, defineConfig as L, StateDescriptor as M, TeardownInput as N, PrismaAppConfig as O, buildConfig as P, deserializeContainers as R, LoweredResult as S, Outputs as T, mergedProviders as U, lower as V, resolveStateLayer as W, LocalTargetProvidersInput as _, Bundle as a, LowerError as b, DEV_DIR as c, DeploymentResult as d, ExtensionDescriptor as f, LocalTargetEmulatorsInput as g, LocalTargetDescriptor as h, AssembleInput as i, ServiceLowering as j, ProvisionEdge as k, DeployedEntity as l, LocalTargetAttachment as m, ApplicationDescriptor as n, ContainerDescriptor as o, LocalTargetAttachInput as p, Artifact as r, ContainerInstance as s, AlchemyStateLayer as t, DeployedNode as u, LocateContainerInput as v, NodeDescriptor as w, LowerOptions as x, LowerContext as y, isBuildOnlyExtension as z };
-//# sourceMappingURL=app-config-Cbv_lA38-BHJsd1DF.d.mts.map
+export { ProvisionEdge as A, isBuildOnlyExtension as B, LoweredResult as C, PackageInput as D, Outputs as E, buildConfig as F, resolveStateLayer as G, lower as H, containerEnv as I, containerEnvVarName as L, ServiceLowering as M, StateDescriptor as N, PreflightInput as O, TeardownInput as P, defineConfig as R, LowerOptions as S, NodeDescriptor as T, lowering as U, joinDeployment as V, mergedProviders as W, LocalTargetEmulatorsInput as _, Bundle as a, LowerContext as b, ContainerInstance as c, DeployedNode as d, DeploymentResult as f, LocalTargetDescriptor as g, LocalTargetAttachment as h, AssembleInput as i, ProvisionerDescriptor as j, PrismaAppConfig as k, DEV_DIR as l, LocalTargetAttachInput as m, ApplicationDescriptor as n, ContainerCredentials as o, ExtensionDescriptor as p, Artifact as r, ContainerDescriptor as s, AlchemyStateLayer as t, DeployedEntity as u, LocalTargetProvidersInput as v, Lowering as w, LowerError as x, LocateContainerInput as y, deserializeContainers as z };
+//# sourceMappingURL=app-config-aIrriqVU-Dpj1RqnY.d.mts.map

package/dist/app-config-aIrriqVU-Dpj1RqnY.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-config-aIrriqVU-Dpj1RqnY.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/app-config-aIrriqVU.d.mts"],"mappings":"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"}

package/dist/config-BeBRB-6m.d.mts

@@ -0,0 +1 @@
+import "./app-config-aIrriqVU-Dpj1RqnY.mjs";

package/dist/config.d.mts

@@ -1,3 +1,3 @@
-import { D as PreflightInput, F as containerEnv, I as containerEnvVarName, L as defineConfig, M as StateDescriptor, N as TeardownInput, O as PrismaAppConfig, R as deserializeContainers, _ as LocalTargetProvidersInput, c as DEV_DIR, f as ExtensionDescriptor, g as LocalTargetEmulatorsInput, h as LocalTargetDescriptor, m as LocalTargetAttachment, o as ContainerDescriptor, p as LocalTargetAttachInput, s as ContainerInstance, v as LocateContainerInput, w as NodeDescriptor, z as isBuildOnlyExtension } from "./app-config-Cbv_lA38-BHJsd1DF.mjs";
-import "./config-whuqZ5xT.mjs";
-export { type ContainerDescriptor, type ContainerInstance, DEV_DIR, ExtensionDescriptor, LocalTargetAttachInput, LocalTargetAttachment, LocalTargetDescriptor, LocalTargetEmulatorsInput, LocalTargetProvidersInput, type LocateContainerInput, NodeDescriptor, PreflightInput, PrismaAppConfig, StateDescriptor, TeardownInput, containerEnv, containerEnvVarName, defineConfig, deserializeContainers, isBuildOnlyExtension };
+import { B as isBuildOnlyExtension, I as containerEnv, L as containerEnvVarName, N as StateDescriptor, O as PreflightInput, P as TeardownInput, R as defineConfig, T as NodeDescriptor, _ as LocalTargetEmulatorsInput, c as ContainerInstance, g as LocalTargetDescriptor, h as LocalTargetAttachment, k as PrismaAppConfig, l as DEV_DIR, m as LocalTargetAttachInput, o as ContainerCredentials, p as ExtensionDescriptor, s as ContainerDescriptor, v as LocalTargetProvidersInput, y as LocateContainerInput, z as deserializeContainers } from "./app-config-aIrriqVU-Dpj1RqnY.mjs";
+import "./config-BeBRB-6m.mjs";
+export { type ContainerCredentials, type ContainerDescriptor, type ContainerInstance, DEV_DIR, ExtensionDescriptor, LocalTargetAttachInput, LocalTargetAttachment, LocalTargetDescriptor, LocalTargetEmulatorsInput, LocalTargetProvidersInput, type LocateContainerInput, NodeDescriptor, PreflightInput, PrismaAppConfig, StateDescriptor, TeardownInput, containerEnv, containerEnvVarName, defineConfig, deserializeContainers, isBuildOnlyExtension };

package/dist/control.d.mts

@@ -0,0 +1,219 @@
+import { dt as CliStructuredError } from "./graph-types-N6brq1zY-1VMNwtkJ.mjs";
+import { u as DeployedEntity } from "./app-config-aIrriqVU-Dpj1RqnY.mjs";
+import "./config-BeBRB-6m.mjs";
+import "./index-DryPyF9U.mjs";
+import "./deploy-BeBRB-6m.mjs";
+//#region ../../0-framework/0-foundation/foundation/dist/result.d.mts
+//#region src/result.d.ts
+/**
+ * Represents a successful result containing a value.
+ */
+interface Ok<T> {
+  readonly ok: true;
+  readonly value: T;
+  assertOk(): T;
+  assertNotOk(): never;
+}
+/**
+ * Represents an unsuccessful result containing failure details.
+ */
+interface NotOk<F> {
+  readonly ok: false;
+  readonly failure: F;
+  assertOk(): never;
+  assertNotOk(): F;
+}
+/**
+ * A discriminated union representing either success (Ok) or failure (NotOk).
+ *
+ * @typeParam T - The success value type
+ * @typeParam F - The failure details type
+ */
+type Result<T, F> = Ok<T> | NotOk<F>;
+//#endregion
+//#region ../../0-framework/3-tooling/cli/dist/log-DRnnWupy.d.mts
+//#region src/deployment-summary.d.ts
+/** The serializable projection of DeploymentResult — what CAN cross the process
+ * boundary. Writer (report hook) and reader (deploy operation) share this shape. */
+interface DeployedNodeSummary {
+  readonly address: string;
+  readonly entities: readonly DeployedEntity[];
+}
+interface DeploymentSummary {
+  readonly app: string;
+  readonly nodes: readonly DeployedNodeSummary[];
+}
+//#endregion
+//#region src/operations/shared.d.ts
+/** A running service's dotted address plus its local URL — what `dev` reports
+ * as the front door and `log` reports as the tailable services. */
+interface ServiceEndpoint {
+  readonly address: string;
+  readonly url: string;
+}
+/**
+ * Where a failed execution left its artifacts — details of the CURRENT
+ * execution mechanism (a spawned deploy-engine child driving a generated
+ * stack file), for hosts that want to print a reproduce hint. The mechanism
+ * is not part of the surface's contract, so these fields may change or
+ * disappear if the mechanism does; branch on `code`/`message`/`cause` for
+ * anything durable.
+ */
+interface ExecutionDiagnostics {
+  /** The child's exit status; undefined means the spawn itself threw, or the
+   *  child was killed by a signal (`signal` then names it). */
+  readonly exitCode: number | undefined;
+  /** The signal that killed the child, when one did. A signal-killed converge
+   *  is an abort the user asked for, not a failure of the deploy — a host
+   *  should report it as an interruption and print no reproduce hint. */
+  readonly signal?: string | undefined;
+  readonly stackFilePath: string;
+  readonly reproduceCommand: string;
+  readonly cwd: string;
+}
+/**
+ * Reads the execution diagnostics an engine-failure error carries in
+ * `meta.diagnostics`; undefined for every other failure.
+ */
+declare function executionDiagnostics(f: CliStructuredError): ExecutionDiagnostics | undefined;
+//#endregion
+//#region src/operations/deploy.d.ts
+interface DeployInput {
+  /** Path to the entry module, resolved against `cwd` — same contract as `prisma-composer deploy <entry>`. */
+  readonly entry: string;
+  /** Override the root node's name (the `--name` flag's slot). */
+  readonly name?: string | undefined;
+  /** Target stage. ABSENT = production — bare deploy targets production (main.ts effectiveStage). */
+  readonly stage?: string | undefined;
+  /** Defaults to process.cwd(); the directory `.prisma-composer/` and `.alchemy` state live under. */
+  readonly cwd?: string | undefined;
+}
+interface DeploySuccess {
+  /** Parsed from the alchemy child's result file. Undefined when the child
+   * did not write one (injected fake alchemy, or a report-less apply). */
+  readonly summary: DeploymentSummary | undefined;
+}
+declare function deploy(input: DeployInput): Promise<Result<DeploySuccess, CliStructuredError>>;
+//#endregion
+//#region src/operations/destroy.d.ts
+/** Destroy must name its target explicitly — no silent default to production. Encoded, not re-derived from flags. */
+type DestroyTarget = {
+  readonly kind: 'production';
+} | {
+  readonly kind: 'stage';
+  readonly stage: string;
+};
+type DestroyEvent =
+/** Emitted before the pipeline when `<cwd>/.alchemy` is missing/empty. */
+{
+  readonly kind: 'no-local-deploy-state';
+  readonly cwd: string;
+};
+interface DestroyInput {
+  readonly entry: string;
+  readonly name?: string | undefined;
+  readonly target: DestroyTarget;
+  readonly cwd?: string | undefined;
+  /** Mid-operation notifications, in real time. Rendering is the host's. */
+  readonly onEvent?: ((event: DestroyEvent) => void) | undefined;
+}
+declare function destroy(input: DestroyInput): Promise<Result<void, CliStructuredError>>;
+//#endregion
+//#region src/operations/dev.d.ts
+type DevEvent =
+/** Initial front door + after each successful re-converge. */
+{
+  readonly kind: 'ready';
+  readonly endpoints: readonly ServiceEndpoint[];
+} | {
+  readonly kind: 'unwatchable';
+  readonly address: string;
+} | {
+  readonly kind: 'rebuild-failed';
+  readonly message: string;
+} |
+/** The file watcher itself errored (EMFILE, a vanished directory); the session keeps running. */
+{
+  readonly kind: 'watch-error';
+  readonly message: string;
+} |
+/** The app keeps running, still watching. */
+{
+  readonly kind: 'converge-failed';
+  readonly stackFilePath: string;
+  readonly reproduceCommand: string;
+  readonly cwd: string;
+} | {
+  readonly kind: 'stopping';
+} |
+/** One service refused to stop during stop(); teardown continues and `stopped` still follows. */
+{
+  readonly kind: 'stop-error';
+  readonly message: string;
+} | {
+  readonly kind: 'stopped';
+};
+interface DevInput {
+  readonly entry: string;
+  readonly name?: string | undefined;
+  readonly fresh?: boolean | undefined;
+  readonly cwd?: string | undefined;
+  readonly onEvent?: ((event: DevEvent) => void) | undefined;
+}
+/** A running dev session. The operation NEVER touches process signal handlers —
+ * the host owns signals (and must evict alchemy's import-time SIGINT/SIGTERM
+ * listeners before installing its own; see run-dev.ts). */
+interface DevSession {
+  /** The initial front door, already merged across attachments. */
+  readonly endpoints: readonly ServiceEndpoint[];
+  /** Stop the watch loop and the app's services (emulators and data stay up).
+   * Idempotent; emits 'stopping'/'stopped'; resolves `closed`. */
+  stop(): Promise<void>;
+  /** Settles when the session has fully stopped (via stop()). */
+  readonly closed: Promise<void>;
+}
+declare function dev(input: DevInput): Promise<Result<DevSession, CliStructuredError>>;
+//#endregion
+//#region src/operations/log.d.ts
+interface LogLine {
+  readonly service: string;
+  readonly line: string;
+}
+type LogEvent =
+/** One attachment's stream died; the others continue. */
+{
+  readonly kind: 'stream-failed';
+  readonly message: string;
+} |
+/** The consumer fell behind and the bounded merge queue overflowed:
+ * `count` oldest lines were dropped since the last delivered line. */
+{
+  readonly kind: 'lines-dropped';
+  readonly count: number;
+};
+interface LogInput {
+  readonly entry: string;
+  readonly name?: string | undefined;
+  /** Restrict to one service's dotted address; validated against running services. */
+  readonly address?: string | undefined;
+  /** Trailing history lines before live output. Defaults to 0 (live only) —
+   * the attachment contract's default; the CLI's user-facing default of 20 stays in main.ts. */
+  readonly tail?: number | undefined;
+  readonly cwd?: string | undefined;
+  /** Ends the stream when aborted. The host owns SIGINT/SIGTERM → abort. */
+  readonly signal?: AbortSignal | undefined;
+  readonly onEvent?: ((event: LogEvent) => void) | undefined;
+}
+interface LogAttached {
+  /** For the adapter's empty-services notice. */
+  readonly appName: string;
+  /** Every running service. EMPTY means nothing is running — a valid, non-failure state;
+   * `lines` is then an already-finished iterable. */
+  readonly services: readonly ServiceEndpoint[];
+  /** Merged, address-filtered stream; ends on signal abort or when every source ends. */
+  readonly lines: AsyncIterable<LogLine>;
+}
+declare function log(input: LogInput): Promise<Result<LogAttached, CliStructuredError>>;
+//#endregion
+export { type CliStructuredError, type DeployInput, type DeploySuccess, type DeployedNodeSummary, type DeploymentSummary, type DestroyEvent, type DestroyInput, type DestroyTarget, type DevEvent, type DevInput, type DevSession, type ExecutionDiagnostics, type LogAttached, type LogEvent, type LogInput, type LogLine, type NotOk, type Ok, type Result, type ServiceEndpoint, deploy, destroy, dev, executionDiagnostics, log };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../../../0-framework/0-foundation/foundation/dist/result.d.mts","../../../0-framework/3-tooling/cli/dist/log-DRnnWupy.d.mts"],"mappings":";;;;;;;;;;UAIU,GAAG;WACF;WACA,OAAO;EAChB,YAAY;EACZ;;;;;UAKQ,MAAM;WACL;WACA,SAAS;EAClB;EACA,eAAe;;;;;;;;KAQZ,OAAO,GAAG,KAAK,GAAG,KAAK,MAAM;;;;;;UCfxB;WACC;WACA,mBAAmB;;UAEpB;WACC;WACA,gBAAgB;;;;;;UAMjB;WACC;WACA;;;;;;;;;;UA2CD;;;WAGC;;;;WAIA;WACA;WACA;WACA;;;;;;iBAMM,qBAAqB,GAAG,qBAAqB;;;UAGpD;;WAEC;;WAEA;;WAEA;;WAEA;;UAED;;;WAGC,SAAS;;iBAEH,OAAO,OAAO,cAAc,QAAQ,OAAO,eAAe;;;;KAQtE;WACM;;WAEA;WACA;;KAEN;;;WAGM;WACA;;UAED;WACC;WACA;WACA,QAAQ;WACR;;WAEA,YAAY,OAAO;;iBAEb,QAAQ,OAAO,eAAe,QAAQ,aAAa;;;KAO/D;;;WAGM;WACA,oBAAoB;;WAEpB;WACA;;WAEA;WACA;;;;WAIA;WACA;;;;WAIA;WACA;WACA;WACA;;WAEA;;;;WAIA;WACA;;WAEA;;UAED;WACC;WACA;WACA;WACA;WACA,YAAY,OAAO;;;;;UAKpB;;WAEC,oBAAoB;;;EAG7B,QAAQ;;WAEC,QAAQ;;iBAEF,IAAI,OAAO,WAAW,QAAQ,OAAO,YAAY;;;UAcxD;WACC;WACA;;KAEN;;;WAGM;WACA;;;;;WAKA;WACA;;UAYD;WACC;WACA;;WAEA;;;WAGA;WACA;;WAEA,SAAS;WACT,YAAY,OAAO;;UAEpB;;WAEC;;;WAGA,mBAAmB;;WAEnB,OAAO,cAAc;;iBAEf,IAAI,OAAO,WAAW,QAAQ,OAAO,aAAa"}

package/dist/control.mjs

@@ -0,0 +1,70 @@
+import { a as executionDiagnostics, o as executorLoadFailure, t as notOk } from "./result-CY_TB7bn.mjs";
+//#region ../../0-framework/3-tooling/cli/dist/log-DfT2hHqi.mjs
+async function deploy(input) {
+	return deployWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's RunDeps, unit
+* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
+* internal types and is not part of the published surface. */
+async function deployWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-deploy-destroy-DfVJUICu-Dbgn1GR_.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("deploy", error, cwd));
+	}
+	return executor.executeDeploy(input, deps, cwd);
+}
+async function destroy(input) {
+	return destroyWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's RunDeps, unit
+* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
+* internal types and is not part of the published surface. */
+async function destroyWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-deploy-destroy-DfVJUICu-Dbgn1GR_.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("destroy", error, cwd));
+	}
+	return executor.executeDestroy(input, deps, cwd);
+}
+async function dev(input) {
+	return devWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's RunDeps, unit
+* tests). Deliberately NOT re-exported through `./control` — the seam mirrors
+* internal types and is not part of the published surface. */
+async function devWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-dev-BMTFWfFc-CGDFqR4w.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("dev", error, cwd));
+	}
+	return executor.executeDev(input, deps, cwd);
+}
+async function log(input) {
+	return logWithDeps(input, {});
+}
+/** In-package variant threading the injection seam (the CLI's LogRunDeps,
+* unit tests). Deliberately NOT re-exported through `./control` — the seam
+* mirrors internal types and is not part of the published surface. */
+async function logWithDeps(input, deps) {
+	const cwd = input.cwd ?? process.cwd();
+	let executor;
+	try {
+		executor = await import("./execute-log-Cay9hlKW-ChlIv192.mjs");
+	} catch (error) {
+		return notOk(executorLoadFailure("log", error, cwd));
+	}
+	return executor.executeLog(input, deps, cwd);
+}
+//#endregion
+export { deploy, destroy, dev, executionDiagnostics, log };
+
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":[],"sources":["../../../0-framework/3-tooling/cli/dist/log-DfT2hHqi.mjs"],"sourcesContent":["import { n as executorLoadFailure } from \"./shared-BTnATsqm.mjs\";\nimport { notOk } from \"@internal/foundation/result\";\n//#region src/operations/deploy.ts\nasync function deploy(input) {\n\treturn deployWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's RunDeps, unit\n* tests). Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function deployWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-deploy-destroy-DfVJUICu.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"deploy\", error, cwd));\n\t}\n\treturn executor.executeDeploy(input, deps, cwd);\n}\n//#endregion\n//#region src/operations/destroy.ts\nasync function destroy(input) {\n\treturn destroyWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's RunDeps, unit\n* tests). Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function destroyWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-deploy-destroy-DfVJUICu.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"destroy\", error, cwd));\n\t}\n\treturn executor.executeDestroy(input, deps, cwd);\n}\n//#endregion\n//#region src/operations/dev.ts\nasync function dev(input) {\n\treturn devWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's RunDeps, unit\n* tests). Deliberately NOT re-exported through `./control` — the seam mirrors\n* internal types and is not part of the published surface. */\nasync function devWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-dev-BMTFWfFc.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"dev\", error, cwd));\n\t}\n\treturn executor.executeDev(input, deps, cwd);\n}\n//#endregion\n//#region src/operations/log.ts\nasync function log(input) {\n\treturn logWithDeps(input, {});\n}\n/** In-package variant threading the injection seam (the CLI's LogRunDeps,\n* unit tests). Deliberately NOT re-exported through `./control` — the seam\n* mirrors internal types and is not part of the published surface. */\nasync function logWithDeps(input, deps) {\n\tconst cwd = input.cwd ?? process.cwd();\n\tlet executor;\n\ttry {\n\t\texecutor = await import(\"./execute-log-Cay9hlKW.mjs\");\n\t} catch (error) {\n\t\treturn notOk(executorLoadFailure(\"log\", error, cwd));\n\t}\n\treturn executor.executeLog(input, deps, cwd);\n}\n//#endregion\nexport { destroy as a, deployWithDeps as c, devWithDeps as i, logWithDeps as n, destroyWithDeps as o, dev as r, deploy as s, log as t };\n\n//# sourceMappingURL=log-DfT2hHqi.mjs.map"],"mappings":";;AAGA,eAAe,OAAO,OAAO;CAC5B,OAAO,eAAe,OAAO,CAAC,CAAC;AAChC;;;;AAIA,eAAe,eAAe,OAAO,MAAM;CAC1C,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,UAAU,OAAO,GAAG,CAAC;CACvD;CACA,OAAO,SAAS,cAAc,OAAO,MAAM,GAAG;AAC/C;AAGA,eAAe,QAAQ,OAAO;CAC7B,OAAO,gBAAgB,OAAO,CAAC,CAAC;AACjC;;;;AAIA,eAAe,gBAAgB,OAAO,MAAM;CAC3C,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,WAAW,OAAO,GAAG,CAAC;CACxD;CACA,OAAO,SAAS,eAAe,OAAO,MAAM,GAAG;AAChD;AAGA,eAAe,IAAI,OAAO;CACzB,OAAO,YAAY,OAAO,CAAC,CAAC;AAC7B;;;;AAIA,eAAe,YAAY,OAAO,MAAM;CACvC,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,OAAO,OAAO,GAAG,CAAC;CACpD;CACA,OAAO,SAAS,WAAW,OAAO,MAAM,GAAG;AAC5C;AAGA,eAAe,IAAI,OAAO;CACzB,OAAO,YAAY,OAAO,CAAC,CAAC;AAC7B;;;;AAIA,eAAe,YAAY,OAAO,MAAM;CACvC,MAAM,MAAM,MAAM,OAAO,QAAQ,IAAI;CACrC,IAAI;CACJ,IAAI;EACH,WAAW,MAAM,OAAO;CACzB,SAAS,OAAO;EACf,OAAO,MAAM,oBAAoB,OAAO,OAAO,GAAG,CAAC;CACpD;CACA,OAAO,SAAS,WAAW,OAAO,MAAM,GAAG;AAC5C"}

package/dist/deploy-BeBRB-6m.d.mts

@@ -0,0 +1 @@
+import "./app-config-aIrriqVU-Dpj1RqnY.mjs";

package/dist/deploy.d.mts

@@ -1,3 +1,3 @@
-import { A as ProvisionerDescriptor, B as joinDeployment, C as Lowering, E as PackageInput, H as lowering, P as buildConfig, S as LoweredResult, T as Outputs, U as mergedProviders, V as lower, W as resolveStateLayer, a as Bundle, b as LowerError, d as DeploymentResult, i as AssembleInput, j as ServiceLowering, k as ProvisionEdge, l as DeployedEntity, n as ApplicationDescriptor, r as Artifact, t as AlchemyStateLayer, u as DeployedNode, x as LowerOptions, y as LowerContext } from "./app-config-Cbv_lA38-BHJsd1DF.mjs";
-import "./deploy-whuqZ5xT.mjs";
+import { A as ProvisionEdge, C as LoweredResult, D as PackageInput, E as Outputs, F as buildConfig, G as resolveStateLayer, H as lower, M as ServiceLowering, S as LowerOptions, U as lowering, V as joinDeployment, W as mergedProviders, a as Bundle, b as LowerContext, d as DeployedNode, f as DeploymentResult, i as AssembleInput, j as ProvisionerDescriptor, n as ApplicationDescriptor, r as Artifact, t as AlchemyStateLayer, u as DeployedEntity, w as Lowering, x as LowerError } from "./app-config-aIrriqVU-Dpj1RqnY.mjs";
+import "./deploy-BeBRB-6m.mjs";
 export { AlchemyStateLayer, ApplicationDescriptor, Artifact, AssembleInput, Bundle, DeployedEntity, DeployedNode, DeploymentResult, LowerContext, LowerError, LowerOptions, LoweredResult, Lowering, Outputs, PackageInput, ProvisionEdge, ProvisionerDescriptor, ServiceLowering, buildConfig, joinDeployment, lower, lowering, mergedProviders, resolveStateLayer };