@hype-stack/cli 0.9.0 → 1.0.1

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"}

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

@@ -0,0 +1,17 @@
+import { DeployTarget, PlannedTarget } from './types.js';
+export interface ProjectEnv {
+    /** Values found in the project's `.env` files, per target. */
+    local: Partial<Record<DeployTarget, Record<string, string>>>;
+    /** Keys each app declares in its `.env.example`, per target. */
+    declared: Partial<Record<DeployTarget, string[]>>;
+}
+/**
+ * Collect what the project already knows about its own configuration.
+ *
+ * `.env.example` is the contract: it lists everything an app needs, which is
+ * what makes it safe to forward matching values from `.env` and to report the
+ * rest as unset. A root `.env` is treated as shared defaults that the app's own
+ * file overrides.
+ */
+export declare function readProjectEnv(projectRoot: string, targets: PlannedTarget[]): Promise<ProjectEnv>;
+//# sourceMappingURL=project-env.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-env.d.ts","sourceRoot":"","sources":["../../src/deploy/project-env.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE9D,MAAM,WAAW,UAAU;IACzB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAC7D,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;CACnD;AAOD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CA2BvG"}

package/dist/deploy/providers/fly.d.ts

@@ -0,0 +1,56 @@
+import { ServiceOutputs } from '../types.js';
+import { DeployProviderAdapter } from './types.js';
+/**
+ * Region used when the plan does not pin one. Fly opens a region picker when
+ * `mpg create` and `redis create` are called without `--region`, which would
+ * hang a deploy that nobody is watching, so there has to be a fallback.
+ */
+export declare const DEFAULT_FLY_REGION = "iad";
+/** Fly prompts for a Managed Postgres plan the same way it prompts for a region. */
+export declare const DEFAULT_POSTGRES_PLAN = "basic";
+export declare function flyAppUrl(app: string): string;
+/**
+ * Read the organization slugs out of `fly orgs list --json`. Newer flyctl
+ * prints an array of objects; older versions print a `{ "Name": "slug" }` map.
+ */
+export declare function parseOrgSlugs(output: string): string[];
+/**
+ * Parse the `Key: value` block Fly prints after provisioning. `fly storage
+ * create` and `fly redis status` both use this shape, and it is the only way to
+ * get at credentials Fly will not show again.
+ */
+export declare function parseFlyKeyValues(output: string): Record<string, string>;
+/** Pull the first `redis://` or `rediss://` URL out of any Fly output. */
+export declare function parseRedisUrl(output: string): string | null;
+/** Pull the first `postgres://` or `postgresql://` URL out of any Fly output. */
+export declare function parsePostgresUrl(output: string): string | null;
+interface MpgCluster {
+    id: string;
+    name: string;
+}
+/**
+ * Find a Managed Postgres cluster in `fly mpg list --json` output.
+ *
+ * Every other `mpg` subcommand takes a cluster id, not a name, and Fly happily
+ * creates a second cluster with a name it already has. Looking the name up
+ * first is what makes a repeated deploy reuse the database instead of doubling
+ * it.
+ */
+export declare function findClusterInList(output: string, name: string): MpgCluster | null;
+/**
+ * Read the connection string out of `fly mpg status --json`. The uri lives
+ * under `credentials`, separate from the cluster fields under `data`, and the
+ * v1 and v2 APIs disagree on its key.
+ */
+export declare function parseMpgCredentials(output: string): string | null;
+export declare const flyProvider: DeployProviderAdapter;
+/**
+ * Names of the secrets already set on an app. Fly never returns the values, but
+ * the names are enough to tell a re-deploy apart from a bucket that was created
+ * outside this command.
+ */
+export declare function parseSecretNames(output: string): string[];
+/** Map Tigris's AWS-shaped output onto the env names the backend's S3 client reads. */
+export declare function tigrisOutputs(values: Record<string, string>, bucketName: string): ServiceOutputs | null;
+export {};
+//# sourceMappingURL=fly.d.ts.map

package/dist/deploy/providers/fly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fly.d.ts","sourceRoot":"","sources":["../../../src/deploy/providers/fly.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAEV,qBAAqB,EAMtB,MAAM,YAAY,CAAC;AAKpB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC,oFAAoF;AACpF,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAE7C,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBtD;AA6CD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxE;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG3D;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG9D;AAED,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAajF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAcjE;AAED,eAAO,MAAM,WAAW,EAAE,qBA+IzB,CAAC;AAgOF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAUzD;AAiBD,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAWvG"}

package/dist/deploy/providers/index.d.ts

@@ -0,0 +1,9 @@
+import { ProviderId } from '../types.js';
+import { flyProvider } from './fly.js';
+import { railwayProvider } from './railway.js';
+import { DeployProviderAdapter } from './types.js';
+export declare const PROVIDER_ADAPTERS: Record<ProviderId, DeployProviderAdapter>;
+export declare function getProviderAdapter(id: ProviderId): DeployProviderAdapter;
+export { flyProvider, railwayProvider };
+export type { AuthStatus, DeployProviderAdapter, DeployTargetInput, DeployTargetResult, ProviderContext, ProvisionInput, ProvisionResult, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/deploy/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deploy/providers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,UAAU,EAAE,qBAAqB,CAGvE,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,UAAU,GAAG,qBAAqB,CAExE;AAED,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,CAAC;AACxC,YAAY,EACV,UAAU,EACV,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC"}

package/dist/deploy/providers/railway.d.ts

@@ -0,0 +1,29 @@
+import { DeployProviderAdapter } from './types.js';
+/** Service names Railway assigns to the databases it provisions. */
+export declare const RAILWAY_POSTGRES_SERVICE = "Postgres";
+export declare const RAILWAY_REDIS_SERVICE = "Redis";
+/**
+ * Pull a Railway-generated hostname out of a command's output. `--json` shapes
+ * have shifted across CLI releases, so the JSON is searched for any `domain`
+ * key first and the raw text is scanned as a fallback.
+ */
+export declare function parseRailwayDomain(output: string): string | null;
+export interface RailwayService {
+    id: string;
+    name: string;
+}
+/**
+ * Parse `railway service list --json`.
+ *
+ * Railway does not enforce unique service names, so `railway add` on a name
+ * that is already taken creates a second service rather than failing. Listing
+ * first is the only way a re-run lands on the same infrastructure. Railway's
+ * own CLI help says as much: "prefer service IDs ... when names may collide".
+ */
+export declare function parseRailwayServices(output: string): RailwayService[];
+/** Parse `railway variable list --kv` output into a map. */
+export declare function parseRailwayVariables(output: string): Record<string, string>;
+export declare const railwayProvider: DeployProviderAdapter;
+/** Workspace names from `railway whoami --json`. */
+export declare function parseRailwayWorkspaces(output: string): string[];
+//# sourceMappingURL=railway.d.ts.map

package/dist/deploy/providers/railway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"railway.d.ts","sourceRoot":"","sources":["../../../src/deploy/providers/railway.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,qBAAqB,EAMtB,MAAM,YAAY,CAAC;AAEpB,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,aAAa,CAAC;AACnD,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAQ7C;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWhE;AA+BD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE,CAcrE;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAoB5E;AAED,eAAO,MAAM,eAAe,EAAE,qBAwK7B,CAAC;AAqCF,oDAAoD;AACpD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAa/D"}

package/dist/deploy/providers/types.d.ts

@@ -0,0 +1,92 @@
+import { CommandRunner } from '../runner.js';
+import { DeployPlan, DeployTarget, PlannedService, PlannedTarget, ProviderId, ServiceOutputs } from '../types.js';
+export interface ProviderContext {
+    runner: CommandRunner;
+    plan: DeployPlan;
+    /** Project root. Every command runs from here so monorepo paths stay stable. */
+    cwd: string;
+    /** Progress line for the spinner or the headless log. */
+    log?: (message: string) => void;
+}
+export interface AuthStatus {
+    ok: boolean;
+    /** Account identifier the provider reported, shown in the confirmation summary. */
+    account?: string;
+    /** Why it failed, phrased as the command to run. */
+    fix?: string;
+}
+export interface ProvisionResult {
+    /** Connection values to inject into the backend env. */
+    outputs: ServiceOutputs;
+    /**
+     * Keys the provider wired straight onto the target app instead of handing
+     * back a value (Fly's `mpg attach` is the case that needs this). They are not
+     * reported as missing even though nothing local knows their value.
+     */
+    providedByProvider?: string[];
+    /** One-line explanation surfaced in the summary. */
+    note?: string;
+}
+export interface ProvisionInput {
+    service: PlannedService;
+    /** The app the service is being wired into, when one is being deployed. */
+    backend?: PlannedTarget;
+    /**
+     * True when the consuming backend runs on a different provider. Same-provider
+     * wiring can use private networking and reference variables; cross-provider
+     * wiring has to resolve a publicly reachable connection string.
+     */
+    crossProvider: boolean;
+}
+export interface DeployTargetInput {
+    target: PlannedTarget;
+    /** Full env for this target, managed values already merged over forwarded ones. */
+    env: Record<string, string>;
+    /** Values to mask in any echoed command. */
+    secrets: string[];
+    /**
+     * Command to run against the new build before it takes traffic, used for
+     * database migrations. Providers that support a release hook should prefer
+     * it: the command runs from the image being shipped, and a failure stops the
+     * release instead of leaving a new version talking to an old schema.
+     */
+    releaseCommand?: string[];
+}
+export interface DeployTargetResult {
+    /** Public origin the provider reported. Compared against the reserved one. */
+    url?: string;
+    note?: string;
+    /**
+     * True when {@link DeployTargetInput.releaseCommand} ran as part of this
+     * deploy, so the orchestrator does not run it a second time over SSH.
+     */
+    releaseRan?: boolean;
+}
+export interface DeployProviderAdapter {
+    id: ProviderId;
+    /** Confirm the provider CLI is installed and logged in. Never throws. */
+    checkAuth(ctx: ProviderContext): Promise<AuthStatus>;
+    /**
+     * Create the remote app and settle its public origin before anything is
+     * built. The frontends bake the backend's URL into their bundle, so every URL
+     * has to be known up front rather than discovered after the fact.
+     */
+    reserveTarget(ctx: ProviderContext, target: PlannedTarget): Promise<string>;
+    provisionService(ctx: ProviderContext, input: ProvisionInput): Promise<ProvisionResult>;
+    /** Push env vars to the remote app. Static hosts with no runtime env may no-op. */
+    setEnv(ctx: ProviderContext, input: DeployTargetInput): Promise<void>;
+    deployTarget(ctx: ProviderContext, input: DeployTargetInput): Promise<DeployTargetResult>;
+    /**
+     * Run a one-off command inside the deployed app, used for `prisma migrate
+     * deploy`. Providers that cannot do this leave it undefined and the
+     * orchestrator prints the command for the user to run.
+     */
+    runRemote?(ctx: ProviderContext, target: PlannedTarget, command: string[]): Promise<{
+        ok: boolean;
+        output: string;
+    }>;
+}
+/** Targets a provider is responsible for in this plan. */
+export declare function targetsFor(plan: DeployPlan, provider: ProviderId): PlannedTarget[];
+export declare function findTarget(plan: DeployPlan, target: DeployTarget): PlannedTarget | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/deploy/providers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/deploy/providers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAEvH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,aAAa,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;IACjB,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,OAAO,CAAC;IACZ,mFAAmF;IACnF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,OAAO,EAAE,cAAc,CAAC;IACxB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;OAIG;IACH,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,4CAA4C;IAC5C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,UAAU,CAAC;IAEf,yEAAyE;IACzE,SAAS,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAErD;;;;OAIG;IACH,aAAa,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE5E,gBAAgB,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAExF,mFAAmF;IACnF,MAAM,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtE,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE1F;;;;OAIG;IACH,SAAS,CAAC,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtH;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,aAAa,EAAE,CAElF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,GAAG,aAAa,GAAG,SAAS,CAE5F"}

package/dist/deploy/report.d.ts

@@ -0,0 +1,13 @@
+import { TargetEnvPlan } from './env-plan.js';
+import { DeployOutcome, DeployPlan } from './types.js';
+/** The plan as a block the user confirms before anything is created or billed. */
+export declare function renderPlanSummary(plan: DeployPlan): string;
+/** What each app will receive, so surprises show up before the deploy, not after. */
+export declare function renderEnvSummary(envPlans: TargetEnvPlan[]): string;
+/** What actually happened, step by step. */
+export declare function renderOutcome(outcome: DeployOutcome): string;
+/** Clickable list of every origin the deploy settled on. */
+export declare function renderUrls(outcome: DeployOutcome): string;
+/** Follow-up work the user still owns, or an empty list when there is none. */
+export declare function collectWarnings(outcome: DeployOutcome): string[];
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/deploy/report.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE5D,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CA+B1D;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,CAqBlE;AAED,4CAA4C;AAC5C,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAa5D;AAED,4DAA4D;AAC5D,wBAAgB,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAQzD;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,EAAE,CAehE"}