@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-ASX6AW36.js

@@ -0,0 +1,789 @@
+import {
+  CHRONICLE_MAX_APPEND_BATCH,
+  CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS,
+  CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION,
+  ChronicleJournal,
+  ChronicleMetricsStore,
+  ChronicleQueryEngine,
+  ChronicleSqliteJournal,
+  chronicleProjectServerEndpoint,
+  chronicleProjectServerMetadataPath,
+  encodeChronicleProjectServerMessage,
+  importLegacyChronicleJournal,
+  resolveChronicleRuntimeLocation
+} from "./chunk-AT4V4XGI.js";
+import {
+  resolveWstackPaths
+} from "./chunk-YNCVSFGF.js";
+
+// src/chronicle/project-server-client.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var CONNECT_ATTEMPT_TIMEOUT_MS = 750;
+var SERVER_START_TIMEOUT_MS = 1e4;
+var DEFAULT_CALL_TIMEOUT_MS = 3e4;
+var APPEND_CALL_TIMEOUT_MS = 6e4;
+var DEFAULT_BATCH_WINDOW_MS = 5;
+var DEFAULT_MAX_PENDING = 1e5;
+function resolveChronicleDaemonAvailability(moduleUrl = import.meta.url, exists = fs.existsSync) {
+  if (process.env["WRONGSTACK_CHRONICLE_INLINE"] || process.env["WRONGSTACK_CHRONICLE_SERVER"] === "0") {
+    return { kind: "inline-requested" };
+  }
+  const url = locateChronicleProjectServer(moduleUrl, exists);
+  return url ? { kind: "available", url } : { kind: "missing-build" };
+}
+function resolveChronicleProjectServerUrl(moduleUrl = import.meta.url, exists = fs.existsSync) {
+  const availability = resolveChronicleDaemonAvailability(moduleUrl, exists);
+  return availability.kind === "available" ? availability.url : null;
+}
+function locateChronicleProjectServer(moduleUrl, exists) {
+  const candidates = [
+    // Normal unbundled output: dist/chronicle/project-server-client.js.
+    "./project-server.js",
+    // Core plugin bundle: dist/plugin/index.js.
+    "../chronicle/project-server.js",
+    // Core root bundle: dist/index.js.
+    "./chronicle/project-server.js"
+  ];
+  for (const relativePath of candidates) {
+    try {
+      const url = new URL(relativePath, moduleUrl);
+      if (url.protocol === "file:" && exists(fileURLToPath(url))) return url;
+    } catch {
+    }
+  }
+  return null;
+}
+function isChronicleProjectServerAvailable() {
+  return resolveChronicleProjectServerUrl() !== null;
+}
+function delay(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var ChronicleProjectServerClient = class {
+  constructor(options) {
+    this.options = options;
+    this.endpoint = chronicleProjectServerEndpoint(options.projectDir);
+  }
+  options;
+  endpoint;
+  socket = null;
+  info = null;
+  buffer = "";
+  connecting = null;
+  connectResolve = null;
+  connectReject = null;
+  nextId = 1;
+  /** WS-027: read from the owner-only metadata file — see currentAuthToken. */
+  authToken;
+  pending = /* @__PURE__ */ new Map();
+  async call(op, args, options = {}) {
+    await this.ensureConnected(true);
+    return this.request(
+      { type: "request", op, args },
+      options.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS
+    );
+  }
+  ping() {
+    return this.call("ping", {}, { timeoutMs: 3e3 });
+  }
+  /**
+   * Request the Chronicle project server to shut down cleanly.
+   *
+   * Returns the server PID and acknowledgment. Does not throw if the server
+   * is already offline or unreachable — the caller is assumed to want the
+   * server stopped regardless of current state.
+   */
+  async shutdown(reason) {
+    try {
+      await this.ensureConnected(false);
+    } catch {
+      return { stopped: false, reason: "offline" };
+    }
+    const pid = this.info?.pid;
+    try {
+      const result = await this.request(
+        { type: "shutdown", reason },
+        5e3
+      ) ?? { stopped: true };
+      return { ...result, ...pid !== void 0 && result.pid === void 0 ? { pid } : {} };
+    } catch {
+      return { stopped: false, ...pid !== void 0 ? { pid } : {}, reason: "write-failed" };
+    }
+  }
+  async close() {
+    const socket = this.socket;
+    this.socket = null;
+    this.info = null;
+    if (socket && !socket.destroyed) {
+      await new Promise((resolve3) => {
+        socket.once("close", resolve3);
+        socket.end();
+      });
+    }
+  }
+  async ensureConnected(spawnIfMissing) {
+    if (this.socket && !this.socket.destroyed && this.info) return;
+    if (this.connecting) return this.connecting;
+    if (!isChronicleProjectServerAvailable()) {
+      throw new Error(
+        "Built Chronicle project server is unavailable. Build @wrongstack/core or use the inline journal."
+      );
+    }
+    this.connecting = this.connectWithElection(spawnIfMissing).finally(() => {
+      this.connecting = null;
+    });
+    return this.connecting;
+  }
+  async connectWithElection(spawnIfMissing) {
+    const deadline = Date.now() + (spawnIfMissing ? SERVER_START_TIMEOUT_MS : CONNECT_ATTEMPT_TIMEOUT_MS);
+    let spawned = false;
+    let lastError = new Error("Chronicle project server unavailable");
+    while (Date.now() < deadline) {
+      try {
+        await this.connectOnce();
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+      if (!spawnIfMissing) break;
+      if (!spawned) {
+        this.spawnDetachedServer();
+        spawned = true;
+      }
+      await delay(75);
+    }
+    throw lastError;
+  }
+  connectOnce() {
+    this.socket?.destroy();
+    this.socket = null;
+    this.authToken = void 0;
+    this.info = null;
+    this.buffer = "";
+    return new Promise((resolve3, reject) => {
+      const socket = net.createConnection(this.endpoint);
+      this.socket = socket;
+      socket.setEncoding("utf8");
+      const timer = setTimeout(() => {
+        reject(new Error("Chronicle project server handshake timed out"));
+        socket.destroy();
+      }, CONNECT_ATTEMPT_TIMEOUT_MS);
+      timer.unref?.();
+      this.connectResolve = () => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        resolve3();
+      };
+      this.connectReject = (error) => {
+        clearTimeout(timer);
+        this.connectResolve = null;
+        this.connectReject = null;
+        reject(error);
+      };
+      socket.on("data", (chunk) => this.onData(socket, chunk));
+      socket.on("error", (error) => {
+        if (!this.info) this.connectReject?.(error);
+      });
+      socket.on("close", () => this.onClose(socket));
+    });
+  }
+  /**
+   * WS-027: the per-process token, read from the daemon's owner-only metadata
+   * file — never from the `hello` frame, which the daemon sends to every
+   * socket that connects (the mistake WS-028 found in the SAGE daemon).
+   *
+   * Read lazily and re-read while unknown: the daemon starts listening before
+   * it writes metadata (endpoint ownership has to be won first), and a
+   * respawned daemon mints a new token, so a cached wrong one would be sticky.
+   */
+  currentAuthToken() {
+    if (this.authToken === void 0) {
+      try {
+        const raw = fs.readFileSync(
+          chronicleProjectServerMetadataPath(this.options.projectDir),
+          "utf8"
+        );
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.authToken === "string" && parsed.authToken.length > 0) {
+          this.authToken = parsed.authToken;
+        }
+      } catch {
+      }
+    }
+    return this.authToken;
+  }
+  request(message, timeoutMs) {
+    const socket = this.socket;
+    if (!socket || socket.destroyed) {
+      return Promise.reject(new Error("Chronicle project server connection is unavailable"));
+    }
+    const id = this.nextId++;
+    const encoded = encodeChronicleProjectServerMessage({
+      ...message,
+      id,
+      authToken: this.currentAuthToken()
+    });
+    if (encoded.length > CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS) {
+      return Promise.reject(new Error("Chronicle project server request exceeded frame limit"));
+    }
+    const label = message.type === "request" ? message.op : message.type;
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        this.pending.delete(id);
+        pending.reject(new Error(`Chronicle ${label} exceeded its ${timeoutMs}ms timeout`));
+      }, timeoutMs);
+      timer.unref?.();
+      this.pending.set(id, { resolve: resolve3, reject, timer });
+      socket.write(encoded);
+    });
+  }
+  onData(socket, chunk) {
+    if (socket !== this.socket) return;
+    this.buffer += chunk;
+    if (this.buffer.length > CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS) {
+      socket.destroy(new Error("Chronicle project server response exceeded frame limit"));
+      return;
+    }
+    while (true) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) return;
+      const line = this.buffer.slice(0, newline);
+      this.buffer = this.buffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        socket.destroy(new Error("Invalid Chronicle project server response"));
+        return;
+      }
+      this.onMessage(message);
+    }
+  }
+  onMessage(message) {
+    if (message.type === "hello") {
+      if (message.protocolVersion !== CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION) {
+        this.connectReject?.(
+          new Error(
+            `Chronicle protocol mismatch: client=${CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION}, server=${message.protocolVersion}`
+          )
+        );
+        this.socket?.destroy();
+        return;
+      }
+      if (normalizePath(message.projectRoot) !== normalizePath(this.options.projectRoot) || normalizePath(message.projectDir) !== normalizePath(this.options.projectDir)) {
+        this.connectReject?.(new Error("Chronicle project server identity mismatch"));
+        this.socket?.destroy();
+        return;
+      }
+      this.info = message;
+      this.connectResolve?.();
+      return;
+    }
+    const pending = this.pending.get(message.id);
+    if (!pending) return;
+    this.pending.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.ok) pending.resolve(message.result);
+    else {
+      const error = new Error(message.error);
+      if (message.errorName) error.name = message.errorName;
+      pending.reject(error);
+    }
+  }
+  onClose(socket) {
+    if (socket !== this.socket) return;
+    this.socket = null;
+    this.info = null;
+    const error = new Error("Chronicle project server connection closed");
+    this.connectReject?.(error);
+    this.connectResolve = null;
+    this.connectReject = null;
+    const pending = [...this.pending.values()];
+    this.pending.clear();
+    for (const request of pending) {
+      clearTimeout(request.timer);
+      request.reject(error);
+    }
+  }
+  spawnDetachedServer() {
+    const url = resolveChronicleProjectServerUrl();
+    if (!url) throw new Error("Built Chronicle project server is unavailable");
+    const args = [
+      fileURLToPath(url),
+      "--project-root",
+      this.options.projectRoot,
+      "--global-root",
+      this.options.globalRoot,
+      "--project-id",
+      this.options.projectId,
+      "--project-dir",
+      this.options.projectDir,
+      "--workspace-id",
+      this.options.workspaceId
+    ];
+    if (this.options.retentionDays !== void 0) {
+      args.push("--retention-days", String(this.options.retentionDays));
+    }
+    const child = spawn(process.execPath, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: process.env
+    });
+    child.unref();
+  }
+};
+var ChronicleRemoteJournal = class {
+  client;
+  maxPending;
+  batchWindowMs;
+  pending = [];
+  timer;
+  inflight = /* @__PURE__ */ new Set();
+  counters = {
+    acceptedEvents: 0,
+    persistedEvents: 0,
+    rejectedEvents: 0,
+    failedEvents: 0,
+    batches: 0,
+    maxObservedPending: 0,
+    largestBatch: 0,
+    partitionRolls: 0
+  };
+  lastBatchDurationMs;
+  constructor(options, client = new ChronicleProjectServerClient(options)) {
+    this.client = client;
+    this.maxPending = Math.max(1, options.maxPending ?? DEFAULT_MAX_PENDING);
+    this.batchWindowMs = Math.max(0, options.batchWindowMs ?? DEFAULT_BATCH_WINDOW_MS);
+  }
+  append(input) {
+    if (this.pending.length >= this.maxPending) {
+      this.counters.rejectedEvents++;
+      return Promise.reject(
+        new Error(`Chronicle backpressure limit reached (${this.maxPending} pending events)`)
+      );
+    }
+    const promise = new Promise((resolve3, reject) => {
+      this.pending.push({ input, resolve: resolve3, reject });
+    });
+    this.counters.acceptedEvents++;
+    this.counters.maxObservedPending = Math.max(
+      this.counters.maxObservedPending,
+      this.pending.length
+    );
+    this.schedule();
+    return promise;
+  }
+  stats() {
+    return {
+      ...this.counters,
+      pendingEvents: this.pending.length,
+      ...this.lastBatchDurationMs !== void 0 ? { lastBatchDurationMs: this.lastBatchDurationMs } : {}
+    };
+  }
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    while (this.pending.length > 0 || this.inflight.size > 0) {
+      if (this.pending.length > 0) this.startBatch();
+      await Promise.all([...this.inflight]);
+    }
+    if (this.counters.acceptedEvents === 0) return;
+    await this.client.call("flush", {}, { timeoutMs: APPEND_CALL_TIMEOUT_MS });
+  }
+  async dispose() {
+    await this.flush();
+    await this.client.close();
+  }
+  schedule() {
+    if (this.timer) return;
+    if (this.batchWindowMs === 0) {
+      queueMicrotask(() => this.startBatch());
+      return;
+    }
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.startBatch();
+    }, this.batchWindowMs);
+    this.timer.unref?.();
+  }
+  startBatch() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    if (this.pending.length === 0) return;
+    const batch = this.pending.splice(0, CHRONICLE_MAX_APPEND_BATCH);
+    const started = performance.now();
+    this.counters.batches++;
+    this.counters.largestBatch = Math.max(this.counters.largestBatch, batch.length);
+    const run = this.client.call(
+      "append",
+      { inputs: batch.map((entry) => entry.input) },
+      { timeoutMs: APPEND_CALL_TIMEOUT_MS }
+    ).then((events) => {
+      if (events.length !== batch.length) {
+        throw new Error(
+          `Chronicle server returned ${events.length} events for ${batch.length} inputs`
+        );
+      }
+      batch.forEach((entry, index) => {
+        entry.resolve(events[index]);
+      });
+      this.counters.persistedEvents += batch.length;
+    }).catch((error) => {
+      this.counters.failedEvents += batch.length;
+      for (const entry of batch) entry.reject(error);
+    }).finally(() => {
+      this.lastBatchDurationMs = performance.now() - started;
+      this.inflight.delete(run);
+      if (this.pending.length > 0) this.schedule();
+    });
+    this.inflight.add(run);
+  }
+};
+function normalizePath(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+// src/chronicle/project-access.ts
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+import * as path2 from "node:path";
+function resolveChronicleProjectServerOptions(options) {
+  if (options.projectPaths) {
+    return {
+      projectRoot: path2.resolve(options.projectRoot),
+      ...options.projectPaths,
+      ...options.retentionDays !== void 0 ? { retentionDays: options.retentionDays } : {}
+    };
+  }
+  const paths = resolveWstackPaths({
+    projectRoot: options.projectRoot,
+    userHome: options.userHome ?? os.homedir()
+  });
+  return {
+    projectRoot: path2.resolve(options.projectRoot),
+    globalRoot: paths.globalRoot,
+    projectId: paths.projectHash,
+    projectDir: paths.projectDir,
+    workspaceId: paths.projectSlug,
+    ...options.retentionDays !== void 0 ? { retentionDays: options.retentionDays } : {}
+  };
+}
+function createChronicleProjectAccess(options) {
+  const resolved = resolveChronicleProjectServerOptions(options);
+  if (isChronicleProjectServerAvailable()) {
+    const client = new ChronicleProjectServerClient(resolved);
+    return {
+      mode: "server",
+      call: (op, args, callOptions) => client.call(op, args, callOptions),
+      close: () => client.close()
+    };
+  }
+  assertInlineWasRequested("createChronicleProjectAccess");
+  return new InlineChronicleProjectAccess(resolved);
+}
+function assertInlineWasRequested(caller) {
+  if (resolveChronicleDaemonAvailability().kind !== "missing-build") return;
+  throw new Error(
+    `${caller}: built Chronicle project server is unavailable. Build @wrongstack/core, or set WRONGSTACK_CHRONICLE_INLINE=1 to explicitly accept a process-local journal.`
+  );
+}
+function createChronicleEventJournal(options) {
+  const resolved = resolveChronicleProjectServerOptions(options);
+  const identity = resolveChronicleRuntimeLocation({
+    globalRoot: resolved.globalRoot,
+    projectId: resolved.projectId,
+    projectDir: resolved.projectDir
+  });
+  if (isChronicleProjectServerAvailable()) {
+    const journal2 = new ChronicleRemoteJournal(resolved);
+    return {
+      journal: journal2,
+      identity,
+      serverBacked: true,
+      dispose: () => journal2.dispose()
+    };
+  }
+  assertInlineWasRequested("createChronicleEventJournal");
+  if (useSqliteStore()) {
+    const journal2 = new ChronicleSqliteEventSink(path2.join(resolved.projectDir, "chronicle"));
+    return {
+      journal: journal2,
+      identity,
+      serverBacked: false,
+      dispose: () => journal2.close()
+    };
+  }
+  const journal = new ChronicleJournal({
+    filePath: legacyPartitionPath(identity),
+    retentionDays: options.retentionDays
+  });
+  return {
+    journal,
+    identity,
+    serverBacked: false,
+    dispose: () => journal.flush()
+  };
+}
+function legacyPartitionPath(location) {
+  return path2.join(location.chronicleDirectory, `${location.day}.events.jsonl`);
+}
+function useSqliteStore() {
+  return process.env["WRONGSTACK_CHRONICLE_STORE"] !== "jsonl";
+}
+var ChronicleSqliteEventSink = class {
+  ready;
+  last;
+  constructor(directory) {
+    this.ready = (async () => {
+      await fsPromises.mkdir(directory, { recursive: true });
+      const journal = new ChronicleSqliteJournal({ directory });
+      try {
+        await importLegacyChronicleJournal(journal, directory);
+      } catch (error) {
+        journal.close();
+        throw error;
+      }
+      return journal;
+    })();
+  }
+  async append(input) {
+    const journal = await this.ready;
+    const event = await journal.append(input);
+    this.last = journal.stats();
+    return event;
+  }
+  async flush() {
+    await this.ready;
+  }
+  stats() {
+    return this.last ?? EMPTY_JOURNAL_STATS;
+  }
+  async close() {
+    (await this.ready).close();
+  }
+};
+var EMPTY_JOURNAL_STATS = {
+  acceptedEvents: 0,
+  persistedEvents: 0,
+  rejectedEvents: 0,
+  failedEvents: 0,
+  batches: 0,
+  pendingEvents: 0,
+  maxObservedPending: 0,
+  largestBatch: 0,
+  partitionRolls: 0
+};
+var MAX_OPEN_JOURNAL_DAYS = 2;
+var InlineChronicleProjectAccess = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  mode = "inline";
+  journals = /* @__PURE__ */ new Map();
+  sqlite;
+  /**
+   * Open the SQLite journal, importing the legacy partitions the first time.
+   *
+   * The import is part of opening rather than a separate migration step so no
+   * caller can read a half-migrated store: until it finishes, this promise has
+   * not resolved and every operation is still queued behind it.
+   */
+  store() {
+    this.sqlite ??= (async () => {
+      await fsPromises.mkdir(this.chronicleDirectory, { recursive: true });
+      const journal = new ChronicleSqliteJournal({ directory: this.chronicleDirectory });
+      try {
+        await importLegacyChronicleJournal(journal, this.chronicleDirectory);
+      } catch (error) {
+        this.sqlite = void 0;
+        journal.close();
+        throw error;
+      }
+      return journal;
+    })();
+    return this.sqlite;
+  }
+  async call(op, rawArgs, _callOptions) {
+    switch (op) {
+      case "ping":
+        return this.health();
+      case "append": {
+        const args = rawArgs;
+        if (useSqliteStore()) {
+          const store = await this.store();
+          return await store.appendBatch(args.inputs);
+        }
+        return await Promise.all(
+          args.inputs.map((input) => this.journalForToday().append(input))
+        );
+      }
+      case "flush":
+        await this.flush();
+        return void 0;
+      case "purge": {
+        const args = rawArgs;
+        if (useSqliteStore()) {
+          const store = await this.store();
+          return await store.purge(args);
+        }
+        return await this.journalForToday().purge(args);
+      }
+      case "query": {
+        const args = rawArgs;
+        return await (await this.queryEngine()).query(args.query);
+      }
+      case "facet": {
+        const args = rawArgs;
+        const engine = await this.queryEngine();
+        return {
+          values: await engine.facet(args.field, args.query, args.limit),
+          diagnostics: engine.diagnostics
+        };
+      }
+      case "facets": {
+        const args = rawArgs;
+        const engine = await this.queryEngine();
+        return {
+          values: await engine.facets(args.fields, args.query, args.limit),
+          diagnostics: engine.diagnostics
+        };
+      }
+      case "graph": {
+        const args = rawArgs;
+        return await (await this.queryEngine()).graph(args.seed, args.hops, args.maxNodes);
+      }
+      case "metrics": {
+        const args = rawArgs;
+        const store = ChronicleMetricsStore.open(this.chronicleDirectory);
+        try {
+          const refreshed = args.refresh === false ? { ingestedEvents: 0, ingestedBytes: 0, sourceFiles: 0, invalidLines: 0 } : await store.refresh();
+          const data = args.view === "providers" ? store.providerDaily(args.providers) : args.view === "tasks" ? store.taskOutcomes(args.tasks) : args.view === "files" ? store.fileLineage(args.files) : store.summary();
+          return { refreshed, data };
+        } finally {
+          store.close();
+        }
+      }
+    }
+  }
+  async close() {
+    await this.flush();
+    if (this.sqlite) {
+      const store = await this.sqlite;
+      this.sqlite = void 0;
+      store.close();
+    }
+    for (const journal of this.journals.values()) {
+      await journal.flush().catch(() => {
+      });
+    }
+    this.journals.clear();
+  }
+  get chronicleDirectory() {
+    return path2.join(this.options.projectDir, "chronicle");
+  }
+  /**
+   * Drop journals for days we will not write to again.
+   *
+   * Mirrors the daemon's `pruneJournals` in `project-server.ts`: without a cap
+   * an inline access object that lives across midnight kept one open
+   * `ChronicleJournal` (with its write buffer and file handle) per day, forever.
+   */
+  pruneJournals(currentDay) {
+    if (this.journals.size <= MAX_OPEN_JOURNAL_DAYS) return;
+    const keep = new Set(
+      [...this.journals.keys()].sort().reverse().slice(0, MAX_OPEN_JOURNAL_DAYS)
+    );
+    keep.add(currentDay);
+    for (const [day, journal] of this.journals) {
+      if (keep.has(day)) continue;
+      this.journals.delete(day);
+      void journal.flush().catch(() => {
+      });
+    }
+  }
+  journalForToday() {
+    const now = /* @__PURE__ */ new Date();
+    const day = now.toISOString().slice(0, 10);
+    let journal = this.journals.get(day);
+    if (!journal) {
+      const identity = resolveChronicleRuntimeLocation({
+        globalRoot: this.options.globalRoot,
+        projectId: this.options.projectId,
+        projectDir: this.options.projectDir,
+        now
+      });
+      journal = new ChronicleJournal({
+        filePath: legacyPartitionPath(identity),
+        retentionDays: this.options.retentionDays
+      });
+      this.journals.set(day, journal);
+      this.pruneJournals(day);
+    }
+    return journal;
+  }
+  /**
+   * Both engines expose the same read surface, so every `call()` branch is
+   * backend-agnostic. The SQLite one shares the journal's connection, which is
+   * also what makes the legacy import a precondition of reading.
+   */
+  async queryEngine() {
+    if (useSqliteStore()) return (await this.store()).queryEngine();
+    return ChronicleQueryEngine.fromDirectory(this.chronicleDirectory);
+  }
+  async flush() {
+    if (useSqliteStore()) {
+      if (this.sqlite) await this.sqlite;
+      return;
+    }
+    await Promise.all([...this.journals.values()].map((journal) => journal.flush()));
+  }
+  health() {
+    const memory = process.memoryUsage();
+    return {
+      protocolVersion: CHRONICLE_PROJECT_SERVER_PROTOCOL_VERSION,
+      pid: process.pid,
+      projectRoot: this.options.projectRoot,
+      projectDir: this.options.projectDir,
+      chronicleDirectory: this.chronicleDirectory,
+      endpoint: "inline",
+      startedAt: new Date(Date.now() - process.uptime() * 1e3).toISOString(),
+      checkedAt: Date.now(),
+      uptimeMs: Math.round(process.uptime() * 1e3),
+      clients: 1,
+      activeRequests: 0,
+      journal: this.journalForToday().stats(),
+      watcher: { active: false, watchedFiles: 0 },
+      memory: {
+        rss: memory.rss,
+        heapUsed: memory.heapUsed,
+        heapTotal: memory.heapTotal,
+        external: memory.external
+      }
+    };
+  }
+};
+
+export {
+  isChronicleProjectServerAvailable,
+  ChronicleProjectServerClient,
+  ChronicleRemoteJournal,
+  resolveChronicleProjectServerOptions,
+  createChronicleProjectAccess,
+  createChronicleEventJournal
+};
+//# sourceMappingURL=chunk-ASX6AW36.js.map