@remnic/core 9.69.56 → 9.69.57

package/dist/chunk-KQAFEZQX.js

@@ -0,0 +1,264 @@
+import {
+  CAPSULE_ID_PATTERN,
+  CapsuleBlockSchema,
+  ExportBundleV2Schema,
+  ExportManifestV2Schema
+} from "./chunk-WEHSQBFR.js";
+import {
+  encryptCapsuleFile
+} from "./chunk-X7Y7WX73.js";
+import {
+  CAPSULE_SCHEMA_VERSION,
+  EXPORT_FORMAT
+} from "./chunk-J4EB7DNW.js";
+import {
+  DEFAULT_TRANSFER_EXCLUDE_DIRS,
+  computeTransferOutputRel
+} from "./chunk-UI3NYK34.js";
+import {
+  listFilesRecursive,
+  sha256File,
+  toPosixRelPath,
+  writeJsonFile
+} from "./chunk-GCGJW34D.js";
+
+// src/transfer/capsule-export.ts
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import path from "path";
+import { gzipSync } from "zlib";
+var DEFAULT_EXCLUDE_DIRS = DEFAULT_TRANSFER_EXCLUDE_DIRS;
+var TRANSCRIPTS_DIR = "transcripts";
+var PEERS_DIR = "peers";
+async function exportCapsule(opts) {
+  validateName(opts.name);
+  if (opts.encrypt === true && !opts.memoryDir) {
+    throw new Error(
+      "exportCapsule: 'memoryDir' is required when 'encrypt' is true so the secure-store key can be retrieved."
+    );
+  }
+  const encryptionMemoryDir = opts.encrypt === true ? opts.memoryDir : void 0;
+  const sinceMs = parseSince(opts.since);
+  const includeKinds = normalizeIncludeKinds(opts.includeKinds);
+  const peerFilter = normalizePeerIds(opts.peerIds);
+  const transcriptsOverride = opts.includeTranscripts === true;
+  const rootAbs = path.resolve(opts.root);
+  await assertIsDirectory(rootAbs);
+  const outDirAbs = path.resolve(opts.outDir ?? path.join(rootAbs, ".capsules"));
+  if (outDirAbs === rootAbs) {
+    throw new Error(
+      "exportCapsule: 'outDir' must not equal 'root'. Choose a separate directory (default: <root>/.capsules) so the export does not overwrite or shadow the source tree."
+    );
+  }
+  await mkdir(outDirAbs, { recursive: true });
+  const outDirRelPosix = computeTransferOutputRel(rootAbs, outDirAbs);
+  const filesAbs = await listFilesRecursive(rootAbs);
+  const records = [];
+  const manifestFiles = [];
+  for (const abs of filesAbs) {
+    const relPosix = toPosixRelPath(abs, rootAbs);
+    if (!shouldInclude(relPosix, includeKinds, peerFilter, outDirRelPosix, transcriptsOverride)) continue;
+    if (sinceMs !== null) {
+      const st = await stat(abs);
+      if (st.mtimeMs < sinceMs) continue;
+    }
+    const content = await readFile(abs, "utf-8");
+    records.push({ path: relPosix, content });
+    const { sha256, bytes } = await sha256File(abs);
+    manifestFiles.push({ path: relPosix, sha256, bytes });
+  }
+  records.sort((a, b) => a.path.localeCompare(b.path));
+  manifestFiles.sort((a, b) => a.path.localeCompare(b.path));
+  const capsule = buildCapsuleBlock(opts.name, opts.capsule);
+  const includesTranscripts = transcriptsOverride || (includeKinds ?? /* @__PURE__ */ new Set()).has(TRANSCRIPTS_DIR);
+  const createdAtMs = opts.now ?? Date.now();
+  const manifest = ExportManifestV2Schema.parse({
+    format: EXPORT_FORMAT,
+    schemaVersion: CAPSULE_SCHEMA_VERSION,
+    createdAt: new Date(createdAtMs).toISOString(),
+    pluginVersion: opts.pluginVersion ?? "0.0.0",
+    includesTranscripts,
+    files: manifestFiles,
+    capsule
+  });
+  const bundle = ExportBundleV2Schema.parse({
+    manifest,
+    records
+  });
+  const archivePath = path.join(outDirAbs, `${opts.name}.capsule.json.gz`);
+  const manifestPath = path.join(outDirAbs, `${opts.name}.manifest.json`);
+  await writeJsonFile(manifestPath, manifest);
+  const json = JSON.stringify(bundle);
+  const gz = gzipSync(Buffer.from(json, "utf-8"));
+  await writeFile(archivePath, gz);
+  if (opts.encrypt === true) {
+    try {
+      const { encPath } = await encryptCapsuleFile({
+        sourceGzPath: archivePath,
+        memoryDir: encryptionMemoryDir
+      });
+      await unlink(archivePath);
+      return { archivePath: encPath, manifestPath, manifest, encryptedArchivePath: encPath };
+    } catch (error) {
+      try {
+        await unlink(archivePath);
+      } catch {
+      }
+      throw error;
+    }
+  }
+  return { archivePath, manifestPath, manifest, encryptedArchivePath: null };
+}
+function validateName(name) {
+  if (typeof name !== "string" || !CAPSULE_ID_PATTERN.test(name)) {
+    throw new Error(
+      `exportCapsule: invalid capsule name. Expected /${CAPSULE_ID_PATTERN.source}/`
+    );
+  }
+  if (name.length > 64) {
+    throw new Error(
+      "exportCapsule: invalid capsule name. Must be 64 characters or fewer."
+    );
+  }
+}
+var ISO_8601_RE = /^\d{4}-\d{2}-\d{2}(?:[Tt]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:[Zz]|[+-]\d{2}:?\d{2}))?$/;
+function parseSince(since) {
+  if (since === void 0) return null;
+  if (typeof since !== "string" || since.trim() === "") {
+    throw new Error("exportCapsule: 'since' must be a non-empty ISO-8601 string");
+  }
+  if (!ISO_8601_RE.test(since)) {
+    throw new Error(
+      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
+    );
+  }
+  const ms = Date.parse(since);
+  if (!Number.isFinite(ms)) {
+    throw new Error(
+      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
+    );
+  }
+  assertCalendarRoundTrip(since, ms);
+  return ms;
+}
+function isValidCapsuleSince(since) {
+  try {
+    parseSince(since);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertCalendarRoundTrip(since, ms) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(since);
+  if (!m) return;
+  const wantY = Number(m[1]);
+  const wantMo = Number(m[2]);
+  const wantD = Number(m[3]);
+  const offsetMatch = /([+-])(\d{2}):?(\d{2})$/.exec(since);
+  let displayMs = ms;
+  if (offsetMatch) {
+    const sign = offsetMatch[1] === "-" ? -1 : 1;
+    const offsetMin = sign * (Number(offsetMatch[2]) * 60 + Number(offsetMatch[3]));
+    displayMs = ms + offsetMin * 6e4;
+  }
+  const dd = new Date(displayMs);
+  const gotY = dd.getUTCFullYear();
+  const gotMo = dd.getUTCMonth() + 1;
+  const gotD = dd.getUTCDate();
+  if (gotY !== wantY || gotMo !== wantMo || gotD !== wantD) {
+    throw new Error(
+      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
+    );
+  }
+}
+function normalizeIncludeKinds(kinds) {
+  if (kinds === void 0) return null;
+  const set = /* @__PURE__ */ new Set();
+  for (const raw of kinds) {
+    if (typeof raw !== "string" || raw.trim() === "") {
+      throw new Error("exportCapsule: 'includeKinds' entries must be non-empty strings");
+    }
+    if (raw.includes("/") || raw.includes("\\")) {
+      throw new Error(
+        `exportCapsule: 'includeKinds' entries must be top-level segment names, got: ${raw}`
+      );
+    }
+    set.add(raw);
+  }
+  return set;
+}
+function normalizePeerIds(peerIds) {
+  if (peerIds === void 0) return null;
+  const set = /* @__PURE__ */ new Set();
+  for (const raw of peerIds) {
+    if (typeof raw !== "string" || raw.trim() === "") {
+      throw new Error("exportCapsule: 'peerIds' entries must be non-empty strings");
+    }
+    if (raw.includes("/") || raw.includes("\\") || raw === "." || raw === "..") {
+      throw new Error(
+        `exportCapsule: 'peerIds' entries must be plain segment names, got: ${raw}`
+      );
+    }
+    set.add(raw);
+  }
+  return set;
+}
+async function assertIsDirectory(absPath) {
+  const st = await stat(absPath).catch(() => null);
+  if (!st || !st.isDirectory()) {
+    throw new Error(
+      `exportCapsule: 'root' must be an existing directory: ${absPath}`
+    );
+  }
+}
+function shouldInclude(relPosix, includeKinds, peerFilter, outDirRelPosix, transcriptsOverride = false) {
+  const parts = relPosix.split("/");
+  if (parts.some((p) => DEFAULT_EXCLUDE_DIRS.has(p))) return false;
+  if (outDirRelPosix !== null) {
+    if (relPosix === outDirRelPosix) return false;
+    if (relPosix.startsWith(`${outDirRelPosix}/`)) return false;
+  }
+  const top = parts[0];
+  if (top === TRANSCRIPTS_DIR && !transcriptsOverride && (includeKinds === null || !includeKinds.has(TRANSCRIPTS_DIR))) {
+    return false;
+  }
+  if (includeKinds !== null) {
+    if (parts.length < 2) return false;
+    if (!includeKinds.has(top)) return false;
+  }
+  if (top === PEERS_DIR && peerFilter !== null) {
+    if (peerFilter.size === 0) return false;
+    if (parts.length < 2) return false;
+    if (!peerFilter.has(parts[1])) return false;
+  }
+  return true;
+}
+function buildCapsuleBlock(name, override) {
+  const parent = override?.parent ?? null;
+  const parentCapsule = override && Object.prototype.hasOwnProperty.call(override, "parentCapsule") ? override.parentCapsule ?? null : parent?.capsuleId ?? null;
+  const merged = {
+    id: name,
+    version: override?.version ?? "0.1.0",
+    schemaVersion: override?.schemaVersion ?? "taxonomy-v1",
+    parentCapsule,
+    parent,
+    description: override?.description ?? "",
+    retrievalPolicy: override?.retrievalPolicy ?? {
+      tierWeights: {},
+      directAnswerEnabled: false
+    },
+    includes: override?.includes ?? {
+      taxonomy: false,
+      identityAnchors: false,
+      peerProfiles: false,
+      procedural: false
+    }
+  };
+  return CapsuleBlockSchema.parse(merged);
+}
+
+export {
+  exportCapsule,
+  isValidCapsuleSince
+};
+//# sourceMappingURL=chunk-KQAFEZQX.js.map

package/dist/chunk-L4WBADKG.js

@@ -0,0 +1,72 @@
+import {
+  applyRecallStateViews
+} from "./chunk-DBB5JPSL.js";
+import {
+  isGenericRecallExcludedPath
+} from "./chunk-TYP7GYRI.js";
+import {
+  isChangeOrientedQuery
+} from "./chunk-EH3HNCAM.js";
+import {
+  shouldFilterSupersededFromRecall
+} from "./chunk-5WITETWU.js";
+
+// src/recall-state-view-admission.ts
+function resolveRecallStateViewActive(options, config, query) {
+  return (options.stateView === true || config.recallStateViews === true) && isChangeOrientedQuery(query);
+}
+function filterRecentScanMemoriesForStateView(memories, config, supersessionOptions, stateViewActive, asOfMs) {
+  const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
+  let stateViewAdmittedIds = null;
+  if (stateViewActive && !asOfActive) {
+    stateViewAdmittedIds = new Set(
+      memories.filter(
+        (m) => !isGenericRecallExcludedPath(m.path, config) && m.frontmatter.status !== "superseded" && !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions)
+      ).map((m) => m.frontmatter.id).filter((id) => typeof id === "string" && id.length > 0)
+    );
+    for (let progress = true; progress; ) {
+      progress = false;
+      for (const m of memories) {
+        const id = m.frontmatter.id;
+        if (typeof id !== "string" || id.length === 0) continue;
+        if (stateViewAdmittedIds.has(id)) continue;
+        if (isGenericRecallExcludedPath(m.path, config)) continue;
+        if (m.frontmatter.status !== "superseded") continue;
+        if (!shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions)) continue;
+        if (stateViewAdmittedIds.has(m.frontmatter.supersededBy ?? "")) {
+          stateViewAdmittedIds.add(id);
+          progress = true;
+        }
+      }
+    }
+  }
+  return memories.filter((m) => {
+    if (isGenericRecallExcludedPath(m.path, config)) return false;
+    const status = m.frontmatter.status;
+    if (!status || status === "active") return true;
+    if (status === "superseded") {
+      if (asOfActive) return true;
+      const id = m.frontmatter.id;
+      if (stateViewAdmittedIds !== null && typeof id === "string" && stateViewAdmittedIds.has(id)) {
+        return true;
+      }
+      return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);
+    }
+    return false;
+  });
+}
+function indexStateViewAnnotatedResults(results, query, config, stateViewActive, asOfMs) {
+  return new Map(
+    applyRecallStateViews(results, query, config, stateViewActive, asOfMs).map((xr) => [
+      `${xr.namespace ?? ""}\0${xr.path}`,
+      xr
+    ])
+  );
+}
+
+export {
+  resolveRecallStateViewActive,
+  filterRecentScanMemoriesForStateView,
+  indexStateViewAnnotatedResults
+};
+//# sourceMappingURL=chunk-L4WBADKG.js.map

package/dist/chunk-LAL4B37X.js

@@ -0,0 +1,275 @@
+import {
+  OKF_EXPORT_VERSION,
+  lintOkfDir,
+  publishBundle,
+  rejectSymlinkPath,
+  renderFrontmatter,
+  writeBundleFile
+} from "./chunk-UJX4I26O.js";
+import {
+  parseOaiMemCitation
+} from "./chunk-D24OXEPB.js";
+import {
+  resolveNamespaceChildRoot
+} from "./chunk-3UXOZBHV.js";
+import {
+  StorageManager
+} from "./chunk-S2OBXHMN.js";
+import {
+  OKF_PROFILE_TYPE,
+  okfTypeForMemory
+} from "./chunk-PCEYGOSL.js";
+import {
+  normalizeProjectionPreview
+} from "./chunk-SCU65EZI.js";
+import {
+  inferMemoryStatus
+} from "./chunk-7RJUVTVF.js";
+
+// src/transfer/export-okf.ts
+import { mkdirSync, rmSync } from "fs";
+import { mkdtemp } from "fs/promises";
+import path from "path";
+var OKF_LOG_TRUNCATION_MARKER = "<!-- okf-log-truncated -->";
+var DEFAULT_OKF_LOG_MAX_ENTRIES = 500;
+var MEMORY_STATUSES = [
+  "active",
+  "pending_review",
+  "rejected",
+  "quarantined",
+  "superseded",
+  "archived",
+  "forgotten"
+];
+function parseIncludeStatus(raw) {
+  const values = splitCsv(raw);
+  if (values.length === 0) return ["active"];
+  const allowed = new Set(MEMORY_STATUSES);
+  for (const value of values) {
+    if (!allowed.has(value)) {
+      throw new Error(`invalid --include-status ${value}; allowed: ${MEMORY_STATUSES.join(", ")}`);
+    }
+  }
+  return values;
+}
+async function exportOkfBundle(opts) {
+  const outDir = path.resolve(opts.outDir);
+  rejectSymlinkPath(outDir);
+  const namespace = (opts.namespace ?? "").trim();
+  const memoryDir = namespace ? resolveNamespaceChildRoot(opts.memoryDir, namespace, "--namespace") : opts.memoryDir;
+  const includeStatus = new Set(parseIncludeStatus(opts.includeStatus));
+  const includeCategories = opts.includeCategories?.length ? new Set(opts.includeCategories) : null;
+  const excludeTags = new Set(opts.excludeTags ?? []);
+  const storage = new StorageManager(memoryDir);
+  const memories = await storage.readAllMemories();
+  const included = [];
+  let excluded = 0;
+  for (const memory of memories) {
+    const rel = toRel(memory.path, memoryDir);
+    if (!opts.includeWearables && rel.startsWith("wearables/")) {
+      excluded += 1;
+      continue;
+    }
+    const status = inferMemoryStatus(memory.frontmatter, memory.path);
+    if (!includeStatus.has(status)) {
+      excluded += 1;
+      continue;
+    }
+    if (includeCategories && !includeCategories.has(memory.frontmatter.category)) {
+      excluded += 1;
+      continue;
+    }
+    if ((memory.frontmatter.tags ?? []).some((tag) => excludeTags.has(tag))) {
+      excluded += 1;
+      continue;
+    }
+    included.push(memory);
+  }
+  included.sort((a, b) => toRel(a.path, memoryDir).localeCompare(toRel(b.path, memoryDir)));
+  mkdirSync(path.dirname(outDir), { recursive: true });
+  const staging = await mkdtemp(path.join(path.dirname(outDir), ".remnic-okf-export-"));
+  const byCategory = {};
+  const idToRel = /* @__PURE__ */ new Map();
+  for (const memory of included) {
+    const rel = toRel(memory.path, memoryDir);
+    idToRel.set(memory.frontmatter.id, rel);
+  }
+  for (const memory of included) {
+    const rel = toRel(memory.path, memoryDir);
+    const rendered = renderMemory(memory, rel, idToRel);
+    writeBundleFile(staging, rel, rendered);
+    const category = memory.frontmatter.category;
+    byCategory[category] = (byCategory[category] ?? 0) + 1;
+  }
+  if (opts.includeProfile) {
+    try {
+      const profile = await storage.readProfile();
+      if (profile) {
+        writeBundleFile(
+          staging,
+          "profile.md",
+          renderFrontmatter({
+            type: OKF_PROFILE_TYPE,
+            title: "User Profile",
+            timestamp: (/* @__PURE__ */ new Date(0)).toISOString()
+          }) + profile.replace(/^\uFEFF/, "")
+        );
+      }
+    } catch {
+    }
+  }
+  if (opts.includeLog) {
+    const events = await storage.readAllMemoryLifecycleEvents();
+    writeBundleFile(staging, "log.md", renderLog(events, idToRel, opts.logMaxEntries ?? DEFAULT_OKF_LOG_MAX_ENTRIES));
+  }
+  writeIndexes(staging, included, memoryDir);
+  const lint = lintOkfDir(staging);
+  const blocking = lint.findings.filter((f) => f.code !== "skipped_encrypted" && f.code !== "reserved_basename");
+  if (blocking.length > 0) {
+    rmSync(staging, { recursive: true, force: true });
+    throw new Error(`OKF export failed lint: ${blocking.map((f) => `${f.file}: ${f.message}`).join("; ")}`);
+  }
+  publishBundle(staging, outDir, opts.force === true);
+  return {
+    exported: included.length,
+    excluded,
+    byCategory,
+    plaintextWarning: true
+  };
+}
+function renderMemory(memory, rel, idToRel) {
+  const fm = memory.frontmatter;
+  const title = firstHeading(memory.content) ?? `${humanize(fm.category)} ${fm.created.slice(0, 10)}`;
+  const type = fm.type ?? okfTypeForMemory(fm);
+  const fields = {
+    ...fm,
+    type,
+    title,
+    description: normalizeProjectionPreview(memory.content),
+    tags: fm.tags ?? [],
+    timestamp: fm.updated
+  };
+  if (fm.artifactType) fields.resource = rel;
+  let body = memory.content.trim();
+  const citation = parseOaiMemCitation(body);
+  if (citation) {
+    const start = body.indexOf("<oai-mem-citation>");
+    const end = body.indexOf("</oai-mem-citation>");
+    if (start >= 0 && end > start) {
+      body = `${body.slice(0, start).trimEnd()}
+
+${body.slice(end + "</oai-mem-citation>".length).trimStart()}`.trim();
+    }
+    const lines = citation.entries.map((entry, index) => `${index + 1}. [${entry.path}](${entry.path})`);
+    body = `${body}
+
+# Citations
+
+${lines.join("\n")}
+`;
+  }
+  const links = fm.links ?? [];
+  if (links.length > 0) {
+    body += `
+# Related
+
+${links.map((link) => renderRelated(link, idToRel)).join("\n")}
+`;
+  }
+  return renderFrontmatter(fields) + body + (body.endsWith("\n") ? "" : "\n");
+}
+function renderRelated(link, idToRel) {
+  const target = idToRel.get(link.targetId) ?? link.targetId;
+  const href = target.startsWith("/") ? target : `/${target}`;
+  return `- ${link.linkType}: [${link.targetId}](${href})`;
+}
+function writeIndexes(root, memories, memoryDir) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const memory of memories) {
+    const rel = toRel(memory.path, memoryDir);
+    const dir = path.posix.dirname(rel);
+    const key = dir === "." ? "" : dir.split("/")[0] ?? "";
+    const list = groups.get(key) ?? [];
+    list.push(memory);
+    groups.set(key, list);
+  }
+  const sections = [...groups.keys()].sort().map((key) => {
+    const heading = key === "" ? "Root" : humanize(key);
+    const lines = (groups.get(key) ?? []).sort((a, b) => toRel(a.path, memoryDir).localeCompare(toRel(b.path, memoryDir))).map((memory) => {
+      const rel = toRel(memory.path, memoryDir);
+      const title = firstHeading(memory.content) ?? memory.frontmatter.id;
+      const description = normalizeProjectionPreview(memory.content);
+      return `* [${title}](/${rel}) - ${description}`;
+    });
+    return `## ${heading}
+
+${lines.join("\n")}`;
+  });
+  writeBundleFile(root, "index.md", `---
+okf_version: "${OKF_EXPORT_VERSION}"
+---
+
+${sections.join("\n\n")}
+`);
+}
+function renderLog(events, idToRel, maxEntries) {
+  const sorted = [...events].sort((a, b) => String(b.timestamp ?? "").localeCompare(String(a.timestamp ?? "")));
+  const truncated = sorted.length > maxEntries;
+  const kept = sorted.slice(0, maxEntries);
+  const byDay = /* @__PURE__ */ new Map();
+  for (const event of kept) {
+    const day = String(event.timestamp ?? "").slice(0, 10) || "unknown";
+    const list = byDay.get(day) ?? [];
+    list.push(event);
+    byDay.set(day, list);
+  }
+  const days = [...byDay.keys()].sort((a, b) => b.localeCompare(a));
+  const parts = ["# Log", ""];
+  for (const day of days) {
+    parts.push(`## ${day}`, "");
+    for (const event of byDay.get(day) ?? []) {
+      const action = boldAction(event.type ?? event.action ?? "Update");
+      const id = event.memoryId;
+      const rel = id ? idToRel.get(id) : void 0;
+      const target = rel ? `[${id}](/${rel})` : id ?? "";
+      parts.push(`- **${action}** ${target}`.trimEnd());
+    }
+    parts.push("");
+  }
+  if (truncated) parts.push(OKF_LOG_TRUNCATION_MARKER, "");
+  return `${parts.join("\n")}
+`;
+}
+function boldAction(raw) {
+  const lower = raw.toLowerCase();
+  if (lower.includes("create") || lower.includes("add")) return "Creation";
+  if (lower.includes("deprecat") || lower.includes("delete") || lower.includes("archiv")) return "Deprecation";
+  return "Update";
+}
+function firstHeading(content) {
+  for (const line of content.split("\n")) {
+    const match = /^#\s+(\S.*)$/.exec(line.trim());
+    if (match) return match[1].trim();
+  }
+  return void 0;
+}
+function humanize(value) {
+  return value.replace(/[_-]/g, " ").replace(/\b\w/g, (ch) => ch.toUpperCase());
+}
+function splitCsv(raw) {
+  if (raw === void 0 || raw === null || raw === "") return [];
+  const parts = Array.isArray(raw) ? raw.map(String) : String(raw).split(",");
+  return parts.map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function toRel(abs, root) {
+  return path.relative(path.resolve(root), path.resolve(abs)).split(path.sep).join("/");
+}
+
+export {
+  OKF_LOG_TRUNCATION_MARKER,
+  DEFAULT_OKF_LOG_MAX_ENTRIES,
+  parseIncludeStatus,
+  exportOkfBundle,
+  firstHeading
+};
+//# sourceMappingURL=chunk-LAL4B37X.js.map