@wrongstack/persistence 0.309.0 → 0.310.0

package/dist/atomic-write.d.ts

@@ -40,6 +40,7 @@ export declare class PersistenceFsError extends Error {
  */
 export declare function createPersistencePrimitives(options?: PersistencePrimitiveOptions): PersistencePrimitives;
 export declare const atomicWrite: (targetPath: string, content: string | Uint8Array, opts?: AtomicWriteOptions) => Promise<void>;
+export declare const atomicReplaceWithWriter: <T>(targetPath: string, write: (handle: fs.FileHandle) => Promise<T>, opts?: AtomicWriteOptions) => Promise<T>;
 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/index.d.ts

@@ -2,4 +2,5 @@ export * from './atomic-write.js';
 export * from './file-permissions.js';
 export * from './project-endpoint.js';
 export * from './socket-path.js';
+export * from './sqlite-runtime.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -61,10 +61,18 @@ function createPersistencePrimitives(options = {}) {
     await fs.mkdir(path.dirname(targetPath), { recursive: true });
     const tmp = tempPathFor(targetPath);
     try {
+      const createMode = opts.mode;
       if (typeof content === "string") {
-        await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+        await fs.writeFile(tmp, content, {
+          flag: "wx",
+          encoding: opts.encoding ?? "utf8",
+          ...createMode !== void 0 ? { mode: createMode } : {}
+        });
       } else {
-        await fs.writeFile(tmp, content, { flag: "wx" });
+        await fs.writeFile(tmp, content, {
+          flag: "wx",
+          ...createMode !== void 0 ? { mode: createMode } : {}
+        });
       }
       await commitTemp(tmp, targetPath, opts);
     } catch (error) {
@@ -72,11 +80,11 @@ function createPersistencePrimitives(options = {}) {
       throw error;
     }
   }
-  async function atomicReplaceWithWriter(targetPath, write, opts = {}) {
+  async function atomicReplaceWithWriter2(targetPath, write, opts = {}) {
     await fs.mkdir(path.dirname(targetPath), { recursive: true });
     const tmp = tempPathFor(targetPath);
     try {
-      const handle = await fs.open(tmp, "wx");
+      const handle = await fs.open(tmp, "wx", opts.mode);
       let result;
       try {
         result = await write(handle);
@@ -127,7 +135,9 @@ function createPersistencePrimitives(options = {}) {
           await retryAfterBackoff();
           continue;
         }
-        if (code !== "EEXIST" && code !== "EPERM") throw error;
+        if (code !== "EEXIST" && code !== "EPERM" && code !== "EACCES" && code !== "EBUSY") {
+          throw error;
+        }
         try {
           const stat2 = await fs.stat(lockPath);
           if (Date.now() - stat2.mtimeMs > staleMs) {
@@ -163,7 +173,7 @@ function createPersistencePrimitives(options = {}) {
       await fs.unlink(lockPath).catch(() => void 0);
     }
   }
-  return { atomicWrite: atomicWrite2, atomicReplaceWithWriter, ensureDir: ensureDir2, withFileLock: withFileLock2 };
+  return { atomicWrite: atomicWrite2, atomicReplaceWithWriter: atomicReplaceWithWriter2, ensureDir: ensureDir2, withFileLock: withFileLock2 };
 }
 async function waitForLockRelease(lockPath, remainingMs) {
   const parentDir = path.dirname(lockPath);
@@ -243,6 +253,7 @@ async function renameWithRetry(from, to) {
 }
 var defaultPrimitives = createPersistencePrimitives();
 var atomicWrite = defaultPrimitives.atomicWrite;
+var atomicReplaceWithWriter = defaultPrimitives.atomicReplaceWithWriter;
 var ensureDir = defaultPrimitives.ensureDir;
 var withFileLock = defaultPrimitives.withFileLock;
 
@@ -424,17 +435,67 @@ async function bindProjectEndpoint(options) {
     )
   };
 }
+
+// src/sqlite-runtime.ts
+import { createRequire } from "node:module";
+function databaseSyncFromNode(module) {
+  if (typeof module !== "object" || module === null || !("DatabaseSync" in module)) return null;
+  return typeof module.DatabaseSync === "function" ? module.DatabaseSync : null;
+}
+function databaseSyncFromBun(module) {
+  if (typeof module !== "object" || module === null || !("Database" in module)) return null;
+  if (typeof module.Database !== "function") return null;
+  const BunDatabase = module.Database;
+  function BunDatabaseSync(filename, options) {
+    const bunOptions = options?.readOnly ? { readonly: true, create: false, readwrite: false } : void 0;
+    return new BunDatabase(filename, bunOptions);
+  }
+  return BunDatabaseSync;
+}
+function loadRuntimeDatabaseSync(loadModule = createRequire(import.meta.url)) {
+  let nodeError;
+  try {
+    const Database = databaseSyncFromNode(loadModule("node:sqlite"));
+    if (Database) return Database;
+    nodeError = new Error("node:sqlite did not export DatabaseSync");
+  } catch (error) {
+    nodeError = error;
+  }
+  let bunError;
+  try {
+    const Database = databaseSyncFromBun(loadModule("bun:sqlite"));
+    if (Database) return Database;
+    bunError = new Error("bun:sqlite did not export Database");
+  } catch (error) {
+    bunError = error;
+  }
+  const describe = (error) => error instanceof Error ? error.message : String(error);
+  throw new Error(
+    `No supported synchronous SQLite runtime is available (node:sqlite: ${describe(nodeError)}; bun:sqlite: ${describe(bunError)}).`
+  );
+}
+function isRuntimeSqliteAvailable(loadModule) {
+  try {
+    loadRuntimeDatabaseSync(loadModule);
+    return true;
+  } catch {
+    return false;
+  }
+}
 export {
   PersistenceFsError,
   SECRET_DIR_MODE,
   SECRET_FILE_MODE,
   assertUnixSocketPathWithinLimit,
+  atomicReplaceWithWriter,
   atomicWrite,
   bindProjectEndpoint,
   checkUnixSocketPath,
   createPersistencePrimitives,
   ensureDir,
   isProjectEndpointLive,
+  isRuntimeSqliteAvailable,
+  loadRuntimeDatabaseSync,
   restrictDirPermissions,
   restrictFilePermissions,
   unixSocketPathLimit,

package/dist/sqlite-runtime.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseSync } from 'node:sqlite';
+type DatabaseSyncConstructor = typeof DatabaseSync;
+type ModuleLoader = (specifier: string) => unknown;
+/**
+ * Resolve the synchronous SQLite constructor for the active JavaScript runtime.
+ * Node uses `node:sqlite`; Bun uses a small constructor adapter over `bun:sqlite`.
+ * The SQL surface WrongStack relies on (`exec`, `prepare`, `get`, `all`, `run`,
+ * and `close`) is shared by both implementations.
+ */
+export declare function loadRuntimeDatabaseSync(loadModule?: ModuleLoader): DatabaseSyncConstructor;
+export declare function isRuntimeSqliteAvailable(loadModule?: ModuleLoader): boolean;
+export {};
+//# sourceMappingURL=sqlite-runtime.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/persistence",
-  "version": "0.309.0",
+  "version": "0.310.0",
   "license": "MIT",
   "description": "Dependency-free filesystem persistence primitives shared across WrongStack packages.",
   "repository": {
@@ -35,7 +35,7 @@
   },
   "scripts": {
     "build": "node ../../scripts/build-package.mjs",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
     "test": "vitest run --config vitest.config.ts",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   }