arkgate 4.7.6 → 4.8.0

package/dist/runtime/index.d.ts

@@ -0,0 +1,497 @@
+export { k as AICodeGate, l as AICodeGateContext, m as AICodeGateOptions, n as AICodeGateResult, o as AICodeGateViolation, p as AIGateExtension, q as ANALYSIS_IR_SCHEMA_VERSION, r as ARK_ANALYSIS_RESULT_SCHEMA, s as ARK_ANALYSIS_RESULT_SCHEMA_VERSION, t as ARK_DESIGN_DELTA_SCHEMA_VERSION, u as ARK_ENFORCEMENT_STATE_SCHEMA_VERSION, v as AdapterCompletenessReason, w as AdapterDiagnostic, x as AdapterResult, y as AdapterSeverity, z as AdapterViolationInput, B as AnalysisCapabilityUse, C as AnalysisCompilerOptions, D as AnalysisCompleteness, F as AnalysisContract, G as AnalysisEvidence, H as AnalysisFile, I as AnalysisFileChange, J as AnalysisFileInput, K as AnalysisImportEdge, L as AnalysisIr, M as AnalysisMode, N as AnalysisResult, O as AnalysisViolation, P as AnalyzeArchitectureConvergenceInput, Q as AnalyzeChangeInput, S as AnalyzePolicyDeltaInput, T as AnalyzeProjectInput, U as AnalyzeResolvedProjectInput, V as ArchitectureActualChange, W as ArchitectureChangeMap, X as ArchitectureChangeMapContract, Y as ArchitectureChangeMapDependency, Z as ArchitectureChangeMapFile, _ as ArchitectureChangeOperation, $ as ArchitectureConvergenceClassification, a0 as ArchitectureConvergenceFinding, a1 as ArchitectureConvergenceResult, a2 as ArchitectureDependency, a3 as ArchitectureEngineEdge, a4 as ArchitectureEngineResult, a5 as ArchitectureEngineViolation, a6 as ArkDesignDeltaResult, a7 as ArkEnforcementHost, a8 as ArkEnforcementState, aa as ChangePreflightResult, ac as CollectAnalysisConfigWarningsInput, ad as DIAGNOSTIC_CATALOG, ae as DIAGNOSTIC_CATALOG_SCHEMA_VERSION, af as DIAGNOSTIC_DOCS_RELATIVE_PATH, ag as DIAGNOSTIC_RULE_IDS, ah as DesignDeltaChange, ai as DesignDeltaEnforcementScope, aj as DesignDeltaIdentity, ak as DesignSmellEvidence, al as DesignSmellFinding, am as DesignSmellId, an as DiagnosticCatalogEntry, ao as DiagnosticCategory, ap as EnforcementBoundaryState, aq as EnforcementEvidence, ar as EnforcementEvidenceField, as as EnforcementVerification, at as EvaluateArchitectureGraphInput, au as ForbiddenCapabilityUse, aw as POLICY_DELTA_SCHEMA_VERSION, ax as PolicyDelta, ay as PolicyDeltaAcknowledgement, az as PolicyDeltaAnalysis, aA as PolicyDeltaClassification, aB as PolicyDeltaFinding, aC as PreflightResolvedChangeInput, aD as PreparedChangeFile, aE as RESOLVED_CANDIDATE_FACTS_SCHEMA, aF as RESOLVED_CANDIDATE_FACTS_SCHEMA_VERSION, aG as ResolvedAmbientFact, aH as ResolvedAnalysisFile, aI as ResolvedAnalysisIr, aJ as ResolvedAnalysisResult, e as ResolvedArkRunCompositionRootHitFact, a as ResolvedArkRunDeclarationFact, b as ResolvedArkRunKernelCallFact, R as ResolvedArkRunKernelCallKind, c as ResolvedArkRunManagedNewFact, aK as ResolvedCandidateFacts, aL as ResolvedCandidateFactsInput, aM as ResolvedCapability, aN as ResolvedCapabilityFact, aO as ResolvedChangePreflightResult, d as ResolvedDependencyFact, aP as ResolvedDependencyKind, aQ as ResolvedDependencyState, aR as ResolvedFactsCompleteness, f as ResolvedFactsReason, aS as ResolvedFileFact, aT as ResolvedIntentReferenceFact, aU as ResolvedPublishFact, aV as ResolvedSafetyFact, aW as ResolvedSafetyKind, aX as ResolvedSafetyReport, aY as SemanticDependency, aZ as SemanticDependencyKind, b2 as analyzeArchitectureConvergence, b3 as analyzeChange, b4 as analyzePolicyDelta, b5 as analyzeProject, b6 as analyzeResolvedProject, b9 as catalogFixForRuleId, ba as catalogWhyForRuleId, bb as classifyArkPolicyDelta, bc as collectAnalysisConfigWarnings, be as collectForbiddenCapabilityUses, bf as createAICodeGate, bg as createAdapterResult, bh as createArchitectureProfile, bi as createArchitectureProfileFromArkConfig, bj as createElevenLayerArkConfig, bk as createResolvedCandidateFacts, bm as detectArchitectureCycles, bn as deterministicHash, bo as diagnosticDocsFragment, bp as diagnosticDocsPath, bq as elevenLayerProfile, br as evaluateArchitectureGraph, bu as explainViolation, bw as extractSemanticDependencies, bx as getDiagnosticCatalogEntry, by as isCataloguedOrArkRuleFamily, bz as isKnownDiagnosticCode, bA as loadContract, bB as loadResolvedCandidateFacts, bC as policyDeltaAcknowledgementMatches, bD as preflightChange, bE as preflightResolvedChange, bF as resolvedFactsEvidenceRequirementsHash, bG as serializeDiagnosticCatalog, bH as stableSerialize, bI as toAdapterDiagnostic, bJ as version } from '../diagnosticCatalog-RiKPUFRG.js';
+import { P as PolicyViolation, g as PolicySeverity, h as PolicyEnforcementMode, i as Policy, I as IntentName, j as IntentCreator, k as IntentRelationship, b as ArchitectureProfile, D as DomainEvent } from '../types-DCSlrRnV.js';
+export { A as ArchitectureLayer, a as ArchitectureLayerConfig, c as ArchitectureRule, d as ArkCheckConfig, l as CorrelationId, C as CreateArchitectureProfileFromArkConfigOptions, e as CreateArchitectureProfileOptions, f as CreateElevenLayerArkConfigOptions, E as EventMetadata, m as IntentRelationshipKind } from '../types-DCSlrRnV.js';
+import { I as IntentRegistry, D as DefineIntentOptions, a as DependencyGraph, G as GraphEdge, b as AuditStore, c as AuditRecord, d as AuditQuery, e as CreateAuditTrailOptions, f as AuditTrail, E as EventContractRegistry, g as EventContract, h as EventContractValidationResult, M as MetadataRegistry, R as ReadModelStore, i as CreateProjectionRegistryOptions, P as ProjectionRegistry, j as EventBufferStore, k as EventBufferRecord, l as EventBufferStatus, m as EventBusOptions, n as EventBus, o as CreateObservabilityReporterOptions, O as ObservabilityReporter, p as PolicyEngine, q as ArkManifest, W as WorkflowStore, S as SagaContext, r as WorkflowSnapshot, s as SagaDefinition, t as CreateWorkflowEngineOptions, u as SagaInstance, v as WorkflowEngine, C as CreateArkKernelOptions, A as ArkKernel, w as ArkKernelConfig, x as CreateArkKernelFromConfigOptions, T as TraceRecordType, y as TraceRecord, z as OutboxStatus, B as OutboxRecord, F as ObservabilityDriftReport } from '../types-C9KApBzX.js';
+export { H as ARK_RUN_COMPONENT_LIFETIMES, J as ARK_RUN_EPHEMERAL_DEFAULT, K as ARK_RUN_GRAPH_DEFAULT_SLICE, L as ARK_RUN_GRAPH_NODE_KINDS, N as ARK_RUN_GRAPH_PROCESS_EDGE_KINDS, Q as ARK_RUN_GRAPH_SCHEMA_VERSION, U as ARK_RUN_GRAPH_SLICES, V as ARK_RUN_GRAPH_TECHNICAL_EDGE_KINDS, X as ARK_RUN_INFORMATION_PACKAGE_SCHEMA_VERSION, Y as ARK_RUN_INSPECTOR_DEFAULT_HOST, Z as ARK_RUN_INSPECTOR_DEFAULT_PORT, _ as ARK_RUN_INSPECTOR_EVENTS_PATH, $ as ARK_RUN_INSPECTOR_GRAPH_PATH, a0 as ARK_RUN_INSPECTOR_SCHEMA_VERSION, a1 as ARK_RUN_INSPECTOR_SNAPSHOT_PATH, a2 as ARK_RUN_INSPECTOR_SSE_EVENT, a3 as ARK_RUN_INSPECTOR_TRANSPORT_FALLBACK, a4 as ARK_RUN_TRANSPORT_KINDS, a5 as ArkManifestArchitecture, a6 as ArkManifestData, a7 as ArkManifestEntityLink, a8 as ArkManifestGraph, a9 as ArkManifestIntent, aa as ArkManifestPolicy, ab as ArkManifestProjection, ac as ArkRunBrokerAdapter, ad as ArkRunComponentLifetime, ae as ArkRunDeliveredVia, af as ArkRunExtendedInfo, ag as ArkRunGraph, ah as ArkRunGraphEdge, ai as ArkRunGraphEdgeKind, aj as ArkRunGraphMatch, ak as ArkRunGraphMatchInput, al as ArkRunGraphNode, am as ArkRunGraphNodeKind, an as ArkRunGraphProcessEdgeKind, ao as ArkRunGraphQuery, ap as ArkRunGraphResolvedQuery, aq as ArkRunGraphSlice, ar as ArkRunGraphTechnicalEdgeKind, as as ArkRunInformationPackageComponent, at as ArkRunInspectorBind, au as ArkRunInspectorBindError, av as ArkRunInspectorBindInput, aw as ArkRunInspectorHandle, ax as ArkRunInspectorProductionError, ay as ArkRunInspectorSnapshot, az as ArkRunInspectorSnapshotInput, aA as ArkRunInspectorSource, aB as ArkRunInspectorTransportFacts, aC as ArkRunPublisher, aD as ArkRunRegisterOptions, aE as ArkRunRegistrationHandle, aF as ArkRunSendOptions, aG as ArkRunSendPlan, aH as ArkRunSendPlanInput, aI as ArkRunSendResult, aJ as ArkRunTransportKind, aK as AuditRecordInput, aL as AuditRecordType, aM as DependencyInformationPackage, aN as EntityMeta, aO as EventContractIssue, aP as EventHandler, aQ as EventInterceptionInfo, aR as EventInterceptor, aS as EventInterceptorContext, aT as EventPayloadPatch, aU as EventPayloadSchema, aV as EventPublisher, aW as EventSchemaField, aX as EventSchemaFieldType, aY as FieldMeta, aZ as GraphNode, a_ as InvalidArkRunGraphQueryError, a$ as InvalidArkRunSendOptionError, b0 as ObservabilityFlow, b1 as ObservedLayerFlowMode, b2 as OutboxStore, b3 as PolicyEvaluationResult, b4 as ProjectionCheckpoint, b5 as ProjectionDefinition, b6 as PublishedEventRecord, b7 as RetryPolicy, b8 as SagaStatus, b9 as SagaStep, ba as StartArkRunInspectorOptions, bb as TraceSink, bc as Unsubscribe, bd as WorkflowDefinition, be as WorkflowStatus, bf as WorkflowStep, bg as arkRunGraphQueryFromSearchParams, bh as arkRunInspectorUrl, bi as buildArkRunInspectorSnapshot, bj as buildDependencyInformationPackage, bk as closeArkRunGraphQuery, bl as closedArkRunEphemeral, bm as closedArkRunTransportKind, bn as formatArkRunGraphMermaid, bo as formatArkRunInspectorSseEvent, bp as isArkRunInspectorLoopbackHost, bq as isArkRunInspectorProductionEnv, br as requestArkRunGraph, bs as resolveArkRunInspectorBind, bt as resolveArkRunSendPlan, bu as startArkRunInspector } from '../types-C9KApBzX.js';
+import '../configTypes-BdCe_gvv.js';
+
+/**
+ * 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>;
+
+/**
+ * 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;
+
+/**
+ * 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>;
+
+/**
+ * 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 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;
+
+/**
+ * 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;
+
+/**
+ * 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
+ * This is not an atomic outbox (see `docs/production-hardening.md`).
+ */
+declare class InMemoryEventBuffer implements EventBufferStore {
+    private readonly records;
+    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. */
+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);
+}
+
+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>;
+
+/**
+ * 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;
+/**
+ * Preferred ArkRun factory. Each call is a new isolated instance — there is no
+ * process-wide singleton.
+ */
+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;
+
+export { type Adapter, type AdapterGovernanceIssue, type AdapterGovernanceResult, ArchitectureProfile, ArkKernel, ArkKernelConfig, ArkManifest, type ArkTestHarness, type ArkTestSnapshot, AuditQuery, AuditRecord, AuditStore, AuditTrail, type BuildPublishPolicyContextOptions, type ContractCheckResult, type CreateAdapterOptions, CreateArkKernelFromConfigOptions, CreateArkKernelOptions, type CreateArkManifestOptions, CreateAuditTrailOptions, CreateObservabilityReporterOptions, CreateProjectionRegistryOptions, CreateWorkflowEngineOptions, DEFAULT_MAX_HISTORY_SIZE, DefineIntentOptions, type DefinePolicyOptions, type DefinePortOptions, DependencyGraph, DomainEvent, EventBufferRecord, EventBufferStatus, EventBufferStore, EventBus, EventBusOptions, EventContract, EventContractRegistry, EventContractRegistryImpl, EventContractValidationResult, EventContractViolationError, GraphEdge, type GraphPolicyContext, InMemoryAuditStore, InMemoryEventBuffer, 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, 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, createAdapter, createArkKernel, createArkKernelFromConfig, createArkManifest, createArkTestHarness, createAuditTrail, createDependencyGraph, createEventBus, createEventContractRegistry, createIntentRegistry, createLenientArkKernel, createLenientArkKernelFromConfig, createMetadataRegistry, createObservabilityReporter, createProjectionRegistry, createSaga, createStrictArkKernel, createStrictArkKernelFromConfig, createWorkflowEngine, defaultIntentRegistry, defineArchitectureProfilePolicy, defineIntent, defineLayerPolicy, definePolicy, definePort, definePublishPolicy, isLayerPolicy, syncRegistryToGraph, validateIntentName };