@hype-stack/cli 1.0.0 → 1.0.1

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmDpC,wBAAgB,aAAa,IAAI,OAAO,CAoJvC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0EpC,wBAAgB,aAAa,IAAI,OAAO,CAuLvC"}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,26 @@
+import { resolveAssignment } from '../deploy/assign.js';
+import { DeployOptions, DeployTarget, ManagedService } from '../deploy/types.js';
+/**
+ * Deploy the whole stack: the two frontends, the backend, and the Postgres,
+ * Valkey, and object storage they run on.
+ *
+ * Every provider assignment is saved to the `deploy` block of `stack.json` on
+ * the way out, so the second run is `hype-stack deploy` with no flags and lands
+ * on exactly the same infrastructure.
+ */
+export declare function deployCommand(options?: DeployOptions): Promise<void>;
+export interface PromptGapsInput {
+    assignment: ReturnType<typeof resolveAssignment>;
+    availableTargets: DeployTarget[];
+    requestedTargets: DeployTarget[];
+}
+/**
+ * What the flags and the saved config left open, which is exactly what has to
+ * be asked about. Services only count when a backend is part of the run: a
+ * frontend-only deploy has nothing that would talk to a database.
+ */
+export declare function pendingAssignments(input: PromptGapsInput): {
+    targets: DeployTarget[];
+    services: ManagedService[];
+};
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAOA,OAAO,EAAgB,iBAAiB,EAAqC,MAAM,qBAAqB,CAAC;AA4BzG,OAAO,KAAK,EAEV,aAAa,EAEb,YAAY,EACZ,cAAc,EAGf,MAAM,oBAAoB,CAAC;AAM5B;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmJ9E;AA2BD,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IACjD,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,gBAAgB,EAAE,YAAY,EAAE,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,GAAG;IAC1D,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B,CAUA"}

package/dist/config/bin.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
-import { l as e, n as t, t as n, u as r } from "../cli-DtlLnANf.js";
+import { d as e, n as t, t as n, u as r } from "../cli-C8n6X5xr.js";
 import { z as i } from "zod";
 import * as a from "@sentry/node";
 //#region src/core/sentry.ts
 var o = 2e3;
-function s({ command: e, dsn: t }) {
-	if (!t) return !1;
+function s({ command: t, dsn: n }) {
+	if (!n) return !1;
 	try {
 		return a.init({
-			dsn: t,
-			release: `@hype-stack/cli@${r}`,
+			dsn: n,
+			release: `@hype-stack/cli@${e}`,
 			sendDefaultPii: !1,
 			initialScope: { tags: {
-				command: e,
+				command: t,
 				node: process.version,
 				platform: process.platform
 			} }
@@ -51,7 +51,7 @@ var l = i.object({
 	"onboard",
 	"template"
 ], f = process.argv[2], p = f && d.includes(f) ? f : "root";
-f === "mcp" && process.argv[3] !== "install" && (e("mcp"), t());
+f === "mcp" && process.argv[3] !== "install" && (r("mcp"), t());
 var m = s({
 	command: p,
 	dsn: process.env.CLI_SENTRY_DSN

package/dist/deploy/assets.d.ts

@@ -0,0 +1,73 @@
+import { PlannedTarget } from './types.js';
+/** Where generated deploy files land, relative to the project root. */
+export declare const DEPLOY_ASSETS_DIR = ".hype-stack/deploy";
+/**
+ * Port the generated static image listens on. Fixed rather than read from
+ * `$PORT` so the nginx config needs no templating, which keeps `try_files
+ * $uri` from being eaten by the base image's envsubst step. Both providers are
+ * told this number explicitly.
+ */
+export declare const STATIC_PORT = 8080;
+export declare function assetsDir(projectRoot: string): string;
+export interface FlyTomlInput {
+    app: string;
+    region?: string;
+    internalPort: number;
+    /** Static targets run one always-on machine; a suspended SPA host is pointless latency. */
+    minMachines?: number;
+    /**
+     * Command to run in a temporary machine built from the new image, before any
+     * traffic moves to it. This is where migrations belong: Fly aborts the whole
+     * deploy if it exits non-zero, so a release never goes out against a database
+     * it cannot run on.
+     */
+    releaseCommand?: string;
+}
+export declare function renderFlyToml(input: FlyTomlInput): string;
+export interface WriteFlyTomlInput {
+    projectRoot: string;
+    target: PlannedTarget;
+    internalPort: number;
+    releaseCommand?: string;
+}
+export declare function writeFlyToml(input: WriteFlyTomlInput): Promise<string>;
+/**
+ * nginx config for a single-page app: every unknown path falls back to
+ * `index.html` so client-side routing survives a hard refresh.
+ */
+export declare function renderStaticNginxConf(port: number): string;
+export interface StaticDockerfileInput {
+    /** Build output directory, relative to the project root. */
+    contentDir: string;
+    /** nginx config path, relative to the project root. */
+    configPath: string;
+    port: number;
+}
+/**
+ * Image for a prebuilt SPA. The bundle is built on the machine running the
+ * deploy (so the `VITE_*` values are the resolved production ones) and this
+ * image only has to serve it, which keeps the remote build to a single COPY.
+ */
+export declare function renderStaticDockerfile(input: StaticDockerfileInput): string;
+export interface StaticImageAssets {
+    /** Dockerfile path relative to the project root. */
+    dockerfile: string;
+    /** nginx config path relative to the project root. */
+    nginxConf: string;
+    port: number;
+}
+/**
+ * Write the Dockerfile and nginx config that turn a built SPA into a container,
+ * for the providers that host containers rather than static assets.
+ */
+export declare function writeStaticImageAssets(projectRoot: string, target: PlannedTarget, contentDir: string): Promise<StaticImageAssets>;
+/**
+ * Locate the Dockerfile a container target builds from, relative to the project
+ * root. Returns null when the app ships none, which is what turns into the
+ * "add a Dockerfile" error instead of a confusing remote build failure.
+ */
+export declare function findTargetDockerfile(projectRoot: string, target: PlannedTarget): Promise<string | null>;
+export declare function toPosixRelative(from: string, to: string): string;
+/** Keep generated deploy files out of git; they are reproducible from `stack.json`. */
+export declare function ensureAssetsGitignored(projectRoot: string): Promise<void>;
+//# sourceMappingURL=assets.d.ts.map

package/dist/deploy/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/deploy/assets.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,uEAAuE;AACvE,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAErD;AAUD,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,2FAA2F;IAC3F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAsBzD;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAsB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ5E;AAGD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAED,MAAM,WAAW,qBAAqB;IACpC,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAa3E;AAED,MAAM,WAAW,iBAAiB;IAChC,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,iBAAiB,CAAC,CAS5B;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAI7G;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,uFAAuF;AACvF,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAc/E"}

package/dist/deploy/assign.d.ts

@@ -0,0 +1,58 @@
+import { ServeModes } from './detect.js';
+import { DeployConfig, DeployResource, DeployTarget, ManagedService, ProviderId } from './types.js';
+export type AssignmentIssueCode = "unassigned" | "missing-target" | "unsupported-serve-mode";
+export interface AssignmentIssue {
+    resource: DeployResource;
+    provider?: ProviderId;
+    code: AssignmentIssueCode;
+    message: string;
+    /** How to get past it, phrased as something the user can paste. */
+    fix?: string;
+}
+export interface Assignment {
+    targets: Partial<Record<DeployTarget, ProviderId>>;
+    services: Partial<Record<ManagedService, ProviderId>>;
+}
+export interface ResolveAssignmentInput {
+    config: DeployConfig;
+    /** Provider for anything without a more specific assignment. Beats the saved `defaultProvider`. */
+    defaultProvider?: ProviderId;
+    /** Per-resource `--backend fly` style overrides. Beat everything else. */
+    overrides?: Partial<Record<DeployResource, ProviderId>>;
+    /** Targets that actually exist in the project, from `stack.json` -> `apps`. */
+    availableTargets: DeployTarget[];
+    /** Restrict this run to a subset of targets. Empty or omitted means all available. */
+    only?: DeployTarget[];
+}
+/**
+ * Work out which provider owns each target and service.
+ *
+ * Precedence, highest first: an explicit `--<resource> <provider>` override, the
+ * saved `stack.json` entry, the `--provider` default for this run, then the
+ * saved `defaultProvider`. Anything still unresolved comes back absent, and
+ * {@link validateAssignment} turns that into an `unassigned` issue rather than
+ * guessing a provider that would bill the user.
+ */
+export declare function resolveAssignment(input: ResolveAssignmentInput): Assignment;
+/**
+ * Narrow the targets to deploy: the intersection of what the project has and
+ * what `--only` asked for, in catalog order so the summary is always stable.
+ */
+export declare function selectTargets(availableTargets: DeployTarget[], only?: DeployTarget[]): DeployTarget[];
+export interface ValidateAssignmentInput {
+    assignment: Assignment;
+    availableTargets: DeployTarget[];
+    /** Targets the user explicitly asked for, so a typo is reported rather than ignored. */
+    requestedTargets?: DeployTarget[];
+    /** Serve mode per app, from detection. A null entry means it cannot ship at all. */
+    serveModes?: ServeModes;
+}
+/**
+ * Check every assignment against the provider capability matrix. Returns the
+ * full list of problems rather than the first one, so a bad plan is fixed in a
+ * single pass instead of one error per run.
+ */
+export declare function validateAssignment(input: ValidateAssignmentInput): AssignmentIssue[];
+/** Format issues into one block for a note/error, newest-friendly for a terminal. */
+export declare function formatIssues(issues: AssignmentIssue[]): string;
+//# sourceMappingURL=assign.d.ts.map

package/dist/deploy/assign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assign.d.ts","sourceRoot":"","sources":["../../src/deploy/assign.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEzG,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,gBAAgB,GAAG,wBAAwB,CAAC;AAE7F,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC;IACnD,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,YAAY,CAAC;IACrB,mGAAmG;IACnG,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC,CAAC;IACxD,+EAA+E;IAC/E,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,sFAAsF;IACtF,IAAI,CAAC,EAAE,YAAY,EAAE,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,UAAU,CAkB3E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,YAAY,EAAE,EAAE,IAAI,CAAC,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAIrG;AAED,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,YAAY,EAAE,CAAC;IACjC,wFAAwF;IACxF,gBAAgB,CAAC,EAAE,YAAY,EAAE,CAAC;IAClC,oFAAoF;IACpF,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,eAAe,EAAE,CAsDpF;AAaD,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,CAO9D"}

package/dist/deploy/build.d.ts

@@ -0,0 +1,29 @@
+import { ProviderContext } from './providers/types.js';
+import { PlannedTarget } from './types.js';
+/**
+ * Pick the package script that produces the deployable artifact. Returns null
+ * when the app declares none, which the caller turns into an actionable error
+ * rather than deploying an empty directory.
+ */
+export declare function resolveBuildScript(root: string): Promise<string | null>;
+export interface BuildResult {
+    /** Script that ran, or null when the target needed no local build. */
+    script: string | null;
+    /** Build output directory relative to the project root, for static targets. */
+    outputDir?: string;
+}
+export interface BuildTargetInput {
+    target: PlannedTarget;
+    /** Env for the build, which is where `VITE_*` values get baked into the bundle. */
+    env: Record<string, string>;
+    secrets: string[];
+}
+/**
+ * Build a static target locally.
+ *
+ * Vite inlines `VITE_*` at build time, so the bundle has to be produced with the
+ * production API origin already resolved. Building here (rather than on the
+ * provider) is also what lets a static host receive a plain folder of files.
+ */
+export declare function buildStaticTarget(ctx: ProviderContext, input: BuildTargetInput): Promise<BuildResult>;
+//# sourceMappingURL=build.d.ts.map

package/dist/deploy/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/deploy/build.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAchD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAI7E;AAED,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,aAAa,CAAC;IACtB,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC,CAgC3G"}

package/dist/deploy/catalog.d.ts

@@ -0,0 +1,60 @@
+import { DeployResource, DeployTarget, ManagedService, ProviderId, ProviderSpec, ServiceSpec, TargetSpec } from './types.js';
+/**
+ * Deploy settings live in the `deploy` block of `stack.json` rather than a file
+ * of their own. A project without `stack.json` is not a Hype Stack project, so
+ * there is nothing to deploy and nowhere sensible to record what was created.
+ */
+export declare const DEPLOY_CONFIG_FILE = "stack.json";
+/** Key inside `stack.json` that holds everything below. */
+export declare const DEPLOY_CONFIG_KEY = "deploy";
+/**
+ * Dotted path to a deploy setting, for error messages that tell the user
+ * exactly what to edit, e.g. `deploy.services.bucket.external`.
+ */
+export declare function settingPath(...segments: string[]): string;
+/**
+ * Schema version written into the `deploy` block. Tracked separately from
+ * `stack.json`'s own version so the two can evolve without forcing each other.
+ */
+export declare const DEPLOY_CONFIG_VERSION = 1;
+/** Environment name used when neither the flag nor the saved config picks one. */
+export declare const DEFAULT_ENVIRONMENT = "production";
+export declare const DEPLOY_TARGETS: DeployTarget[];
+export declare const MANAGED_SERVICES: ManagedService[];
+/**
+ * Providers the CLI will drive.
+ *
+ * The bar for being here is deploying the whole stack unattended: all three
+ * apps as containers, plus Postgres, Valkey, and an S3-compatible bucket, from
+ * one command with no dashboard visits in the middle. Static hosts do not
+ * qualify, however good they are at the static half. Cloudflare and Netlify
+ * cannot run the backend at all and have no managed Postgres, which would leave
+ * the user assembling the rest by hand.
+ */
+export declare const PROVIDER_IDS: ProviderId[];
+export declare const TARGET_SPECS: Record<DeployTarget, TargetSpec>;
+export declare const SERVICE_SPECS: Record<ManagedService, ServiceSpec>;
+export declare const PROVIDER_SPECS: Record<ProviderId, ProviderSpec>;
+export declare function isDeployTarget(value: string): value is DeployTarget;
+export declare function isManagedService(value: string): value is ManagedService;
+export declare function isProviderId(value: string): value is ProviderId;
+export declare function isDeployResource(value: string): value is DeployResource;
+/** Human label for a target or service, for prompts and the summary. */
+export declare function resourceLabel(resource: DeployResource): string;
+export declare function providerLabel(provider: ProviderId): string;
+/**
+ * Providers that can host `resource`.
+ *
+ * Every one of them can host all three apps and run all three services, which
+ * is the entry requirement, so this is the full list. It stays a function
+ * because the picker and the error messages read better asking the question
+ * than asserting the answer.
+ */
+export declare function providersForResource(_resource: DeployResource): ProviderId[];
+/**
+ * Default remote resource name. Provider namespaces are global-ish (Fly app
+ * names are unique per organization, Railway service names per project), so the
+ * project name is always the prefix to keep two projects from colliding.
+ */
+export declare function defaultResourceName(projectName: string, resource: DeployResource): string;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/deploy/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/deploy/catalog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,cAAc,EACd,UAAU,EACV,YAAY,EACZ,WAAW,EACX,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,eAAoB,CAAC;AAEpD,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB,WAAW,CAAC;AAE1C;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAEzD;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD,eAAO,MAAM,cAAc,EAAE,YAAY,EAAqC,CAAC;AAE/E,eAAO,MAAM,gBAAgB,EAAE,cAAc,EAAqC,CAAC;AAEnF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,UAAU,EAAuB,CAAC;AAE7D,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAgCzD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,cAAc,EAAE,WAAW,CAgB7D,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,UAAU,EAAE,YAAY,CAe3D,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,YAAY,CAEnE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,cAAc,CAEvE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAE/D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,cAAc,CAEvE;AAED,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAG9D;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAE1D;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,cAAc,GAAG,UAAU,EAAE,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAEzF"}

package/dist/deploy/config.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { DeployConfig } from './types.js';
+export declare const deployConfigSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    projectName: z.ZodString;
+    environment: z.ZodString;
+    defaultProvider: z.ZodOptional<z.ZodEnum<{
+        railway: "railway";
+        fly: "fly";
+    }>>;
+    targets: z.ZodDefault<z.ZodObject<{
+        backend: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                railway: "railway";
+                fly: "fly";
+            }>;
+            app: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        frontend: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                railway: "railway";
+                fly: "fly";
+            }>;
+            app: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        admin: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                railway: "railway";
+                fly: "fly";
+            }>;
+            app: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    services: z.ZodDefault<z.ZodObject<{
+        postgres: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                railway: "railway";
+                fly: "fly";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            external: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        valkey: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                railway: "railway";
+                fly: "fly";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            external: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        bucket: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                railway: "railway";
+                fly: "fly";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            external: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    fly: z.ZodOptional<z.ZodObject<{
+        org: z.ZodOptional<z.ZodString>;
+        postgresPlan: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    railway: z.ZodOptional<z.ZodObject<{
+        workspace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function hasDeployConfig(projectRoot: string): Promise<boolean>;
+/**
+ * Read the `deploy` block out of `stack.json`, returning null when the project
+ * has never been deployed. A block that exists but does not validate is a hard
+ * error rather than a fallback to defaults, for the reason above.
+ */
+export declare function loadDeployConfig(projectRoot: string): Promise<DeployConfig | null>;
+/**
+ * Write the `deploy` block back, leaving the rest of `stack.json` untouched.
+ *
+ * The file is re-read first rather than reusing the copy loaded at startup,
+ * because a deploy runs long enough for `compose` or an editor to have
+ * rewritten it in the meantime, and clobbering an installed pack log would be a
+ * far worse outcome than a stale provider name.
+ */
+export declare function saveDeployConfig(projectRoot: string, config: DeployConfig): Promise<void>;
+export declare function createDeployConfig(projectName: string, environment?: string): DeployConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/deploy/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/deploy/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA2B/C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB7B,CAAC;AA2BH,wBAAsB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG3E;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAkBxF;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAG/F;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,SAAsB,GAAG,YAAY,CAQvG"}

package/dist/deploy/detect.d.ts

@@ -0,0 +1,36 @@
+import { StackConfig } from '../types/types.js';
+import { DeployTarget, ServeMode } from './types.js';
+/** Absolute path to a target's app directory, honoring `stack.json` -> `paths`. */
+export declare function targetRoot(projectRoot: string, target: DeployTarget, config: StackConfig | null): string;
+/**
+ * Which of the three apps this project actually has. A template composed
+ * without the admin app should not be offered an admin deploy, and asking the
+ * filesystem is more reliable than trusting a `stack.json` that predates a
+ * removed app.
+ */
+export declare function detectAvailableTargets(projectRoot: string, config: StackConfig | null): Promise<DeployTarget[]>;
+/**
+ * How a target ships.
+ *
+ * A Dockerfile wins whenever there is one. It is the deployment the project's
+ * authors wrote and tested, and both providers build it as-is, so generating an
+ * image over the top would quietly drop their SSR server. Without one the CLI
+ * has to produce the image itself, which it can only do for a build that emits
+ * a folder of files.
+ *
+ * Returns null when neither is possible, which assignment validation turns into
+ * a reportable issue rather than a failure halfway through a remote build.
+ */
+export declare function detectServeMode(root: string, target: DeployTarget): Promise<ServeMode | null>;
+/** Serve mode per target. A null entry means the app cannot ship at all yet. */
+export type ServeModes = Partial<Record<DeployTarget, ServeMode | null>>;
+export declare function detectServeModes(projectRoot: string, targets: DeployTarget[], config: StackConfig | null): Promise<ServeModes>;
+/** Drop the targets that cannot ship, leaving what the plan can be built from. */
+export declare function deployableModes(modes: ServeModes): Partial<Record<DeployTarget, ServeMode>>;
+/**
+ * Find the directory a static build lands in. Vite's default is `dist`, but a
+ * TanStack Start build writes `.output/public`, so both are probed before
+ * falling back to the catalog default. Returns a path relative to the app root.
+ */
+export declare function detectStaticDir(root: string, target: DeployTarget): Promise<string>;
+//# sourceMappingURL=detect.d.ts.map

package/dist/deploy/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/deploy/detect.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAsB1D,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,CAKxG;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAUrH;AAUD;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAqBnG;AAED,gFAAgF;AAChF,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC;AAEzE,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,YAAY,EAAE,EACvB,MAAM,EAAE,WAAW,GAAG,IAAI,GACzB,OAAO,CAAC,UAAU,CAAC,CASrB;AAED,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,CAS3F;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAUzF"}

package/dist/deploy/dry-run.d.ts

@@ -0,0 +1,14 @@
+import { DryRunResponse } from './runner.js';
+/**
+ * Sample provider output for `deploy --dry-run`.
+ *
+ * A dry run executes nothing, so every command comes back empty, and an adapter
+ * that parses a connection string out of its output would stop the walk at the
+ * first service. These stand-ins keep the run going to the end, which is the
+ * whole point of a dry run: seeing every command, not just the first few.
+ *
+ * The values are obviously fake so nobody mistakes a dry run for a real one.
+ */
+export declare const DRY_RUN_PLACEHOLDER = "dry-run-placeholder";
+export declare const DRY_RUN_RESPONSES: DryRunResponse[];
+//# sourceMappingURL=dry-run.d.ts.map

package/dist/deploy/dry-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dry-run.d.ts","sourceRoot":"","sources":["../../src/deploy/dry-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,aAAa,CAAC;AAE/D;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,wBAAwB,CAAC;AAUzD,eAAO,MAAM,iBAAiB,EAAE,cAAc,EAwE7C,CAAC"}

package/dist/deploy/env-plan.d.ts

@@ -0,0 +1,67 @@
+import { DeployPlan, DeployTarget, ManagedService, ServiceOutputs, TargetEnvPlan, TargetUrls } from './types.js';
+export type { TargetEnvPlan } from './types.js';
+/**
+ * Env vars the deploy owns. A value the user left in a local `.env` never
+ * overrides one of these: the whole point is that the deployed apps point at
+ * the infrastructure this command just provisioned, not at localhost.
+ */
+export declare const MANAGED_KEYS: Record<DeployTarget, string[]>;
+export interface BuildEnvPlanInput {
+    plan: DeployPlan;
+    /** Connection values from each provisioned service. */
+    serviceOutputs: Partial<Record<ManagedService, ServiceOutputs>>;
+    /** Public origin for each target, resolved before any build runs. */
+    urls: TargetUrls;
+    /** Parsed local `.env` contents per target, used to carry third-party secrets over. */
+    localEnv?: Partial<Record<DeployTarget, Record<string, string>>>;
+    /** Keys each app declares in `.env.example`, used to decide what to forward and what is missing. */
+    declaredKeys?: Partial<Record<DeployTarget, string[]>>;
+    /**
+     * Keys a provider wired onto the app itself, out of band (Fly's `mpg attach`
+     * sets `DATABASE_URL` this way). Nothing local knows the value, but the app
+     * has it, so they are not reported as missing.
+     */
+    externallyProvided?: Partial<Record<DeployTarget, string[]>>;
+}
+export declare function buildEnvPlan(input: BuildEnvPlanInput): TargetEnvPlan[];
+export interface PreviewEnvPlanInput {
+    plan: DeployPlan;
+    localEnv?: Partial<Record<DeployTarget, Record<string, string>>>;
+    declaredKeys?: Partial<Record<DeployTarget, string[]>>;
+}
+/**
+ * The env plan as it will look once the run has settled every origin and
+ * connection string, for the summary shown before anything is created.
+ *
+ * Building that summary from empty inputs instead would report every value the
+ * deploy is about to set (`DATABASE_URL`, `VITE_API_BASE_URL`, and the rest) as
+ * unset, directly above the prompt asking whether to go ahead. The shape is
+ * known from the plan even though the values are not, so it is filled with
+ * stand-ins and run through the same code the real pass uses.
+ */
+export declare function previewEnvPlan(input: PreviewEnvPlanInput): TargetEnvPlan[];
+interface ManagedEnvInput {
+    target: DeployTarget;
+    environment: string;
+    port?: number;
+    serviceOutputs: Partial<Record<ManagedService, ServiceOutputs>>;
+    urls: TargetUrls;
+}
+/**
+ * Compute the deploy-owned env for one target. Keys whose source is not
+ * available yet are simply absent, so a frontend-only deploy does not stamp an
+ * empty `VITE_API_BASE_URL` over a working one.
+ */
+export declare function managedEnvFor(input: ManagedEnvInput): Record<string, string>;
+/** Every env var to apply to a target, managed values winning over forwarded ones. */
+export declare function mergedEnv(plan: TargetEnvPlan): Record<string, string>;
+/**
+ * Parse a `.env` file into a flat map. Handles the `export KEY=value` prefix and
+ * single or double quoted values, and drops comments and blank lines. Escapes
+ * are left alone: dotenv's own handling of them varies by implementation, and a
+ * value is only ever passed through verbatim from here.
+ */
+export declare function parseEnvContent(content: string): Record<string, string>;
+/** Keys declared in a `.env.example`, in file order and deduped. */
+export declare function declaredEnvKeys(exampleContent: string): string[];
+//# sourceMappingURL=env-plan.d.ts.map

package/dist/deploy/env-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-plan.d.ts","sourceRoot":"","sources":["../../src/deploy/env-plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,aAAa,EACb,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAkBvD,CAAC;AAmBF,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,UAAU,CAAC;IACjB,uDAAuD;IACvD,cAAc,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;IAChE,qEAAqE;IACrE,IAAI,EAAE,UAAU,CAAC;IACjB,uFAAuF;IACvF,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACjE,oGAAoG;IACpG,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IACvD;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;CAC9D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,aAAa,EAAE,CAwBtE;AAQD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACjE,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;CACxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,aAAa,EAAE,CAa1E;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;IAChE,IAAI,EAAE,UAAU,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoB5E;AAyDD,sFAAsF;AACtF,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAErE;AAYD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkBvE;AAcD,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhE"}

package/dist/deploy/migrations.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Work out the command that applies pending migrations inside the deployed
+ * backend container.
+ *
+ * The template ships a `migration:latest` script, so that is used when present:
+ * it already knows where the schema lives and which Prisma config to load.
+ * Otherwise fall back to invoking Prisma directly against the schema, which
+ * works for a stock layout.
+ */
+export declare function resolveMigrationCommand(backendRoot: string, projectRoot: string): Promise<string[]>;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/deploy/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../src/deploy/migrations.ts"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAUzG"}

package/dist/deploy/orchestrate.d.ts

@@ -0,0 +1,31 @@
+import { DeployProviderAdapter } from './providers/types.js';
+import { CommandRunner } from './runner.js';
+import { DeployOutcome, DeployPlan, DeployTarget, ManagedService, ProviderId, ServiceOutputs } from './types.js';
+export interface RunDeployInput {
+    plan: DeployPlan;
+    runner: CommandRunner;
+    /** Swap in fakes for tests. Defaults to the real provider adapters. */
+    adapters?: Partial<Record<ProviderId, DeployProviderAdapter>>;
+    /** Parsed local `.env` per target, so third-party keys carry over. */
+    localEnv?: Partial<Record<DeployTarget, Record<string, string>>>;
+    /** Keys each app declares in `.env.example`. */
+    declaredKeys?: Partial<Record<DeployTarget, string[]>>;
+    /** Assume services already exist; reuse the values in `knownServiceOutputs`. */
+    skipProvision?: boolean;
+    knownServiceOutputs?: Partial<Record<ManagedService, ServiceOutputs>>;
+    skipMigrations?: boolean;
+    /** Skip the provider auth probe. Used by `--dry-run`, where no command really runs. */
+    skipAuthCheck?: boolean;
+    log?: (message: string) => void;
+}
+/**
+ * Walk the plan.
+ *
+ * The order is forced by a dependency cycle in the env: the two frontends inline
+ * the backend's origin at build time, and the backend needs their origins for
+ * CORS. It is broken by settling every public URL in a reserve pass before
+ * anything is built, so by the time env vars are computed all of them are known.
+ */
+export declare function runDeploy(input: RunDeployInput): Promise<DeployOutcome>;
+export declare function involvedProviders(plan: DeployPlan): ProviderId[];
+//# sourceMappingURL=orchestrate.d.ts.map

package/dist/deploy/orchestrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrate.d.ts","sourceRoot":"","sources":["../../src/deploy/orchestrate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAmB,MAAM,sBAAsB,CAAC;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EAEV,YAAY,EACZ,cAAc,EAEd,UAAU,EACV,cAAc,EAGf,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAC,CAAC;IAC9D,sEAAsE;IACtE,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACjE,gDAAgD;IAChD,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IACvD,gFAAgF;IAChF,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;IACtE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,uFAAuF;IACvF,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CA+J7E;AAmDD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,CAOhE"}

package/dist/deploy/plan.d.ts

@@ -0,0 +1,23 @@
+import { StackConfig } from '../types/types.js';
+import { Assignment } from './assign.js';
+import { DeployConfig, DeployPlan, DeployTarget, ServeMode } from './types.js';
+export interface BuildPlanInput {
+    projectRoot: string;
+    config: DeployConfig;
+    assignment: Assignment;
+    stackConfig: StackConfig | null;
+    /** Detected serve mode per target, overriding the catalog default. */
+    serveModes?: Partial<Record<DeployTarget, ServeMode>>;
+    /** Detected static output directory per target, relative to the app root. */
+    staticDirs?: Partial<Record<DeployTarget, string>>;
+}
+/**
+ * Turn an assignment plus the saved config into a plan where nothing is left
+ * implicit: every app name, region, and root path is resolved here so the
+ * provider adapters never have to invent one, and so the summary the user
+ * confirms is exactly what runs.
+ */
+export declare function buildPlan(input: BuildPlanInput): DeployPlan;
+/** Fold the resolved plan back into the config so the next run reuses the same names. */
+export declare function applyPlanToConfig(config: DeployConfig, plan: DeployPlan): DeployConfig;
+//# sourceMappingURL=plan.d.ts.map

package/dist/deploy/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/deploy/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EAGZ,SAAS,EAEV,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,sEAAsE;IACtE,UAAU,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,CAAC;IACtD,6EAA6E;IAC7E,UAAU,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;CACpD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CAmD3D;AAkBD,yFAAyF;AACzF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,YAAY,CAoCtF"}