@supernovae-st/nika 0.118.7 → 0.120.2

package/dist/index.d.cts

@@ -1,5 +1,21 @@
 interface NikaSharedConfig {
-    /** Bound for each event subscriber. Default: 256 events. */
+    /**
+     * How many of a run's most recent frames a session retains, and therefore
+     * the most a view opened after the fact can be given, and the largest
+     * `bufferSize` a view may ask for. Default: 4096 frames. For scale, one
+     * measured fixture (a clean native run of 90 independent mock/echo infer
+     * tasks) wrote 273 frames; other shapes write more, so count your own.
+     *
+     * It is a finite bound, never a promise about the run. A run longer than it
+     * still succeeds and `run.result()` still resolves; only a late view is
+     * refused, with `NikaEventBufferOverflowError` whose `reason` is
+     * `replay_truncated` and whose `observed` says what to set. An explicit
+     * value is kept exactly as given. Each frame is bounded by
+     * `machineBufferBytes`, so the retained history holds at most
+     * `eventBufferSize * machineBufferBytes` of frame text per run. That bounds
+     * the history only: frames already handed to a consumer, other views and
+     * other runs are not counted in it.
+     */
     eventBufferSize?: number;
     /** Bound for buffered diagnostics and one machine frame. Default: 64 KiB. */
     machineBufferBytes?: number;
@@ -130,11 +146,38 @@ interface NikaRunSealedEvent extends NikaEventFields {
     kind: 'run_sealed';
     receipt?: NikaReceipt;
 }
+/**
+ * A journal delivery loss the resident reported, exactly as its contract
+ * closes it: the run's journal mirror stopped recording. It is independent of
+ * the execution: a run can settle `succeeded` and still carry it. It is never
+ * a verdict and never changes a status; it says the trace may be incomplete
+ * before `traceVerify` is trusted. Its absence is only absence: it never
+ * claims that a journal exists.
+ *
+ * Engine main, ahead of the contract this package pins: no released engine
+ * writes it yet, and a resident that predates it simply never sends it.
+ */
+interface NikaJournalEvidence {
+    status: 'mirror_lost';
+    /** The mirror's first error, classified: never OS text, never a path. */
+    reason: 'write_failed' | 'record_refused';
+}
+/**
+ * Fields only the resident's frames carry, both from engine main, ahead of the
+ * contract this package pins. Both are optional on the wire and absent on a
+ * resident that predates them.
+ */
+interface NikaResidentEventFields extends NikaEventFields {
+    /** When the resident admitted the event: RFC 3339, UTC. Outside the event's hash chain. */
+    at?: string;
+    /** A reported journal delivery loss, on the terminal frame. */
+    evidence?: NikaJournalEvidence;
+}
 /**
  * The HTTP transport admitted the execution and it is running. This is the
  * first lifecycle frame `nika serve --bind` streams for a durable job.
  */
-interface NikaExecutionStartedEvent extends NikaEventFields {
+interface NikaExecutionStartedEvent extends NikaResidentEventFields {
     kind: 'execution.started';
 }
 /**
@@ -142,7 +185,7 @@ interface NikaExecutionStartedEvent extends NikaEventFields {
  * `run_settled`: the one frame that carries the run's outputs, receipt, and
  * final status together.
  */
-interface NikaExecutionSettledEvent<Outputs extends Record<string, unknown> = Record<string, unknown>> extends NikaEventFields {
+interface NikaExecutionSettledEvent<Outputs extends Record<string, unknown> = Record<string, unknown>> extends NikaResidentEventFields {
     kind: 'execution.settled';
     status?: NikaRunStatus;
     outputs?: Outputs;
@@ -155,19 +198,19 @@ interface NikaExecutionSettledEvent<Outputs extends Record<string, unknown> = Re
  * claimed, or a running one whose owner settled the request as a
  * cancellation. It carries the settlement when the runtime built one.
  */
-interface NikaExecutionCancelledEvent extends NikaEventFields {
+interface NikaExecutionCancelledEvent extends NikaResidentEventFields {
     kind: 'execution.cancelled';
     settlement?: NikaSettlement;
 }
 /** The server refused the execution. */
-interface NikaExecutionRefusedEvent extends NikaEventFields {
+interface NikaExecutionRefusedEvent extends NikaResidentEventFields {
     kind: 'execution.refused';
 }
 /**
  * The execution was interrupted before settling. A resident that restarts
  * marks an orphaned running job with either word, so both are one variant.
  */
-interface NikaExecutionInterruptedEvent extends NikaEventFields {
+interface NikaExecutionInterruptedEvent extends NikaResidentEventFields {
     kind: 'execution.interrupted' | 'interrupted';
 }
 /**
@@ -187,6 +230,69 @@ interface NikaUnknownEvent extends NikaEventFields {
  * shape, so untyped callers see no change.
  */
 type NikaEvent<Outputs extends Record<string, unknown> = Record<string, unknown>> = NikaWorkflowStartedEvent | NikaTaskScheduledEvent | NikaTaskStartedEvent | NikaTaskCompletedEvent | NikaWorkflowCompletedEvent<Outputs> | NikaWorkflowFailedEvent | NikaWorkflowInterruptedEvent | NikaRunSettledEvent<Outputs> | NikaRunSealedEvent | NikaExecutionStartedEvent | NikaExecutionSettledEvent<Outputs> | NikaExecutionCancelledEvent | NikaExecutionRefusedEvent | NikaExecutionInterruptedEvent | NikaUnknownEvent;
+/**
+ * The SDK's one lifecycle vocabulary, identical on both transports. Each word
+ * names a fact an engine wrote; the protocol word that carried it stays on
+ * `raw.kind`. Transports differ in cardinality, never in these names.
+ *
+ * A frame that speaks of the run's state earns its name only for a
+ * (kind, status) pair a producer defines. The engine's state word decides and
+ * is never defaulted: an absent, null, future, or still-running status, or
+ * one that contradicts its kind, stays an `engine.event`.
+ *
+ * - `run.started`: `workflow_started` · `execution.started`.
+ * - `task.scheduled` · `task.started` · `task.completed` · `task.failed`: the
+ *   native `task_*` frames. `nika serve` streams no per-task frame, so an HTTP
+ *   run yields none; the SDK never synthesizes one.
+ * - `run.waiting`: the settlement frame (`run_settled` · `execution.settled`)
+ *   carrying `paused`. A human gate holds the run: it is not failed, not a
+ *   completed execution, and stays resumable.
+ * - `run.settled`: exactly these pairs, and no other. The settlement frame
+ *   (`run_settled` · `execution.settled`) carrying `succeeded`, `failed`, or
+ *   `cancelled`; `execution.cancelled` carrying `cancelled`;
+ *   `execution.refused` carrying `failed`. A dedicated end kind with another
+ *   terminal word (a refusal that `succeeded`, a cancellation that `failed`)
+ *   contradicts itself and stays an `engine.event`.
+ * - `run.interrupted`: `workflow_interrupted` · `execution.interrupted` ·
+ *   `interrupted` carrying `interrupted`. The engine lost the execution and
+ *   its settlement is unknown: an evidence state, never a settlement. This is
+ *   an engine-reported frame, distinct from the thrown
+ *   `NikaObservationInterrupted`, which means this client lost its
+ *   observation of a run that may still be running.
+ * - `run.sealed`: `run_sealed`, native only.
+ * - `engine.event`: every other frame, including kinds this SDK version does
+ *   not know yet. Nothing is dropped; read `raw`.
+ *
+ * The projection keeps no state between frames and deduplicates nothing. The
+ * set is additive: keep a `default` branch.
+ */
+type NikaRunEventKind = 'run.started' | 'task.scheduled' | 'task.started' | 'task.completed' | 'task.failed' | 'run.waiting' | 'run.settled' | 'run.interrupted' | 'run.sealed' | 'engine.event';
+/**
+ * One run event in the SDK's lifecycle vocabulary, as `run.events()` yields
+ * it. It is a projection of exactly one protocol frame: `raw` is that frame,
+ * untouched, and every other field is present only when the frame stated it.
+ * An `engine.event` is given no lifecycle meaning: it carries no `status`,
+ * `task` or `error`, only its cursor and `raw`.
+ */
+interface NikaRunEvent<Outputs extends Record<string, unknown> = Record<string, unknown>> {
+    readonly kind: NikaRunEventKind;
+    /** The transport whose protocol `raw` speaks. */
+    readonly transport: NikaTransportKind;
+    /** The engine's own state word, never renamed: a waiting run reads `paused`. */
+    readonly status?: NikaRunStatus;
+    /**
+     * HTTP only: the SSE sequence of this frame, the cursor to persist for
+     * `attachRun(id, { lastEventId })`. A native process has no durable replay,
+     * so a native event never carries one.
+     */
+    readonly sequence?: number;
+    /** The task a `task.*` frame named. */
+    readonly task?: string;
+    /** The failure the frame named: a failed task, or a failed settlement. */
+    readonly error?: NikaMachineError;
+    /** The exact protocol frame the engine wrote. */
+    readonly raw: NikaEvent<Outputs>;
+}
 /**
  * Engine-issued proof material. The SDK transports it but never constructs,
  * reads a workflow to enrich it, or verifies its claims itself.
@@ -250,7 +356,13 @@ interface NikaSettlement {
     error?: NikaMachineError;
     [key: string]: unknown;
 }
-/** The only terminal value for a run. */
+/**
+ * The engine's result of observing an admitted run, including a paused run.
+ * Admitted workflow failure resolves with `status: 'failed'`; configuration,
+ * transport, protocol, and compatibility errors reject instead. Use
+ * `isNikaRunSucceeded(result)` before treating an observation as success.
+ * Outputs are optional even on success, and status stays forward-compatible.
+ */
 interface NikaRunResult<Outputs extends Record<string, unknown> = Record<string, unknown>> {
     id: NikaRunId;
     status: NikaRunStatus;
@@ -263,11 +375,68 @@ interface NikaRunResult<Outputs extends Record<string, unknown> = Record<string,
     execution_id?: NikaExecutionId;
     /** The settlement's cause, tally and spend (engine 0.118+), when the terminal frame carried them. */
     settlement?: NikaSettlement;
+    /**
+     * HTTP only: the journal delivery loss the resident reported on the terminal
+     * frame or the durable job that settled this run. Copied, never inferred:
+     * absent when the resident reported none, which claims nothing about a
+     * journal. It never changes `status`. A native process reports none.
+     */
+    evidence?: NikaJournalEvidence;
     [key: string]: unknown;
 }
-/** A run identity plus its one terminal settlement. */
+/**
+ * An admitted run and its whole lifecycle. `run()` and `attachRun()` return
+ * one only after admission: a workflow the engine refuses rejects there and
+ * never yields a handle. Every member is bound to the run, so a method may be
+ * extracted (`const { events, result } = run`) and still works.
+ *
+ * The handle owns observation, settlement, status and cancellation, nothing
+ * else: checking, proof, catalogs and authoring stay on `Nika`. It is
+ * process-bound. To continue in another process, persist `id` and the last
+ * `event.sequence` you fully processed, then call
+ * `nika.attachRun(id, { lastEventId })`, the one recovery door.
+ *
+ * `id` is what differs by transport, and the type cannot show it:
+ * - HTTP: the resident's durable job id. This is the identity to store.
+ * - native: an ephemeral correlation id of this SDK process. It appears in no
+ *   journal and cannot be recovered after the process ends; `attachRun`
+ *   refuses it. Resume a native run through the engine's own trace.
+ */
 interface NikaRun<Outputs extends Record<string, unknown> = Record<string, unknown>> {
     readonly id: NikaRunId;
+    /**
+     * A bounded view of the run's events in the SDK's lifecycle vocabulary;
+     * each event keeps its protocol frame on `raw`. Transports differ in how
+     * many facts they emit, never in their names. The iterator throws for a
+     * broken observation (`NikaObservationInterrupted` carries the cursor); an
+     * admitted workflow failure ends it normally and is read from `result()`.
+     */
+    readonly events: (options?: NikaEventsOptions) => AsyncIterable<NikaRunEvent<Outputs>>;
+    /**
+     * The engine's result of observing this run, settled once. One failure law:
+     * - rejects: a transport, protocol, or compatibility fault, or a broken
+     *   observation (`NikaObservationInterrupted`, which carries the cursor).
+     *   None of them says the run failed; it may still be running.
+     * - resolves with `status: 'failed'`: an admitted failure is result data,
+     *   with the engine's `error.code` when the engine named one. `cancelled`
+     *   and the engine-reported `interrupted` resolve the same way.
+     * - resolves with `status: 'paused'`: a human gate holds the run. It is
+     *   neither a failure nor a completed execution.
+     * Read `isNikaRunSucceeded(result)` before treating it as success.
+     */
+    readonly result: () => Promise<NikaRunResult<Outputs>>;
+    /**
+     * The current durable status, without waiting for settlement. Only a
+     * resident owns one: a native run rejects with a typed
+     * `NikaCompatibilityError` instead of inventing a status.
+     */
+    readonly status: () => Promise<NikaRunStatus>;
+    /**
+     * Ask the engine to cancel. Idempotent: every call returns the one request.
+     * Acceptance is not a result; read what the engine recorded from `result()`.
+     */
+    readonly cancel: () => Promise<NikaCancelResult>;
+    /** Compatibility alias of `result()`: the same promise, kept while code migrates. */
     readonly done: Promise<NikaRunResult<Outputs>>;
 }
 interface NikaCancelResult {
@@ -278,9 +447,9 @@ interface NikaCancelResult {
      * `already_settled`: the run had already ended, nothing was cancelled.
      * `cancellation_requested`: the request was accepted while the execution
      * owner had not settled yet (a native SIGTERM, or the resident's 202); the
-     * run then settles on its own terminal, read from `run.done`, which may be
-     * `cancelled`, `succeeded`, `failed`, or `interrupted` once the resident's
-     * grace expired. Open to the engine's future words.
+     * run then settles on its own terminal, read from `run.result()`, which may
+     * be `cancelled`, `succeeded`, `failed`, or `interrupted` once the
+     * resident's grace expired. Open to the engine's future words.
      */
     status: 'cancelled' | 'already_settled' | 'cancellation_requested' | (string & {});
     transport: NikaTransportKind;
@@ -315,10 +484,39 @@ interface NikaCheckOptions {
     signal?: AbortSignal;
 }
 interface NikaRunOptions {
+    /**
+     * Literal values for the workflow's declared `inputs:`, by name, with the
+     * same meaning on both transports. Values are strict JSON and stay literal:
+     * a string is never read as `@env:NAME`, an expression or a number, and
+     * nothing is coerced to the declared type. The engine validates the map
+     * (unknown key, type mismatch, missing required input) and refuses before
+     * any run exists. A value JSON cannot carry (`undefined`, a function, a
+     * symbol, a bigint, a non-finite number, a cycle, a class instance, a
+     * custom prototype, an array hole, an accessor, a Proxy) rejects `run()`
+     * with `NikaConfigurationError` instead of being dropped, and the
+     * serialized map is bounded at 1 MiB. No caller code runs while it is
+     * judged: no getter is invoked, and a Proxy is refused before it is read.
+     *
+     * Needs an engine that advertises the literal channel: `inputsLiteral`
+     * natively (values ride stdin, never argv), `jobInputs` over HTTP by served
+     * name. An engine without it rejects with `NikaCompatibilityError`; the SDK
+     * never falls back to `--var`. An execution snapshot freezes its inputs, so
+     * an HTTP run of a local path refuses `inputs`. Never put a secret here.
+     */
+    inputs?: Record<string, unknown>;
+    /**
+     * @deprecated Use `inputs`. `vars` is the native `--var KEY=VALUE` operator
+     * channel: the engine reads `@env:NAME` from its environment and coerces
+     * text to the declared type, so it cannot carry literal API values and has
+     * no HTTP form. Combining it with `inputs` rejects `run()`.
+     */
     vars?: Record<string, string | number | boolean>;
     model?: string;
     maxCostUsd?: number;
-    /** Retained for HTTP admission deduplication. */
+    /**
+     * Required for HTTP admission; reuse the same key and request after an
+     * uncertain response. Direct native runs reject this option.
+     */
     idempotencyKey?: string;
 }
 /** Resume observation of an already-admitted durable HTTP job. */
@@ -329,7 +527,12 @@ interface NikaAttachRunOptions {
 interface NikaEventsOptions {
     /** Stops this subscriber view. It never cancels the run. */
     signal?: AbortSignal;
-    /** Per-view queue bound, capped by the client eventBufferSize. */
+    /**
+     * Per-view queue bound, capped by the client eventBufferSize, which is also
+     * its default. A live view that falls further behind than this fails with
+     * `reason: 'live_backpressure'`; a view opened after more frames than this
+     * is refused with `reason: 'replay_truncated'`. Neither skips a frame.
+     */
     bufferSize?: number;
 }
 interface NikaTraceVerifyOptions {
@@ -344,8 +547,29 @@ interface NikaScheduleFinding {
     detail: string;
     [key: string]: unknown;
 }
-/** Findings carried by the one operation-error taxonomy. */
-type NikaOperationFinding = NikaScheduleFinding;
+/**
+ * One engine-owned check finding, exactly as the engine's check report
+ * carries it. `code` is absent when the engine's failure class names none (an
+ * unreadable workflow file); the SDK never supplies one. The vocabulary
+ * remains additive.
+ */
+interface NikaCheckFinding {
+    code?: string;
+    message?: string;
+    severity?: string;
+    gate?: string;
+    kind?: string;
+    /** The task the finding judges, when it judges one. */
+    task?: string;
+    docs_url?: string;
+    [key: string]: unknown;
+}
+/**
+ * Findings carried by the one operation-error taxonomy: a schedule refusal
+ * carries schedule findings (`detail`), a refused `run()` carries the check
+ * findings that refused it (`message`).
+ */
+type NikaOperationFinding = NikaScheduleFinding | NikaCheckFinding;
 type NikaScheduleWhen = {
     kind: 'once';
     at: string;
@@ -497,6 +721,10 @@ declare class NikaProtocolError extends NikaTransportError {
 /**
  * Observation broke before terminal settlement and the final durable read
  * stayed non-terminal. The cursor feeds attachRun(id, { lastEventId }).
+ *
+ * This is about the client's view, never about the run: the run may still be
+ * running on the resident. It is not the engine's own `interrupted` state,
+ * which arrives as a `run.interrupted` event and as `result.status`.
  */
 declare class NikaObservationInterrupted extends NikaTransportError {
     readonly runId: string;
@@ -520,10 +748,36 @@ declare class NikaOperationError extends NikaError {
         machineCode?: string;
     });
 }
+/**
+ * An event view would have had to skip frames, so it refused instead. The SDK
+ * never silently omits a frame. Two different bounds can be exceeded, and
+ * `reason` says which. Neither is about the run: it keeps running or stays
+ * settled, and `run.result()` is unaffected.
+ *
+ * - `live_backpressure`: a view that was observing live fell more than
+ *   `limit` frames behind the stream. Read faster, or give it a larger
+ *   `bufferSize`. Other views are unaffected.
+ * - `replay_truncated`: a view was opened after the run had already produced
+ *   more frames than it can be given. `observed` is how many the session saw
+ *   and `retained` how many it still holds. When `retained === observed`
+ *   nothing is lost and a view with `bufferSize >= observed` replays them
+ *   all; when `retained < observed` the earlier frames are gone from this
+ *   process, so raise `eventBufferSize` to at least `observed` for the next
+ *   run, or observe it live.
+ */
 declare class NikaEventBufferOverflowError extends NikaError {
     readonly runId: string;
+    /** The bound that was exceeded: the view's `bufferSize`. */
     readonly limit: number;
-    constructor(runId: string, limit: number);
+    readonly reason: 'live_backpressure' | 'replay_truncated';
+    /** `replay_truncated` only: frames the session had observed when it refused. */
+    readonly observed?: number;
+    /** `replay_truncated` only: frames the session still held when it refused. */
+    readonly retained?: number;
+    constructor(runId: string, limit: number, replay?: {
+        observed: number;
+        retained: number;
+    });
 }
 declare class NikaRunOwnershipError extends NikaError {
     constructor();
@@ -538,6 +792,16 @@ declare class NikaEngineUnavailable extends NikaError {
     constructor(platform: string, arch: string, packageName?: string);
 }
 
+/**
+ * Narrows a result to the engine's successful settlement. Admitted failures
+ * resolve as result data; awaiting a run alone does not establish success.
+ * Paused, cancelled, interrupted, failed, and unknown statuses return false.
+ * Outputs remain optional: a successful workflow need not declare any.
+ */
+declare function isNikaRunSucceeded<Outputs extends Record<string, unknown> = Record<string, unknown>>(result: NikaRunResult<Outputs>): result is NikaRunResult<Outputs> & {
+    status: 'succeeded';
+};
+
 /**
  * Narrows any run event to the terminal settlement frame, which carries the
  * run's status, outputs, and receipt together. Both transports have one: the
@@ -570,24 +834,56 @@ declare class Nika {
     constructor(config?: NikaConfig);
     check(workflow: string, options?: NikaCheckOptions): Promise<NikaCheckResult>;
     /**
+     * Resolves with the run's handle once the engine admitted it, and rejects
+     * without one when the engine refused it. The handle owns the lifecycle:
+     * `run.events()`, `run.result()`, `run.status()`, `run.cancel()`.
+     *
      * `Outputs` is the caller's projection of the engine-emitted outputs map;
      * the SDK transports outputs without validating their shape.
      */
     run<Outputs extends Record<string, unknown> = Record<string, unknown>>(workflow: string, options?: NikaRunOptions): Promise<NikaRun<Outputs>>;
-    /** Reattach this client process to an already-admitted durable HTTP job. */
+    /**
+     * The one recovery door: reattach this client process to an
+     * already-admitted durable HTTP job and get a full `NikaRun` back. Pass the
+     * last `event.sequence` you fully processed as `lastEventId`. A native
+     * process is process-bound and refuses with a typed compatibility error.
+     */
     attachRun<Outputs extends Record<string, unknown> = Record<string, unknown>>(id: string, options?: NikaAttachRunOptions): Promise<NikaRun<Outputs>>;
     /** List contained workflow names from a resident HTTP authority. */
     listWorkflows(): Promise<readonly string[]>;
     /** Read path-free metadata for one contained workflow. */
     workflow(name: string): Promise<NikaWorkflowMetadata>;
+    /**
+     * The run's events in the protocol vocabulary of its transport
+     * (`workflow_*` · `task_*` · `run_*` natively, `execution.*` over HTTP).
+     *
+     * @deprecated Use `run.events()`: one lifecycle vocabulary on both
+     * transports, with this same frame kept on `event.raw`. This wrapper is a
+     * compatibility door for one release train, counted from publication: it
+     * ships unchanged in the first published train that carries `run.events()`,
+     * and the earliest train that may remove it is the one after, as announced
+     * in that train's release notes. It accepts only a run this client created.
+     */
     events<Outputs extends Record<string, unknown> = Record<string, unknown>>(run: NikaRun<Outputs>, options?: NikaEventsOptions): AsyncIterable<NikaEvent<Outputs>>;
+    /**
+     * @deprecated Use `run.cancel()`; both return the one memoized request.
+     * Kept through the same compatibility window as `events(run)`. It accepts
+     * only a run this client created.
+     */
     cancel(run: NikaRun): Promise<NikaCancelResult>;
-    /** Read the current durable status without waiting for terminal settlement. */
+    /**
+     * Read the current durable status without waiting for terminal settlement.
+     *
+     * @deprecated Use `run.status()`. Kept through the same compatibility
+     * window as `events(run)`. It accepts only a run this client created.
+     */
     status(run: NikaRun): Promise<NikaRunStatus>;
     schedule(workflow: string, options: NikaScheduleOptions): Promise<NikaScheduleApplyResult>;
     scheduleStatus(id: string): Promise<NikaScheduleStatus>;
     traceVerify(receipt: NikaReceipt, options?: NikaTraceVerifyOptions): Promise<NikaTraceVerifyResult>;
+    /** One session per admitted run, owned by this client and by no registry. */
+    private own;
     private session;
 }
 
-export { Nika, type NikaAttachRunOptions, type NikaCancelResult, type NikaCheckOptions, type NikaCheckResult, NikaCompatibilityError, type NikaConfig, NikaConfigurationError, type NikaCostQualifier, NikaEngineUnavailable, NikaError, type NikaEvent, NikaEventBufferOverflowError, type NikaEventsOptions, type NikaExecutionCancelledEvent, type NikaExecutionId, type NikaExecutionInterruptedEvent, type NikaExecutionRefusedEvent, type NikaExecutionSettledEvent, type NikaExecutionStartedEvent, type NikaJobId, type NikaLocalConfig, type NikaMachineError, NikaObservationInterrupted, type NikaOperation, NikaOperationError, type NikaOperationFinding, NikaProtocolError, type NikaReceipt, type NikaRemoteConfig, type NikaRun, type NikaRunCause, type NikaRunId, type NikaRunOptions, NikaRunOwnershipError, type NikaRunResult, type NikaRunSealedEvent, type NikaRunSettledEvent, type NikaRunStatus, type NikaScheduleAfterSkip, type NikaScheduleApplyResult, type NikaScheduleClaim, type NikaScheduleDefinition, type NikaScheduleDue, type NikaScheduleFinding, type NikaScheduleLastDecision, type NikaScheduleMissed, type NikaScheduleOptions, type NikaScheduleOverlap, type NikaSchedulePause, type NikaScheduleSlot, type NikaScheduleStatus, type NikaScheduleWhen, type NikaSettlement, type NikaSpend, type NikaTaskCompletedEvent, type NikaTaskScheduledEvent, type NikaTaskStartedEvent, type NikaTaskTally, type NikaTraceVerifyOptions, type NikaTraceVerifyResult, NikaTransportError, type NikaTransportKind, type NikaUnknownEvent, type NikaWorkflowCompletedEvent, type NikaWorkflowFailedEvent, type NikaWorkflowInterruptedEvent, type NikaWorkflowMetadata, type NikaWorkflowStartedEvent, isNikaRunSealedEvent, isNikaRunSettledEvent, isNikaTerminalEvent };
+export { Nika, type NikaAttachRunOptions, type NikaCancelResult, type NikaCheckFinding, type NikaCheckOptions, type NikaCheckResult, NikaCompatibilityError, type NikaConfig, NikaConfigurationError, type NikaCostQualifier, NikaEngineUnavailable, NikaError, type NikaEvent, NikaEventBufferOverflowError, type NikaEventsOptions, type NikaExecutionCancelledEvent, type NikaExecutionId, type NikaExecutionInterruptedEvent, type NikaExecutionRefusedEvent, type NikaExecutionSettledEvent, type NikaExecutionStartedEvent, type NikaJobId, type NikaJournalEvidence, type NikaLocalConfig, type NikaMachineError, NikaObservationInterrupted, type NikaOperation, NikaOperationError, type NikaOperationFinding, NikaProtocolError, type NikaReceipt, type NikaRemoteConfig, type NikaRun, type NikaRunCause, type NikaRunEvent, type NikaRunEventKind, type NikaRunId, type NikaRunOptions, NikaRunOwnershipError, type NikaRunResult, type NikaRunSealedEvent, type NikaRunSettledEvent, type NikaRunStatus, type NikaScheduleAfterSkip, type NikaScheduleApplyResult, type NikaScheduleClaim, type NikaScheduleDefinition, type NikaScheduleDue, type NikaScheduleFinding, type NikaScheduleLastDecision, type NikaScheduleMissed, type NikaScheduleOptions, type NikaScheduleOverlap, type NikaSchedulePause, type NikaScheduleSlot, type NikaScheduleStatus, type NikaScheduleWhen, type NikaSettlement, type NikaSpend, type NikaTaskCompletedEvent, type NikaTaskScheduledEvent, type NikaTaskStartedEvent, type NikaTaskTally, type NikaTraceVerifyOptions, type NikaTraceVerifyResult, NikaTransportError, type NikaTransportKind, type NikaUnknownEvent, type NikaWorkflowCompletedEvent, type NikaWorkflowFailedEvent, type NikaWorkflowInterruptedEvent, type NikaWorkflowMetadata, type NikaWorkflowStartedEvent, isNikaRunSealedEvent, isNikaRunSettledEvent, isNikaRunSucceeded, isNikaTerminalEvent };