@wrongstack/persistence 0.295.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ECOSTACK TECHNOLOGY OÜ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# `@wrongstack/persistence`
+
+Dependency-free filesystem persistence primitives shared by WrongStack packages.
+
+The package owns atomic replacement, parent-directory creation, cooperative file
+locks, stale-lock recovery, watcher-assisted contention waits, bounded lock
+timeouts, and transient Windows rename retries. It intentionally owns no domain
+repository, serialization format, migration policy, or cloud synchronization.
+
+```ts
+import { atomicWrite, withFileLock } from '@wrongstack/persistence';
+
+await withFileLock(file, async () => {
+  await atomicWrite(file, JSON.stringify(value));
+});
+```
+
+The default timeout error is `PersistenceFsError`. A host with an established
+error hierarchy can call `createPersistencePrimitives` and inject only the
+timeout-error factory. This keeps dependency direction toward the primitive
+while preserving host compatibility contracts.
+
+Core and Kanban retain thin adapters during migration. Their behavior is locked
+to this package by one shared adversarial conformance suite.

package/dist/atomic-write.d.ts

@@ -0,0 +1,43 @@
+export interface AtomicWriteOptions {
+    mode?: number | undefined;
+    encoding?: BufferEncoding | undefined;
+}
+export interface FileLockOptions {
+    timeoutMs?: number | undefined;
+    staleMs?: number | undefined;
+}
+export interface FileLockTimeoutDetails {
+    targetPath: string;
+    timeoutMs: number;
+}
+export interface PersistencePrimitiveOptions {
+    createLockTimeoutError?: ((details: FileLockTimeoutDetails) => Error) | undefined;
+}
+export interface PersistencePrimitives {
+    atomicWrite(targetPath: string, content: string | Uint8Array, opts?: AtomicWriteOptions): Promise<void>;
+    ensureDir(dir: string): Promise<void>;
+    withFileLock<T>(targetPath: string, fn: () => Promise<T>, opts?: FileLockOptions): Promise<T>;
+}
+/** A dependency-free structured error for persistence boundary failures. */
+export declare class PersistenceFsError extends Error {
+    name: string;
+    readonly code: string;
+    readonly path?: string | undefined;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(opts: {
+        message: string;
+        code: string;
+        path?: string | undefined;
+        context?: Record<string, unknown> | undefined;
+        cause?: unknown | undefined;
+    });
+}
+/**
+ * Create an isolated primitive set. Hosts may inject their own structured
+ * timeout error without making this low-level package depend on that host.
+ */
+export declare function createPersistencePrimitives(options?: PersistencePrimitiveOptions): PersistencePrimitives;
+export declare const atomicWrite: (targetPath: string, content: string | Uint8Array, opts?: AtomicWriteOptions) => Promise<void>;
+export declare const ensureDir: (dir: string) => Promise<void>;
+export declare const withFileLock: <T>(targetPath: string, fn: () => Promise<T>, opts?: FileLockOptions) => Promise<T>;
+//# sourceMappingURL=atomic-write.d.ts.map

package/dist/atomic-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.d.ts","sourceRoot":"","sources":["../src/atomic-write.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CACvC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,2BAA2B;IAC1C,sBAAsB,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,sBAAsB,KAAK,KAAK,CAAC,GAAG,SAAS,CAAC;CACnF;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,CACT,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,IAAI,CAAC,EAAE,kBAAkB,GACxB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/F;AAED,4EAA4E;AAC5E,qBAAa,kBAAmB,SAAQ,KAAK;IAClC,IAAI,SAAa;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAEvD,YAAY,IAAI,EAAE;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;QAC9C,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;KAC7B,EAKA;CACF;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,GAAE,2BAAgC,GACxC,qBAAqB,CAyHvB;AAgED,eAAO,MAAM,WAAW,eA5NR,MAAM,WACT,MAAM,GAAG,UAAU,SACrB,kBAAkB,KACxB,OAAO,CAAC,IAAI,CAyNuC,CAAC;AACzD,eAAO,MAAM,SAAS,QAzNL,MAAM,KAAG,OAAO,CAAC,IAAI,CAyNc,CAAC;AACrD,eAAO,MAAM,YAAY,GAzNV,CAAC,cAAc,MAAM,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,SAAS,eAAe,KAAG,OAAO,CAAC,CAAC,CAyNpC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './atomic-write.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,180 @@
+// src/atomic-write.ts
+import { randomBytes } from "node:crypto";
+import { watch as watchDir } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var PersistenceFsError = class extends Error {
+  name = "FsError";
+  code;
+  path;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.code = opts.code;
+    this.path = opts.path;
+    this.context = opts.context;
+  }
+};
+function createPersistencePrimitives(options = {}) {
+  const createLockTimeoutError = options.createLockTimeoutError ?? (({ targetPath, timeoutMs }) => new PersistenceFsError({
+    message: `Timed out waiting for file lock: ${targetPath}`,
+    code: "FS_ATOMIC_WRITE_FAILED",
+    path: targetPath,
+    context: { timeoutMs }
+  }));
+  async function atomicWrite2(targetPath, content, opts = {}) {
+    const dir = path.dirname(targetPath);
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = path.join(
+      dir,
+      `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`
+    );
+    try {
+      if (typeof content === "string") {
+        await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      } else {
+        await fs.writeFile(tmp, content, { flag: "wx" });
+      }
+      try {
+        const fileHandle = await fs.open(tmp, "r+");
+        try {
+          await fileHandle.sync();
+        } finally {
+          await fileHandle.close();
+        }
+      } catch {
+      }
+      let mode;
+      try {
+        const stat2 = await fs.stat(targetPath);
+        mode = stat2.mode & 511;
+      } catch {
+        mode = opts.mode;
+      }
+      if (mode !== void 0) await fs.chmod(tmp, mode);
+      await renameWithRetry(tmp, targetPath);
+      if (mode !== void 0 && process.platform === "win32") {
+        await fs.chmod(targetPath, mode).catch(() => void 0);
+      }
+    } catch (error) {
+      await fs.unlink(tmp).catch(() => void 0);
+      throw error;
+    }
+  }
+  async function ensureDir2(dir) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+  async function withFileLock2(targetPath, fn, opts = {}) {
+    const dir = path.dirname(targetPath);
+    const lockPath = path.join(dir, `.${path.basename(targetPath)}.lock`);
+    const timeoutMs = opts.timeoutMs ?? 15e3;
+    const staleMs = opts.staleMs ?? 3e4;
+    const started = Date.now();
+    let handle;
+    for (; ; ) {
+      try {
+        handle = await fs.open(lockPath, "wx");
+        await handle.writeFile(`${process.pid}:${Date.now()}`);
+        break;
+      } catch (error) {
+        if (handle) {
+          await handle.close().catch(() => void 0);
+          await fs.unlink(lockPath).catch(() => void 0);
+          handle = void 0;
+        }
+        const code = error.code;
+        if (code === "ENOENT") {
+          await fs.mkdir(dir, { recursive: true });
+          continue;
+        }
+        if (code !== "EEXIST" && code !== "EPERM") throw error;
+        try {
+          const stat2 = await fs.stat(lockPath);
+          if (Date.now() - stat2.mtimeMs > staleMs) {
+            await fs.unlink(lockPath);
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        const elapsed = Date.now() - started;
+        if (elapsed >= timeoutMs) {
+          throw createLockTimeoutError({ targetPath, timeoutMs });
+        }
+        await waitForLockRelease(lockPath, timeoutMs - elapsed);
+      }
+    }
+    try {
+      return await fn();
+    } finally {
+      await handle?.close().catch(() => void 0);
+      await fs.unlink(lockPath).catch(() => void 0);
+    }
+  }
+  return { atomicWrite: atomicWrite2, ensureDir: ensureDir2, withFileLock: withFileLock2 };
+}
+async function waitForLockRelease(lockPath, remainingMs) {
+  const parentDir = path.dirname(lockPath);
+  const lockName = path.basename(lockPath);
+  const intervalMs = Math.min(remainingMs, 100);
+  return new Promise((resolve) => {
+    let settled = false;
+    let watcher = null;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      watcher?.close();
+      resolve();
+    };
+    const timer = setTimeout(settle, intervalMs);
+    try {
+      watcher = watchDir(parentDir, (eventType, filename) => {
+        if (filename === lockName && (eventType === "rename" || eventType === "change")) {
+          clearTimeout(timer);
+          settle();
+        }
+      });
+    } catch {
+      clearTimeout(timer);
+      setTimeout(settle, Math.min(remainingMs, 25));
+      return;
+    }
+    void fs.access(lockPath).catch(() => {
+      clearTimeout(timer);
+      settle();
+    });
+  });
+}
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fs.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastError;
+  for (let attempt = 0; attempt <= delays.length; attempt++) {
+    try {
+      await fs.rename(from, to);
+      return;
+    } catch (error) {
+      lastError = error;
+      const code = error.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || attempt === delays.length) throw error;
+      await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+    }
+  }
+  throw lastError;
+}
+var defaultPrimitives = createPersistencePrimitives();
+var atomicWrite = defaultPrimitives.atomicWrite;
+var ensureDir = defaultPrimitives.ensureDir;
+var withFileLock = defaultPrimitives.withFileLock;
+export {
+  PersistenceFsError,
+  atomicWrite,
+  createPersistencePrimitives,
+  ensureDir,
+  withFileLock
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/atomic-write.ts"],
+  "sourcesContent": ["import { randomBytes } from 'node:crypto';\nimport type { FSWatcher } from 'node:fs';\nimport { watch as watchDir } from 'node:fs';\nimport * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\n\nexport interface AtomicWriteOptions {\n  mode?: number | undefined;\n  encoding?: BufferEncoding | undefined;\n}\n\nexport interface FileLockOptions {\n  timeoutMs?: number | undefined;\n  staleMs?: number | undefined;\n}\n\nexport interface FileLockTimeoutDetails {\n  targetPath: string;\n  timeoutMs: number;\n}\n\nexport interface PersistencePrimitiveOptions {\n  createLockTimeoutError?: ((details: FileLockTimeoutDetails) => Error) | undefined;\n}\n\nexport interface PersistencePrimitives {\n  atomicWrite(\n    targetPath: string,\n    content: string | Uint8Array,\n    opts?: AtomicWriteOptions,\n  ): Promise<void>;\n  ensureDir(dir: string): Promise<void>;\n  withFileLock<T>(targetPath: string, fn: () => Promise<T>, opts?: FileLockOptions): Promise<T>;\n}\n\n/** A dependency-free structured error for persistence boundary failures. */\nexport class PersistenceFsError extends Error {\n  override name = 'FsError';\n  readonly code: string;\n  readonly path?: string | undefined;\n  readonly context?: Record<string, unknown> | undefined;\n\n  constructor(opts: {\n    message: string;\n    code: string;\n    path?: string | undefined;\n    context?: Record<string, unknown> | undefined;\n    cause?: unknown | undefined;\n  }) {\n    super(opts.message, { cause: opts.cause });\n    this.code = opts.code;\n    this.path = opts.path;\n    this.context = opts.context;\n  }\n}\n\n/**\n * Create an isolated primitive set. Hosts may inject their own structured\n * timeout error without making this low-level package depend on that host.\n */\nexport function createPersistencePrimitives(\n  options: PersistencePrimitiveOptions = {},\n): PersistencePrimitives {\n  const createLockTimeoutError =\n    options.createLockTimeoutError ??\n    (({ targetPath, timeoutMs }: FileLockTimeoutDetails) =>\n      new PersistenceFsError({\n        message: `Timed out waiting for file lock: ${targetPath}`,\n        code: 'FS_ATOMIC_WRITE_FAILED',\n        path: targetPath,\n        context: { timeoutMs },\n      }));\n\n  async function atomicWrite(\n    targetPath: string,\n    content: string | Uint8Array,\n    opts: AtomicWriteOptions = {},\n  ): Promise<void> {\n    const dir = path.dirname(targetPath);\n    await fs.mkdir(dir, { recursive: true });\n    const tmp = path.join(\n      dir,\n      `.${path.basename(targetPath)}.${randomBytes(6).toString('hex')}.tmp`,\n    );\n\n    try {\n      if (typeof content === 'string') {\n        await fs.writeFile(tmp, content, { flag: 'wx', encoding: opts.encoding ?? 'utf8' });\n      } else {\n        await fs.writeFile(tmp, content, { flag: 'wx' });\n      }\n      try {\n        const fileHandle = await fs.open(tmp, 'r+');\n        try {\n          await fileHandle.sync();\n        } finally {\n          await fileHandle.close();\n        }\n      } catch {\n        // fsync is best-effort; the atomic rename still protects readers.\n      }\n\n      let mode: number | undefined;\n      try {\n        const stat = await fs.stat(targetPath);\n        mode = stat.mode & 0o777;\n      } catch {\n        mode = opts.mode;\n      }\n      if (mode !== undefined) await fs.chmod(tmp, mode);\n\n      await renameWithRetry(tmp, targetPath);\n      if (mode !== undefined && process.platform === 'win32') {\n        await fs.chmod(targetPath, mode).catch(() => undefined);\n      }\n    } catch (error) {\n      await fs.unlink(tmp).catch(() => undefined);\n      throw error;\n    }\n  }\n\n  async function ensureDir(dir: string): Promise<void> {\n    await fs.mkdir(dir, { recursive: true });\n  }\n\n  async function withFileLock<T>(\n    targetPath: string,\n    fn: () => Promise<T>,\n    opts: FileLockOptions = {},\n  ): Promise<T> {\n    const dir = path.dirname(targetPath);\n    const lockPath = path.join(dir, `.${path.basename(targetPath)}.lock`);\n    const timeoutMs = opts.timeoutMs ?? 15_000;\n    const staleMs = opts.staleMs ?? 30_000;\n    const started = Date.now();\n    let handle: fs.FileHandle | undefined;\n\n    for (;;) {\n      try {\n        handle = await fs.open(lockPath, 'wx');\n        await handle.writeFile(`${process.pid}:${Date.now()}`);\n        break;\n      } catch (error) {\n        if (handle) {\n          await handle.close().catch(() => undefined);\n          await fs.unlink(lockPath).catch(() => undefined);\n          handle = undefined;\n        }\n\n        const code = (error as NodeJS.ErrnoException).code;\n        if (code === 'ENOENT') {\n          await fs.mkdir(dir, { recursive: true });\n          continue;\n        }\n        if (code !== 'EEXIST' && code !== 'EPERM') throw error;\n\n        try {\n          const stat = await fs.stat(lockPath);\n          if (Date.now() - stat.mtimeMs > staleMs) {\n            await fs.unlink(lockPath);\n            continue;\n          }\n        } catch {\n          continue;\n        }\n\n        const elapsed = Date.now() - started;\n        if (elapsed >= timeoutMs) {\n          throw createLockTimeoutError({ targetPath, timeoutMs });\n        }\n        await waitForLockRelease(lockPath, timeoutMs - elapsed);\n      }\n    }\n\n    try {\n      return await fn();\n    } finally {\n      await handle?.close().catch(() => undefined);\n      await fs.unlink(lockPath).catch(() => undefined);\n    }\n  }\n\n  return { atomicWrite, ensureDir, withFileLock };\n}\n\nasync function waitForLockRelease(lockPath: string, remainingMs: number): Promise<void> {\n  const parentDir = path.dirname(lockPath);\n  const lockName = path.basename(lockPath);\n  const intervalMs = Math.min(remainingMs, 100);\n\n  return new Promise<void>((resolve) => {\n    let settled = false;\n    let watcher: FSWatcher | null = null;\n    const settle = (): void => {\n      if (settled) return;\n      settled = true;\n      watcher?.close();\n      resolve();\n    };\n    const timer = setTimeout(settle, intervalMs);\n\n    try {\n      watcher = watchDir(parentDir, (eventType, filename) => {\n        if (filename === lockName && (eventType === 'rename' || eventType === 'change')) {\n          clearTimeout(timer);\n          settle();\n        }\n      });\n    } catch {\n      clearTimeout(timer);\n      setTimeout(settle, Math.min(remainingMs, 25));\n      return;\n    }\n\n    void fs.access(lockPath).catch(() => {\n      clearTimeout(timer);\n      settle();\n    });\n  });\n}\n\nconst TRANSIENT_RENAME_CODES = new Set(['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY']);\n\nasync function renameWithRetry(from: string, to: string): Promise<void> {\n  if (process.platform !== 'win32') {\n    await fs.rename(from, to);\n    return;\n  }\n\n  const delays = [10, 25, 60, 120, 250];\n  let lastError: unknown;\n  for (let attempt = 0; attempt <= delays.length; attempt++) {\n    try {\n      await fs.rename(from, to);\n      return;\n    } catch (error) {\n      lastError = error;\n      const code = (error as NodeJS.ErrnoException).code;\n      if (!code || !TRANSIENT_RENAME_CODES.has(code) || attempt === delays.length) throw error;\n      await new Promise((resolve) => setTimeout(resolve, delays[attempt]));\n    }\n  }\n  throw lastError;\n}\n\nconst defaultPrimitives = createPersistencePrimitives();\n\nexport const atomicWrite = defaultPrimitives.atomicWrite;\nexport const ensureDir = defaultPrimitives.ensureDir;\nexport const withFileLock = defaultPrimitives.withFileLock;\n"],
+  "mappings": ";AAAA,SAAS,mBAAmB;AAE5B,SAAS,SAAS,gBAAgB;AAClC,YAAY,QAAQ;AACpB,YAAY,UAAU;AAgCf,IAAM,qBAAN,cAAiC,MAAM;AAAA,EACnC,OAAO;AAAA,EACP;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,MAMT;AACD,UAAM,KAAK,SAAS,EAAE,OAAO,KAAK,MAAM,CAAC;AACzC,SAAK,OAAO,KAAK;AACjB,SAAK,OAAO,KAAK;AACjB,SAAK,UAAU,KAAK;AAAA,EACtB;AACF;AAMO,SAAS,4BACd,UAAuC,CAAC,GACjB;AACvB,QAAM,yBACJ,QAAQ,2BACP,CAAC,EAAE,YAAY,UAAU,MACxB,IAAI,mBAAmB;AAAA,IACrB,SAAS,oCAAoC,UAAU;AAAA,IACvD,MAAM;AAAA,IACN,MAAM;AAAA,IACN,SAAS,EAAE,UAAU;AAAA,EACvB,CAAC;AAEL,iBAAeA,aACb,YACA,SACA,OAA2B,CAAC,GACb;AACf,UAAM,MAAW,aAAQ,UAAU;AACnC,UAAS,SAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACvC,UAAM,MAAW;AAAA,MACf;AAAA,MACA,IAAS,cAAS,UAAU,CAAC,IAAI,YAAY,CAAC,EAAE,SAAS,KAAK,CAAC;AAAA,IACjE;AAEA,QAAI;AACF,UAAI,OAAO,YAAY,UAAU;AAC/B,cAAS,aAAU,KAAK,SAAS,EAAE,MAAM,MAAM,UAAU,KAAK,YAAY,OAAO,CAAC;AAAA,MACpF,OAAO;AACL,cAAS,aAAU,KAAK,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,MACjD;AACA,UAAI;AACF,cAAM,aAAa,MAAS,QAAK,KAAK,IAAI;AAC1C,YAAI;AACF,gBAAM,WAAW,KAAK;AAAA,QACxB,UAAE;AACA,gBAAM,WAAW,MAAM;AAAA,QACzB;AAAA,MACF,QAAQ;AAAA,MAER;AAEA,UAAI;AACJ,UAAI;AACF,cAAMC,QAAO,MAAS,QAAK,UAAU;AACrC,eAAOA,MAAK,OAAO;AAAA,MACrB,QAAQ;AACN,eAAO,KAAK;AAAA,MACd;AACA,UAAI,SAAS,OAAW,OAAS,SAAM,KAAK,IAAI;AAEhD,YAAM,gBAAgB,KAAK,UAAU;AACrC,UAAI,SAAS,UAAa,QAAQ,aAAa,SAAS;AACtD,cAAS,SAAM,YAAY,IAAI,EAAE,MAAM,MAAM,MAAS;AAAA,MACxD;AAAA,IACF,SAAS,OAAO;AACd,YAAS,UAAO,GAAG,EAAE,MAAM,MAAM,MAAS;AAC1C,YAAM;AAAA,IACR;AAAA,EACF;AAEA,iBAAeC,WAAU,KAA4B;AACnD,UAAS,SAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AAAA,EACzC;AAEA,iBAAeC,cACb,YACA,IACA,OAAwB,CAAC,GACb;AACZ,UAAM,MAAW,aAAQ,UAAU;AACnC,UAAM,WAAgB,UAAK,KAAK,IAAS,cAAS,UAAU,CAAC,OAAO;AACpE,UAAM,YAAY,KAAK,aAAa;AACpC,UAAM,UAAU,KAAK,WAAW;AAChC,UAAM,UAAU,KAAK,IAAI;AACzB,QAAI;AAEJ,eAAS;AACP,UAAI;AACF,iBAAS,MAAS,QAAK,UAAU,IAAI;AACrC,cAAM,OAAO,UAAU,GAAG,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC,EAAE;AACrD;AAAA,MACF,SAAS,OAAO;AACd,YAAI,QAAQ;AACV,gBAAM,OAAO,MAAM,EAAE,MAAM,MAAM,MAAS;AAC1C,gBAAS,UAAO,QAAQ,EAAE,MAAM,MAAM,MAAS;AAC/C,mBAAS;AAAA,QACX;AAEA,cAAM,OAAQ,MAAgC;AAC9C,YAAI,SAAS,UAAU;AACrB,gBAAS,SAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACvC;AAAA,QACF;AACA,YAAI,SAAS,YAAY,SAAS,QAAS,OAAM;AAEjD,YAAI;AACF,gBAAMF,QAAO,MAAS,QAAK,QAAQ;AACnC,cAAI,KAAK,IAAI,IAAIA,MAAK,UAAU,SAAS;AACvC,kBAAS,UAAO,QAAQ;AACxB;AAAA,UACF;AAAA,QACF,QAAQ;AACN;AAAA,QACF;AAEA,cAAM,UAAU,KAAK,IAAI,IAAI;AAC7B,YAAI,WAAW,WAAW;AACxB,gBAAM,uBAAuB,EAAE,YAAY,UAAU,CAAC;AAAA,QACxD;AACA,cAAM,mBAAmB,UAAU,YAAY,OAAO;AAAA,MACxD;AAAA,IACF;AAEA,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,UAAE;AACA,YAAM,QAAQ,MAAM,EAAE,MAAM,MAAM,MAAS;AAC3C,YAAS,UAAO,QAAQ,EAAE,MAAM,MAAM,MAAS;AAAA,IACjD;AAAA,EACF;AAEA,SAAO,EAAE,aAAAD,cAAa,WAAAE,YAAW,cAAAC,cAAa;AAChD;AAEA,eAAe,mBAAmB,UAAkB,aAAoC;AACtF,QAAM,YAAiB,aAAQ,QAAQ;AACvC,QAAM,WAAgB,cAAS,QAAQ;AACvC,QAAM,aAAa,KAAK,IAAI,aAAa,GAAG;AAE5C,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,QAAI,UAAU;AACd,QAAI,UAA4B;AAChC,UAAM,SAAS,MAAY;AACzB,UAAI,QAAS;AACb,gBAAU;AACV,eAAS,MAAM;AACf,cAAQ;AAAA,IACV;AACA,UAAM,QAAQ,WAAW,QAAQ,UAAU;AAE3C,QAAI;AACF,gBAAU,SAAS,WAAW,CAAC,WAAW,aAAa;AACrD,YAAI,aAAa,aAAa,cAAc,YAAY,cAAc,WAAW;AAC/E,uBAAa,KAAK;AAClB,iBAAO;AAAA,QACT;AAAA,MACF,CAAC;AAAA,IACH,QAAQ;AACN,mBAAa,KAAK;AAClB,iBAAW,QAAQ,KAAK,IAAI,aAAa,EAAE,CAAC;AAC5C;AAAA,IACF;AAEA,SAAQ,UAAO,QAAQ,EAAE,MAAM,MAAM;AACnC,mBAAa,KAAK;AAClB,aAAO;AAAA,IACT,CAAC;AAAA,EACH,CAAC;AACH;AAEA,IAAM,yBAAyB,oBAAI,IAAI,CAAC,SAAS,SAAS,UAAU,WAAW,CAAC;AAEhF,eAAe,gBAAgB,MAAc,IAA2B;AACtE,MAAI,QAAQ,aAAa,SAAS;AAChC,UAAS,UAAO,MAAM,EAAE;AACxB;AAAA,EACF;AAEA,QAAM,SAAS,CAAC,IAAI,IAAI,IAAI,KAAK,GAAG;AACpC,MAAI;AACJ,WAAS,UAAU,GAAG,WAAW,OAAO,QAAQ,WAAW;AACzD,QAAI;AACF,YAAS,UAAO,MAAM,EAAE;AACxB;AAAA,IACF,SAAS,OAAO;AACd,kBAAY;AACZ,YAAM,OAAQ,MAAgC;AAC9C,UAAI,CAAC,QAAQ,CAAC,uBAAuB,IAAI,IAAI,KAAK,YAAY,OAAO,OAAQ,OAAM;AACnF,YAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,OAAO,OAAO,CAAC,CAAC;AAAA,IACrE;AAAA,EACF;AACA,QAAM;AACR;AAEA,IAAM,oBAAoB,4BAA4B;AAE/C,IAAM,cAAc,kBAAkB;AACtC,IAAM,YAAY,kBAAkB;AACpC,IAAM,eAAe,kBAAkB;",
+  "names": ["atomicWrite", "stat", "ensureDir", "withFileLock"]
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@wrongstack/persistence",
+  "version": "0.295.0",
+  "license": "MIT",
+  "description": "Dependency-free filesystem persistence primitives shared across WrongStack packages.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WrongStack/WrongStack.git",
+    "directory": "packages/persistence"
+  },
+  "homepage": "https://github.com/WrongStack/WrongStack#readme",
+  "bugs": "https://github.com/WrongStack/WrongStack/issues",
+  "author": "ECOSTACK TECHNOLOGY OÜ",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}