arkgate 2.12.0 → 3.0.0

package/dist/index.d.ts

@@ -1,534 +1,337 @@
-import { I as IntentRegistry, a as IntentName, D as DefineIntentOptions, b as IntentCreator, P as PolicyViolation, c as PolicySeverity, d as PolicyEnforcementMode, e as Policy, f as CreateArchitectureProfileOptions, g as ArchitectureProfile, h as ArkCheckConfig, i as CreateArchitectureProfileFromArkConfigOptions, j as CreateElevenLayerArkConfigOptions, k as DependencyGraph, G as GraphEdge, l as IntentRelationship, m as AuditStore, n as AuditRecord, o as AuditQuery, p as CreateAuditTrailOptions, q as AuditTrail, E as EventContractRegistry, r as EventContract, s as DomainEvent, t as EventContractValidationResult, O as OutboxStore, u as OutboxRecord, v as OutboxStatus, w as EventBusOptions, x as EventBus, y as CreateObservabilityReporterOptions, z as ObservabilityReporter, M as MetadataRegistry, R as ReadModelStore, B as CreateProjectionRegistryOptions, F as ProjectionRegistry, 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, C as CreateArkKernelOptions, A as ArkKernel, U as ArkKernelConfig, V as CreateArkKernelFromConfigOptions, X as TraceRecordType, Y as TraceRecord, Z as ObservabilityDriftReport } from './types-BZ17b9i5.js';
-export { _ as ArchitectureLayer, $ as ArchitectureLayerConfig, a0 as ArchitectureRule, a1 as ArkManifestArchitecture, a2 as ArkManifestData, a3 as ArkManifestEntityLink, a4 as ArkManifestGraph, a5 as ArkManifestIntent, a6 as ArkManifestPolicy, a7 as ArkManifestProjection, a8 as AuditRecordInput, a9 as AuditRecordType, aa as CorrelationId, ab as EntityMeta, ac as EventContractIssue, ad as EventHandler, ae as EventInterceptionInfo, af as EventInterceptor, ag as EventInterceptorContext, ah as EventMetadata, ai as EventPayloadPatch, aj as EventPayloadSchema, ak as EventPublisher, al as EventSchemaField, am as EventSchemaFieldType, an as FieldMeta, ao as GraphNode, ap as IntentRelationshipKind, aq as ObservabilityFlow, ar as ObservedLayerFlowMode, as as PolicyEvaluationResult, at as ProjectionCheckpoint, au as ProjectionDefinition, av as PublishedEventRecord, aw as RetryPolicy, ax as SagaStatus, ay as SagaStep, az as TraceSink, aA as Unsubscribe, aB as WorkflowDefinition, aC as WorkflowStatus, aD as WorkflowStep } from './types-BZ17b9i5.js';
+import { a as ArkConfigRule, b as ArkConfigLayer, A as ArkConfig, c as ArkConfigLoadResult } from './configContract-BxSIwVRo.js';
+export { d as ARK_CONFIG_SCHEMA, e as ARK_CONFIG_SCHEMA_VERSION, l as loadArkConfigContract, p as parseArkConfigJson } from './configContract-BxSIwVRo.js';
 
 /** ArkGate library version — single source of truth. */
-declare const version = "2.12.0";
-
-/**
- * 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.
- */
+declare const version = "3.0.0";
+
+/** Versioned public result contract shared by every ArkGate enforcement adapter. */
+declare const ARK_ANALYSIS_RESULT_SCHEMA_VERSION: "1.0";
+type AdapterSeverity = 'error' | 'warning';
+type AdapterViolationInput = {
+    ruleId?: unknown;
+    code?: unknown;
+    message?: unknown;
+    file?: unknown;
+    line?: unknown;
+    column?: unknown;
+    target?: unknown;
+    fromLayer?: unknown;
+    toLayer?: unknown;
+    typeOnly?: unknown;
+    severity?: unknown;
+};
+type AdapterDiagnostic = {
+    ruleId: string;
+    severity: AdapterSeverity;
+    message: string;
+    location: {
+        file: string;
+        line: number;
+        column: number;
+    };
+    evidence: {
+        target?: string;
+        fromLayer?: string;
+        toLayer?: string;
+        typeOnly?: boolean;
+    };
+};
+type AdapterResult = {
+    schemaVersion: typeof ARK_ANALYSIS_RESULT_SCHEMA_VERSION;
+    valid: boolean;
+    diagnostics: AdapterDiagnostic[];
+};
+declare function toAdapterDiagnostic(violation: AdapterViolationInput, fallbackSeverity?: AdapterSeverity): AdapterDiagnostic;
+declare function createAdapterResult(input: {
+    valid: boolean;
+    violations?: readonly AdapterViolationInput[];
+    warnings?: readonly AdapterViolationInput[];
+}): AdapterResult;
+declare const ARK_ANALYSIS_RESULT_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://unpkg.com/arkgate@2/schemas/ark.analysis-result.schema.json";
+    readonly title: "ArkGate analysis result";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schemaVersion", "valid", "diagnostics"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: "1.0";
+        };
+        readonly valid: {
+            readonly type: "boolean";
+        };
+        readonly diagnostics: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["ruleId", "severity", "message", "location", "evidence"];
+                readonly properties: {
+                    readonly ruleId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly severity: {
+                        readonly enum: readonly ["error", "warning"];
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly location: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly required: readonly ["file", "line", "column"];
+                        readonly properties: {
+                            readonly file: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly line: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            };
+                            readonly column: {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            };
+                        };
+                    };
+                    readonly evidence: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly target: {
+                                readonly type: "string";
+                            };
+                            readonly fromLayer: {
+                                readonly type: "string";
+                            };
+                            readonly toLayer: {
+                                readonly type: "string";
+                            };
+                            readonly typeOnly: {
+                                readonly type: "boolean";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
 
 /**
- * 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'] }
- * );
- * ```
+ * AI Code Gate (basic).
  *
- * @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.
+ * Allows validation of generated source code against the defined architecture.
  */
-interface IntentNameValidation {
-    valid: boolean;
-    reason?: string;
+interface AICodeGateViolation {
+    /** Stable rule identifier for agents and CI pipelines. */
+    ruleId: string;
+    /** @deprecated Use ruleId — kept for backward compatibility. */
+    code: string;
+    message: string;
+    line?: number;
+    suggestion?: string;
+    source?: string;
+    filePath?: string;
+    target?: string;
+    fromLayer?: string;
+    toLayer?: string;
+    details?: unknown;
 }
-/**
- * Validate that an intent name follows Ark naming conventions.
- */
-declare function validateIntentName(name: string): IntentNameValidation;
-
-/**
- * Typed error thrown when hard policies are violated.
- */
-
-declare class PolicyViolationError extends Error {
-    readonly violations: PolicyViolation[];
-    constructor(violations: PolicyViolation[]);
+/** Extension point for external analyzers (AST, semantic, etc.). */
+interface AIGateExtension<Context = unknown> {
+    readonly name: string;
+    analyze(source: string, context?: Context): AICodeGateViolation[];
 }
-
-/**
- * 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[];
+interface AICodeGateContext {
+    filePath?: string;
+    agentId?: string;
+    layer?: string;
+    [key: string]: unknown;
+}
+interface AICodeGateResult {
+    valid: boolean;
+    violations: AICodeGateViolation[];
+}
+interface AICodeGate<Context = AICodeGateContext> {
+    validate(source: string, context?: Context): AICodeGateResult;
 }
-/**
- * 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>;
-
-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.
+ * Policy types for the Ark kernel.
  *
- * Collects declared and observed relationships.
- * Generates Mermaid diagrams and JSON.
- * Supports simple violation detection via rule functions.
+ * Policies allow declaring architectural rules that can be checked at runtime.
+ * Supports both hard policies (must never be violated) and soft policies (warnings).
  */
-
-declare function createDependencyGraph(): DependencyGraph;
-
+type PolicySeverity = 'hard' | 'soft';
+type PolicyEnforcementMode = 'runtime' | 'static' | 'runtime-and-static' | 'advisory';
 /**
- * Bridge IntentRegistry relationships into a DependencyGraph.
+ * Represents a single violation of a policy.
  */
-
-interface SyncRegistryOptions {
-    /** Skip edges whose target intent is not registered (default: false). */
-    requireRegisteredTargets?: boolean;
+interface PolicyViolation {
+    /** Name of the policy that was violated */
+    policyName: string;
+    /** Severity level of the policy */
+    severity: PolicySeverity;
+    /** Human-readable explanation of the violation */
+    message: string;
+    /** Optional additional structured details */
+    details?: unknown;
 }
 /**
- * Sync declared intent relationships from a registry into a dependency graph.
+ * A Policy defines a rule that can be evaluated against a context.
  *
- * - `dependsOn` → `declared` edges
- * - `produces` → `produces` edges
- */
-declare function syncRegistryToGraph(registry: IntentRegistry, graph: DependencyGraph, options?: SyncRegistryOptions): void;
-
-/**
- * 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.
+ * @template Context - The shape of data the policy evaluates (e.g. { registry, events })
  */
-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[];
-    }>;
+interface Policy<Context = unknown> {
+    /** Unique name of the policy (used in violations and reporting) */
+    readonly name: string;
+    /** Whether this is a hard rule (enforced strictly) or soft (advisory) */
+    readonly severity: PolicySeverity;
+    /** Optional tags for policy classification (e.g. 'layer', 'naming') */
+    readonly tags?: readonly string[];
+    readonly owner?: string;
+    readonly version?: string;
+    readonly rationale?: string;
+    readonly enforcementMode?: PolicyEnforcementMode;
+    readonly deprecated?: boolean | string;
+    readonly replacedBy?: string;
     /**
-     * Clean-architecture dependency matrix (declared dependsOn / declared edges only).
-     * Does not block observed event flows (Domain events consumed by Application).
+     * Evaluates the policy against the given context.
+     * Return true / [] for pass, false / single violation / array for failure.
      */
-    cleanArchitectureMatrix(): Policy<{
-        edges?: GraphEdge[];
-        relationships?: IntentRelationship[];
-    }>;
-};
-declare function defineArchitectureProfilePolicy<Context extends {
-    edges?: GraphEdge[];
-    relationships?: IntentRelationship[];
-}>(profile: ArchitectureProfile, options?: Omit<LayerPolicyOptions, 'rules' | 'resolveLayer'>): Policy<Context>;
+    check(context: Context): boolean | PolicyViolation | PolicyViolation[];
+}
 
 /**
- * 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`).
+ * Core domain primitives for Ark.
+ * These types are the foundation for all governance concepts.
  */
-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.
+ * Semantic intent names follow a convention:
+ * - Domain.* for domain events and entities
+ * - Application.* for use-cases / orchestration
+ * - Adapter.* for integration points
+ * - Workflow.* for sagas and processes
+ * - Job.* for background jobs and scheduling
+ * - Presentation.* for UI/API adapters
+ * - Reporting.* for read models and projections
+ * - Metadata.* for extensibility contracts
+ * - Security.* / Audit.* / Observability.* for cross-cutting kernel concerns
+ * - Kernel.* for Ark-owned governance signals
  */
-declare function createAuditTrail(options?: CreateAuditTrailOptions): AuditTrail;
-
-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;
+type IntentName = `Domain.${string}` | `Application.${string}` | `Adapter.${string}` | `Workflow.${string}` | `Job.${string}` | `Presentation.${string}` | `Reporting.${string}` | `Metadata.${string}` | `Security.${string}` | `Audit.${string}` | `Observability.${string}` | `Kernel.${string}`;
+type CorrelationId = string;
+interface EventMetadata {
+    occurredAt: string;
+    source: string;
+    kernelInstanceId?: string;
+    eventVersion?: string;
+    schemaVersion?: string;
+    allowInterception?: boolean;
+    interceptions?: Array<{
+        interceptorId: string;
+        timestamp: string;
+    }>;
+    correlationId?: CorrelationId;
+    causationId?: string;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    [key: string]: unknown;
 }
-declare function createEventContractRegistry(): EventContractRegistry;
-
-/**
- * Reference in-process outbox. **Not production durability** — state is lost on
- * process exit. Use only for tests/demos/local single-process work; inject a durable
- * `OutboxStore` in production (see `docs/production-hardening.md`).
- */
-declare class InMemoryOutboxStore implements OutboxStore {
-    private readonly records;
-    enqueue(event: DomainEvent): Promise<OutboxRecord>;
-    markDispatched(id: string): Promise<void>;
-    markFailed(id: string, error: unknown): Promise<void>;
-    list(status?: OutboxStatus): Promise<OutboxRecord[]>;
-    clear(): Promise<void>;
+interface DomainEvent<Name extends IntentName = IntentName, Payload = unknown> {
+    intent: Name;
+    payload: Payload;
+    metadata: EventMetadata;
 }
 
 /**
- * EventBus implementation — public surface + publish orchestration.
+ * Intent-specific types for the Ark kernel.
  *
- * 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.
+ * Intents provide semantic naming for every important concept in the system
+ * (domain events, application operations, adapters, workflows).
  */
 
 /**
- * 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.
+ * An IntentCreator is a callable that creates a strongly-typed DomainEvent
+ * when invoked with a payload.
+ *
+ * It also carries the semantic `name`.
  *
  * @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.
+ * const OrderPlaced = defineIntent<'Domain.Order.OrderPlaced', { orderId: string }>('Domain.Order.OrderPlaced');
+ * const event = OrderPlaced({ orderId: 'o-1' });
  */
-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);
-}
-
-declare function createObservabilityReporter(options: CreateObservabilityReporterOptions): ObservabilityReporter;
-
-/**
- * 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;
-
-/** 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>): void;
-    get<P extends SagaContext = SagaContext>(id: string): WorkflowSnapshot<P> | undefined;
-    list(workflowName?: string): WorkflowSnapshot[];
-    clear(): void;
+interface IntentCreator<Name extends IntentName, Payload = unknown> {
+    /**
+     * Creates a DomainEvent for this intent.
+     */
+    (payload: Payload): DomainEvent<Name, Payload>;
+    /**
+     * The fully-qualified semantic name of the intent (e.g. "Domain.Order.OrderPlaced").
+     */
+    readonly name: Name;
 }
-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>;
 
 /**
- * Default cap for in-memory history, trace, and audit records. Without a cap a
- * long-running process grows without bound on every publish. Pass
- * `maxHistorySize: Infinity` to explicitly opt back into unbounded retention.
+ * Architecture layer profiles.
+ *
+ * A profile turns semantic names such as `Domain.Order.Placed` into governed
+ * layer names and dependency rules.
  */
-declare const DEFAULT_MAX_HISTORY_SIZE = 1000;
-declare function createArkKernel(options?: CreateArkKernelOptions): ArkKernel;
-declare function createStrictArkKernel(options?: CreateArkKernelOptions): ArkKernel;
-declare function createArkKernelFromConfig(config: ArkKernelConfig, options?: CreateArkKernelFromConfigOptions): ArkKernel;
-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;
-
-/**
- * Ports & Adapters basic contracts.
- */
-interface Port<T = unknown> {
-    readonly name: string;
-    readonly ownerLayer?: string;
-    readonly intent?: IntentName;
-    readonly allowedAdapters?: string[];
-    readonly __port?: T;
+interface ArchitectureLayer {
+    name: string;
+    prefixes: string[];
+    /**
+     * Custom matcher for teams whose intent names don't follow prefix conventions.
+     * Checked before any prefix matching, in layer declaration order. A layer may
+     * use `match` alone (with `prefixes: []`), prefixes alone, or both.
+     */
+    match?: (name: string) => boolean;
+    description?: string;
+    order?: number;
 }
-interface Adapter<T = unknown> {
-    readonly name?: string;
-    readonly layer?: string;
-    readonly intent?: IntentName;
-    readonly port: Port<T>;
-    readonly impl: T;
+type ArchitectureRule = ArkConfigRule;
+interface ArchitectureProfile {
+    name: string;
+    layers: ArchitectureLayer[];
+    rules: ArchitectureRule[];
+    resolveLayer(name: string): string | undefined;
 }
-interface DefinePortOptions {
-    ownerLayer?: string;
-    intent?: IntentName;
-    allowedAdapters?: string[];
+interface CreateArchitectureProfileOptions {
+    name: string;
+    layers: ArchitectureLayer[];
+    rules?: ArchitectureRule[];
 }
-interface CreateAdapterOptions {
+interface CreateArchitectureProfileFromArkConfigOptions {
+    /** Runtime profile name. Default: config.name or "ark.config.json". */
     name?: string;
-    layer?: string;
-    intent?: IntentName;
-    requiredKeys?: string[];
 }
-/**
- * Simple contract checker (duck typing + optional required keys).
- */
-type ContractCheckResult = {
-    ok: true;
-} | {
-    ok: false;
-    missing: string[];
+type ArchitectureLayerConfig = ArkConfigLayer;
+type ArkCheckConfig = Omit<ArkConfig, '$schema' | 'schemaVersion' | 'rules'> & {
+    $schema?: string;
+    schemaVersion?: ArkConfig['schemaVersion'];
+    rules?: ArchitectureRule[];
 };
-interface AdapterGovernanceIssue {
-    ruleId: 'ADAPTER_NOT_ALLOWED_FOR_PORT';
-    message: string;
-    port: string;
-    adapter?: string;
+interface CreateElevenLayerArkConfigOptions {
+    /** Source root used in generated file patterns. Default: "src". */
+    rootDir?: string;
+    /** Include entries for ark-check. Default: [rootDir]. */
+    include?: string[];
+    /** Mark generated layers optional. Default: true. */
+    optionalLayers?: boolean;
 }
-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;
-
-/**
- * AI Code Gate (basic).
- *
- * Allows validation of generated source code against the defined architecture.
- */
-interface AICodeGateViolation {
-    /** Stable rule identifier for agents and CI pipelines. */
-    ruleId: string;
-    /** @deprecated Use ruleId — kept for backward compatibility. */
-    code: string;
-    message: string;
-    line?: number;
-    suggestion?: string;
-    source?: string;
-    filePath?: string;
-    target?: string;
-    fromLayer?: string;
-    toLayer?: string;
-    details?: unknown;
-}
-/** Extension point for external analyzers (AST, semantic, etc.). */
-interface AIGateExtension<Context = unknown> {
-    readonly name: string;
-    analyze(source: string, context?: Context): AICodeGateViolation[];
-}
-interface AICodeGateContext {
-    filePath?: string;
-    agentId?: string;
-    layer?: string;
-    [key: string]: unknown;
-}
-interface AICodeGateResult {
-    valid: boolean;
-    violations: AICodeGateViolation[];
-}
-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.
@@ -603,9 +406,172 @@ interface AICodeGateOptions<Context = AICodeGateContext> {
         name: string;
         patterns?: string[];
     }>;
-    /** Explicit file-level escape hatch for reviewed non-literal dynamic imports. */
+    /** Explicit file-level escape hatch for reviewed non-literal import()/require() calls. */
     allowNonLiteralDynamicImport?: (filePath?: string) => boolean;
 }
 declare function createAICodeGate<Context = AICodeGateContext>(options?: AICodeGateOptions<Context>): AICodeGate<Context>;
 
-export { type AICodeGate, type AICodeGateContext, type AICodeGateOptions, type AICodeGateResult, type AICodeGateViolation, type AIGateExtension, type Adapter, type AdapterGovernanceIssue, type AdapterGovernanceResult, ArchitectureProfile, ArkCheckConfig, ArkKernel, ArkKernelConfig, ArkManifest, type ArkTestHarness, type ArkTestSnapshot, AuditQuery, AuditRecord, AuditStore, AuditTrail, type BuildPublishPolicyContextOptions, type ContractCheckResult, type CreateAdapterOptions, CreateArchitectureProfileFromArkConfigOptions, CreateArchitectureProfileOptions, CreateArkKernelFromConfigOptions, CreateArkKernelOptions, type CreateArkManifestOptions, CreateAuditTrailOptions, CreateElevenLayerArkConfigOptions, CreateObservabilityReporterOptions, CreateProjectionRegistryOptions, CreateWorkflowEngineOptions, DEFAULT_MAX_HISTORY_SIZE, DefineIntentOptions, type DefinePolicyOptions, type DefinePortOptions, DependencyGraph, DomainEvent, EventBus, EventBusOptions, EventContract, EventContractRegistry, EventContractRegistryImpl, EventContractValidationResult, EventContractViolationError, GraphEdge, type GraphPolicyContext, InMemoryAuditStore, InMemoryOutboxStore, InMemoryReadModelStore, InMemoryWorkflowStore, IntentCreator, IntentCreator as IntentDefinition, IntentName, type IntentNameValidation, IntentRegistry, IntentRelationship, InvalidIntentNameError, type LayerFlowRule, LayerPolicyContextError, type LayerPolicyOptions, MANIFEST_SCHEMA_VERSION, MetadataRegistry, ObservabilityDriftReport, ObservabilityReporter, ObservedLayerFlowViolationError, OutboxRecord, OutboxStatus, OutboxStore, Policy, PolicyEnforcementMode, PolicyEngine, PolicySeverity, PolicyViolation, PolicyViolationError, type Port, ProjectionRegistry, type PublishPolicyContext, ReadModelStore, SagaDefinition, SagaInstance, SourceMetadataOverrideError, type SyncRegistryOptions, TraceRecord, TraceRecordType, UnknownEventSourceError, UnregisteredIntentError, WorkflowEngine, WorkflowSnapshot, WorkflowStore, architecturalPolicies, buildPublishPolicyContext, checkAdapterGovernance, checkContract, createAICodeGate, createAdapter, createArchitectureProfile, createArchitectureProfileFromArkConfig, createArkKernel, createArkKernelFromConfig, createArkManifest, createArkTestHarness, createAuditTrail, createDependencyGraph, createElevenLayerArkConfig, createEventBus, createEventContractRegistry, createIntentRegistry, createLenientArkKernel, createLenientArkKernelFromConfig, createMetadataRegistry, createObservabilityReporter, createProjectionRegistry, createSaga, createStrictArkKernel, createStrictArkKernelFromConfig, createWorkflowEngine, defaultIntentRegistry, defineArchitectureProfilePolicy, defineIntent, defineLayerPolicy, definePolicy, definePort, definePublishPolicy, elevenLayerProfile, isLayerPolicy, syncRegistryToGraph, validateIntentName, version };
+/**
+ * Stable, pure vocabulary for ArkGate's importable analysis engine.
+ *
+ * Parsing and filesystem discovery belong to adapters. This module intentionally
+ * contains only the versioned data contract and deterministic hash primitives.
+ */
+declare const ANALYSIS_IR_SCHEMA_VERSION: "1.0";
+type AnalysisFileInput = {
+    path: string;
+    content: string;
+};
+type AnalysisFileChange = {
+    path: string;
+    content: string;
+} | {
+    path: string;
+    delete: true;
+};
+type AnalysisCompilerOptions = Readonly<Record<string, unknown>>;
+type AnalysisFile = AnalysisFileInput & {
+    contentHash: string;
+    layer: string | null;
+};
+type AnalysisImportEdge = {
+    from: string;
+    specifier: string;
+    to: string | null;
+    resolution: 'resolved' | 'unresolved';
+    fromLayer: string | null;
+    toLayer: string | null;
+    evidence: AnalysisEvidence;
+};
+/** A capability use is reserved for C04's symbol-aware implementation. */
+type AnalysisCapabilityUse = {
+    file: string;
+    symbol: string;
+    capability: string;
+    evidence: AnalysisEvidence;
+};
+type AnalysisEvidence = {
+    kind: 'import' | 'policy';
+    file: string;
+    line: number;
+    excerpt: string;
+};
+type AnalysisViolation = {
+    ruleId: string;
+    message: string;
+    edge?: AnalysisImportEdge;
+    evidence: AnalysisEvidence;
+};
+type AnalysisIr = {
+    schemaVersion: typeof ANALYSIS_IR_SCHEMA_VERSION;
+    policyHash: string;
+    compilerOptionsHash: string;
+    files: AnalysisFile[];
+    layers: string[];
+    edges: AnalysisImportEdge[];
+    capabilityUses: AnalysisCapabilityUse[];
+    violations: AnalysisViolation[];
+};
+/**
+ * Stable FNV-1a hash. It is an identity/fingerprint, not a security primitive.
+ * The output is deliberately portable across the CLI, MCP, hooks, and browserless
+ * consumers without Node's crypto runtime.
+ */
+declare function deterministicHash(value: string): string;
+/** Serialize JSON-like values with sorted object keys for reproducible hashes. */
+declare function stableSerialize(value: unknown): string;
+
+type SemanticDependencyKind = 'import' | 'export' | 'dynamic-import' | 'require';
+type SemanticDependency = {
+    specifier?: string;
+    kind: SemanticDependencyKind;
+    line: number;
+    typeOnly: boolean;
+    unresolved: boolean;
+    node: unknown;
+};
+type ForbiddenCapabilityUse = {
+    name: string;
+    line: number;
+    node: unknown;
+};
+/** Extract every dependency form whose specifier is statically knowable, plus unresolved calls. */
+declare function extractSemanticDependencies(ts: any, sourceFile: any): SemanticDependency[];
+/** Resolve forbidden ambient capabilities through symbols, aliases, globalThis, and static keys. */
+declare function collectForbiddenCapabilityUses(ts: any, sourceFile: any, forbidden: readonly string[]): ForbiddenCapabilityUse[];
+
+type AnalysisContract = ArkConfigLoadResult & {
+    policyHash: string;
+};
+type AnalyzeProjectInput = {
+    contract: AnalysisContract;
+    files: readonly AnalysisFileInput[];
+    compilerOptions?: AnalysisCompilerOptions;
+};
+type AnalyzeChangeInput = AnalyzeProjectInput & {
+    changes: readonly AnalysisFileChange[];
+};
+type AnalysisResult = {
+    ir: AnalysisIr;
+};
+type ArchitectureEngineViolation = {
+    ruleId: string;
+    message: string;
+    file?: string;
+    line?: number;
+    target?: string;
+    fromLayer?: string;
+    toLayer?: string;
+    [key: string]: unknown;
+};
+type ArchitectureEngineEdge = {
+    from: string;
+    fromLayer: string;
+    to?: string;
+    toLayer?: string;
+    line: number;
+    kind: string;
+    typeOnly?: boolean;
+    targetTypeOnlyExports?: boolean;
+    sourcePureTypeModule?: boolean;
+    namedBindingsTypeOnly?: boolean;
+    portProofEligible?: boolean;
+};
+type EvaluateArchitectureGraphInput = {
+    config: ArkConfig;
+    rules: ArkConfig['rules'];
+    files: readonly string[];
+    contentViolations: readonly ArchitectureEngineViolation[];
+    edges: readonly ArchitectureEngineEdge[];
+    warnings?: readonly ArchitectureEngineViolation[];
+    safety?: unknown;
+};
+type ArchitectureEngineResult = {
+    violations: ArchitectureEngineViolation[];
+    warnings: ArchitectureEngineViolation[];
+    safety?: unknown;
+};
+type CollectAnalysisConfigWarningsInput = {
+    config: ArkConfig;
+    rules: ArkConfig['rules'];
+    files: readonly string[];
+    manifest?: {
+        architecture?: {
+            layers?: readonly {
+                name?: string;
+                prefixes?: readonly string[];
+            }[];
+        };
+    };
+};
+declare function loadContract(input: unknown, source?: string): AnalysisContract;
+declare function analyzeProject(input: AnalyzeProjectInput): AnalysisResult;
+declare function analyzeChange(input: AnalyzeChangeInput): AnalysisResult;
+declare function explainViolation(violation: AnalysisViolation): string;
+declare function detectArchitectureCycles(graph: ReadonlyMap<string, ReadonlySet<string>>): ArchitectureEngineViolation[];
+/** Canonical graph and layer-policy evaluator shared by library, CLI, and MCP adapters. */
+declare function evaluateArchitectureGraph(input: EvaluateArchitectureGraphInput): ArchitectureEngineResult;
+/** Canonical config diagnostics over repo-relative file paths. */
+declare function collectAnalysisConfigWarnings(input: CollectAnalysisConfigWarningsInput): ArchitectureEngineViolation[];
+
+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, type AdapterDiagnostic, type AdapterResult, type AdapterSeverity, type AdapterViolationInput, type AnalysisCapabilityUse, type AnalysisCompilerOptions, type AnalysisContract, type AnalysisEvidence, type AnalysisFile, type AnalysisFileChange, type AnalysisFileInput, type AnalysisImportEdge, type AnalysisIr, type AnalysisResult, type AnalysisViolation, type AnalyzeChangeInput, type AnalyzeProjectInput, type ArchitectureEngineEdge, type ArchitectureEngineResult, type ArchitectureEngineViolation, type ArchitectureLayer, type ArchitectureLayerConfig, type ArchitectureProfile, type ArchitectureRule, type ArkCheckConfig, ArkConfig, ArkConfigLoadResult, type CollectAnalysisConfigWarningsInput, type CreateArchitectureProfileFromArkConfigOptions, type CreateArchitectureProfileOptions, type CreateElevenLayerArkConfigOptions, type EvaluateArchitectureGraphInput, type ForbiddenCapabilityUse, type SemanticDependency, type SemanticDependencyKind, analyzeChange, analyzeProject, collectAnalysisConfigWarnings, collectForbiddenCapabilityUses, createAICodeGate, createAdapterResult, createArchitectureProfile, createArchitectureProfileFromArkConfig, createElevenLayerArkConfig, detectArchitectureCycles, deterministicHash, elevenLayerProfile, evaluateArchitectureGraph, explainViolation, extractSemanticDependencies, loadContract, stableSerialize, toAdapterDiagnostic, version };