@runa-ai/runa-cli 0.7.3 → 0.8.0

package/dist/{cli-SVXOSMW6.js → cli-ZY5VRIJA.js}

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { enableNonInteractiveMode } from './chunk-6Y3LAUGL.js';
 import { getRequestedCommandNameFromArgv } from './chunk-UWWSAPDR.js';
-import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-AO554K3G.js';
+import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-GHQH6UC5.js';
 import { emitDefaultSuccessIfNeeded } from './chunk-WJXC4MVY.js';
 import { parseOutputFormat, setOutputFormat, getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
@@ -170,7 +170,7 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
       return;
     }
     if (requested === "dev") {
-      const { devCommand: devCommand2 } = await import('./dev-MLRKIP7F.js');
+      const { devCommand: devCommand2 } = await import('./dev-GB5ERUVR.js');
       program.addCommand(devCommand2);
       return;
     }
@@ -188,7 +188,7 @@ async function registerProjectLifecycleCommands(program, requested, loadAllComma
     import('./upgrade-7L4JIE4K.js'),
     import('./validate-CAAW4Y44.js'),
     import('./build-HQMSVN6N.js'),
-    import('./dev-MLRKIP7F.js')
+    import('./dev-GB5ERUVR.js')
   ]);
   program.addCommand(initCommand);
   program.addCommand(prepareCommand);
@@ -462,11 +462,11 @@ async function registerFocusedStatusUtilityCommand(program, requested) {
   return false;
 }
 async function registerCiCommand(program) {
-  const { ciCommand } = await import('./ci-Z4525QW6.js');
+  const { ciCommand } = await import('./ci-ZK3LKYFX.js');
   program.addCommand(ciCommand);
 }
 async function registerDbCommand(program) {
-  const { dbCommand } = await import('./db-S4V4ETDR.js');
+  const { dbCommand } = await import('./db-EPI2DQYN.js');
   program.addCommand(dbCommand);
 }
 async function registerServicesCommand(program) {
@@ -474,11 +474,11 @@ async function registerServicesCommand(program) {
   program.addCommand(servicesCommand);
 }
 async function registerEnvCommand(program) {
-  const { envCommand } = await import('./env-WNHJVLOT.js');
+  const { envCommand } = await import('./env-WP74UUMO.js');
   program.addCommand(envCommand);
 }
 async function registerHotfixCommand(program) {
-  const { hotfixCommand } = await import('./hotfix-Z5EGVSMH.js');
+  const { hotfixCommand } = await import('./hotfix-TOSGTVCW.js');
   program.addCommand(hotfixCommand);
 }
 async function registerSdkCommand(program) {
@@ -498,7 +498,7 @@ async function registerWorkflowCommand(program) {
   program.addCommand(workflowCommand);
 }
 async function registerVulnCheckCommand(program) {
-  const { vulnCheckCommand } = await import('./vuln-check-D575VXIQ.js');
+  const { vulnCheckCommand } = await import('./vuln-check-G6I4YYDC.js');
   program.addCommand(vulnCheckCommand);
 }
 async function registerTemplateCheckCommand(program) {

package/dist/commands/ci/commands/ci-resolvers.d.ts

@@ -16,8 +16,7 @@ export type CiDbMode = 'auto' | 'local';
 export type CiPrProfile = 'runa-strict' | 'pj-stable';
 export type CiPrPolicy = {
     allowLocalFallback: boolean;
-    allowPartialPhases: boolean;
-    source: 'default:runa-repo' | 'default:pj-repo' | 'default:unknown' | 'config';
+    source: 'default' | 'config';
 };
 export declare function resolveMode(modeRaw: unknown): 'github-actions' | 'local';
 export declare function resolvePhase(phaseRaw: unknown): CiPrPhase;

package/dist/commands/ci/machine/actors/setup/pr-common.d.ts

@@ -37,7 +37,7 @@ export declare function resolvePrContext(input: PrContextInput): PrContext;
 /**
  * Resolve CI policy from config or defaults.
  */
-export declare function resolvePolicy(_config: unknown, _repoKind: RepoKind): CiPrPolicy;
+export declare function resolvePolicy(config: unknown, repoKind: RepoKind): CiPrPolicy;
 /**
  * Detect repo kind from directory structure.
  */

package/dist/commands/ci/machine/contract.d.ts

@@ -34,6 +34,8 @@ export type CiExecutionEnv = z.infer<typeof CiExecutionEnvSchema>;
 export declare const CiPhaseSchema: z.ZodEnum<{
     all: "all";
     test: "test";
+    blocking: "blocking";
+    observability: "observability";
 }>;
 export type CiPhase = z.infer<typeof CiPhaseSchema>;
 export declare const CiDbModeSchema: z.ZodEnum<{
@@ -109,6 +111,8 @@ export declare const CiInputSchema: z.ZodObject<{
     phase: z.ZodOptional<z.ZodEnum<{
         all: "all";
         test: "test";
+        blocking: "blocking";
+        observability: "observability";
     }>>;
     dbMode: z.ZodOptional<z.ZodEnum<{
         auto: "auto";
@@ -147,6 +151,8 @@ export declare const SetupResultSchema: z.ZodObject<{
     phase: z.ZodEnum<{
         all: "all";
         test: "test";
+        blocking: "blocking";
+        observability: "observability";
     }>;
     repoKind: z.ZodEnum<{
         unknown: "unknown";
@@ -424,7 +430,6 @@ export type PrContext = z.infer<typeof PrContextSchema>;
  */
 export declare const CiPrPolicySchema: z.ZodObject<{
     allowLocalFallback: z.ZodBoolean;
-    allowPartialPhases: z.ZodBoolean;
     source: z.ZodEnum<{
         default: "default";
         config: "config";

package/dist/commands/ci/machine/guards.d.ts

@@ -91,10 +91,26 @@ export declare function shouldSetupRoles(context: CiContext): boolean;
  * Check if GitHub comment should be posted.
  */
 export declare function shouldPostGitHubComment(context: CiContext): boolean;
+/**
+ * Check if ci-pr is running in blocking-only phase.
+ */
+export declare function isBlockingPhase(context: CiContext): boolean;
+/**
+ * Check if ci-pr is running in observability-only phase.
+ */
+export declare function isObservabilityPhase(context: CiContext): boolean;
 /**
  * Check if ci-pr is running in test-only phase.
  */
 export declare function isTestPhase(context: CiContext): boolean;
+/**
+ * Check if the ci-pr execution branch should run.
+ */
+export declare function shouldRunPrExecutionPhase(context: CiContext): boolean;
+/**
+ * Check if the ci-pr observability branch should run.
+ */
+export declare function shouldRunPrObservabilityPhase(context: CiContext): boolean;
 /**
  * Check if context has an error.
  */

package/dist/commands/ci/machine/machine.d.ts

@@ -159,6 +159,12 @@ export declare const ciMachine: import("xstate").StateMachine<CiContext, CiEvent
 } | {
     type: "shouldPostGitHubComment";
     params: unknown;
+} | {
+    type: "shouldRunPrExecutionPhase";
+    params: unknown;
+} | {
+    type: "shouldRunPrObservabilityPhase";
+    params: unknown;
 } | {
     type: "hasError";
     params: unknown;
@@ -171,8 +177,8 @@ export declare const ciMachine: import("xstate").StateMachine<CiContext, CiEvent
     finalize: "complete" | "writeSummary" | "postComment";
 } | {
     postSeedPr: {
-        observability: "done" | "productionPreview" | "collectSchemaStats";
-        execution: "done" | "failed" | "staticChecks" | "capabilities" | "appStart" | "setupRoles" | "buildAndPlaywright" | "runCoreTests" | "coreTestsFailed" | "coreTestsComplete" | {
+        observability: "done" | "productionPreview" | "collectSchemaStats" | "gate";
+        execution: "done" | "failed" | "staticChecks" | "capabilities" | "appStart" | "setupRoles" | "buildAndPlaywright" | "gate" | "runCoreTests" | "coreTestsFailed" | "coreTestsComplete" | {
             e2ePhase: {
                 intermediateComment: "done" | "checking" | "posting";
                 e2eTests: "done" | "running";
@@ -210,7 +216,7 @@ export declare const ciMachine: import("xstate").StateMachine<CiContext, CiEvent
     executionMode?: "local" | "github-actions" | undefined;
     output?: "json" | "human" | undefined;
     config?: string | undefined;
-    phase?: "all" | "test" | undefined;
+    phase?: "all" | "test" | "blocking" | "observability" | undefined;
     dbMode?: "auto" | "local" | undefined;
     branchName?: string | undefined;
     skipStaticChecks?: boolean | undefined;
@@ -279,6 +285,7 @@ export declare const ciMachine: import("xstate").StateMachine<CiContext, CiEvent
             states: {
                 readonly execution: {
                     states: {
+                        readonly gate: {};
                         readonly setupRoles: {};
                         readonly staticChecks: {};
                         readonly buildAndPlaywright: {};
@@ -310,6 +317,7 @@ export declare const ciMachine: import("xstate").StateMachine<CiContext, CiEvent
                 };
                 readonly observability: {
                     states: {
+                        readonly gate: {};
                         readonly productionPreview: {};
                         readonly collectSchemaStats: {};
                         readonly done: {};

package/dist/commands/db/apply/actors/seed-actors.d.ts

@@ -4,6 +4,7 @@ import type { DbApplyInput } from '../contract.js';
  */
 export declare const applySeeds: import("xstate").PromiseActorLogic<{
     applied: boolean;
+    warnings: string[];
 }, {
     input: DbApplyInput;
     targetDir: string;

package/dist/commands/db/apply/contract.d.ts

@@ -41,6 +41,18 @@ export declare const DbApplyMetricsSchema: z.ZodObject<{
     retryAttempts: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type DbApplyMetrics = z.infer<typeof DbApplyMetricsSchema>;
+export declare const DbApplyPlanSummarySchema: z.ZodObject<{
+    rawStatements: z.ZodNumber;
+    effectiveStatements: z.ZodNumber;
+    noiseStatements: z.ZodNumber;
+    categories: z.ZodObject<{
+        idempotentDrop: z.ZodNumber;
+        idempotentAuthz: z.ZodNumber;
+        idempotentRls: z.ZodNumber;
+        suppressedFunction: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DbApplyPlanSummary = z.infer<typeof DbApplyPlanSummarySchema>;
 export declare const DbApplyOutputSchema: z.ZodObject<{
     success: z.ZodBoolean;
     idempotentSchemasApplied: z.ZodNumber;
@@ -52,6 +64,17 @@ export declare const DbApplyOutputSchema: z.ZodObject<{
     error: z.ZodOptional<z.ZodString>;
     planSql: z.ZodOptional<z.ZodString>;
     filteredPlanSql: z.ZodOptional<z.ZodString>;
+    planSummary: z.ZodOptional<z.ZodObject<{
+        rawStatements: z.ZodNumber;
+        effectiveStatements: z.ZodNumber;
+        noiseStatements: z.ZodNumber;
+        categories: z.ZodObject<{
+            idempotentDrop: z.ZodNumber;
+            idempotentAuthz: z.ZodNumber;
+            idempotentRls: z.ZodNumber;
+            suppressedFunction: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
     checkOnly: z.ZodOptional<z.ZodBoolean>;
     dataViolations: z.ZodOptional<z.ZodNumber>;
     ssotWarning: z.ZodOptional<z.ZodString>;

package/dist/commands/db/apply/helpers/fresh-db-handler.d.ts

@@ -10,12 +10,13 @@
  *
  * Safety: Fail-safe — if all detection fails, assumes existing DB (uses pg-schema-diff).
  */
-import type { DbApplyInput } from '../contract.js';
+import type { DbApplyInput, DbApplyPlanSummary } from '../contract.js';
 export interface PgSchemaDiffResult {
     sql: string;
     hazards: string[];
     applied: boolean;
     filteredPlanSql?: string;
+    planSummary?: DbApplyPlanSummary;
     retryAttempts?: number;
     retryWaitMs?: number;
     dataViolations?: number;

package/dist/commands/db/apply/helpers/hazard-handler.d.ts

@@ -12,6 +12,7 @@
  * - INDEX_BUILD / INDEX_DROPPED: Index operations
  */
 import type { DbApplyInput } from '../contract.js';
+import type { DbApplyPlanSummary } from '../contract.js';
 import { type ParsedHazard } from './idempotent-object-registry.js';
 /**
  * Parse hazards from pg-schema-diff output with context.
@@ -48,13 +49,23 @@ export declare function handleHazardsWithContext(planOutput: string, input: DbAp
     hasDeletesData: boolean;
     hasAuthzUpdate: boolean;
 };
-export declare function displayCheckModeResults(planOutput: string, filterInfo?: {
-    filteredPlanSql: string;
-    removedDropStatements: {
-        sql: string;
-    }[];
-    removedAuthzStatements: {
-        sql: string;
-    }[];
+export declare function displayCheckModeResults(planOutput: string, options?: {
+    verbose?: boolean;
+    filterInfo?: {
+        filteredPlanSql: string;
+        removedDropStatements: {
+            sql: string;
+        }[];
+        removedAuthzStatements: {
+            sql: string;
+        }[];
+        removedRlsStatements: {
+            sql: string;
+        }[];
+        suppressedFunctionStatements?: {
+            sql: string;
+        }[];
+        planSummary?: DbApplyPlanSummary;
+    };
 }): void;
 //# sourceMappingURL=hazard-handler.d.ts.map

package/dist/commands/db/apply/helpers/index.d.ts

@@ -6,10 +6,11 @@
 export { acquireAdvisoryLock, MIGRATION_LOCK_ID, releaseAdvisoryLock, } from './advisory-lock.js';
 export type { PlanHazard, PlanStatement, ValidatedPlan } from './plan-validator.js';
 export { ALLOWED_DDL_PREFIXES, BLOCKED_SQL_PATTERNS, parsePlanOutput, validatePlanForExecution, validateStatementTypes, } from './plan-validator.js';
+export { isNoChangePlanOutput } from './no-change-plan.js';
 export type { FilterResult } from './plan-drop-protection.js';
 export { filterIdempotentProtectedStatements, isDropStatementForProtectedObject, } from './plan-drop-protection.js';
 export type { CheckModeFilterResult } from './plan-check-filter.js';
-export { filterCheckModePlanStatements, isIdempotentManagedAuthzStatement, resetManagedAuthzCache, stripLeadingSessionStatements, } from './plan-check-filter.js';
+export { buildCheckModePlanSummary, filterCheckModePlanStatements, isIdempotentManagedAuthzStatement, isIdempotentManagedRlsStatement, resetManagedAuthzCache, stripLeadingSessionStatements, } from './plan-check-filter.js';
 export type { IdempotentProtectedObjects, ParsedHazard } from './idempotent-object-registry.js';
 export { filterFalsePositiveHazards, getIdempotentProtectedObjects, getIdempotentProtectedTables, getIdempotentRoles, isIdempotentRoleHazard, resetIdempotentRolesCache, } from './idempotent-object-registry.js';
 export { buildAllowedHazards, displayCheckModeResults, displayHazardsWithContext, handleHazardsWithContext, handleProductionAuthzProtection, handleProductionDataProtection, parseHazardsWithContext, } from './hazard-handler.js';

package/dist/commands/db/apply/helpers/no-change-plan.d.ts

@@ -0,0 +1,2 @@
+export declare function isNoChangePlanOutput(planOutput: string): boolean;
+//# sourceMappingURL=no-change-plan.d.ts.map

package/dist/commands/db/apply/helpers/plan-check-filter.d.ts

@@ -1,9 +1,11 @@
+import type { DbApplyPlanSummary } from '../contract.js';
 import type { IdempotentProtectedObjects } from './idempotent-object-registry.js';
 import type { PlanStatement, ValidatedPlan } from './plan-validator.js';
 export interface CheckModeFilterResult {
     filteredPlan: ValidatedPlan;
     removedDropStatements: PlanStatement[];
     removedAuthzStatements: PlanStatement[];
+    removedRlsStatements: PlanStatement[];
 }
 declare function parseRolesFromAuthzStatement(sql: string): string[];
 export declare function stripLeadingSessionStatements(sql: string): string;
@@ -18,7 +20,16 @@ type AuthzTarget = {
 } | null;
 declare function parseAuthzTarget(sql: string): AuthzTarget;
 export declare function isIdempotentManagedAuthzStatement(sql: string, schemasDir?: string): boolean;
+export declare function isIdempotentManagedRlsStatement(sql: string, schemasDir?: string): boolean;
 export declare function filterCheckModePlanStatements(plan: ValidatedPlan, protectedTables: string[], protectedObjects: IdempotentProtectedObjects, schemasDir?: string): CheckModeFilterResult;
+export declare function buildCheckModePlanSummary(params: {
+    rawStatementCount: number;
+    filteredPlan: ValidatedPlan;
+    removedDropStatements: readonly PlanStatement[];
+    removedAuthzStatements: readonly PlanStatement[];
+    removedRlsStatements: readonly PlanStatement[];
+    suppressedFunctionStatements?: readonly PlanStatement[];
+}): DbApplyPlanSummary;
 export declare function resetManagedAuthzCache(): void;
 export declare const _parseRolesFromAuthzStatement: typeof parseRolesFromAuthzStatement;
 export declare const _parseAuthzTarget: typeof parseAuthzTarget;

package/dist/commands/db/apply/machine.d.ts

@@ -1,6 +1,39 @@
+/**
+ * AI HINT: db apply State Machine (Declarative Schema Management)
+ *
+ * Purpose: Orchestrate schema application to any DB (local, Branch DB, Production)
+ *
+ * User Journey (2-pass idempotent):
+ * 1. Apply idempotent schemas (1st pass: extensions, roles - may skip dependent tables)
+ * 2. Run pg-schema-diff (current DB → desired state)
+ * 3. Apply idempotent schemas (2nd pass: dependent tables now succeed)
+ * 4. Validate partitions (non-blocking drift detection)
+ * 5. Apply seeds
+ *
+ * Why 2-pass idempotent?
+ * - Some idempotent SQL depends on declarative tables (e.g., areas → floors)
+ * - 1st pass: extensions/roles succeed, dependent tables are skipped (no error)
+ * - 2nd pass: dependent tables succeed because declarative tables now exist
+ *
+ * Architecture:
+ * - No migration files needed
+ * - pg-schema-diff runs at runtime against actual DB state
+ * - Same logic for all environments
+ *
+ * E2E Test Mapping (CLI observable behavior):
+ * - idle → expect(log).toContain('Starting db apply')
+ * - applyingIdempotentPre → expect(log).toContain('Applied idempotent schema')
+ * - applyingPgSchemaDiff → expect(log).toContain('pg-schema-diff')
+ * - applyingIdempotentPost → expect(log).toContain('Applied idempotent schema')
+ * - validatingPartitions → expect(log).toContain('partition')
+ * - applyingSeeds → expect(log).toContain('Applying seeds')
+ * - done → expect(exitCode).toBe(0)
+ * - failed → expect(exitCode).toBe(1)
+ */
+import { type CommandWarning } from '@runa-ai/runa';
 import { type SnapshotFrom } from 'xstate';
 import * as actors from './actors.js';
-import type { DbApplyInput } from './contract.js';
+import type { DbApplyInput, DbApplyPlanSummary } from './contract.js';
 interface DbApplyContext {
     input: DbApplyInput;
     targetDir: string;
@@ -18,7 +51,9 @@ interface DbApplyContext {
     error: string | null;
     planSql: string | null;
     filteredPlanSql: string | null;
+    planSummary: DbApplyPlanSummary | null;
     ssotWarning: string | null;
+    nonCriticalWarnings: CommandWarning[];
     idempotentFiles: string[];
     idempotentRisks: {
         high: number;
@@ -44,6 +79,7 @@ export declare const dbApplyMachine: import("xstate").StateMachine<DbApplyContex
 }, {
     [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
         applied: boolean;
+        warnings: string[];
     }, {
         input: DbApplyInput;
         targetDir: string;
@@ -73,6 +109,7 @@ export declare const dbApplyMachine: import("xstate").StateMachine<DbApplyContex
     src: "applySeeds";
     logic: import("xstate").PromiseActorLogic<{
         applied: boolean;
+        warnings: string[];
     }, {
         input: DbApplyInput;
         targetDir: string;
@@ -124,6 +161,9 @@ export declare const dbApplyMachine: import("xstate").StateMachine<DbApplyContex
     }, import("xstate").EventObject>;
     id: string | undefined;
 }, {
+    type: "assignPgSchemaDiffResult";
+    params: import("xstate").NonReducibleUnknown;
+} | {
     type: "releaseAdvisoryLockOnFailure";
     params: unknown;
 }, never, never, "done" | "failed" | "idle" | "acquiringLock" | "previewingIdempotent" | "applyingIdempotentPre" | "applyingPgSchemaDiff" | "applyingIdempotentPost" | "validatingPartitions" | "releasingLock" | "applyingSeeds", string, {
@@ -196,6 +236,17 @@ export declare const dbApplyMachine: import("xstate").StateMachine<DbApplyContex
     error?: string | undefined;
     planSql?: string | undefined;
     filteredPlanSql?: string | undefined;
+    planSummary?: {
+        rawStatements: number;
+        effectiveStatements: number;
+        noiseStatements: number;
+        categories: {
+            idempotentDrop: number;
+            idempotentAuthz: number;
+            idempotentRls: number;
+            suppressedFunction: number;
+        };
+    } | undefined;
     checkOnly?: boolean | undefined;
     dataViolations?: number | undefined;
     ssotWarning?: string | undefined;

package/dist/commands/db/utils/duplicate-function-ownership.d.ts

@@ -0,0 +1,35 @@
+import { type SqlLayer } from './declarative-dependency-sql-utils.js';
+export interface FunctionOwnershipDefinition {
+    qualifiedName: string;
+    signature: string | null;
+    file: string;
+    line: number;
+    layer: SqlLayer;
+}
+export interface DuplicateFunctionOwnershipFinding {
+    code: 'DUPLICATE_FUNCTION_OWNERSHIP' | 'DUPLICATE_FUNCTION_OWNERSHIP_AMBIGUOUS';
+    qualifiedName: string;
+    signature: string | null;
+    message: string;
+    suggestion: string;
+    declarativeDefinitions: FunctionOwnershipDefinition[];
+    idempotentDefinitions: FunctionOwnershipDefinition[];
+}
+export interface DuplicateFunctionOwnershipAnalysisResult {
+    contractNote: string;
+    findings: DuplicateFunctionOwnershipFinding[];
+    definitions: {
+        declarative: FunctionOwnershipDefinition[];
+        idempotent: FunctionOwnershipDefinition[];
+    };
+}
+export interface FormattedDuplicateFunctionOwnershipFinding {
+    summary: string;
+    declarativeLocations: string[];
+    idempotentLocations: string[];
+    suggestion: string;
+}
+export declare const DUPLICATE_FUNCTION_OWNERSHIP_NOTE = "Function ownership belongs to declarative SQL; idempotent 2nd pass must not redefine declarative-managed functions.";
+export declare function analyzeDuplicateFunctionOwnership(targetDir: string): DuplicateFunctionOwnershipAnalysisResult;
+export declare function formatDuplicateFunctionOwnershipFinding(finding: DuplicateFunctionOwnershipFinding): FormattedDuplicateFunctionOwnershipFinding;
+//# sourceMappingURL=duplicate-function-ownership.d.ts.map

package/dist/commands/db/utils/plan-size-guard.d.ts

@@ -0,0 +1,16 @@
+import type { DbApplyPlanSummary } from '../apply/contract.js';
+export declare const PLAN_SIZE_WARNING_THRESHOLD: {
+    readonly effectiveStatements: 200;
+    readonly rawStatements: 500;
+};
+export declare const PLAN_SIZE_BLOCKER_THRESHOLD: {
+    readonly effectiveStatements: 500;
+    readonly rawStatements: 1000;
+};
+export interface PlanSizeAssessment {
+    severity: 'ok' | 'warning' | 'blocker';
+    reasons: string[];
+}
+export declare function assessPlanSize(summary: DbApplyPlanSummary | undefined): PlanSizeAssessment;
+export declare function formatPlanSizeSummary(summary: DbApplyPlanSummary): string;
+//# sourceMappingURL=plan-size-guard.d.ts.map

package/dist/commands/db/utils/preflight-checks/duplicate-function-ownership-checks.d.ts

@@ -0,0 +1,4 @@
+import type { createCLILogger } from '@runa-ai/runa';
+import type { PreflightCheckResult, StepCounter } from '../preflight-check.js';
+export declare function runDuplicateFunctionOwnershipCheck(result: PreflightCheckResult, logger: ReturnType<typeof createCLILogger>, step: StepCounter): Promise<void>;
+//# sourceMappingURL=duplicate-function-ownership-checks.d.ts.map