@tobq/boardclip 0.0.0-stage → 2.1.108

package/lib/backup.js

@@ -0,0 +1,275 @@
+'use strict';
+
+// Content-addressed local backup store (the "logic-bug time-machine").
+//
+// A backup is a point-in-time snapshot of the clipboard history + settings. The
+// naive design copied the WHOLE history JSON (~4-5MB) on every change, so an edit
+// to one note re-stored thousands of unchanged items. This store instead keeps a
+// content-addressed OBJECT POOL: each stored item (and the settings object) is
+// written once under its sha256, and a snapshot is just a small MANIFEST listing
+// the ordered item hashes. Unchanged items across snapshots share one blob, so a
+// snapshot after editing one note costs ~one item + a manifest, not a full copy.
+//
+// Everything stays PLAIN-TEXT JSON on disk (objects and manifests) so a backup is
+// still greppable/inspectable during an incident. Reuses lib/blob-store for the
+// atomic write + dir helpers and lib/retention (planRetention) for eviction.
+//
+// Layout under `baseDir` (e.g. clipboard-backups/):
+//   objects/{sha256}.json            one stored item, or the settings object
+//   snapshots/{stamp}-{reason}.json  manifest { items:[hash], settings:hash, ... }
+//   {stamp}-{reason}-{hash12}.json   LEGACY full snapshots (read-only, age out)
+//
+// This module is deliberately filesystem-real but dependency-light: pass a baseDir
+// and (optionally) `now`, so it's testable against a temp dir.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const blobStore = require('./blob-store');
+const { planRetention } = require('./retention');
+
+const OBJECTS_DIRNAME = 'objects';
+const SNAPSHOTS_DIRNAME = 'snapshots';
+const OBJECT_RE = /^[a-f0-9]{64}\.json$/i;
+const MANIFEST_RE = /\.json$/i;
+// Legacy full-snapshot filenames: {ISO-stamp}-{reason}-{hash12}.json in baseDir.
+const LEGACY_RE = /^\d{4}-\d{2}-\d{2}T[\dhZ.-]*-[a-z]+-[a-f0-9]{6,}\.json$/i;
+
+function sha256Hex(str) {
+  return crypto.createHash('sha256').update(str).digest('hex');
+}
+
+// Deterministic JSON (recursively sorted object keys) so two equal items always
+// serialize to the same bytes and therefore hash to the same object.
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    const keys = Object.keys(value).sort();
+    return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(',')}}`;
+  }
+  return JSON.stringify(value === undefined ? null : value);
+}
+
+function objectsDir(baseDir) { return path.join(baseDir, OBJECTS_DIRNAME); }
+function snapshotsDir(baseDir) { return path.join(baseDir, SNAPSHOTS_DIRNAME); }
+
+function objectPath(baseDir, hash) {
+  return path.join(objectsDir(baseDir), `${hash}.json`);
+}
+
+// In-memory index of the pool's hashes per baseDir, seeded ONCE from a readdir
+// of objects/ (one syscall for the whole pool). The previous existsSync-per-item
+// check was a ~10k-stat storm on every snapshot of a mature history (~0.8s of
+// the 0.9s a no-change snapshot cost, measured 2026-09-02). GC invalidates the
+// index for its baseDir so a re-referenced object is re-written, never assumed.
+const poolIndex = new Map();
+function knownHashes(baseDir) {
+  let set = poolIndex.get(baseDir);
+  if (!set) {
+    set = new Set();
+    let names = [];
+    try { names = fs.readdirSync(objectsDir(baseDir)); } catch {}
+    for (const name of names) {
+      if (OBJECT_RE.test(name)) set.add(name.slice(0, -'.json'.length).toLowerCase());
+    }
+    poolIndex.set(baseDir, set);
+  }
+  return set;
+}
+
+// Write `value` into the pool iff its content isn't already there; return its hash.
+function putObject(baseDir, value) {
+  const json = stableStringify(value);
+  const hash = sha256Hex(json);
+  const known = knownHashes(baseDir);
+  if (!known.has(hash)) {
+    blobStore.ensureDir(objectsDir(baseDir));
+    blobStore.atomicWriteFile(objectPath(baseDir, hash), json);
+    known.add(hash);
+  }
+  return hash;
+}
+
+function getObject(baseDir, hash) {
+  try { return JSON.parse(fs.readFileSync(objectPath(baseDir, hash), 'utf8')); }
+  catch { return null; }
+}
+
+function toIso(createdAt) {
+  if (createdAt instanceof Date) return createdAt.toISOString();
+  const d = new Date(createdAt || Date.now());
+  return Number.isNaN(d.getTime()) ? new Date().toISOString() : d.toISOString();
+}
+
+// Write a content-addressed snapshot. Returns { manifestPath, manifest }.
+function writeSnapshot(baseDir, { history, settings = null, reason = 'periodic', createdAt = new Date(), source = {} } = {}) {
+  const items = (Array.isArray(history) ? history : []).map(item => putObject(baseDir, item));
+  const settingsHash = settings != null ? putObject(baseDir, settings) : null;
+  const iso = toIso(createdAt);
+  const manifest = {
+    version: 1,
+    createdAt: iso,
+    reason,
+    source,
+    count: items.length,
+    settings: settingsHash,
+    items,
+  };
+  const dir = snapshotsDir(baseDir);
+  blobStore.ensureDir(dir);
+  const stamp = iso.replace(/[:.]/g, '-');
+  const manifestPath = path.join(dir, `${stamp}-${reason}.json`);
+  blobStore.atomicWriteFile(manifestPath, JSON.stringify(manifest));
+  return { manifestPath, manifest };
+}
+
+function readManifestFile(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+// Reconstruct a snapshot's full { createdAt, reason, history, settings } from either
+// a new manifest (items are hashes → resolve from the pool) or a legacy full file
+// (history/settings inline). Accepts a manifest path or a parsed manifest object.
+function readSnapshot(baseDir, manifestOrPath) {
+  const manifest = typeof manifestOrPath === 'string' ? readManifestFile(manifestOrPath) : manifestOrPath;
+  if (!manifest || typeof manifest !== 'object') return null;
+
+  // Legacy full snapshot: history already inline.
+  if (Array.isArray(manifest.history)) {
+    return {
+      createdAt: manifest.createdAt || null,
+      reason: manifest.reason || 'legacy',
+      history: manifest.history,
+      settings: manifest.settings && typeof manifest.settings === 'object' ? manifest.settings : null,
+    };
+  }
+
+  // New manifest: resolve item hashes + settings hash from the pool.
+  const items = Array.isArray(manifest.items) ? manifest.items : [];
+  const history = items.map(hash => getObject(baseDir, hash)).filter(v => v != null);
+  const settings = manifest.settings ? getObject(baseDir, manifest.settings) : null;
+  return {
+    createdAt: manifest.createdAt || null,
+    reason: manifest.reason || 'periodic',
+    history,
+    settings,
+  };
+}
+
+// Enumerate snapshot descriptors (new manifests + legacy full files), newest first.
+function listSnapshots(baseDir) {
+  const out = [];
+  // New manifests.
+  try {
+    for (const name of fs.readdirSync(snapshotsDir(baseDir))) {
+      if (!MANIFEST_RE.test(name)) continue;
+      const filePath = path.join(snapshotsDir(baseDir), name);
+      try {
+        const st = fs.statSync(filePath);
+        out.push({ path: filePath, name, mtimeMs: st.mtimeMs, size: st.size, legacy: false });
+      } catch {}
+    }
+  } catch {}
+  // Legacy full snapshots in baseDir.
+  try {
+    for (const name of fs.readdirSync(baseDir)) {
+      if (!LEGACY_RE.test(name)) continue;
+      const filePath = path.join(baseDir, name);
+      try {
+        const st = fs.statSync(filePath);
+        if (st.isFile()) out.push({ path: filePath, name, mtimeMs: st.mtimeMs, size: st.size, legacy: true });
+      } catch {}
+    }
+  } catch {}
+  out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out;
+}
+
+// Set of object hashes referenced by the given manifest descriptors.
+function referencedHashes(baseDir, descriptors) {
+  const refs = new Set();
+  for (const d of descriptors) {
+    if (d.legacy) continue; // legacy files carry their own content, reference no pool objects
+    const manifest = readManifestFile(d.path);
+    if (!manifest) continue;
+    for (const h of Array.isArray(manifest.items) ? manifest.items : []) refs.add(h);
+    if (manifest.settings) refs.add(manifest.settings);
+  }
+  return refs;
+}
+
+// Delete pool objects not referenced by any surviving manifest. Returns freed count.
+function gcObjects(baseDir, survivors) {
+  const refs = referencedHashes(baseDir, survivors);
+  let freed = 0;
+  let names = [];
+  try { names = fs.readdirSync(objectsDir(baseDir)); } catch { return 0; }
+  for (const name of names) {
+    if (!OBJECT_RE.test(name)) continue;
+    const hash = name.slice(0, -'.json'.length).toLowerCase();
+    if (refs.has(hash)) continue;
+    try { fs.rmSync(path.join(objectsDir(baseDir), name), { force: true }); freed++; } catch {}
+  }
+  poolIndex.delete(baseDir); // objects vanished: re-seed lazily on the next putObject
+  return freed;
+}
+
+function totalBytes(baseDir) {
+  return blobStore.directoryBytes(objectsDir(baseDir))
+    + blobStore.directoryBytes(snapshotsDir(baseDir))
+    + blobStore.directoryBytes(baseDir); // legacy files live directly in baseDir
+}
+
+// Object GC reads every surviving manifest, so on the save hot path it must not run
+// on every prune. Throttle it: the cheap part (manifest eviction) always runs; the
+// full-scan GC + size enforcement runs only when something was actually evicted (so
+// orphans are possible) and the throttle has elapsed, OR when the byte cap is exceeded.
+// Orphaned objects between GCs are tiny (a changed item each) and harmless.
+const lastGcByBase = new Map();
+
+// Prune snapshots by age + count, GC unreferenced objects, then enforce a size
+// ceiling by dropping the oldest surviving snapshots (re-GC) until under maxBytes.
+function pruneBackups(baseDir, { maxAgeMs, maxBytes, maxManifests, now = Date.now(), gcMinIntervalMs = 0 } = {}) {
+  let survivors = listSnapshots(baseDir);
+
+  // 1. age + count eviction (planRetention is oldest-first LRU by mtime). Cheap:
+  //    listSnapshots only stats files, and eviction is stat+unlink — no manifest reads.
+  const evicted = planRetention(
+    survivors.map(s => ({ ...s, filePath: s.path })),
+    { maxAgeMs, maxFiles: maxManifests, now },
+  );
+  const evictedPaths = new Set(evicted.map(e => e.filePath));
+  for (const e of evicted) { try { fs.rmSync(e.filePath, { force: true }); } catch {} }
+  survivors = survivors.filter(s => !evictedPaths.has(s.path));
+
+  const overSize = maxBytes != null && totalBytes(baseDir) > maxBytes;
+  const gcDue = (now - (lastGcByBase.get(baseDir) || 0)) >= gcMinIntervalMs;
+  if (!((evictedPaths.size > 0 && gcDue) || overSize)) return;
+
+  // 2. GC objects no longer referenced by a surviving manifest.
+  gcObjects(baseDir, survivors);
+  lastGcByBase.set(baseDir, now);
+
+  // 3. size ceiling: drop oldest survivors until total is under maxBytes.
+  if (maxBytes != null) {
+    survivors.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
+    while (survivors.length > 1 && totalBytes(baseDir) > maxBytes) {
+      const oldest = survivors.shift();
+      try { fs.rmSync(oldest.path, { force: true }); } catch {}
+      gcObjects(baseDir, survivors);
+    }
+  }
+}
+
+module.exports = {
+  stableStringify,
+  sha256Hex,
+  putObject,
+  getObject,
+  writeSnapshot,
+  readSnapshot,
+  listSnapshots,
+  pruneBackups,
+  OBJECTS_DIRNAME,
+  SNAPSHOTS_DIRNAME,
+};

package/lib/blob-field-store.js

@@ -0,0 +1,275 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const blobStore = require('./blob-store');
+const clipboardModel = require('./clipboard-model');
+
+const DEFAULT_THRESHOLD_BYTES = 64 * 1024;
+
+// ONE content-addressed blob store, instantiated once per clipboard payload
+// FIELD (text, html, rtf). Hashing, atomic writes, hydrate, externalize-above-
+// threshold, sync filtering and unreferenced cleanup live here exactly once, so
+// a fourth clipboard format is a config object rather than a fourth copy of the
+// mechanics. lib/blob-store.js still owns the raw file primitives.
+//
+// The one real behavioural axis is PREVIEW, and it is not cosmetic:
+//   text  (previewChars > 0) keeps a truncated preview, so a missing blob still
+//         renders something in the list and the user does not see an empty clip.
+//   html/rtf (previewChars = 0) must NOT. A truncated markup payload is worse
+//         than none — unbalanced tags and broken RTF groups paste as visible
+//         garbage — so a missing rich blob degrades to ABSENT, which makes the
+//         paste fall back to plain text. That is the correct failure direction.
+//
+// dropWhenEmpty removes the field entirely when there is nothing to store, so
+// every plain-text clip in the history file does not grow two empty strings.
+function makeBlobFieldStore(config) {
+  const field = String(config.field || '');
+  const dirname = String(config.dirname || '');
+  const ext = String(config.ext || '');
+  const previewChars = Number(config.previewChars) || 0;
+  const dropWhenEmpty = !!config.dropWhenEmpty;
+  const defaultThreshold = Number(config.thresholdBytes) || DEFAULT_THRESHOLD_BYTES;
+  const names = clipboardModel.blobFieldNames(field);
+  const REF_RE = new RegExp(`^[a-f0-9]{64}\\.${ext}$`, 'i');
+  const MISSING_FLAG = `__${field}BlobMissing`;
+  const LOADED_FLAG = `__${field}BlobLoaded`;
+
+  function refForHash(hash) {
+    const normalized = String(hash || '').trim().toLowerCase();
+    return /^[a-f0-9]{64}$/.test(normalized) ? `${normalized}.${ext}` : '';
+  }
+
+  function safeRef(ref) {
+    const value = path.basename(String(ref || '').trim());
+    return REF_RE.test(value) ? value.toLowerCase() : '';
+  }
+
+  // Every path helper refuses a falsy baseDir. Without this a missing directory
+  // would make path.join('', ref) resolve to a RELATIVE path and read or write
+  // blobs next to the process cwd.
+  function pathForRef(baseDir, ref) {
+    if (!baseDir) return '';
+    const safe = safeRef(ref);
+    return safe ? path.join(baseDir, safe) : '';
+  }
+
+  function preview(value) {
+    return previewChars ? String(value || '').slice(0, previewChars) : '';
+  }
+
+  function byteLength(value) {
+    return Buffer.byteLength(String(value || ''), 'utf8');
+  }
+
+  function markRuntime(item, key, value) {
+    Object.defineProperty(item, key, {
+      value,
+      writable: true,
+      configurable: true,
+      enumerable: false,
+    });
+  }
+
+  function clearRuntimeFlags(item) {
+    try { delete item[MISSING_FLAG]; } catch {}
+    try { delete item[LOADED_FLAG]; } catch {}
+  }
+
+  function clearMetadata(copy) {
+    delete copy[names.hash];
+    delete copy[names.ref];
+    delete copy[names.size];
+    delete copy[names.preview];
+  }
+
+  function setValue(target, value) {
+    if (dropWhenEmpty && !value) delete target[names.value];
+    else target[names.value] = value;
+  }
+
+  function writeBlob(baseDir, value, hash) {
+    if (!baseDir) return '';
+    blobStore.ensureDir(baseDir);
+    const ref = refForHash(hash || clipboardModel.valueHash(value));
+    if (!ref) return '';
+    const filePath = pathForRef(baseDir, ref);
+    if (!filePath) return '';
+    if (!fs.existsSync(filePath)) blobStore.atomicWriteFile(filePath, String(value || ''));
+    return ref;
+  }
+
+  function readBlob(baseDir, item) {
+    if (!item || item.type === 'image') return null;
+    const ref = safeRef(item[names.ref]) || refForHash(item[names.hash]);
+    const filePath = pathForRef(baseDir, ref);
+    if (!filePath) return null;
+    try {
+      const value = fs.readFileSync(filePath, 'utf8');
+      if (item[names.hash] && clipboardModel.valueHash(value) !== String(item[names.hash]).toLowerCase()) {
+        return null;
+      }
+      return value;
+    } catch {
+      return null;
+    }
+  }
+
+  function hydrateItem(item, baseDir) {
+    if (!item || item.type === 'image') return item;
+    clearRuntimeFlags(item);
+    if (!item[names.ref] && !item[names.hash]) {
+      setValue(item, String(item[names.value] || ''));
+      return item;
+    }
+
+    const value = readBlob(baseDir, item);
+    if (value != null) {
+      item[names.value] = value;
+      markRuntime(item, LOADED_FLAG, true);
+      return item;
+    }
+
+    setValue(item, previewChars ? String(item[names.preview] || item[names.value] || '') : '');
+    markRuntime(item, MISSING_FLAG, true);
+    return item;
+  }
+
+  function hydrateHistory(items, baseDir) {
+    if (!Array.isArray(items)) return [];
+    for (const item of items) hydrateItem(item, baseDir);
+    return items;
+  }
+
+  function prepareItemForStorage(item, baseDir, options = {}) {
+    if (!item || item.type === 'image') return { ...(item || {}) };
+    const threshold = Number(options.thresholdBytes) || defaultThreshold;
+
+    // Metadata present but the in-memory value is not the full payload (a
+    // missing blob, or a peer's preview-only copy). Keep the metadata so the
+    // blob can still be fetched from a peer; never overwrite it with a partial.
+    if ((item[names.hash] || item[names.ref]) && !clipboardModel.hasVerifiedFullValue(item, names)) {
+      const copy = { ...item };
+      const kept = previewChars ? String(item[names.preview] || item[names.value] || '') : '';
+      setValue(copy, kept);
+      if (previewChars && !copy[names.preview]) copy[names.preview] = kept;
+      clearRuntimeFlags(copy);
+      return copy;
+    }
+
+    const value = String(item[names.value] || '');
+    const bytes = byteLength(value);
+    const shouldExternalize = bytes > threshold || !!item[names.ref];
+    if (!shouldExternalize) {
+      const copy = { ...item };
+      setValue(copy, value);
+      clearMetadata(copy);
+      clearRuntimeFlags(copy);
+      return copy;
+    }
+
+    const hash = clipboardModel.valueHash(value);
+    try {
+      const ref = writeBlob(baseDir, value, hash);
+      if (!ref) throw new Error('Invalid blob reference');
+      const copy = { ...item };
+      setValue(copy, preview(value));
+      copy[names.hash] = hash;
+      copy[names.ref] = ref;
+      copy[names.size] = bytes;
+      if (previewChars) copy[names.preview] = preview(value);
+      clearRuntimeFlags(copy);
+      return copy;
+    } catch {
+      // Corruption guard: if the blob cannot be written, keep the full value
+      // inline rather than shipping a reference to a file that does not exist.
+      const copy = { ...item };
+      copy[names.value] = value;
+      clearMetadata(copy);
+      clearRuntimeFlags(copy);
+      return copy;
+    }
+  }
+
+  function prepareHistoryForStorage(items, baseDir, options = {}) {
+    if (baseDir) { try { blobStore.ensureDir(baseDir); } catch {} }
+    return (Array.isArray(items) ? items : []).map(item => prepareItemForStorage(item, baseDir, options));
+  }
+
+  function refsOf(items) {
+    const refs = new Set();
+    for (const item of Array.isArray(items) ? items : []) {
+      const ref = safeRef(item && item[names.ref]);
+      if (ref) refs.add(ref);
+    }
+    return [...refs];
+  }
+
+  function syncBlobs(localDir, remoteDir) {
+    if (!localDir || !remoteDir) return;
+    blobStore.syncMissingFiles(localDir, remoteDir, { filter: name => !!safeRef(name) });
+  }
+
+  function removeLocalBlobIfUnreferenced(item, items, baseDir) {
+    if (!item || item.type === 'image' || !baseDir) return;
+    const ref = safeRef(item[names.ref]) || refForHash(item[names.hash]);
+    if (!ref) return;
+    const stillUsed = (items || []).some(candidate => candidate !== item && (
+      safeRef(candidate && candidate[names.ref]) === ref ||
+      refForHash(candidate && candidate[names.hash]) === ref
+    ));
+    if (stillUsed) return;
+    try { fs.rmSync(pathForRef(baseDir, ref), { force: true }); } catch {}
+  }
+
+  // True when the item advertises this payload but hydrate could not produce it
+  // (the blob file is absent locally — typically synced metadata whose blob has
+  // not arrived yet). The distinction matters: such a payload is ADVERTISED but
+  // not USABLE, so a fresh capture carrying the real bytes should replace it.
+  function isBlobMissing(item) {
+    return !!(item && item[MISSING_FLAG]);
+  }
+
+  // Remove the whole field group. Used when replacing one payload with another:
+  // a leftover ref/hash beside a new inline value describes different content,
+  // and prepareItemForStorage would then reject the new value as unverified.
+  function clearField(item) {
+    if (!item) return item;
+    delete item[names.value];
+    clearMetadata(item);
+    clearRuntimeFlags(item);
+    return item;
+  }
+
+  function setInlineValue(item, value) {
+    if (!item || item.type === 'image') return item;
+    setValue(item, String(value || ''));
+    clearMetadata(item);
+    clearRuntimeFlags(item);
+    return item;
+  }
+
+  return {
+    field,
+    dirname,
+    ext,
+    names,
+    previewChars,
+    thresholdBytes: defaultThreshold,
+    refForHash,
+    safeRef,
+    preview,
+    hydrateItem,
+    hydrateHistory,
+    prepareItemForStorage,
+    prepareHistoryForStorage,
+    refsOf,
+    syncBlobs,
+    removeLocalBlobIfUnreferenced,
+    setInlineValue,
+    isBlobMissing,
+    clearField,
+  };
+}
+
+module.exports = { makeBlobFieldStore, DEFAULT_THRESHOLD_BYTES };

package/lib/blob-store.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function atomicWriteFile(filePath, data) {
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmpPath, data);
+  fs.renameSync(tmpPath, filePath);
+}
+
+// ONE JSON text parser for every store read (local files AND remote provider
+// files). Windows PowerShell's default UTF-8 writer prepends a BOM, which
+// JSON.parse rejects — and a rejected parse is destructive here: the caller
+// treats the store as empty and the next canonical write replaces it. Accept
+// that valid document instead of silently discarding the user's data.
+function parseJsonText(raw) {
+  return JSON.parse(String(raw == null ? '' : raw).replace(/^\uFEFF/, ''));
+}
+
+function directoryBytes(dir) {
+  let total = 0;
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      try {
+        const stats = fs.statSync(path.join(dir, name));
+        if (stats.isFile()) total += stats.size;
+      } catch {}
+    }
+  } catch {}
+  return total;
+}
+
+function copyMissingFiles(fromDir, toDir, options = {}) {
+  const filter = typeof options.filter === 'function' ? options.filter : () => true;
+  try { ensureDir(toDir); } catch { return; }
+
+  let names = [];
+  try { names = fs.readdirSync(fromDir); } catch { return; }
+
+  for (const name of names) {
+    if (!filter(name)) continue;
+    const source = path.join(fromDir, name);
+    const dest = path.join(toDir, name);
+    try {
+      if (!fs.statSync(source).isFile()) continue;
+      if (!fs.existsSync(dest)) fs.copyFileSync(source, dest);
+    } catch {}
+  }
+}
+
+function syncMissingFiles(localDir, remoteDir, options = {}) {
+  copyMissingFiles(remoteDir, localDir, options);
+  copyMissingFiles(localDir, remoteDir, options);
+}
+
+module.exports = {
+  ensureDir,
+  atomicWriteFile,
+  parseJsonText,
+  directoryBytes,
+  copyMissingFiles,
+  syncMissingFiles,
+};