@deepseek-ai/dsh-session-persistence-jsonl 0.0.1-rc.1

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-session-persistence-jsonl`.
+* @module @deepseek-ai/dsh-session-persistence-jsonl/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-session-persistence-jsonl";
+/** Cordis companion plugin name. */
+const name = "session-persistence-jsonl-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: persistence correctness requires backend round-trip and crash-tail tests;
+* this package exposes no continuously observable in-process relation.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/format.d.ts

@@ -0,0 +1,175 @@
+/**
+ * On-disk format helpers for the JSONL session-persistence backend: path
+ * sanitization (a {@link SessionId} is an unvalidated branded string, so it
+ * MUST be encoded before use in a path — no traversal, no collision), the
+ * per-project/session directory layout, header-line (de)serialization, and the
+ * truncation-repair offset computation.
+ *
+ * @module dsh-session-persistence-jsonl/format
+ */
+import type { SessionEvent, SessionHeader, SessionId } from '@deepseek-ai/dsh-session';
+/** Physical encoding selected for JSONL session artifacts. */
+export type JsonlCompression = 'zstd' | 'none';
+/**
+ * Return the artifact suffix for one physical encoding.
+ * @param compression - configured JSONL artifact encoding.
+ * @returns `.jsonl.zstd` for Zstandard or `.jsonl` for plaintext.
+ */
+export declare function logSuffix(compression: JsonlCompression): '.jsonl.zstd' | '.jsonl';
+/**
+ * The first JSONL record of a session artifact: the immutable
+ * {@link SessionHeader} tagged as a `session` record so a reader can tell it
+ * apart from an event line.
+ */
+export interface HeaderLine {
+    type: 'session';
+    version: number;
+    id: SessionId;
+    createdAt: number;
+    cwd?: string;
+    parentSession?: SessionId;
+    seedLength?: number;
+    origin?: 'subagent';
+    delegationDepth: number;
+    agentPreset?: string;
+}
+/**
+ * Build the header line object from a {@link SessionHeader}.
+ * @param header - the immutable session metadata to serialize.
+ * @returns the `type: 'session'`-tagged line object, absent optional fields omitted (never null).
+ */
+export declare function toHeaderLine(header: SessionHeader): HeaderLine;
+/**
+ * Parse a header line back into a {@link SessionHeader}.
+ * @param line - the shape-checked first line of a log (see the `isHeaderLine` guard).
+ * @returns the header, absent optional fields omitted.
+ */
+export declare function fromHeaderLine(line: HeaderLine): SessionHeader;
+/**
+ * Encode an arbitrary string as a single safe path segment, injectively over ALL JS (UTF-16)
+ * strings — including lone surrogates. A {@link SessionId} is an unvalidated branded string,
+ * so this neutralizes `../`, absolute paths, NUL, and separators before any filesystem use.
+ * Safe code units remain literal; every other unit, including `~`, becomes
+ * `~XXXX`. Operating on code units preserves lone surrogates, while special-
+ * casing `.` and `..` prevents traversal by an otherwise safe whole segment.
+ *
+ * @param raw - the string to encode; must be non-empty (throws on `''`).
+ * @returns the escaped single path segment, decodable back to `raw`.
+ */
+export declare function encodeSegment(raw: string): string;
+/**
+ * Build the readable directory key for a project path.
+ * Filesystem separators and drive separators become `-`; unsafe code units use
+ * the same `~XXXX` escape as session ids. The key is bounded for filesystem
+ * component limits. Separator replacement and truncation are intentionally
+ * lossy, following the common human-navigable project-directory convention.
+ * @param cwd - the session's project directory.
+ * @returns a single filesystem-safe project directory name.
+ */
+export declare function projectKey(cwd: string): string;
+/**
+ * The configured root's human-navigable project directory. A configured root
+ * may be local or shared; this grouping does not prescribe its deployment.
+ * @param root - the backend's session root directory.
+ * @param cwd - the session's project directory; `undefined` selects `_no-cwd`.
+ * @returns the project directory path under `root`.
+ */
+export declare function projectDir(root: string, cwd: string | undefined): string;
+/**
+ * The directory owned by one session and available for future session-local
+ * artifacts.
+ * @param root - the backend's session root directory.
+ * @param cwd - the session's project directory.
+ * @param id - the session id, encoded to one safe path segment.
+ * @returns the session directory beneath its project directory.
+ */
+export declare function sessionDir(root: string, cwd: string | undefined, id: SessionId): string;
+/**
+ * The append-only event-log file path for a session.
+ * @param root - the backend's session root directory.
+ * @param cwd - the session's project directory (`undefined` → `_no-cwd`).
+ * @param id - the session id, path-encoded via {@link encodeSegment} before filesystem use.
+ * @param compression - physical artifact encoding and filename suffix.
+ * @returns the session's configured JSONL artifact path.
+ */
+export declare function logPath(root: string, cwd: string | undefined, id: SessionId, compression: JsonlCompression): string;
+/**
+ * Serialize an event batch as JSONL lines (no trailing newline). With
+ * `packChunks` on, delta-chunk runs pack into `text-chunks` /
+ * `reasoning-chunks` / `tool-call-chunks` storage rows; off writes one event
+ * per line, byte-identical to the pre-packing layout. Reading is layout-blind
+ * either way ({@link scanLog} always decodes rows), so the switch changes only
+ * newly written bytes.
+ * @param events - the batch to serialize, in log order.
+ * @param packChunks - whether to pack delta runs into storage rows.
+ * @returns the batch's JSONL text; the writer adds the final newline.
+ */
+export declare function eventLines(events: readonly SessionEvent[], packChunks: boolean): string;
+interface SessionLogScan {
+    meta: SessionHeader;
+    events: SessionEvent[];
+    committedBytes: number;
+}
+/**
+ * Incrementally scan complete JSONL event records after an independently
+ * supplied header record. Newline search and byte offsets stay on raw buffers;
+ * only complete records are decoded to UTF-8. A fragment crossing writes is
+ * copied because a decoder may reuse its output buffer after `write()` returns.
+ */
+export declare class SessionLogScanner {
+    private readonly meta;
+    private readonly events;
+    private fragments;
+    private fragmentBytes;
+    private inputBytes;
+    private committedBytes;
+    private eventLine;
+    private issue;
+    private finished;
+    /**
+     * Create an event scanner from exactly one newline-terminated header record.
+     * @param headerRecord - the complete first JSONL record, including its newline.
+     */
+    constructor(headerRecord: Buffer);
+    /**
+     * Consume the next raw plaintext chunk, retaining only an incomplete final record.
+     * @param chunk - bytes immediately following all previously supplied bytes.
+     */
+    write(chunk: Buffer): void;
+    /**
+     * Snapshot progress before appending a recoverable torn-frame prefix.
+     * @returns byte, committed-prefix, and expanded-event cursors.
+     */
+    checkpoint(): {
+        inputBytes: number;
+        committedBytes: number;
+        eventCount: number;
+    };
+    /**
+     * Finish scanning, ignoring a final record without a newline as a torn tail.
+     * @returns the header, contiguous event prefix, and safe truncation offset.
+     */
+    finish(): SessionLogScan;
+    /** Decode one complete event row and update the contiguous prefix. */
+    private consumeEventLine;
+}
+/**
+ * Parse a complete or torn JSONL buffer into its preserved event prefix. This
+ * compatibility wrapper supplies the first record separately, then delegates
+ * event rows to {@link SessionLogScanner}.
+ *
+ * @param buffer - the raw bytes of the log file (header line first).
+ * @returns the header, preserved event prefix, and byte offset safe to append at.
+ */
+export declare function scanLog(buffer: Buffer): SessionLogScan;
+/**
+ * Parse just the header line of a log into a {@link SessionHeader}, or
+ * `undefined` if it is missing/not a header. Used by `list()` to read session
+ * metadata WITHOUT parsing the whole log: a session picker scales with the
+ * number of sessions, not the total size of every conversation.
+ * @param firstLine - the first line of a log file (without its trailing newline).
+ * @returns the parsed header, or `undefined` when the line is not a well-formed session header.
+ */
+export declare function parseHeaderMeta(firstLine: string): SessionHeader | undefined;
+export {};
+//# sourceMappingURL=format.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,163 @@
+/**
+ * JSONL durable session-persistence backend. It stores a header and contiguous
+ * events in one append-only file per session, and delegates orchestration to
+ * {@link PersistenceCoordinator}. Its side-effect-free locator returns the
+ * absolute per-session log target before materialization.
+ * @module @deepseek-ai/dsh-session-persistence-jsonl
+ */
+import { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { SessionPersistence, type PersistenceBackend, type SessionLocation, type SessionPersistenceSnapshot, type SessionInspection, type SessionPersistenceRevision as PersistenceRevision, type StoredPrefix } from '@deepseek-ai/dsh-session-persistence';
+import type { SessionEvent, SessionId, SessionHeader, SessionPreparation } from '@deepseek-ai/dsh-session';
+import { type JsonlCompression } from './format.ts';
+export type { JsonlCompression } from './format.ts';
+/** Loader schema for the JSONL artifact's physical encoding. */
+export declare const JsonlCompressionSchema: z<JsonlCompression>;
+/** Plugin config: where the JSONL backend keeps its session logs, and the packed-row write switch. */
+export interface Config {
+    /**
+     * Root directory for all session files. Required (no default): a default of
+     * `process.cwd()` would scatter session files as the process's cwd changes
+     * (bash calls, subprocesses). Sessions group under human-readable project
+     * directories, then per-session directories. An existing root must be a
+     * readable directory; an absent root is created on first materialization.
+     */
+    root: string;
+    /**
+     * Write runs of consecutive `assistant/chunk` delta events as packed
+     * `text-chunks`/`reasoning-chunks`/`tool-call-chunks` rows (lossless,
+     * ~60% smaller logs measured on a real session). Defaults to true; false
+     * keeps one `SessionEvent` per line for diagnostics. Reading packed rows is
+     * unconditional: a log's layout never depends on this switch.
+     */
+    packChunks?: boolean;
+    /** Physical encoding; defaults to checksummed Zstandard frames. */
+    compression?: JsonlCompression;
+    /** Maximum cold Session preparations retained for history-to-resume reuse. */
+    preparedSessionCacheSize?: number;
+    /** Fixed live-event coalescing window; not a backend completion deadline. */
+    writeBatchMaxDelayMs?: number;
+}
+/** Opaque coordinator token for replacing bytes recovered from a torn frame. */
+interface JsonlTornMarker {
+    truncateTo: number;
+    recoveredEvents: SessionEvent[];
+}
+/**
+ * The JSONL persistence backend. Load as a plugin; it registers as
+ * `ctx.sessionPersistence` and (via the coordinator) installs the write-path
+ * listeners. Its torn-tail marker carries the byte offset and any events
+ * recovered from an incomplete final Zstandard frame.
+ */
+export declare class SessionPersistenceJsonl extends SessionPersistence implements PersistenceBackend<JsonlTornMarker> {
+    config: Config;
+    static inject: string[];
+    static Config: z<Config>;
+    /**
+     * Backend label for coordinator diagnostics and effects. It shadows
+     * `Service.name` without changing the service key captured by the base
+     * constructor.
+     */
+    readonly name = "session-persistence-jsonl";
+    private root;
+    private packChunks;
+    private compression;
+    private coordinator;
+    private rootEncodingCheck;
+    constructor(ctx: Context, config: Config);
+    /** Resolve the absolute target path without touching the filesystem. */
+    locate(meta: SessionHeader): SessionLocation;
+    create(meta: SessionHeader): Promise<void>;
+    append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
+    prepare(id: SessionId, signal?: AbortSignal): Promise<SessionPreparation>;
+    load(id: SessionId): Promise<SessionInspection>;
+    inspect(id: SessionId, signal?: AbortSignal): Promise<SessionInspection>;
+    readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
+        meta: SessionHeader;
+        events: SessionEvent[];
+    }>;
+    /** Read a stored prefix by id across all project directories when cwd is unknown. */
+    loadStored(id: SessionId, signal?: AbortSignal): Promise<StoredPrefix<JsonlTornMarker> | undefined>;
+    /**
+     * Read one log's stat-derived revision without loading its event bytes.
+     * Resolving an id with unknown cwd still scans the project directories.
+     */
+    readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<PersistenceRevision | undefined>;
+    /**
+     * Read a stored prefix and convert torn-tail state to the opaque marker the
+     * coordinator can round-trip without knowing the physical encoding.
+     */
+    private readPrefix;
+    /** Decode complete frames and retain complete JSONL records from a torn final frame. */
+    private readZstdPrefix;
+    /** Durably append a batch, lazily materializing the file when not yet present. */
+    appendBatch(meta: SessionHeader, events: readonly SessionEvent[], isMaterialized: boolean): Promise<void>;
+    /**
+     * Make a crash repair durable: truncate a torn tail, restore complete events
+     * decoded from it, then append synthetic closers. Two fsync'd steps — the seam
+     * does not require this to be atomic.
+     */
+    commitRepair(meta: SessionHeader, tornMarker: JsonlTornMarker | undefined, closers: readonly SessionEvent[]): Promise<void>;
+    /** List valid unique stored sessions' metadata (header line only — no full-log parse). */
+    list(signal?: AbortSignal): Promise<SessionHeader[]>;
+    /** List metadata plus a stat-derived identity for each append-only log. */
+    listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
+    private listArtifacts;
+    /** Atomically write the header line + first batch (temp-write, fsync, publish). */
+    private materialize;
+    private materializePosix;
+    private materializeWin32;
+    private rejectExistingLog;
+    private writeSyncedTempFile;
+    /** Encode the header and first batch without combining their frame boundaries. */
+    private encodeMaterialization;
+    /** Encode one durable append batch in the configured physical representation. */
+    private encodeEventBatch;
+    /** fsync a POSIX directory so a just-created/renamed entry is crash-durable. */
+    private syncDirPosix;
+    /**
+     * Append and fsync event lines. On a partial write or sync failure, restore the
+     * previous size before rethrowing because the unchanged cursor will retry the
+     * batch; leaving partial bytes would create duplicate sequence numbers.
+     */
+    private appendLines;
+    private rollbackAppend;
+    /** Truncate the log file to `offset` bytes and fsync (discard the crash tail). */
+    private repair;
+    /**
+     * Read the first newline-terminated line of a file without loading the whole
+     * file. Returns undefined if the file is empty or has no complete first line.
+     * Reads in bounded chunks so a huge log costs only the header read.
+     */
+    private readFirstLine;
+    /** Read and validate only the independently compressed header frame. */
+    private readFirstZstdLine;
+    /** Find the unique physical log for an id across every project directory. */
+    private findLog;
+    /** Require an existing configured root to be a readable directory. */
+    private assertUsableRoot;
+    /** Reject metadata that does not identify the selected physical log. */
+    private assertStoredIdentity;
+    /**
+     * Whether two path spellings resolve to the same physical file. This admits
+     * case aliases on case-insensitive filesystems without weakening identity
+     * checks on case-sensitive stores.
+     */
+    private sameFile;
+    /** The human-readable project directories under the configured root. */
+    private listProjectDirs;
+    /** List session-owned directories and reject the obsolete flat-file layout. */
+    private listSessionDirs;
+    /** Reject a root that already belongs to the other physical encoding. */
+    private ensureRootEncoding;
+    private checkRootEncoding;
+    private rejectLegacyFlatArtifact;
+    private rejectOppositeArtifact;
+    private oppositeCompression;
+    private encodingMismatch;
+    private legacyLayout;
+    private exists;
+    private assertLogParentAllowsAbsence;
+}
+export default SessionPersistenceJsonl;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-session-persistence-jsonl`.
+ * @module @deepseek-ai/dsh-session-persistence-jsonl/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "session-persistence-jsonl-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/win32.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Windows durable namespace helpers for the JSONL backend.
+ *
+ * POSIX publishes a newly-created log by creating a directory entry and then
+ * fsyncing the parent directory. Windows does not expose that parent-directory
+ * fsync contract through Node, so the Windows path uses the native durable
+ * namespace primitive instead: create a staging object in the target directory
+ * and publish it with `MoveFileExW(..., MOVEFILE_WRITE_THROUGH)` without
+ * replacement or cross-volume copy fallback.
+ *
+ * @module dsh-session-persistence-jsonl/win32
+ */
+/**
+ * Publish `existing` at `replacement` with Windows write-through rename
+ * semantics. The destination must not already exist; the move must stay within
+ * the volume (no copy fallback flag is set).
+ * @param existing - the synced staging path to move.
+ * @param replacement - the final path, which must not already exist.
+ */
+export declare function publishNewFileWin32(existing: string, replacement: string): Promise<void>;
+/**
+ * Create `target` and its missing ancestors with durable Windows namespace
+ * publication. Each missing directory is first created as a random staging
+ * sibling, then moved to its final name with `MOVEFILE_WRITE_THROUGH`; races
+ * with another creator are accepted only after verifying the winner is a
+ * directory.
+ * @param target - the absolute directory path to create durably when absent.
+ */
+export declare function ensureDurableDirectoryWin32(target: string): Promise<void>;
+//# sourceMappingURL=win32.d.ts.map

package/lib/types/zstd-private-decoder.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Node-private synchronous Zstandard frame decoder optimization.
+ * @module dsh-session-persistence-jsonl/zstd-private-decoder
+ */
+import type { ZstdFrameDecoder, ZstdFrameRange } from './zstd.ts';
+/**
+ * Synchronous multi-frame decoder backed by one Node Zstd stream handle. Node
+ * exposes synchronous decoding only as a one-shot API, so this adapter uses
+ * the stream's private handle contract to reuse its native context and output
+ * chunks across frames.
+ */
+export declare class NodePrivateZstdFrameDecoder implements ZstdFrameDecoder {
+    private readonly stream;
+    private readonly errorKey;
+    private readonly output;
+    private decoderError?;
+    private started;
+    private closed;
+    private constructor();
+    /**
+     * Create the optimized decoder when this Node release exposes the expected
+     * private stream shape.
+     * @returns a shared decoder, or `undefined` when callers must use the public fallback.
+     */
+    static create(): NodePrivateZstdFrameDecoder | undefined;
+    /** @inheritdoc */
+    decode(source: Buffer, frames: readonly ZstdFrameRange[]): Generator<Buffer, void, void>;
+    /** Decode one frame; its returned scratch view remains valid until the next call. */
+    private decodeFrame;
+    /** @inheritdoc */
+    close(): void;
+}
+//# sourceMappingURL=zstd-private-decoder.d.ts.map

package/lib/types/zstd-public-decoder.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Public-API synchronous Zstandard frame decoder fallback.
+ * @module dsh-session-persistence-jsonl/zstd-public-decoder
+ */
+import type { ZstdFrameDecoder, ZstdFrameRange } from './zstd.ts';
+/** Multi-frame adapter built exclusively from Node's supported one-shot API. */
+export declare class PublicZstdFrameDecoder implements ZstdFrameDecoder {
+    private started;
+    private closed;
+    /** @inheritdoc */
+    decode(source: Buffer, frames: readonly ZstdFrameRange[]): Generator<Buffer, void, void>;
+    /** @inheritdoc */
+    close(): void;
+}
+//# sourceMappingURL=zstd-public-decoder.d.ts.map

package/lib/types/zstd.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Zstandard frame primitives for the JSONL persistence backend. The backend
+ * owns a concatenated-frame container so it can append and recover batches
+ * without exposing compression mechanics through the persistence seam.
+ * @module dsh-session-persistence-jsonl/zstd
+ */
+/** Byte range occupied by one structurally complete Zstandard frame. */
+export interface ZstdFrameRange {
+    /** Inclusive frame start. */
+    start: number;
+    /** Exclusive frame end. */
+    end: number;
+}
+/** Structural scan result for a concatenated Zstandard stream. */
+export interface ZstdFrameScan {
+    /** Complete frames in file order. */
+    frames: ZstdFrameRange[];
+    /** Start of an incomplete final frame, when EOF interrupts one. */
+    tornStart?: number;
+}
+/**
+ * Locate complete frames without decompressing their blocks. Invalid complete
+ * structure rejects; EOF inside the final frame returns its start for repair.
+ * @param buffer - complete bytes currently present in the session artifact.
+ * @param maxFrames - optional complete-frame limit for metadata-only readers.
+ * @returns complete frame ranges and an optional incomplete-final-frame start.
+ */
+export declare function scanZstdFrames(buffer: Buffer, maxFrames?: number): ZstdFrameScan;
+/**
+ * Compress one independently decodable, checksummed Zstandard frame.
+ * @param input - JSONL bytes for a header or durable event batch.
+ * @returns the complete encoded frame.
+ */
+export declare function compressZstdFrame(input: Buffer | string): Promise<Buffer>;
+/**
+ * Decompress one complete frame and validate its checksum.
+ * @param input - one structurally complete Zstandard frame.
+ * @returns the frame plaintext.
+ */
+export declare function decompressZstdFrame(input: Buffer): Promise<Buffer>;
+/** Common lifecycle for interchangeable synchronous multi-frame decoders. */
+export interface ZstdFrameDecoder {
+    /**
+     * Decode and checksum complete frames in source order. Each yielded buffer
+     * remains valid only until the iterator advances to the next frame.
+     * @param source - concatenated Zstandard frame bytes.
+     * @param frames - structurally complete ranges within `source`.
+     * @returns one plaintext buffer per frame.
+     */
+    decode(source: Buffer, frames: readonly ZstdFrameRange[]): Generator<Buffer, void, void>;
+    /** Release decoder-owned resources; repeated calls are harmless. */
+    close(): void;
+}
+/**
+ * Select the shared private decoder when the running Node 22/24/26 shape is
+ * compatible, otherwise preserve correctness with the public one-shot API.
+ * @returns a synchronous decoder with an implementation-independent lifecycle.
+ */
+export declare function createZstdFrameDecoder(): ZstdFrameDecoder;
+/**
+ * Recover available plaintext from a structurally incomplete final frame.
+ * `ZSTD_e_flush` deliberately suppresses final-frame and checksum completion;
+ * callers must establish the torn frame boundary before using this helper.
+ * @param input - available bytes from a known incomplete Zstandard frame.
+ * @returns plaintext produced from the available input.
+ */
+export declare function decompressZstdPrefix(input: Buffer): Promise<Buffer>;
+//# sourceMappingURL=zstd.d.ts.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@deepseek-ai/dsh-session-persistence-jsonl",
+  "description": "JSONL durable session persistence backend for the DeepSeek Harness",
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/session/session-persistence-jsonl"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "BSD-3-Clause",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  },
+  "dependencies": {
+    "koffi": "^3.1.0",
+    "@deepseek-ai/schemastery": "^3.18.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  }
+}