@objectstack/metadata-fs 5.0.0

package/dist/index.js

@@ -0,0 +1,588 @@
+// src/repository.ts
+import fs2 from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
+import chokidar from "chokidar";
+import {
+  hashSpec,
+  ConflictError,
+  refKey
+} from "@objectstack/metadata-core";
+
+// src/layout.ts
+import path from "path";
+function itemPath(layout, type, name) {
+  return path.join(layout.root, type, `${name}.json`);
+}
+function typeDir(layout, type) {
+  return path.join(layout.root, type);
+}
+function logDir(layout) {
+  return path.join(layout.root, ".objectstack", ".log");
+}
+function logFile(layout) {
+  return path.join(logDir(layout), `main.jsonl`);
+}
+function parseItemPath(layout, absPath) {
+  const rel = path.relative(layout.root, absPath);
+  if (rel.startsWith("..") || rel.startsWith(".objectstack")) return null;
+  const segments = rel.split(path.sep);
+  if (segments.length !== 2) return null;
+  const type = segments[0];
+  const file = segments[1];
+  if (!file.endsWith(".json")) return null;
+  const name = file.slice(0, -".json".length);
+  return { type, name };
+}
+
+// src/jsonl-log.ts
+import fs from "fs/promises";
+import path2 from "path";
+import readline from "readline";
+import { createReadStream, existsSync } from "fs";
+var JsonlLog = class {
+  constructor(file) {
+    this.file = file;
+  }
+  async append(evt) {
+    await fs.mkdir(path2.dirname(this.file), { recursive: true });
+    await fs.appendFile(this.file, JSON.stringify(evt) + "\n", "utf8");
+  }
+  /** Read all events in seq order (i.e. file order). */
+  async *readAll() {
+    if (!existsSync(this.file)) return;
+    const rl = readline.createInterface({
+      input: createReadStream(this.file, { encoding: "utf8" }),
+      crlfDelay: Infinity
+    });
+    try {
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        try {
+          yield JSON.parse(line);
+        } catch {
+        }
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  /** Return the highest seq number in the log, or 0 if empty. */
+  async highestSeq() {
+    let max = 0;
+    for await (const evt of this.readAll()) {
+      if (typeof evt.seq === "number" && evt.seq > max) max = evt.seq;
+    }
+    return max;
+  }
+};
+
+// src/sync.ts
+var KeyedMutex = class {
+  constructor() {
+    this.tails = /* @__PURE__ */ new Map();
+  }
+  async run(key, fn) {
+    const prev = this.tails.get(key) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    const swallowed = next.catch(() => void 0);
+    this.tails.set(key, swallowed);
+    try {
+      return await next;
+    } finally {
+      if (this.tails.get(key) === swallowed) {
+        this.tails.delete(key);
+      }
+    }
+  }
+};
+function createBroker(matches) {
+  const subs = /* @__PURE__ */ new Set();
+  return {
+    subscribe: (s) => {
+      subs.add(s);
+    },
+    unsubscribe: (s) => {
+      subs.delete(s);
+    },
+    publish: (evt) => {
+      for (const s of subs) {
+        if (s.closed) continue;
+        if (!matches(evt, s.filter)) continue;
+        s.push(evt);
+      }
+    }
+  };
+}
+
+// src/watch-iterable.ts
+function createWatchIterable(args) {
+  const queue = [];
+  let waiter = null;
+  let closed = false;
+  const delivered = /* @__PURE__ */ new Set();
+  const evtKey = (e) => `${args.branchKeyOf(e)}#${e.seq}`;
+  const subscriber = {
+    filter: args.filter,
+    closed: false,
+    push: (evt) => {
+      if (subscriber.closed) return;
+      const k = evtKey(evt);
+      if (delivered.has(k)) return;
+      if (waiter) {
+        delivered.add(k);
+        const w = waiter;
+        waiter = null;
+        w({ value: clone(evt), done: false });
+      } else {
+        queue.push(evt);
+      }
+    }
+  };
+  args.broker.subscribe(subscriber);
+  const replay = [...args.replay].sort((a, b) => a.seq - b.seq);
+  let replayIdx = 0;
+  const drain = () => {
+    while (replayIdx < replay.length) {
+      const evt = replay[replayIdx++];
+      if (typeof args.since === "number" && evt.seq <= args.since) continue;
+      const k = evtKey(evt);
+      if (delivered.has(k)) continue;
+      delivered.add(k);
+      return { value: clone(evt), done: false };
+    }
+    while (queue.length > 0) {
+      const evt = queue.shift();
+      const k = evtKey(evt);
+      if (delivered.has(k)) continue;
+      delivered.add(k);
+      return { value: clone(evt), done: false };
+    }
+    return null;
+  };
+  const close = () => {
+    if (!closed) {
+      closed = true;
+      subscriber.closed = true;
+      args.broker.unsubscribe(subscriber);
+      if (waiter) {
+        const w = waiter;
+        waiter = null;
+        w({ value: void 0, done: true });
+      }
+    }
+    return { value: void 0, done: true };
+  };
+  const iterator = {
+    next: () => {
+      if (closed) return Promise.resolve({ value: void 0, done: true });
+      const immediate = drain();
+      if (immediate) return Promise.resolve(immediate);
+      return new Promise((resolve) => {
+        waiter = resolve;
+      });
+    },
+    return: () => Promise.resolve(close()),
+    throw: (err) => {
+      close();
+      return Promise.reject(err);
+    }
+  };
+  return { [Symbol.asyncIterator]: () => iterator };
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/repository.ts
+var matchRefFilter = (ref, filter) => {
+  if (filter.org && filter.org !== ref.org) return false;
+  if (filter.type && filter.type !== ref.type) return false;
+  if (filter.name && filter.name !== ref.name) return false;
+  return true;
+};
+var matchEvent = (evt, filter) => matchRefFilter(evt.ref, filter);
+var FileSystemRepository = class {
+  constructor(opts) {
+    this.mutex = new KeyedMutex();
+    this.broker = createBroker(matchEvent);
+    /** In-memory index: refKey → current hash (HEAD). */
+    this.heads = /* @__PURE__ */ new Map();
+    /** Next seq counter, hydrated from the log on `start()`. */
+    this.nextSeq = 1;
+    /** Paths we wrote ourselves; suppress the resulting chokidar event. */
+    this.selfWrites = /* @__PURE__ */ new Set();
+    this.watcher = null;
+    this.started = false;
+    this.org = opts.org;
+    this.fsActor = opts.fsActor ?? "fs";
+    this.disableWatch = opts.disableWatch ?? false;
+    this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
+    this.layout = { root: path3.resolve(opts.root) };
+    this.log = new JsonlLog(logFile(this.layout));
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────────
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    await fs2.mkdir(this.layout.root, { recursive: true });
+    await fs2.mkdir(logDir(this.layout), { recursive: true });
+    await this.scanHeads();
+    const highest = await this.log.highestSeq();
+    this.nextSeq = highest + 1;
+    if (!this.disableWatch) this.startWatcher();
+  }
+  async close() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    this.started = false;
+  }
+  // ── Read API ────────────────────────────────────────────────────────
+  async get(ref) {
+    this.assertScope(ref);
+    const file = itemPath(this.layout, ref.type, ref.name);
+    if (!existsSync2(file)) return null;
+    const body = await readJson(file);
+    if (!body) return null;
+    const hash = hashSpec(body);
+    if (ref.version && ref.version !== hash) return null;
+    const meta = await this.findMetaForHash(ref, hash);
+    return {
+      ref: { ...ref, version: void 0 },
+      body,
+      hash,
+      parentHash: meta?.parentHash ?? null,
+      authoredBy: meta?.actor ?? this.fsActor,
+      authoredAt: meta?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      message: meta?.message,
+      seq: meta?.seq ?? 0
+    };
+  }
+  async *list(filter) {
+    const limit = filter.limit ?? Infinity;
+    let yielded = 0;
+    for (const [key, hash] of this.heads) {
+      const ref = parseRefKey(key);
+      if (!ref) continue;
+      if (!matchRefFilter(ref, filter)) continue;
+      if (filter.nameContains && !ref.name.includes(filter.nameContains)) continue;
+      const meta = await this.findMetaForHash(ref, hash);
+      const header = {
+        ref: { ...ref, version: void 0 },
+        hash,
+        parentHash: meta?.parentHash ?? null,
+        authoredBy: meta?.actor ?? this.fsActor,
+        authoredAt: meta?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        message: meta?.message,
+        seq: meta?.seq ?? 0
+      };
+      yield header;
+      if (++yielded >= limit) return;
+    }
+  }
+  async *history(ref, opts = {}) {
+    this.assertScope(ref);
+    const since = opts.sinceSeq ?? -1;
+    const limit = opts.limit ?? Infinity;
+    let yielded = 0;
+    for await (const evt of this.log.readAll()) {
+      if (evt.seq <= since) continue;
+      if (evt.ref.type !== ref.type || evt.ref.name !== ref.name) continue;
+      if (evt.ref.org !== ref.org) continue;
+      yield evt;
+      if (++yielded >= limit) return;
+    }
+  }
+  watch(filter, since) {
+    const replay = [];
+    const promise = (async () => {
+      for await (const evt of this.log.readAll()) {
+        if (matchEvent(evt, filter)) replay.push(evt);
+      }
+    })();
+    return deferredIterable(promise.then(
+      () => createWatchIterable({
+        filter,
+        since,
+        replay,
+        broker: this.broker,
+        matches: matchEvent,
+        branchKeyOf: (e) => e.ref.org
+      })
+    ));
+  }
+  // ── Write API ───────────────────────────────────────────────────────
+  put(ref, spec, opts) {
+    this.assertScope(ref);
+    return this.mutex.run(refKey(ref), async () => {
+      const key = refKey(ref);
+      const currentHead = this.heads.get(key) ?? null;
+      if ((opts.parentVersion ?? null) !== currentHead) {
+        throw new ConflictError(ref, opts.parentVersion ?? null, currentHead);
+      }
+      const hash = hashSpec(spec);
+      if (currentHead === hash) {
+        const meta = await this.findMetaForHash(ref, hash);
+        return {
+          version: hash,
+          seq: meta?.seq ?? 0,
+          item: {
+            ref: { ...ref, version: void 0 },
+            body: spec,
+            hash,
+            parentHash: meta?.parentHash ?? null,
+            authoredBy: meta?.actor ?? this.fsActor,
+            authoredAt: meta?.ts ?? this.now().toISOString(),
+            message: meta?.message,
+            seq: meta?.seq ?? 0
+          }
+        };
+      }
+      const seq = this.nextSeq++;
+      const ts = this.now().toISOString();
+      const file = itemPath(this.layout, ref.type, ref.name);
+      await fs2.mkdir(typeDir(this.layout, ref.type), { recursive: true });
+      this.selfWrites.add(file);
+      try {
+        await writeJsonAtomic(file, spec);
+      } finally {
+        setTimeout(() => this.selfWrites.delete(file), 200);
+      }
+      this.heads.set(key, hash);
+      const evt = {
+        seq,
+        op: currentHead ? "update" : "create",
+        ref: { ...ref, version: void 0 },
+        hash,
+        parentHash: currentHead,
+        actor: opts.actor,
+        message: opts.message,
+        ts,
+        source: opts.source ?? "fs"
+      };
+      await this.log.append(evt);
+      this.broker.publish(evt);
+      return {
+        version: hash,
+        seq,
+        item: {
+          ref: { ...ref, version: void 0 },
+          body: spec,
+          hash,
+          parentHash: currentHead,
+          authoredBy: opts.actor,
+          authoredAt: ts,
+          message: opts.message,
+          seq
+        }
+      };
+    });
+  }
+  delete(ref, opts) {
+    this.assertScope(ref);
+    return this.mutex.run(refKey(ref), async () => {
+      const key = refKey(ref);
+      const currentHead = this.heads.get(key) ?? null;
+      if (currentHead !== opts.parentVersion) {
+        throw new ConflictError(ref, opts.parentVersion, currentHead);
+      }
+      const file = itemPath(this.layout, ref.type, ref.name);
+      this.selfWrites.add(file);
+      try {
+        if (existsSync2(file)) await fs2.unlink(file);
+      } finally {
+        setTimeout(() => this.selfWrites.delete(file), 200);
+      }
+      this.heads.delete(key);
+      const seq = this.nextSeq++;
+      const ts = this.now().toISOString();
+      const evt = {
+        seq,
+        op: "delete",
+        ref: { ...ref, version: void 0 },
+        hash: null,
+        parentHash: currentHead,
+        actor: opts.actor,
+        message: opts.message,
+        ts,
+        source: opts.source ?? "fs"
+      };
+      await this.log.append(evt);
+      this.broker.publish(evt);
+      return { seq };
+    });
+  }
+  // ── Internals ───────────────────────────────────────────────────────
+  assertScope(ref) {
+    if (ref.org !== this.org) {
+      throw new Error(
+        `FileSystemRepository scope mismatch: expected org=${this.org}, got org=${ref.org}`
+      );
+    }
+  }
+  async scanHeads() {
+    this.heads.clear();
+    let entries = [];
+    try {
+      entries = await fs2.readdir(this.layout.root, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      const type = entry.name;
+      const dir = path3.join(this.layout.root, type);
+      let files = [];
+      try {
+        files = await fs2.readdir(dir);
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const name = file.slice(0, -".json".length);
+        const ref = {
+          org: this.org,
+          type,
+          name
+        };
+        const body = await readJson(path3.join(dir, file));
+        if (!body) continue;
+        this.heads.set(refKey(ref), hashSpec(body));
+      }
+    }
+  }
+  async findMetaForHash(ref, hash) {
+    let last = null;
+    for await (const evt of this.log.readAll()) {
+      if (evt.ref.type !== ref.type || evt.ref.name !== ref.name) continue;
+      if (evt.ref.org !== ref.org) continue;
+      if (evt.hash === hash) last = evt;
+    }
+    return last;
+  }
+  startWatcher() {
+    const w = chokidar.watch(this.layout.root, {
+      ignored: [/(^|[\\/])\../],
+      // skip dotfiles incl. .objectstack
+      ignoreInitial: true,
+      depth: 2,
+      awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 20 },
+      // Use polling to avoid `fs.watch` EMFILE on macOS / busy dev hosts.
+      // The depth-2 recursion would otherwise wire native watches across
+      // the entire customization tree.
+      usePolling: true,
+      interval: 1e3,
+      binaryInterval: 2e3
+    });
+    w.on("add", (p) => void this.handleFsChange(p, "add"));
+    w.on("change", (p) => void this.handleFsChange(p, "change"));
+    w.on("unlink", (p) => void this.handleFsChange(p, "unlink"));
+    this.watcher = w;
+  }
+  async handleFsChange(absPath, kind) {
+    if (this.selfWrites.has(absPath)) return;
+    const parsed = parseItemPath(this.layout, absPath);
+    if (!parsed) return;
+    const ref = {
+      org: this.org,
+      type: parsed.type,
+      name: parsed.name
+    };
+    const key = refKey(ref);
+    await this.mutex.run(key, async () => {
+      if (kind === "unlink") {
+        const currentHead2 = this.heads.get(key) ?? null;
+        if (!currentHead2) return;
+        this.heads.delete(key);
+        const seq2 = this.nextSeq++;
+        const evt2 = {
+          seq: seq2,
+          op: "delete",
+          ref: { ...ref, version: void 0 },
+          hash: null,
+          parentHash: currentHead2,
+          actor: this.fsActor,
+          ts: this.now().toISOString(),
+          source: "fs"
+        };
+        await this.log.append(evt2);
+        this.broker.publish(evt2);
+        return;
+      }
+      const body = await readJson(absPath);
+      if (!body) return;
+      const hash = hashSpec(body);
+      const currentHead = this.heads.get(key) ?? null;
+      if (currentHead === hash) return;
+      this.heads.set(key, hash);
+      const seq = this.nextSeq++;
+      const evt = {
+        seq,
+        op: currentHead ? "update" : "create",
+        ref: { ...ref, version: void 0 },
+        hash,
+        parentHash: currentHead,
+        actor: this.fsActor,
+        ts: this.now().toISOString(),
+        source: "fs"
+      };
+      await this.log.append(evt);
+      this.broker.publish(evt);
+    });
+  }
+};
+async function readJson(file) {
+  try {
+    const text = await fs2.readFile(file, "utf8");
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function writeJsonAtomic(file, body) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await fs2.writeFile(tmp, JSON.stringify(body, null, 2) + "\n", "utf8");
+  await fs2.rename(tmp, file);
+}
+function parseRefKey(key) {
+  const parts = key.split("/");
+  if (parts.length !== 3) return null;
+  return {
+    org: parts[0],
+    type: parts[1],
+    name: parts[2]
+  };
+}
+function deferredIterable(promise) {
+  return {
+    [Symbol.asyncIterator]() {
+      let inner = null;
+      return {
+        async next() {
+          if (!inner) {
+            const iterable = await promise;
+            inner = iterable[Symbol.asyncIterator]();
+          }
+          return inner.next();
+        },
+        async return(value) {
+          if (!inner) {
+            const iterable = await promise;
+            inner = iterable[Symbol.asyncIterator]();
+          }
+          if (inner.return) return inner.return(value);
+          return { value: void 0, done: true };
+        }
+      };
+    }
+  };
+}
+export {
+  FileSystemRepository,
+  JsonlLog
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/repository.ts","../src/layout.ts","../src/jsonl-log.ts","../src/sync.ts","../src/watch-iterable.ts"],"sourcesContent":["// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * `FileSystemRepository` — Node-only implementation of\n * `MetadataRepository` backed by JSON files plus a JSONL change log.\n *\n * See `README.md` for the on-disk layout and ADR-0008 §10 PR-4 for the\n * design rationale.\n *\n * Invariants\n * ──────────\n *   - All `put` / `delete` ops serialize per-key via `KeyedMutex`.\n *   - The change-log JSONL is the durable source of `seq`. On boot we\n *     scan the log to learn the next seq value.\n *   - Body files (`<type>/<name>.json`) are the source of truth; the\n *     log is a denormalised history index.\n *   - chokidar-driven external edits are translated into MetadataEvents\n *     by hashing the new content and comparing to the last-known hash.\n */\n\nimport fs from 'node:fs/promises';\nimport { existsSync } from 'node:fs';\nimport path from 'node:path';\nimport type { FSWatcher } from 'chokidar';\nimport chokidar from 'chokidar';\nimport {\n  type MetadataRepository,\n  type MetaRef,\n  type MetadataItem,\n  type MetadataItemHeader,\n  type MetadataEvent,\n  type PutOptions,\n  type PutResult,\n  type DeleteOptions,\n  type DeleteResult,\n  type ListFilter,\n  type WatchFilter,\n  type HistoryOptions,\n  type MetadataType,\n  hashSpec,\n  ConflictError,\n  refKey,\n} from '@objectstack/metadata-core';\nimport {\n  type FsLayout,\n  itemPath,\n  parseItemPath,\n  typeDir,\n  logDir,\n  logFile,\n} from './layout.js';\nimport { JsonlLog } from './jsonl-log.js';\nimport { KeyedMutex, createBroker, type EventBroker } from './sync.js';\nimport { createWatchIterable } from './watch-iterable.js';\n\nexport interface FileSystemRepositoryOptions {\n  /** Absolute path to the metadata root directory. */\n  root: string;\n  /** Tenant/org. */\n  org: string;\n  /** Identity reported in events that originate from external FS edits. */\n  fsActor?: string;\n  /** Disable chokidar watcher (e.g. for read-only contexts). */\n  disableWatch?: boolean;\n  /** Optional clock injection for deterministic tests. */\n  now?: () => Date;\n}\n\nconst matchRefFilter = (\n  ref: MetaRef,\n  filter: { org?: string; type?: MetadataType; name?: string },\n): boolean => {\n  if (filter.org && filter.org !== ref.org) return false;\n  if (filter.type && filter.type !== ref.type) return false;\n  if (filter.name && filter.name !== ref.name) return false;\n  return true;\n};\n\nconst matchEvent = (evt: MetadataEvent, filter: WatchFilter): boolean => matchRefFilter(evt.ref, filter);\n\nexport class FileSystemRepository implements MetadataRepository {\n  private readonly layout: FsLayout;\n  private readonly org: string;\n  private readonly fsActor: string;\n  private readonly disableWatch: boolean;\n  private readonly now: () => Date;\n  private readonly log: JsonlLog;\n  private readonly mutex = new KeyedMutex();\n  private readonly broker: EventBroker = createBroker(matchEvent);\n\n  /** In-memory index: refKey → current hash (HEAD). */\n  private readonly heads = new Map<string, string>();\n  /** Next seq counter, hydrated from the log on `start()`. */\n  private nextSeq = 1;\n  /** Paths we wrote ourselves; suppress the resulting chokidar event. */\n  private readonly selfWrites = new Set<string>();\n  private watcher: FSWatcher | null = null;\n  private started = false;\n\n  constructor(opts: FileSystemRepositoryOptions) {\n    this.org = opts.org;\n    this.fsActor = opts.fsActor ?? 'fs';\n    this.disableWatch = opts.disableWatch ?? false;\n    this.now = opts.now ?? (() => new Date());\n    this.layout = { root: path.resolve(opts.root) };\n    this.log = new JsonlLog(logFile(this.layout));\n  }\n\n  // ── Lifecycle ───────────────────────────────────────────────────────\n\n  async start(): Promise<void> {\n    if (this.started) return;\n    this.started = true;\n    await fs.mkdir(this.layout.root, { recursive: true });\n    await fs.mkdir(logDir(this.layout), { recursive: true });\n\n    // 1) Scan body files to build the head index.\n    await this.scanHeads();\n\n    // 2) Hydrate nextSeq from the existing log.\n    const highest = await this.log.highestSeq();\n    this.nextSeq = highest + 1;\n\n    // 3) Start the watcher (unless disabled).\n    if (!this.disableWatch) this.startWatcher();\n  }\n\n  async close(): Promise<void> {\n    if (this.watcher) {\n      await this.watcher.close();\n      this.watcher = null;\n    }\n    this.started = false;\n  }\n\n  // ── Read API ────────────────────────────────────────────────────────\n\n  async get(ref: MetaRef): Promise<MetadataItem | null> {\n    this.assertScope(ref);\n    const file = itemPath(this.layout, ref.type, ref.name);\n    if (!existsSync(file)) return null;\n    const body = await readJson(file);\n    if (!body) return null;\n    const hash = hashSpec(body);\n    if (ref.version && ref.version !== hash) return null;\n    // Walk back through the log to populate parent/authoredBy/seq.\n    const meta = await this.findMetaForHash(ref, hash);\n    return {\n      ref: { ...ref, version: undefined },\n      body: body as Record<string, unknown>,\n      hash,\n      parentHash: meta?.parentHash ?? null,\n      authoredBy: meta?.actor ?? this.fsActor,\n      authoredAt: meta?.ts ?? new Date(0).toISOString(),\n      message: meta?.message,\n      seq: meta?.seq ?? 0,\n    };\n  }\n\n  async *list(filter: ListFilter): AsyncIterable<MetadataItemHeader> {\n    const limit = filter.limit ?? Infinity;\n    let yielded = 0;\n    for (const [key, hash] of this.heads) {\n      const ref = parseRefKey(key);\n      if (!ref) continue;\n      if (!matchRefFilter(ref, filter)) continue;\n      if (filter.nameContains && !ref.name.includes(filter.nameContains)) continue;\n      const meta = await this.findMetaForHash(ref, hash);\n      const header: MetadataItemHeader = {\n        ref: { ...ref, version: undefined },\n        hash,\n        parentHash: meta?.parentHash ?? null,\n        authoredBy: meta?.actor ?? this.fsActor,\n        authoredAt: meta?.ts ?? new Date(0).toISOString(),\n        message: meta?.message,\n        seq: meta?.seq ?? 0,\n      };\n      yield header;\n      if (++yielded >= limit) return;\n    }\n  }\n\n  async *history(ref: MetaRef, opts: HistoryOptions = {}): AsyncIterable<MetadataEvent> {\n    this.assertScope(ref);\n    const since = opts.sinceSeq ?? -1;\n    const limit = opts.limit ?? Infinity;\n    let yielded = 0;\n    for await (const evt of this.log.readAll()) {\n      if (evt.seq <= since) continue;\n      if (evt.ref.type !== ref.type || evt.ref.name !== ref.name) continue;\n      if (evt.ref.org !== ref.org) continue;\n      yield evt;\n      if (++yielded >= limit) return;\n    }\n  }\n\n  watch(filter: WatchFilter, since?: number): AsyncIterable<MetadataEvent> {\n    // Eagerly snapshot the existing log for replay; new events route via broker.\n    const replay: MetadataEvent[] = [];\n    const promise = (async () => {\n      for await (const evt of this.log.readAll()) {\n        if (matchEvent(evt, filter)) replay.push(evt);\n      }\n    })();\n    // We must await replay before returning, but the public API is\n    // sync-returning AsyncIterable. Wrap in a deferred iterable.\n    return deferredIterable(promise.then(() =>\n      createWatchIterable({\n        filter,\n        since,\n        replay,\n        broker: this.broker,\n        matches: matchEvent,\n        branchKeyOf: (e) => e.ref.org,\n      }),\n    ));\n  }\n\n  // ── Write API ───────────────────────────────────────────────────────\n\n  put(ref: MetaRef, spec: unknown, opts: PutOptions): Promise<PutResult> {\n    this.assertScope(ref);\n    return this.mutex.run(refKey(ref), async () => {\n      const key = refKey(ref);\n      const currentHead = this.heads.get(key) ?? null;\n      if ((opts.parentVersion ?? null) !== currentHead) {\n        throw new ConflictError(ref, opts.parentVersion ?? null, currentHead);\n      }\n      const hash = hashSpec(spec);\n      if (currentHead === hash) {\n        // No-op write — same content.\n        const meta = await this.findMetaForHash(ref, hash);\n        return {\n          version: hash,\n          seq: meta?.seq ?? 0,\n          item: {\n            ref: { ...ref, version: undefined },\n            body: spec as Record<string, unknown>,\n            hash,\n            parentHash: meta?.parentHash ?? null,\n            authoredBy: meta?.actor ?? this.fsActor,\n            authoredAt: meta?.ts ?? this.now().toISOString(),\n            message: meta?.message,\n            seq: meta?.seq ?? 0,\n          },\n        };\n      }\n\n      const seq = this.nextSeq++;\n      const ts = this.now().toISOString();\n      const file = itemPath(this.layout, ref.type, ref.name);\n      await fs.mkdir(typeDir(this.layout, ref.type), { recursive: true });\n      this.selfWrites.add(file);\n      try {\n        await writeJsonAtomic(file, spec);\n      } finally {\n        // Hold the suppression until chokidar has had a chance to emit;\n        // we keep it in selfWrites for one debounce tick.\n        setTimeout(() => this.selfWrites.delete(file), 200);\n      }\n      this.heads.set(key, hash);\n\n      const evt: MetadataEvent = {\n        seq,\n        op: currentHead ? 'update' : 'create',\n        ref: { ...ref, version: undefined },\n        hash,\n        parentHash: currentHead,\n        actor: opts.actor,\n        message: opts.message,\n        ts,\n        source: opts.source ?? 'fs',\n      };\n      await this.log.append(evt);\n      this.broker.publish(evt);\n\n      return {\n        version: hash,\n        seq,\n        item: {\n          ref: { ...ref, version: undefined },\n          body: spec as Record<string, unknown>,\n          hash,\n          parentHash: currentHead,\n          authoredBy: opts.actor,\n          authoredAt: ts,\n          message: opts.message,\n          seq,\n        },\n      };\n    });\n  }\n\n  delete(ref: MetaRef, opts: DeleteOptions): Promise<DeleteResult> {\n    this.assertScope(ref);\n    return this.mutex.run(refKey(ref), async () => {\n      const key = refKey(ref);\n      const currentHead = this.heads.get(key) ?? null;\n      if (currentHead !== opts.parentVersion) {\n        throw new ConflictError(ref, opts.parentVersion, currentHead);\n      }\n      const file = itemPath(this.layout, ref.type, ref.name);\n      this.selfWrites.add(file);\n      try {\n        if (existsSync(file)) await fs.unlink(file);\n      } finally {\n        setTimeout(() => this.selfWrites.delete(file), 200);\n      }\n      this.heads.delete(key);\n      const seq = this.nextSeq++;\n      const ts = this.now().toISOString();\n      const evt: MetadataEvent = {\n        seq,\n        op: 'delete',\n        ref: { ...ref, version: undefined },\n        hash: null,\n        parentHash: currentHead,\n        actor: opts.actor,\n        message: opts.message,\n        ts,\n        source: opts.source ?? 'fs',\n      };\n      await this.log.append(evt);\n      this.broker.publish(evt);\n      return { seq };\n    });\n  }\n\n  // ── Internals ───────────────────────────────────────────────────────\n\n  private assertScope(ref: MetaRef): void {\n    if (ref.org !== this.org) {\n      throw new Error(\n        `FileSystemRepository scope mismatch: expected org=${this.org}, got org=${ref.org}`,\n      );\n    }\n  }\n\n  private async scanHeads(): Promise<void> {\n    this.heads.clear();\n    // Walk one level deep: <root>/<type>/<name>.json\n    let entries: import('node:fs').Dirent[] = [];\n    try {\n      entries = await fs.readdir(this.layout.root, { withFileTypes: true });\n    } catch {\n      return;\n    }\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue;\n      if (entry.name.startsWith('.')) continue;\n      const type = entry.name;\n      const dir = path.join(this.layout.root, type);\n      let files: string[] = [];\n      try {\n        files = await fs.readdir(dir);\n      } catch {\n        continue;\n      }\n      for (const file of files) {\n        if (!file.endsWith('.json')) continue;\n        const name = file.slice(0, -'.json'.length);\n        const ref: MetaRef = {\n          org: this.org,\n          type: type as MetadataType,\n          name,\n        };\n        const body = await readJson(path.join(dir, file));\n        if (!body) continue;\n        this.heads.set(refKey(ref), hashSpec(body));\n      }\n    }\n  }\n\n  private async findMetaForHash(\n    ref: MetaRef,\n    hash: string,\n  ): Promise<MetadataEvent | null> {\n    let last: MetadataEvent | null = null;\n    for await (const evt of this.log.readAll()) {\n      if (evt.ref.type !== ref.type || evt.ref.name !== ref.name) continue;\n      if (evt.ref.org !== ref.org) continue;\n      if (evt.hash === hash) last = evt;\n    }\n    return last;\n  }\n\n  private startWatcher(): void {\n    const w = chokidar.watch(this.layout.root, {\n      ignored: [/(^|[\\\\/])\\../], // skip dotfiles incl. .objectstack\n      ignoreInitial: true,\n      depth: 2,\n      awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 20 },\n      // Use polling to avoid `fs.watch` EMFILE on macOS / busy dev hosts.\n      // The depth-2 recursion would otherwise wire native watches across\n      // the entire customization tree.\n      usePolling: true,\n      interval: 1000,\n      binaryInterval: 2000,\n    });\n    w.on('add', (p) => void this.handleFsChange(p, 'add'));\n    w.on('change', (p) => void this.handleFsChange(p, 'change'));\n    w.on('unlink', (p) => void this.handleFsChange(p, 'unlink'));\n    this.watcher = w;\n  }\n\n  private async handleFsChange(absPath: string, kind: 'add' | 'change' | 'unlink'): Promise<void> {\n    if (this.selfWrites.has(absPath)) return; // Suppress our own writes.\n    const parsed = parseItemPath(this.layout, absPath);\n    if (!parsed) return;\n    const ref: MetaRef = {\n      org: this.org,\n      type: parsed.type as MetadataType,\n      name: parsed.name,\n    };\n    const key = refKey(ref);\n    await this.mutex.run(key, async () => {\n      if (kind === 'unlink') {\n        const currentHead = this.heads.get(key) ?? null;\n        if (!currentHead) return;\n        this.heads.delete(key);\n        const seq = this.nextSeq++;\n        const evt: MetadataEvent = {\n          seq,\n          op: 'delete',\n          ref: { ...ref, version: undefined },\n          hash: null,\n          parentHash: currentHead,\n          actor: this.fsActor,\n          ts: this.now().toISOString(),\n          source: 'fs',\n        };\n        await this.log.append(evt);\n        this.broker.publish(evt);\n        return;\n      }\n      const body = await readJson(absPath);\n      if (!body) return;\n      const hash = hashSpec(body);\n      const currentHead = this.heads.get(key) ?? null;\n      if (currentHead === hash) return; // No content change.\n      this.heads.set(key, hash);\n      const seq = this.nextSeq++;\n      const evt: MetadataEvent = {\n        seq,\n        op: currentHead ? 'update' : 'create',\n        ref: { ...ref, version: undefined },\n        hash,\n        parentHash: currentHead,\n        actor: this.fsActor,\n        ts: this.now().toISOString(),\n        source: 'fs',\n      };\n      await this.log.append(evt);\n      this.broker.publish(evt);\n    });\n  }\n}\n\n// ── Utilities ─────────────────────────────────────────────────────────\n\nasync function readJson(file: string): Promise<unknown | null> {\n  try {\n    const text = await fs.readFile(file, 'utf8');\n    return JSON.parse(text);\n  } catch {\n    return null;\n  }\n}\n\nasync function writeJsonAtomic(file: string, body: unknown): Promise<void> {\n  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;\n  await fs.writeFile(tmp, JSON.stringify(body, null, 2) + '\\n', 'utf8');\n  await fs.rename(tmp, file);\n}\n\nfunction parseRefKey(key: string): MetaRef | null {\n  const parts = key.split('/');\n  if (parts.length !== 3) return null;\n  return {\n    org: parts[0]!,\n    type: parts[1]! as MetadataType,\n    name: parts[2]!,\n  };\n}\n\n/**\n * Wrap a Promise<AsyncIterable<T>> as a sync-returning AsyncIterable<T>.\n * The first `.next()` awaits the promise.\n */\nfunction deferredIterable<T>(promise: Promise<AsyncIterable<T>>): AsyncIterable<T> {\n  return {\n    [Symbol.asyncIterator]() {\n      let inner: AsyncIterator<T> | null = null;\n      return {\n        async next() {\n          if (!inner) {\n            const iterable = await promise;\n            inner = iterable[Symbol.asyncIterator]();\n          }\n          return inner.next();\n        },\n        async return(value?: unknown) {\n          if (!inner) {\n            const iterable = await promise;\n            inner = iterable[Symbol.asyncIterator]();\n          }\n          if (inner.return) return inner.return(value);\n          return { value: undefined, done: true };\n        },\n      } as AsyncIterator<T>;\n    },\n  };\n}\n","// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Disk layout helpers — see ADR-0008 §10 PR-4 / packages/metadata-fs README.\n *\n *   <root>/<type>/<name>.json     — canonical body\n *   <root>/.objectstack/.log/main.jsonl  — append-only change log\n */\n\nimport path from 'node:path';\nimport type { MetadataType } from '@objectstack/metadata-core';\n\nexport interface FsLayout {\n  /** Absolute path to the metadata root. */\n  root: string;\n}\n\nexport function itemPath(layout: FsLayout, type: MetadataType, name: string): string {\n  return path.join(layout.root, type, `${name}.json`);\n}\n\nexport function typeDir(layout: FsLayout, type: MetadataType): string {\n  return path.join(layout.root, type);\n}\n\nexport function logDir(layout: FsLayout): string {\n  return path.join(layout.root, '.objectstack', '.log');\n}\n\nexport function logFile(layout: FsLayout): string {\n  // Single change log per filesystem root (branching is a Git concern,\n  // not a metadata-layer concern).\n  return path.join(logDir(layout), `main.jsonl`);\n}\n\n/** Parse a path like \".../view/case_grid.json\" into {type, name}. */\nexport function parseItemPath(\n  layout: FsLayout,\n  absPath: string,\n): { type: string; name: string } | null {\n  const rel = path.relative(layout.root, absPath);\n  if (rel.startsWith('..') || rel.startsWith('.objectstack')) return null;\n  const segments = rel.split(path.sep);\n  if (segments.length !== 2) return null;\n  const type = segments[0]!;\n  const file = segments[1]!;\n  if (!file.endsWith('.json')) return null;\n  const name = file.slice(0, -'.json'.length);\n  return { type, name };\n}\n","// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Append-only JSONL change log writer / reader. Each line is a single\n * `MetadataEvent` serialized via `JSON.stringify`.\n *\n * Durability strategy\n * ───────────────────\n *   - Append with `O_APPEND` semantics (Node's `fs.appendFile` is\n *     atomic for sub-PIPE_BUF-sized writes; events are well under 4 KiB).\n *   - Read by streaming the file line-by-line and JSON.parse-ing each.\n *   - On a corrupt line we skip and continue — the body files are the\n *     source of truth; the log is a denormalised history index.\n */\n\nimport fs from 'node:fs/promises';\nimport path from 'node:path';\nimport readline from 'node:readline';\nimport { createReadStream, existsSync } from 'node:fs';\nimport type { MetadataEvent } from '@objectstack/metadata-core';\n\nexport class JsonlLog {\n  constructor(private readonly file: string) {}\n\n  async append(evt: MetadataEvent): Promise<void> {\n    await fs.mkdir(path.dirname(this.file), { recursive: true });\n    await fs.appendFile(this.file, JSON.stringify(evt) + '\\n', 'utf8');\n  }\n\n  /** Read all events in seq order (i.e. file order). */\n  async *readAll(): AsyncIterable<MetadataEvent> {\n    if (!existsSync(this.file)) return;\n    const rl = readline.createInterface({\n      input: createReadStream(this.file, { encoding: 'utf8' }),\n      crlfDelay: Infinity,\n    });\n    try {\n      for await (const line of rl) {\n        if (!line.trim()) continue;\n        try {\n          yield JSON.parse(line) as MetadataEvent;\n        } catch {\n          // Skip corrupt line.\n        }\n      }\n    } finally {\n      rl.close();\n    }\n  }\n\n  /** Return the highest seq number in the log, or 0 if empty. */\n  async highestSeq(): Promise<number> {\n    let max = 0;\n    for await (const evt of this.readAll()) {\n      if (typeof evt.seq === 'number' && evt.seq > max) max = evt.seq;\n    }\n    return max;\n  }\n}\n","// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Mutex / event-broker primitives used by FileSystemRepository.\n *\n * `KeyedMutex` serializes operations on the same key (refKey). The\n * broker re-uses the same manual-AsyncIterator pattern as\n * InMemoryRepository so that consumer `return()` reliably unblocks.\n */\n\nimport type { MetadataEvent, WatchFilter } from '@objectstack/metadata-core';\n\nexport class KeyedMutex {\n  private readonly tails = new Map<string, Promise<unknown>>();\n\n  async run<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    const prev = this.tails.get(key) ?? Promise.resolve();\n    const next = prev.then(fn, fn);\n    // Save the swallowed-error tail so successive runs don't reject on\n    // an unrelated prior failure.\n    const swallowed = next.catch(() => undefined);\n    this.tails.set(key, swallowed);\n    try {\n      return await next;\n    } finally {\n      // Best-effort cleanup: drop the entry if nothing newer was queued.\n      if (this.tails.get(key) === swallowed) {\n        this.tails.delete(key);\n      }\n    }\n  }\n}\n\nexport interface BrokerSubscriber {\n  filter: WatchFilter;\n  closed: boolean;\n  push(evt: MetadataEvent): void;\n}\n\nexport interface EventBroker {\n  subscribe(sub: BrokerSubscriber): void;\n  unsubscribe(sub: BrokerSubscriber): void;\n  publish(evt: MetadataEvent): void;\n}\n\nexport function createBroker(matches: (evt: MetadataEvent, filter: WatchFilter) => boolean): EventBroker {\n  const subs = new Set<BrokerSubscriber>();\n  return {\n    subscribe: (s) => { subs.add(s); },\n    unsubscribe: (s) => { subs.delete(s); },\n    publish: (evt) => {\n      for (const s of subs) {\n        if (s.closed) continue;\n        if (!matches(evt, s.filter)) continue;\n        s.push(evt);\n      }\n    },\n  };\n}\n","// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.\n\n/**\n * Manual `AsyncIterator` factory for `repo.watch()`. Mirrors the\n * pattern used in `@objectstack/metadata-core`'s `InMemoryRepository`:\n * async generators do NOT run `finally` when paused on an unresolved\n * `await`, so we cannot use them to implement `watch()`.\n */\n\nimport type { MetadataEvent, WatchFilter } from '@objectstack/metadata-core';\nimport { type EventBroker, type BrokerSubscriber } from './sync.js';\n\nexport interface CreateWatchIteratorArgs {\n  filter: WatchFilter;\n  since: number | undefined;\n  replay: MetadataEvent[];\n  broker: EventBroker;\n  /** Returns true if `evt.ref` matches `filter`. */\n  matches: (evt: MetadataEvent, filter: WatchFilter) => boolean;\n  branchKeyOf: (evt: MetadataEvent) => string;\n}\n\nexport function createWatchIterable(\n  args: CreateWatchIteratorArgs,\n): AsyncIterable<MetadataEvent> {\n  const queue: MetadataEvent[] = [];\n  let waiter: ((evt: IteratorResult<MetadataEvent>) => void) | null = null;\n  let closed = false;\n  const delivered = new Set<string>();\n  const evtKey = (e: MetadataEvent) => `${args.branchKeyOf(e)}#${e.seq}`;\n\n  const subscriber: BrokerSubscriber = {\n    filter: args.filter,\n    closed: false,\n    push: (evt) => {\n      if (subscriber.closed) return;\n      const k = evtKey(evt);\n      if (delivered.has(k)) return;\n      if (waiter) {\n        delivered.add(k);\n        const w = waiter;\n        waiter = null;\n        w({ value: clone(evt), done: false });\n      } else {\n        queue.push(evt);\n      }\n    },\n  };\n  args.broker.subscribe(subscriber);\n\n  const replay = [...args.replay].sort((a, b) => a.seq - b.seq);\n  let replayIdx = 0;\n\n  const drain = (): IteratorResult<MetadataEvent> | null => {\n    while (replayIdx < replay.length) {\n      const evt = replay[replayIdx++]!;\n      if (typeof args.since === 'number' && evt.seq <= args.since) continue;\n      const k = evtKey(evt);\n      if (delivered.has(k)) continue;\n      delivered.add(k);\n      return { value: clone(evt), done: false };\n    }\n    while (queue.length > 0) {\n      const evt = queue.shift()!;\n      const k = evtKey(evt);\n      if (delivered.has(k)) continue;\n      delivered.add(k);\n      return { value: clone(evt), done: false };\n    }\n    return null;\n  };\n\n  const close = (): IteratorResult<MetadataEvent> => {\n    if (!closed) {\n      closed = true;\n      subscriber.closed = true;\n      args.broker.unsubscribe(subscriber);\n      if (waiter) {\n        const w = waiter;\n        waiter = null;\n        w({ value: undefined, done: true });\n      }\n    }\n    return { value: undefined, done: true };\n  };\n\n  const iterator: AsyncIterator<MetadataEvent> = {\n    next: () => {\n      if (closed) return Promise.resolve({ value: undefined, done: true });\n      const immediate = drain();\n      if (immediate) return Promise.resolve(immediate);\n      return new Promise<IteratorResult<MetadataEvent>>((resolve) => {\n        waiter = resolve;\n      });\n    },\n    return: () => Promise.resolve(close()),\n    throw: (err) => {\n      close();\n      return Promise.reject(err);\n    },\n  };\n  return { [Symbol.asyncIterator]: () => iterator };\n}\n\nfunction clone<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value)) as T;\n}\n"],"mappings":"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","names":["fs","existsSync","path","path","path","fs","existsSync","currentHead","seq","evt"]}