@equationalapplications/core-okf 5.3.0 → 5.4.0

package/dist/index.mjs

@@ -24,6 +24,10 @@ function quoteString(value) {
 function serializeScalarString(value) {
   return needsQuoting(value) ? quoteString(value) : value;
 }
+function serializeActorString(value) {
+  if (/[/:]/.test(value)) return quoteString(value);
+  return value;
+}
 function serializeKey(key) {
   if (/\s/.test(key) || needsQuoting(key) || isIso8601Timestamp(key)) {
     return quoteString(key);
@@ -35,8 +39,52 @@ function serializeValue(value) {
   if (typeof value === "boolean") return String(value);
   if (typeof value === "number") return String(value);
   if (typeof value === "string") return serializeScalarString(value);
+  if (Array.isArray(value)) return serializeFlowSequenceValue(value);
+  if (typeof value === "object") return serializeFlowMappingValue(value);
   throw new Error(`Unsupported frontmatter value type: ${typeof value}`);
 }
+function needsFlowQuoting(value) {
+  return needsQuoting(value) || /[,{}[\]/:]/.test(value);
+}
+function serializeFlowScalarString(value) {
+  return needsFlowQuoting(value) ? quoteString(value) : value;
+}
+function serializeFlowMappingValue(obj, depth = 0) {
+  const entries = Object.entries(obj).filter(([, v]) => v !== void 0);
+  if (entries.length === 0) return "{}";
+  const parts = entries.map(([k, v]) => {
+    let rendered;
+    if (typeof v === "string") rendered = serializeFlowScalarString(v);
+    else if (v === null || typeof v === "boolean" || typeof v === "number") rendered = serializeValue(v);
+    else if (Array.isArray(v)) {
+      if (depth >= 1) throw new Error(`serializeFlowMappingValue: nesting deeper than one level is not supported (key "${k}")`);
+      rendered = serializeFlowSequenceValue(v, depth + 1);
+    } else if (typeof v === "object") {
+      if (depth >= 1) throw new Error(`serializeFlowMappingValue: nesting deeper than one level is not supported (key "${k}")`);
+      rendered = serializeFlowMappingValue(v, depth + 1);
+    } else {
+      throw new Error(`serializeFlowMappingValue: unsupported value type for key "${k}"`);
+    }
+    return `${serializeKey(k)}: ${rendered}`;
+  });
+  return `{ ${parts.join(", ")} }`;
+}
+function serializeFlowSequenceValue(arr, depth = 0) {
+  if (arr.length === 0) return "[]";
+  const parts = arr.map((item) => {
+    if (typeof item === "string") return serializeFlowScalarString(item);
+    if (item === null || typeof item === "boolean" || typeof item === "number") return serializeValue(item);
+    if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+      return serializeFlowMappingValue(item, depth);
+    }
+    if (Array.isArray(item)) {
+      if (depth >= 1) throw new Error(`serializeFlowSequenceValue: nested array deeper than one level is not supported`);
+      return serializeFlowSequenceValue(item, depth + 1);
+    }
+    throw new Error("serializeFlowSequenceValue: unsupported item type");
+  });
+  return `[ ${parts.join(", ")} ]`;
+}
 function serializeFrontmatter(fm) {
   const lines = ["---"];
   for (const [key, value] of Object.entries(fm)) {
@@ -44,16 +92,16 @@ function serializeFrontmatter(fm) {
     if (Array.isArray(value)) {
       if (value.length === 0) {
         lines.push(`${serializeKey(key)}: []`);
+      } else if (value.some((item) => item !== null && typeof item === "object")) {
+        lines.push(`${serializeKey(key)}: ${serializeFlowSequenceValue(value)}`);
       } else {
         lines.push(`${serializeKey(key)}:`);
         for (const item of value) {
-          if (typeof item === "string") {
-            lines.push(`  - ${serializeScalarString(item)}`);
-          } else {
-            lines.push(`  - ${serializeValue(item)}`);
-          }
+          lines.push(`  - ${typeof item === "string" ? serializeScalarString(item) : serializeValue(item)}`);
         }
       }
+    } else if (value !== null && typeof value === "object") {
+      lines.push(`${serializeKey(key)}: ${serializeFlowMappingValue(value)}`);
     } else {
       lines.push(`${serializeKey(key)}: ${serializeValue(value)}`);
     }
@@ -132,6 +180,121 @@ function matchFrontmatterKeyValue(line) {
   const tail = line.slice(key.length + 1);
   return { key, value: tail.trimStart(), hasValue: tail.trim().length > 0 };
 }
+function hasUnquotedAnchorOrAlias(text) {
+  let quote = null;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "\\" && i + 1 < text.length) {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "&" || ch === "*") return true;
+  }
+  return false;
+}
+function splitFlowEntries(inner) {
+  const entries = [];
+  let buf = "";
+  let i = 0;
+  let quote = null;
+  let depthBrace = 0;
+  let depthBracket = 0;
+  while (i < inner.length) {
+    const ch = inner[i];
+    if (quote) {
+      buf += ch;
+      if (ch === "\\" && i + 1 < inner.length) {
+        buf += inner[i + 1];
+        i += 2;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      buf += ch;
+      i++;
+      continue;
+    }
+    if (ch === "{") depthBrace++;
+    else if (ch === "}") depthBrace--;
+    else if (ch === "[") depthBracket++;
+    else if (ch === "]") depthBracket--;
+    if (ch === "," && depthBrace === 0 && depthBracket === 0) {
+      entries.push(buf.trim());
+      buf = "";
+      i++;
+      continue;
+    }
+    buf += ch;
+    i++;
+  }
+  if (buf.trim().length > 0) entries.push(buf.trim());
+  if (depthBrace !== 0 || depthBracket !== 0 || quote !== null) return null;
+  return entries;
+}
+function parseFlowMapping(text, depth = 0) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+  if (hasUnquotedAnchorOrAlias(trimmed)) return null;
+  const inner = trimmed.slice(1, -1).trim();
+  if (inner.length === 0) return {};
+  const entries = splitFlowEntries(inner);
+  if (!entries) return null;
+  const out = {};
+  for (const entry of entries) {
+    const kv = matchFrontmatterKeyValue(entry);
+    if (!kv || !kv.hasValue) return null;
+    const v = kv.value.trim();
+    if (v.startsWith("{") || v.startsWith("[")) {
+      if (depth >= 1) return null;
+      const nested = v.startsWith("{") ? parseFlowMapping(v, depth + 1) : parseFlowSequence(v, depth + 1);
+      if (nested === null) return null;
+      out[parseKey(kv.key)] = nested;
+      continue;
+    }
+    out[parseKey(kv.key)] = parseScalarValue(v);
+  }
+  return out;
+}
+function parseFlowSequence(text, depth = 0) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return null;
+  if (hasUnquotedAnchorOrAlias(trimmed)) return null;
+  const inner = trimmed.slice(1, -1).trim();
+  if (inner.length === 0) return [];
+  const entries = splitFlowEntries(inner);
+  if (!entries) return null;
+  const out = [];
+  for (const entry of entries) {
+    const v = entry.trim();
+    if (v.startsWith("{")) {
+      const nested = parseFlowMapping(v, depth);
+      if (nested === null) return null;
+      out.push(nested);
+      continue;
+    }
+    if (v.startsWith("[")) {
+      if (depth >= 1) return null;
+      const nested = parseFlowSequence(v, depth + 1);
+      if (nested === null) return null;
+      out.push(nested);
+      continue;
+    }
+    out.push(parseScalarValue(v));
+  }
+  return out;
+}
 function parseFrontmatter(content) {
   const lines = content.split(/\r?\n/);
   const fallback = { frontmatter: { type: "" }, rest: content };
@@ -169,6 +332,34 @@ function parseFrontmatter(content) {
       frontmatter[key] = items;
       continue;
     }
+    const valueRaw = kv.value.trim();
+    if (valueRaw.startsWith("{")) {
+      const flowObj = parseFlowMapping(valueRaw);
+      if (flowObj !== null) {
+        frontmatter[parseKey(kv.key)] = flowObj;
+        i++;
+        continue;
+      }
+      frontmatter[parseKey(kv.key)] = null;
+      i++;
+      continue;
+    }
+    if (valueRaw.startsWith("[")) {
+      if (valueRaw === "[]") {
+        frontmatter[parseKey(kv.key)] = [];
+        i++;
+        continue;
+      }
+      const flowSeq = parseFlowSequence(valueRaw);
+      if (flowSeq !== null) {
+        frontmatter[parseKey(kv.key)] = flowSeq;
+        i++;
+        continue;
+      }
+      frontmatter[parseKey(kv.key)] = null;
+      i++;
+      continue;
+    }
     frontmatter[parseKey(kv.key)] = parseScalarValue(kv.value);
     i++;
   }
@@ -425,6 +616,181 @@ function extractMarkdownLinks(body) {
   return links;
 }
 
-export { appendEventIdComment, appendRelatedSection, buildConceptDocument, buildEntityIndexMd, buildIndexMd, buildLogMd, buildRootIndexMd, extractMarkdownLinks, isAllowedOkfPath, parseConcept, parseEntityIndexMd, parseEventIdComment, parseFrontmatter, parseLogMd, parseRootIndexMd, serializeFrontmatter, splitRelatedSection };
+// src/footnotes.ts
+var FOOTNOTE_DEFINITION = /^\[\^([^\]]+)\]:\s?(.*)$/;
+function extractFootnotes(body) {
+  const out = [];
+  const lines = body.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const m = FOOTNOTE_DEFINITION.exec(lines[i]);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const id = m[1];
+    const firstLine = m[2] ?? "";
+    const collected = [firstLine];
+    i++;
+    while (i < lines.length) {
+      const next = lines[i];
+      if (FOOTNOTE_DEFINITION.test(next)) break;
+      if (/^\s{2,}\S/.test(next) || /^\s{2,}/.test(next)) {
+        collected.push(next.replace(/^\s{2}/, ""));
+        i++;
+        continue;
+      }
+      break;
+    }
+    out.push({ id, body: collected.join("\n").trimEnd() });
+  }
+  return out;
+}
+function serializeFootnotes(footnotes) {
+  return footnotes.map((f) => {
+    const lines = f.body.split("\n");
+    const [firstLine, ...continuation] = lines;
+    const tail = continuation.map((line) => `
+  ${line}`).join("");
+    return `[^${f.id}]: ${firstLine ?? ""}${tail}`;
+  }).join("\n");
+}
+
+// src/v02-helpers.ts
+function deriveTrustTier(verified) {
+  if (!verified || verified.length === 0) return "unverified";
+  for (const v of verified) {
+    if (typeof v?.by === "string" && v.by.startsWith("human:")) return "human-reviewed";
+  }
+  return "machine-confirmed";
+}
+function parseStaleAfter(staleAfter) {
+  if (staleAfter == null) return null;
+  if (typeof staleAfter === "number") return Number.isFinite(staleAfter) ? staleAfter : null;
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(staleAfter);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const ts = Date.UTC(year, month - 1, day);
+  if (!Number.isFinite(ts)) return null;
+  const d = new Date(ts);
+  if (d.getUTCFullYear() !== year || d.getUTCMonth() + 1 !== month || d.getUTCDate() !== day) {
+    return null;
+  }
+  return ts;
+}
+function isStaleAfter(staleAfter, now) {
+  const cutoff = parseStaleAfter(staleAfter);
+  if (cutoff == null) return false;
+  return now >= cutoff;
+}
+function parseVerifiedFlexible(value) {
+  if (value == null) return [];
+  if (Array.isArray(value)) {
+    return value.filter(
+      (v) => !!v && typeof v === "object" && typeof v.by === "string" && typeof v.at === "string"
+    );
+  }
+  if (typeof value === "object" && typeof value.by === "string" && typeof value.at === "string") {
+    return [value];
+  }
+  return [];
+}
+function formatVerifiedJson(entries) {
+  const sorted = [...entries].sort((a, b) => {
+    const ta = Date.parse(a.at);
+    const tb = Date.parse(b.at);
+    const fa = Number.isFinite(ta);
+    const fb = Number.isFinite(tb);
+    if (fa && fb) return ta - tb;
+    if (fa && !fb) return -1;
+    if (!fa && fb) return 1;
+    return a.at < b.at ? -1 : a.at > b.at ? 1 : 0;
+  });
+  return JSON.stringify(sorted);
+}
+function formatSourcesJson(sources, sharedWindow) {
+  const folded = sources.map(
+    (s) => s.usage_window ? s : sharedWindow ? { ...s, usage_window: sharedWindow } : s
+  );
+  return JSON.stringify(folded);
+}
+function latestVerified(entries, _now) {
+  if (!entries || entries.length === 0) return null;
+  let best = null;
+  let bestAt = -Infinity;
+  for (const e of entries) {
+    const ts = Date.parse(e.at);
+    if (Number.isFinite(ts) && ts > bestAt) {
+      best = e;
+      bestAt = ts;
+    }
+  }
+  if (!best) return null;
+  return { by: best.by, at: bestAt };
+}
+var URL_LINE = /^\s*-\s+(https?:\/\/\S+)\s*$/;
+function parseCitationsList(body) {
+  const lines = body.split(/\r?\n/);
+  let inFence = false;
+  let fenceMarker = "";
+  let fenceLength = 0;
+  let startIdx = -1;
+  const isFenceClose = (marker, fullMatch, line) => {
+    if (marker[0] !== fenceMarker) return false;
+    if (marker.length < fenceLength) return false;
+    return /^\s*$/.test(line.slice(fullMatch.length));
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fence = /^\s*(```+|~~~+)/.exec(line);
+    if (fence) {
+      const marker = fence[1];
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = marker[0];
+        fenceLength = marker.length;
+      } else if (isFenceClose(marker, fence[0], line)) {
+        inFence = false;
+        fenceMarker = "";
+        fenceLength = 0;
+      }
+      continue;
+    }
+    if (!inFence && /^\s*#{1,2}\s*citations\s*$/i.test(line)) {
+      startIdx = i;
+      break;
+    }
+  }
+  if (startIdx === -1) return [];
+  const out = [];
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    const fence = /^\s*(```+|~~~+)/.exec(line);
+    if (fence) {
+      const marker = fence[1];
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = marker[0];
+        fenceLength = marker.length;
+        continue;
+      }
+      if (isFenceClose(marker, fence[0], line)) {
+        inFence = false;
+        fenceMarker = "";
+        fenceLength = 0;
+      }
+      continue;
+    }
+    if (!inFence && /^\s*#{1,2}\s+/.test(line)) break;
+    if (inFence) continue;
+    const m = URL_LINE.exec(line);
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+
+export { appendEventIdComment, appendRelatedSection, buildConceptDocument, buildEntityIndexMd, buildIndexMd, buildLogMd, buildRootIndexMd, deriveTrustTier, extractFootnotes, extractMarkdownLinks, formatSourcesJson, formatVerifiedJson, isAllowedOkfPath, isStaleAfter, latestVerified, parseCitationsList, parseConcept, parseEntityIndexMd, parseEventIdComment, parseFlowMapping, parseFlowSequence, parseFrontmatter, parseLogMd, parseRootIndexMd, parseVerifiedFlexible, serializeActorString, serializeFootnotes, serializeFrontmatter, splitRelatedSection };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map