superbee 0.1.4 → 0.1.5-pre.2

package/dist/publication.mjs

@@ -1157,7 +1157,7 @@ var require_omap = __commonJS({
     var _toString = Object.prototype.toString;
     function resolveYamlOmap(data) {
       if (data === null) return true;
-      var objectKeys = [], index2, length, pair, pairKey, pairHasKey, object = data;
+      var objectKeys = {}, index2, length, pair, pairKey, pairHasKey, object = data;
       for (index2 = 0, length = object.length; index2 < length; index2 += 1) {
         pair = object[index2];
         pairHasKey = false;
@@ -1169,8 +1169,8 @@ var require_omap = __commonJS({
           }
         }
         if (!pairHasKey) return false;
-        if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-        else return false;
+        if (_hasOwnProperty.call(objectKeys, pairKey)) return false;
+        Object.defineProperty(objectKeys, pairKey, { value: true });
       }
       return true;
     }
@@ -1607,17 +1607,22 @@ var require_loader = __commonJS({
         state.result += _result;
       }
     }
+    function chargeMergeWork(state) {
+      state.totalMergeKeys += 1;
+      if (state.maxTotalMergeKeys !== -1 && state.totalMergeKeys > state.maxTotalMergeKeys) {
+        throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
+      }
+    }
     function mergeMappings(state, destination, source, overridableKeys) {
       var sourceKeys, key, index2, quantity;
       if (!common.isObject(source)) {
         throwError(state, "cannot merge mappings; the provided source object is unacceptable");
       }
+      chargeMergeWork(state);
       sourceKeys = Object.keys(source);
       for (index2 = 0, quantity = sourceKeys.length; index2 < quantity; index2 += 1) {
         key = sourceKeys[index2];
-        if (state.maxTotalMergeKeys !== -1 && ++state.totalMergeKeys > state.maxTotalMergeKeys) {
-          throwError(state, "merge keys exceeded maxTotalMergeKeys (" + state.maxTotalMergeKeys + ")");
-        }
+        chargeMergeWork(state);
         if (!_hasOwnProperty.call(destination, key)) {
           setProperty(destination, key, source[key]);
           overridableKeys[key] = true;
@@ -1646,6 +1651,9 @@ var require_loader = __commonJS({
       }
       if (keyTag === "tag:yaml.org,2002:merge") {
         if (Array.isArray(valueNode)) {
+          if (valueNode.length > 100) {
+            throwError(state, "abnormal merge sequence size");
+          }
           for (index2 = 0, quantity = valueNode.length; index2 < quantity; index2 += 1) {
             mergeMappings(state, _result, valueNode[index2], overridableKeys);
           }
@@ -31536,6 +31544,13 @@ var MalformedDocumentError = class extends Error {
   }
 };
 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"));
+    }
+  }
   let parsed;
   try {
     parsed = (0, import_gray_matter.default)(raw, { engines: { yaml: yamlEngine } });
@@ -31545,16 +31560,20 @@ function parseMarkdown(raw, context) {
   const frontmatter2 = normalizeFrontmatter(parsed.data ?? {});
   return { frontmatter: frontmatter2, body: parsed.content };
 }
+function normalizeDocumentBodyForStorage(body) {
+  return body.endsWith("\n") ? body : `${body}
+`;
+}
 function stringifyWithData(data, body) {
   const engines2 = import_gray_matter.default.engines;
   const yaml3 = engines2.yaml.stringify(data).trim();
   const content3 = body ?? "";
   const newline = (value) => value.endsWith("\n") ? value : `${value}
 `;
-  if (yaml3 === "{}") return newline(content3);
+  if (yaml3 === "{}") return normalizeDocumentBodyForStorage(content3);
   return `---
 ${newline(yaml3)}---
-${newline(content3)}`;
+${normalizeDocumentBodyForStorage(content3)}`;
 }
 function stringifyDoc(frontmatter2, body) {
   return stringifyWithData(frontmatter2, body);
@@ -31839,6 +31858,33 @@ function processExists(pid) {
     return err.code !== "ESRCH";
   }
 }
+function staleLockQuarantinePath(lockPath, owner) {
+  const tokenHash = createHash("sha256").update(owner.token).digest("hex");
+  return `${lockPath}.stale-${tokenHash}`;
+}
+async function pathExists(candidate) {
+  try {
+    await fs.lstat(candidate);
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function quarantineStaleLock(lockPath, owner) {
+  if (owner.hostname !== hostname() || processExists(owner.pid)) return false;
+  const quarantinePath = staleLockQuarantinePath(lockPath, owner);
+  try {
+    await fs.rename(lockPath, quarantinePath);
+    return true;
+  } catch (err) {
+    const code2 = err.code;
+    if (code2 === "ENOENT") return false;
+    if (await pathExists(quarantinePath)) return false;
+    if (process.platform === "win32" && WINDOWS_DIRECTORY_CONTENTION_CODES.has(code2 ?? "")) return false;
+    throw err;
+  }
+}
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -31901,46 +31947,74 @@ async function selectLockRoot(options2) {
   await ensurePrivateLockRoot(lockRoot);
   return lockRoot;
 }
+var WINDOWS_DIRECTORY_CONTENTION_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
+async function classifyLockClaimFailure(error, lockPath) {
+  const code2 = error.code;
+  if (code2 === "EEXIST") return "contention";
+  if (process.platform !== "win32" || !WINDOWS_DIRECTORY_CONTENTION_CODES.has(code2 ?? "")) return "terminal";
+  try {
+    await fs.lstat(lockPath);
+    return "contention";
+  } catch (probeError) {
+    const probeCode = probeError.code;
+    return probeCode === "ENOENT" || probeCode === "ENOTDIR" ? "unwitnessed-windows-sharing-error" : "terminal";
+  }
+}
 async function claimLockPath(lockPath, owner, waitMs, pollMs) {
   const started = owner.created_at_ms;
+  let unwitnessedWindowsRetryUsed = false;
   while (true) {
     try {
       await fs.mkdir(lockPath, { mode: 448 });
-      try {
-        await fs.writeFile(path.join(lockPath, OWNER_FILE), `${JSON.stringify(owner)}
+    } catch (err) {
+      const failure = await classifyLockClaimFailure(err, lockPath);
+      if (failure === "terminal") throw err;
+      if (failure === "unwitnessed-windows-sharing-error") {
+        if (unwitnessedWindowsRetryUsed) throw err;
+        unwitnessedWindowsRetryUsed = true;
+        continue;
+      } else {
+        unwitnessedWindowsRetryUsed = false;
+      }
+      let existingOwner = await readOwner(lockPath);
+      if (existingOwner !== null) {
+        if (await quarantineStaleLock(lockPath, existingOwner)) continue;
+        existingOwner = await readOwner(lockPath);
+      }
+      if (Date.now() - started >= waitMs) throw timeoutError(lockPath, existingOwner, owner.target);
+      await delay(pollMs);
+      continue;
+    }
+    try {
+      await fs.writeFile(path.join(lockPath, OWNER_FILE), `${JSON.stringify(owner)}
 `, {
-          encoding: "utf8",
-          flag: "wx",
-          mode: 384
-        });
-      } catch (err) {
-        await fs.rm(lockPath, { recursive: true, force: true }).catch(() => {
-        });
-        throw err;
-      }
-      return async () => {
-        const current = await readOwner(lockPath);
-        if (current?.token !== owner.token) {
-          throw new FilesystemMutationLockError(
-            `refusing to release filesystem mutation lock '${lockPath}' because its owner token changed; the mutation may have completed, inspect the lock before retrying.`,
-            { lockPath, owner: current, stale: false, malformed: current === null }
-          );
-        }
-        try {
-          await fs.rm(lockPath, { recursive: true, force: false });
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          throw new FilesystemMutationLockError(
-            `mutation completed but filesystem lock '${lockPath}' could not be removed (${message}); inspect the lock before retrying.`,
-            { lockPath, owner: current, stale: false, malformed: false }
-          );
-        }
-      };
+        encoding: "utf8",
+        flag: "wx",
+        mode: 384
+      });
     } catch (err) {
-      if (err.code !== "EEXIST") throw err;
+      await fs.rm(lockPath, { recursive: true, force: true }).catch(() => {
+      });
+      throw err;
     }
-    if (Date.now() - started >= waitMs) throw timeoutError(lockPath, await readOwner(lockPath), owner.target);
-    await delay(pollMs);
+    return async () => {
+      const current = await readOwner(lockPath);
+      if (current?.token !== owner.token) {
+        throw new FilesystemMutationLockError(
+          `refusing to release filesystem mutation lock '${lockPath}' because its owner token changed; the mutation may have completed, inspect the lock before retrying.`,
+          { lockPath, owner: current, stale: false, malformed: current === null }
+        );
+      }
+      try {
+        await fs.rm(lockPath, { recursive: true, force: false });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new FilesystemMutationLockError(
+          `mutation completed but filesystem lock '${lockPath}' could not be removed (${message}); inspect the lock before retrying.`,
+          { lockPath, owner: current, stale: false, malformed: false }
+        );
+      }
+    };
   }
 }
 function newOwner(target) {
@@ -33027,6 +33101,10 @@ var VALID_FIELDS_KEYS = /* @__PURE__ */ new Set([
   "descriptions"
 ]);
 var MISPLACED_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["enum", "enums", "values", "constraints"]);
+var CLAIM_COORDINATE_KEYS = [
+  ["owner_field", "ownerField"],
+  ["state_field", "stateField"]
+];
 function parseConventionDoc(doc) {
   const fm = doc.frontmatter;
   const governs = typeof fm.governs === "string" ? fm.governs.trim() : "";
@@ -33335,6 +33413,35 @@ function parseConventionDoc(doc) {
       if (Object.keys(parsed).length > 0) expectsInbound = parsed;
     }
   }
+  const claimSource = fm.claim;
+  let claim;
+  if (claimSource !== void 0) {
+    if (!isPlainObject(claimSource)) {
+      warnings.push({
+        code: "KIND_CONVENTION_BAD_SHAPE",
+        message: `kind convention '${doc.id}' has a non-map 'claim' key (${describeShape(claimSource)}; expected a map declaring 'owner_field' and/or 'state_field'); ignoring it.`,
+        field: "claim",
+        severity: "warning"
+      });
+    } else {
+      const parsed = {};
+      for (const [key, target] of CLAIM_COORDINATE_KEYS) {
+        const declared = claimSource[key];
+        if (declared === void 0) continue;
+        if (!isScalar(declared) || String(declared).trim() === "") {
+          warnings.push({
+            code: "KIND_CONVENTION_BAD_MEMBER",
+            message: `kind convention '${doc.id}' has a malformed 'claim.${key}' (${describeShape(declared)}; expected a declared field name); skipping it.`,
+            field: `claim.${key}`,
+            severity: "warning"
+          });
+          continue;
+        }
+        parsed[target] = String(declared).trim();
+      }
+      if (parsed.ownerField !== void 0 || parsed.stateField !== void 0) claim = parsed;
+    }
+  }
   const sections = Array.isArray(fm.sections) ? fm.sections.filter((s) => typeof s === "string" && s.trim() !== "") : void 0;
   const title = typeof fm.title === "string" && fm.title.trim() !== "" ? fm.title.trim() : governs;
   let description;
@@ -33367,6 +33474,7 @@ function parseConventionDoc(doc) {
   if (sections && sections.length > 0) kind.sections = sections;
   if (freshnessHorizon !== void 0) kind.freshnessHorizon = freshnessHorizon;
   if (browseCollapsed !== void 0) kind.browseCollapsed = browseCollapsed;
+  if (claim !== void 0) kind.claim = claim;
   return {
     ok: true,
     kind,
@@ -43191,18 +43299,37 @@ async function authorizePublicationRoot(requested) {
 }
 async function assertPublicationRoot(identity) {
   let entry;
+  try {
+    entry = await lstat(identity.requested);
+  } catch (error) {
+    const code2 = error.code;
+    if (code2 === "ENOENT" || code2 === "ENOTDIR") {
+      throw new PublicationError("SOURCE_CHANGED", "the publication source identity became unavailable during capture", { retryable: true, cause: error });
+    }
+    throw new PublicationError("IO_ERROR", "the publication source identity could not be read during capture", { cause: error });
+  }
+  if (entry.isSymbolicLink() || !entry.isDirectory()) {
+    throw new PublicationError("SOURCE_CHANGED", "the publication source root changed during capture", {
+      retryable: true,
+      expected: { canonical: identity.canonical, dev: identity.dev, ino: identity.ino },
+      actual: { symlink: entry.isSymbolicLink(), directory: entry.isDirectory() }
+    });
+  }
   let canonical2;
   let current;
   try {
-    [entry, canonical2, current] = await Promise.all([
-      lstat(identity.requested),
+    [canonical2, current] = await Promise.all([
       realpath(identity.requested),
       stat(identity.requested)
     ]);
   } catch (error) {
-    throw new PublicationError("SOURCE_CHANGED", "the publication source identity became unavailable during capture", { retryable: true, cause: error });
+    const code2 = error.code;
+    if (code2 === "ENOENT" || code2 === "ENOTDIR") {
+      throw new PublicationError("SOURCE_CHANGED", "the publication source identity became unavailable during capture", { retryable: true, cause: error });
+    }
+    throw new PublicationError("IO_ERROR", "the publication source identity could not be read during capture", { cause: error });
   }
-  if (entry.isSymbolicLink() || !entry.isDirectory() || !current.isDirectory() || canonical2 !== identity.canonical || current.dev !== identity.dev || current.ino !== identity.ino) {
+  if (!current.isDirectory() || canonical2 !== identity.canonical || current.dev !== identity.dev || current.ino !== identity.ino) {
     throw new PublicationError("SOURCE_CHANGED", "the publication source root changed during capture", {
       retryable: true,
       expected: { canonical: identity.canonical, dev: identity.dev, ino: identity.ino },
@@ -43378,6 +43505,16 @@ function mapCaptureError(error) {
   }
   return new PublicationError("INVALID_BUNDLE", error instanceof Error ? error.message : "the bundle is invalid", { cause: error });
 }
+async function classifyCaptureError(error, rootIdentity) {
+  const mapped = mapCaptureError(error);
+  if (mapped.code !== "IO_ERROR") return mapped;
+  try {
+    await assertPublicationRoot(rootIdentity);
+  } catch (rootError) {
+    if (rootError instanceof PublicationError && rootError.code === "SOURCE_CHANGED") return rootError;
+  }
+  return mapped;
+}
 function addObject(objects, bytes, mediaType, representation) {
   const digest2 = sha256(bytes);
   if (!objects.has(digest2)) objects.set(digest2, bytes.slice());
@@ -43577,7 +43714,7 @@ async function capturePublicationSnapshot(options2) {
       }
       return handle;
     } catch (error) {
-      lastError = mapCaptureError(error);
+      lastError = await classifyCaptureError(error, rootIdentity);
       if (!lastError.retryable || attempt === maxAttempts) throw lastError;
     }
   }