0sec-cli 0.15.0 → 0.17.0

package/chunks/chunk-SOG2U7B3.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+import {
+  homeStateDir
+} from "./chunk-KKGE5RQE.js";
+
+// packages/core/dist/agent/journal/types.js
+var JOURNAL_SCHEMA_VERSION = 1;
+var DEFAULT_JOURNAL_SIDECAR_THRESHOLD_BYTES = 32 * 1024;
+
+// packages/core/dist/agent/journal/migrate.js
+function migrateJournalEntry(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Invalid journal entry: expected object");
+  }
+  const entry = raw;
+  if (entry.schemaVersion === JOURNAL_SCHEMA_VERSION) {
+    return raw;
+  }
+  throw new Error(`Unsupported journal entry schema version: ${String(entry.schemaVersion)}`);
+}
+
+// packages/core/dist/agent/journal/rehydrate.js
+function emptyState() {
+  return {
+    runId: null,
+    lastSeq: -1,
+    toolSteps: [],
+    hypotheses: [],
+    findings: [],
+    notes: [],
+    decisions: [],
+    done: false,
+    summary: ""
+  };
+}
+function orderEntries(entries) {
+  const seqOf = (entry) => {
+    const seq = entry?.seq;
+    return typeof seq === "number" && Number.isFinite(seq) ? seq : Number.POSITIVE_INFINITY;
+  };
+  return entries.map((entry, index) => ({ entry, index })).sort((a, b) => {
+    const sa = seqOf(a.entry);
+    const sb = seqOf(b.entry);
+    if (sa !== sb)
+      return sa - sb;
+    return a.index - b.index;
+  }).map(({ entry }) => entry);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rehydrateContext(entries) {
+  const state = emptyState();
+  if (!Array.isArray(entries) || entries.length === 0)
+    return state;
+  const ordered = orderEntries(entries);
+  const callsByCallId = /* @__PURE__ */ new Map();
+  const hypothesisByStatement = /* @__PURE__ */ new Map();
+  for (const entry of ordered) {
+    if (!entry || typeof entry !== "object" || typeof entry.kind !== "string") {
+      continue;
+    }
+    if (typeof entry.runId === "string" && state.runId === null) {
+      state.runId = entry.runId;
+    }
+    if (typeof entry.seq === "number" && entry.seq > state.lastSeq) {
+      state.lastSeq = entry.seq;
+    }
+    switch (entry.kind) {
+      case "tool_call": {
+        const e = entry;
+        if (typeof e.tool !== "string")
+          break;
+        const step = {
+          tool: e.tool,
+          ...e.arguments !== void 0 ? { arguments: e.arguments } : {},
+          ...typeof e.turn === "number" ? { turn: e.turn } : {},
+          ...e.callId ? { callId: e.callId } : {}
+        };
+        state.toolSteps.push(step);
+        if (e.callId)
+          callsByCallId.set(e.callId, step);
+        break;
+      }
+      case "tool_result": {
+        const e = entry;
+        if (typeof e.tool !== "string")
+          break;
+        const result = {
+          ok: e.ok === true,
+          ...e.output !== void 0 ? { output: e.output } : {},
+          ...typeof e.error === "string" ? { error: e.error } : {}
+        };
+        let target;
+        if (e.callId && callsByCallId.has(e.callId)) {
+          target = callsByCallId.get(e.callId);
+        } else {
+          for (let i = state.toolSteps.length - 1; i >= 0; i -= 1) {
+            const candidate = state.toolSteps[i];
+            if (candidate.tool === e.tool && candidate.result === void 0) {
+              target = candidate;
+              break;
+            }
+          }
+        }
+        if (target) {
+          target.result = result;
+        } else {
+          state.toolSteps.push({
+            tool: e.tool,
+            ...typeof e.turn === "number" ? { turn: e.turn } : {},
+            ...e.callId ? { callId: e.callId } : {},
+            result
+          });
+        }
+        break;
+      }
+      case "hypothesis": {
+        const e = entry;
+        if (typeof e.statement !== "string")
+          break;
+        const existing = hypothesisByStatement.get(e.statement);
+        const merged = {
+          statement: e.statement,
+          ...e.rationale !== void 0 ? { rationale: e.rationale } : existing?.rationale ? { rationale: existing.rationale } : {},
+          ...typeof e.confidence === "number" ? { confidence: e.confidence } : existing?.confidence !== void 0 ? { confidence: existing.confidence } : {},
+          status: e.status ?? existing?.status ?? "open"
+        };
+        hypothesisByStatement.set(e.statement, merged);
+        break;
+      }
+      case "finding": {
+        const e = entry;
+        if (isPlainObject(e.finding))
+          state.findings.push(e.finding);
+        break;
+      }
+      case "observation": {
+        const e = entry;
+        if (typeof e.summary === "string" && e.summary.trim())
+          state.notes.push(e.summary);
+        break;
+      }
+      case "note": {
+        const e = entry;
+        if (typeof e.text === "string" && e.text.trim())
+          state.notes.push(e.text);
+        break;
+      }
+      case "decision": {
+        const e = entry;
+        if (typeof e.decision === "string" && e.decision.trim())
+          state.decisions.push(e.decision);
+        break;
+      }
+      case "done": {
+        const e = entry;
+        state.done = true;
+        if (typeof e.summary === "string")
+          state.summary = e.summary;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of ordered) {
+    if (entry?.kind !== "hypothesis")
+      continue;
+    const statement = entry.statement;
+    if (typeof statement !== "string" || seen.has(statement))
+      continue;
+    seen.add(statement);
+    const merged = hypothesisByStatement.get(statement);
+    if (merged)
+      state.hypotheses.push(merged);
+  }
+  return state;
+}
+
+// packages/core/dist/agent/journal/seed.js
+var MAX_OUTPUT_CHARS = 1200;
+function clip(text, max) {
+  if (text.length <= max)
+    return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+function renderValue(value) {
+  if (value === void 0 || value === null)
+    return "";
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function renderToolStep(step, index) {
+  const turn = typeof step.turn === "number" ? ` (turn ${step.turn})` : "";
+  const args = step.arguments !== void 0 ? ` ${clip(renderValue(step.arguments), 400)}` : "";
+  const lines = [`${index + 1}. ${step.tool}${turn}:${args}`];
+  if (step.result) {
+    if (step.result.ok) {
+      const out = clip(renderValue(step.result.output ?? ""), MAX_OUTPUT_CHARS);
+      lines.push(`   \u2192 ok${out ? `: ${out}` : ""}`);
+    } else {
+      lines.push(`   \u2192 error: ${clip(step.result.error ?? "unknown", 400)}`);
+    }
+  } else {
+    lines.push("   \u2192 (no result recorded)");
+  }
+  return lines.join("\n");
+}
+function renderSeedMessages(state) {
+  const hasProgress = state.toolSteps.length > 0 || state.hypotheses.length > 0 || state.findings.length > 0 || state.notes.length > 0 || state.decisions.length > 0 || state.done || state.summary.trim().length > 0;
+  if (!hasProgress)
+    return [];
+  const sections = [
+    "[Execution journal \u2014 prior progress on this run, rehydrated from disk]"
+  ];
+  if (state.toolSteps.length > 0) {
+    sections.push("## Tool steps so far\n" + state.toolSteps.map((step, i) => renderToolStep(step, i)).join("\n"));
+  }
+  if (state.hypotheses.length > 0) {
+    sections.push("## Hypotheses\n" + state.hypotheses.map((h) => {
+      const conf = typeof h.confidence === "number" ? ` (confidence ${h.confidence})` : "";
+      const rationale = h.rationale ? ` \u2014 ${h.rationale}` : "";
+      return `- [${h.status}] ${h.statement}${conf}${rationale}`;
+    }).join("\n"));
+  }
+  if (state.findings.length > 0) {
+    sections.push("## Findings recorded\n" + state.findings.map((f, i) => `${i + 1}. ${clip(renderValue(f), MAX_OUTPUT_CHARS)}`).join("\n"));
+  }
+  if (state.decisions.length > 0) {
+    sections.push("## Decisions\n" + state.decisions.map((d) => `- ${d}`).join("\n"));
+  }
+  if (state.notes.length > 0) {
+    sections.push("## Notes\n" + state.notes.map((n) => `- ${n}`).join("\n"));
+  }
+  if (state.done && state.summary.trim()) {
+    sections.push(`## Prior run closed
+${state.summary}`);
+  }
+  sections.push("Continue from this state. Use your tools \u2014 do not repeat steps already completed above.");
+  return [
+    {
+      role: "user",
+      content: [{ type: "text", text: sections.join("\n\n") }]
+    }
+  ];
+}
+
+// packages/core/dist/agent/journal/writer.js
+import { closeSync, copyFileSync, createReadStream, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeSync, fsyncSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { dirname, join, resolve, sep } from "node:path";
+function defaultJournalRootDir() {
+  return join(homeStateDir(), "runs");
+}
+function resolveJournalPaths(options) {
+  const runDir = options.runDir ?? join(options.rootDir ?? defaultJournalRootDir(), options.runId);
+  return {
+    runDir,
+    journalPath: join(runDir, "journal.jsonl"),
+    artifactsDir: join(runDir, "artifacts")
+  };
+}
+function branchJournal(options) {
+  const { runId, fromEntry, label, rootDir } = options;
+  const effectiveRootDir = rootDir ?? defaultJournalRootDir();
+  const srcPaths = resolveJournalPaths({ runId, rootDir: effectiveRootDir });
+  if (!existsSync(srcPaths.journalPath)) {
+    throw new Error(`Source journal not found: ${srcPaths.journalPath}`);
+  }
+  const allEntries = loadJournalSync({ runId, rootDir: effectiveRootDir });
+  if (allEntries.length === 0) {
+    throw new Error(`Source journal is empty: ${srcPaths.journalPath}`);
+  }
+  if (fromEntry < 0 || fromEntry >= allEntries.length) {
+    throw new Error(`fromEntry ${fromEntry} is out of range; journal has ${allEntries.length} entries (valid: 0..${allEntries.length - 1})`);
+  }
+  const suffix = label ? `-${label}` : "";
+  const newRunId = `${runId}-branch${suffix}-${randomUUID().slice(0, 8)}`;
+  const dstPaths = resolveJournalPaths({ runId: newRunId, rootDir: effectiveRootDir });
+  mkdirSync(dstPaths.runDir, { recursive: true, mode: 448 });
+  mkdirSync(dstPaths.artifactsDir, { recursive: true, mode: 448 });
+  const entriesToCopy = allEntries.slice(0, fromEntry + 1);
+  const rewrittenEntries = entriesToCopy.map((entry) => ({
+    ...entry,
+    runId: newRunId
+  }));
+  const lines = rewrittenEntries.map((entry) => JSON.stringify(entry)).join("\n") + "\n";
+  const fd = openSync(dstPaths.journalPath, "w", 384);
+  try {
+    writeSync(fd, Buffer.from(lines, "utf8"));
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  const refsToCopy = /* @__PURE__ */ new Set();
+  for (const entry of entriesToCopy) {
+    if (!entry.artifacts)
+      continue;
+    for (const artifact of entry.artifacts) {
+      if (artifact.kind === "ref") {
+        refsToCopy.add(artifact.ref);
+      }
+    }
+  }
+  let artifactsCopied = 0;
+  for (const ref of refsToCopy) {
+    const srcPath = join(srcPaths.runDir, ref);
+    const dstPath = join(dstPaths.runDir, ref);
+    if (existsSync(srcPath)) {
+      mkdirSync(dirname(dstPath), { recursive: true, mode: 448 });
+      copyFileSync(srcPath, dstPath);
+      artifactsCopied += 1;
+    }
+  }
+  fsyncDir(dirname(dstPaths.runDir));
+  return {
+    newRunId,
+    paths: dstPaths,
+    entriesCopied: entriesToCopy.length,
+    artifactsCopied
+  };
+}
+function createJournalWriter(options) {
+  return new FileJournalWriter(options);
+}
+function loadJournal(pathOrOptions, pathOptions) {
+  if (typeof pathOrOptions === "string") {
+    return loadJournalFromPath(pathOrOptions, pathOptions);
+  }
+  return loadJournalSync(pathOrOptions);
+}
+async function* streamJournal(path, options = {}) {
+  if (!existsSync(path))
+    return;
+  const migrate = options.migrate ?? migrateJournalEntry;
+  const runDir = options.runDir ?? dirname(path);
+  const stream = createReadStream(path, { encoding: "utf8" });
+  let buffer = "";
+  let lineNumber = 0;
+  try {
+    for await (const chunk of stream) {
+      buffer += String(chunk);
+      let newline = buffer.indexOf("\n");
+      while (newline !== -1) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        lineNumber += 1;
+        const entry = parseCompleteJournalLine(line, lineNumber, migrate);
+        if (entry) {
+          yield options.preserveRefs ? entry : await rehydrateEntryArtifacts(entry, runDir);
+        }
+        newline = buffer.indexOf("\n");
+      }
+    }
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT" && lineNumber === 0 && !buffer)
+      return;
+    throw err;
+  }
+  if (!buffer.trim())
+    return;
+  try {
+    const entry = migrate(JSON.parse(buffer));
+    yield options.preserveRefs ? entry : await rehydrateEntryArtifacts(entry, runDir);
+  } catch {
+  }
+}
+function loadJournalSync(options) {
+  const paths = resolveJournalPaths(options);
+  if (!existsSync(paths.journalPath))
+    return [];
+  const text = readFileSync(paths.journalPath, "utf8");
+  return parseJournalText(text, options.migrate ?? migrateJournalEntry);
+}
+async function loadJournalFromPath(path, options = {}) {
+  const entries = [];
+  for await (const entry of streamJournal(path, options)) {
+    entries.push(entry);
+  }
+  return entries;
+}
+function parseJournalText(text, migrate) {
+  const lines = text.split("\n");
+  const entries = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.trim())
+      continue;
+    try {
+      entries.push(migrate(JSON.parse(line)));
+    } catch (err) {
+      const isTrailingLine = lines.slice(index + 1).every((rest) => rest.trim() === "");
+      const lineWasTerminated = index < lines.length - 1;
+      if (isTrailingLine && !lineWasTerminated)
+        break;
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Invalid journal line ${index + 1}: ${msg}`);
+    }
+  }
+  return entries;
+}
+function parseCompleteJournalLine(line, lineNumber, migrate) {
+  if (!line.trim())
+    return void 0;
+  try {
+    return migrate(JSON.parse(line));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid journal line ${lineNumber}: ${msg}`);
+  }
+}
+async function rehydrateEntryArtifacts(entry, runDir) {
+  const artifacts = entry.artifacts;
+  if (!artifacts || artifacts.length === 0)
+    return entry;
+  const resolved = await Promise.all(artifacts.map((artifact) => artifact.kind === "ref" ? rehydrateRefArtifact(artifact, runDir) : artifact));
+  return { ...entry, artifacts: resolved };
+}
+async function rehydrateRefArtifact(artifact, runDir) {
+  const sidecarPath = resolveSidecarPath(runDir, artifact.ref);
+  let bytes;
+  try {
+    bytes = await readFile(sidecarPath);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      throw new Error(`Journal sidecar artifact missing: ${artifact.ref}`);
+    }
+    throw err;
+  }
+  const encoding = artifact.mediaType && !artifact.mediaType.startsWith("text/") && !artifact.mediaType.includes("json") ? "base64" : "utf8";
+  const inline = {
+    kind: "inline",
+    ...artifact.name ? { name: artifact.name } : {},
+    ...artifact.mediaType ? { mediaType: artifact.mediaType } : {},
+    content: encoding === "base64" ? bytes.toString("base64") : bytes.toString("utf8"),
+    encoding,
+    sha256: artifact.sha256,
+    size: artifact.size
+  };
+  return inline;
+}
+function resolveSidecarPath(runDir, ref) {
+  const root = resolve(runDir);
+  const resolved = resolve(root, ref);
+  if (resolved !== root && !resolved.startsWith(`${root}${sep}`)) {
+    throw new Error(`Journal artifact ref escapes run directory: ${ref}`);
+  }
+  return resolved;
+}
+var FileJournalWriter = class {
+  paths;
+  runId;
+  sidecarThresholdBytes;
+  now;
+  idFactory;
+  /** Next monotonic seq to assign. Seeded from any pre-existing journal so
+   *  resumed / branched runs continue the numbering rather than restarting. */
+  nextSeq;
+  constructor(options) {
+    this.runId = options.runId;
+    this.paths = resolveJournalPaths(options);
+    this.sidecarThresholdBytes = options.sidecarThresholdBytes ?? DEFAULT_JOURNAL_SIDECAR_THRESHOLD_BYTES;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.idFactory = options.idFactory ?? randomUUID;
+    mkdirSync(this.paths.runDir, { recursive: true, mode: 448 });
+    mkdirSync(this.paths.artifactsDir, { recursive: true, mode: 448 });
+    fsyncDir(dirname(this.paths.runDir));
+    this.nextSeq = seedNextSeq(this.paths.journalPath);
+  }
+  append(input) {
+    const id = input.id ?? this.idFactory();
+    const timestamp = input.timestamp ?? this.now().toISOString();
+    const artifacts = input.artifacts ? materializeArtifacts(this.paths, input.artifacts, this.sidecarThresholdBytes) : void 0;
+    const seq = input.seq ?? this.nextSeq;
+    this.nextSeq = Math.max(this.nextSeq, seq) + 1;
+    const { artifacts: _inputArtifacts, id: _inputId, timestamp: _inputTimestamp, seq: _inputSeq, ...rest } = input;
+    const entry = {
+      schemaVersion: JOURNAL_SCHEMA_VERSION,
+      id,
+      runId: this.runId,
+      seq,
+      timestamp,
+      ...rest,
+      ...artifacts && artifacts.length > 0 ? { artifacts } : {}
+    };
+    atomicAppendJsonLine(this.paths.journalPath, entry);
+    return entry;
+  }
+  load() {
+    return loadJournal({ runId: this.runId, runDir: this.paths.runDir });
+  }
+};
+function seedNextSeq(journalPath) {
+  if (!existsSync(journalPath))
+    return 0;
+  let text;
+  try {
+    text = readFileSync(journalPath, "utf8");
+  } catch {
+    return 0;
+  }
+  const lines = text.split("\n").filter((line) => line.trim() !== "");
+  if (lines.length === 0)
+    return 0;
+  let maxSeq = -1;
+  let sawSeq = false;
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed.seq === "number" && Number.isFinite(parsed.seq)) {
+        sawSeq = true;
+        if (parsed.seq > maxSeq)
+          maxSeq = parsed.seq;
+      }
+    } catch {
+    }
+  }
+  return sawSeq ? maxSeq + 1 : lines.length;
+}
+function materializeArtifacts(paths, artifacts, thresholdBytes) {
+  return artifacts.map((artifact) => {
+    const bytes = artifact.content instanceof Uint8Array ? Buffer.from(artifact.content) : Buffer.from(artifact.content, "utf8");
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    const size = bytes.byteLength;
+    if (artifact.forceSidecar || size > thresholdBytes) {
+      const ext = sanitizeExtension(artifact.ext ?? inferExtension(artifact));
+      const filename = `${sha256}.${ext}`;
+      const absPath = join(paths.artifactsDir, filename);
+      atomicWriteFile(absPath, bytes);
+      const ref = {
+        kind: "ref",
+        ...artifact.name ? { name: artifact.name } : {},
+        ...artifact.mediaType ? { mediaType: artifact.mediaType } : {},
+        ref: `artifacts/${filename}`,
+        sha256,
+        size
+      };
+      return ref;
+    }
+    const binary = artifact.content instanceof Uint8Array;
+    const inline = {
+      kind: "inline",
+      ...artifact.name ? { name: artifact.name } : {},
+      ...artifact.mediaType ? { mediaType: artifact.mediaType } : {},
+      content: binary ? bytes.toString("base64") : bytes.toString("utf8"),
+      encoding: binary ? "base64" : "utf8",
+      sha256,
+      size
+    };
+    return inline;
+  });
+}
+function inferExtension(artifact) {
+  if (artifact.mediaType?.includes("json"))
+    return "json";
+  if (artifact.mediaType?.startsWith("text/"))
+    return "txt";
+  return typeof artifact.content === "string" ? "txt" : "bin";
+}
+function sanitizeExtension(ext) {
+  const cleaned = ext.replace(/^\.+/, "").replace(/[^A-Za-z0-9_-]/g, "").slice(0, 16);
+  return cleaned || "bin";
+}
+var LINUX_PIPE_BUF = 4096;
+function atomicAppendJsonLine(path, entry) {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const line = JSON.stringify(entry) + "\n";
+  const bytes = Buffer.from(line, "utf8");
+  if (bytes.byteLength > LINUX_PIPE_BUF) {
+    process.emitWarning(`journal line ${bytes.byteLength}B exceeds PIPE_BUF (${LINUX_PIPE_BUF}B); concurrent writers may interleave. Consider forcing the artifact to a sidecar.`, { code: "0SEC_JOURNAL_LINE_TOO_LARGE", type: "Warning" });
+  }
+  const fd = openSync(path, "a", 384);
+  try {
+    writeSync(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function atomicWriteFile(path, data) {
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = join(dir, `.${Date.now()}-${randomUUID()}.tmp`);
+  const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+  const fd = openSync(tmp, "w", 384);
+  try {
+    writeSync(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(tmp, path);
+  fsyncDir(dir);
+}
+function fsyncDir(dir) {
+  try {
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+      return;
+    const fd = openSync(dir, "r");
+    try {
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+  }
+}
+
+// packages/core/dist/agent/journal/credential-shared.js
+function buildCredentialSharedEntry(record) {
+  const sourceTarget = record.sourceTarget.trim();
+  const destTarget = record.destTarget.trim();
+  const credentialKind = record.credentialKind.trim();
+  const originatingFindingId = record.originatingFindingId.trim();
+  if (!sourceTarget)
+    throw new Error("credential_shared: sourceTarget is required");
+  if (!destTarget)
+    throw new Error("credential_shared: destTarget is required");
+  if (!credentialKind)
+    throw new Error("credential_shared: credentialKind is required");
+  if (!originatingFindingId)
+    throw new Error("credential_shared: originatingFindingId is required");
+  return {
+    kind: "credential_shared",
+    sourceTarget,
+    destTarget,
+    credentialKind,
+    originatingFindingId,
+    ...record.rationale ? { rationale: record.rationale } : {},
+    ...record.turn !== void 0 ? { turn: record.turn } : {}
+  };
+}
+function appendCredentialShared(sink, record) {
+  sink.append(buildCredentialSharedEntry(record));
+}
+
+export {
+  JOURNAL_SCHEMA_VERSION,
+  DEFAULT_JOURNAL_SIDECAR_THRESHOLD_BYTES,
+  migrateJournalEntry,
+  appendCredentialShared,
+  rehydrateContext,
+  renderSeedMessages,
+  defaultJournalRootDir,
+  resolveJournalPaths,
+  branchJournal,
+  createJournalWriter,
+  loadJournal,
+  streamJournal
+};