@devicerail/recorder 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+export type RecorderErrorCode = "action_call_reused" | "action_correlation_mismatch" | "action_in_flight" | "action_not_started" | "action_result_mismatch" | "bundle_cli_failed" | "bundle_summary_invalid" | "bundle_summary_mismatch" | "checkpoint_conflict" | "checkpoint_corrupt" | "checkpoint_durability_unknown" | "checkpoint_locked" | "duplicate_event_id" | "event_too_large" | "invalid_event" | "invalid_lifecycle" | "operation_cancelled" | "out_of_order" | "sequence_conflict" | "sequence_gap" | "session_export_mismatch" | "session_mismatch" | "session_not_ended" | "source_conflict" | "source_corrupt" | "source_durability_unknown" | "source_too_large" | "terminal_append" | "upstream_unavailable";
+export interface RecorderErrorOptions extends ErrorOptions {
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+export declare class RecorderError extends Error {
+    readonly code: RecorderErrorCode;
+    readonly details: Readonly<Record<string, unknown>> | undefined;
+    constructor(code: RecorderErrorCode, message: string, options?: RecorderErrorOptions);
+}

package/dist/errors.js

@@ -0,0 +1,10 @@
+export class RecorderError extends Error {
+    code;
+    details;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.name = "RecorderError";
+        this.code = code;
+        this.details = options.details;
+    }
+}

package/dist/event-log.d.ts

@@ -0,0 +1,71 @@
+import type { ProtocolVersion, TestEvent } from "@devicerail/protocol";
+import type { EventAcceptance, EventBatchResult, EventLogSnapshot } from "./types.js";
+declare const PREPARED_STATE: unique symbol;
+declare const ABSENT: unique symbol;
+type CorrelationValue = string | number | null | typeof ABSENT;
+interface OpenAction {
+    readonly deviceId: CorrelationValue;
+    readonly requestId: CorrelationValue;
+}
+interface OpenMediaStream {
+    readonly mediaType: string;
+    readonly nextFrameIndex: number;
+}
+interface MutableLogState {
+    readonly owner: object;
+    eventCount: number;
+    readonly appendedEvents: TestEvent[];
+    readonly eventIds: OverlaySet;
+    openActions: Map<string, OpenAction>;
+    openMediaStreams: Map<string, OpenMediaStream>;
+    readonly seenCallIds: OverlaySet;
+    readonly seenMediaStreamIds: OverlaySet;
+    terminal: boolean;
+}
+declare class OverlaySet {
+    #private;
+    readonly added: Set<string>;
+    constructor(base: ReadonlySet<string>);
+    has(value: string): boolean;
+    add(value: string): void;
+}
+/** Opaque, generation-bound result of validating one delivery batch. */
+export interface PreparedEventBatch {
+    readonly baseGeneration: number;
+    readonly acceptedEvents: readonly TestEvent[];
+    readonly result: EventBatchResult;
+    readonly [PREPARED_STATE]: MutableLogState;
+}
+/** Runtime-validates and takes an immutable snapshot of one untrusted event. */
+export declare function validateTestEvent(value: unknown, location?: string, protocol?: ProtocolVersion): TestEvent;
+/** Sequence-authoritative, transport-neutral Session event accumulator. */
+export declare class EventLog {
+    #private;
+    constructor(sessionId: string, eventProtocolVersion?: ProtocolVersion);
+    /** Strictly reconstructs a canonical checkpoint log. */
+    static replay(sessionId: string, events: readonly unknown[], eventProtocolVersion?: ProtocolVersion): EventLog;
+    get sessionId(): string;
+    get events(): readonly TestEvent[];
+    get lastSequence(): number | null;
+    get nextSequence(): number;
+    get terminal(): boolean;
+    get openActionCount(): number;
+    /**
+     * Creates an isolated speculative branch. Immutable event chunks are shared;
+     * identity indexes are copied because subsequent writes to either branch must
+     * remain independent. The Recorder hot path uses `prepareBatch` instead.
+     */
+    fork(): EventLog;
+    accept(value: unknown): EventAcceptance;
+    /** Validate a batch without copying or mutating the confirmed event prefix. */
+    prepareBatch(values: readonly unknown[]): PreparedEventBatch;
+    /** Commit a previously validated batch without replaying its durable prefix. */
+    commitPreparedBatch(prepared: PreparedEventBatch): EventBatchResult;
+    /**
+     * Accepts one delivery batch atomically. Any malformed event or state-machine
+     * failure leaves the prior log unchanged.
+     */
+    acceptBatch(values: readonly unknown[]): EventBatchResult;
+    snapshot(): EventLogSnapshot;
+}
+export {};