@hype-stack/cli 1.0.0 → 1.1.0

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/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAc,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAWnE,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA0W3E"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAc,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAWnE,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAwW3E"}

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;AA6BzG,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,CA2J9E;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/commands/template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/commands/template.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAIV,sBAAsB,EAGvB,MAAM,mBAAmB,CAAC;AAsB3B;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,IAAI,CAAC,CAkXzF"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/commands/template.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAIV,sBAAsB,EAGvB,MAAM,mBAAmB,CAAC;AAsB3B;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,OAAO,CAAC,IAAI,CAAC,CAgXzF"}

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-DdPVabIO.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/core/onboard-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onboard-catalog.d.ts","sourceRoot":"","sources":["../../src/core/onboard-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAUsB,CAAC;AAEhD,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAUzD,CAAC;AAIF,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED,yFAAyF;AACzF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAGzE;AA4CD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAGnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,UAAU,EAAE,GAAG,OAAO,CAIjG;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE;IAAE,UAAU,EAAE;QAAE,OAAO,EAAE,UAAU,CAAA;KAAE,CAAA;CAAE,EAAE,GAAG,SAAS,GACzD,UAAU,EAAE,CAWd;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAStE;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAY7C,CAAC;AAEF,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAalE"}
+{"version":3,"file":"onboard-catalog.d.ts","sourceRoot":"","sources":["../../src/core/onboard-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAUsB,CAAC;AAEhD,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAUzD,CAAC;AAIF,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKxD;AAED,yFAAyF;AACzF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAGzE;AA4CD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAGnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,UAAU,EAAE,GAAG,OAAO,CAIjG;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE;IAAE,UAAU,EAAE;QAAE,OAAO,EAAE,UAAU,CAAA;KAAE,CAAA;CAAE,EAAE,GAAG,SAAS,GACzD,UAAU,EAAE,CAWd;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAStE;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAc7C,CAAC;AAEF,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAalE"}

package/dist/deploy/assets.d.ts

@@ -0,0 +1,114 @@
+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;
+/**
+ * Seconds a provider waits for the healthcheck to pass before calling the
+ * release failed. Long enough for a cold Node process and a Prisma pool, short
+ * enough that a crash loop is reported rather than waited out.
+ */
+export declare const HEALTHCHECK_TIMEOUT_SECONDS = 30;
+/**
+ * Railway reads build and deploy settings from a `railway.json` at the root of
+ * what it is given, and everything else about a service can only be set from
+ * the dashboard. That file is the only way the CLI can ask for a healthcheck or
+ * a pre-deploy migration.
+ *
+ * It is per-project, not per-service, which is normally the end of the idea in
+ * a monorepo. It works here because each `railway up` uploads its own snapshot
+ * of the directory: write the settings for the target about to be pushed, push
+ * it, and the next target overwrites them.
+ */
+export declare const RAILWAY_CONFIG_FILE = "railway.json";
+export interface RailwayConfigInput {
+    /** Dockerfile the service builds from, relative to the project root. */
+    dockerfilePath: string;
+    healthcheckPath: string;
+    /**
+     * Commands run in the new image before it takes traffic. Migrations belong
+     * here: Railway fails the deployment if one exits non-zero, so a release
+     * never goes out against a schema it cannot run on.
+     */
+    preDeployCommand?: string[];
+}
+export declare function renderRailwayConfig(input: RailwayConfigInput): string;
+/**
+ * Is there a `railway.json` or `railway.toml` the user wrote themselves? Their
+ * config wins outright: overwriting it would silently undo whatever they
+ * configured, and merging into it would mean guessing which half they meant.
+ */
+export declare function hasOwnRailwayConfig(projectRoot: string): Promise<boolean>;
+export declare function writeRailwayConfig(projectRoot: string, input: RailwayConfigInput): Promise<void>;
+/** Clear the generated config once the upload that needed it is done. */
+export declare function removeRailwayConfig(projectRoot: string): Promise<void>;
+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;
+    /** Path Fly polls before the new machines take traffic. */
+    healthcheckPath?: 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":"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"}

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/auth.d.ts

@@ -0,0 +1,52 @@
+import { DeployProviderAdapter } from './providers/types.js';
+import { CommandRunner } from './runner.js';
+import { DeployPlan, ProviderId, ProviderSpec } from './types.js';
+/**
+ * Sign in to every provider the plan touches, before the deploy is confirmed.
+ *
+ * A deploy that starts unauthenticated fails on its first command, several
+ * screens after the point where the user could have done something about it.
+ * So the login is settled here instead: while nothing has been created, while
+ * the question is still "do you want to do this", and while there is somebody
+ * at the keyboard to answer it.
+ *
+ * Nothing about it is optional. There is no path through this module that
+ * returns without a working login, which is the whole point.
+ */
+/** Extra environment for every deploy command. A key set to `undefined` is unset. */
+export type AuthEnv = Record<string, string | undefined>;
+export interface ProviderAuthOutcome {
+    /** Tokens the user supplied, to be layered onto every command in the run. */
+    env: AuthEnv;
+    /** Who each provider says we are. Saves the run a second round of probes. */
+    accounts: Partial<Record<ProviderId, string>>;
+}
+/** How the user wants to sign in. */
+export type SignInMethod = "browser" | "browserless" | "token";
+/**
+ * Everything the gate needs from outside itself: a shell, a terminal, and a
+ * person. Swapped out wholesale in tests, which is the only way to exercise a
+ * flow built out of prompts and other people's binaries.
+ */
+export interface AuthIO {
+    /** A runner carrying `env`, for the `--version` and `whoami` probes. */
+    createRunner(env: AuthEnv): CommandRunner;
+    /** Run a command with the terminal attached. Browser logins need a real TTY. */
+    runInteractive(command: string, args: string[], cwd: string): Promise<number>;
+    confirmInstall(spec: ProviderSpec): Promise<boolean>;
+    chooseMethod(spec: ProviderSpec): Promise<SignInMethod>;
+    readToken(spec: ProviderSpec): Promise<string>;
+}
+export declare function createAuthIO(): AuthIO;
+export interface EnsureProviderAuthInput {
+    plan: DeployPlan;
+    providers: ProviderId[];
+    /** Nobody to ask: `--yes`, or a headless run driven by an agent. */
+    skipPrompts: boolean;
+    io?: AuthIO;
+    /** Swap in fakes for tests. Defaults to the real provider adapters. */
+    adapters?: Partial<Record<ProviderId, DeployProviderAdapter>>;
+}
+export declare function ensureProviderAuth(input: EnsureProviderAuthInput): Promise<ProviderAuthOutcome>;
+export declare function unattendedFix(spec: ProviderSpec): string;
+//# sourceMappingURL=auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/deploy/auth.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,qBAAqB,EAAmB,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEvE;;;;;;;;;;;GAWG;AAEH,qFAAqF;AACrF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAEzD,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,GAAG,EAAE,OAAO,CAAC;IACb,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;CAC/C;AAED,qCAAqC;AACrC,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,aAAa,GAAG,OAAO,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACrB,wEAAwE;IACxE,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CAAC;IAC1C,gFAAgF;IAChF,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9E,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrD,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACxD,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAChD;AAED,wBAAgB,YAAY,IAAI,MAAM,CAQrC;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,oEAAoE;IACpE,WAAW,EAAE,OAAO,CAAC;IACrB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAC,CAAC;CAC/D;AAED,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAoBrG;AA6HD,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAGxD"}

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,CAoCzD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,cAAc,EAAE,WAAW,CAgB7D,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,UAAU,EAAE,YAAY,CA0B3D,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,CAoBxF;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"}