superbee 0.1.5 → 0.1.6

package/dist/publication.mjs

@@ -3136,8 +3136,8 @@ var require_js_yaml = __commonJS({
 var require_js_yaml2 = __commonJS({
   "../../node_modules/js-yaml/index.js"(exports2, module2) {
     "use strict";
-    var yaml3 = require_js_yaml();
-    module2.exports = yaml3;
+    var yaml4 = require_js_yaml();
+    module2.exports = yaml4;
   }
 });
 
@@ -31491,6 +31491,53 @@ import path3 from "node:path";
 // ../core/src/frontmatter.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
 var import_js_yaml = __toESM(require_js_yaml2(), 1);
+
+// ../core/src/frontmatter-contract.ts
+var MalformedDocumentError = class extends Error {
+  name = "MalformedDocumentError";
+  context;
+  detail;
+  constructor(context, cause) {
+    const detail = ((cause instanceof Error ? cause.message : String(cause)).split("\n")[0] ?? "").trim();
+    super(
+      `malformed frontmatter${context ? ` in '${context}'` : ""}: ${detail} \u2014 fix the YAML or remove the file`
+    );
+    if (context !== void 0) this.context = context;
+    this.detail = detail;
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+
+// ../core/src/frontmatter-splitter.ts
+function delimiterLineEnd(input, offset) {
+  if (!input.startsWith("---", offset)) return null;
+  const suffix = offset + 3;
+  if (suffix === input.length) return suffix;
+  if (input[suffix] === "\n") return suffix + 1;
+  if (input[suffix] === "\r" && input[suffix + 1] === "\n") return suffix + 2;
+  return null;
+}
+function splitLeadingFrontmatter(raw, context) {
+  const input = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+  const openingEnd = delimiterLineEnd(input, 0);
+  if (openingEnd === null) return { body: input };
+  let lineStart = openingEnd;
+  while (lineStart < input.length) {
+    const closingEnd = delimiterLineEnd(input, lineStart);
+    if (closingEnd !== null) {
+      return {
+        yamlSource: input.slice(openingEnd, lineStart),
+        body: input.slice(closingEnd)
+      };
+    }
+    const nextLineFeed = input.indexOf("\n", lineStart);
+    if (nextLineFeed === -1) break;
+    lineStart = nextLineFeed + 1;
+  }
+  throw new MalformedDocumentError(context, new Error("unterminated YAML frontmatter delimiter"));
+}
+
+// ../core/src/frontmatter.ts
 var YAML_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp";
 function requireYamlTimestampType() {
   const type = import_js_yaml.default.DEFAULT_SAFE_SCHEMA.implicit.find(
@@ -31527,38 +31574,17 @@ function normalizeFrontmatter(data) {
   }
   return out;
 }
-var MalformedDocumentError = class extends Error {
-  name = "MalformedDocumentError";
-  /** The document id/path the malformed content belongs to (when the caller supplied one). */
-  context;
-  /** The underlying parser message, first line only — for compact per-doc reporting. */
-  detail;
-  constructor(context, cause) {
-    const detail = ((cause instanceof Error ? cause.message : String(cause)).split("\n")[0] ?? "").trim();
-    super(
-      `malformed frontmatter${context ? ` in '${context}'` : ""}: ${detail} \u2014 fix the YAML or remove the file`
-    );
-    if (context !== void 0) this.context = context;
-    this.detail = detail;
-    if (cause !== void 0) this.cause = cause;
-  }
-};
 function parseMarkdown(raw, context) {
-  if (/^---(?:\r?\n|$)/.test(raw)) {
-    const firstLineEnd = raw.indexOf("\n");
-    const afterOpening = firstLineEnd === -1 ? "" : raw.slice(firstLineEnd + 1);
-    if (!/^---\r?$/m.test(afterOpening)) {
-      throw new MalformedDocumentError(context, new Error("unterminated YAML frontmatter delimiter"));
-    }
-  }
+  const split = splitLeadingFrontmatter(raw, context);
+  if (!("yamlSource" in split)) return { frontmatter: {}, body: split.body };
   let parsed;
   try {
-    parsed = (0, import_gray_matter.default)(raw, { engines: { yaml: yamlEngine } });
+    parsed = yamlEngine.parse(split.yamlSource);
   } catch (err) {
     throw new MalformedDocumentError(context, err);
   }
-  const frontmatter2 = normalizeFrontmatter(parsed.data ?? {});
-  return { frontmatter: frontmatter2, body: parsed.content };
+  const frontmatter2 = normalizeFrontmatter(parsed);
+  return { frontmatter: frontmatter2, body: split.body };
 }
 function normalizeDocumentBodyForStorage(body) {
   return body.endsWith("\n") ? body : `${body}
@@ -31566,13 +31592,13 @@ function normalizeDocumentBodyForStorage(body) {
 }
 function stringifyWithData(data, body) {
   const engines2 = import_gray_matter.default.engines;
-  const yaml3 = engines2.yaml.stringify(data).trim();
+  const yaml4 = engines2.yaml.stringify(data).trim();
   const content3 = body ?? "";
   const newline = (value) => value.endsWith("\n") ? value : `${value}
 `;
-  if (yaml3 === "{}") return normalizeDocumentBodyForStorage(content3);
+  if (yaml4 === "{}") return normalizeDocumentBodyForStorage(content3);
   return `---
-${newline(yaml3)}---
+${newline(yaml4)}---
 ${normalizeDocumentBodyForStorage(content3)}`;
 }
 function stringifyDoc(frontmatter2, body) {
@@ -32478,25 +32504,12 @@ function mutationActorFromFrontmatter(frontmatter2) {
 
 // ../core/src/versioning.ts
 import { createHash as createHash3 } from "node:crypto";
-function sha256Hex(input) {
-  return createHash3("sha256").update(input, "utf8").digest("hex");
-}
-function versionOfBytes(raw) {
-  return `sha256:${sha256Hex(raw)}`;
-}
-function blobVersion(bytes) {
-  return `sha256:${createHash3("sha256").update(bytes).digest("hex")}`;
-}
-function defaultActor() {
-  return process.env.USER?.trim() || process.env.USERNAME?.trim() || process.env.LOGNAME?.trim() || "local";
-}
+
+// ../core/src/version-transport.ts
 var VersionConflict = class extends Error {
   name = "VersionConflict";
-  /** The concept id whose write was rejected. */
   id;
-  /** The version the caller expected the backend to currently hold (`null` = expected absent). */
   expected;
-  /** The version the backend actually holds (`null` if the document does not exist). */
   actual;
   constructor(id, expected, actual) {
     super(
@@ -32508,6 +32521,20 @@ var VersionConflict = class extends Error {
   }
 };
 
+// ../core/src/versioning.ts
+function sha256Hex(input) {
+  return createHash3("sha256").update(input, "utf8").digest("hex");
+}
+function versionOfBytes(raw) {
+  return `sha256:${sha256Hex(raw)}`;
+}
+function blobVersion(bytes) {
+  return `sha256:${createHash3("sha256").update(bytes).digest("hex")}`;
+}
+function defaultActor() {
+  return process.env.USER?.trim() || process.env.USERNAME?.trim() || process.env.LOGNAME?.trim() || "local";
+}
+
 // ../core/src/backend.ts
 var publicationRoots = /* @__PURE__ */ new WeakMap();
 function firstString(...vals) {
@@ -32781,16 +32808,51 @@ function normalizeSegments(segments) {
 function joinPosix(base, rel) {
   return normalizeSegments([...base.split("/"), ...rel.split("/")]).join("/");
 }
-var MD_LINK_RE = /\[([^\]]*)\]\(([^)\s]+)\)/g;
 function isExternalHref(href) {
   const h = href.trim();
   return /^[a-z][a-z0-9+.-]*:\/\//i.test(h) || h.startsWith("mailto:") || h.startsWith("#");
 }
 function extractMarkdownLinks(body) {
   const out = [];
-  for (const m of body.matchAll(MD_LINK_RE)) {
-    if (typeof m.index === "number" && m.index > 0 && body[m.index - 1] === "!") continue;
-    out.push({ text: m[1] ?? "", href: m[2] ?? "" });
+  let textOpen = -1;
+  let afterClose;
+  let hrefFirst;
+  let hrefRest;
+  for (let cursor = 0; cursor < body.length; cursor++) {
+    const char = body[cursor];
+    if (hrefRest) {
+      if (char === ")") {
+        if (hrefRest.open === 0 || body[hrefRest.open - 1] !== "!") {
+          out.push({
+            text: body.slice(hrefRest.open + 1, hrefRest.close),
+            href: body.slice(hrefRest.hrefStart, cursor)
+          });
+        }
+        textOpen = -1;
+        afterClose = void 0;
+        hrefFirst = void 0;
+        hrefRest = void 0;
+        continue;
+      }
+      if (char.trim() === "") hrefRest = void 0;
+    }
+    if (hrefFirst) {
+      if (char !== ")" && char.trim() !== "" && !hrefRest) {
+        hrefRest = hrefFirst;
+      }
+      hrefFirst = void 0;
+    }
+    if (afterClose) {
+      if (char === "(") {
+        hrefFirst = { ...afterClose, hrefStart: cursor + 1 };
+      }
+      afterClose = void 0;
+    }
+    if (textOpen >= 0 && char === "]") {
+      afterClose = { open: textOpen, close: cursor };
+      textOpen = -1;
+    }
+    if (char === "[" && textOpen < 0) textOpen = cursor;
   }
   return out;
 }
@@ -32827,6 +32889,24 @@ function parseLinksFromDoc(doc) {
   return links;
 }
 
+// ../core/src/portable-frontmatter.ts
+var import_js_yaml2 = __toESM(require_js_yaml2(), 1);
+function parseLeadingFrontmatter(raw, context) {
+  const split = splitLeadingFrontmatter(raw, context);
+  if (!("yamlSource" in split)) return {};
+  try {
+    const parsed = import_js_yaml2.default.safeLoad(split.yamlSource);
+    if (parsed === void 0 || parsed === null) return {};
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new TypeError("YAML frontmatter must be a mapping");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof MalformedDocumentError) throw error;
+    throw new MalformedDocumentError(context, error);
+  }
+}
+
 // ../core/src/query-filter.ts
 function matchesFilter(doc, filter) {
   if (filter.prefix && !doc.id.startsWith(filter.prefix)) return false;
@@ -32846,25 +32926,27 @@ function matchesFilter(doc, filter) {
   return true;
 }
 
-// ../core/src/bundle.ts
-function backendFor(bundle) {
-  return bundle.backend ?? new FilesystemBackend(bundle.root);
-}
-async function readBundleOkfVersion(bundle) {
-  const index2 = await backendFor(bundle).readReserved("", "index.md");
+// ../core/src/engine.ts
+async function readBundleOkfVersion(backend) {
+  const index2 = await backend.readReserved("", "index.md");
   if (!index2) return void 0;
-  const value = parseMarkdown(index2.content, "index.md").frontmatter.okf_version;
+  const value = parseLeadingFrontmatter(index2.content, "index.md").okf_version;
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
-async function readDocVersioned(bundle, id) {
+function assertReadableConceptId(id) {
   assertSafeConceptId(id);
   const rel = pathFromConceptId(id);
   if (isReservedFile(rel)) {
     throw new InvalidInputError(`'${id}' is a reserved file (index.md / log.md), not a concept document.`);
   }
-  return backendFor(bundle).read(id);
 }
-var isEnoent = (err) => err?.code === "ENOENT";
+async function readDocVersioned(backend, id) {
+  assertReadableConceptId(id);
+  return backend.read(id);
+}
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
 async function readManyExisting(backend, ids, onMalformed) {
   try {
     return await backend.readMany(ids);
@@ -32875,13 +32957,13 @@ async function readManyExisting(backend, ids, onMalformed) {
     for (const id of ids) {
       try {
         out.push(await backend.read(id));
-      } catch (e) {
-        if (isEnoent(e)) continue;
-        if (e instanceof MalformedDocumentError && onMalformed) {
-          onMalformed({ id, reason: e.detail });
+      } catch (candidate) {
+        if (isEnoent(candidate)) continue;
+        if (candidate instanceof MalformedDocumentError && onMalformed) {
+          onMalformed({ id, reason: candidate.detail });
           continue;
         }
-        throw e;
+        throw candidate;
       }
     }
     return out;
@@ -32891,25 +32973,25 @@ async function scanMatching(backend, filter, onSkip) {
   const ids = await backend.list(filter.prefix);
   const results = [];
   for (const result of await readManyExisting(backend, ids, onSkip)) {
-    if (!matchesFilter(result.doc, filter)) continue;
-    results.push(result);
+    if (matchesFilter(result.doc, filter)) results.push(result);
   }
   results.sort((a, b) => a.doc.id.localeCompare(b.doc.id));
   return results;
 }
-async function query(bundle, filter = {}, options2 = {}) {
-  const scanned = await scanMatching(backendFor(bundle), filter, options2.onSkip);
-  return scanned.map((r) => r.doc);
+async function query(backend, filter = {}, options2 = {}) {
+  return (await scanMatching(backend, filter, options2.onSkip)).map((result) => result.doc);
 }
-async function queryHeads(bundle, filter = {}, options2 = {}) {
-  const backend = backendFor(bundle);
+async function queryHeads(backend, filter = {}, options2 = {}) {
   if (backend.queryHeads) {
-    const rows = (await backend.queryHeads(filter)).filter((r) => matchesFilter(r, filter));
+    const rows = (await backend.queryHeads(filter)).filter((row) => matchesFilter(row, filter));
     rows.sort((a, b) => a.id.localeCompare(b.id));
     return rows;
   }
-  const scanned = await scanMatching(backend, filter, options2.onSkip);
-  return scanned.map(({ doc, version }) => ({ id: doc.id, frontmatter: doc.frontmatter, version }));
+  return (await scanMatching(backend, filter, options2.onSkip)).map(({ doc, version }) => ({
+    id: doc.id,
+    frontmatter: doc.frontmatter,
+    version
+  }));
 }
 function normalizeEdgeSelector(raw) {
   if (raw.endsWith("/")) {
@@ -32922,25 +33004,19 @@ function normalizeEdgeSelector(raw) {
 }
 function matchesEdgeSelector(value, selectors) {
   if (selectors === void 0) return true;
-  for (const normalized of selectors) {
-    if (normalized.endsWith("/")) {
-      if (value.startsWith(normalized)) return true;
-    } else if (value === normalized) {
-      return true;
-    }
-  }
-  return false;
+  return selectors.some(
+    (selector2) => selector2.endsWith("/") ? value.startsWith(selector2) : value === selector2
+  );
 }
-function toSelectorList(v) {
-  if (v === void 0) return void 0;
-  return Array.isArray(v) ? v : [v];
+function toSelectorList(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value : [value];
 }
-async function queryEdges(bundle, filter = {}) {
+async function queryEdges(backend, filter = {}) {
   const fromSelectors = toSelectorList(filter.from)?.map(normalizeEdgeSelector);
   const toSelectors = toSelectorList(filter.to)?.map(normalizeEdgeSelector);
-  const docs = await query(bundle);
   const edges = [];
-  for (const doc of docs) {
+  for (const doc of await query(backend)) {
     for (const link of parseLinksFromDoc(doc)) {
       if (!matchesEdgeSelector(link.from, fromSelectors)) continue;
       if (!matchesEdgeSelector(link.to, toSelectors)) continue;
@@ -32952,6 +33028,26 @@ async function queryEdges(bundle, filter = {}) {
   return edges;
 }
 
+// ../core/src/bundle.ts
+function backendFor(bundle) {
+  return bundle.backend ?? new FilesystemBackend(bundle.root);
+}
+async function readBundleOkfVersion2(bundle) {
+  return readBundleOkfVersion(backendFor(bundle));
+}
+async function readDocVersioned2(bundle, id) {
+  return readDocVersioned(backendFor(bundle), id);
+}
+async function query2(bundle, filter = {}, options2 = {}) {
+  return query(backendFor(bundle), filter, options2);
+}
+async function queryHeads2(bundle, filter = {}, options2 = {}) {
+  return queryHeads(backendFor(bundle), filter, options2);
+}
+async function queryEdges2(bundle, filter = {}) {
+  return queryEdges(backendFor(bundle), filter);
+}
+
 // ../core/src/kinds.ts
 var CONVENTIONS_PREFIX = "conventions/";
 var CONVENTION_TYPE = "Convention";
@@ -33544,7 +33640,7 @@ function applyQuerySelectionFilters(rows, params, kinds = []) {
 // ../core/src/kinds-load.ts
 async function loadKinds(bundle) {
   const warnings = [];
-  const docs = await query(bundle, { prefix: CONVENTIONS_PREFIX, type: CONVENTION_TYPE }, {
+  const docs = await query2(bundle, { prefix: CONVENTIONS_PREFIX, type: CONVENTION_TYPE }, {
     onSkip: ({ id, reason }) => warnings.push({
       code: "KIND_CONVENTION_MALFORMED",
       message: `skipped kind convention '${id}' with unparseable frontmatter: ${reason}`,
@@ -42993,13 +43089,13 @@ var BridgeService = class {
     let outcome;
     try {
       outcome = await this.execute(before, request);
-    } catch (error) {
+    } catch {
       outcome = {
         reply: fail(
           request.id,
           request.bridge,
           "RUNTIME",
-          error instanceof Error ? error.message : String(error)
+          "the View request failed"
         )
       };
     }
@@ -43043,11 +43139,8 @@ var BridgeService = class {
     let next;
     try {
       next = await this.subscriptionSnapshot();
-    } catch (error) {
-      return this.reload(
-        launchId,
-        error instanceof Error ? error.message : String(error)
-      );
+    } catch {
+      return this.reload(launchId, "the View subscription could not be refreshed");
     }
     const after = await this.options.launches.resolve(launchId, true);
     if (!after) return this.reload(launchId, "the View changed while its subscription was polled");
@@ -43082,7 +43175,7 @@ var BridgeService = class {
     return { status: "reload-required", message };
   }
   async subscriptionSnapshot() {
-    const rows = await queryHeads(this.options.bundle, {});
+    const rows = await queryHeads2(this.options.bundle, {});
     if (rows.length > MAX_SUBSCRIPTION_HEADS) {
       throw new Error("the bundle is too large for the experimental View polling snapshot");
     }
@@ -43097,7 +43190,7 @@ var BridgeService = class {
         return { reply: null, openPageId: request.pageId };
       }
       try {
-        const target = await readDocVersioned(this.options.bundle, request.pageId);
+        const target = await readDocVersioned2(this.options.bundle, request.pageId);
         if (!isAnyRegistryId(target.doc.id) || !parseRegistration(target.doc.id, target.doc.frontmatter)) {
           throw new Error("invalid View target");
         }
@@ -43118,13 +43211,13 @@ var BridgeService = class {
       };
     }
     if (request.type === "query") {
-      const rows = await queryHeads(this.options.bundle, {
+      const rows = await queryHeads2(this.options.bundle, {
         ...request.params.type ? { type: request.params.type } : {},
         ...request.params.prefix ? { prefix: request.params.prefix } : {}
       });
       const [registry, okfVersion] = await Promise.all([
         loadKinds(this.options.bundle),
-        readBundleOkfVersion(this.options.bundle)
+        readBundleOkfVersion2(this.options.bundle)
       ]);
       const result = boundedRows(
         rows,
@@ -43139,9 +43232,9 @@ var BridgeService = class {
     }
     if (request.type === "read" || request.type === "read-versioned") {
       const [result, registry, okfVersion] = await Promise.all([
-        readDocVersioned(this.options.bundle, request.docId),
+        readDocVersioned2(this.options.bundle, request.docId),
         loadKinds(this.options.bundle),
-        readBundleOkfVersion(this.options.bundle)
+        readBundleOkfVersion2(this.options.bundle)
       ]);
       if (Buffer.byteLength(result.doc.body, "utf8") > MAX_DOCUMENT_BODY_BYTES) {
         return { reply: fail(request.id, request.bridge, "TOO_LARGE", "the document body exceeded the 1 MiB View limit") };
@@ -43160,7 +43253,7 @@ var BridgeService = class {
     if (request.type === "render-document") {
       let result;
       try {
-        result = await readDocVersioned(this.options.bundle, request.docId);
+        result = await readDocVersioned2(this.options.bundle, request.docId);
       } catch (error) {
         if (error?.code === "ENOENT") {
           return {
@@ -43187,7 +43280,7 @@ var BridgeService = class {
       };
     }
     if (request.type === "edges") {
-      const edges = await queryEdges(this.options.bundle, request.params);
+      const edges = await queryEdges2(this.options.bundle, request.params);
       if (edges.length > MAX_EDGE_ROWS) {
         return { reply: fail(request.id, request.bridge, "TOO_LARGE", `the edge query exceeded ${MAX_EDGE_ROWS} rows`) };
       }