@deepseek-ai/dsh-storage-json 0.0.1-rc.1

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, DeepSeek
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/storage/storage-json/README.md
+README.md: c3417846a70f8a227a19a5abf834156d530e3597
+README.zh.md: e66c711dca838620eb9c90a3edacd2639970505e

package/README.md

@@ -0,0 +1,38 @@
+# @deepseek-ai/dsh-storage-json
+
+English | [中文](README.zh.md)
+
+JSON backend for the [storage hub](../storage/README.md): one human-readable `<unit>.json` file per unit under a configured root, registered as backend `json`. Design: [domain KV storage Agent Note](../../../.agents/notes/proposed/architecture/2026-07-24-domain-kv-storage-and-workspace.zh.md).
+
+## Model
+
+- The in-memory unit state is authoritative; every write primitive republishes the whole file via temp-write + fsync + atomic `rename()` replace. A unit file is always the complete current net state — legibility is this backend's reason to exist; scale is the SQLite backend's job.
+- A missing file opens as an empty unit and materializes on the first write. A foreign or unparsable file rejects with `malformed-medium`; a stored version differing from the descriptor rejects with `version-mismatch` (no migration, pre-release stance).
+- Write ordering across calls belongs to the caller (the domain layer's write chain); each single call is atomic and durable once resolved.
+
+## Config
+
+| Key | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `root` | string | required — no default (a cwd fallback would scatter files) | Directory holding unit files; created `0o700` on demand |
+
+## Model Experience
+
+### Stored domain records
+
+#### What the model sees
+
+Nothing. This backend contributes no prompt, tool, or schema; it persists non-session domain data behind `ctx.storage` for host-side consumers only.
+
+#### Token effect
+
+Zero live-request tokens.
+
+#### KV Cache effect
+
+None — the backend never touches live request prefixes.
+
+## Known Limitations and Deferred Work
+
+- Windows durability relies on libuv's `rename()` (`MoveFileExW` with replacement) without an explicit write-through flag; the session-log backend's stricter Win32 write-through publish helper is planned to move down here when the append-log facet lands (see the Agent Note's migration section).
+- No cross-process write locking: two processes writing the same root can interleave whole-file replacements (last write wins). Single-host-process deployments are the current consumer; the multi-process story is deferred per the Agent Note's out-of-scope table.

package/README.zh.md

@@ -0,0 +1,38 @@
+# @deepseek-ai/dsh-storage-json
+
+[English](README.md) | 中文
+
+[存储中心](../storage/README.md)的 JSON 后端：配置根目录下每个单元使用一个人类可读的 `<unit>.json` 文件，注册为后端 `json`。设计见[领域 KV 存储 Agent Note](../../../.agents/notes/proposed/architecture/2026-07-24-domain-kv-storage-and-workspace.zh.md)。
+
+## 模型
+
+- 内存中的单元状态具有最终决定权；每个写入原语都会通过临时文件写入 + fsync + 原子 `rename()` 替换重新发布整个文件。单元文件始终是完整的当前状态：可读性是该后端存在的理由，规模问题则属于 SQLite 后端。
+- 缺失文件会作为空单元打开，并在第一次写入时物化。外来或无法解析的文件以 `malformed-medium` 拒绝；已存版本与描述符不同时以 `version-mismatch` 拒绝（预发布立场，不迁移）。
+- 跨调用的写入顺序属于调用方（领域层的写入链）；每次调用都具备原子性，并在完成时已达到持久状态。
+
+## 配置
+
+| Key | 类型 | 默认值 | 含义 |
+| --- | --- | --- | --- |
+| `root` | string | 必填，无默认值（cwd 回退会让文件散落各处） | 保存单元文件的目录；按需以 `0o700` 创建 |
+
+## 模型体验
+
+### 已存领域记录
+
+#### 模型看到的内容
+
+无。该后端不贡献提示词、工具或 schema；它在 `ctx.storage` 后面持久化非会话领域数据，只供宿主侧消费方使用。
+
+#### Token 影响
+
+实时请求 token 为零。
+
+#### KV Cache 影响
+
+无：该后端从不触碰实时请求前缀。
+
+## 已知限制与暂缓事项
+
+- Windows 持久性依赖 libuv 的 `rename()`（调用 `MoveFileExW` 并启用替换），没有显式 write-through 标志；追加日志分面落地时，计划把会话日志后端更严格的 Win32 write-through 发布辅助函数下移到此处（见 Agent Note 的迁移章节）。
+- 没有跨进程写锁：两个进程写入同一根目录时，可能交错执行整文件替换（最后写入者胜出）。当前消费方采用单一宿主进程部署；多进程方案按 Agent Note 的范围外事项表暂缓。

package/lib/index.js

@@ -0,0 +1,297 @@
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { StorageError, UNIT_NAME_RE, storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
+import { randomUUID } from "node:crypto";
+//#region lib/types/atomic.js
+/**
+* Atomic whole-file replacement for the JSON backend.
+*
+* Publish protocol: write a same-directory temp file, fsync it, then
+* `rename()` over the target. Rename is an atomic replace on POSIX and on
+* Windows (libuv maps it to `MoveFileExW(..., MOVEFILE_REPLACE_EXISTING)`),
+* and replacement is the intended semantic here — unlike the session-log
+* backend's link()+unlink() no-clobber protocol, a unit file has exactly one
+* writer per process and last-write-wins is correct. After the rename the
+* parent directory is fsynced on POSIX so the new entry is crash-durable.
+* @module @deepseek-ai/dsh-storage-json/src/atomic
+*/
+/**
+* Durably replace `path` with `data`.
+* @param path - Absolute target file path.
+* @param data - Full new file content.
+* @returns resolution after the replacement is crash-durable.
+*/
+async function writeAtomic(path, data) {
+	const tmp = join(dirname(path), `.${randomUUID()}.tmp`);
+	try {
+		const handle = await open(tmp, "wx", 384);
+		try {
+			await handle.writeFile(data, "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await rename(tmp, path);
+		await fsyncDirectory(dirname(path));
+	} catch (error) {
+		await rm(tmp, { force: true });
+		throw error;
+	}
+}
+/** fsync a POSIX directory so a just-renamed entry is crash-durable. */
+/* v8 ignore start -- Windows rejects O_RDONLY directory opens; POSIX coverage exercises this. */
+async function fsyncDirectory(path) {
+	if (process.platform === "win32") return;
+	const handle = await open(path, "r");
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+/* v8 ignore stop */
+//#endregion
+//#region lib/types/format.js
+/**
+* On-disk JSON unit format: the file is always the current net state, kept
+* human-readable (pretty-printed, stable key order from insertion) — that
+* legibility is this backend's reason to exist.
+* @module @deepseek-ai/dsh-storage-json/src/format
+*/
+/**
+* Serialize a unit state to file content.
+* @param name - Unit name, stamped into the header.
+* @param state - Authoritative in-memory state.
+* @returns pretty-printed JSON document with a trailing newline.
+*/
+function serialize(name, state) {
+	const tables = {};
+	for (const [table, records] of state.tables) tables[table] = Object.fromEntries(records);
+	const document = {
+		unit: {
+			name,
+			version: state.version
+		},
+		global: state.global,
+		tables
+	};
+	return `${JSON.stringify(document, null, 2)}\n`;
+}
+/**
+* Parse file content into unit state, validating shape and version.
+* @param text - Raw file content.
+* @param descriptor - Expected identity; version mismatch rejects.
+* @returns the parsed state.
+*/
+function parse(text, descriptor) {
+	let document;
+	try {
+		document = JSON.parse(text);
+	} catch (error) {
+		throw new StorageError("malformed-medium", `unit '${descriptor.name}': file is not valid JSON`, { cause: error });
+	}
+	if (typeof document !== "object" || document === null) throw new StorageError("malformed-medium", `unit '${descriptor.name}': file is not a JSON object`);
+	const { unit, global: globalValue, tables } = document;
+	if (typeof unit !== "object" || unit === null || unit["name"] !== descriptor.name || typeof unit["version"] !== "number") throw new StorageError("malformed-medium", `unit '${descriptor.name}': missing or foreign unit header`);
+	const version = unit["version"];
+	if (version !== descriptor.version) throw new StorageError("version-mismatch", `unit '${descriptor.name}': stored version ${version} != expected ${descriptor.version}`);
+	if (typeof tables !== "object" || tables === null) throw new StorageError("malformed-medium", `unit '${descriptor.name}': tables is not an object`);
+	const state = {
+		version,
+		global: globalValue ?? null,
+		tables: /* @__PURE__ */ new Map()
+	};
+	for (const table of descriptor.tables) {
+		const records = tables[table];
+		if (records === void 0) {
+			state.tables.set(table, /* @__PURE__ */ new Map());
+			continue;
+		}
+		if (typeof records !== "object" || records === null || Array.isArray(records)) throw new StorageError("malformed-medium", `unit '${descriptor.name}': table '${table}' is not an object`);
+		state.tables.set(table, new Map(Object.entries(records)));
+	}
+	return state;
+}
+//#endregion
+//#region lib/types/unit.js
+/**
+* One opened JSON unit. The in-memory state is authoritative; every write
+* primitive mutates it and republishes the whole file atomically. Writes are
+* NOT queued here — per the backend contract, write ordering belongs to the
+* caller (the domain layer's write chain); this unit only guarantees that
+* each single call publishes a complete, durable file.
+* @module @deepseek-ai/dsh-storage-json/src/unit
+*/
+/**
+* Open (load or lazily create) one unit backed by `path`.
+* @param descriptor - Static identity and shape of the unit.
+* @param path - Absolute unit file path under the backend root.
+* @param onClose - Backend callback releasing the unit's open-slot.
+* @returns the opened unit.
+*/
+async function openJsonUnit(descriptor, path, onClose) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return new JsonKvUnit(descriptor, path, text === void 0 ? {
+		version: descriptor.version,
+		global: null,
+		tables: new Map(descriptor.tables.map((table) => [table, /* @__PURE__ */ new Map()]))
+	} : parse(text, descriptor), onClose);
+}
+var JsonKvUnit = class {
+	descriptor;
+	path;
+	state;
+	onClose;
+	closed = false;
+	/** In-flight publishes; close() drains them before releasing the unit. */
+	inFlight = /* @__PURE__ */ new Set();
+	constructor(descriptor, path, state, onClose) {
+		this.descriptor = descriptor;
+		this.path = path;
+		this.state = state;
+		this.onClose = onClose;
+	}
+	async loadAll() {
+		this.assertOpen();
+		const tables = {};
+		for (const [table, records] of this.state.tables) tables[table] = Object.fromEntries(records);
+		return {
+			tables,
+			global: this.state.global
+		};
+	}
+	async putRecord(table, key, value) {
+		this.assertOpen();
+		const records = this.records(table);
+		const hadKey = records.has(key);
+		const previous = records.get(key);
+		records.set(key, value);
+		await this.publish().catch((error) => {
+			if (hadKey) records.set(key, previous);
+			else records.delete(key);
+			throw error;
+		});
+	}
+	async deleteRecord(table, key) {
+		this.assertOpen();
+		const records = this.records(table);
+		if (!records.has(key)) return;
+		const previous = records.get(key);
+		records.delete(key);
+		await this.publish().catch((error) => {
+			records.set(key, previous);
+			throw error;
+		});
+	}
+	async setGlobal(value) {
+		this.assertOpen();
+		if (!this.descriptor.hasGlobal) throw new Error(`unit '${this.descriptor.name}' does not declare a global slot`);
+		const previous = this.state.global;
+		this.state.global = value;
+		await this.publish().catch((error) => {
+			this.state.global = previous;
+			throw error;
+		});
+	}
+	async close() {
+		if (this.closed) {
+			await Promise.allSettled(this.inFlight);
+			return;
+		}
+		this.closed = true;
+		await Promise.allSettled(this.inFlight);
+		this.onClose();
+	}
+	assertOpen() {
+		if (this.closed) throw new StorageError("closed", `unit '${this.descriptor.name}' is closed`);
+	}
+	records(table) {
+		const records = this.state.tables.get(table);
+		if (!records) throw new Error(`unit '${this.descriptor.name}' does not declare table '${table}'`);
+		return records;
+	}
+	publish() {
+		const write = writeAtomic(this.path, serialize(this.descriptor.name, this.state));
+		this.inFlight.add(write);
+		write.catch(() => {}).finally(() => this.inFlight.delete(write));
+		return write;
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/**
+* JSON storage backend: one human-readable file per unit under a configured
+* root, published by atomic whole-file rewrite. Registers as backend `json`
+* on the storage hub.
+* @module @deepseek-ai/dsh-storage-json
+*/
+/** Cordis plugin name. */
+const name = "storage-json";
+/** The hub must exist before the backend can register. */
+const inject = ["storage"];
+/** Config schema. */
+const Config = z.object({ root: z.string().required() });
+/** JSON backend: owns the file-tree root and serves the `kv` facet. */
+var JsonStorageBackend = class {
+	root;
+	open = /* @__PURE__ */ new Map();
+	opening = /* @__PURE__ */ new Map();
+	closed = false;
+	constructor(root) {
+		this.root = root;
+	}
+	kv = { open: async (descriptor) => {
+		if (this.closed) throw new StorageError("closed", "json backend is closed");
+		validateDescriptor(descriptor);
+		if (this.open.has(descriptor.name) || this.opening.has(descriptor.name)) throw new Error(`unit '${descriptor.name}' is already open; a unit has exactly one live handle`);
+		const opening = this.openUnit(descriptor);
+		this.opening.set(descriptor.name, opening);
+		return opening.finally(() => this.opening.delete(descriptor.name));
+	} };
+	async openUnit(descriptor) {
+		await mkdir(this.root, {
+			recursive: true,
+			mode: 448
+		});
+		const unit = await openJsonUnit(descriptor, join(this.root, `${descriptor.name}.json`), () => this.open.delete(descriptor.name));
+		if (this.closed) {
+			await unit.close();
+			throw new StorageError("closed", "json backend is closed");
+		}
+		this.open.set(descriptor.name, unit);
+		return unit;
+	}
+	async close() {
+		if (!this.closed) this.closed = true;
+		await Promise.allSettled([...this.opening.values()]);
+		for (const unit of [...this.open.values()]) await unit.close();
+	}
+};
+function validateDescriptor(descriptor) {
+	if (!UNIT_NAME_RE.test(descriptor.name)) throw new StorageError("malformed-medium", `invalid unit name '${descriptor.name}'`);
+	for (const table of descriptor.tables) if (!UNIT_NAME_RE.test(table)) throw new StorageError("malformed-medium", `invalid table name '${table}' in unit '${descriptor.name}'`);
+}
+/**
+* Register the `json` backend on the storage hub.
+* @param ctx - Plugin context.
+* @param config - Validated configuration.
+*/
+function apply(ctx, config) {
+	const backend = new JsonStorageBackend(config.root);
+	ctx.effect(() => {
+		const unregister = ctx.storage.backend.register("json", backend);
+		return async () => {
+			unregister();
+			await backend.close();
+		};
+	});
+	ctx.provide(storageBackendServiceKey("json"), backend);
+}
+//#endregion
+export { Config, JsonStorageBackend, apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-storage-json`.
+* @module @deepseek-ai/dsh-storage-json/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-storage-json";
+/** Cordis companion plugin name. */
+const name = "storage-json-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: correctness here is write-durability and
+* publish-then-reparse equivalence, which require medium round-trip tests
+* (the shared backend conformance suite); the backend 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/atomic.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Atomic whole-file replacement for the JSON backend.
+ *
+ * Publish protocol: write a same-directory temp file, fsync it, then
+ * `rename()` over the target. Rename is an atomic replace on POSIX and on
+ * Windows (libuv maps it to `MoveFileExW(..., MOVEFILE_REPLACE_EXISTING)`),
+ * and replacement is the intended semantic here — unlike the session-log
+ * backend's link()+unlink() no-clobber protocol, a unit file has exactly one
+ * writer per process and last-write-wins is correct. After the rename the
+ * parent directory is fsynced on POSIX so the new entry is crash-durable.
+ * @module @deepseek-ai/dsh-storage-json/src/atomic
+ */
+/**
+ * Durably replace `path` with `data`.
+ * @param path - Absolute target file path.
+ * @param data - Full new file content.
+ * @returns resolution after the replacement is crash-durable.
+ */
+export declare function writeAtomic(path: string, data: string): Promise<void>;
+//# sourceMappingURL=atomic.d.ts.map

package/lib/types/format.d.ts

@@ -0,0 +1,28 @@
+/**
+ * On-disk JSON unit format: the file is always the current net state, kept
+ * human-readable (pretty-printed, stable key order from insertion) — that
+ * legibility is this backend's reason to exist.
+ * @module @deepseek-ai/dsh-storage-json/src/format
+ */
+import type { KvUnitDescriptor } from '@deepseek-ai/dsh-storage';
+/** In-memory authoritative state of one unit; the file is its projection. `global` is `null` until first written. */
+export interface UnitState {
+    version: number;
+    global: unknown;
+    tables: Map<string, Map<string, unknown>>;
+}
+/**
+ * Serialize a unit state to file content.
+ * @param name - Unit name, stamped into the header.
+ * @param state - Authoritative in-memory state.
+ * @returns pretty-printed JSON document with a trailing newline.
+ */
+export declare function serialize(name: string, state: UnitState): string;
+/**
+ * Parse file content into unit state, validating shape and version.
+ * @param text - Raw file content.
+ * @param descriptor - Expected identity; version mismatch rejects.
+ * @returns the parsed state.
+ */
+export declare function parse(text: string, descriptor: KvUnitDescriptor): UnitState;
+//# sourceMappingURL=format.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * JSON storage backend: one human-readable file per unit under a configured
+ * root, published by atomic whole-file rewrite. Registers as backend `json`
+ * on the storage hub.
+ * @module @deepseek-ai/dsh-storage-json
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { KvFacet, StorageBackend } from '@deepseek-ai/dsh-storage';
+/** Cordis plugin name. */
+export declare const name = "storage-json";
+/** The hub must exist before the backend can register. */
+export declare const inject: string[];
+/**
+ * Plugin configuration.
+ * `root` has NO default on purpose: a `process.cwd()` fallback would scatter
+ * unit files wherever the process happens to start; assemblies state the
+ * location explicitly.
+ */
+export interface Config {
+    /** Directory holding one `<unit>.json` file per unit. */
+    root: string;
+}
+/** Config schema. */
+export declare const Config: z<Config>;
+/** JSON backend: owns the file-tree root and serves the `kv` facet. */
+export declare class JsonStorageBackend implements StorageBackend {
+    private readonly root;
+    private readonly open;
+    private readonly opening;
+    private closed;
+    constructor(root: string);
+    readonly kv: KvFacet;
+    private openUnit;
+    close(): Promise<void>;
+}
+/**
+ * Register the `json` backend on the storage hub.
+ * @param ctx - Plugin context.
+ * @param config - Validated configuration.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-storage-json`.
+ * @module @deepseek-ai/dsh-storage-json/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "storage-json-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/unit.d.ts

@@ -0,0 +1,18 @@
+/**
+ * One opened JSON unit. The in-memory state is authoritative; every write
+ * primitive mutates it and republishes the whole file atomically. Writes are
+ * NOT queued here — per the backend contract, write ordering belongs to the
+ * caller (the domain layer's write chain); this unit only guarantees that
+ * each single call publishes a complete, durable file.
+ * @module @deepseek-ai/dsh-storage-json/src/unit
+ */
+import type { KvUnit, KvUnitDescriptor } from '@deepseek-ai/dsh-storage';
+/**
+ * Open (load or lazily create) one unit backed by `path`.
+ * @param descriptor - Static identity and shape of the unit.
+ * @param path - Absolute unit file path under the backend root.
+ * @param onClose - Backend callback releasing the unit's open-slot.
+ * @returns the opened unit.
+ */
+export declare function openJsonUnit(descriptor: KvUnitDescriptor, path: string, onClose: () => void): Promise<KvUnit>;
+//# sourceMappingURL=unit.d.ts.map

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@deepseek-ai/dsh-storage-json",
+  "description": "JSON file KV storage backend for the DeepSeek Harness storage hub",
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/storage/storage-json"
+  },
+  "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-storage": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-storage": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  }
+}