arkgate 4.8.23 → 4.8.25

package/dist/{diagnosticCatalog-35mrwAHe.d.ts → runtime/index.d.cts}

@@ -1,5 +1,453 @@
-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-Ik_OakcI.js';
-import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-Bbf_MFGe.js';
+import { a as AuditStore, b as AuditRecord, c as AuditQuery, d as CreateAuditTrailOptions, e as AuditTrail, f as CreateArchitectureProfileOptions, g as ArchitectureProfile, h as ArkCheckConfig, i as CreateArchitectureProfileFromArkConfigOptions, j as CreateElevenLayerArkConfigOptions, D as DependencyGraph, I as IntentRegistry, E as EventContractRegistry, k as EventContract, l as DomainEvent, m as EventContractValidationResult, n as IntentName, o as DefineIntentOptions, p as IntentCreator, M as MetadataRegistry, R as ReadModelStore, q as CreateProjectionRegistryOptions, P as ProjectionRegistry, r as PolicyViolation, s as PolicySeverity, t as PolicyEnforcementMode, u as Policy, G as GraphEdge, v as IntentRelationship, w as EventBufferStore, x as EventBufferRecord, y as EventBufferStatus, z as EventBusOptions, B as EventBus, F as CreateObservabilityReporterOptions, O as ObservabilityReporter, H as PolicyEngine, J as ArkManifest, W as WorkflowStore, S as SagaContext, K as WorkflowSnapshot, L as SagaDefinition, N as CreateWorkflowEngineOptions, Q as SagaInstance, T as WorkflowEngine, U as ArkConfig, V as ArkConfigLoadResult, X as DependencyInformationPackage, C as CreateArkKernelOptions, A as ArkKernel, Y as ArkKernelConfig, Z as CreateArkKernelFromConfigOptions, _ as TraceRecordType, $ as TraceRecord, a0 as OutboxStatus, a1 as OutboxRecord, a2 as ObservabilityDriftReport } from '../types-CnauMQQL.cjs';
+export { a3 as ARK_RUN_COMPONENT_LIFETIMES, a4 as ARK_RUN_EPHEMERAL_DEFAULT, a5 as ARK_RUN_GRAPH_DEFAULT_SLICE, a6 as ARK_RUN_GRAPH_NODE_KINDS, a7 as ARK_RUN_GRAPH_PROCESS_EDGE_KINDS, a8 as ARK_RUN_GRAPH_SCHEMA_VERSION, a9 as ARK_RUN_GRAPH_SLICES, aa as ARK_RUN_GRAPH_TECHNICAL_EDGE_KINDS, ab as ARK_RUN_INFORMATION_PACKAGE_SCHEMA_VERSION, ac as ARK_RUN_INSPECTOR_DEFAULT_HOST, ad as ARK_RUN_INSPECTOR_DEFAULT_PORT, ae as ARK_RUN_INSPECTOR_EVENTS_PATH, af as ARK_RUN_INSPECTOR_GRAPH_PATH, ag as ARK_RUN_INSPECTOR_MONITOR_SAMPLE_LIMIT, ah as ARK_RUN_INSPECTOR_OUTBOX_PATH, ai as ARK_RUN_INSPECTOR_SCHEMA_VERSION, aj as ARK_RUN_INSPECTOR_SNAPSHOT_PATH, ak as ARK_RUN_INSPECTOR_SSE_EVENT, al as ARK_RUN_INSPECTOR_TRANSPORT_FALLBACK, am as ARK_RUN_INSPECTOR_WORKFLOWS_PATH, an as ARK_RUN_TRANSPORT_KINDS, ao as ArchitectureLayer, ap as ArchitectureLayerConfig, aq as ArchitectureRule, ar as ArkManifestArchitecture, as as ArkManifestData, at as ArkManifestEntityLink, au as ArkManifestGraph, av as ArkManifestIntent, aw as ArkManifestPolicy, ax as ArkManifestProjection, ay as ArkRunBrokerAdapter, az as ArkRunComponentLifetime, aA as ArkRunDeliveredVia, aB as ArkRunExtendedInfo, aC as ArkRunGraph, aD as ArkRunGraphEdge, aE as ArkRunGraphEdgeKind, aF as ArkRunGraphMatch, aG as ArkRunGraphMatchInput, aH as ArkRunGraphNode, aI as ArkRunGraphNodeKind, aJ as ArkRunGraphProcessEdgeKind, aK as ArkRunGraphQuery, aL as ArkRunGraphResolvedQuery, aM as ArkRunGraphSlice, aN as ArkRunGraphTechnicalEdgeKind, aO as ArkRunInformationPackageComponent, aP as ArkRunInspectorBind, aQ as ArkRunInspectorBindError, aR as ArkRunInspectorBindInput, aS as ArkRunInspectorHandle, aT as ArkRunInspectorHardening, aU as ArkRunInspectorHardeningDurability, aV as ArkRunInspectorMonitorBuildOptions, aW as ArkRunInspectorOutboxMonitor, aX as ArkRunInspectorOutboxRecordSummary, aY as ArkRunInspectorProductionError, aZ as ArkRunInspectorSnapshot, a_ as ArkRunInspectorSnapshotInput, a$ as ArkRunInspectorSource, b0 as ArkRunInspectorStoreDurability, b1 as ArkRunInspectorStoreDurabilityKind, b2 as ArkRunInspectorStoreRole, b3 as ArkRunInspectorTransportFacts, b4 as ArkRunInspectorWorkflowSummary, b5 as ArkRunInspectorWorkflowsMonitor, b6 as ArkRunPublisher, b7 as ArkRunRegisterOptions, b8 as ArkRunRegistrationHandle, b9 as ArkRunSendOptions, ba as ArkRunSendPlan, bb as ArkRunSendPlanInput, bc as ArkRunSendResult, bd as ArkRunTransportKind, be as AuditRecordInput, bf as AuditRecordType, bg as CorrelationId, bh as EntityMeta, bi as EventContractIssue, bj as EventHandler, bk as EventInterceptionInfo, bl as EventInterceptor, bm as EventInterceptorContext, bn as EventMetadata, bo as EventPayloadPatch, bp as EventPayloadSchema, bq as EventPublisher, br as EventSchemaField, bs as EventSchemaFieldType, bt as FieldMeta, bu as GraphNode, bv as IntentRelationshipKind, bw as InvalidArkRunGraphQueryError, bx as InvalidArkRunSendOptionError, by as ObservabilityFlow, bz as ObservedLayerFlowMode, bA as OutboxStore, bB as PolicyEvaluationResult, bC as ProjectionCheckpoint, bD as ProjectionDefinition, bE as PublishedEventRecord, bF as RetryPolicy, bG as SagaStatus, bH as SagaStep, bI as StartArkRunInspectorOptions, bJ as TraceSink, bK as Unsubscribe, bL as WorkflowDefinition, bM as WorkflowStatus, bN as WorkflowStep, bO as appendDecisionTape, bP as arkRunGraphQueryFromSearchParams, bQ as arkRunInspectorUrl, bR as buildArkRunInspectorHardening, bS as buildArkRunInspectorOutboxMonitor, bT as buildArkRunInspectorSnapshot, bU as buildArkRunInspectorWorkflowsMonitor, bV as buildDependencyInformationPackage, bW as classifyArkRunInspectorStoreDurability, bX as closeArkRunGraphQuery, bY as closedArkRunEphemeral, bZ as closedArkRunTransportKind, b_ as formatArkRunGraphMermaid, b$ as formatArkRunInspectorSseEvent, c0 as isArkRunInspectorLoopbackHost, c1 as isArkRunInspectorProductionEnv, c2 as requestArkRunGraph, c3 as resolveArkRunInspectorBind, c4 as resolveArkRunSendPlan, c5 as startArkRunInspector, c6 as unavailableArkRunInspectorOutboxMonitor, c7 as unavailableArkRunInspectorWorkflowsMonitor } from '../types-CnauMQQL.cjs';
+
+/**
+ * Reference in-process audit store. **Not production durability** — records do not
+ * survive process restarts. For production, inject an `AuditStore` that writes to your
+ * durable log/DB (see `docs/production-hardening.md`).
+ */
+declare class InMemoryAuditStore implements AuditStore {
+    private readonly maxRecords?;
+    private readonly records;
+    constructor(maxRecords?: number | undefined);
+    append(record: AuditRecord): void;
+    query(query?: AuditQuery): AuditRecord[];
+    clear(): void;
+}
+/**
+ * Create an audit trail. Defaults to `InMemoryAuditStore` (**not** production durability).
+ * Pass `options.store` for a durable backend.
+ */
+declare function createAuditTrail(options?: CreateAuditTrailOptions): AuditTrail;
+
+declare function createArchitectureProfile(options: CreateArchitectureProfileOptions): ArchitectureProfile;
+declare function createArchitectureProfileFromArkConfig(config: ArkCheckConfig, options?: CreateArchitectureProfileFromArkConfigOptions): ArchitectureProfile;
+declare const elevenLayerProfile: ArchitectureProfile;
+declare function createElevenLayerArkConfig(options?: CreateElevenLayerArkConfigOptions): ArkCheckConfig;
+
+/**
+ * DependencyGraph implementation.
+ *
+ * Collects declared and observed relationships.
+ * Generates Mermaid diagrams and JSON.
+ * Supports simple violation detection via rule functions.
+ */
+
+declare function createDependencyGraph(): DependencyGraph;
+
+/**
+ * Bridge IntentRegistry relationships into a DependencyGraph.
+ */
+
+interface SyncRegistryOptions {
+    /** Skip edges whose target intent is not registered (default: false). */
+    requireRegisteredTargets?: boolean;
+}
+/**
+ * Sync declared intent relationships from a registry into a dependency graph.
+ *
+ * - `dependsOn` → `declared` edges
+ * - `produces` → `produces` edges
+ */
+declare function syncRegistryToGraph(registry: IntentRegistry, graph: DependencyGraph, options?: SyncRegistryOptions): void;
+
+declare class EventContractRegistryImpl implements EventContractRegistry {
+    private readonly contracts;
+    register(contract: EventContract): void;
+    get(intent: string, version?: string): EventContract | undefined;
+    list(intent?: string): EventContract[];
+    validate(event: DomainEvent): EventContractValidationResult;
+    clear(): void;
+    private key;
+}
+declare function createEventContractRegistry(): EventContractRegistry;
+
+/**
+ * defineIntent
+ *
+ * The primary ergonomic function for declaring semantic intents.
+ *
+ * Uses a default shared registry for convenience, while still allowing
+ * isolated registries via `createIntentRegistry()`.
+ *
+ * Intents are the core of Ark's governance model. They give every
+ * architectural concept (domain events, use cases, adapter operations, workflows)
+ * an explicit, namespaced, machine-readable identity.
+ */
+
+/**
+ * Define a new semantic intent.
+ *
+ * This is the main entry point most users (and AI generators) will use.
+ *
+ * @example
+ * ```ts
+ * // Domain event
+ * const OrderPlaced = defineIntent<'Domain.Order.OrderPlaced', {
+ *   orderId: string;
+ *   amount: number;
+ * }>('Domain.Order.OrderPlaced');
+ *
+ * const event = OrderPlaced({ orderId: 'o-42', amount: 99.5 });
+ *
+ * // Application operation that declares a dependency at definition time
+ * const ConfirmOrder = defineIntent<'Application.ConfirmOrder', { orderId: string }>(
+ *   'Application.ConfirmOrder',
+ *   { dependsOn: ['Domain.Order.OrderPlaced'] }
+ * );
+ * ```
+ *
+ * @param name - Unique semantic name. Recommended convention:
+ *   - `Domain.*` for domain concepts and events
+ *   - `Application.*` for use cases / orchestration
+ *   - `Adapter.*` for external integrations
+ *   - `Workflow.*` for sagas and long-running processes
+ * @param options - Optional initial relationship declarations (`dependsOn`, `produces`)
+ */
+declare function defineIntent<N extends IntentName, P = unknown>(name: N, options?: DefineIntentOptions): IntentCreator<N, P>;
+/**
+ * Create an isolated IntentRegistry.
+ * Useful for testing, multiple bounded contexts, or advanced governance setups.
+ */
+declare function createIntentRegistry(): IntentRegistry;
+/**
+ * The default registry backing the top-level `defineIntent` calls.
+ * You can inspect it or use it directly if needed.
+ */
+declare const defaultIntentRegistry: IntentRegistry;
+
+/**
+ * Runtime validation for semantic intent naming conventions.
+ */
+interface IntentNameValidation {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Validate that an intent name follows Ark naming conventions.
+ */
+declare function validateIntentName(name: string): IntentNameValidation;
+
+/**
+ * Basic MetadataRegistry implementation.
+ */
+
+declare function createMetadataRegistry(): MetadataRegistry;
+
+/**
+ * Reference in-process read-model store. **Not production durability.**
+ * See `docs/production-hardening.md`.
+ */
+declare class InMemoryReadModelStore implements ReadModelStore {
+    private readonly states;
+    load<State = unknown>(name: string): State | undefined;
+    save<State = unknown>(name: string, state: State): void;
+    clear(name?: string): void;
+}
+declare function createProjectionRegistry(options?: CreateProjectionRegistryOptions): ProjectionRegistry;
+
+/**
+ * Typed error thrown when hard policies are violated.
+ */
+
+declare class PolicyViolationError extends Error {
+    readonly violations: PolicyViolation[];
+    constructor(violations: PolicyViolation[]);
+}
+
+/**
+ * definePolicy
+ *
+ * Factory function to create architectural policies in a declarative way.
+ */
+
+interface DefinePolicyOptions<Context = unknown> {
+    name: string;
+    severity?: PolicySeverity;
+    tags?: readonly string[];
+    owner?: string;
+    version?: string;
+    rationale?: string;
+    enforcementMode?: PolicyEnforcementMode;
+    deprecated?: boolean | string;
+    replacedBy?: string;
+    check: (context: Context) => boolean | PolicyViolation | PolicyViolation[];
+}
+/**
+ * Creates a Policy from a declarative configuration.
+ *
+ * The provided `check` function is called as-is. The PolicyEngine is responsible
+ * for normalizing results (booleans, single violations, arrays) into a consistent
+ * set of PolicyViolation objects.
+ *
+ * @example
+ * ```ts
+ * const noDomainToInfra = definePolicy({
+ *   name: 'Domain must not depend on infrastructure',
+ *   severity: 'hard',
+ *   check: (ctx) => {
+ *     const violations: PolicyViolation[] = [];
+ *     // ... logic using ctx.registry.getAllRelationships()
+ *     return violations.length > 0 ? violations : true;
+ *   }
+ * });
+ * ```
+ */
+declare function definePolicy<Context = unknown>(options: DefinePolicyOptions<Context>): Policy<Context>;
+
+/**
+ * Built-in architectural policy helpers.
+ */
+
+interface LayerFlowRule {
+    from: string;
+    to: string;
+    allowed: boolean;
+    message?: string;
+}
+interface LayerPolicyOptions {
+    name?: string;
+    severity?: 'hard' | 'soft';
+    /** Prefix rules — e.g. { from: 'Domain', to: 'Adapter', allowed: false } */
+    rules: LayerFlowRule[];
+    resolveLayer?: (name: string) => string | undefined;
+}
+/**
+ * Create a policy that enforces layer-crossing rules on graph edges or intent relationships.
+ */
+declare function defineLayerPolicy<Context extends {
+    edges?: GraphEdge[];
+    relationships?: IntentRelationship[];
+}>(options: LayerPolicyOptions): Policy<Context>;
+/** True when a policy requires graph/registry context to enforce layer rules. */
+declare function isLayerPolicy(policy: Policy): boolean;
+/** Preset architectural policy factories. */
+declare const architecturalPolicies: {
+    /**
+     * @deprecated Use cleanArchitectureMatrix() for full layer rules.
+     * Blocks Domain → Adapter declared dependencies only.
+     */
+    layerIsolation(): Policy<{
+        edges?: GraphEdge[];
+        relationships?: IntentRelationship[];
+    }>;
+    /**
+     * Clean-architecture dependency matrix (declared dependsOn / declared edges only).
+     * Does not block observed event flows (Domain events consumed by Application).
+     */
+    cleanArchitectureMatrix(): Policy<{
+        edges?: GraphEdge[];
+        relationships?: IntentRelationship[];
+    }>;
+};
+declare function defineArchitectureProfilePolicy<Context extends {
+    edges?: GraphEdge[];
+    relationships?: IntentRelationship[];
+}>(profile: ArchitectureProfile, options?: Omit<LayerPolicyOptions, 'rules' | 'resolveLayer'>): Policy<Context>;
+
+interface InMemoryEventBufferOptions {
+    /**
+     * Maximum records retained. When exceeded, the oldest settled record
+     * (`dispatched` / `failed`) is evicted first; only when every record is still
+     * `pending` is the oldest pending record evicted, and `evictedPending` counts
+     * it so the loss is visible. A record evicted while still in flight that is
+     * settled afterwards (`markDispatched` / `markFailed`) was delivered, not lost,
+     * so it leaves the count. Default: unbounded (`Infinity`). Kernels built by
+     * `createArkKernel` pass `maxHistorySize` (default 1000).
+     */
+    maxRecords?: number;
+}
+/**
+ * Reference in-process event buffer. **Not production durability** — state is lost on
+ * process exit. Use only for tests/demos/local single-process work; inject a durable
+ * store for production. This is not an atomic outbox (see `docs/production-hardening.md`).
+ */
+declare class InMemoryEventBuffer implements EventBufferStore {
+    private readonly records;
+    private readonly maxRecords;
+    /**
+     * Ids evicted while `pending`, oldest first. A later settle removes the id (the
+     * record was in flight, not lost). Bounded to {@link EVICTED_PENDING_TRACK_LIMIT}
+     * ids so the tracker itself cannot grow without limit; ids that fall off stay counted.
+     */
+    private readonly evictedPendingIds;
+    private evictedPendingCount;
+    constructor(options?: InMemoryEventBufferOptions);
+    /**
+     * Pending records dropped because the cap was reached with nothing settled to
+     * evict, and never settled afterwards. Records still in flight when evicted
+     * (e.g. fire-and-forget local handlers) leave the count once the kernel
+     * settles them.
+     */
+    get evictedPending(): number;
+    private trackEvictedPending;
+    /** A settle for an evicted in-flight record: delivered, so not a loss. */
+    private settleEvicted;
+    private evictOverflow;
+    enqueue(event: DomainEvent): Promise<EventBufferRecord>;
+    markDispatched(id: string): Promise<void>;
+    markFailed(id: string, error: unknown): Promise<void>;
+    list(status?: EventBufferStatus): Promise<EventBufferRecord[]>;
+    clear(): Promise<void>;
+}
+/**
+ * @deprecated Use InMemoryEventBuffer.
+ * @alias Kept as a public alias of `arkgate/runtime` until its removal.
+ */
+declare const InMemoryOutboxStore: typeof InMemoryEventBuffer;
+
+/**
+ * EventBus implementation — public surface + publish orchestration.
+ *
+ * Publish pipeline stages live in cohesive modules (R8):
+ *   guards → interceptors → contract re-check → observed layer flow →
+ *   policy → history/outbox/trace → handlers → onPublish hook
+ */
+
+declare function createEventBus<Context = unknown>(options?: EventBusOptions<Context>): EventBus;
+
+/**
+ * Helpers for building policy evaluation context on event publish.
+ */
+
+/**
+ * Standard context for policies evaluated during event publish.
+ * Includes the event plus optional registry relationships and graph edges
+ * so layer policies (e.g. architecturalPolicies.layerIsolation) can run.
+ */
+interface PublishPolicyContext {
+    event: DomainEvent;
+    relationships?: IntentRelationship[];
+    edges?: GraphEdge[];
+}
+interface GraphPolicyContext {
+    relationships?: IntentRelationship[];
+    edges?: GraphEdge[];
+}
+interface BuildPublishPolicyContextOptions {
+    intentRegistry?: IntentRegistry;
+    dependencyGraph?: DependencyGraph;
+}
+/**
+ * Build a getPolicyContext function that feeds registry + graph data to policies.
+ *
+ * @example
+ * ```ts
+ * const bus = createEventBus({
+ *   intentRegistry: registry,
+ *   dependencyGraph: graph,
+ *   policies: [architecturalPolicies.layerIsolation()],
+ * });
+ * ```
+ */
+declare function buildPublishPolicyContext(options: BuildPublishPolicyContextOptions): (event: DomainEvent) => PublishPolicyContext;
+declare function definePublishPolicy(options: DefinePolicyOptions<PublishPolicyContext>): Policy<PublishPolicyContext>;
+
+/**
+ * Event bus governance errors.
+ */
+declare class UnregisteredIntentError extends Error {
+    readonly intentName: string;
+    constructor(intentName: string);
+}
+declare class InvalidIntentNameError extends Error {
+    readonly intentName: string;
+    readonly reason: string;
+    constructor(intentName: string, reason: string);
+}
+declare class LayerPolicyContextError extends Error {
+    constructor();
+}
+declare class EventContractViolationError extends Error {
+    readonly intentName: string;
+    readonly issues: unknown[];
+    constructor(intentName: string, issues: unknown[]);
+}
+declare class UnknownEventSourceError extends Error {
+    readonly intentName: string;
+    readonly source?: string;
+    constructor(intentName: string, source?: string);
+}
+declare class SourceMetadataOverrideError extends Error {
+    readonly boundSource: string;
+    readonly attemptedSource: string;
+    constructor(boundSource: string, attemptedSource: string);
+}
+/**
+ * Thrown when the OBSERVED producer→event flow crosses a forbidden layer boundary
+ * under `enforceObservedLayerFlow: 'hard'`. Unlike declared-model policy errors, this
+ * reflects what the running system actually did at publish time.
+ */
+declare class ObservedLayerFlowViolationError extends Error {
+    readonly source: string;
+    readonly intentName: string;
+    readonly fromLayer: string;
+    readonly toLayer: string;
+    constructor(source: string, intentName: string, fromLayer: string, toLayer: string, message?: string);
+}
+/**
+ * A kernel built from an `ark.config.json` was explicitly asked for hard
+ * observed-layer-flow enforcement (`enforceObservedLayerFlow: 'hard'`), but some
+ * deny-rule layers declare no `intentPrefixes` and are not canonical 11-layer
+ * names (which get built-in prefixes), so no intent maps to them and the rule
+ * would be a silent no-op. With the strict default (hard implied, not passed),
+ * the kernel builds and records a `layer.observedFlowUnresolvable` audit record
+ * instead. Fix: add `intentPrefixes`, or pass `'soft' | 'off'`.
+ */
+declare class ArkKernelConfigError extends Error {
+    readonly code: 'ARKRUN_LAYER_FLOW_UNRESOLVABLE';
+    readonly layers: string[];
+    constructor(layers: string[]);
+}
+
+declare function createObservabilityReporter(options: CreateObservabilityReporterOptions): ObservabilityReporter;
+
+/** Current Ark manifest JSON schema version. */
+declare const MANIFEST_SCHEMA_VERSION = "1.0";
+
+/**
+ * Aggregates kernel registries into a single machine-readable manifest.
+ */
+
+interface CreateArkManifestOptions {
+    registry?: IntentRegistry;
+    policyEngine?: PolicyEngine;
+    metadata?: MetadataRegistry;
+    graph?: DependencyGraph;
+    profile?: ArchitectureProfile;
+    projections?: ProjectionRegistry;
+    eventContracts?: EventContractRegistry;
+    observability?: ObservabilityReporter;
+}
+/**
+ * Create a machine-readable snapshot of the current architectural contract.
+ * Intended for AI agents, codegen tools, and documentation generators.
+ */
+declare function createArkManifest(options?: CreateArkManifestOptions): ArkManifest;
+
+/**
+ * In-process workflow engine with durable-store seams.
+ */
+
+/**
+ * Reference in-process workflow store. **Not production durability.**
+ * See `docs/production-hardening.md`.
+ */
+declare class InMemoryWorkflowStore implements WorkflowStore {
+    private readonly snapshots;
+    save<P extends SagaContext>(snapshot: WorkflowSnapshot<P>, _tx?: unknown): void;
+    get<P extends SagaContext = SagaContext>(id: string, _tx?: unknown): WorkflowSnapshot<P> | undefined;
+    list(workflowName?: string): WorkflowSnapshot[];
+    claim(workerId: string, timeoutMs: number, workflowName?: string): WorkflowSnapshot | undefined;
+    clear(): void;
+}
+declare function createWorkflowEngine(bus: EventBus, options?: CreateWorkflowEngineOptions): WorkflowEngine;
+declare function createSaga<P extends SagaContext = SagaContext>(def: SagaDefinition<P>, bus: EventBus, options?: CreateWorkflowEngineOptions & {
+    id?: string;
+}): SagaInstance<P>;
+
+/** ArkGate library version — single source of truth. */
+declare const version = "4.8.25";
 
 /** Versioned public result contract types + JSON Schema (adapter envelope). */
 /**
@@ -8,8 +456,6 @@ import { A as ArkConfig, c as ArkConfigLoadResult } from './configTypes-Bbf_MFGe
  * 1.4 added optional evidence.arkruleId + evidence.arkruleSource (ADR 0012 / AR03).
  */
 declare const ARK_ANALYSIS_RESULT_SCHEMA_VERSION: "1.5";
-/** Repo-relative diagnostics docs path (parity with ACS02 diagnostic catalog). */
-declare const ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH: "docs/diagnostics.md";
 type AdapterSeverity = 'error' | 'warning';
 type AnalysisCompleteness = 'complete' | 'partial' | 'unavailable';
 type AnalysisMode = 'lexical-compatibility' | 'resolved-candidate-facts';
@@ -77,6 +523,12 @@ type AdapterDiagnostic = {
         arkruleId?: string;
         /** AR03 — ArkRules source file path. */
         arkruleSource?: string;
+        /** Nested-wall reason. Not part of the baseline key. */
+        reasonId?: 'CROSS_PARENT_SLICE' | 'CROSS_SIBLING_SLICE' | 'CROSS_PARENT_VIA_SHARED';
+        /** Last segment of the importer universe id, with a reasonId. */
+        universeFrom?: string;
+        /** Last segment of the importee universe id, with a reasonId. */
+        universeTo?: string;
     };
     /** Added in schema 1.1; optional in TypeScript so 1.0 consumer-owned values remain valid. */
     nextAction?: string;
@@ -347,6 +799,17 @@ declare const ARK_ANALYSIS_RESULT_SCHEMA: {
                                 readonly type: "string";
                                 readonly minLength: 1;
                             };
+                            readonly reasonId: {
+                                readonly enum: readonly ["CROSS_PARENT_SLICE", "CROSS_SIBLING_SLICE", "CROSS_PARENT_VIA_SHARED"];
+                            };
+                            readonly universeFrom: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly universeTo: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
                         };
                     };
                     readonly nextAction: {
@@ -397,9 +860,6 @@ declare function createAdapterResult(input: {
     warnings?: readonly AdapterViolationInput[];
 }): CurrentAdapterResult;
 
-/** ArkGate library version — single source of truth. */
-declare const version = "4.8.23";
-
 /**
  * AI Code Gate (basic).
  *
@@ -420,6 +880,12 @@ interface AICodeGateViolation {
     toLayer?: string;
     /** Nested-wall reason. Absent on a classic layer deny and on a child-only parent import. */
     reasonId?: string;
+    /** Last segment of the importer universe id, with a reasonId. */
+    universeFrom?: string;
+    /** Last segment of the importee universe id, with a reasonId. */
+    universeTo?: string;
+    /** True when a peerIsolation rule produced this finding (also mirrored in details). */
+    peerIsolation?: boolean;
     /** False for an advisory sibling crossing. Omitted findings still block the snippet. */
     failsStrict?: boolean;
     details?: unknown;
@@ -451,11 +917,6 @@ interface AICodeGate<Context = AICodeGateContext> {
     validate(source: string, context?: Context): AICodeGateResult;
 }
 
-declare function createArchitectureProfile(options: CreateArchitectureProfileOptions): ArchitectureProfile;
-declare function createArchitectureProfileFromArkConfig(config: ArkCheckConfig, options?: CreateArchitectureProfileFromArkConfigOptions): ArchitectureProfile;
-declare const elevenLayerProfile: ArchitectureProfile;
-declare function createElevenLayerArkConfig(options?: CreateElevenLayerArkConfigOptions): ArkCheckConfig;
-
 /**
  * Basic AI Code Gate implementation.
  *
@@ -551,6 +1012,10 @@ declare function deterministicHash(value: string): string;
 /** Serialize JSON-like values with sorted object keys for reproducible hashes. */
 declare function stableSerialize(value: unknown): string;
 
+/**
+ * ArkOrder resolver-fact extraction (ADR 0029). Syntax only — no verdicts.
+ */
+
 type ResolvedArkOrderPlaneCallFact = {
     file: string;
     line: number;
@@ -580,6 +1045,18 @@ type ResolvedArkOrderReleaseKeyCountFact = {
     line: number;
     keyCount: number;
 };
+/** A freshness key (ttl/freshUntil/maxAge) inside the ξ literal of plane.release / proposeRelease. */
+type ResolvedArkOrderXiTtlFact = {
+    file: string;
+    line: number;
+    key: string;
+};
+/** A literal `allowedKinds` entry that a literal `informationBudget.cannotObserve` denies. */
+type ResolvedArkOrderBudgetLeakFact = {
+    file: string;
+    line: number;
+    kind: string;
+};
 
 /**
  * Versioned type vocabulary for resolved candidate facts (schema 1.0).
@@ -655,6 +1132,8 @@ type ResolvedClassShapeFact = {
         referencesGuardOrPublish: boolean;
     }[];
     dataOnly?: boolean;
+    /** Source offset where the class-shape scan stopped (unwalkable body/header). */
+    truncatedUntil?: number;
 };
 type ResolvedDependencyFact = {
     from: string;
@@ -734,8 +1213,10 @@ type ResolvedCandidateFactsInput = {
     arkOrderXiFieldWrites?: readonly ResolvedArkOrderXiFieldWriteFact[];
     arkOrderIngestWritesXi?: readonly ResolvedArkOrderIngestWriteFact[];
     arkOrderReleaseKeyCounts?: readonly ResolvedArkOrderReleaseKeyCountFact[];
+    arkOrderXiTtlKeys?: readonly ResolvedArkOrderXiTtlFact[];
+    arkOrderBudgetLeaks?: readonly ResolvedArkOrderBudgetLeakFact[];
 };
-type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash' | 'classShapes' | 'arkRunKernelCalls' | 'arkOrderPlaneCalls' | 'arkOrderGenericUpdates' | 'arkOrderXiFieldWrites' | 'arkOrderIngestWritesXi' | 'arkOrderReleaseKeyCounts' | 'arkOrderRootHits' | 'arkRunManagedNews' | 'arkRunCompositionRootHits' | 'arkRunDeclarations'> & {
+type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHash' | 'classShapes' | 'arkRunKernelCalls' | 'arkOrderPlaneCalls' | 'arkOrderGenericUpdates' | 'arkOrderXiFieldWrites' | 'arkOrderIngestWritesXi' | 'arkOrderReleaseKeyCounts' | 'arkOrderXiTtlKeys' | 'arkOrderBudgetLeaks' | 'arkOrderRootHits' | 'arkRunManagedNews' | 'arkRunCompositionRootHits' | 'arkRunDeclarations'> & {
     schemaVersion: typeof RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION;
     completenessReasons: ResolvedFactsReason[];
     candidateTreeHash: string;
@@ -757,6 +1238,8 @@ type ResolvedCandidateFacts = Omit<ResolvedCandidateFactsInput, 'candidateTreeHa
     arkOrderXiFieldWrites: ResolvedArkOrderXiFieldWriteFact[];
     arkOrderIngestWritesXi: ResolvedArkOrderIngestWriteFact[];
     arkOrderReleaseKeyCounts: ResolvedArkOrderReleaseKeyCountFact[];
+    arkOrderXiTtlKeys: ResolvedArkOrderXiTtlFact[];
+    arkOrderBudgetLeaks: ResolvedArkOrderBudgetLeakFact[];
     factsHash: string;
 };
 
@@ -1180,6 +1663,10 @@ declare const RESOLVED_CANDIDATE_FACTS_SCHEMA: {
                     readonly dataOnly: {
                         readonly type: "boolean";
                     };
+                    readonly truncatedUntil: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
                     readonly mutatingMethods: {
                         readonly type: "array";
                         readonly items: {
@@ -1466,6 +1953,52 @@ declare const RESOLVED_CANDIDATE_FACTS_SCHEMA: {
                 };
             };
         };
+        readonly arkOrderXiTtlKeys: {
+            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 arkOrderBudgetLeaks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["file", "line", "kind"];
+                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 kind: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
         readonly factsHash: {
             readonly type: "string";
             readonly minLength: 1;
@@ -1698,17 +2231,12 @@ type ArkRuleInvariantEntry = {
     mode?: ArkRuleMode;
     appliesTo?: string[];
 };
-type ArkRulesFile = {
-    $schema?: string;
-    schemaVersion: '1.0';
-    layer: string;
-    structure?: ArkRuleStructureEntry[];
-    invariants?: ArkRuleInvariantEntry[];
-};
 type ArkRuleProvenance = {
     sourceFile: string;
     ruleId: string;
     layer: string;
+    /** Set when the rule was read from a child-slice file. Absent on central files. */
+    childId?: string;
 };
 type EffectiveStructureRule = ArkRuleStructureEntry & {
     mode: ArkRuleMode;
@@ -1722,6 +2250,8 @@ type EffectiveArkRules = {
     schemaVersion: '1.0';
     byLayer: Record<string, {
         sourceFile: string;
+        /** Every file merged into this layer, central paths first. Absent on older catalogs. */
+        sourceFiles?: string[];
         structure: EffectiveStructureRule[];
         invariants: EffectiveInvariantRule[];
     }>;
@@ -1729,6 +2259,30 @@ type EffectiveArkRules = {
     invariants: EffectiveInvariantRule[];
 };
 
+/** Priority order: guard-family operators first, constants last. */
+declare const INVARIANT_PROBE_OPERATORS: readonly ["negate-guard", "drop-throw", "flip-comparison", "boundary-shift", "const-shift"];
+type ProbeOperator = (typeof INVARIANT_PROBE_OPERATORS)[number];
+declare const INVARIANT_PROBE_VERDICTS: readonly ["killed", "survived", "not-reached", "inconclusive", "unprobeable"];
+type ProbeVerdict = (typeof INVARIANT_PROBE_VERDICTS)[number];
+declare const INVARIANT_PROBE_REASONS: readonly ["all-killed", "mutant-survived", "reach-canary-survived", "baseline-red", "baseline-timeout", "runner-error", "file-not-loaded", "mutant-runtime-error", "no-symbol", "declaration-only", "symbol-not-found", "no-covering-test", "no-site"];
+type ProbeReason = (typeof INVARIANT_PROBE_REASONS)[number];
+/** What promotion and status read from one row. */
+type InvariantProbeSummary = {
+    verdict: ProbeVerdict;
+    reason: ProbeReason;
+    /** False when a hashed input changed since the run; a stale row changes nothing. */
+    fresh: boolean;
+    survivors: Array<{
+        operator: ProbeOperator;
+        line: number;
+        original: string;
+        replacement: string;
+    }>;
+    staleBecause?: string[];
+    symbolFile?: string;
+    probedOn?: string;
+};
+
 /**
  * Pure invariant coverage evidence (ADR 0014 / AR09–AR10).
  *
@@ -1744,53 +2298,6 @@ type EffectiveArkRules = {
  * method.
  */
 type DeclarationShape = 'function' | 'class' | 'const' | 'method' | 'type' | 'interface' | 'enum';
-/** Where a bare mention of an id or symbol sat. Never coverage. */
-type MentionContext = 'test-body' | 'comment' | 'string' | 'import';
-/**
- * One coverage verdict. Best evidence wins: test-title, then declaration,
- * then mention-only, then none. A comment in another file, when the symbol
- * still occurs in code, is `declaration-miss` and does not count.
- * Regexes, the test-file vs source split, and `Aggregate.method` lookup stay
- * behind this value.
- */
-type CoverageEvidence = {
-    kind: 'test-title';
-    file: string;
-    title: string;
-} | {
-    kind: 'declaration';
-    file: string;
-    shape: DeclarationShape;
-} | {
-    kind: 'mention-only';
-    file: string;
-    context: MentionContext;
-} | {
-    kind: 'declaration-miss';
-    symbol: string;
-} | {
-    kind: 'none';
-};
-/** Invariant fields the classifier reads. A full catalog entry is assignable. */
-type CoverageInvariant = {
-    id: string;
-    coverage?: {
-        test?: boolean;
-        symbol?: string;
-    } | null;
-};
-/** File set the classifier reads. Tooling has already loaded the contents. */
-type CoverageFiles = {
-    /** Project-relative path → file contents (tests and sources). */
-    fileContents: Readonly<Record<string, string>>;
-    /** Paths already classified as tests. */
-    testFiles?: readonly string[];
-    /**
-     * Declared runner roots. A test title inside a root beats one outside it.
-     * The outside-roots finding stays a separate verdict.
-     */
-    coverageRoots?: readonly string[];
-};
 type InvariantCoverageEvidence = {
     invariantId: string;
     layer: string;
@@ -1828,48 +2335,13 @@ type InvariantCoverageEvidence = {
      * so existing promote fixtures stay valid; the evaluator always sets it.
      */
     coverageRootsDeclared?: boolean;
-};
-type InvariantUncoveredKind = 'never-had-tests' | 'tests-disappeared';
-type InvariantCoverageRuleId = 'INVARIANT_UNCOVERED' | 'INVARIANT_COVERAGE_OUTSIDE_ROOTS';
-type InvariantCoverageViolation = {
-    ruleId: InvariantCoverageRuleId;
-    message: string;
-    file: string;
-    line: number;
-    arkruleId: string;
-    arkruleSource: string;
-    fromLayer: string;
-    severity: 'error' | 'warning';
-    failsStrict: boolean;
-    /**
-     * 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;
-    /** Project-relative path → file contents (tests + domain sources). */
-    fileContents: Readonly<Record<string, string>>;
-    /** Paths considered tests (already filtered by Tooling via globs). */
-    testFiles?: readonly string[];
-    /** When true, missing test files make coverage partial (never green covered). */
-    testGlobsMissing?: boolean;
-    /**
-     * Tooling hit MAX_COVERAGE_FILES. Partial must not claim the repo never had tests —
-     * 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.
+     * Committed mutation-probe evidence for this invariant (ADR 0039), attached
+     * by Tooling when `.ark/invariant-probe.json` has a row. Additive: absent on
+     * every evaluation that has no artifact. Only a fresh `survived` /
+     * `not-reached` changes promotion; every other state changes nothing.
      */
-    coverageRoots?: readonly string[];
+    probe?: InvariantProbeSummary;
 };
 /**
  * What the Tooling scan actually saw. Every discard has a counted reason —
@@ -1911,31 +2383,6 @@ type InvariantCoverageStats = {
         outOfRoot: number;
     };
 };
-/**
- * Best coverage evidence for `invariant` in `files`.
- * test-title beats a declaration; a declaration beats a bare mention; a bare
- * mention beats silence. Callers do not re-scan to explain the verdict.
- */
-declare function classifyCoverage(invariant: CoverageInvariant, files: CoverageFiles): CoverageEvidence;
-/**
- * Policy: a test title or any declaration counts, including type, interface,
- * and enum. A mention-only verdict never counts. `none` does not count.
- */
-declare function countsAsCoverage(ev: CoverageEvidence): boolean;
-/** Sentence for the verdict. `INVARIANT_UNCOVERED` prints this; it does not re-derive it. */
-declare function describeCoverage(invariant: CoverageInvariant, ev: CoverageEvidence): string;
-declare function evaluateInvariantCoverage(input: EvaluateInvariantCoverageInput): {
-    coverage: InvariantCoverageEvidence[];
-    violations: InvariantCoverageViolation[];
-    partial: boolean;
-};
-/**
- * Deterministic promotion gate: refuse advisory→enforced when invariant is uncovered.
- */
-declare function canPromoteInvariant(coverage: InvariantCoverageEvidence | undefined): {
-    ok: boolean;
-    reason: string;
-};
 
 /**
  * Pure ArkRules structure sensor evaluation (ADR 0013).
@@ -1958,85 +2405,37 @@ type ClassShapeFact = {
     }[];
     /** Heuristic: data-only class (fields, no methods beyond accessors). */
     dataOnly?: boolean;
-};
-type ArkRuleSensorViolation = {
-    ruleId: string;
-    code: string;
-    message: string;
-    file: string;
-    line: number;
-    fromLayer?: string;
-    arkruleId: string;
-    arkruleSource: string;
-    severity: 'error' | 'warning';
-    sensor: ArkRuleSensorId;
-    /** When true, advisory surfaces only (does not fail strict). */
-    failsStrict: boolean;
-};
-type EvaluateArkRuleSensorsInput = {
-    arkRules: EffectiveArkRules;
-    classShapes: readonly ClassShapeFact[];
-    /** Project-relative paths in scope for the analysis. */
-    files: readonly string[];
-    /**
-     * Optional layer membership: path → layer name. When omitted, structure rules
-     * apply by appliesTo globs only (or all files when appliesTo is absent).
-     */
-    layerForFile?: (path: string) => string | null | undefined;
     /**
-     * Optional thin/orchestration heuristic flags per file (Tooling-supplied).
+     * Set when the scanner could not walk the class to its end: the character
+     * offset (in the source file) where analysis stopped. Enumerable on purpose so
+     * it survives fact canonicalisation and serialisation; enforced structure
+     * sensors report it instead of passing in silence.
      */
-    fileHints?: Readonly<Record<string, {
-        orchestrationHeavy?: boolean;
-        adapterThick?: boolean;
-        persistenceWrite?: boolean;
-    }>>;
-};
-/**
- * Evaluate all structure sensors. Empty Effective Contract → no findings (byte-for-byte parity).
- */
-declare function evaluateArkRuleSensors(input: EvaluateArkRuleSensorsInput): ArkRuleSensorViolation[];
-/**
- * ADR 0012 D3 — a structure rule whose appliesTo matches zero governed files is
- * never silent green. Advisory → warning; enforced → failsStrict.
- * Rules without appliesTo (whole-layer) never emit this signal.
- */
-declare function collectEmptyAppliesToFindings(arkRules: EffectiveArkRules, files: readonly string[]): ArkRuleSensorViolation[];
-/** Optional resolved-import facts when the collector already classified the specifier. */
-type ResolvedPersistenceImportFact = {
-    specifier?: string;
-    resolvedFile?: string;
-    layer?: string | null;
+    truncatedUntil?: number;
 };
+
 /**
- * Pure Tooling/Domain heuristic for orchestration-only / thin-adapter fileHints.
- * Prefers false negatives over false positives (ADR 0013 discipline).
- * Returns null when neither flag is set (callers may omit the path).
- */
-declare function deriveArkRuleFileHints(_file: string, content: string, resolvedImports?: readonly ResolvedPersistenceImportFact[]): {
-    orchestrationHeavy?: boolean;
-    adapterThick?: boolean;
-    persistenceWrite?: boolean;
-} | null;
-/**
- * Build fileHints map from path→content. Omits paths with no flags (sparse map).
- */
-declare function buildArkRuleFileHints(fileContents: Readonly<Record<string, string>>, resolvedImportsByFile?: Readonly<Record<string, readonly ResolvedPersistenceImportFact[]>>): Record<string, {
-    orchestrationHeavy?: boolean;
-    adapterThick?: boolean;
-    persistenceWrite?: boolean;
-}>;
-/**
- * Lightweight class-shape extraction from TypeScript source text (no compiler).
- * Conservative: prefers false negatives over false positives for mutability.
- * Tooling may replace with TypeScript-API facts; sensors consume the same shape.
+ * Config-key version floors plus pin evidence (#338).
  *
- * Limitation (AR05/AR06): only `export class` / `export abstract class` forms.
- * `export default class`, re-exported classes, and non-exported aggregates are
- * invisible — enforced structure sensors stay silent (false negative). Silence
- * is never proof of compliance.
+ * A slice key such as `childSlices` is rejected at config load by an older
+ * arkgate (the rule schema sets `additionalProperties: false`). ArkGate warns
+ * about that only with evidence that this repo pins such an older arkgate: an
+ * exact package.json dependency, the installed copy, the lockfile, a hook
+ * script, or a CI workflow. Without evidence it stays silent.
+ *
+ * Pure: Tooling reads the files and passes their text here.
  */
-declare function extractClassShapesFromSource(file: string, content: string): ClassShapeFact[];
+/** Where a pin was found. */
+type ArkgatePinSource = 'package-json' | 'package-lock' | 'installed' | 'hook' | 'ci';
+type ArkgatePinEvidence = {
+    /** Repo-relative file that pins arkgate. */
+    file: string;
+    /** 1-based line of the pin. */
+    line: number;
+    /** Pinned version, without a leading `v`. */
+    version: string;
+    source: ArkgatePinSource;
+};
 
 declare const POLICY_DELTA_SCHEMA_VERSION: "1.0";
 type PolicyDeltaClassification = 'strengthening' | 'neutral' | 'judgment-required' | 'weakening';
@@ -2116,6 +2515,10 @@ type AnalysisResult = {
 type AnalyzeResolvedProjectInput = {
     contract: AnalysisContract;
     facts: unknown;
+    /** Tooling FS evidence of arkgate pins. Omitted: version-floor warnings stay silent. */
+    arkgatePins?: readonly ArkgatePinEvidence[];
+    /** The running arkgate version, for the version-floor nextAction. */
+    runningArkgateVersion?: string;
     /**
      * D0 adopted or --require-gates / --strict-merge. When true, a missing
      * domain-invariant tests path fails closed. Omitted stays silent.
@@ -2158,12 +2561,20 @@ type AnalyzeResolvedProjectInput = {
         persistenceWrite?: boolean;
     }>>;
 };
+/** Tooling-supplied analysis evidence for one side (base or candidate) of a preflight. */
+type ResolvedAnalysisSideInputs = Pick<AnalyzeResolvedProjectInput, 'adopted' | 'invariantTestsPathPresent' | 'coverageRootsPresent' | 'coverageInputs' | 'fileHints'>;
 type PreflightResolvedChangeInput = {
     contract: AnalysisContract;
     baseFacts: unknown;
     candidateFacts: unknown;
     changes: readonly AnalysisFileChange[];
     changeMap?: ArchitectureChangeMapContract;
+    /**
+     * ArkRules evidence (coverage contents, structural hints) for the on-disk base and
+     * the in-memory candidate, so preflight runs the same engine inputs as ark-check.
+     */
+    baseAnalysisInputs?: ResolvedAnalysisSideInputs;
+    candidateAnalysisInputs?: ResolvedAnalysisSideInputs;
 };
 type ResolvedAnalysisFile = ResolvedFileFact & {
     layer: string | null;
@@ -2342,6 +2753,13 @@ type CollectAnalysisConfigWarningsInput = {
     config: ArkConfig;
     rules: ArkConfig['rules'];
     files: readonly string[];
+    /**
+     * Tooling FS evidence of arkgate pins in this repo (package.json, lockfile,
+     * installed copy, hook scripts, CI). Omitted: version-floor warnings stay silent.
+     */
+    arkgatePins?: readonly ArkgatePinEvidence[];
+    /** The running arkgate version. The version-floor nextAction targets it when newer. */
+    runningArkgateVersion?: string;
     manifest?: {
         architecture?: {
             layers?: readonly {
@@ -2390,6 +2808,8 @@ declare function analyzeResolvedProject(input: AnalyzeResolvedProjectInput): Res
  */
 declare function preflightChange(input: AnalyzeChangeInput): ChangePreflightResult;
 
+/** Atomic preflight over one validated base/candidate facts pair (ADR 0011). */
+
 /**
  * Validate that the supplied candidate is exactly the declared in-memory
  * overlay, then return its canonical resolved verdict. No project file is read
@@ -2400,6 +2820,89 @@ declare function preflightResolvedChange(input: PreflightResolvedChangeInput): R
 /** Canonical config diagnostics over repo-relative file paths. */
 declare function collectAnalysisConfigWarnings(input: CollectAnalysisConfigWarningsInput): ArchitectureEngineViolation[];
 
+/**
+ * Public diagnostic code catalog (ACS02).
+ *
+ * Closed vocabulary of stable `ruleId` values emitted by ArkGate adapters with
+ * human/agent `why` / `fix` anchors and docs fragment ids. Cataloguing only —
+ * no new rule semantics, no LLM verdict, no enforcement from prose.
+ *
+ * **Canonical** for docs, agent projection (ACS04), and finding refs (ACS06).
+ * Runtime remediation remains in `remediation.ts`; parity tests bind the two.
+ *
+ * Zero Node I/O. Optional CLI surface: generated `bin/lib/diagnostic-catalog.mjs`.
+ *
+ * @see docs/diagnostics.md
+ * @see docs/plans/agent-contract-surface-4.3/README.md
+ */
+/** Product-relative docs path (shipped in the npm tarball when listed in package files). */
+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' | 'drift' | 'snippet-policy' | 'config' | 'adapter' | 'meta';
+type DiagnosticCatalogEntry = {
+    /** Stable public violation / diagnostic id. */
+    ruleId: string;
+    /** Short title for indexes and agent projection. */
+    title: string;
+    /** Why this finding exists (contract intent). */
+    why: string;
+    /**
+     * Canonical fix guidance (agent + human). Contextual nextAction on live
+     * findings may specialize this (e.g. type-only vs value layer import).
+     */
+    fix: string;
+    /** Markdown fragment id for docs/diagnostics.md (without leading #). */
+    docsAnchor: string;
+    category: DiagnosticCategory;
+    /**
+     * When true, finding is commonly advisory / non-blocking in default profiles
+     * (doctor/config warnings, type-only placement debt, empty ArkRule scope).
+     * Not a severity bit for the engine — documentation only.
+     */
+    oftenAdvisory?: boolean;
+};
+/**
+ * Closed public catalog. Order is stable (category groups, then ruleId) for
+ * deterministic serialization and docs generation.
+ *
+ * Every production-emitted `ruleId` must appear here. Remediation switch cases
+ * and adapter nextAction branches are parity-tested against this list.
+ */
+declare const DIAGNOSTIC_CATALOG: readonly DiagnosticCatalogEntry[];
+/** All public ruleIds in catalog order. */
+declare const DIAGNOSTIC_RULE_IDS: readonly string[];
+declare function isKnownDiagnosticCode(ruleId: string | null | undefined): boolean;
+/**
+ * True when the code is catalogued or is an ArkRule-family id handled by the
+ * ARKRULE_* prefix fallback in remediation (structure sensors may add members later
+ * only via catalog + ROADMAP — prefix alone is not a license for free-form ids).
+ */
+declare function isCataloguedOrArkRuleFamily(ruleId: string | null | undefined): boolean;
+declare function getDiagnosticCatalogEntry(ruleId: string | null | undefined): DiagnosticCatalogEntry | undefined;
+/** Fragment for docs links, e.g. `#LAYER_IMPORT_VIOLATION`. */
+declare function diagnosticDocsFragment(ruleId: string): string;
+/**
+ * Repo-relative docs path with fragment (for agents and JSON).
+ * Package consumers resolve against the installed package root or GitHub tree.
+ */
+declare function diagnosticDocsPath(ruleId: string): string;
+/** Catalog snapshot for JSON export / agent projection (stable field order). */
+declare function serializeDiagnosticCatalog(): {
+    schemaVersion: typeof DIAGNOSTIC_CATALOG_SCHEMA_VERSION;
+    docsPath: typeof DIAGNOSTIC_DOCS_RELATIVE_PATH;
+    codes: readonly DiagnosticCatalogEntry[];
+};
+/**
+ * Static catalog fix for a ruleId when no live violation context is available.
+ * Live adapters should still use deterministicNextAction for specialized edges.
+ */
+declare function catalogFixForRuleId(ruleId: string | null | undefined): string | undefined;
+/**
+ * Static catalog why for a ruleId (agent “why” surface).
+ */
+declare function catalogWhyForRuleId(ruleId: string | null | undefined): string | undefined;
+
 /** Public, evidence-backed enforcement state shared by doctor adapters. */
 declare const ARK_ENFORCEMENT_STATE_SCHEMA_VERSION: "1.1";
 type EnforcementVerification = boolean | 'unverified';
@@ -2491,86 +2994,135 @@ type ArkDesignDeltaResult = {
 };
 
 /**
- * Public diagnostic code catalog (ACS02).
- *
- * Closed vocabulary of stable `ruleId` values emitted by ArkGate adapters with
- * human/agent `why` / `fix` anchors and docs fragment ids. Cataloguing only —
- * no new rule semantics, no LLM verdict, no enforcement from prose.
- *
- * **Canonical** for docs, agent projection (ACS04), and finding refs (ACS06).
- * Runtime remediation remains in `remediation.ts`; parity tests bind the two.
- *
- * Zero Node I/O. Optional CLI surface: generated `bin/lib/diagnostic-catalog.mjs`.
- *
- * @see docs/diagnostics.md
- * @see docs/plans/agent-contract-surface-4.3/README.md
+ * In-memory shadow / replay / compare for ArkRun information packages (XP07 / ADR 0033).
+ * Not durable. Not a second bus. Stripped snapshots only.
  */
-/** Product-relative docs path (shipped in the npm tarball when listed in package files). */
-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' | 'drift' | 'snippet-policy' | 'config' | 'adapter' | 'meta';
-type DiagnosticCatalogEntry = {
-    /** Stable public violation / diagnostic id. */
-    ruleId: string;
-    /** Short title for indexes and agent projection. */
-    title: string;
-    /** Why this finding exists (contract intent). */
-    why: string;
-    /**
-     * Canonical fix guidance (agent + human). Contextual nextAction on live
-     * findings may specialize this (e.g. type-only vs value layer import).
-     */
-    fix: string;
-    /** Markdown fragment id for docs/diagnostics.md (without leading #). */
-    docsAnchor: string;
-    category: DiagnosticCategory;
-    /**
-     * When true, finding is commonly advisory / non-blocking in default profiles
-     * (doctor/config warnings, type-only placement debt, empty ArkRule scope).
-     * Not a severity bit for the engine — documentation only.
-     */
-    oftenAdvisory?: boolean;
-};
+
+type InformationPackageDiff = {
+    readonly path: string;
+    readonly left: unknown;
+    readonly right: unknown;
+};
+type InformationPackageCompare = {
+    readonly equal: boolean;
+    readonly diffs: readonly InformationPackageDiff[];
+};
+/** Shadow: identity snapshot. The live kernel is not copied. */
+declare function shadowInformationPackage(pack: DependencyInformationPackage): DependencyInformationPackage;
+declare function compareInformationPackages(left: DependencyInformationPackage, right: DependencyInformationPackage): InformationPackageCompare;
 /**
- * Closed public catalog. Order is stable (category groups, then ruleId) for
- * deterministic serialization and docs generation.
- *
- * Every production-emitted `ruleId` must appear here. Remediation switch cases
- * and adapter nextAction branches are parity-tested against this list.
+ * Replay: apply sequential snapshots as the "tape". Each step is compared to
+ * the previous shadow. No bus, no store, no time travel across processes.
  */
-declare const DIAGNOSTIC_CATALOG: readonly DiagnosticCatalogEntry[];
-/** All public ruleIds in catalog order. */
-declare const DIAGNOSTIC_RULE_IDS: readonly string[];
-declare function isKnownDiagnosticCode(ruleId: string | null | undefined): boolean;
+declare function replayInformationPackages(tape: readonly DependencyInformationPackage[]): InformationPackageCompare[];
+
 /**
- * True when the code is catalogued or is an ArkRule-family id handled by the
- * ARKRULE_* prefix fallback in remediation (structure sensors may add members later
- * only via catalog + ROADMAP — prefix alone is not a license for free-form ids).
+ * Default cap for in-memory history, trace, audit, and default event-buffer
+ * records. Without a cap a long-running process grows without bound on every
+ * publish. Pass `maxHistorySize: Infinity` to explicitly opt back into unbounded
+ * retention. An injected `eventBuffer` owns its own retention.
  */
-declare function isCataloguedOrArkRuleFamily(ruleId: string | null | undefined): boolean;
-declare function getDiagnosticCatalogEntry(ruleId: string | null | undefined): DiagnosticCatalogEntry | undefined;
-/** Fragment for docs links, e.g. `#LAYER_IMPORT_VIOLATION`. */
-declare function diagnosticDocsFragment(ruleId: string): string;
+declare const DEFAULT_MAX_HISTORY_SIZE = 1000;
+declare function createArkKernel(options?: CreateArkKernelOptions): ArkKernel;
 /**
- * Repo-relative docs path with fragment (for agents and JSON).
- * Package consumers resolve against the installed package root or GitHub tree.
+ * Preferred ArkRun factory. Each call is a new isolated instance — there is no
+ * process-wide singleton.
  */
-declare function diagnosticDocsPath(ruleId: string): string;
-/** Catalog snapshot for JSON export / agent projection (stable field order). */
-declare function serializeDiagnosticCatalog(): {
-    schemaVersion: typeof DIAGNOSTIC_CATALOG_SCHEMA_VERSION;
-    docsPath: typeof DIAGNOSTIC_DOCS_RELATIVE_PATH;
-    codes: readonly DiagnosticCatalogEntry[];
-};
+declare function createStrictArkKernel(options?: CreateArkKernelOptions): ArkKernel;
+declare function createArkKernelFromConfig(config: ArkKernelConfig, options?: CreateArkKernelFromConfigOptions): ArkKernel;
 /**
- * Static catalog fix for a ruleId when no live violation context is available.
- * Live adapters should still use deterministicNextAction for specialized edges.
+ * Strict kernel whose runtime layer profile comes from `ark.config.json`.
+ * Hard observed-layer-flow needs every layer a deny rule names to resolve an
+ * intent: declared `intentPrefixes`, or a canonical 11-layer name (`DomainModel`,
+ * `ApplicationOrchestration`, … — what `ark init` writes) which gets the built-in
+ * prefixes. A custom-named deny layer without prefixes is recorded as a
+ * `layer.observedFlowUnresolvable` audit record (`ARKRUN_LAYER_FLOW_UNRESOLVABLE`);
+ * passing `enforceObservedLayerFlow: 'hard'` explicitly throws `ArkKernelConfigError`
+ * instead.
  */
-declare function catalogFixForRuleId(ruleId: string | null | undefined): string | undefined;
+declare function createStrictArkKernelFromConfig(config: ArkKernelConfig, options?: CreateArkKernelFromConfigOptions): ArkKernel;
+declare function createLenientArkKernelFromConfig(config: ArkKernelConfig, options?: CreateArkKernelFromConfigOptions): ArkKernel;
+declare function createLenientArkKernel(options?: CreateArkKernelOptions): ArkKernel;
+
+interface ArkTestSnapshot {
+    events: DomainEvent[];
+    traces: TraceRecord[];
+    audit: AuditRecord[];
+    outbox: OutboxRecord[];
+    observability: ObservabilityDriftReport;
+}
+interface ArkTestHarness {
+    events(intent?: string): DomainEvent[];
+    traces(type?: TraceRecordType): TraceRecord[];
+    audit(query?: AuditQuery): Promise<AuditRecord[]>;
+    outbox(status?: OutboxStatus): Promise<OutboxRecord[]>;
+    observability(): ObservabilityDriftReport;
+    snapshot(): Promise<ArkTestSnapshot>;
+    clear(): Promise<void>;
+}
+
+declare function createArkTestHarness(kernel: ArkKernel): ArkTestHarness;
+
 /**
- * Static catalog why for a ruleId (agent “why” surface).
+ * Ports & Adapters basic contracts.
  */
-declare function catalogWhyForRuleId(ruleId: string | null | undefined): string | undefined;
+interface Port<T = unknown> {
+    readonly name: string;
+    readonly ownerLayer?: string;
+    readonly intent?: IntentName;
+    readonly allowedAdapters?: string[];
+    readonly __port?: T;
+}
+interface Adapter<T = unknown> {
+    readonly name?: string;
+    readonly layer?: string;
+    readonly intent?: IntentName;
+    readonly port: Port<T>;
+    readonly impl: T;
+}
+interface DefinePortOptions {
+    ownerLayer?: string;
+    intent?: IntentName;
+    allowedAdapters?: string[];
+}
+interface CreateAdapterOptions {
+    name?: string;
+    layer?: string;
+    intent?: IntentName;
+    requiredKeys?: string[];
+}
+/**
+ * Simple contract checker (duck typing + optional required keys).
+ */
+type ContractCheckResult = {
+    ok: true;
+} | {
+    ok: false;
+    missing: string[];
+};
+interface AdapterGovernanceIssue {
+    ruleId: 'ADAPTER_NOT_ALLOWED_FOR_PORT';
+    message: string;
+    port: string;
+    adapter?: string;
+}
+type AdapterGovernanceResult = {
+    ok: true;
+    issues: [];
+} | {
+    ok: false;
+    issues: AdapterGovernanceIssue[];
+};
+
+/**
+ * Ports and Adapters utilities.
+ *
+ * definePort + createAdapter with basic runtime contract validation.
+ */
+
+declare function definePort<T = unknown>(name: string, options?: DefinePortOptions): Port<T>;
+declare function createAdapter<T>(port: Port<T>, impl: T, requiredKeysOrOptions?: string[] | CreateAdapterOptions, adapterOptions?: CreateAdapterOptions): Adapter<T>;
+declare function checkContract(impl: unknown, requiredKeys?: string[]): ContractCheckResult;
+declare function checkAdapterGovernance(adapter: Adapter): AdapterGovernanceResult;
 
-export { type ArchitectureChangeMapFile as $, type AdapterViolationInput as A, type AdapterResult as B, type AdapterSeverity 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 ArkRulesFile as a, type ResolvedPublishFact 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 ForbiddenCapabilityUse as aA, type InvariantCoverageEvidence as aB, type MentionContext as aC, POLICY_DELTA_SCHEMA_VERSION as aD, type PolicyDelta as aE, type PolicyDeltaAcknowledgement as aF, type PolicyDeltaAnalysis as aG, type PolicyDeltaClassification as aH, type PolicyDeltaFinding as aI, type PreflightResolvedChangeInput as aJ, type PreparedChangeFile as aK, RESOLVED_CANDIDATE_FACTS_SCHEMA as aL, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION as aM, type ResolvedAmbientFact as aN, type ResolvedAnalysisFile as aO, type ResolvedAnalysisIr as aP, type ResolvedAnalysisResult as aQ, type ResolvedCandidateFacts as aR, type ResolvedCandidateFactsInput as aS, type ResolvedCapability as aT, type ResolvedCapabilityFact as aU, type ResolvedChangePreflightResult as aV, type ResolvedDependencyKind as aW, type ResolvedDependencyState as aX, type ResolvedFactsCompleteness as aY, type ResolvedFileFact as aZ, type ResolvedIntentReferenceFact as a_, type ArkEnforcementState as aa, type ArkRuleSensorViolation as ab, type ChangePreflightResult as ac, type ClassShapeFact as ad, type CollectAnalysisConfigWarningsInput as ae, type CoverageEvidence as af, type CoverageFiles as ag, type CoverageInvariant as ah, DIAGNOSTIC_CATALOG as ai, DIAGNOSTIC_CATALOG_SCHEMA_VERSION as aj, DIAGNOSTIC_DOCS_RELATIVE_PATH as ak, DIAGNOSTIC_RULE_IDS as al, type DeclarationShape as am, type DesignDeltaChange as an, type DesignDeltaEnforcementScope as ao, type DesignDeltaIdentity as ap, type DesignSmellEvidence as aq, type DesignSmellFinding as ar, type DesignSmellId as as, type DiagnosticCatalogEntry as at, type DiagnosticCategory as au, type EnforcementBoundaryState as av, type EnforcementEvidence as aw, type EnforcementEvidenceField as ax, type EnforcementVerification as ay, type EvaluateArchitectureGraphInput as az, type ResolvedArkRunDeclarationFact as b, type ResolvedSafetyFact as b0, type ResolvedSafetyKind as b1, type ResolvedSafetyReport as b2, type SemanticDependency as b3, type SemanticDependencyKind as b4, analyzeArchitectureConvergence as b5, analyzeChange as b6, analyzePolicyDelta as b7, analyzeProject as b8, analyzeResolvedProject as b9, explainViolation as bA, extractClassShapesFromSource as bB, extractSemanticDependencies as bC, getDiagnosticCatalogEntry as bD, isCataloguedOrArkRuleFamily as bE, isKnownDiagnosticCode as bF, loadContract as bG, loadResolvedCandidateFacts as bH, policyDeltaAcknowledgementMatches as bI, preflightChange as bJ, preflightResolvedChange as bK, resolvedFactsEvidenceRequirementsHash as bL, serializeDiagnosticCatalog as bM, stableSerialize as bN, toAdapterDiagnostic as bO, version as bP, buildArkRuleFileHints as ba, canPromoteInvariant as bb, catalogFixForRuleId as bc, catalogWhyForRuleId as bd, classifyArkPolicyDelta as be, classifyCoverage as bf, collectAnalysisConfigWarnings as bg, collectEmptyAppliesToFindings as bh, collectForbiddenCapabilityUses as bi, countsAsCoverage as bj, createAICodeGate as bk, createAdapterResult as bl, createArchitectureProfile as bm, createArchitectureProfileFromArkConfig as bn, createElevenLayerArkConfig as bo, createResolvedCandidateFacts as bp, deriveArkRuleFileHints as bq, describeCoverage as br, detectArchitectureCycles as bs, deterministicHash as bt, diagnosticDocsFragment as bu, diagnosticDocsPath as bv, elevenLayerProfile as bw, evaluateArchitectureGraph as bx, evaluateArkRuleSensors as by, evaluateInvariantCoverage as bz, type ResolvedArkRunKernelCallFact as c, type ResolvedArkRunManagedNewFact as d, type ResolvedDependencyFact as e, type ResolvedArkRunCompositionRootHitFact as f, type ResolvedFactsReason as g, type ResolvedArkOrderPlaneCallFact as h, type ResolvedArkOrderGenericUpdateFact as i, type ResolvedArkOrderRootHitFact as j, type ResolvedArkOrderXiFieldWriteFact as k, type ResolvedArkOrderIngestWriteFact as l, ADAPTER_DIAGNOSTIC_DOCS_RELATIVE_PATH as m, type AICodeGate as n, type AICodeGateContext as o, type AICodeGateOptions as p, type AICodeGateResult as q, type AICodeGateViolation as r, type AIGateExtension as s, ANALYSIS_IR_SCHEMA_VERSION as t, ARK_ANALYSIS_RESULT_SCHEMA as u, ARK_ANALYSIS_RESULT_SCHEMA_VERSION as v, ARK_DESIGN_DELTA_SCHEMA_VERSION as w, ARK_ENFORCEMENT_STATE_SCHEMA_VERSION as x, type AdapterCompletenessReason as y, type AdapterDiagnostic as z };
+export { type AICodeGate, type AICodeGateContext, type AICodeGateOptions, type AICodeGateResult, type AICodeGateViolation, type AIGateExtension, ANALYSIS_IR_SCHEMA_VERSION, ARK_ANALYSIS_RESULT_SCHEMA, ARK_ANALYSIS_RESULT_SCHEMA_VERSION, ARK_DESIGN_DELTA_SCHEMA_VERSION, ARK_ENFORCEMENT_STATE_SCHEMA_VERSION, type Adapter, type AdapterCompletenessReason, type AdapterDiagnostic, type AdapterGovernanceIssue, type AdapterGovernanceResult, type AdapterResult, type AdapterSeverity, type AdapterViolationInput, type AnalysisCapabilityUse, type AnalysisCompilerOptions, type AnalysisCompleteness, type AnalysisContract, type AnalysisEvidence, type AnalysisFile, type AnalysisFileChange, type AnalysisFileInput, type AnalysisImportEdge, type AnalysisIr, type AnalysisMode, type AnalysisResult, type AnalysisViolation, type AnalyzeArchitectureConvergenceInput, type AnalyzeChangeInput, type AnalyzePolicyDeltaInput, type AnalyzeProjectInput, type AnalyzeResolvedProjectInput, type ArchitectureActualChange, type ArchitectureChangeMap, type ArchitectureChangeMapContract, type ArchitectureChangeMapDependency, type ArchitectureChangeMapFile, type ArchitectureChangeOperation, type ArchitectureConvergenceClassification, type ArchitectureConvergenceFinding, type ArchitectureConvergenceResult, type ArchitectureDependency, type ArchitectureEngineEdge, type ArchitectureEngineResult, type ArchitectureEngineViolation, ArchitectureProfile, ArkCheckConfig, type ArkDesignDeltaResult, type ArkEnforcementHost, type ArkEnforcementState, ArkKernel, ArkKernelConfig, ArkKernelConfigError, ArkManifest, type ArkTestHarness, type ArkTestSnapshot, AuditQuery, AuditRecord, AuditStore, AuditTrail, type BuildPublishPolicyContextOptions, type ChangePreflightResult, type CollectAnalysisConfigWarningsInput, type ContractCheckResult, type CreateAdapterOptions, CreateArchitectureProfileFromArkConfigOptions, CreateArchitectureProfileOptions, CreateArkKernelFromConfigOptions, CreateArkKernelOptions, type CreateArkManifestOptions, CreateAuditTrailOptions, CreateElevenLayerArkConfigOptions, CreateObservabilityReporterOptions, CreateProjectionRegistryOptions, CreateWorkflowEngineOptions, DEFAULT_MAX_HISTORY_SIZE, DIAGNOSTIC_CATALOG, DIAGNOSTIC_CATALOG_SCHEMA_VERSION, DIAGNOSTIC_DOCS_RELATIVE_PATH, DIAGNOSTIC_RULE_IDS, DefineIntentOptions, type DefinePolicyOptions, type DefinePortOptions, DependencyGraph, DependencyInformationPackage, type DesignDeltaChange, type DesignDeltaEnforcementScope, type DesignDeltaIdentity, type DesignSmellEvidence, type DesignSmellFinding, type DesignSmellId, type DiagnosticCatalogEntry, type DiagnosticCategory, DomainEvent, type EnforcementBoundaryState, type EnforcementEvidence, type EnforcementEvidenceField, type EnforcementVerification, type EvaluateArchitectureGraphInput, EventBufferRecord, EventBufferStatus, EventBufferStore, EventBus, EventBusOptions, EventContract, EventContractRegistry, EventContractRegistryImpl, EventContractValidationResult, EventContractViolationError, type ForbiddenCapabilityUse, GraphEdge, type GraphPolicyContext, InMemoryAuditStore, InMemoryEventBuffer, type InMemoryEventBufferOptions, InMemoryOutboxStore, InMemoryReadModelStore, InMemoryWorkflowStore, type InformationPackageCompare, type InformationPackageDiff, IntentCreator, IntentCreator as IntentDefinition, IntentName, type IntentNameValidation, IntentRegistry, IntentRelationship, InvalidIntentNameError, type LayerFlowRule, LayerPolicyContextError, type LayerPolicyOptions, MANIFEST_SCHEMA_VERSION, MetadataRegistry, ObservabilityDriftReport, ObservabilityReporter, ObservedLayerFlowViolationError, OutboxRecord, OutboxStatus, POLICY_DELTA_SCHEMA_VERSION, Policy, type PolicyDelta, type PolicyDeltaAcknowledgement, type PolicyDeltaAnalysis, type PolicyDeltaClassification, type PolicyDeltaFinding, PolicyEnforcementMode, PolicyEngine, PolicySeverity, PolicyViolation, PolicyViolationError, type Port, type PreflightResolvedChangeInput, type PreparedChangeFile, ProjectionRegistry, type PublishPolicyContext, RESOLVED_CANDIDATE_FACTS_SCHEMA, RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION, ReadModelStore, type ResolvedAmbientFact, type ResolvedAnalysisFile, type ResolvedAnalysisIr, type ResolvedAnalysisResult, type ResolvedArkRunCompositionRootHitFact, type ResolvedArkRunDeclarationFact, type ResolvedArkRunKernelCallFact, type ResolvedArkRunKernelCallKind, type ResolvedArkRunManagedNewFact, type ResolvedCandidateFacts, type ResolvedCandidateFactsInput, type ResolvedCapability, type ResolvedCapabilityFact, type ResolvedChangePreflightResult, type ResolvedDependencyFact, type ResolvedDependencyKind, type ResolvedDependencyState, type ResolvedFactsCompleteness, type ResolvedFactsReason, type ResolvedFileFact, type ResolvedIntentReferenceFact, type ResolvedPublishFact, type ResolvedSafetyFact, type ResolvedSafetyKind, type ResolvedSafetyReport, SagaDefinition, SagaInstance, type SemanticDependency, type SemanticDependencyKind, SourceMetadataOverrideError, type SyncRegistryOptions, TraceRecord, TraceRecordType, UnknownEventSourceError, UnregisteredIntentError, WorkflowEngine, WorkflowSnapshot, WorkflowStore, analyzeArchitectureConvergence, analyzeChange, analyzePolicyDelta, analyzeProject, analyzeResolvedProject, architecturalPolicies, buildPublishPolicyContext, catalogFixForRuleId, catalogWhyForRuleId, checkAdapterGovernance, checkContract, classifyArkPolicyDelta, collectAnalysisConfigWarnings, collectForbiddenCapabilityUses, compareInformationPackages, createAICodeGate, createAdapter, createAdapterResult, createArchitectureProfile, createArchitectureProfileFromArkConfig, createArkKernel, createArkKernelFromConfig, createArkManifest, createArkTestHarness, createAuditTrail, createDependencyGraph, createElevenLayerArkConfig, createEventBus, createEventContractRegistry, createIntentRegistry, createLenientArkKernel, createLenientArkKernelFromConfig, createMetadataRegistry, createObservabilityReporter, createProjectionRegistry, createResolvedCandidateFacts, createSaga, createStrictArkKernel, createStrictArkKernelFromConfig, createWorkflowEngine, defaultIntentRegistry, defineArchitectureProfilePolicy, defineIntent, defineLayerPolicy, definePolicy, definePort, definePublishPolicy, detectArchitectureCycles, deterministicHash, diagnosticDocsFragment, diagnosticDocsPath, elevenLayerProfile, evaluateArchitectureGraph, explainViolation, extractSemanticDependencies, getDiagnosticCatalogEntry, isCataloguedOrArkRuleFamily, isKnownDiagnosticCode, isLayerPolicy, loadContract, loadResolvedCandidateFacts, policyDeltaAcknowledgementMatches, preflightChange, preflightResolvedChange, replayInformationPackages, resolvedFactsEvidenceRequirementsHash, serializeDiagnosticCatalog, shadowInformationPackage, stableSerialize, syncRegistryToGraph, toAdapterDiagnostic, validateIntentName, version };