@vistagenic/vista 0.2.16 → 0.3.2

package/dist/deploy/adapters/docker.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const cli_runner_1 = require("../cli-runner");
+const preflight_1 = require("../preflight");
+const utils_1 = require("../utils");
+const DOCKERFILE_TEMPLATE = `# syntax=docker/dockerfile:1
+
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package.json package-lock.json* pnpm-lock.yaml* yarn.lock* ./
+RUN npm install --no-audit --no-fund
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+ENV PORT=3003
+COPY --from=builder /app/.vista ./.vista
+COPY --from=builder /app/package.json ./package.json
+EXPOSE 3003
+CMD ["node", ".vista/standalone/server.js"]
+`;
+const DOCKERIGNORE_TEMPLATE = `node_modules
+.git
+.vista/cache
+.flash
+.next
+.vercel
+dist
+coverage
+*.log
+.env*
+`;
+exports.dockerAdapter = {
+    id: 'docker',
+    requiredOutput: 'standalone',
+    supportsFullRuntime: true,
+    async preflight(ctx) {
+        return (0, preflight_1.runStandalonePreflight)(ctx);
+    },
+    async emit(ctx) {
+        const dockerfilePath = path_1.default.join(ctx.cwd, 'Dockerfile');
+        const dockerignorePath = path_1.default.join(ctx.cwd, '.dockerignore');
+        (0, utils_1.writeFileIfAllowed)(dockerfilePath, DOCKERFILE_TEMPLATE, ctx.force);
+        (0, utils_1.writeFileIfAllowed)(dockerignorePath, DOCKERIGNORE_TEMPLATE, ctx.force);
+        return {
+            status: 'emitted',
+            target: 'docker',
+            artifactPaths: [
+                path_1.default.join(ctx.vistaDir, 'standalone', 'server.js'),
+                dockerfilePath,
+                dockerignorePath,
+            ],
+            instructions: [
+                'Build image: docker build -t my-vista-app .',
+                'Run container: docker run -p 3003:3003 -e PORT=3003 my-vista-app',
+            ],
+        };
+    },
+    async deploy(ctx) {
+        const emitted = await exports.dockerAdapter.emit(ctx);
+        if (ctx.dryRun) {
+            return emitted;
+        }
+        const errors = await exports.dockerAdapter.preflight(ctx);
+        if (errors.length > 0) {
+            return {
+                status: 'failed',
+                target: 'docker',
+                warnings: errors,
+            };
+        }
+        if (!(0, cli_runner_1.isCliAvailable)('docker')) {
+            return {
+                status: 'emitted',
+                target: 'docker',
+                artifactPaths: emitted.artifactPaths,
+                warnings: ['Docker CLI not found.'],
+                instructions: emitted.instructions,
+            };
+        }
+        const imageTag = 'my-vista-app';
+        const buildResult = (0, cli_runner_1.runCliCommand)(`docker build -t ${imageTag} .`, {
+            cwd: ctx.cwd,
+            dryRun: ctx.dryRun,
+        });
+        if (!buildResult.ok) {
+            return {
+                status: 'emitted',
+                target: 'docker',
+                artifactPaths: emitted.artifactPaths,
+                warnings: [buildResult.stderr || 'Docker build failed.'],
+                instructions: emitted.instructions,
+            };
+        }
+        return {
+            status: 'deployed',
+            target: 'docker',
+            artifactPaths: emitted.artifactPaths,
+            instructions: [
+                `Image built: ${imageTag}`,
+                `Run locally: docker run -p 3003:3003 -e PORT=3003 ${imageTag}`,
+            ],
+        };
+    },
+};

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

@@ -0,0 +1,15 @@
+import type { ResolvedDeployTarget } from '../types';
+import { cloudflareAdapter } from './cloudflare';
+import { dockerAdapter } from './docker';
+import { netlifyAdapter } from './netlify';
+import { renderAdapter } from './render';
+import { vercelAdapter } from './vercel';
+export declare const deployAdapters: {
+    readonly render: import("../types").DeployAdapter;
+    readonly vercel: import("../types").DeployAdapter;
+    readonly cloudflare: import("../types").DeployAdapter;
+    readonly netlify: import("../types").DeployAdapter;
+    readonly docker: import("../types").DeployAdapter;
+};
+export declare function getDeployAdapter(target: ResolvedDeployTarget): import("../types").DeployAdapter;
+export { cloudflareAdapter, dockerAdapter, netlifyAdapter, renderAdapter, vercelAdapter };

package/dist/deploy/adapters/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vercelAdapter = exports.renderAdapter = exports.netlifyAdapter = exports.dockerAdapter = exports.cloudflareAdapter = exports.deployAdapters = void 0;
+exports.getDeployAdapter = getDeployAdapter;
+const cloudflare_1 = require("./cloudflare");
+Object.defineProperty(exports, "cloudflareAdapter", { enumerable: true, get: function () { return cloudflare_1.cloudflareAdapter; } });
+const docker_1 = require("./docker");
+Object.defineProperty(exports, "dockerAdapter", { enumerable: true, get: function () { return docker_1.dockerAdapter; } });
+const netlify_1 = require("./netlify");
+Object.defineProperty(exports, "netlifyAdapter", { enumerable: true, get: function () { return netlify_1.netlifyAdapter; } });
+const render_1 = require("./render");
+Object.defineProperty(exports, "renderAdapter", { enumerable: true, get: function () { return render_1.renderAdapter; } });
+const vercel_1 = require("./vercel");
+Object.defineProperty(exports, "vercelAdapter", { enumerable: true, get: function () { return vercel_1.vercelAdapter; } });
+exports.deployAdapters = {
+    render: render_1.renderAdapter,
+    vercel: vercel_1.vercelAdapter,
+    cloudflare: cloudflare_1.cloudflareAdapter,
+    netlify: netlify_1.netlifyAdapter,
+    docker: docker_1.dockerAdapter,
+};
+function getDeployAdapter(target) {
+    return exports.deployAdapters[target];
+}

package/dist/deploy/adapters/netlify.d.ts

@@ -0,0 +1,2 @@
+import type { DeployAdapter } from '../types';
+export declare const netlifyAdapter: DeployAdapter;

package/dist/deploy/adapters/netlify.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.netlifyAdapter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cli_runner_1 = require("../cli-runner");
+const preflight_1 = require("../preflight");
+const utils_1 = require("../utils");
+const NETLIFY_OUTPUT_DIR = '.vista/deploy/netlify';
+function getNetlifyOutputDir(ctx) {
+    return path_1.default.join(ctx.cwd, NETLIFY_OUTPUT_DIR);
+}
+function writeNetlifyToml(ctx) {
+    const targetFile = path_1.default.join(ctx.cwd, 'netlify.toml');
+    const content = `[build]
+  command = "npm run build"
+  publish = ".vista/deploy/netlify"
+
+[dev]
+  command = "npm run dev"
+  port = 3003
+`;
+    (0, utils_1.writeFileIfAllowed)(targetFile, content, ctx.force);
+    return targetFile;
+}
+function writeRedirects(outputDir) {
+    const redirectsPath = path_1.default.join(outputDir, '_redirects');
+    const lines = [
+        '/_vista/* /:splat 200',
+        '/ /static/pages/index.html 200',
+        '/rsc /static/pages/index.rsc 200',
+        '/_rsc/* /static/pages/:splat.rsc 200',
+        '/* /static/pages/:splat.html 200',
+    ];
+    fs_1.default.writeFileSync(redirectsPath, `${lines.join('\n')}\n`, 'utf8');
+    return redirectsPath;
+}
+exports.netlifyAdapter = {
+    id: 'netlify',
+    requiredOutput: 'static',
+    supportsFullRuntime: false,
+    async preflight(ctx) {
+        return (0, preflight_1.runStaticHostPreflight)(ctx);
+    },
+    async emit(ctx) {
+        const outputDir = getNetlifyOutputDir(ctx);
+        fs_1.default.rmSync(outputDir, { recursive: true, force: true });
+        (0, utils_1.ensureDir)(outputDir);
+        (0, utils_1.copyStaticHostAssets)(ctx.cwd, ctx.vistaDir, outputDir);
+        const redirectsPath = writeRedirects(outputDir);
+        const netlifyTomlPath = writeNetlifyToml(ctx);
+        return {
+            status: 'emitted',
+            target: 'netlify',
+            artifactPaths: [outputDir, redirectsPath, netlifyTomlPath],
+            instructions: [
+                'Netlify deploy uses pre-rendered static output from .vista/deploy/netlify.',
+            ],
+        };
+    },
+    async deploy(ctx) {
+        const emitted = await exports.netlifyAdapter.emit(ctx);
+        if (ctx.dryRun) {
+            return emitted;
+        }
+        const preflightMessages = await exports.netlifyAdapter.preflight(ctx);
+        const { errors, warnings } = (0, preflight_1.splitPreflightMessages)(preflightMessages);
+        if (errors.length > 0) {
+            return {
+                status: 'failed',
+                target: 'netlify',
+                warnings: [...warnings, ...errors],
+            };
+        }
+        const outputDir = getNetlifyOutputDir(ctx);
+        if (!(0, cli_runner_1.isCliAvailable)('netlify')) {
+            return {
+                status: 'emitted',
+                target: 'netlify',
+                artifactPaths: emitted.artifactPaths,
+                warnings: [...warnings, 'Netlify CLI not found. Install with: npm i -g netlify-cli'],
+                instructions: [
+                    'Install Netlify CLI: npm i -g netlify-cli',
+                    `Then run: netlify deploy --prod --dir="${outputDir}"`,
+                ],
+            };
+        }
+        const command = ctx.prod
+            ? `netlify deploy --prod --dir="${outputDir}"`
+            : `netlify deploy --dir="${outputDir}"`;
+        const result = (0, cli_runner_1.runCliCommand)(command, { cwd: ctx.cwd, dryRun: ctx.dryRun });
+        if (!result.ok) {
+            return {
+                status: 'emitted',
+                target: 'netlify',
+                artifactPaths: emitted.artifactPaths,
+                warnings: [...warnings, result.stderr || 'Netlify deploy failed.'],
+                instructions: [
+                    'Run: netlify login',
+                    'Or set NETLIFY_AUTH_TOKEN in your environment.',
+                ],
+            };
+        }
+        return {
+            status: 'deployed',
+            target: 'netlify',
+            url: (0, cli_runner_1.extractDeploymentUrl)(`${result.stdout}\n${result.stderr}`),
+            artifactPaths: emitted.artifactPaths,
+            warnings,
+        };
+    },
+};

package/dist/deploy/adapters/render.d.ts

@@ -0,0 +1,2 @@
+import type { DeployAdapter } from '../types';
+export declare const renderAdapter: DeployAdapter;

package/dist/deploy/adapters/render.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const cli_runner_1 = require("../cli-runner");
+const preflight_1 = require("../preflight");
+const utils_1 = require("../utils");
+const RENDER_YAML_TEMPLATE = `services:
+  - type: web
+    name: my-vista-app
+    runtime: node
+    region: oregon
+    plan: free
+    buildCommand: |
+      npm install --no-audit --no-fund
+      npm run build
+    startCommand: npm run start
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: PORT
+        value: "3003"
+    healthCheckPath: /
+`;
+exports.renderAdapter = {
+    id: 'render',
+    requiredOutput: 'standalone',
+    supportsFullRuntime: true,
+    async preflight(ctx) {
+        return (0, preflight_1.runStandalonePreflight)(ctx);
+    },
+    async emit(ctx) {
+        const renderYamlPath = path_1.default.join(ctx.cwd, 'render.yaml');
+        const result = (0, utils_1.writeFileIfAllowed)(renderYamlPath, RENDER_YAML_TEMPLATE, ctx.force);
+        const artifactPaths = [path_1.default.join(ctx.vistaDir, 'standalone', 'server.js')];
+        if (result.written || result.skipped) {
+            artifactPaths.push(renderYamlPath);
+        }
+        return {
+            status: 'emitted',
+            target: 'render',
+            artifactPaths,
+            instructions: [
+                'Connect this repository on Render and select Blueprint (render.yaml).',
+                'Or create a Web Service with buildCommand "npm run build" and startCommand "npm run start".',
+            ],
+        };
+    },
+    async deploy(ctx) {
+        const emitted = await exports.renderAdapter.emit(ctx);
+        if (ctx.dryRun) {
+            return emitted;
+        }
+        const errors = await exports.renderAdapter.preflight(ctx);
+        if (errors.length > 0) {
+            return {
+                status: 'failed',
+                target: 'render',
+                warnings: errors,
+            };
+        }
+        if (!(0, cli_runner_1.isCliAvailable)('render')) {
+            return {
+                status: 'emitted',
+                target: 'render',
+                artifactPaths: emitted.artifactPaths,
+                instructions: [
+                    'Push to GitHub and connect the repo on https://dashboard.render.com',
+                    'Render will detect render.yaml automatically.',
+                    'Ensure NODE_ENV=production and PORT are set in service env vars.',
+                ],
+            };
+        }
+        const command = ctx.prod ? 'render deploy --confirm' : 'render deploy';
+        const result = (0, cli_runner_1.runCliCommand)(command, { cwd: ctx.cwd, dryRun: ctx.dryRun });
+        if (!result.ok) {
+            return {
+                status: 'emitted',
+                target: 'render',
+                artifactPaths: emitted.artifactPaths,
+                warnings: [result.stderr || 'Render CLI deploy failed.'],
+                instructions: emitted.instructions,
+            };
+        }
+        return {
+            status: 'deployed',
+            target: 'render',
+            url: (0, cli_runner_1.extractDeploymentUrl)(`${result.stdout}\n${result.stderr}`),
+            artifactPaths: emitted.artifactPaths,
+        };
+    },
+};

package/dist/deploy/adapters/vercel.d.ts

@@ -0,0 +1,7 @@
+import type { BuildHookOptions, DeployAdapter } from '../types';
+export declare function isVercelBuildEnvironment(): boolean;
+export declare function hasUserVercelConfig(cwd: string): boolean;
+export declare function writeVercelBuildOutput(options: BuildHookOptions & {
+    force?: boolean;
+}): boolean;
+export declare const vercelAdapter: DeployAdapter;

package/dist/deploy/adapters/vercel.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vercelAdapter = void 0;
+exports.isVercelBuildEnvironment = isVercelBuildEnvironment;
+exports.hasUserVercelConfig = hasUserVercelConfig;
+exports.writeVercelBuildOutput = writeVercelBuildOutput;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cli_runner_1 = require("../cli-runner");
+const preflight_1 = require("../preflight");
+const utils_1 = require("../utils");
+function isVercelBuildEnvironment() {
+    return process.env.VERCEL === '1' || process.env.NOW_REGION !== undefined;
+}
+function hasUserVercelConfig(cwd) {
+    return fs_1.default.existsSync(path_1.default.join(cwd, 'vercel.json'));
+}
+function writeVercelBuildOutput(options) {
+    const { cwd, vistaDir, debug, force = false } = options;
+    if (!force && !isVercelBuildEnvironment()) {
+        return false;
+    }
+    if (!force && hasUserVercelConfig(cwd)) {
+        if (debug) {
+            console.log('[vista:deploy] Found custom vercel.json, skipping internal Vercel output.');
+        }
+        return false;
+    }
+    const vercelOutputDir = path_1.default.join(cwd, '.vercel', 'output');
+    const vercelStaticDir = path_1.default.join(vercelOutputDir, 'static');
+    fs_1.default.rmSync(vercelOutputDir, { recursive: true, force: true });
+    (0, utils_1.ensureDir)(vercelStaticDir);
+    (0, utils_1.copyStaticHostAssets)(cwd, vistaDir, vercelStaticDir);
+    const config = {
+        version: 3,
+        routes: utils_1.STATIC_HOST_ROUTE_RULES,
+    };
+    fs_1.default.writeFileSync(path_1.default.join(vercelOutputDir, 'config.json'), JSON.stringify(config, null, 2));
+    if (debug) {
+        console.log('[vista:deploy] Generated internal Vercel Build Output at .vercel/output/');
+    }
+    return true;
+}
+function writeLegacyVercelJson(ctx) {
+    const targetFile = path_1.default.join(ctx.cwd, 'vercel.json');
+    const payload = {
+        version: 2,
+        buildCommand: 'npm run build',
+        outputDirectory: '.vista',
+        framework: null,
+        installCommand: 'npm install --legacy-peer-deps --no-audit --no-fund',
+        devCommand: 'npm run dev',
+        routes: utils_1.STATIC_HOST_ROUTE_RULES,
+    };
+    const result = (0, utils_1.writeFileIfAllowed)(targetFile, `${JSON.stringify(payload, null, 2)}\n`, ctx.force);
+    return result.written || result.skipped ? targetFile : null;
+}
+exports.vercelAdapter = {
+    id: 'vercel',
+    requiredOutput: 'static',
+    supportsFullRuntime: false,
+    async preflight(ctx) {
+        return (0, preflight_1.runStaticHostPreflight)(ctx);
+    },
+    async emit(ctx) {
+        const artifactPaths = [];
+        const warnings = [];
+        if (ctx.deployConfig.preferBuildOutputApi) {
+            const wrote = writeVercelBuildOutput({
+                cwd: ctx.cwd,
+                vistaDir: ctx.vistaDir,
+                debug: ctx.debug,
+                force: true,
+            });
+            if (wrote) {
+                artifactPaths.push(path_1.default.join(ctx.cwd, '.vercel', 'output'));
+            }
+        }
+        else if (!hasUserVercelConfig(ctx.cwd) || ctx.force) {
+            const legacyPath = writeLegacyVercelJson(ctx);
+            if (legacyPath)
+                artifactPaths.push(legacyPath);
+        }
+        else {
+            artifactPaths.push(path_1.default.join(ctx.cwd, 'vercel.json'));
+        }
+        (0, utils_1.copyStaticHostAssets)(ctx.cwd, ctx.vistaDir, path_1.default.join(ctx.vistaDir));
+        artifactPaths.push(path_1.default.join(ctx.vistaDir, 'static'));
+        return {
+            status: 'emitted',
+            target: 'vercel',
+            artifactPaths,
+            warnings,
+            instructions: [
+                'Vercel deploy uses pre-rendered static pages from .vista/static.',
+                'For full SSR, server actions, and typed API, deploy with --target render or --target docker.',
+            ],
+        };
+    },
+    async deploy(ctx) {
+        const emitted = await exports.vercelAdapter.emit(ctx);
+        if (ctx.dryRun) {
+            return emitted;
+        }
+        const preflightMessages = await exports.vercelAdapter.preflight(ctx);
+        const { errors, warnings } = (0, preflight_1.splitPreflightMessages)(preflightMessages);
+        if (errors.length > 0) {
+            return {
+                status: 'failed',
+                target: 'vercel',
+                warnings: [...warnings, ...errors],
+            };
+        }
+        const hasBuildOutput = fs_1.default.existsSync(path_1.default.join(ctx.cwd, '.vercel', 'output', 'config.json'));
+        const command = hasBuildOutput
+            ? ctx.prod
+                ? 'vercel deploy --prebuilt --prod --yes'
+                : 'vercel deploy --prebuilt --yes'
+            : ctx.prod
+                ? 'vercel deploy --prod --yes'
+                : 'vercel deploy --yes';
+        if (!(0, cli_runner_1.isCliAvailable)('vercel')) {
+            return {
+                status: 'emitted',
+                target: 'vercel',
+                artifactPaths: emitted.artifactPaths,
+                warnings: [
+                    ...warnings,
+                    ...(emitted.warnings ?? []),
+                    'Vercel CLI not found. Install with: npm i -g vercel',
+                ],
+                instructions: [
+                    'Install Vercel CLI: npm i -g vercel',
+                    'Then run: vercel deploy --prod',
+                    'Or connect this repository in the Vercel dashboard with buildCommand "npm run build".',
+                ],
+            };
+        }
+        const result = (0, cli_runner_1.runCliCommand)(command, { cwd: ctx.cwd, dryRun: ctx.dryRun });
+        if (!result.ok) {
+            return {
+                status: 'emitted',
+                target: 'vercel',
+                artifactPaths: emitted.artifactPaths,
+                warnings: [...warnings, result.stderr || 'Vercel deploy failed.'],
+                instructions: [
+                    'Ensure you are logged in: vercel login',
+                    'Or set VERCEL_TOKEN in your environment.',
+                    'You can also deploy from the Vercel dashboard using npm run build.',
+                ],
+            };
+        }
+        return {
+            status: 'deployed',
+            target: 'vercel',
+            url: (0, cli_runner_1.extractDeploymentUrl)(`${result.stdout}\n${result.stderr}`),
+            artifactPaths: emitted.artifactPaths,
+            warnings,
+        };
+    },
+};

package/dist/deploy/cli-runner.d.ts

@@ -0,0 +1,8 @@
+import type { CliRunResult } from './types';
+export declare function isCliAvailable(command: string): boolean;
+export declare function runCliCommand(command: string, options: {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    dryRun?: boolean;
+}): CliRunResult;
+export declare function extractDeploymentUrl(output: string): string | undefined;

package/dist/deploy/cli-runner.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCliAvailable = isCliAvailable;
+exports.runCliCommand = runCliCommand;
+exports.extractDeploymentUrl = extractDeploymentUrl;
+const child_process_1 = require("child_process");
+function parseCommand(command) {
+    const parts = command.trim().split(/\s+/).filter(Boolean);
+    if (parts.length === 0) {
+        throw new Error('[vista:deploy] Empty CLI command.');
+    }
+    return { bin: parts[0], args: parts.slice(1) };
+}
+function isCliAvailable(command) {
+    const { bin } = parseCommand(command);
+    const which = process.platform === 'win32' ? 'where' : 'which';
+    const result = (0, child_process_1.spawnSync)(which, [bin], { stdio: 'ignore' });
+    return result.status === 0;
+}
+function runCliCommand(command, options) {
+    if (options.dryRun) {
+        return {
+            ok: true,
+            stdout: '',
+            stderr: '',
+            command,
+        };
+    }
+    const { bin, args } = parseCommand(command);
+    if (!isCliAvailable(bin)) {
+        return {
+            ok: false,
+            stdout: '',
+            stderr: `CLI not found: ${bin}`,
+            command,
+            missingCli: true,
+        };
+    }
+    const result = (0, child_process_1.spawnSync)(bin, args, {
+        cwd: options.cwd,
+        env: { ...process.env, ...(options.env ?? {}) },
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return {
+        ok: result.status === 0,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+        command,
+        missingCli: false,
+    };
+}
+function extractDeploymentUrl(output) {
+    const match = output.match(/https?:\/\/[^\s]+/g);
+    if (!match || match.length === 0)
+        return undefined;
+    return match[match.length - 1].replace(/[)\]'"]+$/, '');
+}

package/dist/deploy/detect.d.ts

@@ -0,0 +1,6 @@
+import type { DeployTarget, ResolvedDeployConfig } from '../config';
+import type { ResolvedDeployTarget } from './types';
+export declare function normalizeResolvedTarget(raw: unknown): ResolvedDeployTarget | null;
+export declare function resolveDeployTarget(cwd: string, deployConfig: ResolvedDeployConfig, cliTarget?: string | null): ResolvedDeployTarget;
+export declare function resolveEffectiveOutput(deployConfig: ResolvedDeployConfig, target: ResolvedDeployTarget): 'standalone' | 'static' | 'hybrid';
+export declare function listKnownTargets(): DeployTarget[];