@graphrefly/ts 0.0.0

package/dist/storage/node.cjs

@@ -0,0 +1,898 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/node.ts
+var node_exports = {};
+__export(node_exports, {
+  fileAppendLog: () => fileAppendLog,
+  fileBackend: () => fileBackend,
+  fileKv: () => fileKv,
+  sqliteAppendLog: () => sqliteAppendLog,
+  sqliteBackend: () => sqliteBackend,
+  sqliteKv: () => sqliteKv
+});
+module.exports = __toCommonJS(node_exports);
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_module = require("module");
+var import_node_path = require("path");
+
+// src/storage/backend.ts
+var HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function hasStoragePutIfAbsent(backend) {
+  return typeof backend.putIfAbsent === "function";
+}
+function hasStorageVersioned(backend) {
+  return typeof backend.getVersioned === "function" && typeof backend.setIfMatch === "function";
+}
+
+// src/json/codec.ts
+var JS_MIN_NORMAL_NUMBER = 2 ** -1022;
+function assertStableJsonNumber(value, path) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`stableJsonString: non-finite number at ${path}`);
+  }
+}
+function assertStrictJsonNumber(value, path) {
+  assertStableJsonNumber(value, path);
+  if (Object.is(value, -0)) {
+    throw new TypeError(`stableJsonString: non-canonical number at ${path}`);
+  }
+  const abs = Math.abs(value);
+  if (abs > 0 && abs < JS_MIN_NORMAL_NUMBER) {
+    throw new TypeError(`stableJsonString: subnormal number at ${path}`);
+  }
+  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new TypeError(`stableJsonString: integer outside safe range at ${path}`);
+  }
+}
+function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", strictNumbers = false) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (strictNumbers) assertStrictJsonNumber(value, path);
+    else assertStableJsonNumber(value, path);
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`stableJsonString: value at ${path} is not JSON-encodable`);
+  }
+  if (seen.has(value)) throw new TypeError(`stableJsonString: circular reference at ${path}`);
+  const proto = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`stableJsonString: non-plain object at ${path}`);
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+      }
+      for (const key of Object.getOwnPropertyNames(value)) {
+        const isIndex = /^(0|[1-9]\d*)$/.test(key) && Number.isSafeInteger(Number(key)) && Number(key) < value.length;
+        if (key !== "length" && !isIndex) {
+          throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
+        }
+      }
+      const out2 = [];
+      for (let i = 0; i < value.length; i += 1) {
+        if (!(i in value)) {
+          throw new TypeError(`stableJsonString: sparse array hole at ${path}[${i}]`);
+        }
+        out2.push(sortedJsonValue(value[i], seen, `${path}[${i}]`, strictNumbers));
+      }
+      return out2;
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+    }
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortedJsonValue(
+        value[key],
+        seen,
+        `${path}.${key}`,
+        strictNumbers
+      );
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function stableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value));
+}
+function strictStableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value, /* @__PURE__ */ new Set(), "$", true));
+}
+function jsonCodecFor() {
+  const encoder2 = new TextEncoder();
+  const decoder2 = new TextDecoder();
+  return {
+    encode(value) {
+      return encoder2.encode(stableJsonString(value));
+    },
+    decode(bytes) {
+      return JSON.parse(decoder2.decode(bytes));
+    }
+  };
+}
+var jsonCodec = jsonCodecFor();
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function hasUnpairedSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i += 1;
+        continue;
+      }
+      return true;
+    }
+    if (code >= 56320 && code <= 57343) return true;
+  }
+  return false;
+}
+function assertNoUnpairedSurrogates(value, seen = /* @__PURE__ */ new Set(), path = "$") {
+  if (typeof value === "string") {
+    if (hasUnpairedSurrogate(value)) {
+      throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}`);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        assertNoUnpairedSurrogates(value[i], seen, `${path}[${i}]`);
+      }
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      if (hasUnpairedSurrogate(key)) {
+        throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}.${key}`);
+      }
+      assertNoUnpairedSurrogates(value[key], seen, `${path}.${key}`);
+    }
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertNoDuplicateJsonObjectKeys(text) {
+  let index = 0;
+  function fail(message) {
+    throw new TypeError(`strictJsonCodec: ${message}`);
+  }
+  function skipWhitespace() {
+    while (/\s/.test(text[index] ?? "")) index += 1;
+  }
+  function readJsonString() {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      const ch = text[index];
+      if (ch === '"') {
+        index += 1;
+        try {
+          return JSON.parse(text.slice(start, index));
+        } catch {
+          fail("malformed JSON string");
+        }
+      }
+      if (ch === "\\") {
+        index += 2;
+        continue;
+      }
+      index += 1;
+    }
+    fail("unterminated JSON string");
+  }
+  function consumeLiteral(literal) {
+    if (text.slice(index, index + literal.length) !== literal) {
+      fail(`malformed JSON near byte ${index}`);
+    }
+    index += literal.length;
+  }
+  function consumeNumber() {
+    const match = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/.exec(text.slice(index));
+    if (!match) fail(`malformed JSON number near byte ${index}`);
+    index += match[0].length;
+  }
+  function parseValue(path) {
+    skipWhitespace();
+    const ch = text[index];
+    if (ch === "{") {
+      parseObject(path);
+      return;
+    }
+    if (ch === "[") {
+      parseArray(path);
+      return;
+    }
+    if (ch === '"') {
+      readJsonString();
+      return;
+    }
+    if (ch === "t") {
+      consumeLiteral("true");
+      return;
+    }
+    if (ch === "f") {
+      consumeLiteral("false");
+      return;
+    }
+    if (ch === "n") {
+      consumeLiteral("null");
+      return;
+    }
+    if (ch === "-" || ch !== void 0 && ch >= "0" && ch <= "9") {
+      consumeNumber();
+      return;
+    }
+    fail(`malformed JSON near byte ${index}`);
+  }
+  function parseObject(path) {
+    const keys = /* @__PURE__ */ new Set();
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "}") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      skipWhitespace();
+      if (text[index] !== '"') fail(`expected object key near byte ${index}`);
+      const key = readJsonString();
+      if (keys.has(key)) {
+        throw new TypeError(
+          `strictJsonCodec: duplicate object key ${JSON.stringify(key)} at ${path}`
+        );
+      }
+      keys.add(key);
+      skipWhitespace();
+      if (text[index] !== ":") fail(`expected ':' after object key near byte ${index}`);
+      index += 1;
+      parseValue(`${path}.${key}`);
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "}") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or '}' near byte ${index}`);
+    }
+    fail("unterminated JSON object");
+  }
+  function parseArray(path) {
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "]") {
+      index += 1;
+      return;
+    }
+    let item = 0;
+    while (index < text.length) {
+      parseValue(`${path}[${item}]`);
+      item += 1;
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "]") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or ']' near byte ${index}`);
+    }
+    fail("unterminated JSON array");
+  }
+  parseValue("$");
+  skipWhitespace();
+  if (index !== text.length) fail(`trailing JSON token near byte ${index}`);
+}
+function strictJsonCodecFor() {
+  const encoder2 = new TextEncoder();
+  const decoder2 = new TextDecoder("utf-8", { fatal: true });
+  return {
+    encode(value) {
+      assertNoUnpairedSurrogates(value);
+      return encoder2.encode(strictStableJsonString(value));
+    },
+    decode(bytes) {
+      const text = decoder2.decode(bytes);
+      assertNoDuplicateJsonObjectKeys(text);
+      const decoded = JSON.parse(text);
+      assertNoUnpairedSurrogates(decoded);
+      const canonical = encoder2.encode(strictStableJsonString(decoded));
+      if (!bytesEqual(bytes, canonical)) {
+        throw new TypeError("strictJsonCodec: bytes are not canonical stable JSON");
+      }
+      return decoded;
+    }
+  };
+}
+var strictJsonCodec = strictJsonCodecFor();
+
+// src/storage/kv.ts
+function defer(fn) {
+  return Promise.resolve().then(fn);
+}
+function kvStorage(opts) {
+  const codec = opts.codec ?? jsonCodecFor();
+  const { backend } = opts;
+  const tier = {
+    get(key) {
+      return defer(() => backend.get(key)).then(
+        (bytes) => bytes === void 0 ? void 0 : codec.decode(bytes)
+      );
+    },
+    set(key, value) {
+      return defer(() => backend.put(key, codec.encode(value))).then(() => void 0);
+    },
+    delete(key) {
+      return defer(() => backend.delete?.(key)).then(() => void 0);
+    },
+    list(prefix = "") {
+      return defer(() => {
+        if (!backend.list) throw new Error("kvStorage.list: backend does not support listing");
+        return backend.list(prefix);
+      }).then((keys) => [...keys].sort());
+    }
+  };
+  let out = tier;
+  if (hasStoragePutIfAbsent(backend)) {
+    out = {
+      ...out,
+      putIfAbsent(key, value) {
+        return defer(() => backend.putIfAbsent(key, codec.encode(value)));
+      }
+    };
+  }
+  if (hasStorageVersioned(backend)) {
+    out = {
+      ...out,
+      getVersioned(key) {
+        return defer(() => backend.getVersioned(key)).then((result) => {
+          if (result.kind === "miss") return { kind: "miss", generation: result.generation };
+          return {
+            kind: "hit",
+            value: codec.decode(result.value),
+            generation: result.generation
+          };
+        });
+      },
+      setIfMatch(key, value, generation) {
+        return defer(() => backend.setIfMatch(key, codec.encode(value), generation));
+      }
+    };
+  }
+  return out;
+}
+
+// src/storage/append-log.ts
+var APPEND_LOG_SEQ_PAD = 20;
+function appendLogKey(prefix, seq) {
+  if (!Number.isSafeInteger(seq) || seq < 0) {
+    throw new RangeError(`appendLogKey: seq must be a non-negative safe integer, got ${seq}`);
+  }
+  return `${prefix}/${seq.toString().padStart(APPEND_LOG_SEQ_PAD, "0")}`;
+}
+function seqFromKey(prefix, key) {
+  const head = `${prefix}/`;
+  if (!key.startsWith(head)) throw new Error(`append log key outside prefix: ${key}`);
+  const raw = key.slice(head.length);
+  if (!/^\d+$/.test(raw)) {
+    throw new Error(`append log key has a non-numeric sequence: ${key}`);
+  }
+  if (raw.length !== APPEND_LOG_SEQ_PAD) {
+    throw new Error(`append log key sequence must be ${APPEND_LOG_SEQ_PAD} padded digits: ${key}`);
+  }
+  const seq = Number(raw);
+  if (!Number.isSafeInteger(seq)) {
+    throw new Error(`append log key sequence is outside the safe integer range: ${key}`);
+  }
+  return seq;
+}
+function nextSeqFromKeys(prefix, keys) {
+  if (keys.length === 0) return 0;
+  const next = Math.max(...keys.map((key) => seqFromKey(prefix, key))) + 1;
+  if (!Number.isSafeInteger(next)) {
+    throw new RangeError(`append log next sequence is outside the safe integer range: ${prefix}`);
+  }
+  return next;
+}
+function sizeFromKeys(prefix, keys) {
+  for (const key of keys) seqFromKey(prefix, key);
+  return keys.length;
+}
+function validateReadOptions(opts) {
+  const after = opts.after ?? -1;
+  const limit = opts.limit ?? Number.POSITIVE_INFINITY;
+  if (!Number.isSafeInteger(after) || after < -1) {
+    throw new RangeError(
+      `appendLogStorage.read: after must be an integer cursor >= -1, got ${after}`
+    );
+  }
+  if (limit !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(limit) || limit < 0)) {
+    throw new RangeError(
+      `appendLogStorage.read: limit must be a non-negative safe integer or Infinity, got ${limit}`
+    );
+  }
+  return { after, limit };
+}
+function readAppendLogEntries(kv, prefix, opts) {
+  const { after, limit } = validateReadOptions(opts);
+  return kv.list(`${prefix}/`).then((listed) => {
+    const keys = listed.map((key) => ({ key, seq: seqFromKey(prefix, key) })).filter(({ seq }) => seq > after).sort((a, b) => a.seq - b.seq).slice(0, limit);
+    return Promise.all(
+      keys.map(
+        ({ key, seq }) => kv.get(key).then((value) => {
+          if (value === void 0) {
+            throw new Error(`append log listed key is missing: ${key}`);
+          }
+          return { key, seq, value };
+        })
+      )
+    ).then((entries) => {
+      const out = [];
+      for (const entry of entries) if (entry !== void 0) out.push(entry);
+      return out;
+    });
+  });
+}
+function deleteAppendLogEntriesAfter(kv, prefix, seq) {
+  return kv.list(`${prefix}/`).then(
+    (keys) => Promise.all(keys.filter((key) => seqFromKey(prefix, key) > seq).map((key) => kv.delete(key)))
+  ).then(() => kv.list(`${prefix}/`)).then(() => void 0);
+}
+function appendLogStorage(opts) {
+  const { kv, prefix = "event-log" } = opts;
+  let tail = Promise.resolve();
+  function initNextSeq() {
+    return kv.list(`${prefix}/`).then((keys) => {
+      return nextSeqFromKeys(prefix, keys);
+    });
+  }
+  function enqueue(task) {
+    const run = tail.then(task, task);
+    tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  return {
+    append(value) {
+      return enqueue(
+        () => initNextSeq().then((seq) => {
+          const key = appendLogKey(prefix, seq);
+          return kv.set(key, value).then(() => {
+            return { key, seq, value };
+          });
+        })
+      );
+    },
+    read(opts2 = {}) {
+      return enqueue(() => readAppendLogEntries(kv, prefix, opts2));
+    },
+    truncateAfter(seq) {
+      return enqueue(() => deleteAppendLogEntriesAfter(kv, prefix, seq));
+    },
+    size() {
+      return enqueue(() => kv.list(`${prefix}/`).then((keys) => sizeFromKeys(prefix, keys)));
+    }
+  };
+}
+
+// src/storage/node.ts
+var FILE_STEM_PREFIX = "k-";
+var NAMESPACE_SEPARATOR = "\0";
+var SQLITE_GENERATION = /* @__PURE__ */ Symbol("graphrefly.sqliteBackend.generation");
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8", { fatal: true });
+var require2 = (0, import_node_module.createRequire)("/graphrefly-storage-node.js");
+function isErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function keyToStem(key) {
+  let out = "";
+  for (const ch of key) {
+    if (/^[a-zA-Z0-9_-]$/.test(ch)) {
+      out += ch;
+      continue;
+    }
+    for (const byte of encoder.encode(ch)) out += `%${byte.toString(16).padStart(2, "0")}`;
+  }
+  return out;
+}
+function stemToKey(stem) {
+  const bytes = [];
+  let i = 0;
+  while (i < stem.length) {
+    const ch = stem[i];
+    if (ch === "%" && i + 2 < stem.length) {
+      const hex = stem.slice(i + 1, i + 3);
+      if (/^[0-9a-f]{2}$/i.test(hex)) {
+        bytes.push(Number.parseInt(hex, 16));
+        i += 3;
+        continue;
+      }
+    }
+    const code = ch.charCodeAt(0);
+    if (code > 127) return null;
+    bytes.push(code);
+    i += 1;
+  }
+  try {
+    return decoder.decode(new Uint8Array(bytes));
+  } catch {
+    return null;
+  }
+}
+function validateExtension(extension) {
+  if (extension.length < 2 || !extension.startsWith(".") || extension.includes("..") || /[/\\\0]/.test(extension) || !/^[.A-Za-z0-9_-]+$/.test(extension)) {
+    throw new TypeError("fileBackend: extension must be a simple suffix such as .bin");
+  }
+  return extension;
+}
+function validateNamespace(label, namespace) {
+  if (typeof namespace !== "string") {
+    throw new TypeError(`${label}: namespace must be a string`);
+  }
+  if (namespace.includes(NAMESPACE_SEPARATOR)) {
+    throw new TypeError(`${label}: namespace must not contain U+0000`);
+  }
+  return namespace;
+}
+function validateLogicalKey(label, key) {
+  if (typeof key !== "string") {
+    throw new TypeError(`${label}: key must be a string`);
+  }
+  if (key.includes(NAMESPACE_SEPARATOR)) {
+    throw new TypeError(`${label}: key must not contain U+0000`);
+  }
+  return key;
+}
+function validateListPrefix(label, prefix) {
+  if (typeof prefix !== "string") {
+    throw new TypeError(`${label}: list prefix must be a string`);
+  }
+  if (prefix.includes(NAMESPACE_SEPARATOR)) {
+    throw new TypeError(`${label}: list prefix must not contain U+0000`);
+  }
+  return prefix;
+}
+function validateSqliteTableName(tableName) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName)) {
+    throw new TypeError("sqliteBackend: tableName must be a simple SQLite identifier");
+  }
+  return tableName;
+}
+function sqliteGeneration(storageId, key, rowGeneration, epoch) {
+  return Object.freeze({
+    [SQLITE_GENERATION]: Object.freeze([storageId, key, rowGeneration, epoch])
+  });
+}
+function readSqliteGeneration(generation) {
+  if (typeof generation !== "object" || generation === null) return void 0;
+  const maybe = generation;
+  const token = maybe[SQLITE_GENERATION];
+  if (Array.isArray(token) && token.length === 4 && typeof token[0] === "object" && token[0] !== null && typeof token[1] === "string" && (token[2] === null || typeof token[2] === "number") && typeof token[3] === "number") {
+    return token;
+  }
+  return void 0;
+}
+function sqliteChanges(result) {
+  return typeof result === "object" && result !== null && "changes" in result && typeof result.changes === "number" ? result.changes : 0;
+}
+function sqliteBytes(value) {
+  return Uint8Array.from(value instanceof Uint8Array ? value : new Uint8Array(value));
+}
+function loadSqliteDatabaseSync() {
+  try {
+    const DatabaseSync = require2("node:sqlite").DatabaseSync;
+    if (typeof DatabaseSync !== "function") {
+      throw new TypeError("DatabaseSync export is missing");
+    }
+    return DatabaseSync;
+  } catch (error) {
+    throw new Error("sqliteBackend: node:sqlite is not available in this Node runtime", {
+      cause: error
+    });
+  }
+}
+function fileBackend(dir, opts = {}) {
+  const extension = validateExtension(opts.extension ?? ".bin");
+  const namespace = opts.namespace === void 0 ? "" : validateNamespace("fileBackend", opts.namespace);
+  const namespacePrefix = namespace.length > 0 ? `${namespace}${NAMESPACE_SEPARATOR}` : "";
+  const storageKey = (key) => `${namespacePrefix}${validateLogicalKey("fileBackend", key)}`;
+  const pathFor = (key) => (0, import_node_path.join)(dir, `${FILE_STEM_PREFIX}${keyToStem(storageKey(key))}${extension}`);
+  const keyFromFilename = (filename) => {
+    if (!filename.endsWith(extension)) return null;
+    const stem = filename.slice(0, -extension.length);
+    if (!stem.startsWith(FILE_STEM_PREFIX)) return null;
+    const key = stemToKey(stem.slice(FILE_STEM_PREFIX.length));
+    if (key === null || !key.startsWith(namespacePrefix)) return null;
+    const logical = key.slice(namespacePrefix.length);
+    if (logical.includes(NAMESPACE_SEPARATOR)) {
+      throw new TypeError("fileBackend: malformed stored key");
+    }
+    return logical;
+  };
+  return {
+    get(key) {
+      try {
+        return Uint8Array.from((0, import_node_fs.readFileSync)(pathFor(key)));
+      } catch (error) {
+        if (isErrno(error, "ENOENT")) return void 0;
+        throw error;
+      }
+    },
+    put(key, value) {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+      const filePath = pathFor(key);
+      const base = (0, import_node_path.basename)(filePath);
+      const parent = (0, import_node_path.dirname)(filePath);
+      const tmp = (0, import_node_path.join)(parent, `.${base}.${(0, import_node_crypto.randomBytes)(8).toString("hex")}.tmp`);
+      try {
+        (0, import_node_fs.writeFileSync)(tmp, value);
+        (0, import_node_fs.renameSync)(tmp, filePath);
+      } catch (error) {
+        try {
+          (0, import_node_fs.unlinkSync)(tmp);
+        } catch {
+        }
+        throw error;
+      }
+    },
+    putIfAbsent(key, value) {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+      const filePath = pathFor(key);
+      let fd;
+      try {
+        fd = (0, import_node_fs.openSync)(filePath, "wx");
+        (0, import_node_fs.writeFileSync)(fd, value);
+        return true;
+      } catch (error) {
+        if (isErrno(error, "EEXIST")) return false;
+        if (fd !== void 0) {
+          try {
+            (0, import_node_fs.unlinkSync)(filePath);
+          } catch {
+          }
+        }
+        throw error;
+      } finally {
+        if (fd !== void 0) (0, import_node_fs.closeSync)(fd);
+      }
+    },
+    delete(key) {
+      try {
+        (0, import_node_fs.unlinkSync)(pathFor(key));
+      } catch (error) {
+        if (!isErrno(error, "ENOENT")) throw error;
+      }
+    },
+    list(prefix = "") {
+      const validatedPrefix = validateListPrefix("fileBackend", prefix);
+      let entries;
+      try {
+        entries = (0, import_node_fs.readdirSync)(dir);
+      } catch (error) {
+        if (isErrno(error, "ENOENT")) return [];
+        throw error;
+      }
+      const keys = [];
+      for (const entry of entries) {
+        if (entry.startsWith(".")) continue;
+        const key = keyFromFilename(entry);
+        if (key?.startsWith(validatedPrefix)) keys.push(key);
+      }
+      return keys.sort();
+    }
+  };
+}
+function fileKv(dir, opts = {}) {
+  return kvStorage({
+    backend: fileBackend(dir, opts),
+    codec: opts.codec
+  });
+}
+function fileAppendLog(dir, opts = {}) {
+  return appendLogStorage({
+    kv: fileKv(dir, opts),
+    prefix: opts.prefix ?? "event-log"
+  });
+}
+function sqliteBackend(path, opts = {}) {
+  const table = validateSqliteTableName(opts.tableName ?? "graphrefly_storage");
+  const metaTable = validateSqliteTableName(`${table}_meta`);
+  const namespace = opts.namespace === void 0 ? "" : validateNamespace("sqliteBackend", opts.namespace);
+  const DatabaseSync = loadSqliteDatabaseSync();
+  const namespacePrefix = namespace.length > 0 ? `${namespace}${NAMESPACE_SEPARATOR}` : "";
+  const storageKey = (key) => `${namespacePrefix}${validateLogicalKey("sqliteBackend", key)}`;
+  const storageId = Object.freeze({});
+  const logicalKey = (key) => {
+    if (typeof key !== "string") {
+      throw new TypeError("sqliteBackend: stored key is corrupt");
+    }
+    if (!key.startsWith(namespacePrefix)) return void 0;
+    const logical = key.slice(namespacePrefix.length);
+    if (logical.includes(NAMESPACE_SEPARATOR)) {
+      throw new TypeError("sqliteBackend: malformed stored key");
+    }
+    return logical;
+  };
+  const db = new DatabaseSync(path);
+  db.exec(
+    `CREATE TABLE IF NOT EXISTS ${table} (k TEXT PRIMARY KEY, v BLOB NOT NULL, g INTEGER NOT NULL DEFAULT 0)`
+  );
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (!columns.some((column) => column.name === "g")) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN g INTEGER NOT NULL DEFAULT 0`);
+  }
+  db.exec(`CREATE TABLE IF NOT EXISTS ${metaTable} (k TEXT PRIMARY KEY, v INTEGER NOT NULL)`);
+  db.exec(`
+		CREATE TRIGGER IF NOT EXISTS ${table}_generation_insert
+		AFTER INSERT ON ${table}
+		BEGIN
+			INSERT INTO ${metaTable} (k, v) VALUES (NEW.k, 1)
+			ON CONFLICT(k) DO UPDATE SET v = ${metaTable}.v + 1;
+		END
+	`);
+  db.exec(`
+		CREATE TRIGGER IF NOT EXISTS ${table}_generation_update
+		AFTER UPDATE ON ${table}
+		BEGIN
+			INSERT INTO ${metaTable} (k, v) VALUES (NEW.k, 1)
+			ON CONFLICT(k) DO UPDATE SET v = ${metaTable}.v + 1;
+		END
+	`);
+  db.exec(`
+		CREATE TRIGGER IF NOT EXISTS ${table}_generation_delete
+		AFTER DELETE ON ${table}
+		BEGIN
+			INSERT INTO ${metaTable} (k, v) VALUES (OLD.k, 1)
+			ON CONFLICT(k) DO UPDATE SET v = ${metaTable}.v + 1;
+		END
+	`);
+  const keyEpoch = (key) => {
+    const row = db.prepare(`SELECT v FROM ${metaTable} WHERE k = ?`).get(key);
+    const value = row?.v ?? 0;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+      throw new Error("sqliteBackend: per-key generation epoch is corrupt");
+    }
+    return value;
+  };
+  const readRow = (key) => {
+    const row = db.prepare(`SELECT v, g FROM ${table} WHERE k = ?`).get(storageKey(key));
+    if (row?.v === void 0) return void 0;
+    const generation = row.g;
+    if (typeof generation !== "number" || !Number.isSafeInteger(generation) || generation < 0) {
+      throw new Error("sqliteBackend: row generation is corrupt");
+    }
+    return { value: sqliteBytes(row.v), generation };
+  };
+  return {
+    name: `sqlite:${path}/${table}`,
+    get(key) {
+      return readRow(key)?.value;
+    },
+    put(key, value) {
+      db.prepare(
+        `INSERT INTO ${table} (k, v, g) VALUES (?, ?, 0) ON CONFLICT(k) DO UPDATE SET v = excluded.v, g = ${table}.g + 1`
+      ).run(storageKey(key), value);
+    },
+    putIfAbsent(key, value) {
+      const result = db.prepare(`INSERT OR IGNORE INTO ${table} (k, v, g) VALUES (?, ?, 0)`).run(storageKey(key), value);
+      return sqliteChanges(result) === 1;
+    },
+    getVersioned(key) {
+      const row = readRow(key);
+      if (row === void 0) {
+        return {
+          kind: "miss",
+          generation: sqliteGeneration(storageId, storageKey(key), null, keyEpoch(storageKey(key)))
+        };
+      }
+      return {
+        kind: "hit",
+        value: row.value,
+        generation: sqliteGeneration(
+          storageId,
+          storageKey(key),
+          row.generation,
+          keyEpoch(storageKey(key))
+        )
+      };
+    },
+    setIfMatch(key, value, generation) {
+      const keyForStorage = storageKey(key);
+      const observed = readSqliteGeneration(generation);
+      if (observed === void 0 || observed[0] !== storageId || observed[1] !== keyForStorage) {
+        return false;
+      }
+      if (observed[2] === null) {
+        return sqliteChanges(
+          db.prepare(
+            `INSERT INTO ${table} (k, v, g) SELECT ?, ?, 0 WHERE COALESCE((SELECT v FROM ${metaTable} WHERE k = ?), 0) = ? AND NOT EXISTS (SELECT 1 FROM ${table} WHERE k = ?)`
+          ).run(keyForStorage, value, keyForStorage, observed[3], keyForStorage)
+        ) === 1;
+      }
+      return sqliteChanges(
+        db.prepare(
+          `UPDATE ${table} SET v = ?, g = g + 1 WHERE k = ? AND g = ? AND COALESCE((SELECT v FROM ${metaTable} WHERE k = ?), 0) = ?`
+        ).run(value, keyForStorage, observed[2], keyForStorage, observed[3])
+      ) === 1;
+    },
+    delete(key) {
+      db.prepare(`DELETE FROM ${table} WHERE k = ?`).run(storageKey(key));
+    },
+    list(prefix = "") {
+      const validatedPrefix = validateListPrefix("sqliteBackend", prefix);
+      const rows = db.prepare(`SELECT k FROM ${table} ORDER BY k`).all();
+      const out = [];
+      for (const row of rows) {
+        const key = logicalKey(row.k);
+        if (key?.startsWith(validatedPrefix)) out.push(key);
+      }
+      return out.sort();
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+function sqliteKv(path, opts = {}) {
+  const backend = sqliteBackend(path, opts);
+  const tier = kvStorage({
+    backend,
+    codec: opts.codec
+  });
+  return Object.assign(tier, { close: () => backend.close() });
+}
+function sqliteAppendLog(path, opts = {}) {
+  const kv = sqliteKv(path, opts);
+  const log = appendLogStorage({ kv, prefix: opts.prefix ?? "event-log" });
+  return Object.assign(log, { close: () => kv.close() });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileAppendLog,
+  fileBackend,
+  fileKv,
+  sqliteAppendLog,
+  sqliteBackend,
+  sqliteKv
+});
+//# sourceMappingURL=node.cjs.map