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

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
-});

package/src/kinds/discovery.ts

@@ -1,26 +0,0 @@
-/**
- * Shared discovery helpers for infra resource kinds.
- *
- * All infra kinds use the same discovery pattern for *.infra.ts files.
- */
-
-/**
- * Glob pattern for discovering infra resource declaration files.
- */
-export const INFRA_DISCOVERY_PATTERN = '**/*.infra.ts';
-
-/**
- * Extract the stem (base name without extension) from an infra file.
- * Matches both .infra.ts and .infra.tsx extensions.
- *
- * @example
- * extractStem('auth.infra.ts') // 'auth'
- * extractStem('my-service.infra.tsx') // 'my-service'
- * extractStem('not-infra.ts') // null
- */
-export function extractStem(filename: string): string | null {
-	const match = filename.match(/^(.+)\.infra\.tsx?$/);
-	const stem = match ? match[1]! : null;
-	// Return null for empty stem (e.g., '.infra.ts')
-	return stem && stem.length > 0 ? stem : null;
-}

package/src/kinds/git-hosting.kind.ts

@@ -1,100 +0,0 @@
-/**
- * Kind: infra/git-hosting
- *
- * Describes a git hosting service instance (e.g. Gitea, Forgejo).
- *
- * Schema shape: strict common base + `config` discriminated union.
- *
- * - The base (this file) defines fields that are universal across every
- *   adapter: id/kind/name + the hosting shape every git host declares
- *   (domain, url, storagePath, authMethod, etc.).
- * - Adapter-specific fields (dropletSize, dockerImage, volumeSizeGb, …)
- *   live exclusively under `config`. Each adapter package defines its own
- *   concrete schema under its discriminator key.
- */
-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';
-import { deploymentEnvRequirementSchema } from '../schemas.ts';
-
-export const GitHostingTypeSchema = z.enum(['gitea', 'forgejo']);
-export type GitHostingType = z.infer<typeof GitHostingTypeSchema>;
-
-export const GitHostingAuthMethodSchema = z.enum(['local', 'oauth', 'token']);
-export type GitHostingAuthMethod = z.infer<typeof GitHostingAuthMethodSchema>;
-
-const GitHostingBaseSchema = RuntimeDescriptorSchema.extend({
-	kind: z.literal('infra/git-hosting'),
-
-	/** Primary access URL (e.g. 'https://git.example.com'). */
-	url: z.string().url(),
-
-	/** Hostname for DNS resolution (e.g. 'git.example.com'). */
-	hostname: z.string().min(1),
-
-	/** Git hosting software type. */
-	type: GitHostingTypeSchema,
-
-	/** Storage mount path inside the container. */
-	storagePath: z.string().min(1).default('/data'),
-
-	/** Authentication method. */
-	authMethod: GitHostingAuthMethodSchema.default('token'),
-
-	/** Whether TLS is enabled. */
-	ssl: z.boolean().default(true),
-
-	/** Environment variable requirements. */
-	env: z.array(deploymentEnvRequirementSchema).optional()
-});
-
-export const GiteaDoksGitHostingConfigSchema = z.object({
-	/** DigitalOcean Droplet size. */
-	dropletSize: z.string().default('s-2vcpu-2gb'),
-	/** Docker image for the Gitea container. */
-	dockerImage: z.string().default('gitea/gitea:1.21'),
-	/** Volume size in GiB for persistent storage. */
-	volumeSizeGb: z.number().int().positive().default(50),
-	/** Primary domain for the Gitea instance. */
-	domain: z.string().min(1),
-	/** SSH port exposed on the service. */
-	sshPort: z.number().int().positive().default(22),
-	/** HTTP port exposed on the service. */
-	httpPort: z.number().int().positive().default(3000)
-});
-
-export const GitHostingConfigSchema = z.union([
-	GiteaDoksGitHostingConfigSchema.extend({ adapter: z.literal('gitea-doks') })
-]);
-
-export const GitHostingDescriptorSchema = GitHostingBaseSchema.extend({
-	/**
-	 * Adapter-specific configuration. Discriminated union — each adapter
-	 * package defines its own config schema under its discriminator key.
-	 */
-	config: GitHostingConfigSchema.optional()
-});
-
-export type GitHostingDescriptor = z.infer<typeof GitHostingDescriptorSchema>;
-
-class DefaultGitHostingImplementation {
-	constructor(
-		public readonly descriptor: RuntimeDescriptor,
-		public readonly context: unknown
-	) {}
-
-	get config(): GitHostingDescriptor {
-		return this.descriptor as GitHostingDescriptor;
-	}
-}
-
-export const gitHostingKind = createRuntimeKind<GitHostingDescriptor, DefaultGitHostingImplementation>({
-	id: 'infra/git-hosting',
-	descriptorSchema: GitHostingDescriptorSchema,
-	defaultImplementation: DefaultGitHostingImplementation,
-	discoveryPattern: INFRA_DISCOVERY_PATTERN,
-	extractStem
-});