@vibesdotdev/infra-core 0.0.1 → 1.0.0-rc.11

package/SPEC.md

@@ -1,169 +0,0 @@
-# @vibesdotdev/infra-core
-
-Provider-agnostic contract for deployable infrastructure. Defines the runtime
-kinds, descriptor schemas, and deployment factories that adapter packages and
-consuming apps share. Adapter packages
-([`infra-cloudflare`](../infra-cloudflare/SPEC.md),
-[`infra-doks`](../infra-doks/SPEC.md)) implement provider-specific behavior
-against these kinds; consumed by per-app `deployment.config.ts` files, by
-`*.infra.ts` resource declarations under workspace `infra/`, by
-[`secrets`](../secrets/SPEC.md) for env-requirement resolution, and by
-[`deploy`](../deploy/SPEC.md) for orchestration.
-
-## Owns
-
-- **Runtime kinds:** `infra/web-app`, `infra/worker`, `infra/database`,
-  `infra/queue`, `infra/cache`, `infra/object-storage`, `infra/sandbox`,
-  `infra/git-hosting`, `infra/package-registry`.
-- **Plugin descriptors registered by the plugin:** `infraPlugin` (id `infra`)
-  registers all 9 kinds with `discoveryPattern: "**/*.infra.ts"` and
-  pass-through default implementations exposing the validated descriptor as
-  `config`.
-- **Schemas** (`./schemas`): atomic Zod schemas — provider enum, runtime enum,
-  origin, build, env requirement, dependency, upstream — and the assembled
-  `appDeploymentSchema`. Single source of truth for cross-cutting shapes;
-  kind descriptor schemas compose from these primitives.
-- **Kind descriptors** (`./kinds`): one file per kind, each defining a Zod
-  descriptor schema (composed from `./schemas`) and a pass-through default
-  `Implementation` class wired through `createRuntimeKind`.
-- **Deployment factories** (`./deployment`): `createAppDeployment`,
-  `createDeploymentOrigin`, `createDeploymentEnvRequirement`,
-  `createDeploymentDependency`, `getPrimaryOrigin`, `getUpstreamOriginEnv`.
-  These produce the validated objects authored in per-app
-  `deployment.config.ts` files.
-
-## Does not own
-
-- Cloudflare Workers / Workers / Queues / R2 / KV implementations →
-  [`infra-cloudflare`](../infra-cloudflare/SPEC.md).
-- DigitalOcean App Platform / DOKS / Spaces / Managed DB / Managed Redis
-  implementations → [`infra-doks`](../infra-doks/SPEC.md).
-- Standalone Kubernetes / Docker / DO Droplet implementations — no adapter
-  package exists yet (see migration debt).
-- Deployment orchestration, manifest generation, env materialization, and the
-  `infra/` workspace tree (`infra/manifest.ts`, `infra/generate.ts`,
-  `infra/resources/`) → [`deploy`](../deploy/SPEC.md). Per-app
-  `deployment.config.ts` files live in `apps/<app>-web/`.
-- Env-requirement resolution against descriptors →
-  [`secrets`](../secrets/SPEC.md).
-- AI inference selection. Inference is an `ai/provider` + `ai/adapter`
-  concern — see [`ai`](../ai/SPEC.md) and
-  [`ai-providers`](../ai-providers/SPEC.md). No `infra/inference` kind exists
-  or should be added.
-
-## Hard rules
-
-- Core never imports adapter packages. Dependencies are exactly
-  `@vibesdotdev/runtime` + `zod`.
-- Shared shapes live in `./schemas`. Kind descriptor schemas compose from
-  `./schemas`. Do not redeclare an env-requirement schema or any other
-  primitive inside a kind file.
-- New deployable resource types are added as new kinds in `src/kinds/`.
-  Provider-specific concepts (Wrangler bindings, Helm values, Spaces CORS,
-  CF Sandbox outbound proxy specifics, etc.) belong in adapter packages
-  registering implementations against the existing kinds.
-- Inference is not an infra kind. New inference strategies (CF Unified
-  Inference, Agents bindings, etc.) are added as `ai/provider` descriptors +
-  adapters in [`ai-providers`](../ai-providers/SPEC.md).
-- Default implementations are inert pass-throughs that expose the validated
-  descriptor as `config`. Real provider behavior must come from an adapter
-  package registering an implementation for the same kind.
-- Kind discovery pattern is `**/*.infra.ts` for every kind. Apps and the
-  `infra/` workspace declare concrete resources in `*.infra.ts` files; do
-  not change the pattern per kind.
-- Pure TypeScript only. No `$env`, `$server`, `$app`, `@sveltejs/kit`,
-  Svelte, Drizzle, or filesystem APIs in this package.
-- `deploymentProviderSchema` enumerates exactly the providers backed by an
-  active adapter package. Adding a provider value without a corresponding
-  adapter is a contract lie — add the adapter or omit the value.
-- `appDeploymentSchema` cross-validates provider against runtime and origin
-  hostnames (e.g. `cloudflare-workers` requires `edge`; `digitalocean-app`
-  requires `node` or `worker`). Nonsense combinations fail at parse time,
-  not deploy time.
-
-## Migration debt (completed)
-
-- [x] `envRequirementSchema` is locally redeclared in
-  `src/kinds/web-app.kind.ts`, `src/kinds/worker.kind.ts`, and
-  `src/kinds/sandbox.kind.ts` instead of imported from `./schemas`.
-  **Resolution:** Kinds now import `deploymentEnvRequirementSchema` from `./schemas`.
-  All kind files use `import { z } from 'zod/v4'` style for consistency.
-- [x] `package.json#exports` includes `"./kinds/*": "./src/kinds/*.ts"`.
-  **Resolution:** Wildcard removed. All 26 consumers updated to use `./kinds`
-  aggregate subpath instead of deep imports.
-- [x] `deploymentProviderSchema` declares `digitalocean-droplet`,
-  `digitalocean-kubernetes`, `kubernetes`, and `docker`, but only
-  `digitalocean-app` (via `infra-doks`) and `cloudflare-workers` (via
-  `infra-cloudflare`) have active adapter implementations.
-  **Resolution:** Trimmed to only `cloudflare-workers` and `digitalocean-app`.
-- [x] `appDeploymentSchema` does not cross-validate provider against runtime.
-  **Resolution:** Added `.refine()` enforcing provider × runtime matrix:
-  - `cloudflare-workers`: `edge`, `worker`
-  - `digitalocean-app`: `node`, `worker`
-- [x] `discoveryPattern` and `extractStem` are duplicated identically across all
-  9 kind files.
-  **Resolution:** Extracted shared helper in `src/kinds/discovery.ts` with
-  `INFRA_DISCOVERY_PATTERN` constant and `extractStem()` function. All 7
-  kind files now import and reuse.
-- [x] `WebAppDescriptor` and `appDeploymentSchema` describe overlapping concepts
-  (`appDir`, `outputDir`, `runtime`, `env`).
-  **Resolution:** The parallel surfaces are **intentional**:
-  - `WebAppDescriptor` (runtime-discovered resource) lives at `infra/web-app`
-    kind with `adapter`, `domain`, `env`, etc. Used by runtime discovery.
-  - `appDeploymentSchema` (authored deployment config) lives in `./schemas` and
-    is used by `deployment.config.ts` files with `provider`, `build`, `origins`,
-    etc. Both shapes reference similar fields but serve different consumers.
-  No merging; keep parallel with potential future composition via shared
-  fragment schemas if divergence becomes problematic.
-
-## Migration debt
-
-- [x] **`adapter` discriminator → `config` field migration.** All 7 original
-  infra kinds declare `adapter: z.string()` as a top-level discriminator field.
-  This field is not in `RuntimeDescriptorSchema` and `createRuntimeAsset` could not
-  validate it. Every infra kind has moved `adapter` and all adapter-specific
-  fields into a `config` object validated against the kind's registered
-  `descriptorSchema`. **Affected kinds:** `infra/web-app`, `infra/worker`,
-  `infra/database`, `infra/queue`, `infra/cache`, `infra/object-storage`,
-  `infra/sandbox`, `infra/git-hosting`, `infra/package-registry`.
-  - [x] `infra/web-app`: added `WebAppConfigSchema` union
-    (cloudflare-workers, digitalocean-apps)
-  - [x] `infra/worker`: added `WorkerConfigSchema` union
-    (doks-deployment, cloudflare-workers)
-  - [x] `infra/database`: added `DatabaseConfigSchema` union
-    (doks-statefulset, do-managed-postgres, turso)
-  - [x] `infra/queue`: added `QueueConfigSchema` union
-    (doks-statefulset, cloudflare-queues)
-  - [x] `infra/cache`: added `CacheConfigSchema` union
-    (do-managed-redis, cloudflare-kv, doks-redis)
-  - [x] `infra/object-storage`: added `ObjectStorageConfigSchema` union
-    (do-spaces, cloudflare-r2)
-  - [x] `infra/sandbox`: already had all variants (cloudflare-sandbox, docker,
-    digitalocean-droplet)
-  - [x] `infra/git-hosting`: added `GitHostingConfigSchema` union (gitea-doks)
-  - [x] `infra/package-registry`: added `PackageRegistryConfigSchema` union
-    (verdaccio-doks)
-
-## Public entrypoints
-
-`.`, `./schemas`, `./kinds`, `./deployment`, `./plugin`.
-
-Wildcard / migration-era subpaths: `./kinds/*` — do not normalize new code
-against this.
-
-## Verification
-
-`bun test` from `packages/infra-core`. Covers all 9 schemas (accept-valid +
-reject-invalid), all 9 kind descriptor structures, plugin registration shape
-(id, kinds count, kind IDs, discovery pattern, no dependencies, no lifecycle
-hooks), and all 6 factory functions. `bun --bun tsc -p tsconfig.json
---noEmit` is the type gate.
-
-## Links
-
-- [infra-cloudflare/SPEC.md](../infra-cloudflare/SPEC.md)
-- [infra-doks/SPEC.md](../infra-doks/SPEC.md)
-- [deploy/SPEC.md](../deploy/SPEC.md)
-- [secrets/SPEC.md](../secrets/SPEC.md)
-- [runtime/SPEC.md](../runtime/SPEC.md)
-- [ai/SPEC.md](../ai/SPEC.md), [ai-providers/SPEC.md](../ai-providers/SPEC.md)

package/src/bootstrap/index.ts

@@ -1,15 +0,0 @@
-export { bootstrapSeedKind } from './seed.kind.ts';
-export {
-	bootstrapSeedConditionSchema,
-	bootstrapSeedDescriptorSchema,
-	bootstrapSeedModeSchema,
-	type BootstrapSeedCondition,
-	type BootstrapSeedDescriptor,
-	type BootstrapSeedMode
-} from './seed.descriptor.ts';
-export type { BootstrapSeedImpl } from './seed.impl-shape.ts';
-export {
-	runBootstrapSeeds,
-	type BootstrapSeedRunOptions,
-	type BootstrapSeedRunResult
-} from './seed.runner.ts';

package/src/bootstrap/seed.descriptor.ts

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-
-export const bootstrapSeedModeSchema = z.enum(['cold-start', 'deploy']);
-export type BootstrapSeedMode = z.infer<typeof bootstrapSeedModeSchema>;
-
-export const bootstrapSeedConditionSchema = z.discriminatedUnion('kind', [
-	z.object({ kind: z.literal('always') }),
-	z.object({
-		kind: z.literal('env-keys-present'),
-		keys: z.array(z.string().min(1)).min(1)
-	})
-]);
-export type BootstrapSeedCondition = z.infer<typeof bootstrapSeedConditionSchema>;
-
-export const bootstrapSeedDescriptorSchema = z.object({
-	kind: z.literal('bootstrap/seed'),
-	id: z.string().min(1),
-	description: z.string().optional(),
-	executeOn: z.array(bootstrapSeedModeSchema).min(1),
-	condition: bootstrapSeedConditionSchema.optional(),
-	priority: z.number().int().optional()
-});
-
-export type BootstrapSeedDescriptor = z.infer<typeof bootstrapSeedDescriptorSchema>;

package/src/bootstrap/seed.impl-shape.ts

@@ -1,5 +0,0 @@
-import type { VibesRuntime } from '@vibesdotdev/runtime';
-
-export interface BootstrapSeedImpl {
-	run(runtime: VibesRuntime, env: Record<string, string | undefined>): Promise<void>;
-}

package/src/bootstrap/seed.kind.ts

@@ -1,26 +0,0 @@
-import type { RuntimeDescriptor, RuntimeKindDescriptor } from '@vibesdotdev/runtime/schemas/kind';
-import {
-	bootstrapSeedDescriptorSchema,
-	type BootstrapSeedDescriptor
-} from './seed.descriptor.ts';
-import type { BootstrapSeedImpl } from './seed.impl-shape.ts';
-
-class UnregisteredBootstrapSeed implements BootstrapSeedImpl {
-	constructor(_descriptor: RuntimeDescriptor) {}
-	async run(): Promise<void> {
-		// No-op when no impl loader is registered for this descriptor id.
-	}
-}
-
-export const bootstrapSeedKind: RuntimeKindDescriptor<
-	BootstrapSeedDescriptor,
-	BootstrapSeedImpl,
-	never
-> = {
-	id: 'bootstrap/seed',
-	descriptorSchema: bootstrapSeedDescriptorSchema,
-	defaultImplementation: UnregisteredBootstrapSeed as unknown as new (
-		descriptor: RuntimeDescriptor
-	) => BootstrapSeedImpl,
-	contexts: []
-};

package/src/bootstrap/seed.runner.ts

@@ -1,87 +0,0 @@
-import type { VibesRuntime } from '@vibesdotdev/runtime';
-import { getLogger } from '@vibesdotdev/logging';
-import type {
-	BootstrapSeedCondition,
-	BootstrapSeedDescriptor,
-	BootstrapSeedMode
-} from './seed.descriptor.ts';
-import type { BootstrapSeedImpl } from './seed.impl-shape.ts';
-
-const log = getLogger('infra.bootstrap.seed');
-
-export interface BootstrapSeedRunResult {
-	ran: string[];
-	skipped: Array<{ id: string; reason: string }>;
-	failed: Array<{ id: string; error: string }>;
-}
-
-export interface BootstrapSeedRunOptions {
-	env: Record<string, string | undefined>;
-}
-
-export async function runBootstrapSeeds(
-	runtime: VibesRuntime,
-	mode: BootstrapSeedMode,
-	options: BootstrapSeedRunOptions
-): Promise<BootstrapSeedRunResult> {
-	const allDescriptors = runtime
-		.assets('bootstrap/seed')
-		.descriptors() as unknown as readonly BootstrapSeedDescriptor[];
-
-	const result: BootstrapSeedRunResult = { ran: [], skipped: [], failed: [] };
-	const runnable: BootstrapSeedDescriptor[] = [];
-
-	for (const descriptor of allDescriptors) {
-		if (!descriptor.executeOn.includes(mode)) {
-			result.skipped.push({
-				id: descriptor.id,
-				reason: `mode ${mode} not in executeOn`
-			});
-			continue;
-		}
-		if (!evaluateCondition(descriptor.condition, options.env)) {
-			result.skipped.push({
-				id: descriptor.id,
-				reason: 'condition not met'
-			});
-			continue;
-		}
-		runnable.push(descriptor);
-	}
-
-	runnable.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
-
-	for (const descriptor of runnable) {
-		try {
-			const impl = (await runtime
-				.query('bootstrap/seed')
-				.withId(descriptor.id)
-				.resolve()) as BootstrapSeedImpl;
-			await impl.run(runtime, options.env);
-			result.ran.push(descriptor.id);
-			log.info('bootstrap seed completed', {
-				id: descriptor.id,
-				mode,
-				priority: descriptor.priority ?? 100
-			});
-		} catch (err) {
-			const error = err instanceof Error ? err.message : String(err);
-			result.failed.push({ id: descriptor.id, error });
-			log.error('bootstrap seed failed', { id: descriptor.id, mode, error });
-		}
-	}
-
-	return result;
-}
-
-function evaluateCondition(
-	condition: BootstrapSeedCondition | undefined,
-	env: Record<string, string | undefined>
-): boolean {
-	if (!condition) return true;
-	if (condition.kind === 'always') return true;
-	if (condition.kind === 'env-keys-present') {
-		return condition.keys.every((key) => Boolean(env[key]));
-	}
-	return true;
-}

package/src/credentials/resolve.ts

@@ -1,205 +0,0 @@
-/**
- * Provider-agnostic credential resolution for infra/* adapters.
- *
- * Routes through the `secrets/store` runtime kind so every adapter
- * (alerts, RUM, observability, …) reads from the same credential chain
- * the rest of the platform uses. The chain (highest precedence first):
- *
- *   1. process.env (CI / explicit overrides)
- *   2. The tier-resolved secrets/store implementation
- *      - local tier   → encrypted-local → env-file
- *      - production   → cloudflare-secrets-store → cloudflare-api
- *
- * Adapters declare the secret KEY NAMES (e.g. CLOUDFLARE_API_TOKEN) on
- * their descriptor's `adapterConfig` and use this helper to resolve
- * the values. The helper supports `keyCandidates` for fallback chains
- * (e.g. prefer a scoped CLOUDFLARE_NOTIFICATIONS_API_TOKEN, fall back
- * to the broad CLOUDFLARE_API_TOKEN).
- *
- * Why a helper instead of inlining the secrets/store query: provider
- * adapters live in different packages and shouldn't all duplicate the
- * tier-walk + env-overlay logic. Keeping it in infra-core makes the
- * abstraction explicit ("infra/* adapters route credentials through
- * vibes secrets") and gives us one place to evolve the chain (e.g.
- * adding 1Password CLI as a backend).
- */
-
-import { getVibesRuntime } from '@vibesdotdev/runtime';
-
-export type EnvironmentTier = 'local' | 'dev' | 'staging' | 'production';
-
-export interface ResolveAdapterCredentialOptions {
-	/**
-	 * Ordered list of candidate keys. First one that resolves to a
-	 * non-empty value wins. Useful for scoped → fallback patterns:
-	 *   ['CLOUDFLARE_NOTIFICATIONS_API_TOKEN', 'CLOUDFLARE_API_TOKEN']
-	 */
-	keyCandidates: readonly string[];
-	/**
-	 * Environment name to read from the secrets store (default: 'local').
-	 * Maps onto vault.environments[name] in encrypted-local.
-	 */
-	environment?: string;
-	/**
-	 * Tier hint for runtime store selection. Defaults to inferring from
-	 * the environment name when it matches a known tier; falls back to
-	 * 'local' otherwise.
-	 */
-	tier?: EnvironmentTier;
-	/**
-	 * Whether to consult process.env first. Defaults true — CI/CD and
-	 * explicit shell overrides should win. Pass false to force
-	 * store-only resolution.
-	 */
-	includeProcessEnv?: boolean;
-	/**
-	 * Optional human-readable name for the credential, used in error
-	 * messages when no candidate resolves (e.g. "Cloudflare API token").
-	 */
-	humanName?: string;
-}
-
-export interface ResolvedAdapterCredential {
-	/** The KEY that resolved (one of keyCandidates). Useful for audit. */
-	key: string;
-	/** The resolved secret value. Never logged. */
-	value: string;
-	/** Where the value came from: 'process.env' or the store backend id. */
-	source: string;
-}
-
-interface SecretsStoreImplShape {
-	id?: string;
-	get?(environment: string, key: string): Promise<string | undefined>;
-}
-
-interface SecretsStoreDescriptorShape {
-	id: string;
-	priority?: number;
-	tiers?: readonly EnvironmentTier[] | EnvironmentTier[];
-}
-
-/**
- * Tier-aware backend selection. Mirrors the secrets/store kind's own
- * resolver (`packages/secrets/src/kinds/store.kind.ts`) so callers
- * don't need to import internal helpers.
- */
-function pickBackend(
-	descriptors: SecretsStoreDescriptorShape[],
-	tier: EnvironmentTier
-): SecretsStoreDescriptorShape | undefined {
-	if (descriptors.length === 0) return undefined;
-	const matches = descriptors.filter((d) => (d.tiers ?? []).includes(tier));
-	const pool = matches.length > 0 ? matches : descriptors;
-	pool.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
-	return pool[0];
-}
-
-function inferTier(environment: string, override?: EnvironmentTier): EnvironmentTier {
-	if (override) return override;
-	if (environment === 'local' || environment === 'dev' || environment === 'staging' || environment === 'production') {
-		return environment;
-	}
-	return 'local';
-}
-
-/**
- * Resolve a single credential by walking the candidate keys against
- * process.env then the active secrets store. Returns the first match.
- *
- * Throws when no candidate resolves — adapters should let this bubble
- * up so the CLI surfaces a clean "missing credentials" message rather
- * than a vague "401 Unauthorized" downstream.
- */
-export async function resolveAdapterCredential(
-	options: ResolveAdapterCredentialOptions
-): Promise<ResolvedAdapterCredential> {
-	const env = options.environment ?? 'local';
-	const tier = inferTier(env, options.tier);
-	const includeEnv = options.includeProcessEnv ?? true;
-
-	// 1. process.env (CI / shell override)
-	if (includeEnv) {
-		for (const key of options.keyCandidates) {
-			const v = process.env[key];
-			if (v && v.length > 0) {
-				return { key, value: v, source: 'process.env' };
-			}
-		}
-	}
-
-	// 2. secrets/store runtime resolution (tier-aware, priority-ordered)
-	const runtime = getVibesRuntime();
-	if (!runtime.hasKind('secrets/store')) {
-		throw new Error(
-			`No secrets/store kind registered; cannot resolve ${options.humanName ?? options.keyCandidates[0]}. ` +
-				'Load the secrets plugin (and a backend like encrypted-local) before calling this adapter.'
-		);
-	}
-
-	const descriptors = runtime
-		.assets('secrets/store')
-		.descriptors() as SecretsStoreDescriptorShape[];
-	// `VIBES_DEBUG_SECRETS=1` dumps the visible descriptor pool when
-	// you're tracing why a credential is missing or getting misrouted.
-	if (process.env.VIBES_DEBUG_SECRETS === '1') {
-		console.error(`[secrets-debug] descriptors visible at tier=${tier}:`);
-		for (const d of descriptors) {
-			console.error(`  - id=${d.id} priority=${d.priority ?? '-'} tiers=${JSON.stringify(d.tiers)}`);
-		}
-	}
-	const target = pickBackend(descriptors, tier);
-	if (!target) {
-		throw new Error(
-			`No secrets/store backend available for tier=${tier}. Register a backend ` +
-				'(encrypted-local for local, cloudflare-secrets-store for production) before calling this adapter.'
-		);
-	}
-
-	const store = (await runtime
-		.query('secrets/store')
-		.withId(target.id)
-		.resolve()) as SecretsStoreImplShape;
-
-	if (!store || typeof store.get !== 'function') {
-		throw new Error(
-			`Resolved secrets/store '${target.id}' has no get() method for ${options.humanName ?? options.keyCandidates[0]}.`
-		);
-	}
-
-	for (const key of options.keyCandidates) {
-		try {
-			const v = await store.get(env, key);
-			if (v && v.length > 0) {
-				return { key, value: v, source: target.id };
-			}
-		} catch {
-			// next candidate
-		}
-	}
-
-	throw new Error(
-		`Missing credential: none of [${options.keyCandidates.join(', ')}] resolved from process.env or ` +
-			`${target.id} (environment=${env}, tier=${tier}). ` +
-			`Set the value with \`vibes secrets set --environment ${env} ${options.keyCandidates[0]} <value>\`.`
-	);
-}
-
-/**
- * Convenience wrapper for resolving multiple credentials at once.
- * Each key gets a candidate list of one (the key itself). Use the
- * single-credential form when you need fallback chains.
- */
-export async function resolveAdapterCredentials(
-	keys: readonly string[],
-	options?: Omit<ResolveAdapterCredentialOptions, 'keyCandidates' | 'humanName'>
-): Promise<Record<string, ResolvedAdapterCredential>> {
-	const out: Record<string, ResolvedAdapterCredential> = {};
-	for (const key of keys) {
-		out[key] = await resolveAdapterCredential({
-			keyCandidates: [key],
-			...(options ?? {})
-		});
-	}
-	return out;
-}

package/src/deployment.ts

@@ -1,57 +0,0 @@
-import {
-	appDeploymentSchema,
-	deploymentDependencySchema,
-	deploymentEnvRequirementSchema,
-	deploymentOriginSchema,
-	type AppDeployment,
-	type AppDeploymentInput,
-	type DeploymentDependency,
-	type DeploymentEnvRequirement,
-	type DeploymentOrigin,
-	type DeploymentUpstream
-} from './schemas.ts';
-
-export function createAppDeployment(input: AppDeploymentInput): AppDeployment {
-	return appDeploymentSchema.parse(input);
-}
-
-export function createDeploymentOrigin(input: DeploymentOrigin): DeploymentOrigin {
-	return deploymentOriginSchema.parse(input);
-}
-
-export function createDeploymentEnvRequirement(
-	input: DeploymentEnvRequirement
-): DeploymentEnvRequirement {
-	return deploymentEnvRequirementSchema.parse(input);
-}
-
-export function createDeploymentDependency(input: DeploymentDependency): DeploymentDependency {
-	return deploymentDependencySchema.parse(input);
-}
-
-export function getPrimaryOrigin(deployment: AppDeployment): DeploymentOrigin {
-	return (
-		deployment.origins.find((origin) => origin.kind === 'primary') ?? deployment.origins[0]
-	);
-}
-
-export function getUpstreamOriginEnv(
-	upstream: DeploymentUpstream
-): Record<string, string> {
-	if (!upstream.originEnvVar) {
-		return {};
-	}
-
-	return {
-		[upstream.originEnvVar]: upstream.origin
-	};
-}
-
-export type {
-	AppDeployment,
-	AppDeploymentInput,
-	DeploymentDependency,
-	DeploymentEnvRequirement,
-	DeploymentOrigin,
-	DeploymentUpstream
-};