@webpresso/agent-kit 0.21.0

package/dist/esm/config/docs-lint/schemas/ongoing-initiative.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+/**
+ * Schema for ongoing-initiative documents
+ * Used for long-running quality/maintenance tasks in docs/ongoing-initiatives/
+ */
+export declare const ongoingInitiativeFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodLiteral<"ongoing-initiative">;
+    status: z.ZodEnum<{
+        draft: "draft";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        current: "current";
+        active: "active";
+    }>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+}, z.core.$strip>;
+/**
+ * Schema for plan-artifact documents
+ * Used for supplementary files in implementation plans (INDEX.md, EXECUTIVE-SUMMARY.md, etc.)
+ */
+export declare const planArtifactFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodLiteral<"plan-artifact">;
+    artifact_type: z.ZodEnum<{
+        guide: "guide";
+        reference: "reference";
+        strategy: "strategy";
+        matrix: "matrix";
+        spec: "spec";
+    }>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+}, z.core.$strip>;
+/**
+ * Schema for plan-report documents
+ * Used for reports within implementation plans (violations-report.md, etc.)
+ */
+export declare const planReportFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodLiteral<"plan-report">;
+    report_type: z.ZodString;
+    generated_date: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+}, z.core.$strip>;
+//# sourceMappingURL=ongoing-initiative.d.ts.map

package/dist/esm/config/docs-lint/schemas/ongoing-initiative.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { baseFrontmatter, dateString } from './common.js';
+/**
+ * Schema for ongoing-initiative documents
+ * Used for long-running quality/maintenance tasks in docs/ongoing-initiatives/
+ */
+export const ongoingInitiativeFrontmatter = baseFrontmatter.extend({
+    type: z.literal('ongoing-initiative'),
+    status: z.enum(['active', 'archived', 'superseded', 'draft', 'in-progress', 'current']),
+    last_updated: dateString.optional(),
+});
+/**
+ * Schema for plan-artifact documents
+ * Used for supplementary files in implementation plans (INDEX.md, EXECUTIVE-SUMMARY.md, etc.)
+ */
+export const planArtifactFrontmatter = baseFrontmatter.extend({
+    type: z.literal('plan-artifact'),
+    artifact_type: z.enum(['reference', 'strategy', 'matrix', 'guide', 'spec']),
+    last_updated: dateString.optional(),
+});
+/**
+ * Schema for plan-report documents
+ * Used for reports within implementation plans (violations-report.md, etc.)
+ */
+export const planReportFrontmatter = baseFrontmatter.extend({
+    type: z.literal('plan-report'),
+    report_type: z.string(),
+    generated_date: dateString.optional(),
+    last_updated: dateString.optional(),
+});
+//# sourceMappingURL=ongoing-initiative.js.map

package/dist/esm/config/docs-lint/schemas/parent-roadmap.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+/**
+ * Frontmatter schema for parent roadmaps (group-level planning documents).
+ * Located in webpresso/blueprints/<group>/README.md.
+ * Groups related initiatives under a common theme.
+ */
+export declare const parentRoadmapFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodLiteral<"parent-roadmap">;
+    status: z.ZodOptional<z.ZodEnum<{
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        parked: "parked";
+        archived: "archived";
+        current: "current";
+        complete: "complete";
+        deferred: "deferred";
+        deprioritized: "deprioritized";
+        future: "future";
+    }>>;
+    complexity: z.ZodOptional<z.ZodEnum<{
+        L: "L";
+        XL: "XL";
+    }>>;
+    created: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+}, z.core.$strip>;
+export type ParentRoadmapFrontmatter = z.infer<typeof parentRoadmapFrontmatter>;
+/**
+ * Required sections for parent roadmaps
+ * Note: Disabled - parent roadmaps have varied structures
+ */
+export declare const parentRoadmapSections: readonly [];
+//# sourceMappingURL=parent-roadmap.d.ts.map

package/dist/esm/config/docs-lint/schemas/parent-roadmap.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { baseFrontmatter, dateString, implementationStatus } from './common.js';
+/**
+ * Frontmatter schema for parent roadmaps (group-level planning documents).
+ * Located in webpresso/blueprints/<group>/README.md.
+ * Groups related initiatives under a common theme.
+ */
+export const parentRoadmapFrontmatter = baseFrontmatter.extend({
+    type: z.literal('parent-roadmap'),
+    /** Plan status: draft, in-progress, complete, archived */
+    status: implementationStatus.optional(),
+    /** Parent roadmap complexity (always L or XL for multi-initiative groups) */
+    complexity: z.enum(['L', 'XL']).optional(),
+    /** Creation date (optional for incremental adoption) */
+    created: dateString.optional(),
+    /** Last update date (optional for incremental adoption) */
+    last_updated: dateString.optional(),
+});
+/**
+ * Required sections for parent roadmaps
+ * Note: Disabled - parent roadmaps have varied structures
+ */
+export const parentRoadmapSections = [];
+//# sourceMappingURL=parent-roadmap.js.map

package/dist/esm/config/docs-lint/schemas/research.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/**
+ * Frontmatter schema for research documents.
+ * Located in docs/research/
+ */
+export declare const researchFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodOptional<z.ZodLiteral<"research">>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        current: "current";
+        active: "active";
+    }>>;
+    date: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    methodology: z.ZodOptional<z.ZodString>;
+    findings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ResearchFrontmatter = z.infer<typeof researchFrontmatter>;
+//# sourceMappingURL=research.d.ts.map

package/dist/esm/config/docs-lint/schemas/research.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { baseFrontmatter, dateString } from './common.js';
+/**
+ * Frontmatter schema for research documents.
+ * Located in docs/research/
+ */
+export const researchFrontmatter = baseFrontmatter.extend({
+    type: z.literal('research').optional(),
+    /** Research status */
+    status: z
+        .enum(['active', 'archived', 'superseded', 'in-progress', 'current', 'draft'])
+        .optional(),
+    /** Date the research was conducted */
+    date: dateString.optional(),
+    /** Research methodology used */
+    methodology: z.string().optional(),
+    /** Key findings summary */
+    findings: z.array(z.string()).optional(),
+});
+//# sourceMappingURL=research.js.map

package/dist/esm/config/docs-lint/schemas/rule.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+/**
+ * Schema for Rule documents in docs/rules/
+ */
+export declare const ruleFrontmatter: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    last_updated: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodDate, z.ZodTransform<string | undefined, Date>>]>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        draft: "draft";
+        planned: "planned";
+        "in-progress": "in-progress";
+        archived: "archived";
+        superseded: "superseded";
+        open: "open";
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+        deprecated: "deprecated";
+        current: "current";
+        complete: "complete";
+        active: "active";
+        review: "review";
+        deferred: "deferred";
+        backlog: "backlog";
+        "wont-fix": "wont-fix";
+    }>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    related: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    type: z.ZodLiteral<"rule">;
+    priority: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    enforcement: z.ZodEnum<{
+        manual: "manual";
+        automated: "automated";
+        hybrid: "hybrid";
+    }>;
+}, z.core.$strip>;
+export type RuleFrontmatter = z.infer<typeof ruleFrontmatter>;
+export declare const ruleSections: string[];
+//# sourceMappingURL=rule.d.ts.map

package/dist/esm/config/docs-lint/schemas/rule.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { baseFrontmatter } from './common.js';
+/**
+ * Schema for Rule documents in docs/rules/
+ */
+export const ruleFrontmatter = baseFrontmatter.extend({
+    type: z.literal('rule'),
+    priority: z.enum(['critical', 'high', 'medium', 'low']),
+    enforcement: z.enum(['automated', 'manual', 'hybrid']),
+});
+export const ruleSections = ['# ', '> **Policy**:'];
+//# sourceMappingURL=rule.js.map

package/dist/esm/config/e2e-preset/index.d.ts

@@ -0,0 +1,17 @@
+export { createPlaywrightE2ePreset, type PlaywrightCompatibleConfig, type PlaywrightE2ePresetOptions, } from './playwright.js';
+export type E2ePresetRunnerKind = 'playwright' | 'vitest' | 'command';
+export interface E2ePresetSuite {
+    id: string;
+    runner: E2ePresetRunnerKind;
+    configPath: string;
+    fileMatchers: readonly string[];
+}
+export interface ResolveE2ePresetSuiteOptions<TSuite extends E2ePresetSuite = E2ePresetSuite> {
+    suite?: string;
+    file?: string;
+    suites: readonly TSuite[];
+}
+export declare function defineE2ePresetSuite<TSuite extends E2ePresetSuite>(suite: TSuite): TSuite;
+export declare function normalizeE2ePresetPath(filePath: string): string;
+export declare function resolveE2ePresetSuite<TSuite extends E2ePresetSuite>(options: ResolveE2ePresetSuiteOptions<TSuite>): TSuite | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/config/e2e-preset/index.js

@@ -0,0 +1,29 @@
+export { createPlaywrightE2ePreset, } from './playwright.js';
+const ROOT_PATTERNS = [
+    /^(?:.*\/)?apps\/e2e\//u,
+    /^(?:.*\/)?apps\/web\/[^/]+\/e2e\//u,
+    /^(?:.*\/)?apps\/workers\/[^/]+\/e2e\//u,
+];
+export function defineE2ePresetSuite(suite) {
+    return suite;
+}
+export function normalizeE2ePresetPath(filePath) {
+    const normalizedPath = filePath.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
+    for (const pattern of ROOT_PATTERNS) {
+        const match = normalizedPath.match(pattern);
+        if (match?.index !== undefined) {
+            return normalizedPath.slice(match.index + match[0].length);
+        }
+    }
+    return normalizedPath;
+}
+export function resolveE2ePresetSuite(options) {
+    if (options.suite) {
+        return options.suites.find((suite) => suite.id === options.suite) ?? null;
+    }
+    if (!options.file)
+        return null;
+    const normalizedPath = normalizeE2ePresetPath(options.file);
+    return (options.suites.find((suite) => suite.fileMatchers.some((matcher) => normalizedPath.startsWith(matcher))) ?? null);
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/config/e2e-preset/playwright.d.ts

@@ -0,0 +1,17 @@
+export interface PlaywrightE2ePresetOptions {
+    testDir?: string;
+    timeout?: number;
+    fullyParallel?: boolean;
+    trace?: 'on' | 'off' | 'retain-on-failure' | 'on-first-retry';
+}
+export interface PlaywrightCompatibleConfig {
+    testDir?: string;
+    timeout?: number;
+    fullyParallel: boolean;
+    reporter: [string][];
+    use: {
+        trace: 'on' | 'off' | 'retain-on-failure' | 'on-first-retry';
+    };
+}
+export declare function createPlaywrightE2ePreset(options?: PlaywrightE2ePresetOptions): PlaywrightCompatibleConfig;
+//# sourceMappingURL=playwright.d.ts.map

package/dist/esm/config/e2e-preset/playwright.js

@@ -0,0 +1,12 @@
+export function createPlaywrightE2ePreset(options = {}) {
+    return {
+        testDir: options.testDir,
+        timeout: options.timeout,
+        fullyParallel: options.fullyParallel ?? true,
+        reporter: [['list']],
+        use: {
+            trace: options.trace ?? 'retain-on-failure',
+        },
+    };
+}
+//# sourceMappingURL=playwright.js.map

package/dist/esm/config/launch/contracts.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Contract-safe launch-engine primitives.
+ *
+ * These types are intentionally host-agnostic: they describe the generic
+ * shape of a provisioned database handle and a launch profile without
+ * referencing any concrete host provisioner or Webpresso-specific app
+ * slug. Host adapters are responsible for mapping their internal types
+ * into these contracts before calling launch-engine.
+ *
+ * @module webpresso/launch/contracts
+ */
+/**
+ * Generic handle for a provisioned database used during a launch.
+ *
+ * Hosts typically back this with a dedicated branch/snapshot from their
+ * database provider. Launch-engine never inspects provider-specific fields;
+ * it only reads the URIs and forwards the handle to caller-supplied
+ * selectors when building environment vars.
+ */
+export interface ProvisionedDatabaseHandle {
+    /** Opaque identifier for the provisioned database. */
+    id: string;
+    /**
+     * Canonical connection string. Used as the default runtime URL when the
+     * caller does not supply a {@link DatabaseUrlSelector}.
+     */
+    primaryConnectionUri: string;
+    /**
+     * Optional application-tier URL (e.g. pooled/session-mode endpoint) for
+     * workloads that hold long-lived connections or depend on prepared
+     * statements.
+     */
+    applicationConnectionUri?: string;
+    /**
+     * Optional runtime-tier URL (e.g. direct/short-lived endpoint) for
+     * standard request-scoped worker runtimes.
+     */
+    runtimeConnectionUri?: string;
+}
+/**
+ * Caller-supplied selector that chooses which connection URIs a launch
+ * should export as `DATABASE_URL` (and optionally
+ * `HASURA_GRAPHQL_METADATA_DATABASE_URL`).
+ */
+export type DatabaseUrlSelector = (handle: ProvisionedDatabaseHandle) => {
+    runtimeDatabaseUrl: string;
+    metadataDatabaseUrl?: string;
+};
+/**
+ * Generic launch profile: everything needed to build a single launch
+ * registration, expressed without reference to any host-specific runtime
+ * implementation (e.g. cloudflare wrangler, vite, graphql runtimes).
+ */
+export interface LaunchProfile {
+    /** Working directory of the runtime being launched. */
+    cwd: string;
+    /** Plain, non-secret env vars the runtime requires. */
+    vars: Record<string, string>;
+    /** Optional log-file path the caller will use for the spawned process. */
+    logFile?: string;
+    /** Optional provisioned database handle to expose via env vars. */
+    databaseHandle?: ProvisionedDatabaseHandle;
+    /**
+     * Optional selector that maps a {@link ProvisionedDatabaseHandle} to the
+     * runtime/metadata URLs exported to the launch environment. Defaults to
+     * the handle's {@link ProvisionedDatabaseHandle.primaryConnectionUri}.
+     */
+    databaseUrlSelector?: DatabaseUrlSelector;
+}
+/**
+ * Result of a successful launch-engine registration.
+ *
+ * This is the generic, spawnable descriptor: callers decide when (and
+ * whether) to actually spawn a process from it. Host adapters may extend
+ * this shape with their own metadata when needed.
+ */
+export interface LaunchRegistration {
+    /** Spawn command (e.g. node, pnpm). */
+    command: string;
+    /** Arguments to pass to the command. */
+    args: readonly string[];
+    /** Working directory for the spawn. */
+    cwd: string;
+    /** Effective environment for the spawn. */
+    env: NodeJS.ProcessEnv;
+    /** Ports allocated for this launch. */
+    ports: {
+        api: number;
+        inspector: number;
+    };
+    /** Optional log-file path threaded through from the profile. */
+    logFile?: string;
+    /**
+     * The provisioned database handle (if any) used to assemble this
+     * registration, forwarded so callers can later tear down the resource
+     * without re-plumbing state.
+     */
+    databaseHandle?: ProvisionedDatabaseHandle;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/esm/config/launch/contracts.js

@@ -0,0 +1,13 @@
+/**
+ * Contract-safe launch-engine primitives.
+ *
+ * These types are intentionally host-agnostic: they describe the generic
+ * shape of a provisioned database handle and a launch profile without
+ * referencing any concrete host provisioner or Webpresso-specific app
+ * slug. Host adapters are responsible for mapping their internal types
+ * into these contracts before calling launch-engine.
+ *
+ * @module webpresso/launch/contracts
+ */
+export {};
+//# sourceMappingURL=contracts.js.map

package/dist/esm/config/launch/dev-contracts.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Host-agnostic development-service contracts.
+ *
+ * These contracts describe the portable `webpresso agent dev` runtime surface without
+ * naming any concrete supervisor, host app, or Webpresso service id.
+ */
+export type ServiceReadiness = {
+    type: 'http';
+    path?: string;
+    url?: string;
+    timeoutMs?: number;
+    intervalMs?: number;
+} | {
+    type: 'log';
+    pattern: string;
+    timeoutMs?: number;
+} | {
+    type: 'manual';
+    description?: string;
+};
+export interface DevRestartPolicy {
+    onFailure?: boolean;
+    maxRestarts?: number;
+}
+export interface DevServiceStartPlan {
+    id: string;
+    command: string;
+    args: readonly string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    readiness?: ServiceReadiness;
+    restart?: DevRestartPolicy;
+}
+export type DevServiceRuntimeStatus = 'running' | 'stopped' | 'errored' | 'unknown';
+export interface DevServiceRuntimeState {
+    id: string;
+    status: DevServiceRuntimeStatus;
+    message?: string;
+}
+export interface DevSupervisorAdapter {
+    name: string;
+    start(plan: DevServiceStartPlan): Promise<DevServiceRuntimeState>;
+    stop(id: string): Promise<DevServiceRuntimeState>;
+    restart(plan: DevServiceStartPlan): Promise<DevServiceRuntimeState>;
+    status(id: string): Promise<DevServiceRuntimeState>;
+}
+//# sourceMappingURL=dev-contracts.d.ts.map

package/dist/esm/config/launch/dev-contracts.js

@@ -0,0 +1,8 @@
+/**
+ * Host-agnostic development-service contracts.
+ *
+ * These contracts describe the portable `webpresso agent dev` runtime surface without
+ * naming any concrete supervisor, host app, or Webpresso service id.
+ */
+export {};
+//# sourceMappingURL=dev-contracts.js.map

package/dist/esm/config/launch/dev-manifest.d.ts

@@ -0,0 +1,42 @@
+import type { DevRestartPolicy, DevServiceStartPlan, ServiceReadiness } from './dev-contracts.js';
+export interface DevManifestServiceInput {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    readiness?: ServiceReadiness;
+    dependsOn?: string[];
+    restart?: DevRestartPolicy;
+}
+export interface DevManifestGroupInput {
+    services: string[];
+    description?: string;
+}
+export interface DevManifestInput {
+    version: 1;
+    name?: string;
+    services: Record<string, DevManifestServiceInput>;
+    groups?: Record<string, DevManifestGroupInput>;
+    defaults?: {
+        target?: string;
+    };
+}
+export interface NormalizedDevService extends DevServiceStartPlan {
+    dependsOn: string[];
+}
+export interface NormalizedDevGroup {
+    services: string[];
+    description?: string;
+}
+export interface NormalizedDevManifest {
+    version: 1;
+    name?: string;
+    services: Record<string, NormalizedDevService>;
+    groups: Record<string, NormalizedDevGroup>;
+    defaults: {
+        target?: string;
+    };
+}
+export declare function parseDevManifest(raw: unknown): NormalizedDevManifest;
+export declare function resolveDevTargets(manifest: NormalizedDevManifest, target?: string | undefined): string[];
+//# sourceMappingURL=dev-manifest.d.ts.map