arkgate 4.7.6 → 4.8.1

package/dist/types-C9KApBzX.d.ts

@@ -0,0 +1,1237 @@
+import { i as Policy, P as PolicyViolation, I as IntentName, j as IntentCreator, k as IntentRelationship, b as ArchitectureProfile, D as DomainEvent, E as EventMetadata, h as PolicyEnforcementMode, A as ArchitectureLayer, c as ArchitectureRule, d as ArkCheckConfig } from './types-DCSlrRnV.js';
+
+/**
+ * PolicyEngine
+ *
+ * Evaluates collections of policies against a context.
+ * Supports hard and soft policies.
+ * - Hard policies: violations cause enforcement to throw.
+ * - Soft policies: violations are reported as warnings but do not throw.
+ */
+
+interface PolicyEvaluationResult {
+    passed: boolean;
+    violations: PolicyViolation[];
+    hardViolations: PolicyViolation[];
+    softViolations: PolicyViolation[];
+}
+/**
+ * The PolicyEngine is responsible for registering policies and evaluating
+ * them against a given context.
+ */
+declare class PolicyEngine<Context = unknown> {
+    private readonly policies;
+    constructor(initialPolicies?: Policy<Context>[]);
+    /**
+     * Adds a policy to the engine.
+     */
+    add(policy: Policy<Context>): void;
+    /**
+     * Returns all registered policies.
+     */
+    getPolicies(): Policy<Context>[];
+    /**
+     * Evaluates all policies against the provided context.
+     */
+    evaluate(context: Context): PolicyEvaluationResult;
+    /**
+     * Enforces all policies.
+     *
+     * - Soft violations are collected and can be observed (returned or logged).
+     * - Hard violations cause an error to be thrown (by default).
+     *
+     * @returns Evaluation result (including any soft violations)
+     * @throws Error if any hard policy is violated
+     */
+    enforce(context: Context): PolicyEvaluationResult;
+    /**
+     * Clears all registered policies.
+     */
+    clear(): void;
+}
+
+/**
+ * IntentRegistry
+ *
+ * Central registry for semantic intents.
+ * Supports registration, duplicate prevention, and declared dependency relationships.
+ *
+ * This is a core building block for governance, dependency graphs, and policy enforcement.
+ */
+
+/**
+ * Options for declaring relationships when defining an intent.
+ */
+interface DefineIntentOptions {
+    /** Other intents this one depends on (semantic names) */
+    dependsOn?: IntentName[];
+    /** Intents that this one produces / triggers */
+    produces?: IntentName[];
+}
+/**
+ * IntentRegistry manages all registered intents and their declared relationships.
+ */
+declare class IntentRegistry {
+    private readonly intents;
+    private readonly dependencies;
+    private readonly productions;
+    /**
+     * Define/register a new intent.
+     *
+     * @param name - Semantic intent name following the convention (Domain.*, Application.*, etc.)
+     * @param options - Optional relationship declarations
+     * @throws Error if an intent with the same name is already registered
+     */
+    define<N extends IntentName, P = unknown>(name: N, options?: DefineIntentOptions): IntentCreator<N, P>;
+    /**
+     * Declare that one intent depends on / relates to another.
+     * This information is used by the DependencyGraph (future iterations) and for policy checks.
+     *
+     * @param from - The source intent (e.g. an Application operation)
+     * @param to - The target intent it depends on (e.g. a Domain event or concept)
+     */
+    declareDependency(from: string, to: string): void;
+    /**
+     * Declare that one intent produces / emits another (e.g. use case → domain event).
+     */
+    declareProduction(from: string, to: string): void;
+    /**
+     * Retrieve a previously defined intent creator by name.
+     */
+    get<N extends IntentName = IntentName, P = unknown>(name: string): IntentCreator<N, P> | undefined;
+    /**
+     * List all registered intent creators.
+     */
+    list(): IntentCreator<IntentName, unknown>[];
+    /**
+     * Get all declared dependencies for a given intent.
+     */
+    getDependencies(intentName: string): string[];
+    /**
+     * Get all intents produced / emitted by a given intent.
+     */
+    getProductions(intentName: string): string[];
+    /**
+     * Get all declared relationships (useful for graph generation).
+     */
+    getAllRelationships(): IntentRelationship[];
+    /**
+     * Check if an intent name has been registered.
+     */
+    has(name: string): boolean;
+    /**
+     * Clear the registry. Primarily useful for tests.
+     */
+    clear(): void;
+}
+
+/**
+ * Dependency Graph types.
+ *
+ * Used to model declared + observed relationships between intents,
+ * and to generate visualizations (Mermaid) and detect violations.
+ */
+
+interface GraphEdge {
+    from: string;
+    to: string;
+    kind?: 'declared' | 'observed' | 'produces';
+}
+interface GraphNode {
+    id: string;
+    kind?: string;
+}
+interface DependencyGraph {
+    /**
+     * Register a declared dependency between two semantic names.
+     */
+    registerDependency(from: string, to: string, kind?: GraphEdge['kind']): void;
+    /**
+     * Register an observed event flow (producer -> consumer).
+     */
+    registerEventFlow(producer: string, consumer: string): void;
+    /**
+     * Return all nodes.
+     */
+    getNodes(): GraphNode[];
+    /**
+     * Return all edges.
+     */
+    getEdges(): GraphEdge[];
+    /**
+     * Export as JSON.
+     */
+    toJSON(): {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    };
+    /**
+     * Export as Mermaid flowchart.
+     */
+    toMermaid(): string;
+    /**
+     * Export as Mermaid flowchart grouped into profile layers.
+     */
+    toLayerMermaid(profile: ArchitectureProfile): string;
+    /**
+     * Detect violations by running provided policies or simple rules.
+     * For simplicity here we accept predicates that return violation messages.
+     */
+    detectViolations(rules?: Array<(edges: GraphEdge[]) => string[]>): string[];
+}
+
+type MaybePromise<T> = T | Promise<T>;
+type AuditRecordType = 'event.published' | 'event.rawPublish' | 'event.intercepted' | 'interceptor.error' | 'policy.softViolation' | 'policy.hardViolation' | 'layer.observedViolation' | 'handler.error' | 'hook.error' | 'workflow.started' | 'workflow.step.completed' | 'workflow.step.failed' | 'workflow.compensation.completed' | 'workflow.completed' | 'workflow.failed' | 'projection.applied' | 'metadata.changed';
+interface AuditRecord {
+    id: string;
+    type: AuditRecordType;
+    timestamp: string;
+    source?: string;
+    actor?: string;
+    intent?: string;
+    correlationId?: string;
+    causationId?: string;
+    subject?: string;
+    details?: unknown;
+}
+interface AuditRecordInput {
+    type: AuditRecordType;
+    timestamp?: string;
+    source?: string;
+    actor?: string;
+    intent?: string;
+    correlationId?: string;
+    causationId?: string;
+    subject?: string;
+    details?: unknown;
+}
+interface AuditQuery {
+    type?: AuditRecordType;
+    intent?: string;
+    correlationId?: string;
+    subject?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+}
+/**
+ * Pluggable persistence for audit records.
+ *
+ * **Durability stance (R9):** Default is `InMemoryAuditStore` — reference only, not
+ * production durability (lost on restart). Implement this interface for durable audit.
+ * See `docs/production-hardening.md`.
+ */
+interface AuditStore {
+    append(record: AuditRecord): MaybePromise<void>;
+    query(query?: AuditQuery): MaybePromise<AuditRecord[]>;
+    clear(): MaybePromise<void>;
+}
+/**
+ * High-level audit API used by the event bus / kernel.
+ * Durability is that of the injected `AuditStore` (default in-memory).
+ */
+interface AuditTrail {
+    record(input: AuditRecordInput): Promise<AuditRecord>;
+    query(query?: AuditQuery): Promise<AuditRecord[]>;
+    clear(): Promise<void>;
+}
+interface CreateAuditTrailOptions {
+    /** Durable store when provided; otherwise `InMemoryAuditStore` (not production durability). */
+    store?: AuditStore;
+    maxRecords?: number;
+}
+
+type EventSchemaFieldType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'unknown';
+interface EventSchemaField {
+    type: EventSchemaFieldType;
+    required?: boolean;
+    description?: string;
+    /** Allowed literal values for this field. Compared with Object.is. */
+    enum?: unknown[];
+    /** Nested object fields when type is "object". */
+    fields?: EventPayloadSchema;
+    /** Array item schema when type is "array". */
+    items?: EventSchemaField;
+}
+type EventPayloadSchema = Record<string, EventSchemaField>;
+/**
+ * Minimal Standard Schema interface (https://standardschema.dev).
+ * Any zod/valibot/arktype (or other spec-compliant) schema satisfies this,
+ * so Ark stays zero-dependency while accepting the validators you already use.
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+type StandardSchemaResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<StandardSchemaIssue>;
+};
+interface StandardSchemaIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }> | undefined;
+}
+interface EventContract {
+    intent: IntentName;
+    version: string;
+    schema?: EventPayloadSchema;
+    /**
+     * A Standard Schema validator (zod, valibot, arktype, ...) for the payload.
+     * Runs in addition to `schema` when both are present. Must validate
+     * synchronously — async validators produce a contract issue.
+     */
+    standardSchema?: StandardSchemaV1;
+    owner?: string;
+    rationale?: string;
+    deprecated?: boolean | string;
+    allowAdditionalFields?: boolean;
+}
+interface EventContractIssue {
+    intent: string;
+    version?: string;
+    field?: string;
+    message: string;
+}
+interface EventContractValidationResult {
+    ok: boolean;
+    contract?: EventContract;
+    issues: EventContractIssue[];
+}
+interface EventContractRegistry {
+    register(contract: EventContract): void;
+    get(intent: string, version?: string): EventContract | undefined;
+    list(intent?: string): EventContract[];
+    validate(event: DomainEvent): EventContractValidationResult;
+    clear(): void;
+}
+
+/**
+ * Metadata System (basic) for extensibility.
+ *
+ * Allows declaring entities, fields and simple rules/behaviors as data.
+ * This can be used by tools, codegen, or AI to understand the domain without hardcoding.
+ */
+interface FieldMeta {
+    type: string;
+    identity?: boolean;
+    required?: boolean;
+    description?: string;
+    relation?: {
+        entity: string;
+        kind?: 'one' | 'many';
+    };
+    readonly?: boolean;
+    deprecated?: boolean | string;
+    tags?: string[];
+    [key: string]: unknown;
+}
+interface EntityRuleMeta {
+    name: string;
+    description?: string;
+    severity?: 'hard' | 'soft';
+}
+interface EntityMeta {
+    name: string;
+    version?: string;
+    owner?: string;
+    layer?: string;
+    tags?: string[];
+    fields: Record<string, FieldMeta>;
+    rules?: EntityRuleMeta[];
+    /** Intent names this entity emits (domain events). */
+    emits?: string[];
+    /** Intent names this entity consumes / reacts to. */
+    consumes?: string[];
+    /** Read-model or projection names that derive from this entity. */
+    projections?: string[];
+    deprecated?: boolean | string;
+    [key: string]: unknown;
+}
+interface MetadataRegistrationOptions {
+    allowOverwrite?: boolean;
+}
+interface MetadataIssue {
+    entity: string;
+    field?: string;
+    message: string;
+}
+interface MetadataValidationResult {
+    ok: boolean;
+    issues: MetadataIssue[];
+}
+interface MetadataRegistry {
+    entity(name: string, meta: Omit<EntityMeta, 'name'>, options?: MetadataRegistrationOptions): EntityMeta;
+    getEntity(name: string): EntityMeta | undefined;
+    listEntities(): EntityMeta[];
+    findEntitiesByIntent(intentName: string): EntityMeta[];
+    validate(): MetadataValidationResult;
+    toJSON(): EntityMeta[];
+}
+
+interface ProjectionDefinition<State = unknown> {
+    name: string;
+    sourceIntents: IntentName[];
+    initialState: State | (() => State);
+    project(event: DomainEvent<IntentName, unknown>, state: State): MaybePromise<State>;
+}
+interface ProjectionCheckpoint {
+    projection: string;
+    appliedCount: number;
+    lastIntent?: string;
+    lastCorrelationId?: string;
+    updatedAt?: string;
+}
+/**
+ * Pluggable projection/read-model state.
+ *
+ * **Durability stance (R9):** Default `InMemoryReadModelStore` is reference-only (not
+ * production durability). Inject a durable store for production. See
+ * `docs/production-hardening.md`.
+ */
+interface ReadModelStore {
+    load<State = unknown>(name: string): MaybePromise<State | undefined>;
+    save<State = unknown>(name: string, state: State): MaybePromise<void>;
+    clear(name?: string): MaybePromise<void>;
+}
+interface ProjectionRegistry {
+    register<State>(definition: ProjectionDefinition<State>): void;
+    list(): ProjectionDefinition[];
+    apply(event: DomainEvent<IntentName, unknown>): Promise<string[]>;
+    getState<State = unknown>(name: string): Promise<State | undefined>;
+    getCheckpoint(name: string): ProjectionCheckpoint | undefined;
+    getCheckpoints(): ProjectionCheckpoint[];
+    clear(): Promise<void>;
+}
+interface CreateProjectionRegistryOptions {
+    store?: ReadModelStore;
+    auditTrail?: AuditTrail;
+}
+
+type EventBufferStatus = 'pending' | 'dispatched' | 'failed';
+interface EventBufferRecord {
+    id: string;
+    event: DomainEvent;
+    status: EventBufferStatus;
+    attempts: number;
+    createdAt: string;
+    updatedAt: string;
+    error?: string;
+    ownerId?: string;
+    expiresAt?: string;
+}
+/**
+ * Pluggable transactional event buffer for publish handoff (Outbox pattern).
+ *
+ * Provides agnostic primitives (tx parameter, claim leases) to allow production implementations
+ * to safely handle concurrency, atomic handoffs, and background processing.
+ *
+ * **Durability stance (R9):** ArkGate ships only a reference in-process store
+ * (`InMemoryEventBuffer`) for tests, demos, and single-process development — it does
+ * not survive process restarts and is **not production durability**. Inject your own
+ * for a transactional outbox. See `docs/production-hardening.md`.
+ */
+interface EventBufferStore {
+    enqueue(event: DomainEvent, tx?: unknown): Promise<EventBufferRecord>;
+    claim?(workerId: string, timeoutMs: number): Promise<EventBufferRecord | undefined>;
+    markDispatched(id: string, tx?: unknown): Promise<void>;
+    markFailed(id: string, error: unknown, tx?: unknown): Promise<void>;
+    list(status?: EventBufferStatus): Promise<EventBufferRecord[]>;
+    clear(): Promise<void>;
+}
+/** @deprecated Use EventBufferStatus. */
+type OutboxStatus = EventBufferStatus;
+/** @deprecated Use EventBufferRecord. */
+type OutboxRecord = EventBufferRecord;
+/** @deprecated Use EventBufferStore. */
+type OutboxStore = EventBufferStore;
+
+/**
+ * Event Bus types for the Ark kernel.
+ *
+ * The Event Bus is the central nervous system for Domain Events.
+ * It provides publish/subscribe, history for observability, and metadata handling.
+ */
+
+/** Standard trace record for observability and agent consumption. */
+type TraceRecordType = 'event.published' | 'event.rawPublish' | 'event.intercepted' | 'interceptor.error' | 'policy.hardViolation' | 'policy.softViolation' | 'layer.observedViolation' | 'handler.error' | 'hook.error';
+/**
+ * Runtime enforcement mode for observed producer→event layer flows.
+ * - 'off': flows are recorded (for drift reports) but never enforced.
+ * - 'soft': a `layer.observedViolation` trace + audit record is emitted; publish proceeds.
+ * - 'hard': publish throws `ObservedLayerFlowViolationError` before the event reaches
+ *   history, outbox, or subscribers.
+ */
+type ObservedLayerFlowMode = 'off' | 'soft' | 'hard';
+interface TraceRecord {
+    type: TraceRecordType;
+    timestamp: string;
+    intent: string;
+    correlationId?: string;
+    traceId?: string;
+    spanId?: string;
+    details?: unknown;
+}
+type TraceSink = (record: TraceRecord) => void;
+/**
+ * Options when creating an EventBus.
+ */
+interface EventBusOptions<Context = unknown> {
+    /** Optional hook called after every successful publish */
+    onPublish?: (event: DomainEvent) => void | Promise<void>;
+    /** Native audit trail used to persist publish, policy, and handler events. */
+    auditTrail?: AuditTrail;
+    /** Event contracts used to validate payload shape and event versions. */
+    eventContracts?: EventContractRegistry;
+    /** When true, events without a registered contract are rejected. */
+    strictEventContracts?: boolean;
+    /** When true, metadata.source must be explicit and not "unknown". */
+    requireKnownSource?: boolean;
+    /**
+     * Architecture profile used to enforce the OBSERVED producer→event layer flow at
+     * publish time. Required for `enforceObservedLayerFlow` to have effect.
+     */
+    architectureProfile?: ArchitectureProfile;
+    /**
+     * Enforce each published event's real producer→event flow (metadata.source → intent)
+     * against `architectureProfile` layer rules at runtime. Unlike the declared-model layer
+     * policy, this checks what the system actually did. Default: 'off'.
+     */
+    enforceObservedLayerFlow?: ObservedLayerFlowMode;
+    /** Optional non-atomic event buffer for dispatch handoff. */
+    eventBuffer?: EventBufferStore;
+    /** @deprecated Use eventBuffer. */
+    outbox?: EventBufferStore;
+    /** Stable id stamped into event metadata for this kernel/event bus instance. */
+    instanceId?: string;
+    /** Lightweight tracing hooks for OpenTelemetry or custom tracer bridges. */
+    traceSinks?: TraceSink[];
+    /** Called when soft policies produce violations (publish still proceeds). */
+    onSoftViolation?: (result: PolicyEvaluationResult, event: DomainEvent) => void | Promise<void>;
+    /** Called when a subscriber handler throws or rejects. */
+    onHandlerError?: (error: unknown, event: DomainEvent, intentName: string) => void | Promise<void>;
+    /** When true, rethrow handler errors after calling onHandlerError. Default: false. */
+    rethrowHandlerErrors?: boolean;
+    /**
+     * Policies to evaluate on every publish.
+     * If provided, they run before subscribers are notified.
+     * Hard violations will cause publish to throw.
+     */
+    policies?: Policy<Context>[];
+    /**
+     * Function to build the context object passed to policies for a given event.
+     * Default: { event }, or { event, relationships, edges } when registry/graph provided.
+     */
+    getPolicyContext?: (event: DomainEvent) => Context;
+    /**
+     * Intent registry whose relationships are injected into the default policy context.
+     * Enables layer policies (e.g. architecturalPolicies.layerIsolation) on publish.
+     */
+    intentRegistry?: IntentRegistry;
+    /**
+     * Dependency graph whose edges are injected into the default policy context.
+     */
+    dependencyGraph?: DependencyGraph;
+    /**
+     * Pre-configured PolicyEngine to use (alternative to policies array).
+     */
+    policyEngine?: PolicyEngine<Context>;
+    /**
+     * Maximum publish history entries to retain. Oldest evicted when exceeded.
+     * Default: unlimited.
+     */
+    maxHistorySize?: number;
+    /**
+     * When true (default: true if intentRegistry is provided), reject publish/subscribe
+     * for intents not registered in intentRegistry and optionally validate naming.
+     */
+    strictRegistry?: boolean;
+    /**
+     * When true (default: matches strictRegistry), validate intent names follow
+     * Domain.* / Application.* / Adapter.* / Workflow.* conventions at runtime.
+     */
+    validateIntentNaming?: boolean;
+}
+/**
+ * A subscriber is a function that receives events of a specific intent.
+ */
+type EventHandler<N extends IntentName, P = unknown> = (event: DomainEvent<N, P>) => void | Promise<void>;
+type EventPayloadPatch = Record<string, unknown> | unknown[];
+interface EventInterceptorContext<N extends IntentName = IntentName, P = unknown> {
+    readonly event: Readonly<DomainEvent<N, P>>;
+    intercept(patch: EventPayloadPatch): void;
+}
+type EventInterceptor<N extends IntentName = IntentName, P = unknown> = (context: EventInterceptorContext<N, P>) => void | Promise<void>;
+interface EventInterceptionInfo {
+    registrationId: string;
+    interceptorId: string;
+    intent: string;
+    createdAt: string;
+    lastInterceptedAt?: string;
+}
+/**
+ * Unsubscribe function returned by subscribe.
+ */
+type Unsubscribe = () => void;
+/**
+ * Record of a published event for observability.
+ */
+interface PublishedEventRecord {
+    event: DomainEvent;
+    publishedAt: string;
+    subscribersNotified: number;
+}
+interface EventPublisher {
+    readonly source: string;
+    publish<N extends IntentName, P>(intent: IntentCreator<N, P>, payload: P, metadata?: Partial<EventMetadata>, control?: EventDispatchControl): Promise<void>;
+}
+/**
+ * Internal dispatch control for ArkRun send ports.
+ * `publish()` keeps historical defaults (notify + await handlers).
+ */
+interface EventDispatchControl {
+    notifySubscribers?: boolean;
+    awaitHandlers?: boolean;
+    runOnPublish?: boolean;
+    tx?: unknown;
+}
+/**
+ * The public EventBus interface.
+ */
+interface EventBus {
+    /**
+     * Publish an event.
+     * Accepts either a pre-built DomainEvent or an IntentCreator + payload (plus optional metadata).
+     */
+    publish<N extends IntentName, P>(eventOrCreator: DomainEvent<N, P> | IntentCreator<N, P>, payloadOrMeta?: P | Partial<EventMetadata>, metadata?: Partial<EventMetadata>, control?: EventDispatchControl): Promise<void>;
+    /**
+     * Create a source-bound publisher capability. The returned publisher stamps
+     * metadata.source internally and rejects attempts to publish as another source.
+     */
+    createPublisher<N extends IntentName, P>(source: N | IntentCreator<N, P>): EventPublisher;
+    /**
+     * Subscribe to events for a specific intent (by name or creator).
+     * Returns an unsubscribe function.
+     */
+    subscribe<N extends IntentName, P>(intent: N | IntentCreator<N, P>, handler: EventHandler<N, P>): Unsubscribe;
+    /**
+     * Register an add-only interceptor for one intent.
+     * Interceptors may enrich payloads, but cannot overwrite existing payload fields.
+     */
+    registerInterceptor<N extends IntentName, P>(intent: N | IntentCreator<N, P>, interceptor: EventInterceptor<N, P>, interceptorId?: string): string;
+    /**
+     * Remove a registered interceptor by registration id.
+     */
+    unregisterInterceptor(registrationId: string): boolean;
+    /**
+     * List registered interceptors.
+     */
+    listInterceptors(intent?: string): EventInterceptionInfo[];
+    /**
+     * Returns the history of published events (for observability and testing).
+     */
+    getHistory(): PublishedEventRecord[];
+    /**
+     * Clears publish history (useful in tests).
+     */
+    clearHistory(): void;
+    /**
+     * Returns the observability trace (publish, soft violations, handler errors).
+     */
+    getTrace(): TraceRecord[];
+    /**
+     * Clears the observability trace.
+     */
+    clearTrace(): void;
+}
+
+interface ObservabilityFlow {
+    from: string;
+    to: string;
+}
+interface ObservabilityDriftReport {
+    generatedAt: string;
+    declaredProductions: ObservabilityFlow[];
+    observedProductions: ObservabilityFlow[];
+    declaredButUnobserved: ObservabilityFlow[];
+    observedButUndeclared: ObservabilityFlow[];
+    unknownSources: ObservabilityFlow[];
+    unregisteredObservedSources: string[];
+    unregisteredObservedIntents: string[];
+    registeredButNeverObserved: string[];
+}
+interface ObservabilityReporter {
+    report(): ObservabilityDriftReport;
+}
+interface CreateObservabilityReporterOptions {
+    registry?: IntentRegistry;
+    eventBus?: EventBus;
+    graph?: DependencyGraph;
+}
+
+/**
+ * Machine-readable manifest types for agent and tooling consumption.
+ */
+
+interface ArkManifestIntent {
+    name: string;
+    dependencies: string[];
+    productions: string[];
+}
+interface ArkManifestPolicy {
+    /** Stable slug for agents (derived from policy name). */
+    id: string;
+    name: string;
+    severity: 'hard' | 'soft';
+    tags?: string[];
+    description?: string;
+    owner?: string;
+    version?: string;
+    rationale?: string;
+    enforcementMode?: PolicyEnforcementMode;
+    deprecated?: boolean | string;
+    replacedBy?: string;
+}
+interface ArkManifestEntityLink {
+    entity: string;
+    emits?: string[];
+    consumes?: string[];
+}
+interface ArkManifestGraph {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+interface ArkManifestArchitecture {
+    profile: string;
+    layers: ArchitectureLayer[];
+    rules: ArchitectureRule[];
+}
+interface ArkManifestProjection {
+    name: string;
+    sourceIntents: string[];
+    checkpoint?: ProjectionCheckpoint;
+}
+interface ArkManifestData {
+    /** Manifest schema version for agent/tooling compatibility. */
+    schemaVersion: string;
+    version: string;
+    exportedAt: string;
+    intents: ArkManifestIntent[];
+    relationships: IntentRelationship[];
+    policies: ArkManifestPolicy[];
+    entities: EntityMeta[];
+    graph: ArkManifestGraph;
+    architecture?: ArkManifestArchitecture;
+    projections: ArkManifestProjection[];
+    eventContracts: EventContract[];
+    observability?: ObservabilityDriftReport;
+    /** Cross-registry links for agent contract discovery. */
+    links: {
+        entityIntents: ArkManifestEntityLink[];
+    };
+}
+interface ArkManifest {
+    toJSON(): ArkManifestData;
+}
+
+/**
+ * Workflow / Saga support.
+ */
+
+type SagaContext = Record<string, unknown>;
+type SagaStatus = 'idle' | 'running' | 'compensating' | 'completed' | 'failed';
+type WorkflowStatus = SagaStatus | 'waiting';
+interface RetryPolicy {
+    attempts: number;
+    delayMs?: number;
+}
+interface WorkflowStep<P extends SagaContext = SagaContext> {
+    name: string;
+    onEvent?: IntentName;
+    retry?: RetryPolicy;
+    timeoutMs?: number;
+    /**
+     * Execute one step. The signal is aborted when `timeoutMs` elapses; implementations
+     * performing I/O must pass it to the underlying client for cooperative cancellation.
+     */
+    execute: (payload: P, bus: EventBus, signal: AbortSignal) => MaybePromise<Partial<P> | void>;
+    compensate?: (payload: P, bus: EventBus, error?: unknown) => MaybePromise<void>;
+}
+interface WorkflowStartTrigger<P extends SagaContext = SagaContext> {
+    intent: IntentName;
+    mapEventToPayload(event: DomainEvent<IntentName, unknown>): P;
+}
+interface WorkflowDefinition<P extends SagaContext = SagaContext> {
+    name: string;
+    steps: WorkflowStep<P>[];
+    startOn?: WorkflowStartTrigger<P>;
+}
+interface WorkflowSnapshot<P extends SagaContext = SagaContext> {
+    id: string;
+    version?: number;
+    workflowName: string;
+    status: WorkflowStatus;
+    context: P;
+    completedSteps: string[];
+    currentStep?: string;
+    failedStep?: string;
+    attempts: Record<string, number>;
+    startedAt: string;
+    updatedAt: string;
+    completedAt?: string;
+    error?: string;
+    ownerId?: string;
+    expiresAt?: string;
+}
+/**
+ * Pluggable saga/workflow snapshot store with OCC and leases.
+ *
+ * **Durability stance (R9):** Default `InMemoryWorkflowStore` is reference-only (not
+ * production durability). Inject a durable store for production. See
+ * `docs/production-hardening.md`.
+ */
+interface WorkflowStore {
+    save<P extends SagaContext>(snapshot: WorkflowSnapshot<P>, tx?: unknown): MaybePromise<void>;
+    get<P extends SagaContext = SagaContext>(id: string, tx?: unknown): MaybePromise<WorkflowSnapshot<P> | undefined>;
+    list(workflowName?: string): MaybePromise<WorkflowSnapshot[]>;
+    claim?(workerId: string, timeoutMs: number, workflowName?: string): MaybePromise<WorkflowSnapshot | undefined>;
+    clear(): MaybePromise<void>;
+}
+interface WorkflowEngine {
+    register<P extends SagaContext>(definition: WorkflowDefinition<P>): void;
+    start<P extends SagaContext>(workflowName: string, initialPayload: P, options?: {
+        id?: string;
+        tx?: unknown;
+    }): Promise<WorkflowSnapshot<P>>;
+    resume<P extends SagaContext>(id: string, options?: {
+        tx?: unknown;
+    }): Promise<WorkflowSnapshot<P> | undefined>;
+    get<P extends SagaContext = SagaContext>(id: string, tx?: unknown): Promise<WorkflowSnapshot<P> | undefined>;
+    list(workflowName?: string): Promise<WorkflowSnapshot[]>;
+}
+interface CreateWorkflowEngineOptions {
+    store?: WorkflowStore;
+    auditTrail?: AuditTrail;
+    defaultRetry?: RetryPolicy;
+}
+interface SagaStep<P extends SagaContext = SagaContext> extends WorkflowStep<P> {
+}
+interface SagaDefinition<P extends SagaContext = SagaContext> {
+    name: string;
+    steps: SagaStep<P>[];
+}
+interface SagaInstance<P extends SagaContext = SagaContext> {
+    id: string;
+    definition: SagaDefinition<P>;
+    readonly status: SagaStatus;
+    readonly completedSteps: string[];
+    run(initialPayload: P): Promise<void>;
+}
+
+/**
+ * Serializable ArkRun information package (ADR 0023 D4).
+ * Tooling snapshot only — never a gate verdict. Strips factories, live
+ * instances, and input DTOs so inspectors cannot reach construction.
+ */
+declare const ARK_RUN_INFORMATION_PACKAGE_SCHEMA_VERSION: "1.0";
+declare const ARK_RUN_COMPONENT_LIFETIMES: readonly ["singleton", "transient"];
+type ArkRunComponentLifetime = (typeof ARK_RUN_COMPONENT_LIFETIMES)[number];
+type ArkRunExtendedInfo = {
+    label?: string;
+    architectureKind?: string;
+    tags?: string[];
+    group?: string;
+    metadata?: Record<string, string | number | boolean | null>;
+};
+type ArkRunInformationPackageComponent = {
+    id: string;
+    lifetime: ArkRunComponentLifetime;
+    uses: string[];
+    reactsTo: string[];
+    raises: string[];
+    sends: string[];
+    extendedInfo?: ArkRunExtendedInfo;
+};
+type DependencyInformationPackage = {
+    schemaVersion: typeof ARK_RUN_INFORMATION_PACKAGE_SCHEMA_VERSION;
+    kernelInstanceId: string;
+    components: ArkRunInformationPackageComponent[];
+};
+/**
+ * Build a JSON-serializable snapshot from unknown component records.
+ * Only id, lifetime, the four declaration lists, and optional extendedInfo
+ * survive — extra keys (factory, instance, DTO payloads) are dropped.
+ */
+declare function buildDependencyInformationPackage(input: {
+    kernelInstanceId?: unknown;
+    components?: unknown;
+}): DependencyInformationPackage;
+
+/**
+ * ArkRun requestGraph slices (RN13). Tooling only — never a gate verdict.
+ * Consumes the information package so factories and live instances cannot leak.
+ */
+
+declare const ARK_RUN_GRAPH_SCHEMA_VERSION: "1.0";
+declare const ARK_RUN_GRAPH_DEFAULT_SLICE: "process";
+declare const ARK_RUN_GRAPH_SLICES: readonly ["process", "technical"];
+declare const ARK_RUN_GRAPH_NODE_KINDS: readonly ["component", "interaction"];
+declare const ARK_RUN_GRAPH_PROCESS_EDGE_KINDS: readonly ["raises", "reactsTo", "sends"];
+declare const ARK_RUN_GRAPH_TECHNICAL_EDGE_KINDS: readonly ["uses"];
+type ArkRunGraphSlice = (typeof ARK_RUN_GRAPH_SLICES)[number];
+type ArkRunGraphNodeKind = (typeof ARK_RUN_GRAPH_NODE_KINDS)[number];
+type ArkRunGraphProcessEdgeKind = (typeof ARK_RUN_GRAPH_PROCESS_EDGE_KINDS)[number];
+type ArkRunGraphTechnicalEdgeKind = (typeof ARK_RUN_GRAPH_TECHNICAL_EDGE_KINDS)[number];
+type ArkRunGraphEdgeKind = ArkRunGraphProcessEdgeKind | ArkRunGraphTechnicalEdgeKind;
+declare class InvalidArkRunGraphQueryError extends Error {
+    readonly option: 'slice' | 'degreesOfSeparation' | 'nodeIds' | 'include' | 'exclude';
+    constructor(option: InvalidArkRunGraphQueryError['option'], detail?: string);
+}
+type ArkRunGraphMatch = {
+    tokens: string[];
+    ids: string[];
+    labels: string[];
+    tags: string[];
+    groups: string[];
+    architectureKinds: string[];
+};
+type ArkRunGraphResolvedQuery = {
+    slice: ArkRunGraphSlice;
+    nodeIds: string[];
+    degreesOfSeparation: number | null;
+    include: ArkRunGraphMatch;
+    exclude: ArkRunGraphMatch;
+};
+type ArkRunGraphQuery = {
+    slice?: ArkRunGraphSlice;
+    nodeIds?: readonly string[];
+    degreesOfSeparation?: number;
+    include?: string | readonly string[] | ArkRunGraphMatchInput;
+    exclude?: string | readonly string[] | ArkRunGraphMatchInput;
+};
+type ArkRunGraphMatchInput = {
+    ids?: readonly string[];
+    labels?: readonly string[];
+    tags?: readonly string[];
+    groups?: readonly string[];
+    architectureKinds?: readonly string[];
+};
+type ArkRunGraphNode = {
+    id: string;
+    kind: ArkRunGraphNodeKind;
+    lifetime?: ArkRunComponentLifetime;
+    label?: string;
+    group?: string;
+    architectureKind?: string;
+    tags?: string[];
+};
+type ArkRunGraphEdge = {
+    from: string;
+    to: string;
+    kind: ArkRunGraphEdgeKind;
+};
+type ArkRunGraph = {
+    schemaVersion: typeof ARK_RUN_GRAPH_SCHEMA_VERSION;
+    kernelInstanceId: string;
+    slice: ArkRunGraphSlice;
+    query: ArkRunGraphResolvedQuery;
+    nodes: ArkRunGraphNode[];
+    edges: ArkRunGraphEdge[];
+    mermaid: string;
+};
+declare function closeArkRunGraphQuery(input?: unknown): ArkRunGraphResolvedQuery;
+declare function arkRunGraphQueryFromSearchParams(params: {
+    slice?: string | null;
+    nodeIds?: string | null;
+    degreesOfSeparation?: string | null;
+    include?: string | null;
+    exclude?: string | null;
+}): ArkRunGraphQuery;
+/**
+ * Render a closed ArkRun graph as Mermaid flowchart text.
+ * Process slices are left-to-right; technical slices are top-down.
+ */
+declare function formatArkRunGraphMermaid(graph: Pick<ArkRunGraph, 'slice' | 'nodes' | 'edges'>): string;
+/**
+ * Slice the information package into a process or technical graph.
+ * Optional nodeIds + degreesOfSeparation keep a neighborhood; include/exclude
+ * are closed token or field queries. Never a score.
+ */
+declare function requestArkRunGraph(pkgInput?: unknown, queryInput?: unknown): ArkRunGraph;
+
+/**
+ * Closed ArkRun send-port vocabulary (ADR 0024).
+ * Pure plan only — delivery is Kernel. Not a durability claim.
+ */
+declare const ARK_RUN_TRANSPORT_KINDS: readonly ["local", "localBlocking", "broker"];
+type ArkRunTransportKind = (typeof ARK_RUN_TRANSPORT_KINDS)[number];
+type ArkRunDeliveredVia = 'local' | 'broker';
+/** Await local recording / adapter handoff before `send()` resolves. Not durability. */
+declare const ARK_RUN_EPHEMERAL_DEFAULT = true;
+declare class InvalidArkRunSendOptionError extends Error {
+    readonly option: 'transport' | 'ephemeral';
+    constructor(option: 'transport' | 'ephemeral');
+}
+type ArkRunSendPlan = {
+    transport: ArkRunTransportKind;
+    ephemeral: boolean;
+    deliveredVia: ArkRunDeliveredVia;
+    fallbackToLocal: boolean;
+    notifySubscribers: boolean;
+    awaitHandlers: boolean;
+    awaitHandoff: boolean;
+};
+type ArkRunSendPlanInput = {
+    transport?: unknown;
+    ephemeral?: unknown;
+    brokerBound: boolean;
+};
+declare function closedArkRunTransportKind(value: unknown): ArkRunTransportKind;
+declare function closedArkRunEphemeral(value: unknown): boolean;
+/**
+ * Decide where a send goes and what `send()` waits for.
+ * Missing broker → in-process local fallback (not cloud portability).
+ */
+declare function resolveArkRunSendPlan(input: ArkRunSendPlanInput): ArkRunSendPlan;
+
+/**
+ * Closed ArkRun inspector bind + snapshot vocabulary (RN12).
+ * Pure plan only — HTTP listen is Kernel. Not a durability claim.
+ */
+
+declare const ARK_RUN_INSPECTOR_SCHEMA_VERSION: "1.0";
+declare const ARK_RUN_INSPECTOR_DEFAULT_HOST = "127.0.0.1";
+declare const ARK_RUN_INSPECTOR_DEFAULT_PORT = 0;
+declare const ARK_RUN_INSPECTOR_SNAPSHOT_PATH = "/snapshot";
+declare const ARK_RUN_INSPECTOR_EVENTS_PATH = "/events";
+declare const ARK_RUN_INSPECTOR_GRAPH_PATH = "/graph";
+declare const ARK_RUN_INSPECTOR_SSE_EVENT = "snapshot";
+declare const ARK_RUN_INSPECTOR_TRANSPORT_FALLBACK: "in-process-local";
+declare class ArkRunInspectorProductionError extends Error {
+    constructor();
+}
+declare class ArkRunInspectorBindError extends Error {
+    constructor(host: string);
+}
+type ArkRunInspectorBind = {
+    host: string;
+    port: number;
+};
+type ArkRunInspectorTransportFacts = {
+    kinds: ArkRunTransportKind[];
+    ephemeralDefault: boolean;
+    brokerBound: boolean;
+    cloudSdksShipped: false;
+    fallback: typeof ARK_RUN_INSPECTOR_TRANSPORT_FALLBACK;
+};
+type ArkRunInspectorSnapshot = {
+    schemaVersion: typeof ARK_RUN_INSPECTOR_SCHEMA_VERSION;
+    kernelInstanceId: string;
+    bind: {
+        host: string;
+        port: number;
+        loopback: true;
+    };
+    package: DependencyInformationPackage;
+    transport: ArkRunInspectorTransportFacts;
+    observability: unknown;
+};
+type ArkRunInspectorBindInput = {
+    host?: unknown;
+    port?: unknown;
+    nodeEnv?: unknown;
+    processNodeEnv?: unknown;
+};
+type ArkRunInspectorSnapshotInput = {
+    kernelInstanceId?: unknown;
+    host?: unknown;
+    port?: unknown;
+    package?: unknown;
+    observability?: unknown;
+    ephemeralDefault?: unknown;
+    brokerBound?: unknown;
+};
+declare function isArkRunInspectorProductionEnv(nodeEnv: unknown): boolean;
+declare function isArkRunInspectorLoopbackHost(host: unknown): boolean;
+declare function resolveArkRunInspectorBind(input?: ArkRunInspectorBindInput): ArkRunInspectorBind;
+declare function arkRunInspectorUrl(host: string, port: number, path: string): string;
+declare function buildArkRunInspectorSnapshot(input?: ArkRunInspectorSnapshotInput): ArkRunInspectorSnapshot;
+declare function formatArkRunInspectorSseEvent(snapshot: unknown): string;
+
+/**
+ * Per-kernel managed-component registry. Factories stay private so the
+ * information package cannot observe construction (ADR 0023 D4).
+ */
+
+type ArkRunRegisterOptions<T = unknown> = {
+    id: string;
+    lifetime?: ArkRunComponentLifetime;
+    uses?: readonly string[];
+    reactsTo?: readonly string[];
+    raises?: readonly string[];
+    sends?: readonly string[];
+    extendedInfo?: ArkRunExtendedInfo;
+    factory?: () => T;
+};
+type ArkRunRegistrationHandle = ArkRunInformationPackageComponent;
+
+type ArkRunInspectorHandle = {
+    host: string;
+    port: number;
+    url: string;
+    snapshotUrl: string;
+    eventsUrl: string;
+    graphUrl: string;
+    close(): Promise<void>;
+};
+
+/**
+ * Opt-in ArkRun inspector. HTTP is dynamically imported so constructing a
+ * kernel does not bind a port or load `node:http`.
+ */
+
+type StartArkRunInspectorOptions = {
+    host?: string;
+    port?: number;
+    /** Participates in the production veto together with process NODE_ENV. */
+    nodeEnv?: string;
+    sseIntervalMs?: number;
+};
+type ArkRunInspectorSource = {
+    getInspectorSnapshot(bind: ArkRunInspectorBind): ArkRunInspectorSnapshot;
+    requestGraph(query?: ArkRunGraphQuery): ArkRunGraph;
+};
+declare function startArkRunInspector(source: ArkRunInspectorSource, options?: StartArkRunInspectorOptions): Promise<ArkRunInspectorHandle>;
+
+/**
+ * ArkRun send ports (ADR 0024): local / localBlocking / broker-with-local-fallback.
+ * Consumers inject broker adapters. This package does not ship cloud SDKs.
+ * Fallback is in-process local delivery — not cloud portability.
+ */
+
+/**
+ * Consumer-owned broker handoff. Resolving means the adapter accepted the
+ * message, not that downstream consumers processed it. Not a durability claim.
+ */
+interface ArkRunBrokerAdapter {
+    send(event: DomainEvent): void | Promise<void>;
+}
+interface ArkRunSendOptions {
+    transport?: ArkRunTransportKind;
+    /** Override kernel `ephemeral`. Default remains true when both are omitted. */
+    ephemeral?: boolean;
+    source?: string;
+    metadata?: Partial<EventMetadata>;
+}
+type ArkRunSendResult = ArkRunSendPlan;
+
+interface ArkKernel {
+    instanceId: string;
+    profile: ArchitectureProfile;
+    registry: IntentRegistry;
+    graph: DependencyGraph;
+    metadata: MetadataRegistry;
+    auditTrail: AuditTrail;
+    eventContracts: EventContractRegistry;
+    eventBuffer: EventBufferStore;
+    /** @deprecated Use eventBuffer. */
+    outbox: EventBufferStore;
+    projections: ProjectionRegistry;
+    policyEngine: PolicyEngine;
+    eventBus: EventBus;
+    workflowEngine: WorkflowEngine;
+    observability: ObservabilityReporter;
+    publisher<N extends IntentName, P>(source: N | IntentCreator<N, P>): ArkRunPublisher;
+    /**
+     * One send site for local / localBlocking / broker (ADR 0024).
+     * Missing broker falls back to in-process local delivery — not cloud portability.
+     */
+    send<N extends IntentName, P>(intent: IntentCreator<N, P>, payload: P, options?: ArkRunSendOptions): Promise<ArkRunSendResult>;
+    /** Handle is declaration metadata only; the factory never leaves the registry. */
+    register<T>(options: ArkRunRegisterOptions<T>): ArkRunRegistrationHandle;
+    resolve<T = unknown>(id: string): T;
+    resolveSingleton<T = unknown>(id: string): T;
+    /** Tooling snapshot of ids, lifetime, and declarations — never construction. */
+    getDependencyInformationPackage(): DependencyInformationPackage;
+    /**
+     * Process or technical graph slice of the information package.
+     * Optional nodeIds, degreesOfSeparation, and include/exclude query.
+     * Mermaid is a helper string on the result — never a score.
+     */
+    requestGraph(query?: ArkRunGraphQuery): ArkRunGraph;
+    /**
+     * Inspector snapshot (package + transport facts + observability). Never
+     * includes factories, live instances, broker adapters, or input DTOs.
+     */
+    getInspectorSnapshot(bind?: ArkRunInspectorBind): ArkRunInspectorSnapshot;
+    /**
+     * Opt-in loopback inspector. Refuses NODE_ENV=production and public binds.
+     * Loads HTTP only when called.
+     */
+    startInspector(options?: StartArkRunInspectorOptions): Promise<ArkRunInspectorHandle>;
+    syncGraph(): void;
+    manifest(): ArkManifest;
+}
+interface CreateArkKernelOptions {
+    /**
+     * When true (default), createArkKernel uses the hardened runtime defaults:
+     * strict event contracts and hard observed-layer enforcement.
+     * Set to false only for explicit migration/legacy paths.
+     */
+    strict?: boolean;
+    profile?: ArchitectureProfile;
+    policies?: Policy[];
+    auditTrail?: AuditTrail;
+    eventContracts?: EventContractRegistry;
+    eventBuffer?: EventBufferStore;
+    /** @deprecated Use eventBuffer. */
+    outbox?: EventBufferStore;
+    metadata?: MetadataRegistry;
+    projections?: ProjectionRegistry;
+    /**
+     * Cap for in-memory event history, trace, and audit records.
+     * Defaults to DEFAULT_MAX_HISTORY_SIZE (1000); oldest records are evicted
+     * first. Pass Infinity for unbounded retention (pre-1.6 behavior).
+     */
+    maxHistorySize?: number;
+    autoApplyProjections?: boolean;
+    strictEventContracts?: boolean;
+    requireKnownSource?: boolean;
+    /**
+     * Enforce observed producer→event layer flows against the profile at runtime.
+     * Defaults to 'hard' when strict is true and 'off' when strict is false.
+     */
+    enforceObservedLayerFlow?: ObservedLayerFlowMode;
+    instanceId?: string;
+    /**
+     * Consumer-injected broker adapter. Absence is normal: broker sends fall back
+     * to in-process local delivery. Not cloud portability. This package does not
+     * ship cloud SDKs.
+     */
+    broker?: ArkRunBrokerAdapter;
+    /**
+     * Await local bus recording / broker adapter handoff before `send()` resolves.
+     * Default true (CLI, tests, short-lived workers). Not a durability claim.
+     */
+    ephemeral?: boolean;
+}
+interface ArkRunPublisher extends EventPublisher {
+    send<N extends IntentName, P>(intent: IntentCreator<N, P>, payload: P, options?: Omit<ArkRunSendOptions, 'source'>): Promise<ArkRunSendResult>;
+}
+interface CreateArkKernelFromConfigOptions extends Omit<CreateArkKernelOptions, 'profile'> {
+    /** Runtime profile name. Default: config.name or "ark.config.json". */
+    profileName?: string;
+}
+type ArkKernelConfig = ArkCheckConfig;
+
+export { ARK_RUN_INSPECTOR_GRAPH_PATH as $, type ArkKernel as A, type OutboxRecord as B, type CreateArkKernelOptions as C, type DefineIntentOptions as D, type EventContractRegistry as E, type ObservabilityDriftReport as F, type GraphEdge as G, ARK_RUN_COMPONENT_LIFETIMES as H, IntentRegistry as I, ARK_RUN_EPHEMERAL_DEFAULT as J, ARK_RUN_GRAPH_DEFAULT_SLICE as K, ARK_RUN_GRAPH_NODE_KINDS as L, type MetadataRegistry as M, ARK_RUN_GRAPH_PROCESS_EDGE_KINDS as N, type ObservabilityReporter as O, type ProjectionRegistry as P, ARK_RUN_GRAPH_SCHEMA_VERSION as Q, type ReadModelStore as R, type SagaContext as S, type TraceRecordType as T, ARK_RUN_GRAPH_SLICES as U, ARK_RUN_GRAPH_TECHNICAL_EDGE_KINDS as V, type WorkflowStore as W, ARK_RUN_INFORMATION_PACKAGE_SCHEMA_VERSION as X, ARK_RUN_INSPECTOR_DEFAULT_HOST as Y, ARK_RUN_INSPECTOR_DEFAULT_PORT as Z, ARK_RUN_INSPECTOR_EVENTS_PATH as _, type DependencyGraph as a, InvalidArkRunSendOptionError as a$, ARK_RUN_INSPECTOR_SCHEMA_VERSION as a0, ARK_RUN_INSPECTOR_SNAPSHOT_PATH as a1, ARK_RUN_INSPECTOR_SSE_EVENT as a2, ARK_RUN_INSPECTOR_TRANSPORT_FALLBACK as a3, ARK_RUN_TRANSPORT_KINDS as a4, type ArkManifestArchitecture as a5, type ArkManifestData as a6, type ArkManifestEntityLink as a7, type ArkManifestGraph as a8, type ArkManifestIntent as a9, type ArkRunInspectorSource as aA, type ArkRunInspectorTransportFacts as aB, type ArkRunPublisher as aC, type ArkRunRegisterOptions as aD, type ArkRunRegistrationHandle as aE, type ArkRunSendOptions as aF, type ArkRunSendPlan as aG, type ArkRunSendPlanInput as aH, type ArkRunSendResult as aI, type ArkRunTransportKind as aJ, type AuditRecordInput as aK, type AuditRecordType as aL, type DependencyInformationPackage as aM, type EntityMeta as aN, type EventContractIssue as aO, type EventHandler as aP, type EventInterceptionInfo as aQ, type EventInterceptor as aR, type EventInterceptorContext as aS, type EventPayloadPatch as aT, type EventPayloadSchema as aU, type EventPublisher as aV, type EventSchemaField as aW, type EventSchemaFieldType as aX, type FieldMeta as aY, type GraphNode as aZ, InvalidArkRunGraphQueryError as a_, type ArkManifestPolicy as aa, type ArkManifestProjection as ab, type ArkRunBrokerAdapter as ac, type ArkRunComponentLifetime as ad, type ArkRunDeliveredVia as ae, type ArkRunExtendedInfo as af, type ArkRunGraph as ag, type ArkRunGraphEdge as ah, type ArkRunGraphEdgeKind as ai, type ArkRunGraphMatch as aj, type ArkRunGraphMatchInput as ak, type ArkRunGraphNode as al, type ArkRunGraphNodeKind as am, type ArkRunGraphProcessEdgeKind as an, type ArkRunGraphQuery as ao, type ArkRunGraphResolvedQuery as ap, type ArkRunGraphSlice as aq, type ArkRunGraphTechnicalEdgeKind as ar, type ArkRunInformationPackageComponent as as, type ArkRunInspectorBind as at, ArkRunInspectorBindError as au, type ArkRunInspectorBindInput as av, type ArkRunInspectorHandle as aw, ArkRunInspectorProductionError as ax, type ArkRunInspectorSnapshot as ay, type ArkRunInspectorSnapshotInput as az, type AuditStore as b, type ObservabilityFlow as b0, type ObservedLayerFlowMode as b1, type OutboxStore as b2, type PolicyEvaluationResult as b3, type ProjectionCheckpoint as b4, type ProjectionDefinition as b5, type PublishedEventRecord as b6, type RetryPolicy as b7, type SagaStatus as b8, type SagaStep as b9, type StartArkRunInspectorOptions as ba, type TraceSink as bb, type Unsubscribe as bc, type WorkflowDefinition as bd, type WorkflowStatus as be, type WorkflowStep as bf, arkRunGraphQueryFromSearchParams as bg, arkRunInspectorUrl as bh, buildArkRunInspectorSnapshot as bi, buildDependencyInformationPackage as bj, closeArkRunGraphQuery as bk, closedArkRunEphemeral as bl, closedArkRunTransportKind as bm, formatArkRunGraphMermaid as bn, formatArkRunInspectorSseEvent as bo, isArkRunInspectorLoopbackHost as bp, isArkRunInspectorProductionEnv as bq, requestArkRunGraph as br, resolveArkRunInspectorBind as bs, resolveArkRunSendPlan as bt, startArkRunInspector as bu, type AuditRecord as c, type AuditQuery as d, type CreateAuditTrailOptions as e, type AuditTrail as f, type EventContract as g, type EventContractValidationResult as h, type CreateProjectionRegistryOptions as i, type EventBufferStore as j, type EventBufferRecord as k, type EventBufferStatus as l, type EventBusOptions as m, type EventBus as n, type CreateObservabilityReporterOptions as o, PolicyEngine as p, type ArkManifest as q, type WorkflowSnapshot as r, type SagaDefinition as s, type CreateWorkflowEngineOptions as t, type SagaInstance as u, type WorkflowEngine as v, type ArkKernelConfig as w, type CreateArkKernelFromConfigOptions as x, type TraceRecord as y, type OutboxStatus as z };