@geekmidas/cli 10.0.0-alpha.62 → 10.0.0-alpha.63

package/dist/{workspace-BFe57es7.mjs → schemas-Ckm_aBnF.cjs}

@@ -1,6 +1,3 @@
-import { n as __require } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { n as isDeployTarget, o as builtinTarget, r as BUILTIN_TARGETS, s as configurableBuiltins } from "./define-CHBIEc5j.mjs";
-import { basename, isAbsolute, join } from "node:path";
 //#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -4823,7 +4820,7 @@ const initializer = (inst, issues) => {
 const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, void 0, { Parent: Error });
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/parse.js
-const parse$1 = /* @__PURE__ */ _parse(ZodRealError);
+const parse = /* @__PURE__ */ _parse(ZodRealError);
 const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
 const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -4955,7 +4952,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 		own(this, "~standard", value);
 	},
 	parse: function _parse(data, params) {
-		return parse$1(this, data, params, { callee: _parse });
+		return parse(this, data, params, { callee: _parse });
 	},
 	parseAsync: async function _parseAsync(data, params) {
 		return await parseAsync(this, data, params, { callee: _parseAsync });
@@ -5757,997 +5754,89 @@ function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
 //#endregion
-//#region src/workspace/stages.ts
-/**
-* What `gkm test` runs as. The CLI's own, so no project stage may take it:
-* its containers are torn down and rebuilt between runs.
-*/
-const TEST_STAGE = "test";
-/** A stage becomes part of every physical name, so it has to fit in one. */
-const STAGE_NAME = /^[a-z][a-z0-9-]*$/;
-/** Everything wrong with one stage name, or nothing. */
-function nameProblems(name) {
-	const problems = [];
-	if (!STAGE_NAME.test(name)) problems.push(`stage "${name}" must be lowercase letters, digits and hyphens, starting with a letter`);
-	if (name === "test") problems.push(`stage "${TEST_STAGE}" is reserved for gkm test`);
-	return problems;
-}
-/** Everything wrong with a list of deployed stages on its own. */
-function deployedProblems(deployed) {
-	const problems = deployed.flatMap(nameProblems);
-	const seen = /* @__PURE__ */ new Set();
-	for (const name of deployed) {
-		if (seen.has(name)) problems.push(`stage "${name}" is listed twice`);
-		seen.add(name);
-	}
-	return problems;
-}
-/** Everything wrong with a stages block, or nothing. */
-function stageProblems(stages) {
-	if (!stages) return ["`stages` is required, e.g. stages: { local: 'dev', deployed: ['prod'] }"];
-	const { local, deployed, protected: kept = [] } = stages;
-	const problems = [...nameProblems(local), ...deployedProblems(deployed)];
-	if (deployed.includes(local)) problems.push(`"${local}" is both the local stage and a deployed one; they would share secrets`);
-	for (const name of kept) if (!deployed.includes(name)) problems.push(`protected stage "${name}" is not a deployed stage`);
-	return problems;
-}
-/** The stages block, or an error naming everything wrong with it. */
-function validateStages(stages) {
-	const problems = stageProblems(stages);
-	if (problems.length) throw new InvalidStages(problems);
-	return stages;
-}
-/** Refuses a stage the project does not deploy to. */
-function assertDeployedStage(stages, stage) {
-	if (!stages.deployed.includes(stage)) throw new UndeclaredStage(stage, stages.deployed);
-}
-/** A stages block — in gkm.config.ts or from `gkm init`'s flags — that breaks a rule. */
-var InvalidStages = class extends Error {
-	problems;
-	constructor(problems) {
-		super(`Invalid stages:\n  ${problems.join("\n  ")}`);
-		this.problems = problems;
-		this.name = "InvalidStages";
-	}
-};
-/**
-* A stage the project does not deploy to. Refused before anything is
-* provisioned, so a typo does not become a second environment.
-*/
-var UndeclaredStage = class extends Error {
-	stage;
-	deployed;
-	constructor(stage, deployed) {
-		super(`"${stage}" is not a deployed stage. gkm.config.ts deploys to: ${deployed.join(", ") || "nothing yet"}.`);
-		this.stage = stage;
-		this.deployed = deployed;
-		this.name = "UndeclaredStage";
+Object.defineProperty(exports, "_enum", {
+	enumerable: true,
+	get: function() {
+		return _enum;
 	}
-};
-//#endregion
-//#region src/workspace/schema.ts
-/** Routes are a glob, or a list of them. */
-const RoutesSchema = union([string(), array(string())]);
-/**
-* Telescope configuration schema.
-*/
-const TelescopeConfigSchema = object({
-	enabled: boolean().optional(),
-	port: number().optional(),
-	path: string().optional(),
-	ignore: array(string()).optional(),
-	recordBody: boolean().optional(),
-	maxEntries: number().optional(),
-	websocket: boolean().optional()
-});
-/**
-* OpenAPI configuration schema.
-*/
-const OpenApiConfigSchema = object({
-	enabled: boolean().optional(),
-	title: string().optional(),
-	version: string().optional(),
-	description: string().optional()
-});
-/**
-* Hooks configuration schema.
-*/
-const HooksConfigSchema = object({ server: string().optional() });
-/**
-* Combined framework schema (backend, frontend, or mobile).
-*/
-const FrameworkSchema = union([
-	_enum([
-		"hono",
-		"better-auth",
-		"express",
-		"fastify"
-	]),
-	_enum([
-		"nextjs",
-		"remix",
-		"vite",
-		"tanstack-start"
-	]),
-	_enum(["expo"])
-]);
-/** Frontend framework values, kept in sync with FrontendFrameworkSchema. */
-const FRONTEND_FRAMEWORKS = [
-	"nextjs",
-	"remix",
-	"vite",
-	"tanstack-start"
-];
-/** Mobile framework values, kept in sync with MobileFrameworkSchema. */
-const MOBILE_FRAMEWORKS = ["expo"];
-/**
-* A deploy target's name. Which names exist is the workspace's to say — the
-* built-ins and its own `deploy.targets` — so it is checked against both
-* once the whole config is read.
-*/
-const DeployTargetSchema = string().min(1);
-/**
-* The built-in targets a config may name: `dokploy`, deployed by
-* `gkm deploy`, and `sst`, deployed by `sst deploy` from the manifest
-* `gkm build` writes.
-*/
-const SUPPORTED_DEPLOY_TARGETS = configurableBuiltins();
-/** Built-in names reserved for targets that do not exist yet. */
-const PHASE_2_DEPLOY_TARGETS = Object.entries(BUILTIN_TARGETS).filter(([, target]) => target.status === "planned").map(([name]) => name);
-/**
-* Whether a config may name `target`: a usable built-in, or one of its own
-* `deploy.targets`.
-*/
-function isDeployTargetSupported(target, targets = {}) {
-	return SUPPORTED_DEPLOY_TARGETS.includes(target) || Object.hasOwn(targets, target);
-}
-/**
-* Check if a deploy target is planned for Phase 2.
-*/
-function isPhase2DeployTarget(target) {
-	return PHASE_2_DEPLOY_TARGETS.includes(target);
-}
-/**
-* Get error message for unsupported deploy targets.
-*/
-function getDeployTargetError(target, appName) {
-	if (isPhase2DeployTarget(target)) return `Deploy target "${target}"${appName ? ` for app "${appName}"` : ""} is coming in Phase 2. Currently "dokploy" and "sst" are supported.`;
-	return `Unknown deploy target: ${target}. Built in: ${SUPPORTED_DEPLOY_TARGETS.join(", ")}; any other is named in deploy.targets with the package that provides it. Coming in Phase 2: ${PHASE_2_DEPLOY_TARGETS.join(", ")}.`;
-}
-/**
-* One `deploy.targets` entry: a package name, a target object, or either
-* with options.
-*/
-const DeployTargetEntrySchema = union([
-	string().min(1, "A target package name cannot be empty"),
-	custom((value) => isDeployTarget(value), { message: "Expected a package name, a target (defineTarget), or [package or target, options]" }),
-	tuple([union([string().min(1), custom((value) => isDeployTarget(value), { message: "Expected a package name or a target (defineTarget)" })]), unknown()])
-]);
-/**
-* Dokploy workspace configuration schema.
-* Supports either a single endpoint or per-stage endpoints.
-*/
-const DokployWorkspaceConfigSchema = object({
-	/** Single endpoint for all stages */
-	endpoint: url("Dokploy endpoint must be a valid URL").optional(),
-	/** Per-stage endpoints (stage name -> endpoint URL) */
-	endpoints: record(string(), url("Endpoint must be a valid URL")).optional(),
-	registry: string().optional(),
-	registryId: string().optional()
-}).refine((data) => data.endpoint || data.endpoints, { message: "Either endpoint or endpoints must be provided" });
-/**
-* Valid AWS regions.
-*/
-const AwsRegionSchema = _enum([
-	"us-east-1",
-	"us-east-2",
-	"us-west-1",
-	"us-west-2",
-	"af-south-1",
-	"ap-east-1",
-	"ap-south-1",
-	"ap-south-2",
-	"ap-southeast-1",
-	"ap-southeast-2",
-	"ap-southeast-3",
-	"ap-southeast-4",
-	"ap-northeast-1",
-	"ap-northeast-2",
-	"ap-northeast-3",
-	"ca-central-1",
-	"eu-central-1",
-	"eu-central-2",
-	"eu-west-1",
-	"eu-west-2",
-	"eu-west-3",
-	"eu-south-1",
-	"eu-south-2",
-	"eu-north-1",
-	"me-south-1",
-	"me-central-1",
-	"sa-east-1"
-]);
-/**
-* DNS record types supported across providers.
-*/
-const DnsRecordTypeSchema = _enum([
-	"A",
-	"AAAA",
-	"CNAME",
-	"MX",
-	"TXT",
-	"NS",
-	"SRV",
-	"CAA"
-]);
-object({
-	/** Subdomain name (e.g., 'api' for api.example.com, '@' for root) */
-	name: string(),
-	/** Record type */
-	type: DnsRecordTypeSchema,
-	/** TTL in seconds */
-	ttl: number().int().positive(),
-	/** Record values */
-	values: array(string())
-});
-object({
-	/** The record that was upserted */
-	record: object({
-		/** Subdomain name (e.g., 'api' for api.example.com, '@' for root) */
-		name: string(),
-		/** Record type */
-		type: DnsRecordTypeSchema,
-		/** TTL in seconds */
-		ttl: number().int().positive(),
-		/** Record value (IP address, hostname, etc.) */
-		value: string()
-	}),
-	/** Whether the record was created (true) or updated (false) */
-	created: boolean(),
-	/** Whether the record already existed with the same value */
-	unchanged: boolean()
-});
-/**
-* Hostinger DNS provider config (without domain - domain is the record key).
-*/
-const HostingerDnsProviderSchema = object({
-	provider: literal("hostinger"),
-	/** TTL in seconds (default: 300) */
-	ttl: number().int().positive().optional()
-});
-/**
-* Route53 DNS provider config (without domain - domain is the record key).
-*/
-const Route53DnsProviderSchema = object({
-	provider: literal("route53"),
-	/** AWS region (optional - uses AWS_REGION env var if not provided) */
-	region: AwsRegionSchema.optional(),
-	/** AWS profile name (optional - uses default credential chain if not provided) */
-	profile: string().optional(),
-	/** Hosted zone ID (optional - auto-detected from domain if not provided) */
-	hostedZoneId: string().optional(),
-	/** TTL in seconds (default: 300) */
-	ttl: number().int().positive().optional()
-});
-/**
-* Cloudflare DNS provider config (placeholder for future).
-*/
-const CloudflareDnsProviderSchema = object({
-	provider: literal("cloudflare"),
-	/** TTL in seconds (default: 300) */
-	ttl: number().int().positive().optional()
-});
-/**
-* Manual DNS configuration (user handles DNS themselves).
-*/
-const ManualDnsProviderSchema = object({ provider: literal("manual") });
-/**
-* Custom DNS provider config (user-provided implementation).
-*/
-const CustomDnsProviderSchema = object({
-	/** Custom DnsProvider implementation */
-	provider: custom((val) => typeof val === "object" && val !== null && typeof val.name === "string" && typeof val.getRecords === "function" && typeof val.upsertRecords === "function", { message: "Custom DNS provider must implement name, getRecords(), and upsertRecords() methods" }),
-	/** TTL in seconds (default: 300) */
-	ttl: number().int().positive().optional()
-});
-/**
-* Single DNS provider config (for one domain).
-*/
-const DnsProviderSchema = union([discriminatedUnion("provider", [
-	HostingerDnsProviderSchema,
-	Route53DnsProviderSchema,
-	CloudflareDnsProviderSchema,
-	ManualDnsProviderSchema
-]), CustomDnsProviderSchema]);
-/**
-* DNS configuration schema.
-*
-* Maps root domains to their DNS provider configuration.
-* Example:
-* ```
-* dns: {
-*   'geekmidas.dev': { provider: 'hostinger' },
-*   'geekmidas.com': { provider: 'route53' },
-* }
-* ```
-*
-* Supported providers:
-* - 'hostinger': Use Hostinger DNS API
-* - 'route53': Use AWS Route53
-* - 'cloudflare': Use Cloudflare DNS API (future)
-* - 'manual': Don't create records, just print required records
-* - Custom: Provide a DnsProvider implementation
-*/
-const DnsConfigSchema = record(string(), DnsProviderSchema);
-const HostingerDnsConfigSchema = HostingerDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
-const Route53DnsConfigSchema = Route53DnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
-const CloudflareDnsConfigSchema = CloudflareDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
-const ManualDnsConfigSchema = ManualDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
-const CustomDnsConfigSchema = CustomDnsProviderSchema.extend({ domain: string().min(1, "Domain is required") });
-/**
-* Combined DNS config that supports both new multi-domain and legacy single-domain formats.
-*/
-const DnsConfigWithLegacySchema = union([DnsConfigSchema, union([discriminatedUnion("provider", [
-	HostingerDnsConfigSchema,
-	Route53DnsConfigSchema,
-	CloudflareDnsConfigSchema,
-	ManualDnsConfigSchema
-]), CustomDnsConfigSchema])]);
-/**
-* Backups configuration schema.
-*
-* Configures automatic backup destinations for database services.
-* On first deploy, creates S3 bucket with unique name and IAM credentials.
-*/
-const BackupsConfigSchema = object({
-	/** Backup storage type (currently only 's3' supported) */
-	type: literal("s3"),
-	/** AWS profile name for creating bucket/IAM resources */
-	profile: string().optional(),
-	/** AWS region for the backup bucket */
-	region: AwsRegionSchema,
-	/** Cron schedule for backups (default: '0 2 * * *' = 2 AM daily) */
-	schedule: string().optional(),
-	/** Number of backups to retain (default: 30) */
-	retention: number().optional()
-});
-/**
-* Deploy configuration schema.
-*/
-const DeployConfigSchema = object({
-	default: DeployTargetSchema.optional(),
-	targets: record(string(), DeployTargetEntrySchema).superRefine((targets, ctx) => {
-		for (const name of Object.keys(targets)) if (builtinTarget(name)) ctx.addIssue({
-			code: "custom",
-			message: `"${name}" is a built-in target; give this one a name of its own`,
-			path: [name]
-		});
-	}).optional(),
-	/** Whose deploy this is, on a target shared with other workspaces. */
-	namespace: string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "deploy.namespace must be lowercase letters and digits with single '-' between them").optional(),
-	/** Each deployed stage's base domain (stage name -> domain). */
-	domains: record(string(), string()).optional(),
-	dokploy: DokployWorkspaceConfigSchema.optional(),
-	dns: DnsConfigWithLegacySchema.optional(),
-	backups: BackupsConfigSchema.optional()
-});
-/**
-* Models configuration schema.
-*/
-const ModelsConfigSchema = object({
-	path: string().optional(),
-	schema: _enum(["zod"]).optional()
-});
-/**
-* Shared configuration schema.
-*/
-const SharedConfigSchema = object({
-	packages: array(string()).optional(),
-	models: ModelsConfigSchema.optional()
-});
-/**
-* Secrets configuration schema.
-*/
-const StagesConfigSchema = object({
-	local: string(),
-	deployed: array(string()),
-	protected: array(string()).optional()
-}).superRefine((stages, ctx) => {
-	for (const message of stageProblems(stages)) ctx.addIssue({
-		code: "custom",
-		message
-	});
-});
-const SecretsStoreSchema = union([
-	literal("file"),
-	object({
-		provider: literal("ssm"),
-		region: AwsRegionSchema
-	}).strict(),
-	object({ 
-	/** Any backend: an object implementing SecretsStore */
-provider: custom((val) => typeof val === "object" && val !== null && typeof val.name === "string" && typeof val.read === "function" && typeof val.write === "function", { message: "a secrets store has a name, read() and write()" }) })
-]);
-const SecretsConfigSchema = object({
-	enabled: boolean().optional(),
-	store: SecretsStoreSchema.optional(),
-	algorithm: string().optional(),
-	kdf: _enum(["scrypt", "pbkdf2"]).optional()
-});
-/**
-* Local state provider config.
-*/
-const LocalStateConfigSchema = object({ provider: literal("local") });
-/**
-* SSM state provider config (requires region).
-*/
-const SSMStateConfigSchema = object({
-	provider: literal("ssm"),
-	/** AWS region (required for SSM provider) */
-	region: AwsRegionSchema,
-	/** AWS profile name (optional - uses default credential chain if not provided) */
-	profile: string().optional()
 });
-/**
-* S3 state provider config: conditional writes and a lock object in a bucket.
-*/
-const S3StateConfigSchema = object({
-	provider: literal("s3"),
-	/** Bucket the state lives in (must already exist) */
-	bucket: string().min(1),
-	/** AWS region of the bucket */
-	region: AwsRegionSchema,
-	/** Key prefix inside the bucket (default: 'gkm') */
-	prefix: string().optional(),
-	/** AWS profile name (optional - uses default credential chain if not provided) */
-	profile: string().optional()
-});
-/**
-* Custom state provider config (user-provided implementation).
-*/
-const CustomStateConfigSchema = object({ 
-/** Custom StateProvider implementation */
-provider: custom((val) => typeof val === "object" && val !== null && typeof val.read === "function" && typeof val.write === "function", { message: "Custom provider must implement read() and write() methods" }) });
-/**
-* State configuration schema.
-*
-* Configures how deployment state is stored.
-* - 'local': Store in .gkm/deploy-{stage}.json (default)
-* - 'ssm': Store in AWS SSM Parameter Store (requires region)
-* - 's3': Store in an S3 bucket with conditional writes (requires bucket, region)
-* - Custom: Provide a StateStore, or a StateProvider with read/write methods
-*/
-const StateConfigSchema = union([discriminatedUnion("provider", [
-	LocalStateConfigSchema,
-	SSMStateConfigSchema,
-	S3StateConfigSchema
-]), CustomStateConfigSchema]);
-/**
-* App configuration schema.
-*/
-const AppConfigSchema = object({
-	type: _enum([
-		"backend",
-		"web",
-		"mobile"
-	]).optional().default("backend"),
-	path: string().min(1, "App path is required"),
-	port: number().int().positive("Port must be a positive integer"),
-	dependencies: array(string()).optional(),
-	deploy: DeployTargetSchema.optional(),
-	constructs: RoutesSchema.optional(),
-	routes: RoutesSchema.optional(),
-	functions: RoutesSchema.optional(),
-	crons: RoutesSchema.optional(),
-	queues: RoutesSchema.optional(),
-	topics: RoutesSchema.optional(),
-	subscribers: RoutesSchema.optional(),
-	envParser: string().optional(),
-	logger: string().optional(),
-	hooks: HooksConfigSchema.optional(),
-	telescope: union([
-		string(),
-		boolean(),
-		TelescopeConfigSchema
-	]).optional(),
-	openapi: union([boolean(), OpenApiConfigSchema]).optional(),
-	runtime: _enum(["node", "bun"]).optional(),
-	env: union([string(), array(string())]).optional(),
-	entry: string().optional(),
-	framework: FrameworkSchema.optional(),
-	config: object({
-		client: string().optional(),
-		server: string().optional()
-	}).optional()
-}).refine((data) => {
-	if (data.type === "web") {
-		if (!data.framework || !FRONTEND_FRAMEWORKS.includes(data.framework)) return false;
+Object.defineProperty(exports, "array", {
+	enumerable: true,
+	get: function() {
+		return array;
 	}
-	return true;
-}, {
-	message: `Web apps must have a valid web framework (${FRONTEND_FRAMEWORKS.join(", ")})`,
-	path: ["framework"]
-}).refine((data) => {
-	if (data.type === "mobile") {
-		if (!data.framework || !MOBILE_FRAMEWORKS.includes(data.framework)) return false;
+});
+Object.defineProperty(exports, "boolean", {
+	enumerable: true,
+	get: function() {
+		return boolean;
 	}
-	return true;
-}, {
-	message: `Mobile apps must have a valid mobile framework (${MOBILE_FRAMEWORKS.join(", ")})`,
-	path: ["framework"]
-});
-/** What `gkm test` hands a feature test. */
-const TestConfigSchema = object({ 
-/** The folder of per-database factories; `test/factories` by default. */
-factories: string().optional() }).strict();
-/** How `gkm dev` is reached from outside the apps it runs. */
-const DevConfigSchema = object({
-	/** Browser origins that may read the discovery endpoint. */
-	allowedOrigins: array(url().refine((value) => URL.canParse(value) && new URL(value).origin === value, { message: "An origin is a scheme, host and port only, e.g. https://console.example.com — no path or trailing slash" })).optional(),
-	/** The discovery endpoint's loopback port; 4983 by default. */
-	discoveryPort: number().int().min(0).max(65535).optional()
-}).strict();
-/**
-* Workspace configuration schema.
-*/
-const WorkspaceConfigSchema = object({
-	name: string().optional(),
-	/**
-	* Where the workspace's own constructs live, relative to its root.
-	*
-	* Infrastructure is a fact about the product, not about the process that
-	* happens to import it — so a database two apps share is declared once,
-	* at the top, and both find it. An app-level glob still works and is
-	* additive, for something only one app uses.
-	*/
-	constructs: RoutesSchema.optional(),
-	/**
-	* Apps that nothing declares.
-	*
-	* Optional, and normally absent: a `site` is an app and so is a
-	* `rest-api` that named one, so the list is read off the graph. This is
-	* the escape hatch for what no construct describes — a mobile app, a
-	* process someone runs by hand — and for overriding one field of a
-	* derived app without restating it.
-	*/
-	apps: record(string(), AppConfigSchema).optional(),
-	shared: SharedConfigSchema.optional(),
-	deploy: DeployConfigSchema.optional(),
-	stages: StagesConfigSchema,
-	secrets: SecretsConfigSchema.optional(),
-	state: StateConfigSchema.optional(),
-	test: TestConfigSchema.optional(),
-	dev: DevConfigSchema.optional()
-}).strict().refine((data) => {
-	const appNames = Object.keys(data.apps ?? {});
-	for (const [appName, app] of Object.entries(data.apps ?? {})) for (const dep of app.dependencies ?? []) {
-		if (!appNames.includes(dep)) return false;
-		if (dep === appName) return false;
+});
+Object.defineProperty(exports, "custom", {
+	enumerable: true,
+	get: function() {
+		return custom;
 	}
-	return true;
-}, { message: "App dependencies must reference existing apps and cannot be self-referential" }).refine((data) => {
-	const appNames = Object.keys(data.apps ?? {});
-	const visited = /* @__PURE__ */ new Set();
-	const recStack = /* @__PURE__ */ new Set();
-	function hasCycle(app) {
-		if (recStack.has(app)) return true;
-		if (visited.has(app)) return false;
-		visited.add(app);
-		recStack.add(app);
-		const deps = data.apps?.[app]?.dependencies ?? [];
-		for (const dep of deps) if (hasCycle(dep)) return true;
-		recStack.delete(app);
-		return false;
+});
+Object.defineProperty(exports, "discriminatedUnion", {
+	enumerable: true,
+	get: function() {
+		return discriminatedUnion;
 	}
-	for (const app of appNames) {
-		visited.clear();
-		recStack.clear();
-		if (hasCycle(app)) return false;
+});
+Object.defineProperty(exports, "literal", {
+	enumerable: true,
+	get: function() {
+		return literal;
 	}
-	return true;
-}, { message: "Circular dependencies detected between apps" }).superRefine((data, ctx) => {
-	const defaultTarget = data.deploy?.default;
-	const ownTargets = data.deploy?.targets ?? {};
-	if (defaultTarget && !isDeployTargetSupported(defaultTarget, ownTargets)) {
-		ctx.addIssue({
-			code: "custom",
-			message: getDeployTargetError(defaultTarget),
-			path: ["deploy", "default"]
-		});
-		return;
+});
+Object.defineProperty(exports, "number", {
+	enumerable: true,
+	get: function() {
+		return number;
 	}
-	for (const [appName, app] of Object.entries(data.apps ?? {})) if (app.deploy && !isDeployTargetSupported(app.deploy, ownTargets)) {
-		ctx.addIssue({
-			code: "custom",
-			message: getDeployTargetError(app.deploy, appName),
-			path: [
-				"apps",
-				appName,
-				"deploy"
-			]
-		});
-		return;
+});
+Object.defineProperty(exports, "object", {
+	enumerable: true,
+	get: function() {
+		return object;
 	}
-	if (data.state?.provider === "ssm" && !data.name) ctx.addIssue({
-		code: "custom",
-		message: "Workspace name is required when using SSM state provider. Add \"name\" to your gkm.config.ts.",
-		path: ["name"]
-	});
 });
-/**
-* Validate workspace configuration.
-* Throws ZodError with detailed messages on validation failure.
-*/
-function validateWorkspaceConfig(config) {
-	return WorkspaceConfigSchema.parse(config);
-}
-/**
-* Safe validation that returns result instead of throwing.
-*/
-function safeValidateWorkspaceConfig(config) {
-	const result = WorkspaceConfigSchema.safeParse(config);
-	if (result.success) return {
-		success: true,
-		data: result.data
-	};
-	return {
-		success: false,
-		error: result.error
-	};
-}
-/**
-* Format Zod errors into user-friendly messages.
-*/
-function formatValidationErrors(error) {
-	return `Workspace configuration validation failed:\n${error.issues.map((issue) => {
-		const path = issue.path.join(".");
-		return path ? `  - ${path}: ${issue.message}` : `  - ${issue.message}`;
-	}).join("\n")}`;
-}
-//#endregion
-//#region src/workspace/types.ts
-/**
-* Type guard to check if a config is a WorkspaceConfig.
-*
-* @example
-* ```ts
-* const config = await loadConfig();
-* if (isWorkspaceConfig(config)) {
-*   // config.apps is available
-*   console.log(Object.keys(config.apps));
-* }
-* ```
-*/
-function isWorkspaceConfig(config) {
-	if (typeof config !== "object" || config === null) return false;
-	if ("apps" in config && typeof config.apps === "object") return true;
-	return "constructs" in config && Object.keys(config).every((key) => WORKSPACE_KEYS.has(key));
-}
-/** Every top-level key a workspace config has — see `WorkspaceConfigSchema`. */
-const WORKSPACE_KEYS = /* @__PURE__ */ new Set([
-	"name",
-	"constructs",
-	"apps",
-	"shared",
-	"deploy",
-	"stages",
-	"secrets",
-	"state"
-]);
-//#endregion
-//#region src/workspace/publicEnv.ts
-/**
-* All public env-var prefixes the toolbox understands.
-*
-* Used when resolving incoming var names back to a dependency
-* (e.g. `VITE_AUTH_URL` → `auth`). A var matching any of these
-* is considered safe to inline into a client bundle.
-*/
-const PUBLIC_ENV_PREFIXES = [
-	"NEXT_PUBLIC_",
-	"VITE_",
-	"EXPO_PUBLIC_"
-];
-/**
-* Resolve the public env-var prefix that a frontend framework's bundler
-* inlines into client code at build time:
-*
-*  - `nextjs`         → `NEXT_PUBLIC_`
-*  - `vite`           → `VITE_`
-*  - `tanstack-start` → `VITE_` (uses Vite under the hood)
-*  - `expo`           → `EXPO_PUBLIC_`
-*  - `remix`          → `''` (Remix exposes via loaders, no prefix convention)
-*
-* For backend frameworks or unspecified, falls back to `NEXT_PUBLIC_` to
-* preserve the historical default. Backend apps never read these vars
-* from a bundle, so the prefix only affects scaffolding/symmetry.
-*/
-function getPublicEnvPrefix(framework) {
-	switch (framework) {
-		case "vite":
-		case "tanstack-start": return "VITE_";
-		case "expo": return "EXPO_PUBLIC_";
-		case "remix": return "";
-		case "nextjs": return "NEXT_PUBLIC_";
-		default: return "NEXT_PUBLIC_";
+Object.defineProperty(exports, "record", {
+	enumerable: true,
+	get: function() {
+		return record;
 	}
-}
-/**
-* Strip a known public prefix from a var name.
-* Returns the un-prefixed name, or `null` if no prefix matched.
-*/
-function stripPublicPrefix(name) {
-	for (const prefix of PUBLIC_ENV_PREFIXES) if (prefix && name.startsWith(prefix)) return name.slice(prefix.length);
-	return null;
-}
-//#endregion
-//#region src/workspace/index.ts
-/**
-* Validate that all dependencies reference existing apps.
-* Returns the config if valid, throws otherwise.
-*/
-function validateDependencies(apps) {
-	const appNames = new Set(Object.keys(apps));
-	for (const [appName, app] of Object.entries(apps)) for (const dep of app.dependencies ?? []) {
-		if (!appNames.has(dep)) throw new Error(`Invalid dependency: App "${appName}" depends on "${dep}" which does not exist. Valid apps are: ${[...appNames].join(", ")}`);
-		if (dep === appName) throw new Error(`Invalid dependency: App "${appName}" cannot depend on itself.`);
+});
+Object.defineProperty(exports, "string", {
+	enumerable: true,
+	get: function() {
+		return string;
 	}
-}
-/**
-* Define workspace configuration with full TypeScript support and type inference.
-*
-* Uses `const` type parameter to infer literal app names, providing:
-* - Autocomplete for app names in dependencies
-* - Type errors for invalid dependency references
-* - Full type inference for the returned config
-*
-* @example
-* ```ts
-* // gkm.config.ts
-* import { defineWorkspace } from '@geekmidas/cli';
-*
-* export default defineWorkspace({
-*   name: 'my-saas',
-*   apps: {
-*     api: {
-*       type: 'backend',
-*       path: 'apps/api',
-*       port: 3000,
-*       routes: './src/endpoints/**\/*.ts',
-*       envParser: './src/config/env',
-*       logger: './src/logger',
-*     },
-*     web: {
-*       type: 'web',
-*       framework: 'nextjs',
-*       path: 'apps/web',
-*       port: 3001,
-*       dependencies: ['api'], // <- autocomplete shows 'api' | 'web'
-*     },
-*   },
-* });
-*
-* // config.apps.api <- full type inference
-* // config.apps.foo <- TypeScript error
-* ```
-*/
-function defineWorkspace(config) {
-	if (config.apps) validateDependencies(config.apps);
-	const result = safeValidateWorkspaceConfig(config);
-	if (!result.success && result.error) throw new Error(formatValidationErrors(result.error));
-	return config;
-}
-/**
-* Get the package name from package.json in the given directory.
-*/
-function getPackageName(cwd) {
-	try {
-		return __require(`${cwd}/package.json`).name?.replace(/^@[^/]+\//, "");
-	} catch {
-		return;
+});
+Object.defineProperty(exports, "tuple", {
+	enumerable: true,
+	get: function() {
+		return tuple;
 	}
-}
-/**
-* Normalize a workspace configuration with resolved defaults.
-*/
-function normalizeWorkspace(config, cwd) {
-	const name = config.name ?? getPackageName(cwd) ?? basename(cwd);
-	const defaultTarget = config.deploy?.default ?? "dokploy";
-	const normalizedApps = {};
-	for (const [appName, app] of Object.entries(config.apps ?? {})) normalizedApps[appName] = normalizeAppConfig(app, defaultTarget);
-	return {
-		name,
-		root: cwd,
-		...config.constructs ? { constructs: config.constructs } : {},
-		apps: normalizedApps,
-		deploy: config.deploy ?? { default: "dokploy" },
-		shared: config.shared ?? { packages: ["packages/*"] },
-		stages: validateStages(config.stages),
-		secrets: config.secrets ?? {},
-		state: config.state,
-		test: config.test ?? {},
-		...config.dev ? { dev: config.dev } : {}
-	};
-}
-/**
-* Normalize an app configuration with resolved defaults.
-* @param app - App configuration
-* @param defaultTarget - Default deploy target from workspace config
-*/
-function normalizeAppConfig(app, defaultTarget) {
-	return {
-		...app,
-		type: app.type ?? "backend",
-		port: app.port,
-		path: app.path,
-		dependencies: app.dependencies ?? [],
-		resolvedDeployTarget: app.deploy ?? defaultTarget
-	};
-}
-/**
-* Wrap a single-app GkmConfig as a workspace.
-* This allows existing single-app configs to work seamlessly.
-*/
-function wrapSingleAppAsWorkspace(config, cwd) {
-	return {
-		name: config.name ?? getPackageName(cwd) ?? basename(cwd),
-		root: cwd,
-		apps: { api: {
-			type: "backend",
-			path: ".",
-			port: 3e3,
-			dependencies: [],
-			resolvedDeployTarget: config.deploy?.default ?? "dokploy",
-			constructs: config.constructs,
-			hooks: config.hooks,
-			telescope: config.telescope,
-			openapi: config.openapi,
-			runtime: config.runtime,
-			env: config.env
-		} },
-		deploy: {
-			default: "dokploy",
-			...config.deploy
-		},
-		shared: { packages: [] },
-		stages: validateStages(config.stages),
-		secrets: config.secrets ?? {},
-		test: config.test ?? {},
-		...config.dev ? { dev: config.dev } : {}
-	};
-}
-/**
-* Process a loaded configuration (either single-app or workspace).
-* Returns a normalized workspace in both cases.
-*/
-function processConfig(config, cwd) {
-	if (isWorkspaceConfig(config)) {
-		const result = safeValidateWorkspaceConfig(config);
-		if (!result.success && result.error) throw new Error(formatValidationErrors(result.error));
-		return {
-			type: "workspace",
-			raw: config,
-			workspace: normalizeWorkspace(config, cwd)
-		};
+});
+Object.defineProperty(exports, "union", {
+	enumerable: true,
+	get: function() {
+		return union;
 	}
-	return {
-		type: "single",
-		raw: config,
-		workspace: wrapSingleAppAsWorkspace(config, cwd)
-	};
-}
-/**
-* The workspace's own constructs globs, absolute.
-*
-* Infrastructure two apps share is a fact about the product, and declaring it
-* inside one of them makes moving that app a change to the other's database.
-*/
-function workspaceConstructGlobs(workspace) {
-	return constructPatterns(workspace.constructs).map((pattern) => isAbsolute(pattern) ? pattern : join(workspace.root, pattern));
-}
-/**
-* Every constructs glob an app can see, absolute.
-*
-* The workspace's own first, then the app's. Absolute because the app builds
-* from its own directory while the workspace's constructs live above it —
-* a relative glob resolved from the app would look for the product's
-* infrastructure inside one of its consumers and find nothing.
-*
-* Additive, not overriding: an app that declares its own constructs still sees
-* the ones the workspace declared for everybody.
-*/
-function appConstructGlobs(workspace, appName) {
-	const globs = workspaceConstructGlobs(workspace);
-	const app = workspace.apps[appName];
-	if (app) {
-		const root = isAbsolute(app.path) ? app.path : join(workspace.root, app.path);
-		for (const pattern of constructPatterns(app.constructs)) globs.push(isAbsolute(pattern) ? pattern : join(root, pattern));
+});
+Object.defineProperty(exports, "unknown", {
+	enumerable: true,
+	get: function() {
+		return unknown;
 	}
-	return globs;
-}
-/**
-* Every constructs glob in the workspace: its own, plus each app's.
-*
-* One list, so what a deploy provisions and what an app's entry point
-* registers drivers for are read off the same globs.
-*/
-function allConstructGlobs(workspace) {
-	const globs = [...workspaceConstructGlobs(workspace), ...Object.keys(workspace.apps).flatMap((appName) => appConstructGlobs(workspace, appName))];
-	return [...new Set(globs)];
-}
-/** A `Routes` in any of its accepted shapes, as a flat list of patterns. */
-function constructPatterns(routes) {
-	if (!routes) return [];
-	return typeof routes === "string" ? [routes] : routes;
-}
-/**
-* Get the GkmConfig for a specific app in a workspace.
-* Useful for running existing single-app commands on a specific app.
-*/
-function getAppGkmConfig(workspace, appName) {
-	const app = workspace.apps[appName];
-	if (!app || app.type !== "backend") return;
-	return {
-		...workspace.deploy ? { deploy: workspace.deploy } : {},
-		stages: workspace.stages,
-		constructs: appConstructGlobs(workspace, appName),
-		hooks: app.hooks,
-		telescope: app.telescope,
-		openapi: app.openapi,
-		runtime: app.runtime,
-		env: app.env
-	};
-}
-/**
-* Get topologically sorted app names based on dependencies.
-* Apps with no dependencies come first, then apps that depend on them.
-*/
-function getAppBuildOrder(workspace) {
-	const appNames = Object.keys(workspace.apps);
-	const visited = /* @__PURE__ */ new Set();
-	const result = [];
-	function visit(name) {
-		if (visited.has(name)) return;
-		visited.add(name);
-		const app = workspace.apps[name];
-		if (app) for (const dep of app.dependencies) visit(dep);
-		result.push(name);
+});
+Object.defineProperty(exports, "url", {
+	enumerable: true,
+	get: function() {
+		return url;
 	}
-	for (const name of appNames) visit(name);
-	return result;
-}
-/**
-* Resolve the Dokploy endpoint for a specific stage.
-*
-* Uses per-stage endpoint from `endpoints` if available,
-* otherwise falls back to the global `endpoint`.
-*
-* @param dokployConfig - Dokploy workspace configuration
-* @param stage - Deployment stage (e.g., 'development', 'production')
-* @returns The endpoint URL for the stage, or undefined if not configured
-*
-* @example
-* ```ts
-* // With per-stage endpoints
-* const config = {
-*   endpoints: {
-*     development: 'https://dev.dokploy.example.com:3000',
-*     production: 'https://prod.dokploy.example.com:3000',
-*   },
-* };
-* getEndpointForStage(config, 'production'); // => 'https://prod.dokploy.example.com:3000'
-*
-* // With single endpoint
-* const config = { endpoint: 'https://dokploy.example.com:3000' };
-* getEndpointForStage(config, 'production'); // => 'https://dokploy.example.com:3000'
-* ```
-*/
-function getEndpointForStage(dokployConfig, stage) {
-	if (!dokployConfig) return void 0;
-	if (dokployConfig.endpoints?.[stage]) return dokployConfig.endpoints[stage];
-	return dokployConfig.endpoint;
-}
-//#endregion
-export { safeValidateWorkspaceConfig as C, assertDeployedStage as D, TEST_STAGE as E, deployedProblems as O, isPhase2DeployTarget as S, InvalidStages as T, SUPPORTED_DEPLOY_TARGETS as _, getAppBuildOrder as a, getDeployTargetError as b, normalizeWorkspace as c, wrapSingleAppAsWorkspace as d, PUBLIC_ENV_PREFIXES as f, PHASE_2_DEPLOY_TARGETS as g, isWorkspaceConfig as h, defineWorkspace as i, stageProblems as k, processConfig as l, stripPublicPrefix as m, appConstructGlobs as n, getAppGkmConfig as o, getPublicEnvPrefix as p, constructPatterns as r, getEndpointForStage as s, allConstructGlobs as t, workspaceConstructGlobs as u, WorkspaceConfigSchema as v, validateWorkspaceConfig as w, isDeployTargetSupported as x, formatValidationErrors as y };
+});
 
-//# sourceMappingURL=workspace-BFe57es7.mjs.map
+//# sourceMappingURL=schemas-Ckm_aBnF.cjs.map