arkgate 4.8.2 → 4.8.4

package/dist/{diagnosticCatalog-CPzH-MLN.d.ts → diagnosticCatalog-DgTs0abp.d.ts}

@@ -1,5 +1,5 @@
-import { e as CreateArchitectureProfileOptions, b as ArchitectureProfile, d as ArkCheckConfig, C as CreateArchitectureProfileFromArkConfigOptions, f as CreateElevenLayerArkConfigOptions, i as Policy, j as IntentCreator, I as IntentName } from './types-DCSlrRnV.js';
-import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-BdCe_gvv.js';
+import { e as CreateArchitectureProfileOptions, b as ArchitectureProfile, d as ArkCheckConfig, C as CreateArchitectureProfileFromArkConfigOptions, f as CreateElevenLayerArkConfigOptions, i as Policy, j as IntentCreator, I as IntentName } from './types-BuM8WNqe.js';
+import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-dy5PfTqS.js';
 
 /** Versioned public result contract shared by every ArkGate enforcement adapter. */
 /**
@@ -409,7 +409,7 @@ declare const ARK_ANALYSIS_RESULT_SCHEMA: {
 };
 
 /** ArkGate library version — single source of truth. */
-declare const version = "4.8.2";
+declare const version = "4.8.4";
 
 /**
  * AI Code Gate (basic).
@@ -573,6 +573,20 @@ type ResolvedArkOrderRootHitFact = {
     matchedRoot: string;
     hasPlaneFactory: boolean;
 };
+type ResolvedArkOrderXiFieldWriteFact = {
+    file: string;
+    line: number;
+    key: string;
+};
+type ResolvedArkOrderIngestWriteFact = {
+    file: string;
+    line: number;
+};
+type ResolvedArkOrderReleaseKeyCountFact = {
+    file: string;
+    line: number;
+    keyCount: number;
+};
 
 /**
  * Versioned type vocabulary for resolved candidate facts (schema 1.0).
@@ -724,8 +738,11 @@ type ResolvedCandidateFactsInput = {
     arkOrderPlaneCalls?: readonly ResolvedArkOrderPlaneCallFact[];
     arkOrderGenericUpdates?: readonly ResolvedArkOrderGenericUpdateFact[];
     arkOrderRootHits?: readonly ResolvedArkOrderRootHitFact[];
+    arkOrderXiFieldWrites?: readonly ResolvedArkOrderXiFieldWriteFact[];
+    arkOrderIngestWritesXi?: readonly ResolvedArkOrderIngestWriteFact[];
+    arkOrderReleaseKeyCounts?: readonly ResolvedArkOrderReleaseKeyCountFact[];
 };
-type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash' | 'classShapes' | 'arkRunKernelCalls' | 'arkOrderPlaneCalls' | 'arkOrderGenericUpdates' | 'arkOrderRootHits' | 'arkRunManagedNews' | 'arkRunCompositionRootHits' | 'arkRunDeclarations'> & {
+type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash' | 'classShapes' | 'arkRunKernelCalls' | 'arkOrderPlaneCalls' | 'arkOrderGenericUpdates' | 'arkOrderXiFieldWrites' | 'arkOrderIngestWritesXi' | 'arkOrderReleaseKeyCounts' | 'arkOrderRootHits' | 'arkRunManagedNews' | 'arkRunCompositionRootHits' | 'arkRunDeclarations'> & {
     schemaVersion: typeof RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION;
     completenessReasons: ResolvedFactsReason[];
     candidateTreeHash: string;
@@ -744,6 +761,9 @@ type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHa
     arkOrderPlaneCalls: ResolvedArkOrderPlaneCallFact[];
     arkOrderGenericUpdates: ResolvedArkOrderGenericUpdateFact[];
     arkOrderRootHits: ResolvedArkOrderRootHitFact[];
+    arkOrderXiFieldWrites: ResolvedArkOrderXiFieldWriteFact[];
+    arkOrderIngestWritesXi: ResolvedArkOrderIngestWriteFact[];
+    arkOrderReleaseKeyCounts: ResolvedArkOrderReleaseKeyCountFact[];
     factsHash: string;
 };
 
@@ -1388,6 +1408,71 @@ declare const RESOLVED_CANDIDATE_FACTS_SCHEMA: {
                 };
             };
         };
+        readonly arkOrderXiFieldWrites: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "key"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly key: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderIngestWritesXi: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                };
+            };
+        };
+        readonly arkOrderReleaseKeyCounts: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "keyCount"];
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "^(?!/)(?![A-Za-z]:/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\/$).+$";
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                    readonly keyCount: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                };
+            };
+        };
         readonly factsHash: {
             readonly type: "string";
             readonly minLength: 1;
@@ -1598,7 +1683,7 @@ declare function collectForbiddenCapabilityUses(ts: any, sourceFile: any, forbid
  * ./arkRulesContract.ts so generate:cli-pure can emit a self-contained artifact.
  */
 /** Closed sensor vocabulary (ADR 0013). Unknown sensors fail closed at load time. */
-declare const ARK_RULE_SENSOR_IDS: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "no-anemic-model", "invariant-coverage"];
+declare const ARK_RULE_SENSOR_IDS: readonly ["aggregate-private-state", "always-valid-factory", "domain-event-on-mutation", "orchestration-only", "thin-adapter", "writes-via-aggregate", "no-anemic-model", "invariant-coverage"];
 type ArkRuleSensorId = (typeof ARK_RULE_SENSOR_IDS)[number];
 type ArkRuleMode = 'advisory' | 'enforced';
 type ArkRuleStructureEntry = {
@@ -1668,10 +1753,21 @@ type InvariantCoverageEvidence = {
     /** When no test globs were supplied, coverage cannot be proven. */
     partial: boolean;
     description: string;
+    /** Test file that supplied the `test-title` evidence, when there was one. */
+    testEvidenceFile?: string;
+    /**
+     * The only covering test found sits outside `coverage.coverageRoots` — the
+     * places the project declares its runner executes. ArkGate never runs tests,
+     * so a title match outside those roots is a test that exists, not a test that
+     * runs. Absent (undefined) when no roots were declared: without a declaration
+     * there is nothing to compare against, and silence is honest.
+     */
+    outsideDeclaredRoots?: boolean;
 };
 type InvariantUncoveredKind = 'never-had-tests' | 'tests-disappeared';
+type InvariantCoverageRuleId = 'INVARIANT_UNCOVERED' | 'INVARIANT_COVERAGE_OUTSIDE_ROOTS';
 type InvariantCoverageViolation = {
-    ruleId: 'INVARIANT_UNCOVERED';
+    ruleId: InvariantCoverageRuleId;
     message: string;
     file: string;
     line: number;
@@ -1680,8 +1776,12 @@ type InvariantCoverageViolation = {
     fromLayer: string;
     severity: 'error' | 'warning';
     failsStrict: boolean;
-    /** Adopt residual (no test suite) vs regression (suite exists, coverage gone). */
-    kind: InvariantUncoveredKind;
+    /**
+     * Adopt residual (no test suite) vs regression (suite exists, coverage gone).
+     * Only INVARIANT_UNCOVERED carries it: an outside-roots finding is about
+     * WHERE the covering test lives, not about whether one exists.
+     */
+    kind?: InvariantUncoveredKind;
 };
 type EvaluateInvariantCoverageInput = {
     arkRules: EffectiveArkRules;
@@ -1696,6 +1796,55 @@ type EvaluateInvariantCoverageInput = {
      * the suite may exist outside the scan budget.
      */
     coverageBudgetExhausted?: boolean;
+    /** Numbers behind the scan: what was loaded, what was discarded and why. */
+    coverageStats?: InvariantCoverageStats;
+    /**
+     * Declared (`coverage.coverageRoots`) path prefixes where the project says its
+     * runner actually executes tests. ArkGate never executes anything: this is a
+     * second DECLARATION to compare the first against. Absent or empty means no
+     * declaration was made, so no outside-roots claim is possible.
+     */
+    coverageRoots?: readonly string[];
+};
+/**
+ * What the Tooling scan actually saw. Every discard has a counted reason —
+ * a silent drop would make an uncovered verdict unexplainable.
+ */
+type InvariantCoverageStats = {
+    /**
+     * Files actually opened and read. Always >= filesLoaded: a test is read
+     * before it can be judged for naming an invariant, so the file budget bounds
+     * RETENTION, not I/O. Reporting only the retained count made
+     * `coverage.maxFiles` read as a knob on how much the scan opens.
+     */
+    filesRead?: number;
+    /** Files retained as coverage evidence (tests + production). */
+    filesLoaded: number;
+    /** Test files retained (subset of filesLoaded). */
+    testFilesRetained: number;
+    /** The file budget in force for this scan (config `coverage.maxFiles` or the default). */
+    maxFiles: number;
+    discarded: {
+        /** Reached the file budget. */
+        budget: number;
+        /** Test file naming no catalogued invariant (scanned, then dropped). */
+        noInvariantMention: number;
+        /** Larger than the per-file byte cap. */
+        oversize: number;
+        /**
+         * stat/read failed on a file or a directory: permissions, a broken symlink,
+         * or something that moved mid-scan. Files and directories share one counter.
+         */
+        unreadable: number;
+        /** Directory deeper than the walk depth limit — its files were never seen. */
+        depthLimited: number;
+        /**
+         * Symlink inside the tree whose target resolves outside the project root.
+         * Refused as evidence: a file that is not in this repo must not prove an
+         * invariant covered.
+         */
+        outOfRoot: number;
+    };
 };
 declare function evaluateInvariantCoverage(input: EvaluateInvariantCoverageInput): {
     coverage: InvariantCoverageEvidence[];
@@ -1762,6 +1911,7 @@ type EvaluateArkRuleSensorsInput = {
     fileHints?: Readonly<Record<string, {
         orchestrationHeavy?: boolean;
         adapterThick?: boolean;
+        persistenceWrite?: boolean;
     }>>;
 };
 /**
@@ -1782,6 +1932,7 @@ declare function collectEmptyAppliesToFindings(arkRules: EffectiveArkRules, file
 declare function deriveArkRuleFileHints(_file: string, content: string): {
     orchestrationHeavy?: boolean;
     adapterThick?: boolean;
+    persistenceWrite?: boolean;
 } | null;
 /**
  * Build fileHints map from path→content. Omits paths with no flags (sparse map).
@@ -1789,6 +1940,7 @@ declare function deriveArkRuleFileHints(_file: string, content: string): {
 declare function buildArkRuleFileHints(fileContents: Readonly<Record<string, string>>): Record<string, {
     orchestrationHeavy?: boolean;
     adapterThick?: boolean;
+    persistenceWrite?: boolean;
 }>;
 /**
  * Lightweight class-shape extraction from TypeScript source text (no compiler).
@@ -1884,15 +2036,21 @@ type AnalyzeResolvedProjectInput = {
         testFiles?: readonly string[];
         testGlobsMissing?: boolean;
         coverageBudgetExhausted?: boolean;
+        /** Declared `coverage.coverageRoots`: where the project says its runner runs. */
+        coverageRoots?: readonly string[];
+        /** Counted scan facts: files loaded, tests retained, discards by reason. */
+        stats?: InvariantCoverageStats;
     };
     /**
      * AR07 — Tooling-supplied orchestration/thin-adapter heuristics per file.
      * Prefer deriveArkRuleFileHints / buildArkRuleFileHints (Domain pure).
-     * When omitted, orchestration-only and thin-adapter sensors stay silent.
+     * When omitted, orchestration-only, thin-adapter, and writes-via-aggregate
+     * sensors stay silent.
      */
     fileHints?: Readonly<Record<string, {
         orchestrationHeavy?: boolean;
         adapterThick?: boolean;
+        persistenceWrite?: boolean;
     }>>;
 };
 type PreflightResolvedChangeInput = {
@@ -2246,7 +2404,7 @@ type ArkDesignDeltaResult = {
 declare const DIAGNOSTIC_DOCS_RELATIVE_PATH: "docs/diagnostics.md";
 /** Schema id for serializing the catalog snapshot (agents / install projection). */
 declare const DIAGNOSTIC_CATALOG_SCHEMA_VERSION: "1.0";
-type DiagnosticCategory = 'layer' | 'capability' | 'publish' | 'safety' | 'arkrules' | 'arkrun' | 'arkorder' | 'preflight' | 'analysis' | 'snippet-policy' | 'config' | 'adapter' | 'meta';
+type DiagnosticCategory = 'layer' | 'capability' | 'publish' | 'safety' | 'arkrules' | 'arkrun' | 'arkorder' | 'preflight' | 'analysis' | 'drift' | 'snippet-policy' | 'config' | 'adapter' | 'meta';
 type DiagnosticCatalogEntry = {
     /** Stable public violation / diagnostic id. */
     ruleId: string;
@@ -2310,4 +2468,4 @@ declare function catalogFixForRuleId(ruleId: string | null | undefined): string
  */
 declare function catalogWhyForRuleId(ruleId: string | null | undefined): string | undefined;
 
-export { type ArchitectureConvergenceClassification as $, type ArkRulesFile as A, type AnalysisCapabilityUse as B, type AnalysisCompilerOptions as C, type AnalysisCompleteness as D, type EffectiveArkRules as E, type AnalysisContract as F, type AnalysisEvidence as G, type AnalysisFile as H, type AnalysisFileChange as I, type AnalysisFileInput as J, type AnalysisImportEdge as K, type AnalysisIr as L, type AnalysisMode as M, type AnalysisResult as N, type AnalysisViolation as O, type AnalyzeArchitectureConvergenceInput as P, type AnalyzeChangeInput as Q, type ResolvedArkRunKernelCallKind as R, type AnalyzePolicyDeltaInput as S, type AnalyzeProjectInput as T, type AnalyzeResolvedProjectInput as U, type ArchitectureActualChange as V, type ArchitectureChangeMap as W, type ArchitectureChangeMapContract as X, type ArchitectureChangeMapDependency as Y, type ArchitectureChangeMapFile as Z, type ArchitectureChangeOperation as _, type ResolvedArkRunDeclarationFact as a, adapterFindingOccurrenceTargetKeys as a$, type ArchitectureConvergenceFinding as a0, type ArchitectureConvergenceResult as a1, type ArchitectureDependency as a2, type ArchitectureEngineEdge as a3, type ArchitectureEngineResult as a4, type ArchitectureEngineViolation as a5, type ArkDesignDeltaResult as a6, type ArkEnforcementHost as a7, type ArkEnforcementState as a8, type ArkRuleSensorViolation as a9, type PolicyDeltaClassification as aA, type PolicyDeltaFinding as aB, type PreflightResolvedChangeInput as aC, type PreparedChangeFile as aD, RESOLVED_CANDIDATE_FACTS_SCHEMA as aE, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION as aF, type ResolvedAmbientFact as aG, type ResolvedAnalysisFile as aH, type ResolvedAnalysisIr as aI, type ResolvedAnalysisResult as aJ, type ResolvedCandidateFacts as aK, type ResolvedCandidateFactsInput as aL, type ResolvedCapability as aM, type ResolvedCapabilityFact as aN, type ResolvedChangePreflightResult as aO, type ResolvedDependencyKind as aP, type ResolvedDependencyState as aQ, type ResolvedFactsCompleteness as aR, type ResolvedFileFact as aS, type ResolvedIntentReferenceFact as aT, type ResolvedPublishFact as aU, type ResolvedSafetyFact as aV, type ResolvedSafetyKind as aW, type ResolvedSafetyReport as aX, type SemanticDependency as aY, type SemanticDependencyKind as aZ, adapterDocsCodePath as a_, type ChangePreflightResult as aa, type ClassShapeFact as ab, type CollectAnalysisConfigWarningsInput as ac, DIAGNOSTIC_CATALOG as ad, DIAGNOSTIC_CATALOG_SCHEMA_VERSION as ae, DIAGNOSTIC_DOCS_RELATIVE_PATH as af, DIAGNOSTIC_RULE_IDS as ag, type DesignDeltaChange as ah, type DesignDeltaEnforcementScope as ai, type DesignDeltaIdentity as aj, type DesignSmellEvidence as ak, type DesignSmellFinding as al, type DesignSmellId as am, type DiagnosticCatalogEntry as an, type DiagnosticCategory as ao, type EnforcementBoundaryState as ap, type EnforcementEvidence as aq, type EnforcementEvidenceField as ar, type EnforcementVerification as as, type EvaluateArchitectureGraphInput as at, type ForbiddenCapabilityUse as au, type InvariantCoverageEvidence as av, POLICY_DELTA_SCHEMA_VERSION as aw, type PolicyDelta as ax, type PolicyDeltaAcknowledgement as ay, type PolicyDeltaAnalysis as az, type ResolvedArkRunKernelCallFact as b, adapterFindingRefFromTargetKey as b0, adapterFindingTargetKey as b1, analyzeArchitectureConvergence as b2, analyzeChange as b3, analyzePolicyDelta as b4, analyzeProject as b5, analyzeResolvedProject as b6, buildArkRuleFileHints as b7, canPromoteInvariant as b8, catalogFixForRuleId as b9, loadContract as bA, loadResolvedCandidateFacts as bB, policyDeltaAcknowledgementMatches as bC, preflightChange as bD, preflightResolvedChange as bE, resolvedFactsEvidenceRequirementsHash as bF, serializeDiagnosticCatalog as bG, stableSerialize as bH, toAdapterDiagnostic as bI, version as bJ, catalogWhyForRuleId as ba, classifyArkPolicyDelta as bb, collectAnalysisConfigWarnings as bc, collectEmptyAppliesToFindings as bd, collectForbiddenCapabilityUses as be, createAICodeGate as bf, createAdapterResult as bg, createArchitectureProfile as bh, createArchitectureProfileFromArkConfig as bi, createElevenLayerArkConfig as bj, createResolvedCandidateFacts as bk, deriveArkRuleFileHints as bl, detectArchitectureCycles as bm, deterministicHash as bn, diagnosticDocsFragment as bo, diagnosticDocsPath as bp, elevenLayerProfile as bq, evaluateArchitectureGraph as br, evaluateArkRuleSensors as bs, evaluateInvariantCoverage as bt, explainViolation as bu, extractClassShapesFromSource as bv, extractSemanticDependencies as bw, getDiagnosticCatalogEntry as bx, isCataloguedOrArkRuleFamily as by, isKnownDiagnosticCode as bz, type ResolvedArkRunManagedNewFact as c, type ResolvedDependencyFact as d, type ResolvedArkRunCompositionRootHitFact as e, type ResolvedFactsReason as f, type ResolvedArkOrderPlaneCallFact as g, type ResolvedArkOrderGenericUpdateFact as h, type ResolvedArkOrderRootHitFact as i, ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH as j, type AICodeGate as k, type AICodeGateContext as l, type AICodeGateOptions as m, type AICodeGateResult as n, type AICodeGateViolation as o, type AIGateExtension as p, ANALYSIS_IR_SCHEMA_VERSION as q, ARK_ANALYSIS_RESULT_SCHEMA as r, ARK_ANALYSIS_RESULT_SCHEMA_VERSION as s, ARK_DESIGN_DELTA_SCHEMA_VERSION as t, ARK_ENFORCEMENT_STATE_SCHEMA_VERSION as u, type AdapterCompletenessReason as v, type AdapterDiagnostic as w, type AdapterResult as x, type AdapterSeverity as y, type AdapterViolationInput as z };
+export { type ArchitectureChangeMapFile as $, type ArkRulesFile as A, type AdapterSeverity as B, type AdapterViolationInput as C, type AnalysisCapabilityUse as D, type EffectiveArkRules as E, type AnalysisCompilerOptions as F, type AnalysisCompleteness as G, type AnalysisContract as H, type AnalysisEvidence as I, type AnalysisFile as J, type AnalysisFileChange as K, type AnalysisFileInput as L, type AnalysisImportEdge as M, type AnalysisIr as N, type AnalysisMode as O, type AnalysisResult as P, type AnalysisViolation as Q, type ResolvedArkRunKernelCallKind as R, type AnalyzeArchitectureConvergenceInput as S, type AnalyzeChangeInput as T, type AnalyzePolicyDeltaInput as U, type AnalyzeProjectInput as V, type AnalyzeResolvedProjectInput as W, type ArchitectureActualChange as X, type ArchitectureChangeMap as Y, type ArchitectureChangeMapContract as Z, type ArchitectureChangeMapDependency as _, type ResolvedArkRunDeclarationFact as a, type SemanticDependencyKind as a$, type ArchitectureChangeOperation as a0, type ArchitectureConvergenceClassification as a1, type ArchitectureConvergenceFinding as a2, type ArchitectureConvergenceResult as a3, type ArchitectureDependency as a4, type ArchitectureEngineEdge as a5, type ArchitectureEngineResult as a6, type ArchitectureEngineViolation as a7, type ArkDesignDeltaResult as a8, type ArkEnforcementHost as a9, type PolicyDeltaAcknowledgement as aA, type PolicyDeltaAnalysis as aB, type PolicyDeltaClassification as aC, type PolicyDeltaFinding as aD, type PreflightResolvedChangeInput as aE, type PreparedChangeFile as aF, RESOLVED_CANDIDATE_FACTS_SCHEMA as aG, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION as aH, type ResolvedAmbientFact as aI, type ResolvedAnalysisFile as aJ, type ResolvedAnalysisIr as aK, type ResolvedAnalysisResult as aL, type ResolvedCandidateFacts as aM, type ResolvedCandidateFactsInput as aN, type ResolvedCapability as aO, type ResolvedCapabilityFact as aP, type ResolvedChangePreflightResult as aQ, type ResolvedDependencyKind as aR, type ResolvedDependencyState as aS, type ResolvedFactsCompleteness as aT, type ResolvedFileFact as aU, type ResolvedIntentReferenceFact as aV, type ResolvedPublishFact as aW, type ResolvedSafetyFact as aX, type ResolvedSafetyKind as aY, type ResolvedSafetyReport as aZ, type SemanticDependency as a_, type ArkEnforcementState as aa, type ArkRuleSensorViolation as ab, type ChangePreflightResult as ac, type ClassShapeFact as ad, type CollectAnalysisConfigWarningsInput as ae, DIAGNOSTIC_CATALOG as af, DIAGNOSTIC_CATALOG_SCHEMA_VERSION as ag, DIAGNOSTIC_DOCS_RELATIVE_PATH as ah, DIAGNOSTIC_RULE_IDS as ai, type DesignDeltaChange as aj, type DesignDeltaEnforcementScope as ak, type DesignDeltaIdentity as al, type DesignSmellEvidence as am, type DesignSmellFinding as an, type DesignSmellId as ao, type DiagnosticCatalogEntry as ap, type DiagnosticCategory as aq, type EnforcementBoundaryState as ar, type EnforcementEvidence as as, type EnforcementEvidenceField as at, type EnforcementVerification as au, type EvaluateArchitectureGraphInput as av, type ForbiddenCapabilityUse as aw, type InvariantCoverageEvidence as ax, POLICY_DELTA_SCHEMA_VERSION as ay, type PolicyDelta as az, type ResolvedArkRunKernelCallFact as b, adapterDocsCodePath as b0, adapterFindingOccurrenceTargetKeys as b1, adapterFindingRefFromTargetKey as b2, adapterFindingTargetKey as b3, analyzeArchitectureConvergence as b4, analyzeChange as b5, analyzePolicyDelta as b6, analyzeProject as b7, analyzeResolvedProject as b8, buildArkRuleFileHints as b9, isCataloguedOrArkRuleFamily as bA, isKnownDiagnosticCode as bB, loadContract as bC, loadResolvedCandidateFacts as bD, policyDeltaAcknowledgementMatches as bE, preflightChange as bF, preflightResolvedChange as bG, resolvedFactsEvidenceRequirementsHash as bH, serializeDiagnosticCatalog as bI, stableSerialize as bJ, toAdapterDiagnostic as bK, version as bL, canPromoteInvariant as ba, catalogFixForRuleId as bb, catalogWhyForRuleId as bc, classifyArkPolicyDelta as bd, collectAnalysisConfigWarnings as be, collectEmptyAppliesToFindings as bf, collectForbiddenCapabilityUses as bg, createAICodeGate as bh, createAdapterResult as bi, createArchitectureProfile as bj, createArchitectureProfileFromArkConfig as bk, createElevenLayerArkConfig as bl, createResolvedCandidateFacts as bm, deriveArkRuleFileHints as bn, detectArchitectureCycles as bo, deterministicHash as bp, diagnosticDocsFragment as bq, diagnosticDocsPath as br, elevenLayerProfile as bs, evaluateArchitectureGraph as bt, evaluateArkRuleSensors as bu, evaluateInvariantCoverage as bv, explainViolation as bw, extractClassShapesFromSource as bx, extractSemanticDependencies as by, getDiagnosticCatalogEntry as bz, type ResolvedArkRunManagedNewFact as c, type ResolvedDependencyFact as d, type ResolvedArkRunCompositionRootHitFact as e, type ResolvedFactsReason as f, type ResolvedArkOrderPlaneCallFact as g, type ResolvedArkOrderGenericUpdateFact as h, type ResolvedArkOrderRootHitFact as i, type ResolvedArkOrderXiFieldWriteFact as j, type ResolvedArkOrderIngestWriteFact as k, ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH as l, type AICodeGate as m, type AICodeGateContext as n, type AICodeGateOptions as o, type AICodeGateResult as p, type AICodeGateViolation as q, type AIGateExtension as r, ANALYSIS_IR_SCHEMA_VERSION as s, ARK_ANALYSIS_RESULT_SCHEMA as t, ARK_ANALYSIS_RESULT_SCHEMA_VERSION as u, ARK_DESIGN_DELTA_SCHEMA_VERSION as v, ARK_ENFORCEMENT_STATE_SCHEMA_VERSION as w, type AdapterCompletenessReason as x, type AdapterDiagnostic as y, type AdapterResult as z };