arkgate 2.1.0

package/dist/index.d.cts

@@ -0,0 +1,577 @@
+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, C as CreateArchitectureProfileOptions, A as ArchitectureProfile, f as ArkCheckConfig, g as CreateArchitectureProfileFromArkConfigOptions, h as CreateElevenLayerArkConfigOptions, i as DependencyGraph, G as GraphEdge, j as IntentRelationship, k as AuditStore, l as AuditRecord, m as AuditQuery, n as CreateAuditTrailOptions, o as AuditTrail, E as EventContractRegistry, p as EventContract, q as DomainEvent, r as EventContractValidationResult, O as OutboxStore, s as OutboxRecord, t as OutboxStatus, u as EventBusOptions, v as EventBus, w as CreateObservabilityReporterOptions, x as ObservabilityReporter, M as MetadataRegistry, R as ReadModelStore, y as CreateProjectionRegistryOptions, z as ProjectionRegistry, B as PolicyEngine, F as ArkManifest, W as WorkflowStore, S as SagaContext, H as WorkflowSnapshot, J as SagaDefinition, K as CreateWorkflowEngineOptions, L as SagaInstance, N as WorkflowEngine, Q as CreateArkKernelOptions, T as ArkKernel, U as ArkKernelConfig, V as CreateArkKernelFromConfigOptions, X as TraceRecordType, Y as TraceRecord, Z as ObservabilityDriftReport } from './types-DpdVN7Lm.cjs';
+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-DpdVN7Lm.cjs';
+
+/** ArkGate library version — single source of truth. */
+declare const version = "2.1.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.
+ */
+
+/**
+ * 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;
+
+/**
+ * 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>;
+
+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;
+
+/**
+ * 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>;
+
+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;
+}
+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;
+}
+declare function createEventContractRegistry(): EventContractRegistry;
+
+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>;
+}
+
+/**
+ * EventBus implementation.
+ *
+ * Core publish/subscribe mechanics with:
+ * - Intent-aware typing via creators
+ * - Automatic metadata enrichment
+ * - Full publish history for observability
+ * - Strict registry validation (opt-in by default when registry provided)
+ */
+
+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);
+}
+
+declare function createObservabilityReporter(options: CreateObservabilityReporterOptions): ObservabilityReporter;
+
+/**
+ * Basic MetadataRegistry implementation.
+ */
+
+declare function createMetadataRegistry(): MetadataRegistry;
+
+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.
+ */
+
+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;
+}
+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.
+ */
+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 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;
+
+/**
+ * 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;
+}
+
+/**
+ * Basic AI Code Gate implementation.
+ *
+ * Uses simple string heuristics + registered intent names to detect obvious
+ * architectural violations in generated code (e.g. direct infra imports from domain).
+ * Not a full static analyzer — documented limitation.
+ */
+
+interface AICodeGatePolicyContext<Context = AICodeGateContext> {
+    source: string;
+    context?: Context;
+}
+interface AICodeGateOptions<Context = AICodeGateContext> {
+    policies?: Policy<AICodeGatePolicyContext<Context>>[];
+    intents?: Array<string | Pick<IntentCreator<IntentName, unknown>, 'name'>>;
+    /**
+     * Additional forbidden patterns (regex or strings).
+     */
+    forbiddenPatterns?: Array<string | RegExp>;
+    /**
+     * External analyzer extensions (type-only contract; plug in AST tools later).
+     */
+    extensions?: AIGateExtension<Context>[];
+    /**
+     * Optional architecture profile for layer-aware generated-code checks.
+     * When context.layer is provided, intent references are checked against it.
+     */
+    architectureProfile?: ArchitectureProfile;
+    /**
+     * When true, flag string literals that look like intent names but are not registered.
+     */
+    enforceIntentAllowlist?: boolean;
+    /**
+     * Optional TypeScript module object. When provided, AICodeGate adds AST-backed checks
+     * for publish misuse without taking a runtime dependency on TypeScript.
+     */
+    typescript?: unknown;
+    /**
+     * Ambient globals forbidden per layer (layer name → entries such as "fetch" or
+     * "Date.now"). Checked only when `typescript` is provided and context.layer resolves
+     * to a listed layer — mirrors ark-check's FORBIDDEN_GLOBAL rule.
+     */
+    forbiddenGlobals?: Record<string, string[]>;
+    /**
+     * Layer names whose role is infrastructure and may therefore import infrastructure
+     * (a persistence adapter importing the DB is correct, not a violation). The built-in
+     * infra-import heuristics are suppressed for these layers and for any layer whose
+     * name matches the conventional infra tokens. Populate from ark.config.json layers
+     * flagged `mayImportInfrastructure: true`, so unconventionally-named infra layers
+     * opt in explicitly. User-supplied `forbiddenPatterns` still apply everywhere.
+     */
+    infrastructureLayers?: string[];
+    /**
+     * Resolve an import specifier to the architecture layer of its TARGET file, if that target
+     * is governed by a declared layer (else undefined). When provided, the gate lets the
+     * layer RULES decide a governed edge instead of the infrastructure path-heuristic — so the
+     * write gate honors `ark.config.json` exactly like `ark-check`, and the heuristic only
+     * applies to ungoverned targets (external packages, paths no layer covers). The caller
+     * (ark-mcp) supplies this using the config's layer globs + tsconfig path aliases.
+     */
+    resolveImportLayer?: (specifier: string, fromFilePath?: string) => string | undefined;
+}
+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 };