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

package/src/index.ts

@@ -1,149 +0,0 @@
-export {
-	createAppDeployment,
-	createDeploymentOrigin,
-	createDeploymentEnvRequirement,
-	createDeploymentDependency,
-	getPrimaryOrigin,
-	getUpstreamOriginEnv
-} from './deployment.ts';
-export type {
-	AppDeployment,
-	AppDeploymentInput,
-	DeploymentDependency,
-	DeploymentEnvRequirement,
-	DeploymentOrigin,
-	DeploymentUpstream
-} from './deployment.ts';
-export {
-	deploymentProviderSchema,
-	appRuntimeSchema,
-	deploymentOriginSchema,
-	deploymentBuildSchema,
-	deploymentEnvRequirementSchema,
-	deploymentDependencySchema,
-	deploymentUpstreamSchema,
-	appDeploymentSchema
-} from './schemas.ts';
-export type {
-	DeploymentProvider,
-	AppRuntime,
-	DeploymentOrigin as DeploymentOriginType,
-	DeploymentBuild,
-	DeploymentEnvRequirement as DeploymentEnvRequirementType,
-	DeploymentDependency as DeploymentDependencyType,
-	DeploymentUpstream as DeploymentUpstreamType,
-	AppDeploymentInput as AppDeploymentInputType,
-	AppDeployment as AppDeploymentType
-} from './schemas.ts';
-export {
-	webAppKind, WebAppDescriptorSchema, WebAppConfigSchema, CloudflareWorkersWebAppConfigSchema, DigitalOceanAppWebAppConfigSchema
-} from './kinds/index.ts';
-export type { WebAppDescriptor, WebAppDependency } from './kinds/index.ts';
-export {
-	workerKind, WorkerDescriptorSchema, WorkerConfigSchema, DoksDeploymentWorkerConfigSchema, WorkerScalingSchema
-} from './kinds/index.ts';
-export type { WorkerDescriptor, WorkerScaling } from './kinds/index.ts';
-export {
-	databaseKind, DatabaseDescriptorSchema, DatabaseConfigSchema, DoksDatabaseConfigSchema, DOManagedPostgresConfigSchema, TursoDatabaseConfigSchema, CloudflareD1ConfigSchema, DatabaseBackupSchema
-} from './kinds/index.ts';
-export type { DatabaseDescriptor, DatabaseBackup } from './kinds/index.ts';
-export {
-	queueKind, QueueDescriptorSchema, QueueConfigSchema, DoksQueueConfigSchema, QueueTopicSchema
-} from './kinds/index.ts';
-export type { QueueDescriptor, QueueTopic } from './kinds/index.ts';
-export { cacheKind, CacheDescriptorSchema, CacheConfigSchema, DOManagedRedisConfigSchema } from './kinds/index.ts';
-export type { CacheDescriptor } from './kinds/index.ts';
-export {
-	objectStorageKind, ObjectStorageDescriptorSchema, ObjectStorageConfigSchema, DOSpacesConfigSchema, CorsRuleSchema, LifecycleRuleSchema
-} from './kinds/index.ts';
-export type { ObjectStorageDescriptor, CorsRule, LifecycleRule } from './kinds/index.ts';
-export {
-	sandboxKind, SandboxDescriptorSchema, SandboxConfigSchema, CloudflareSandboxConfigSchema, DockerSandboxConfigSchema, DigitalOceanDropletSandboxConfigSchema, SandboxOutboundProxySchema, SandboxResourceLimitsSchema
-} from './kinds/index.ts';
-export type { SandboxDescriptor, SandboxOutboundProxy, SandboxResourceLimits } from './kinds/index.ts';
-export {
-	gitHostingKind, GitHostingDescriptorSchema, GitHostingConfigSchema, GiteaDoksGitHostingConfigSchema, GitHostingTypeSchema, GitHostingAuthMethodSchema
-} from './kinds/index.ts';
-export type { GitHostingDescriptor, GitHostingType, GitHostingAuthMethod } from './kinds/index.ts';
-export {
-	packageRegistryKind, PackageRegistryDescriptorSchema, PackageRegistryConfigSchema, VerdaccioDoksPackageRegistryConfigSchema, PackageRegistryTypeSchema
-} from './kinds/index.ts';
-export type { PackageRegistryDescriptor, PackageRegistryType } from './kinds/index.ts';
-export {
-	logsKind, InfraLogsDescriptorSchema, type InfraLogsDescriptor, type InfraLogsDescriptorInput, type InfraLogsKind, type InfraLogsKindInput, type LogsImplementation
-} from './kinds/index.ts';
-export {
-	artifactKind,
-	ArtifactDescriptorSchema,
-	type ArtifactDescriptor,
-	type ArtifactGenerator,
-	type ArtifactOutput
-} from './kinds/index.ts';
-export { INFRA_DISCOVERY_PATTERN, extractStem } from './kinds/index.ts';
-export {
-	alertsKind,
-	InfraAlertsDescriptorSchema,
-	AlertPolicySchema,
-	AlertMechanismSchema,
-	AlertTypeSchema,
-	AlertWindowSchema,
-	type InfraAlertsDescriptor,
-	type InfraAlertsDescriptorInput,
-	type InfraAlertsKind,
-	type InfraAlertsKindInput,
-	type AlertsImplementation,
-	type AlertPolicy,
-	type AlertMechanism,
-	type AlertType
-} from './kinds/index.ts';
-export {
-	observabilityKind,
-	InfraObservabilityDescriptorSchema,
-	ObservabilityScopeSchema,
-	ObservabilitySettingsSchema,
-	type InfraObservabilityDescriptor,
-	type InfraObservabilityDescriptorInput,
-	type InfraObservabilityKind,
-	type InfraObservabilityKindInput,
-	type ObservabilityImplementation,
-	type ObservabilityScope,
-	type ObservabilitySettings,
-	type ObservabilitySnapshot,
-	type SetObservabilityInput,
-	type SetObservabilityResult
-} from './kinds/index.ts';
-export {
-	rumKind,
-	InfraRumDescriptorSchema,
-	RumPrivacySchema,
-	RumInjectionSchema,
-	type InfraRumDescriptor,
-	type InfraRumDescriptorInput,
-	type InfraRumKind,
-	type InfraRumKindInput,
-	type RumImplementation,
-	type RumSiteSnapshot,
-	type RumPrivacy,
-	type RumInjection
-} from './kinds/index.ts';
-export {
-	resolveAdapterCredential,
-	resolveAdapterCredentials,
-	type EnvironmentTier,
-	type ResolveAdapterCredentialOptions,
-	type ResolvedAdapterCredential
-} from './credentials/resolve.ts';
-export {
-	bootstrapSeedKind,
-	bootstrapSeedConditionSchema,
-	bootstrapSeedDescriptorSchema,
-	bootstrapSeedModeSchema,
-	runBootstrapSeeds,
-	type BootstrapSeedCondition,
-	type BootstrapSeedDescriptor,
-	type BootstrapSeedImpl,
-	type BootstrapSeedMode,
-	type BootstrapSeedRunOptions,
-	type BootstrapSeedRunResult
-} from './bootstrap/index.ts';
-export { default as infraPlugin } from './infra.plugin';

package/src/infra.plugin.ts

@@ -1,54 +0,0 @@
-/**
- * Infrastructure Runtime Plugin
- *
- * Registers all infra resource kinds with the runtime.
- */
-
-import { createRuntimePlugin } from '@vibesdotdev/runtime/factory/plugin';
-import { webAppKind } from './kinds/web-app.kind';
-import { workerKind } from './kinds/worker.kind';
-import { databaseKind } from './kinds/database.kind';
-import { queueKind } from './kinds/queue.kind';
-import { cacheKind } from './kinds/cache.kind';
-import { objectStorageKind } from './kinds/object-storage.kind';
-import { sandboxKind } from './kinds/sandbox.kind';
-import { gitHostingKind } from './kinds/git-hosting.kind';
-import { packageRegistryKind } from './kinds/package-registry.kind';
-import { logsKind } from './kinds/logs.kind';
-import { alertsKind } from './kinds/alerts.kind.ts';
-import { observabilityKind } from './kinds/observability.kind.ts';
-import { rumKind } from './kinds/rum.kind.ts';
-import { bootstrapSeedKind } from './bootstrap/index.ts';
-
-/**
- * Note on layering: inference is an apps/ai domain concern, not an infra kind.
- * Existing runtime kinds `ai/provider`, `ai/adapter`, `ai/model`, and
- * `ai/generation` already express "who/how/where inference runs", and the
- * runtime's hardware scope + connectionMode qualifier + priority already
- * select between consumer-direct, consumer-worker, cloud-worker, and
- * cloud-via-API strategies. New strategies (CF Unified Inference, Agents
- * Week bindings) should be added as new `ai/provider` descriptors + adapters,
- * not as a parallel `infra/inference` kind.
- */
-
-export default createRuntimePlugin({
-	id: 'infra',
-	name: 'Infrastructure',
-	description: 'Resource kinds for deployable infrastructure',
-	kinds: [
-		webAppKind,
-		workerKind,
-		databaseKind,
-		queueKind,
-		cacheKind,
-		objectStorageKind,
-		sandboxKind,
-		gitHostingKind,
-		packageRegistryKind,
-		logsKind,
-		alertsKind,
-		observabilityKind,
-		rumKind,
-		bootstrapSeedKind
-	]
-});

package/src/kinds/alerts.kind.ts

@@ -1,164 +0,0 @@
-/**
- * Infra Alerts Kind
- *
- * Provider-agnostic schema for alerting / notification policies that
- * span billing (budget + per-product usage), reliability (error rate,
- * latency), and operational lifecycle (deploys, subscription changes).
- *
- * Per-provider implementations (cloudflare-alerts, do-monitoring,
- * cloudwatch-alarms) map this shape onto the native API. Where a
- * provider doesn't support a `type`, the impl rejects with a clear
- * "unsupported" error rather than silently falling back.
- *
- * Configuration is declarative — typically encoded in an
- * `infra/account.config.ts` or `infra/alerts.infra.ts` file alongside
- * `infra/dns.ts`. The CLI (`vibes infra alerts list|create|delete`)
- * wraps the same primitive for one-off ops and drift detection.
- */
-
-import * as z from 'zod/v4';
-import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
-import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
-import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
-
-/**
- * Delivery channel for an alert. Provider impls translate these to
- * native delivery slots (e.g. CF's `mechanisms.email[]`).
- */
-const AlertMechanismSchema = z.discriminatedUnion('kind', [
-	z.object({
-		kind: z.literal('email'),
-		/** Email address — must be a verified destination on the provider. */
-		target: z.email()
-	}),
-	z.object({
-		kind: z.literal('webhook'),
-		/** Outbound webhook URL. */
-		target: z.string().url(),
-		/** Optional secret name (in the active secrets store) used for HMAC signing. */
-		secretRef: z.string().optional()
-	}),
-	z.object({
-		kind: z.literal('pagerduty'),
-		/** PagerDuty integration key (Events API v2). */
-		target: z.string().min(1)
-	}),
-	z.object({
-		kind: z.literal('slack'),
-		/** Slack webhook URL (Incoming Webhooks). */
-		target: z.string().url()
-	})
-]);
-
-export type AlertMechanism = z.infer<typeof AlertMechanismSchema>;
-
-/**
- * Cross-provider alert categories. Each maps to one or more native
- * alert types per provider.
- */
-const AlertTypeSchema = z.enum([
-	/** Total cost crossed a dollar threshold for the current billing period. */
-	'budget',
-	/** Per-product usage crossed a numeric threshold (events/req/GB/etc.). */
-	'usage',
-	/** Worker/service error rate over a rolling window. */
-	'error-rate',
-	/** P99 latency or wall-time crossed a threshold. */
-	'latency',
-	/** Catch-all for provider-specific types not yet modeled here. */
-	'custom'
-]);
-
-export type AlertType = z.infer<typeof AlertTypeSchema>;
-
-const AlertWindowSchema = z.enum(['5m', '15m', '1h', '6h', '24h', '7d', '30d']);
-
-const AlertPolicySchema = z.object({
-	/** Stable id for diffing. Auto-generated when omitted. */
-	id: z.string().min(1).optional(),
-	/** Human-readable name (also surfaced by the provider). */
-	name: z.string().min(1),
-	type: AlertTypeSchema,
-	/**
-	 * Threshold value. `budget` reads it as USD (or local currency).
-	 * `usage`/`error-rate`/`latency` read it as units defined by the
-	 * filter (event count, %, ms).
-	 */
-	threshold: z.number().nonnegative(),
-	/** Optional secondary threshold for tiered alerts. */
-	warningThreshold: z.number().nonnegative().optional(),
-	/** Rolling window for `usage`/`error-rate`/`latency`. Ignored for `budget`. */
-	window: AlertWindowSchema.optional(),
-	/**
-	 * Adapter-specific filters. Examples:
-	 *   { product: 'workers_observability' }     // usage on a specific CF product
-	 *   { worker: 'vibes-account' }              // error-rate scoped to one worker
-	 *   { native_alert_type: 'health_check_status_notification' } // custom escape
-	 */
-	filters: z.record(z.string(), z.string()).default({}),
-	mechanisms: z.array(AlertMechanismSchema).min(1),
-	enabled: z.boolean().default(true),
-	description: z.string().optional()
-});
-
-export type AlertPolicy = z.infer<typeof AlertPolicySchema>;
-
-const AlertsBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/alerts'),
-	/** Adapter id (e.g. 'cloudflare-alerts', 'do-monitoring'). */
-	adapter: z.string().min(1),
-	adapterConfig: z.record(z.string(), z.unknown()).optional(),
-	/**
-	 * Default environment name for credential resolution via `vibes
-	 * secrets`. Defaults to 'local' since the CLI / dev workflow is
-	 * the primary caller; production Workers that consume this adapter
-	 * read credentials from CF Secrets Store bindings directly, not
-	 * through this descriptor.
-	 */
-	environment: z.string().default('local'),
-	policies: z.array(AlertPolicySchema).default([])
-});
-
-export type InfraAlertsDescriptor = z.infer<typeof AlertsBaseSchema>;
-export type InfraAlertsDescriptorInput = z.input<typeof AlertsBaseSchema>;
-
-/**
- * Implementation contract every provider implements. Operations are
- * idempotent: `applyPolicies` reconciles the live policy set to the
- * desired set without trampling unrelated policies on the provider.
- */
-export interface AlertsImplementation {
-	/** List policies currently configured on the provider. */
-	listPolicies(): Promise<Array<AlertPolicy & { providerId: string }>>;
-	/** Create a single policy. Returns the provider-assigned id. */
-	createPolicy(policy: AlertPolicy): Promise<{ providerId: string }>;
-	/** Delete a policy by provider id. */
-	deletePolicy(providerId: string): Promise<void>;
-	/**
-	 * Diff desired (descriptor) against live; return the set of policies
-	 * that need create/update/delete. Empty arrays = in sync.
-	 */
-	diff(desired: AlertPolicy[]): Promise<{
-		create: AlertPolicy[];
-		update: Array<{ providerId: string; policy: AlertPolicy }>;
-		delete: Array<{ providerId: string; name: string }>;
-	}>;
-}
-
-export const alertsKind = createRuntimeKind<InfraAlertsDescriptor, AlertsImplementation>({
-	id: 'infra/alerts',
-	descriptorSchema: AlertsBaseSchema,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});
-
-export type InfraAlertsKind = InfraAlertsDescriptor;
-export type InfraAlertsKindInput = InfraAlertsDescriptorInput;
-
-export {
-	AlertsBaseSchema as InfraAlertsDescriptorSchema,
-	AlertPolicySchema,
-	AlertMechanismSchema,
-	AlertTypeSchema,
-	AlertWindowSchema
-};

package/src/kinds/artifact.kind.ts

@@ -1,96 +0,0 @@
-/**
- * Kind: infra/artifact
- *
- * Generic descriptor for generatable infrastructure artifacts.
- *
- * This kind is intentionally unopinionated about what gets generated.
- * Adapter implementations (infra-kubernetes, infra-helm, infra-cloudflare, etc.)
- * define their own descriptor shapes and generation logic.
- *
- * Usage pattern:
- * 1. Adapters register artifact generators with custom descriptors
- * 2. Query: runtime.query('infra/artifact').all()
- * 3. Resolve implementation and call its generate method
- * 4. Implementation returns artifact content (format determined by impl)
- */
-import * as z from 'zod/v4';
-import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
-import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
-import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
-import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
-
-/**
- * Minimal base schema for artifact descriptors.
- *
- * Implementations extend this with their own fields (source resources,
- * output format, generation options, etc.).
- */
-const ArtifactBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/artifact')
-});
-
-/**
- * Generic artifact generator interface.
- *
- * Implementations define their own input/output shapes.
- */
-export interface ArtifactGenerator {
-	/**
-	 * Generate artifact content.
-	 *
-	 * @param options - Implementation-specific options (descriptor, context, etc.)
-	 * @returns Generated artifact (content + metadata)
-	 */
-	generate(options?: unknown): Promise<ArtifactOutput>;
-}
-
-/**
- * Generated artifact output (generic shape).
- *
- * Implementations may return more specific types.
- */
-export interface ArtifactOutput {
-	/** Generated content (string for text formats, Buffer for binary) */
-	content: string | Buffer;
-	/** Recommended filename (including extension) */
-	filename: string;
-	/** Full output path */
-	path: string;
-	/** Optional metadata */
-	metadata?: Record<string, unknown>;
-}
-
-/**
- * Artifact descriptor type (base shape, implementations extend)
- */
-export type ArtifactDescriptor = z.infer<typeof ArtifactBaseSchema>;
-
-/**
- * Artifact descriptor schema
- */
-export const ArtifactDescriptorSchema = ArtifactBaseSchema;
-
-/**
- * Artifact kind descriptor for runtime registration.
- *
- * Note: This kind has no default implementation. Adapters must register
- * their own implementations via runtime plugins.
- */
-class NoOpArtifactImplementation implements ArtifactGenerator {
-	async generate(options?: unknown): Promise<ArtifactOutput> {
-		throw new Error(
-			'No artifact generator registered. Adapter plugins (infra-kubernetes, infra-helm, etc.) must register implementations.'
-		);
-	}
-}
-
-export const artifactKind = createRuntimeKind<ArtifactDescriptor, NoOpArtifactImplementation>({
-	id: 'infra/artifact',
-	descriptorSchema: ArtifactDescriptorSchema,
-	defaultImplementation: NoOpArtifactImplementation,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});
-
-// Re-export discovery helpers
-export { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';

package/src/kinds/cache.kind.ts

@@ -1,104 +0,0 @@
-/**
- * Kind: infra/cache
- *
- * Describes a cache service.
- *
- * Schema shape: strict common base + `config` discriminated union.
- *
- * - The base defines fields universal across adapters: id/kind/name +
- *   the cache shape (engine, maxMemory, eviction, namespace).
- * - Adapter-specific fields (region, version, numNodes, size, …)
- *   live under `config`. Each adapter package defines its own concrete schema.
- */
-import * as z from 'zod/v4';
-import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
-import type { RuntimeKindDescriptorRecord } from '@vibesdotdev/runtime/schemas/kind';
-import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
-import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
-import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
-
-const CacheBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/cache'),
-
-	/** Cache engine (e.g., 'cloudflare-kv', 'redis'). */
-	engine: z.string().min(1).optional(),
-
-	/** Maximum memory hint. */
-	maxMemory: z.string().optional(),
-
-	/** Eviction policy. */
-	eviction: z.enum(['lru', 'lfu', 'ttl']).optional(),
-
-	/** Logical namespace within the cache. */
-	namespace: z.string().optional()
-});
-
-export const DOManagedRedisConfigSchema = z.object({
-	/** Max memory allocation (e.g., '256mb', '1gb'). */
-	maxMemory: z.string().min(1).optional(),
-	/** Eviction policy: lru, lfu, or ttl. */
-	eviction: z.enum(['lru', 'lfu', 'ttl']).optional(),
-	/** DO region (default: nyc1). */
-	region: z.string().min(1).default('nyc1'),
-	/** Redis version (default: 7). */
-	version: z.string().min(1).default('7'),
-	/** Number of nodes (default: 1). */
-	numNodes: z.number().int().positive().default(1),
-	/** Database size tier (optional, derived from maxMemory if not set). */
-	size: z.string().min(1).optional()
-});
-
-export const CloudflareKVCacheConfigSchema = z.object({
-	/** Logical namespace within the KV store. */
-	namespace: z.string().min(1)
-});
-
-export const DOKSRedisCacheConfigSchema = z.object({
-	/** Kubernetes namespace (default: vibes). */
-	namespace: z.string().min(1).default('vibes'),
-	/** Container image (default: redis:{version}). */
-	image: z.string().min(1).optional(),
-	/** Redis version (default: 7). */
-	version: z.string().min(1).default('7'),
-	/** Max memory allocation (e.g., '256mb'). */
-	maxMemory: z.string().optional(),
-	/** Eviction policy: lru, lfu, or ttl. */
-	eviction: z.enum(['lru', 'lfu', 'ttl']).optional(),
-	/** Storage size (default: 1Gi). */
-	storageSize: z.string().min(1).default('1Gi')
-});
-
-export const CacheConfigSchema = z.union([
-	DOManagedRedisConfigSchema.extend({ adapter: z.literal('do-managed-redis') }),
-	CloudflareKVCacheConfigSchema.extend({ adapter: z.literal('cloudflare-kv') }),
-	DOKSRedisCacheConfigSchema.extend({ adapter: z.literal('doks-redis') })
-]);
-
-export const CacheDescriptorSchema = CacheBaseSchema.extend({
-	/**
-	 * Adapter-specific configuration. Discriminated union — each adapter
-	 * package defines its own config schema under its discriminator key.
-	 */
-	config: CacheConfigSchema.optional()
-});
-
-export type CacheDescriptor = z.infer<typeof CacheDescriptorSchema>;
-
-class DefaultCacheImplementation {
-	constructor(
-		public readonly descriptor: RuntimeDescriptor,
-		public readonly context: unknown
-	) {}
-
-	get config(): CacheDescriptor {
-		return this.descriptor as CacheDescriptor;
-	}
-}
-
-export const cacheKind = createRuntimeKind<CacheDescriptor, DefaultCacheImplementation>({
-	id: 'infra/cache',
-	descriptorSchema: CacheDescriptorSchema,
-	defaultImplementation: DefaultCacheImplementation,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});

package/src/kinds/database.kind.ts

@@ -1,120 +0,0 @@
-/**
- * Kind: infra/database
- *
- * Describes a database instance.
- *
- * Schema shape: strict common base + `config` discriminated union.
- *
- * - The base defines fields universal across adapters: id/kind/name +
- *   the database shape (engine, size, replicas, backups).
- * - Adapter-specific fields (namespace, storageSize, version, region, …)
- *   live under `config`. Each adapter package defines its own concrete schema.
- */
-import * as z from 'zod/v4';
-import { createRuntimeKind } from '@vibesdotdev/runtime/factory/kind';
-import type { RuntimeKindDescriptorRecord } from '@vibesdotdev/runtime/schemas/kind';
-import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
-import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
-import { INFRA_DISCOVERY_PATTERN, extractStem } from './discovery.ts';
-
-export const DatabaseBackupSchema = z.object({
-	enabled: z.boolean().default(false),
-	schedule: z.string().optional(),
-	retention: z.string().optional()
-});
-export type DatabaseBackup = z.infer<typeof DatabaseBackupSchema>;
-
-const DatabaseBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/database'),
-
-	/** Database engine (e.g., 'turso', 'postgres'). */
-	engine: z.string().min(1).optional(),
-
-	/** Instance size hint. */
-	size: z.string().optional(),
-
-	/** Replica count. */
-	replicas: z.number().int().nonnegative().optional(),
-
-	/** Backup configuration. */
-	backups: DatabaseBackupSchema.optional()
-});
-
-export const DoksDatabaseConfigSchema = z.object({
-	/** Kubernetes namespace (default: vibes). */
-	namespace: z.string().min(1).default('vibes'),
-	/** Storage size for pgdata volume (default: 10Gi). */
-	storageSize: z.string().min(1).default('10Gi'),
-	/** Container resources. */
-	resources: z
-		.object({
-			requests: z.object({ cpu: z.string().min(1), memory: z.string().min(1) }).optional(),
-			limits: z.object({ cpu: z.string().min(1), memory: z.string().min(1) }).optional()
-		})
-		.optional(),
-	/** Postgres version tag (default: 16-alpine). */
-	version: z.string().min(1).default('16-alpine')
-});
-
-export const DOManagedPostgresConfigSchema = z.object({
-	/** Database size tier (default: db-s-1vcpu-1gb). */
-	size: z.string().min(1).default('db-s-1vcpu-1gb'),
-	/** DO region (default: nyc1). */
-	region: z.string().min(1).default('nyc1'),
-	/** Postgres version (default: 16). */
-	version: z.string().min(1).default('16')
-});
-
-export const TursoDatabaseConfigSchema = z.object({
-	/** Turso database name (defaults to descriptor id). */
-	database: z.string().min(1).optional(),
-	/** Edge region for replication (default: aws:iad1). */
-	region: z.string().min(1).default('aws:iad1')
-});
-
-export const CloudflareD1ConfigSchema = z.object({
-	/** D1 adapter name (always 'cloudflare-d1'). */
-	adapter: z.literal('cloudflare-d1'),
-	/** Binding name for D1 in Cloudflare Workers (default: 'DB'). */
-	binding: z.string().min(1).default('DB'),
-	/** D1 database name. */
-	databaseName: z.string().min(1),
-	/** ID of the consuming app (for wrangler.jsonc generation). */
-	consumerAppId: z.string().min(1)
-});
-
-export const DatabaseConfigSchema = z.union([
-	DoksDatabaseConfigSchema.extend({ adapter: z.literal('doks-statefulset') }),
-	DOManagedPostgresConfigSchema.extend({ adapter: z.literal('do-managed-postgres') }),
-	TursoDatabaseConfigSchema.extend({ adapter: z.literal('turso') }),
-	CloudflareD1ConfigSchema
-]);
-
-export const DatabaseDescriptorSchema = DatabaseBaseSchema.extend({
-	/**
-	 * Adapter-specific configuration. Discriminated union — each adapter
-	 * package defines its own config schema under its discriminator key.
-	 */
-	config: DatabaseConfigSchema.optional()
-});
-
-export type DatabaseDescriptor = z.infer<typeof DatabaseDescriptorSchema>;
-
-class DefaultDatabaseImplementation {
-	constructor(
-		public readonly descriptor: RuntimeDescriptor,
-		public readonly context: unknown
-	) {}
-
-	get config(): DatabaseDescriptor {
-		return this.descriptor as DatabaseDescriptor;
-	}
-}
-
-export const databaseKind = createRuntimeKind<DatabaseDescriptor, DefaultDatabaseImplementation>({
-	id: 'infra/database',
-	descriptorSchema: DatabaseDescriptorSchema,
-	defaultImplementation: DefaultDatabaseImplementation,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});