arkgate 4.8.23 → 4.8.25

package/dist/types-CnauMQQL.d.ts

@@ -0,0 +1,1800 @@
+type MaybePromise<T> = T | Promise<T>;
+type AuditRecordType = 'event.published' | 'event.rawPublish' | 'event.handoffFailed' | 'event.intercepted' | 'interceptor.error' | 'policy.softViolation' | 'policy.hardViolation' | 'layer.observedViolation' | 'layer.observedFlowUnresolvable' | '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 vocabulary for the ark.config.json contract (U02 pilot 1).
+ *
+ * Pure declarations only — no runtime values. The loader/validator logic and the
+ * published JSON Schema live in ./configContract.ts. Extra defaulting lives in
+ * ./configExtras.ts (generated sibling `config-extras.mjs`). Type-only imports
+ * from this file are erased on transpile.
+ */
+type ArkConfigSchemaVersion = '1.0' | '1.1' | '1.2' | '1.3';
+type ArkConfigCyclePolicy = 'strict' | 'soft' | 'framework-soft' | 'off';
+type ArkConfigLayerCapabilities = {
+    deny?: string[];
+};
+/** Who this folder is for. Metadata — not import-rule teeth. Absence is silent. */
+type ArkConfigLayerTrustBoundary = 'public' | 'auth' | 'admin' | 'internal';
+type ArkConfigLayer = {
+    name: string;
+    patterns: string[];
+    exclude?: string[];
+    intentPrefixes?: string[];
+    /**
+     * App-context caption for this layer.
+     * Metadata — excluded from policy hash. Absence is silent.
+     */
+    description?: string;
+    /**
+     * Who this folder is for: public | auth | admin | internal.
+     * Metadata — excluded from policy hash. Absence is silent. Not host/CI TLS.
+     */
+    trustBoundary?: ArkConfigLayerTrustBoundary;
+    /**
+     * Who owns this house: GitHub handles or emails (same identity as stewards).
+     * Metadata — excluded from policy hash. Absence is silent unless
+     * `requireLayerOwners` is true. Not import-rule teeth.
+     */
+    owners?: string[];
+    forbiddenGlobals?: string[];
+    /** ADR 0009 D2 — opt-in effect-capability walls; absence changes no verdict. */
+    capabilities?: ArkConfigLayerCapabilities;
+    /** Dual-depth sugar: `pure: true` denies all seven capabilities. */
+    pure?: boolean;
+    mayImportInfrastructure?: boolean;
+    optional?: boolean;
+    /**
+     * Future house: empty globs are expected. `--strict-config` must not fail.
+     * Typo warning (`CONFIG_LAYER_PATTERN_NO_MATCHES`) is skipped.
+     */
+    reserved?: boolean;
+    /** Alias of reserved — empty pattern matches are allowed. */
+    allowEmpty?: boolean;
+};
+/** How a starred `sliceFolders` prefix is named. Absent equals `path`. */
+type ArkConfigSliceIdentity = 'path' | 'stars';
+type ArkConfigRule = {
+    from: string;
+    to: string;
+    allowed: boolean;
+    message?: string;
+    peerIsolation?: boolean;
+    sliceFolders?: string[];
+    /**
+     * How a starred `sliceFolders` prefix is named.
+     * Absent and `path` keep today's ids. `stars` is the last literal plus every
+     * star binding (a star before the last literal is kept too).
+     */
+    sliceIdentity?: ArkConfigSliceIdentity;
+    /** Roots the repo declares shared on purpose — evidence, not unclassifiable. */
+    sharedRoots?: string[];
+    /** Directed slice→slice edges the repo declares on purpose. */
+    allowedCrossSlice?: ArkConfigCrossSliceEdge[];
+    /**
+     * `"deny"` blocks a shared root from importing a slice.
+     * `"deny-cross-parent"` leaves that hop allowed and asks the whole-graph
+     * check to report a slice that reaches another universe through shared.
+     * The object form carries `stopAt`: composition roots the walk never
+     * passes through.
+     */
+    sharedImportsSlice?: ArkConfigSharedImportsSlice;
+    /**
+     * Optional inner wall. Absent keeps today's universe-wall output.
+     * `siblings` defaults to deny. An object keeps that default and lists enforced subtrees.
+     * `parentMayImportChild` defaults to false.
+     */
+    childSlices?: ArkConfigChildSlices;
+};
+type ArkConfigSharedImportsSlice = 'deny' | 'deny-cross-parent' | {
+    mode: 'deny-cross-parent';
+    stopAt: string[];
+};
+type ArkConfigChildSlices = {
+    sliceFolders: string[];
+    sliceIdentity?: ArkConfigSliceIdentity;
+    commonFolders?: string[];
+    /**
+     * `ratchet` on the object form: absent turns the anti-growth ratchet on only
+     * when the baseline already records an advisory crossing of this rule;
+     * `true` always; `false` measures only.
+     */
+    siblings?: 'deny' | 'advisory' | {
+        default: 'deny' | 'advisory';
+        enforce?: string[];
+        ratchet?: boolean;
+    };
+    parentMayImportChild?: boolean;
+    /** Text for inner-wall findings (sibling, common → child). Absent: ArkGate default, never the rule message. */
+    message?: string;
+    /**
+     * Directed child-slice allowances. `*` is one whole path segment.
+     * Clears a sibling crossing only. The universe `allowedCrossSlice` does not read this list.
+     */
+    allowedCrossSlice?: ArkConfigCrossSliceEdge[];
+    /**
+     * Files outside the slice trees, borrowed onto a child id until they move.
+     * `to` is the universe id plus one child segment.
+     */
+    sliceAliases?: ArkConfigSliceAlias[];
+    /**
+     * Filename at each child slice root. `<Layer>` is the only token.
+     * Example: `arkrules.<Layer>.json`.
+     */
+    arkRulesFile?: string;
+};
+type ArkConfigSliceAlias = {
+    from: string;
+    to: string;
+    /** True: the path stays. It is not an owed move and does not clear other honesty debt. */
+    pinned?: boolean;
+    /** Doctor label, such as `framework-route`. A label alone does not pin. */
+    reason?: string;
+};
+type ArkConfigCrossSliceEdge = {
+    from: string;
+    to: string;
+};
+type ArkConfigSafety = {
+    maxTsSuppressions?: number;
+    maxAnyCasts?: number;
+    allowInMemory?: boolean;
+    allowDisabledPeerIsolation?: boolean;
+};
+/**
+ * Optional invariant-coverage scan controls. Absence keeps the built-in
+ * defaults (test-name heuristic, 400-file budget) and changes no verdict.
+ */
+type ArkConfigCoverage = {
+    /** Globs that decide which files count as tests (replaces the name heuristic). */
+    testGlobs?: string[];
+    /** Max files loaded as coverage evidence before the budget is exhausted. */
+    maxFiles?: number;
+    /**
+     * Path prefixes where this project declares its test runner actually executes
+     * tests. ArkGate never runs anything: this is a second declaration to compare
+     * the coverage scan against, so a covering test found outside them is reported
+     * (INVARIANT_COVERAGE_OUTSIDE_ROOTS) instead of silently certifying the
+     * invariant. Absence is silent unless any catalogued invariant is enforced —
+     * then missing roots fail closed (INVARIANT_COVERAGE_ROOTS_MISSING).
+     */
+    coverageRoots?: string[];
+};
+/**
+ * ADR 0012 — optional map of layer name → project-relative ArkRules file path.
+ * Absence changes no inter-layer verdict.
+ */
+/** One path, or several paths merged into that layer's catalog. */
+type ArkConfigArkRulesRef = string | string[];
+type ArkConfigArkRulesRefs = Record<string, ArkConfigArkRulesRef>;
+/** ADR 0020 — advisory never adds merge teeth; enforced is the extra's merge plane. */
+type ArkConfigArkRunMode = 'advisory' | 'enforced';
+/**
+ * ADR 0020 — optional inline ArkRun extra (schema 1.2+). Absence is silent.
+ * Present objects are fully defaulted by the loader.
+ */
+type ArkConfigArkRun = {
+    mode: ArkConfigArkRunMode;
+    compositionRoots: string[];
+    kernelRoots?: string[];
+    managedLayers: string[];
+    requireDeclarations: boolean;
+    ignoreDirectNewForErrors?: boolean;
+};
+/** ADR 0027 — advisory never adds merge teeth; enforced is the extra's merge plane. */
+type ArkConfigArkOrderMode = 'advisory' | 'enforced';
+/**
+ * ADR 0027 — optional inline ArkOrder extra (schema 1.3+). Absence is silent.
+ * Present objects are fully defaulted by the loader.
+ */
+type ArkConfigArkOrder = {
+    mode: ArkConfigArkOrderMode;
+    planeRoots: string[];
+    managedLayers: string[];
+    /**
+     * Haken cap on one `release()` / `assertXiKeyCap` (default 7).
+     * Not a cap on the `xiKeys` watchlist length.
+     */
+    maxXiKeys: number;
+    /**
+     * Slow product keys the team can already name (plan, cost code, protocol).
+     * Optional. Empty → `ARKORDER_XI_FIELD_WRITE` stays silent.
+     * Repo-wide watchlist — not compared to `maxXiKeys`.
+     */
+    xiKeys: string[];
+    /**
+     * Optional globs that narrow ξ field-write observation inside `managedLayers`.
+     * Same glob engine as `layers[].patterns`. Absence or empty → every file in
+     * those layers. Non-empty → emit only when the layer is managed AND the file
+     * matches at least one glob.
+     */
+    appliesTo?: string[];
+};
+type ArkConfig = {
+    $schema: string;
+    schemaVersion: ArkConfigSchemaVersion;
+    name?: string;
+    include: string[];
+    exclude?: string[];
+    excludeGenerated?: boolean;
+    frameworkOverlay?: string;
+    layers: ArkConfigLayer[];
+    rules: ArkConfigRule[];
+    cyclePolicy?: ArkConfigCyclePolicy;
+    dynamicImportAllowlist?: string[];
+    safety?: ArkConfigSafety;
+    /**
+     * Invariant-coverage scan controls (test globs + file budget).
+     * Absence keeps the defaults; it never turns coverage on by itself.
+     */
+    coverage?: ArkConfigCoverage;
+    /** ADR 0012 — modular ArkRules references (schema 1.1+). */
+    arkRules?: ArkConfigArkRulesRefs;
+    /** ADR 0020 — optional ArkRun extra (schema 1.2+). Absence changes no Layers/ArkRules verdict. */
+    arkRun?: ArkConfigArkRun;
+    /** ADR 0027 — optional ArkOrder extra (schema 1.3+). Absence changes no Layers/ArkRules/ArkRun verdict. */
+    arkOrder?: ArkConfigArkOrder;
+    /**
+     * Optional GitHub handles or emails who may loosen the contract or grow the baseline.
+     * Metadata — excluded from policy hash. Absence means no steward lock (policy-ack still applies).
+     */
+    stewards?: string[];
+    /**
+     * When true, every non-reserved layer must name `owners`. Absence/false is
+     * silent. This flag is policy teeth (stays in policyHash). Owners themselves
+     * stay metadata.
+     */
+    requireLayerOwners?: boolean;
+};
+/** Original input version when the loader rewrote schemaVersion toward current. */
+type ArkConfigMigratedFrom = 'unversioned' | '1.0' | '1.1' | '1.2' | null;
+type ArkConfigLoadResult = {
+    config: ArkConfig;
+    migratedFrom: ArkConfigMigratedFrom;
+};
+
+/**
+ * Architecture layer profiles.
+ *
+ * A profile turns semantic names such as `Domain.Order.Placed` into governed
+ * layer names and dependency rules.
+ */
+
+interface ArchitectureLayer {
+    name: string;
+    prefixes: string[];
+    /**
+     * Custom matcher for teams whose intent names don't follow prefix conventions.
+     * Checked before any prefix matching, in layer declaration order. A layer may
+     * use `match` alone (with `prefixes: []`), prefixes alone, or both.
+     */
+    match?: (name: string) => boolean;
+    description?: string;
+    trustBoundary?: 'public' | 'auth' | 'admin' | 'internal';
+    owners?: string[];
+    order?: number;
+}
+type ArchitectureRule = ArkConfigRule;
+interface ArchitectureProfile {
+    name: string;
+    layers: ArchitectureLayer[];
+    rules: ArchitectureRule[];
+    resolveLayer(name: string): string | undefined;
+}
+interface CreateArchitectureProfileOptions {
+    name: string;
+    layers: ArchitectureLayer[];
+    rules?: ArchitectureRule[];
+}
+interface CreateArchitectureProfileFromArkConfigOptions {
+    /** Runtime profile name. Default: config.name or "ark.config.json". */
+    name?: string;
+}
+type ArchitectureLayerConfig = ArkConfigLayer;
+type ArkCheckConfig = Omit<ArkConfig, '$schema' | 'schemaVersion' | 'rules'> & {
+    $schema?: string;
+    schemaVersion?: ArkConfig['schemaVersion'];
+    rules?: ArchitectureRule[];
+};
+interface CreateElevenLayerArkConfigOptions {
+    /** Source root used in generated file patterns. Default: "src". */
+    rootDir?: string;
+    /** Include entries for ark-check. Default: [rootDir]. */
+    include?: string[];
+    /** Mark generated layers optional. Default: true. */
+    optionalLayers?: boolean;
+}
+
+/**
+ * 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[];
+}
+
+/**
+ * Core domain primitives for Ark.
+ * These types are the foundation for all governance concepts.
+ */
+/**
+ * Semantic intent names follow a convention:
+ * - Domain.* for domain events and entities
+ * - Application.* for use-cases / orchestration
+ * - Adapter.* for integration points
+ * - Workflow.* for sagas and processes
+ * - Job.* for background jobs and scheduling
+ * - Presentation.* for UI/API adapters
+ * - Reporting.* for read models and projections
+ * - Metadata.* for extensibility contracts
+ * - Security.* / Audit.* / Observability.* for cross-cutting kernel concerns
+ * - Kernel.* for Ark-owned governance signals
+ */
+type IntentName = `Domain.${string}` | `Application.${string}` | `Adapter.${string}` | `Workflow.${string}` | `Job.${string}` | `Presentation.${string}` | `Reporting.${string}` | `Metadata.${string}` | `Security.${string}` | `Audit.${string}` | `Observability.${string}` | `Kernel.${string}`;
+type CorrelationId = string;
+interface EventMetadata {
+    occurredAt: string;
+    source: string;
+    kernelInstanceId?: string;
+    eventVersion?: string;
+    schemaVersion?: string;
+    allowInterception?: boolean;
+    interceptions?: Array<{
+        interceptorId: string;
+        timestamp: string;
+    }>;
+    correlationId?: CorrelationId;
+    causationId?: string;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    [key: string]: unknown;
+}
+interface DomainEvent<Name extends IntentName = IntentName, Payload = unknown> {
+    intent: Name;
+    payload: Payload;
+    metadata: EventMetadata;
+}
+
+/**
+ * Intent-specific types for the Ark kernel.
+ *
+ * Intents provide semantic naming for every important concept in the system
+ * (domain events, application operations, adapters, workflows).
+ */
+
+/**
+ * An IntentCreator is a callable that creates a strongly-typed DomainEvent
+ * when invoked with a payload.
+ *
+ * It also carries the semantic `name`.
+ *
+ * @example
+ * const OrderPlaced = defineIntent<'Domain.Order.OrderPlaced', { orderId: string }>('Domain.Order.OrderPlaced');
+ * const event = OrderPlaced({ orderId: 'o-1' });
+ */
+interface IntentCreator<Name extends IntentName, Payload = unknown> {
+    /**
+     * Creates a DomainEvent for this intent.
+     */
+    (payload: Payload): DomainEvent<Name, Payload>;
+    /**
+     * The fully-qualified semantic name of the intent (e.g. "Domain.Order.OrderPlaced").
+     */
+    readonly name: Name;
+}
+/** Kind of relationship between two intents. */
+type IntentRelationshipKind = 'dependsOn' | 'produces';
+/**
+ * Relationship declarations between intents.
+ * Used for dependency analysis and graph generation.
+ */
+interface IntentRelationship {
+    from: string;
+    to: string;
+    kind: IntentRelationshipKind;
+}
+
+/**
+ * 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;
+}
+
+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;
+}
+
+/**
+ * Policy types for the Ark kernel.
+ *
+ * Policies allow declaring architectural rules that can be checked at runtime.
+ * Supports both hard policies (must never be violated) and soft policies (warnings).
+ */
+type PolicySeverity = 'hard' | 'soft';
+type PolicyEnforcementMode = 'runtime' | 'static' | 'runtime-and-static' | 'advisory';
+/**
+ * Represents a single violation of a policy.
+ */
+interface PolicyViolation {
+    /** Name of the policy that was violated */
+    policyName: string;
+    /** Severity level of the policy */
+    severity: PolicySeverity;
+    /** Human-readable explanation of the violation */
+    message: string;
+    /** Optional additional structured details */
+    details?: unknown;
+}
+/**
+ * A Policy defines a rule that can be evaluated against a context.
+ *
+ * @template Context - The shape of data the policy evaluates (e.g. { registry, events })
+ */
+interface Policy<Context = unknown> {
+    /** Unique name of the policy (used in violations and reporting) */
+    readonly name: string;
+    /** Whether this is a hard rule (enforced strictly) or soft (advisory) */
+    readonly severity: PolicySeverity;
+    /** Optional tags for policy classification (e.g. 'layer', 'naming') */
+    readonly tags?: readonly string[];
+    readonly owner?: string;
+    readonly version?: string;
+    readonly rationale?: string;
+    readonly enforcementMode?: PolicyEnforcementMode;
+    readonly deprecated?: boolean | string;
+    readonly replacedBy?: string;
+    /**
+     * Evaluates the policy against the given context.
+     * Return true / [] for pass, false / single violation / array for failure.
+     */
+    check(context: Context): boolean | PolicyViolation | PolicyViolation[];
+}
+
+/**
+ * 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;
+}
+
+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.handoffFailed' | '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;
+    /**
+     * When true, the event-buffer record written for a publish is marked
+     * `dispatched` once local delivery finishes (handlers + onPublish), or `failed`
+     * when a rethrown handler error aborts it. Use only when no external relay
+     * drains the buffer. Default: false — records stay `pending` for a
+     * consumer-owned relay (`claim` / `markDispatched`). `createArkKernel` turns
+     * this on for its default in-memory buffer only.
+     */
+    settleBufferOnLocalDelivery?: boolean;
+    /** @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;
+    /**
+     * When false, skip local-delivery settlement of the buffer record even if the
+     * bus settles on local delivery (the caller owns the outcome, e.g. a broker
+     * handoff). Default: the bus `settleBufferOnLocalDelivery` option.
+     */
+    settleBufferOnLocalDelivery?: boolean;
+    /** Receives the event-buffer record written for this publish, when any. */
+    onBufferRecord?: (record: EventBufferRecord) => void;
+}
+/**
+ * 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;
+};
+declare const ARK_RUN_DECISION_TAPE_RESIDUAL_KINDS: readonly ["absorb", "escalate_up", "hold"];
+type ArkRunDecisionTapeResidualKind = (typeof ARK_RUN_DECISION_TAPE_RESIDUAL_KINDS)[number];
+/** Additive Order residual tape (ADR 0034 D6). Not a bus. Not durable. */
+type ArkRunDecisionTapeRecord = {
+    xiHash: string;
+    event: {
+        kind: string;
+        payload?: Record<string, string | number | boolean | null>;
+    };
+    residual: {
+        kind: ArkRunDecisionTapeResidualKind;
+        reasonCode?: string;
+        eventId?: string;
+        target?: string;
+    };
+};
+type DependencyInformationPackage = {
+    schemaVersion: typeof ARK_RUN_INFORMATION_PACKAGE_SCHEMA_VERSION;
+    kernelInstanceId: string;
+    components: ArkRunInformationPackageComponent[];
+    /** Optional; omitted keeps the 4.8.x component snapshot shape. */
+    decisionTape?: ArkRunDecisionTapeRecord[];
+};
+declare function buildDependencyInformationPackage(input: {
+    kernelInstanceId?: unknown;
+    components?: unknown;
+    decisionTape?: unknown;
+}): DependencyInformationPackage;
+declare function appendDecisionTape(pack: DependencyInformationPackage, record: 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_OUTBOX_PATH = "/outbox";
+declare const ARK_RUN_INSPECTOR_WORKFLOWS_PATH = "/workflows";
+declare const ARK_RUN_INSPECTOR_SSE_EVENT = "snapshot";
+declare const ARK_RUN_INSPECTOR_TRANSPORT_FALLBACK: "in-process-local";
+/** Server-side sample cap for outbox/workflows monitors (DoS floor). */
+declare const ARK_RUN_INSPECTOR_MONITOR_SAMPLE_LIMIT = 32;
+/** Outbox statuses the Queues monitor surfaces (dispatched is omitted). */
+declare const ARK_RUN_INSPECTOR_OUTBOX_MONITOR_STATUSES: readonly ["pending", "failed"];
+type ArkRunInspectorOutboxMonitorStatus = (typeof ARK_RUN_INSPECTOR_OUTBOX_MONITOR_STATUSES)[number];
+type ArkRunInspectorStoreDurabilityKind = 'memory' | 'durable';
+type ArkRunInspectorStoreRole = 'outbox' | 'audit' | 'workflow';
+type ArkRunInspectorStoreDurability = {
+    role: ArkRunInspectorStoreRole;
+    id: string;
+    kind: ArkRunInspectorStoreDurabilityKind;
+};
+type ArkRunInspectorHardeningDurability = {
+    stores: ArkRunInspectorStoreDurability[];
+};
+type ArkRunInspectorHardening = {
+    durability: ArkRunInspectorHardeningDurability;
+};
+type ArkRunInspectorOutboxRecordSummary = {
+    id: string;
+    status: ArkRunInspectorOutboxMonitorStatus;
+    attempts: number;
+    intent?: string;
+    error?: string;
+    updatedAt?: string;
+};
+type ArkRunInspectorOutboxMonitor = {
+    available: boolean;
+    pendingCount: number;
+    failedCount: number;
+    pending: ArkRunInspectorOutboxRecordSummary[];
+    failed: ArkRunInspectorOutboxRecordSummary[];
+    /** Cap applied to pending/failed sample arrays (counts remain accurate). */
+    sampleLimit: number;
+};
+type ArkRunInspectorWorkflowSummary = {
+    id: string;
+    name: string;
+    status: string;
+    currentStep?: string;
+    error?: string;
+};
+type ArkRunInspectorWorkflowsMonitor = {
+    available: boolean;
+    total: number;
+    runningCount: number;
+    compensatingCount: number;
+    failedCount: number;
+    pendingCount: number;
+    workflows: ArkRunInspectorWorkflowSummary[];
+    /** Cap applied to workflows sample array (counts remain accurate). */
+    sampleLimit: number;
+};
+type ArkRunInspectorMonitorBuildOptions = {
+    /** Bound samples; clamped to 0…ARK_RUN_INSPECTOR_MONITOR_SAMPLE_LIMIT. Default 32. */
+    sampleLimit?: number;
+};
+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;
+    /** Explicit store durability facts from real kernel ports (never component-id inference). */
+    hardening: ArkRunInspectorHardening;
+    /** Optional OD04 queue facts when the caller supplies them (endpoints preferred). */
+    outbox?: ArkRunInspectorOutboxMonitor;
+    /** Optional OD04 workflow facts when the caller supplies them (endpoints preferred). */
+    workflows?: ArkRunInspectorWorkflowsMonitor;
+};
+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;
+    hardening?: unknown;
+    outbox?: unknown;
+    workflows?: 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;
+/**
+ * Classify a store port by constructor / declared id. `InMemory*` → memory; else durable.
+ */
+declare function classifyArkRunInspectorStoreDurability(id: unknown, role: ArkRunInspectorStoreRole): ArkRunInspectorStoreDurability;
+/**
+ * Build hardening.durability facts from explicit store rows (not package.components).
+ */
+declare function buildArkRunInspectorHardening(input?: unknown): ArkRunInspectorHardening;
+/**
+ * Sanitize EventBufferStore.list rows into pending/failed monitor facts (no payloads).
+ * Counts cover the full input; sample arrays are capped at sampleLimit (≤32).
+ */
+declare function buildArkRunInspectorOutboxMonitor(records?: unknown, options?: ArkRunInspectorMonitorBuildOptions): ArkRunInspectorOutboxMonitor;
+declare function unavailableArkRunInspectorOutboxMonitor(): ArkRunInspectorOutboxMonitor;
+/**
+ * Sanitize WorkflowEngine.list rows into monitor facts (id/name/status/step/error only).
+ * Counts cover the full input; the workflows sample is capped at sampleLimit (≤32).
+ */
+declare function buildArkRunInspectorWorkflowsMonitor(snapshots?: unknown, options?: ArkRunInspectorMonitorBuildOptions): ArkRunInspectorWorkflowsMonitor;
+declare function unavailableArkRunInspectorWorkflowsMonitor(): ArkRunInspectorWorkflowsMonitor;
+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 ArkRunInspectorListenSource = {
+    getInspectorSnapshot(bind: ArkRunInspectorBind): ArkRunInspectorSnapshot;
+    requestGraph(query?: ArkRunGraphQuery): ArkRunGraph;
+    /** OD04: pending/failed outbox summaries (EventBufferStore.list). */
+    listInspectorOutbox?(): Promise<ArkRunInspectorOutboxMonitor>;
+    /** OD04: workflow/saga summaries (WorkflowEngine.list). */
+    listInspectorWorkflows?(): Promise<ArkRunInspectorWorkflowsMonitor>;
+    /** Duck-typed kernel ports when explicit list* helpers are absent. */
+    outbox?: {
+        list(status?: 'pending' | 'dispatched' | 'failed'): Promise<unknown[]>;
+    };
+    eventBuffer?: {
+        list(status?: 'pending' | 'dispatched' | 'failed'): Promise<unknown[]>;
+    };
+    workflowEngine?: {
+        list(workflowName?: string): Promise<unknown[]>;
+    };
+};
+type ArkRunInspectorHandle = {
+    host: string;
+    port: number;
+    url: string;
+    snapshotUrl: string;
+    eventsUrl: string;
+    graphUrl: string;
+    outboxUrl: string;
+    workflowsUrl: string;
+    close(): Promise<void>;
+};
+
+type StartArkRunInspectorOptions = {
+    host?: string;
+    port?: number;
+    /** Participates in the production veto together with process NODE_ENV. */
+    nodeEnv?: string;
+    sseIntervalMs?: number;
+};
+/** What the inspector reads: snapshot, graph, and optional outbox / workflow monitors. */
+type ArkRunInspectorSource = ArkRunInspectorListenSource;
+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 { type TraceRecord as $, type ArkKernel as A, type EventBus as B, type CreateArkKernelOptions as C, type DependencyGraph as D, type EventContractRegistry as E, type CreateObservabilityReporterOptions as F, type GraphEdge as G, PolicyEngine as H, IntentRegistry as I, type ArkManifest as J, type WorkflowSnapshot as K, type SagaDefinition as L, type MetadataRegistry as M, type CreateWorkflowEngineOptions as N, type ObservabilityReporter as O, type ProjectionRegistry as P, type SagaInstance as Q, type ReadModelStore as R, type SagaContext as S, type WorkflowEngine as T, type ArkConfig as U, type ArkConfigLoadResult as V, type WorkflowStore as W, type DependencyInformationPackage as X, type ArkKernelConfig as Y, type CreateArkKernelFromConfigOptions as Z, type TraceRecordType as _, type AuditStore as a, type ArkRunInspectorSource as a$, type OutboxStatus as a0, type OutboxRecord as a1, type ObservabilityDriftReport as a2, ARK_RUN_COMPONENT_LIFETIMES as a3, ARK_RUN_EPHEMERAL_DEFAULT as a4, ARK_RUN_GRAPH_DEFAULT_SLICE as a5, ARK_RUN_GRAPH_NODE_KINDS as a6, ARK_RUN_GRAPH_PROCESS_EDGE_KINDS as a7, ARK_RUN_GRAPH_SCHEMA_VERSION as a8, ARK_RUN_GRAPH_SLICES as a9, type ArkRunDeliveredVia as aA, type ArkRunExtendedInfo as aB, type ArkRunGraph as aC, type ArkRunGraphEdge as aD, type ArkRunGraphEdgeKind as aE, type ArkRunGraphMatch as aF, type ArkRunGraphMatchInput as aG, type ArkRunGraphNode as aH, type ArkRunGraphNodeKind as aI, type ArkRunGraphProcessEdgeKind as aJ, type ArkRunGraphQuery as aK, type ArkRunGraphResolvedQuery as aL, type ArkRunGraphSlice as aM, type ArkRunGraphTechnicalEdgeKind as aN, type ArkRunInformationPackageComponent as aO, type ArkRunInspectorBind as aP, ArkRunInspectorBindError as aQ, type ArkRunInspectorBindInput as aR, type ArkRunInspectorHandle as aS, type ArkRunInspectorHardening as aT, type ArkRunInspectorHardeningDurability as aU, type ArkRunInspectorMonitorBuildOptions as aV, type ArkRunInspectorOutboxMonitor as aW, type ArkRunInspectorOutboxRecordSummary as aX, ArkRunInspectorProductionError as aY, type ArkRunInspectorSnapshot as aZ, type ArkRunInspectorSnapshotInput as a_, ARK_RUN_GRAPH_TECHNICAL_EDGE_KINDS as aa, ARK_RUN_INFORMATION_PACKAGE_SCHEMA_VERSION as ab, ARK_RUN_INSPECTOR_DEFAULT_HOST as ac, ARK_RUN_INSPECTOR_DEFAULT_PORT as ad, ARK_RUN_INSPECTOR_EVENTS_PATH as ae, ARK_RUN_INSPECTOR_GRAPH_PATH as af, ARK_RUN_INSPECTOR_MONITOR_SAMPLE_LIMIT as ag, ARK_RUN_INSPECTOR_OUTBOX_PATH as ah, ARK_RUN_INSPECTOR_SCHEMA_VERSION as ai, ARK_RUN_INSPECTOR_SNAPSHOT_PATH as aj, ARK_RUN_INSPECTOR_SSE_EVENT as ak, ARK_RUN_INSPECTOR_TRANSPORT_FALLBACK as al, ARK_RUN_INSPECTOR_WORKFLOWS_PATH as am, ARK_RUN_TRANSPORT_KINDS as an, type ArchitectureLayer as ao, type ArchitectureLayerConfig as ap, type ArchitectureRule as aq, type ArkManifestArchitecture as ar, type ArkManifestData as as, type ArkManifestEntityLink as at, type ArkManifestGraph as au, type ArkManifestIntent as av, type ArkManifestPolicy as aw, type ArkManifestProjection as ax, type ArkRunBrokerAdapter as ay, type ArkRunComponentLifetime as az, type AuditRecord as b, formatArkRunInspectorSseEvent as b$, type ArkRunInspectorStoreDurability as b0, type ArkRunInspectorStoreDurabilityKind as b1, type ArkRunInspectorStoreRole as b2, type ArkRunInspectorTransportFacts as b3, type ArkRunInspectorWorkflowSummary as b4, type ArkRunInspectorWorkflowsMonitor as b5, type ArkRunPublisher as b6, type ArkRunRegisterOptions as b7, type ArkRunRegistrationHandle as b8, type ArkRunSendOptions as b9, type OutboxStore as bA, type PolicyEvaluationResult as bB, type ProjectionCheckpoint as bC, type ProjectionDefinition as bD, type PublishedEventRecord as bE, type RetryPolicy as bF, type SagaStatus as bG, type SagaStep as bH, type StartArkRunInspectorOptions as bI, type TraceSink as bJ, type Unsubscribe as bK, type WorkflowDefinition as bL, type WorkflowStatus as bM, type WorkflowStep as bN, appendDecisionTape as bO, arkRunGraphQueryFromSearchParams as bP, arkRunInspectorUrl as bQ, buildArkRunInspectorHardening as bR, buildArkRunInspectorOutboxMonitor as bS, buildArkRunInspectorSnapshot as bT, buildArkRunInspectorWorkflowsMonitor as bU, buildDependencyInformationPackage as bV, classifyArkRunInspectorStoreDurability as bW, closeArkRunGraphQuery as bX, closedArkRunEphemeral as bY, closedArkRunTransportKind as bZ, formatArkRunGraphMermaid as b_, type ArkRunSendPlan as ba, type ArkRunSendPlanInput as bb, type ArkRunSendResult as bc, type ArkRunTransportKind as bd, type AuditRecordInput as be, type AuditRecordType as bf, type CorrelationId as bg, type EntityMeta as bh, type EventContractIssue as bi, type EventHandler as bj, type EventInterceptionInfo as bk, type EventInterceptor as bl, type EventInterceptorContext as bm, type EventMetadata as bn, type EventPayloadPatch as bo, type EventPayloadSchema as bp, type EventPublisher as bq, type EventSchemaField as br, type EventSchemaFieldType as bs, type FieldMeta as bt, type GraphNode as bu, type IntentRelationshipKind as bv, InvalidArkRunGraphQueryError as bw, InvalidArkRunSendOptionError as bx, type ObservabilityFlow as by, type ObservedLayerFlowMode as bz, type AuditQuery as c, isArkRunInspectorLoopbackHost as c0, isArkRunInspectorProductionEnv as c1, requestArkRunGraph as c2, resolveArkRunInspectorBind as c3, resolveArkRunSendPlan as c4, startArkRunInspector as c5, unavailableArkRunInspectorOutboxMonitor as c6, unavailableArkRunInspectorWorkflowsMonitor as c7, type CreateAuditTrailOptions as d, type AuditTrail as e, type CreateArchitectureProfileOptions as f, type ArchitectureProfile as g, type ArkCheckConfig as h, type CreateArchitectureProfileFromArkConfigOptions as i, type CreateElevenLayerArkConfigOptions as j, type EventContract as k, type DomainEvent as l, type EventContractValidationResult as m, type IntentName as n, type DefineIntentOptions as o, type IntentCreator as p, type CreateProjectionRegistryOptions as q, type PolicyViolation as r, type PolicySeverity as s, type PolicyEnforcementMode as t, type Policy as u, type IntentRelationship as v, type EventBufferStore as w, type EventBufferRecord as x, type EventBufferStatus as y, type EventBusOptions as z };