@deepseek-ai/dsh-atomic-write 0.1.1-rc.2 → 0.1.2-alpha.2

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # 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/util/atomic-write/README.md
-README.md: 0e6501c0ae35bf26d7df67f28ce0ae24c85ecca6
-README.zh.md: 377f85f5c4aab74e8c04068b616de32a8ba063d6
+README.md: 69daf671ba9d1269643533a6bb6e64462b8bee05
+README.zh.md: 8a8613c673c4d12634c686cda7f2ced9957492b2

package/README.md

@@ -1,47 +1,135 @@
-# dsh-atomic-write
+---
+description: "Atomic file replacement and cross-process writer locking for packages that must never leave partial, symlink-hijacked, or wider-permission content on disk."
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-atomic-write
 
 English | [中文](README.zh.md)
 
-Zero-dependency atomic file replacement shared by file-backed stores that must never leave partial, symlink-hijacked, or wider-than-intended content on disk — the user-settings document (`dsh-settings-file`) and the credentials store (`dsh-credentials-local`).
+## Summary
+
+`dsh-atomic-write` replaces a file's contents in one atomic step: readers of the target always observe either the complete old content or the complete new content, never a partial write. It also serializes read-modify-write cycles across processes with a writer lock, so concurrent writers of one file cannot resurrect each other's state. The caller states the permission bits for every replacement and the fresh inode carries them through the swap, so replacing a wider-permission file narrows it without a chmod race. It is a zero-dependency library shared by file-backed stores such as the user-settings document and the credentials store; a `cordis.yml` cannot load it, and crash durability is the caller's policy because there is no `fsync`.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
 
-## Surface
+Use `writeFileAtomic` when a file-backed store must replace one already-rendered string without ever exposing a partial, symlink-hijacked, or wider-permission state, and `withFileLock` when several processes read-modify-write the same file. The smallest path is one call with the final content and the replacement's permission bits.
+
+### Writing a file atomically
 
 ```ts
-import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
 
 declare const text: string
-declare const render: (previous: string) => string
-
 await writeFileAtomic('/home/u/.dsh/settings.yaml', text, { mode: 0o600 })
+```
+
+Parent directories are created as needed, and readers observe either the old or the new complete content. On Windows, transient replacement interference reported as `EACCES`, `EBUSY`, or `EPERM` is retried for a bounded interval; any remaining failure removes the temporary file and leaves the target untouched.
+
+### Coordinating writers
+
+For a read-render-commit cycle that a bare atomic commit cannot make safe on its own, hold the writer lock around the operation:
+
+```text
+import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
+
+declare const render: (previous: string) => string
+declare const readCurrent: () => Promise<string>
 
-// Read-modify-write against the same file from several processes.
 await withFileLock('/home/u/.dsh/settings.yaml', async () => {
-  await writeFileAtomic('/home/u/.dsh/settings.yaml', render(text), { mode: 0o600 })
+  const previous = await readCurrent()
+  await writeFileAtomic('/home/u/.dsh/settings.yaml', render(previous), { mode: 0o600 })
 })
 ```
 
-`writeFileAtomic` commits one already-rendered string. The contract, in the order failures would exploit it:
+Only writers contend — readers never take the lock — and a contender backs off exponentially and fails with a timed-out error rather than blocking forever. How long a contender waits is stated per call through `waitMs`: the default is sized for file work alone, so a holder whose cycle includes a network round trip — a credential mutation that refreshes an expired token — states a longer one, because leaving the default would fail every other writer of that file for the duration. The retry cadence stays fixed. A contender never removes an existing lock, because file age cannot prove that its owner stopped.
+
+### Failures to plan for
+
+The lock's parent directory must already exist, so `withFileLock` rejects an invalid parent hierarchy before running the operation. A process that exits while holding the lock leaves the lock sibling behind; later writers time out, and an operator removes it only after verifying that no writer still owns it.
+
+-----
 
-- **Exclusive-create temp** (`wx`, random suffix): the open refuses to follow a symlink planted at a guessable temp path.
-- **The fresh inode carries `mode` through the rename**: replacing a wider-permission file narrows it without a chmod race. `mode` is required so the permission decision stays visible at every call site (subject to the process umask, like every fresh inode).
-- **`rename` replaces a symlinked target itself**, never writing through to its referent.
-- **Same-directory sibling** keeps the rename on one filesystem, so the swap stays atomic.
-- Parent directories are created; on any failure the temp is removed and the failure rethrown; readers observe either the old or the new complete content.
+<a id="understand-the-implementation"></a>
+## Understand the implementation
 
-`withFileLock` serializes the writers of one file across processes, for the read-render-commit cycles a bare atomic commit cannot make safe on its own. The lock is a `wx`-created `<filename>.lock` sibling, so readers never contend; waiters back off exponentially and fail with a timeout rather than block forever. `EEXIST` identifies contention directly; `EPERM` does so only when a fresh `lstat` confirms that the lock path exists, covering Windows exclusive-create behavior without hiding an unrelated permission failure. A contender never removes the existing lock: age cannot distinguish a crashed owner from a paused live writer.
+<details>
+<summary>Implementation internals — click to expand</summary>
 
-How long a contender waits is a property of the operation the holder runs, so it is stated per call through `waitMs`. The default is sized for file work alone; a holder whose cycle includes a network round trip — a credential mutation that refreshes an expired token — states a longer one, because leaving the default would fail every other writer of that file for the duration. The retry cadence stays fixed: it governs how often a contender asks, which no caller has a reason to vary.
+The package is built on one separation: the atomic commit owns the swap, and the writer lock owns cross-process ordering.
 
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | `writeFileAtomic` and `withFileLock`, the package's whole surface |
+| [`src/invariant.ts`](src/invariant.ts) | Invariant companion (no runtime invariant; the replacement contract is exercised by unit tests) |
+
+### Write path
+
+`writeFileAtomic` writes a random-suffix sibling opened with exclusive create (`wx`), then renames it over the target. The exclusive open refuses to follow a symlink planted at a guessable temp path; the same-directory sibling keeps the rename on one filesystem; and the rename replaces a symlinked target itself instead of writing through to its referent. A Windows retry keeps the same complete sibling and uses bounded exponential backoff, so temporary use of the target by software outside the cooperative writer lock cannot turn a safe replacement into an immediate failure; the [retry decision](../../../.agents/notes/implemented/bug-fix/2026-08-29-windows-atomic-replace-retry.md) owns the rationale and rejected alternatives.
+
+`withFileLock` creates a `<filename>.lock` sibling with `wx`. `EEXIST` identifies contention directly; `EPERM` does so only when a fresh `lstat` confirms the lock path exists, covering Windows exclusive-create behavior without hiding an unrelated permission failure. The lock records its creator's PID and is removed by the holder in a `finally`; contention backs off exponentially and fails when the per-call `waitMs` deadline (default two seconds) passes.
+
+### Why the swap stays safe
+
+- **Fresh inode, caller-stated mode** — the temp carries `mode` through the rename, so narrowing a wider-permission file has no chmod race. `mode` is required so the permission decision stays visible at every call site.
+- **Readers never contend** — the rename commit is atomic, so a reader needs no lock.
+- **A contender never deletes a lock** — age cannot distinguish a crashed owner from a paused live writer; recovery is an operator action.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+Read these pages when you need the consuming stores or the family this primitive belongs to.
+
+- [User-settings file store](../../settings/settings-file/README.md) — the settings document every write replaces through this package.
+- [Credentials store](../../credentials/credentials-local/README.md) — the credentials file this package locks and replaces.
+- [util group map](../README.md) — the zero-dependency utility family this package belongs to.
+
+-----
+
+<a id="model-experience"></a>
 ## Model Experience
 
-None, as this is a pure filesystem primitive; nothing here reaches a model request.
+None, as this is a pure filesystem write primitive that registers nothing model-facing.
 
 #### KV Cache effect
 
-None; nothing here enters a request prefix.
+Nothing here enters a request prefix, so provider cache reuse is unaffected.
 
 ## Known Limitations and Deferred Work
 
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define where the package is not the right tool. They are current package constraints, not a task backlog.
+
 - **Atomic, not durable** — no `fsync` of the file or its directory, so after a crash the rename may be observed unwound. The file-backed stores here re-read and republish on boot, keeping durability the caller's policy.
 - **String content only** — no `Buffer` or stream form until a consumer needs one.
-- **Orphaned locks require operator recovery** — a process that exits while holding the lock can leave the sibling behind. Later writers time out without deleting it; an operator removes it only after verifying that no writer still owns it. File age alone is not safe evidence of abandonment.
+- **Orphaned locks require operator recovery** — a process that exits while holding the lock leaves the sibling behind; later writers time out without deleting it.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+A durability-replacement that `fsync`s the file and parent directory and preserves owner-only permissions on Windows remains open (tracked as `settings-atomic-durability` in source).
+
+</details>

package/README.zh.md

@@ -1,47 +1,135 @@
-# dsh-atomic-write
+---
+description: "原子文件替换与跨进程写锁，供绝不允许在磁盘上留下不完整、被符号链接劫持或权限过宽内容的包使用。"
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-atomic-write
 
 [English](README.md) | 中文
 
-零依赖的原子文件替换，供绝不允许在磁盘上留下不完整、被符号链接劫持或权限过宽内容的文件型存储共用：用户设置文档（`dsh-settings-file`）与凭据存储（`dsh-credentials-local`）。
+## 概述
+
+`dsh-atomic-write` 一步原子地替换文件内容：目标的读取方总是看到完整的旧内容或完整的新内容，绝不看到部分写入。它还通过写锁跨进程串行化读-渲染-提交循环，因此同一文件的并发写入方无法复活彼此替换掉的状态。调用方为每次替换声明权限位，全新 inode 会带着这些权限位走完交换，因此替换权限过宽的旧文件时会直接收窄，不存在 chmod 竞态。它是一个零依赖库，由用户设置文档与凭据存储这类文件型存储共享；`cordis.yml` 无法加载它，而且由于没有 `fsync`，崩溃持久性由调用方负责。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
 
-## 接口面
+当文件型存储必须替换一份已渲染好的字符串、且绝不允许暴露部分写入、符号链接劫持或权限过宽状态时，使用 `writeFileAtomic`；当多个进程读写同一文件时，使用 `withFileLock`。最小路径是一次调用，传入最终内容与替换 inode 的权限位。
+
+### 原子写入文件
 
 ```ts
-import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
 
 declare const text: string
-declare const render: (previous: string) => string
-
 await writeFileAtomic('/home/u/.dsh/settings.yaml', text, { mode: 0o600 })
+```
+
+父目录会按需创建，读取方只会观察到旧内容或完整的新内容。在 Windows 上，报告为 `EACCES`、`EBUSY` 或 `EPERM` 的瞬时替换干扰会在有界时间内重试；任何剩余失败都会移除临时文件，并保持目标文件不变。
+
+### 协调写入方
+
+对于单靠原子提交无法保证安全的读-渲染-提交循环，请在操作期间持有写锁：
+
+```text
+import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write'
+
+declare const render: (previous: string) => string
+declare const readCurrent: () => Promise<string>
 
-// Read-modify-write against the same file from several processes.
 await withFileLock('/home/u/.dsh/settings.yaml', async () => {
-  await writeFileAtomic('/home/u/.dsh/settings.yaml', render(text), { mode: 0o600 })
+  const previous = await readCurrent()
+  await writeFileAtomic('/home/u/.dsh/settings.yaml', render(previous), { mode: 0o600 })
 })
 ```
 
-`writeFileAtomic` 提交一份已经渲染好的字符串。约定按故障利用它的先后顺序列出：
+只有写入方会竞争——读取方从不取锁——竞争者按指数退避，超时即以错误失败，而不是无限阻塞。竞争者等待多久由每次调用经 `waitMs` 声明：默认值只按纯文件工作量级选定，因此持锁方循环若包含一次网络往返——例如刷新过期 token 的凭据变更——就应声明更长的值，否则该文件的其他写入方在这段时间内都会失败。退避节奏保持固定。竞争者绝不移除已有锁，因为文件存续时间无法证明其持有者已经停止。
+
+### 需要规划的失败
+
+锁的父目录必须已经存在，因此 `withFileLock` 会在运行操作之前拒绝无效的父目录层级。持锁进程退出时会把锁文件留在原地；后续写入方超时失败，操作者只有在确认没有写入方仍持有该锁后才会移除它。
+
+-----
 
-- **独占创建临时文件**（`wx` + 随机后缀）：open 拒绝跟随预先埋在可猜测临时路径上的符号链接。
-- **全新 inode 携带 `mode` 走完 rename**：替换权限过宽的旧文件时直接收窄，不存在 chmod 竞态。`mode` 为必填，让权限决策始终可见于每个调用点（与所有新建 inode 一样受进程 umask 影响）。
-- **`rename` 替换的是符号链接目标本身**，绝不写穿到其指向的文件。
-- **同目录兄弟文件**保证 rename 落在同一文件系统上，交换保持原子。
-- 自动创建父目录；任何失败都会移除临时文件并重新抛出该失败；读取方只会观察到旧内容或完整的新内容。
+<a id="understand-the-implementation"></a>
+## 理解实现
 
-`withFileLock` 跨进程串行化同一文件的写入方，服务于单靠原子提交无法保证安全的读-渲染-提交循环。锁是以 `wx` 创建的同目录 `<filename>.lock`，因此读取方从不参与竞争；等待方按指数退避，超时即失败而非无限阻塞。`EEXIST` 直接表示竞争；只有一次新的 `lstat` 确认锁路径存在时，`EPERM` 才表示竞争，从而兼容 Windows 的独占创建行为，又不掩盖无关的权限故障。竞争者绝不移除现有锁：锁龄无法区分已经崩溃的所有者与被暂停但仍存活的写入方。
+<details>
+<summary>实现细节——点击展开</summary>
 
-等待多久是持锁方所跑操作的属性，因此由每次调用经 `waitMs` 声明。默认值只按纯文件工作量级选定；若持锁方的循环包含一次网络往返——例如刷新过期 token 的凭据变更——就应声明更长的值，否则该文件的其他写入方会在这段时间内全部失败。退避节奏保持固定：它决定竞争者多久问一次，调用方没有理由改变它。
+本包建立在一个分离之上：原子提交负责交换，写锁负责跨进程排序。
 
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | `writeFileAtomic` 与 `withFileLock`，即本包的全部接口 |
+| [`src/invariant.ts`](src/invariant.ts) | 不变式伴生插件（无运行时不变式；替换约定由单元测试覆盖） |
+
+### 写入路径
+
+`writeFileAtomic` 先以独占创建（`wx`）打开一个随机后缀的同级文件并写入内容，然后 rename 到目标上。独占打开拒绝跟随预先埋在可猜测临时路径上的符号链接；同目录兄弟文件保证 rename 落在同一文件系统上；rename 替换的是符号链接目标本身，绝不写穿到其指向的文件。Windows 重试会保留同一份完整的兄弟文件，并采用有界指数退避，因此协作式写锁之外的软件瞬时占用目标时，不会让安全替换立即失败；[重试决策](../../../.agents/notes/implemented/bug-fix/2026-08-29-windows-atomic-replace-retry.zh.md)记录了理由与被拒绝的替代方案。
+
+`withFileLock` 以 `wx` 创建 `<filename>.lock` 同级文件。`EEXIST` 直接表示竞争；只有一次新的 `lstat` 确认锁路径存在时，`EPERM` 才表示竞争，从而兼容 Windows 的独占创建行为，又不掩盖无关的权限故障。锁记录创建者的 PID，由持有者在 `finally` 中移除；竞争按指数退避，在每次调用声明的 `waitMs` 期限（默认两秒）过后失败。
+
+### 交换为何安全
+
+- **全新 inode，调用方声明的权限位**——临时文件带着 `mode` 走完 rename，因此收窄权限过宽的文件没有 chmod 竞态。`mode` 为必填，让权限决策始终可见于每个调用点。
+- **读取方从不竞争**——rename 提交是原子的，读取方无需加锁。
+- **竞争者绝不移除锁**——文件存续时间无法区分已崩溃的所有者与暂停但仍存活的写入方；恢复是操作者的动作。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当你需要了解消费它的存储或本原语所属的家族时，阅读以下页面。
+
+- [用户设置文件存储](../../settings/settings-file/README.zh.md)——每次写入都通过本包替换的设置文档。
+- [凭据存储](../../credentials/credentials-local/README.zh.md)——本包加锁并替换的凭据文件。
+- [util 组映射](../README.zh.md)——本包所属的零依赖工具家族。
+
+-----
+
+<a id="model-experience"></a>
 ## 模型体验
 
-无：本包是纯文件系统原语，此处没有任何内容会到达模型请求。
+无：本包是纯文件系统写入原语，不注册任何面向模型的内容。
 
 #### KV Cache 影响
 
-无；此处没有任何内容会进入请求前缀。
+此处没有任何内容进入请求前缀，因此提供方缓存复用不受影响。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
 
-## 已知限制与暂缓事项
+
+这些限制说明本包何时不是合适的工具。它们是当前包约束，不是任务积压。
 
 - **原子但不保证持久**——不对文件或其所在目录做 `fsync`，因此崩溃后可能观察到 rename 被回退。此处的文件型存储在启动时重新读取并重新发布，把持久性留作调用方的策略。
 - **仅支持字符串内容**——在有消费方需要之前，不提供 `Buffer` 或流式形态。
-- **遗留锁需要操作者恢复**——进程持锁退出时可能留下同级锁文件。后续写入方超时也不会删除它；操作者只有在确认没有写入方仍拥有该锁后才会移除。文件存续时间本身不能安全证明它已无人持有。
+- **遗留锁需要操作者恢复**——持锁进程退出时可能留下同级锁文件；后续写入方超时也不会删除它。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+一种对文件及其父目录执行 `fsync`、并在 Windows 上保留仅属主权限的持久性替换方案仍未实现（在源码中记录为 `settings-atomic-durability`）。
+
+</details>

package/lib/index.js

@@ -13,6 +13,34 @@ import { dirname } from "node:path";
 * replaced; readers stay lock-free because the rename commit is atomic.
 * @module @deepseek-ai/dsh-atomic-write
 */
+const WINDOWS_TRANSIENT_RENAME_ERRORS = new Set([
+	"EACCES",
+	"EBUSY",
+	"EPERM"
+]);
+const WINDOWS_RENAME_RETRY_INITIAL_MS = 20;
+const WINDOWS_RENAME_RETRY_MAX_MS = 200;
+const WINDOWS_RENAME_RETRY_LIMIT = 8;
+/** Whether Windows reported temporary interference with an atomic replacement. */
+function isTransientWindowsRenameError(error) {
+	if (process.platform !== "win32") return false;
+	return WINDOWS_TRANSIENT_RENAME_ERRORS.has(error?.code ?? "");
+}
+/** Replace the target after bounded retries for transient Windows interference. */
+async function renameAtomicTemp(temp, filename) {
+	let delay = WINDOWS_RENAME_RETRY_INITIAL_MS;
+	for (let retries = 0;; retries += 1) {
+		try {
+			await rename(temp, filename);
+			return;
+		} catch (error) {
+			if (!isTransientWindowsRenameError(error)) throw error;
+			if (retries >= WINDOWS_RENAME_RETRY_LIMIT) throw error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		delay = Math.min(delay * 2, WINDOWS_RENAME_RETRY_MAX_MS);
+	}
+}
 /**
 * Replace `filename` with `content` in one atomic step, creating parent
 * directories. The content is first written to a random-suffix sibling opened
@@ -21,8 +49,10 @@ import { dirname } from "node:path";
 * rename, so replacing a wider-permission file narrows it without a chmod
 * race. The rename also replaces a symlinked target itself instead of writing
 * through to its referent, and the same-directory sibling keeps the rename on
-* one filesystem. On any failure the temp file is removed and the failure
-* rethrown. Crash durability (fsync) is out of scope.
+* one filesystem. Windows replacement retries transient `EACCES`, `EBUSY`,
+* and `EPERM` failures for a bounded interval while the complete temp file
+* remains the rename source. On any remaining failure the temp file is
+* removed and the failure rethrown. Crash durability (fsync) is out of scope.
 * @param filename - final path receiving the content.
 * @param content - complete next file content.
 * @param options - permission bits for the replacement inode.
@@ -38,7 +68,7 @@ async function writeFileAtomic(filename, content, options) {
 			mode: options.mode,
 			flag: "wx"
 		});
-		await rename(temp, filename);
+		await renameAtomicTemp(temp, filename);
 	} catch (error) {
 		await rm(temp, { force: true });
 		throw error;

package/lib/types/index.d.ts

@@ -34,8 +34,10 @@ export interface WriteFileAtomicOptions {
  * rename, so replacing a wider-permission file narrows it without a chmod
  * race. The rename also replaces a symlinked target itself instead of writing
  * through to its referent, and the same-directory sibling keeps the rename on
- * one filesystem. On any failure the temp file is removed and the failure
- * rethrown. Crash durability (fsync) is out of scope.
+ * one filesystem. Windows replacement retries transient `EACCES`, `EBUSY`,
+ * and `EPERM` failures for a bounded interval while the complete temp file
+ * remains the rename source. On any remaining failure the temp file is
+ * removed and the failure rethrown. Crash durability (fsync) is out of scope.
  * @param filename - final path receiving the content.
  * @param content - complete next file content.
  * @param options - permission bits for the replacement inode.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-atomic-write",
   "description": "Zero-dependency atomic file replacement: exclusive-create random-suffix temp + rename carrying the caller-stated permissions (writeFileAtomic)",
-  "version": "0.1.1-rc.2",
+  "version": "0.1.2-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -32,11 +32,11 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2"
   }
 }