superbee 0.4.6-pre.1 → 0.4.6-pre.2

package/dist/publication-bridge.mjs

@@ -2890,15 +2890,30 @@ var FrontmatterRefusedError = class extends InvalidInputError {
   }
 };
 var FilesystemIdentityAliasError = class extends InvalidInputError {
+  reason = "filesystem_alias";
   rel;
   segment;
-  constructor(rel, segment) {
+  existing;
+  suggestedPath;
+  /**
+   * `noun` names the existing entry ("folder" or "file"); `index` is the position of `segment`
+   * in `rel`. Both default from the position of the first segment spelled `segment`.
+   */
+  constructor(rel, segment, existing, noun, index) {
+    const segments = rel.split("/").filter((part) => part !== "" && part !== ".");
+    const at = index ?? segments.indexOf(segment);
+    const kind = noun ?? (at === segments.length - 1 ? "file" : "folder");
+    const clash = existing === void 0 ? `but a ${kind} with that name in a different case or Unicode form already exists` : existing.normalize("NFC") === segment.normalize("NFC") ? `but ${kind} '${existing}' already exists, written in a different Unicode form` : `but ${kind} '${existing}' already exists`;
+    const difference = existing === void 0 ? "case or Unicode form" : existing.normalize("NFC") === segment.normalize("NFC") ? "Unicode form" : existing.toLowerCase() === segment.toLowerCase() ? "case" : "case and Unicode form";
     super(
-      `Path '${rel}' does not match the exact spelling of an existing filesystem entry at segment '${segment}'; ids that differ only by case or Unicode normalization cannot share one file.`
+      `Path '${rel}' uses ${kind} '${segment}', ${clash}, and this disk treats names that differ only by ${difference} as the same name. Use the existing spelling.`
     );
     this.name = "FilesystemIdentityAliasError";
     this.rel = rel;
     this.segment = segment;
+    this.existing = existing;
+    const unusable = existing === void 0 || at < 0 || segments[at] !== segment || kind === "file" && at < segments.length - 1 || existing.normalize("NFC") === segment.normalize("NFC");
+    this.suggestedPath = unusable ? void 0 : segments.map((part, position) => position === at ? existing : part).join("/");
   }
 };
 var ConcurrentReplacementError = class extends Error {
@@ -3103,6 +3118,9 @@ function delimiterLineEnd(input, offset) {
   if (input[suffix] === "\r" && input[suffix + 1] === "\n") return suffix + 2;
   return null;
 }
+function startsWithFrontmatterSyntax(text) {
+  return text.startsWith("\uFEFF") || delimiterLineEnd(text, 0) !== null;
+}
 function splitLeadingFrontmatter(raw, context) {
   const input = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
   const openingEnd = delimiterLineEnd(input, 0);
@@ -3208,7 +3226,10 @@ function stringifyWithSerializedFrontmatter(dumped, body) {
   const content = body ?? "";
   const newline = (value) => value.endsWith("\n") ? value : `${value}
 `;
-  if (dumped === "{}") return normalizeDocumentBodyForStorage(content);
+  if (dumped === "{}") {
+    const stored = normalizeDocumentBodyForStorage(content);
+    return `${startsWithFrontmatterSyntax(stored) ? "---\n---\n" : ""}${stored}`;
+  }
   return `---
 ${newline(dumped)}---
 ${normalizeDocumentBodyForStorage(content)}`;
@@ -4019,36 +4040,57 @@ function hasSourceIdentity(sources, identity) {
   return Array.isArray(sources) && sources.some((entry) => matchesSourceIdentity(entry, identity));
 }
 
+// ../core/src/skip-reasons.ts
+var PERMISSION_DENIED_PREFIX = "permission denied (";
+function permissionDeniedReason(code) {
+  return `${PERMISSION_DENIED_PREFIX}${code})`;
+}
+function isPermissionDeniedSkip(skip) {
+  return skip.reason.startsWith(PERMISSION_DENIED_PREFIX);
+}
+
 // ../core/src/document-scan.ts
 function isEnoent(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
-async function readManyExisting(backend, ids, onMalformed, onAliased) {
-  try {
-    return await backend.readMany(ids);
-  } catch (err) {
-    const malformed = err instanceof MalformedDocumentError && onMalformed !== void 0;
-    const aliased = err instanceof FilesystemIdentityAliasError && onAliased !== void 0;
-    if (!isEnoent(err) && !malformed && !aliased) throw err;
-    const out = [];
-    for (const id of ids) {
-      try {
-        out.push(await backend.read(id));
-      } catch (candidate) {
-        if (isEnoent(candidate)) continue;
-        if (candidate instanceof MalformedDocumentError && onMalformed) {
-          onMalformed({ id, reason: candidate.detail });
-          continue;
-        }
-        if (candidate instanceof FilesystemIdentityAliasError && onAliased) {
-          onAliased({ id, reason: candidate.message });
-          continue;
-        }
-        throw candidate;
+function deniedReason(err) {
+  const code = typeof err === "object" && err !== null ? err.code : void 0;
+  return code === "EACCES" || code === "EPERM" ? permissionDeniedReason(code) : void 0;
+}
+async function readManyExisting(backend, ids, onMalformed, onAliased, onDenied) {
+  const tolerated = (err) => isEnoent(err) || err instanceof MalformedDocumentError && onMalformed !== void 0 || err instanceof FilesystemIdentityAliasError && onAliased !== void 0 || deniedReason(err) !== void 0 && onDenied !== void 0;
+  const readOne = async (id) => {
+    try {
+      return [await backend.read(id)];
+    } catch (candidate) {
+      if (isEnoent(candidate)) return [];
+      if (candidate instanceof MalformedDocumentError && onMalformed) {
+        onMalformed({ id, reason: candidate.detail });
+        return [];
+      }
+      if (candidate instanceof FilesystemIdentityAliasError && onAliased) {
+        onAliased({ id, reason: candidate.message });
+        return [];
       }
+      const reason = deniedReason(candidate);
+      if (reason !== void 0 && onDenied) {
+        onDenied({ id, reason });
+        return [];
+      }
+      throw candidate;
     }
-    return out;
-  }
+  };
+  const readBatch = async (batch) => {
+    try {
+      return await backend.readMany(batch);
+    } catch (err) {
+      if (!tolerated(err)) throw err;
+      if (batch.length === 1) return readOne(batch[0]);
+      const half = Math.ceil(batch.length / 2);
+      return [...await readBatch(batch.slice(0, half)), ...await readBatch(batch.slice(half))];
+    }
+  };
+  return readBatch(ids);
 }
 
 // ../core/src/engine.ts
@@ -4072,7 +4114,7 @@ async function readDocVersioned(backend, id) {
 async function scanMatching(backend, filter, onSkip) {
   const ids = await backend.list(filter.prefix);
   const results = [];
-  for (const result of await readManyExisting(backend, ids, onSkip)) {
+  for (const result of await readManyExisting(backend, ids, onSkip, void 0, onSkip)) {
     if (matchesFilter(result.doc, filter)) results.push(result);
   }
   results.sort((a, b) => compareCodeUnits(a.doc.id, b.doc.id));
@@ -4197,7 +4239,7 @@ function assertStorableReservedWrite(dir, name, content) {
 // ../core/src/filesystem-identity.ts
 import { promises as fs2 } from "node:fs";
 import path2 from "node:path";
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 
 // ../core/src/filesystem-lock.ts
 import { promises as fs, realpathSync } from "node:fs";
@@ -4252,6 +4294,8 @@ import { createHash, randomUUID } from "node:crypto";
 var OWNER_FILE = "owner.json";
 var DEFAULT_WAIT_MS = 5e3;
 var DEFAULT_POLL_MS = 25;
+var UNREADABLE_OWNER_POLL_MS = 2e3;
+var ABANDONED_CLAIM_AGE_MS = 2e3;
 var FilesystemMutationLockError = class extends Error {
   lockPath;
   owner;
@@ -4339,9 +4383,13 @@ async function readOwnerRecord(lockPath) {
   return owner === null ? { state: "absent" } : { state: "record", owner };
 }
 async function resolveOwnerRecord(lockPath, started, waitMs, pollMs) {
+  let firstUnreadable;
   while (true) {
     const record2 = await readOwnerRecord(lockPath);
-    if (record2.state !== "unreadable" || Date.now() - started >= waitMs) return record2;
+    if (record2.state !== "unreadable") return record2;
+    const now = Date.now();
+    firstUnreadable ??= now;
+    if (now - started >= waitMs || now - firstUnreadable >= UNREADABLE_OWNER_POLL_MS) return record2;
     await delay(pollMs);
   }
 }
@@ -4392,6 +4440,17 @@ async function quarantineStaleLock(lockPath, owner, policy) {
     throw err;
   }
 }
+async function removeAbandonedClaim(lockPath) {
+  try {
+    const info = await fs.lstat(lockPath);
+    const age = Date.now() - info.mtimeMs;
+    if (!info.isDirectory() || age < ABANDONED_CLAIM_AGE_MS) return false;
+    await fs.rmdir(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -4442,7 +4501,7 @@ async function timeoutError(lockPath, snapshot, guarded) {
   const sameHost = owner?.hostname === hostname();
   let message;
   if (malformed) {
-    message = `timed out waiting for filesystem mutation lock '${lockPath}'; its owner metadata is missing or malformed. Inspect and remove the lock only after confirming no process is mutating the target, then retry.`;
+    message = `timed out waiting for filesystem mutation lock '${lockPath}'; its owner metadata is missing or malformed. Remove the lock directory once no Superbee process is running, then retry.`;
   } else if (stale) {
     message = `stale filesystem mutation lock '${lockPath}' belongs to absent PID ${owner.pid} on ${owner.hostname}. Inspect and remove the lock, then retry.`;
   } else if (!sameHost) {
@@ -4491,7 +4550,9 @@ async function claimLockPath(lockPath, owner, waitMs, pollMs, policy) {
       } else {
         unwitnessedRetryUsed = false;
       }
-      let existingOwner = await readOwner(lockPath);
+      const existing = await readOwnerRecord(lockPath);
+      let existingOwner = existing.state === "record" ? existing.owner : null;
+      if (existing.state === "absent" && await removeAbandonedClaim(lockPath)) continue;
       if (existingOwner !== null) {
         if (await quarantineStaleLock(lockPath, existingOwner, policy)) continue;
         existingOwner = await readOwner(lockPath);
@@ -4511,14 +4572,13 @@ async function claimLockPath(lockPath, owner, waitMs, pollMs, policy) {
       });
     } catch (err) {
       const code = err.code;
-      if (code === "EEXIST") {
+      if (code === "EEXIST" || code === "ENOENT" || code === "ENOTDIR" || await claimDirectoryLost(lockPath, claimed)) {
         heldTokens.delete(owner.token);
         continue;
       }
       await rollBackOwnClaim(lockPath, owner, claimed, waitMs, pollMs, policy).catch(() => {
       });
       heldTokens.delete(owner.token);
-      if (code === "ENOENT" || code === "ENOTDIR") continue;
       throw err;
     }
     let inFlight;
@@ -4548,9 +4608,18 @@ async function rollBackOwnClaim(lockPath, owner, claimed, waitMs, pollMs, policy
     return;
   }
   if (record2.state === "unreadable" || !await isClaimedDirectory(lockPath, claimed)) return;
-  const remnant = releasedLockRemnantPath(lockPath, owner);
-  await fs.rename(lockPath, remnant);
-  await fs.rm(remnant, { recursive: true, force: true });
+  await fs.rmdir(lockPath);
+}
+async function claimDirectoryLost(lockPath, claimed) {
+  try {
+    const current = await fs.lstat(lockPath, { bigint: true });
+    if (claimed === null) return false;
+    const reborn = claimed.birthtimeNs > 0n && current.birthtimeNs > 0n && current.birthtimeNs !== claimed.birthtimeNs;
+    return current.dev !== claimed.dev || current.ino !== claimed.ino || reborn;
+  } catch (err) {
+    const code = err.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+  }
 }
 async function isClaimedDirectory(lockPath, claimed) {
   if (claimed === null || claimed.birthtimeNs <= 0n) return false;
@@ -4652,6 +4721,12 @@ function foldSegment(segment) {
   return segment.normalize("NFKD").toLowerCase().toUpperCase().toLowerCase();
 }
 
+// ../core/src/filesystem-temp-name.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+function identityTempName(leaf) {
+  return `.${leaf}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
+}
+
 // ../core/src/filesystem-identity.ts
 async function replaceExistingLeaf(port, tmp, target, rel) {
   try {
@@ -4796,10 +4871,32 @@ async function probeSegment(port, candidate, rel, segment) {
 function hasExact(listing, segment) {
   return listing.some((entry) => entry.name === segment);
 }
+function existingSpelling(names, segment) {
+  const folded = foldSegment(segment);
+  const matches = [...names].filter((name) => name !== segment && foldSegment(name) === folded);
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function entryNoun(kind, leaf) {
+  if (kind === void 0) return leaf ? "file" : "folder";
+  return kind === "directory" ? "folder" : "file";
+}
+function aliasRefusal(rel, segments, index, names, kind) {
+  const segment = segments[index];
+  return new FilesystemIdentityAliasError(rel, segment, existingSpelling(names, segment), entryNoun(kind, index === segments.length - 1), index);
+}
+function aliasRefusalFromListing(rel, index, listing, leaf) {
+  const segment = relSegments(rel)[index];
+  const existing = existingSpelling(listing.map((entry) => entry.name), segment);
+  const kind = existing === void 0 ? void 0 : listing.find((entry) => entry.name === existing)?.kind;
+  return new FilesystemIdentityAliasError(rel, segment, existing, entryNoun(kind, leaf), index);
+}
+function listingView(names) {
+  return { has: (name) => names.has(name), names: () => names };
+}
 function freshListings(port) {
   return async (dir) => {
     const listing = await port.entries(dir);
-    return listing === null ? null : { has: (name) => hasExact(listing, name) };
+    return listing === null ? null : { has: (name) => hasExact(listing, name), names: () => listing.map((entry) => entry.name) };
   };
 }
 async function walkExact(port, rootResolved, segments, rel) {
@@ -4811,7 +4908,7 @@ async function walkExact(port, rootResolved, segments, rel) {
     if (probed === null) return { state: "absent", depth: index };
     const listing = await port.entries(parent);
     if (listing === null) return { state: "absent", depth: index };
-    if (!hasExact(listing, segment)) throw new FilesystemIdentityAliasError(rel, segment);
+    if (!hasExact(listing, segment)) throw aliasRefusal(rel, segments, index, listing.map((entry) => entry.name), probed.kind);
     if (index === segments.length - 1) return { state: "exact", leaf: probed };
     if (probed.kind !== "directory") return { state: "shape-mismatch", segment };
     parent = candidate;
@@ -4826,35 +4923,53 @@ async function recordWalk(port, rootResolved, segments, rel) {
     const segment = segments[index];
     const candidate = path2.join(parent, segment);
     const probed = await probeSegment(port, candidate, rel, segment);
-    if (probed === null) return null;
-    if (index < segments.length - 1 && probed.kind !== "directory") return null;
+    if (probed === null) return { recorded, complete: false };
     recorded.push(probed);
+    if (index < segments.length - 1 && probed.kind !== "directory") return { recorded, complete: false };
     parent = candidate;
   }
-  return recorded;
+  return { recorded, complete: true };
 }
-async function confirmedWalk(port, rootResolved, segments, rel, recorded, handle, listings = freshListings(port)) {
+async function confirmedWalk(port, rootResolved, segments, rel, recorded, handle, listings = freshListings(port), stopAt = segments.length) {
   let parent = rootResolved;
-  for (let index = 0; index < segments.length; index++) {
+  for (let index = 0; index < stopAt; index++) {
     const segment = segments[index];
     const candidate = path2.join(parent, segment);
     const listing = await listings(parent);
     if (listing === null) return "absent";
     const listed = listing.has(segment);
     if (handle !== null && index === segments.length - 1) {
-      const verdict = classifyLeaf({ listed, probe: await probeSegment(port, candidate, rel, segment), handle });
-      if (verdict === "aliased") throw new FilesystemIdentityAliasError(rel, segment);
+      const probe = await probeSegment(port, candidate, rel, segment);
+      const verdict = classifyLeaf({ listed, probe, handle });
+      if (verdict === "aliased") throw aliasRefusal(rel, segments, index, listing.names(), probe?.kind);
       return verdict === "replaced" ? "restart" : verdict;
     }
     if (index < segments.length - 1 || !listed) {
-      const verdict = confirmAlias(listed, await probeSegment(port, candidate, rel, segment), recorded[index]);
-      if (verdict === "aliased") throw new FilesystemIdentityAliasError(rel, segment);
+      const probe = await probeSegment(port, candidate, rel, segment);
+      const verdict = confirmAlias(listed, probe, recorded[index]);
+      if (verdict === "aliased") throw aliasRefusal(rel, segments, index, listing.names(), probe?.kind);
       if (verdict !== "continue") return verdict;
     }
     parent = candidate;
   }
   return "continue";
 }
+async function confirmPrefix(port, rootResolved, segments, rel, recorded) {
+  if (recorded.length === 0) return "absent";
+  let kept = prefixListings.get(port);
+  if (kept === void 0) prefixListings.set(port, kept = /* @__PURE__ */ new Map());
+  const cached = witnessedListings(port, kept, Date.now, PREFIX_LISTING_CAPACITY);
+  let verdict;
+  try {
+    verdict = await confirmedWalk(port, rootResolved, segments, rel, recorded, null, cached.source, recorded.length);
+  } catch (error) {
+    if (!cached.reused()) throw error;
+    kept.clear();
+    verdict = await confirmedWalk(port, rootResolved, segments, rel, recorded, null, freshListings(port), recorded.length);
+  }
+  if (verdict === "restart" && cached.reused()) kept.clear();
+  return verdict === "restart" ? "restart" : "absent";
+}
 function countRestart(restarts, rel) {
   if (restarts >= MAX_RESTARTS) throw new ConcurrentReplacementError(rel, restarts + 1);
   return restarts + 1;
@@ -4866,8 +4981,14 @@ async function observeWith(port, rootResolved, rel, read, listings, onExact) {
   const segments = relSegments(rel);
   const target = path2.join(rootResolved, ...segments);
   for (let restarts = 0; ; ) {
-    const recorded = await recordWalk(port, rootResolved, segments, rel);
-    if (recorded === null) return { state: "absent" };
+    const walk = await recordWalk(port, rootResolved, segments, rel);
+    if (!walk.complete) {
+      const prefix = await confirmPrefix(port, rootResolved, segments, rel, walk.recorded);
+      if (prefix === "absent") return { state: "absent" };
+      restarts = countRestart(restarts, rel);
+      continue;
+    }
+    const recorded = walk.recorded;
     const verified = await confirmedWalk(port, rootResolved, segments, rel, recorded, null, listings);
     if (verified === "absent") return { state: "absent" };
     if (verified === "restart") {
@@ -4906,8 +5027,14 @@ async function probeExact(port, root, rel) {
   const segments = relSegments(rel);
   const rootResolved = path2.resolve(root);
   for (let restarts = 0; ; ) {
-    const recorded = await recordWalk(port, rootResolved, segments, rel);
-    if (recorded === null) return { state: "absent" };
+    const walk = await recordWalk(port, rootResolved, segments, rel);
+    if (!walk.complete) {
+      const prefix = await confirmPrefix(port, rootResolved, segments, rel, walk.recorded);
+      if (prefix === "absent") return { state: "absent" };
+      restarts = countRestart(restarts, rel);
+      continue;
+    }
+    const recorded = walk.recorded;
     const leaf = recorded[recorded.length - 1];
     const verified = await confirmedWalk(port, rootResolved, segments, rel, recorded, null);
     const verdict = verified === "continue" ? await confirmedWalk(port, rootResolved, segments, rel, recorded, leaf) : verified;
@@ -4917,45 +5044,56 @@ async function probeExact(port, root, rel) {
   }
 }
 var SETTLED_AFTER_NS = 3000000000n;
+function witnessCanDetectChange(witness) {
+  return witness.mtimeNs > 0n && witness.ctimeNs > 0n;
+}
 function witnessKey(witness) {
   return `${witness.dev}:${witness.ino}:${witness.mtimeNs}:${witness.ctimeNs}`;
 }
-function openObservationPass(port, root, now = Date.now) {
-  const rootResolved = path2.resolve(root);
-  const kept = /* @__PURE__ */ new Map();
-  const reusedVerdicts = [];
-  const fresh = freshListings(port);
-  const witnessOf = port.directoryWitness?.bind(port);
+function witnessedListings(port, kept, now, capacity = Infinity) {
+  let reused = false;
+  const portWitness = port.directoryWitness?.bind(port);
+  if (portWitness === void 0) return { source: freshListings(port), reused: () => false };
+  const witnessOf = async (dir) => {
+    const witness = await portWitness(dir);
+    return witness !== null && witnessCanDetectChange(witness) ? witness : null;
+  };
   const settled = (witness) => {
     const nowNs = BigInt(Math.floor(now())) * 1000000n;
     const latest = witness.mtimeNs > witness.ctimeNs ? witness.mtimeNs : witness.ctimeNs;
     return nowNs - latest >= SETTLED_AFTER_NS;
   };
-  const listingsFor = () => {
-    let reused = false;
-    if (witnessOf === void 0) return { source: fresh, reused: () => false };
-    const source = async (dir) => {
-      const keep = kept.get(dir);
-      if (keep !== void 0) {
-        const current = await witnessOf(dir);
-        if (current !== null && witnessKey(current) === keep.witness) {
-          reused = true;
-          return keep.names;
-        }
-        kept.delete(dir);
-      }
-      const before = await witnessOf(dir);
-      const listing = await port.entries(dir);
-      if (listing === null) return null;
-      const names = new Set(listing.map((entry) => entry.name));
-      const after = await witnessOf(dir);
-      if (before !== null && after !== null && witnessKey(before) === witnessKey(after) && settled(after)) {
-        kept.set(dir, { witness: witnessKey(after), names });
-      }
-      return names;
-    };
-    return { source, reused: () => reused };
+  const source = async (dir) => {
+    const keep = kept.get(dir);
+    if (keep !== void 0) {
+      const current = await witnessOf(dir);
+      if (current !== null && witnessKey(current) === keep.witness) {
+        reused = true;
+        return listingView(keep.names);
+      }
+      kept.delete(dir);
+    }
+    const before = await witnessOf(dir);
+    const listing = await port.entries(dir);
+    if (listing === null) return null;
+    const names = new Set(listing.map((entry) => entry.name));
+    const after = await witnessOf(dir);
+    if (before !== null && after !== null && witnessKey(before) === witnessKey(after) && settled(after)) {
+      kept.delete(dir);
+      kept.set(dir, { witness: witnessKey(after), names });
+      while (kept.size > capacity) kept.delete(kept.keys().next().value);
+    }
+    return listingView(names);
   };
+  return { source, reused: () => reused };
+}
+var prefixListings = /* @__PURE__ */ new WeakMap();
+var PREFIX_LISTING_CAPACITY = 64;
+function openObservationPass(port, root, now = Date.now) {
+  const rootResolved = path2.resolve(root);
+  const kept = /* @__PURE__ */ new Map();
+  const reusedVerdicts = [];
+  const listingsFor = () => witnessedListings(port, kept, now);
   return {
     async observe(rel, read) {
       const listings = listingsFor();
@@ -5058,7 +5196,7 @@ async function readWhole(port, target) {
     await port.close(opened.handle);
   }
 }
-async function mkdirExact(port, parent, segment, isTail, rel) {
+async function mkdirExact(port, parent, segment, isTail, rel, index = -1) {
   const outcome = await port.mkdir(path2.join(parent, segment));
   if (outcome === "created") return;
   const listing = await port.entries(parent);
@@ -5067,7 +5205,9 @@ async function mkdirExact(port, parent, segment, isTail, rel) {
     throw new FilesystemSymlinkEntryError(rel, segment);
   }
   const verdict = classifyMkdir(outcome, listing, segment, isTail);
-  if (verdict === "aliased") throw new FilesystemIdentityAliasError(rel, segment);
+  if (verdict === "aliased") {
+    throw aliasRefusalFromListing(rel, index, listing, false);
+  }
   if (verdict === "shape-mismatch") throw new FilesystemShapeMismatchError(rel, segment);
 }
 async function ensureExactDirectories(port, rootResolved, segments, existingDepth, rel) {
@@ -5087,8 +5227,9 @@ async function ensureExactDirectories(port, rootResolved, segments, existingDept
     }
   }
   let parent = path2.join(rootResolved, ...segments.slice(0, existingDepth));
-  for (const segment of segments.slice(existingDepth, -1)) {
-    await mkdirExact(port, parent, segment, false, rel);
+  for (let index = existingDepth; index < segments.length - 1; index++) {
+    const segment = segments[index];
+    await mkdirExact(port, parent, segment, false, rel, index);
     parent = path2.join(parent, segment);
   }
 }
@@ -5106,7 +5247,7 @@ async function createExactLeaf(port, tmp, target, rel, leaf, rootResolved) {
   }
   const listing = await port.entries(path2.dirname(target)) ?? [];
   if (hasExact(listing, leaf)) throw new ConcurrentReplacementError(rel, 1);
-  throw new FilesystemIdentityAliasError(rel, leaf);
+  throw aliasRefusalFromListing(rel, relSegments(rel).length - 1, listing, true);
 }
 async function mutateExact(port, root, rel, body) {
   const segments = relSegments(rel);
@@ -5128,11 +5269,13 @@ async function mutateExact(port, root, rel, body) {
         async replace(bytes) {
           await ensureExactDirectories(port, rootResolved, segments, existingDepth, rel);
           const dir = path2.dirname(target);
-          const tmpName = `.${leaf}.${process.pid}.${Date.now()}.${randomUUID2()}.tmp`;
+          const tmpName = identityTempName(leaf);
           const tmp = path2.join(dir, tmpName);
           await port.writeTemp(dir, tmpName, bytes);
           try {
             if (realized.state === "exact") {
+              await port.copyMode?.(target, tmp).catch(() => {
+              });
               await replaceExistingLeaf(port, tmp, target, rel);
               return;
             }
@@ -5292,6 +5435,9 @@ function createNodeFilesystemIdentityPort(hostPolicy) {
     async rename(from, to) {
       await fs2.rename(from, to);
     },
+    async copyMode(from, to) {
+      await fs2.chmod(to, (await fs2.lstat(from)).mode & 511);
+    },
     async unlink(target) {
       await fs2.unlink(target);
     },
@@ -5314,6 +5460,7 @@ function blobVersion(bytes) {
 
 // ../core/src/backend.ts
 var publicationContexts = /* @__PURE__ */ new WeakMap();
+var fileMutations = /* @__PURE__ */ new WeakMap();
 function firstString(...vals) {
   for (const v of vals) {
     if (typeof v === "string" && v.trim() !== "") return v;
@@ -5430,6 +5577,7 @@ var FilesystemBackend = class _FilesystemBackend {
     this.#root = path3.resolve(root);
     this.#coordinator = createFilesystemMutationCoordinator(this.#port, this.#root, options.hostPolicy);
     publicationContexts.set(this, { root: this.#root, port: this.#port });
+    fileMutations.set(this, (rel, body) => this.#mutateExact(rel, body));
   }
   async read(id) {
     return this.#readWithEdition(id, () => this.#readEdition());
@@ -5785,6 +5933,7 @@ var KIND_FIELD_TYPE_SET = new Set(KIND_FIELD_TYPES);
 function isKindFieldType(value) {
   return typeof value === "string" && KIND_FIELD_TYPE_SET.has(value);
 }
+var UNDECLARED_FIELDS_POLICIES = ["warn", "error"];
 function buildKindRegistry(docs, initialWarnings = [], options = {}) {
   const accepted = /* @__PURE__ */ new Map();
   const warnings = [...initialWarnings];
@@ -6379,6 +6528,19 @@ function parseConventionDoc(doc, options = {}) {
       });
     }
   }
+  let undeclaredFields;
+  if (fm.undeclared_fields !== void 0) {
+    if (UNDECLARED_FIELDS_POLICIES.includes(fm.undeclared_fields)) {
+      undeclaredFields = fm.undeclared_fields;
+    } else {
+      warnings.push({
+        code: "KIND_CONVENTION_BAD_SHAPE",
+        message: `kind convention '${doc.id}' has an invalid 'undeclared_fields' (${describeShape(fm.undeclared_fields)}; expected warn or error); using warn.`,
+        field: "undeclared_fields",
+        severity: "warning"
+      });
+    }
+  }
   const kind = {
     id: doc.id,
     title,
@@ -6396,6 +6558,7 @@ function parseConventionDoc(doc, options = {}) {
   if (browseCollapsed !== void 0) kind.browseCollapsed = browseCollapsed;
   if (order !== void 0) kind.order = order;
   if (claim !== void 0) kind.claim = claim;
+  if (undeclaredFields !== void 0) kind.undeclaredFields = undeclaredFields;
   if (Object.hasOwn(fm, "deprecated")) {
     kind.deprecated = parseKindDeprecation(fm.deprecated, kind, RESERVED_KIND_FIELD_NAMES, claimCoordinates(options.okfVersion, kind)?.fields ?? []);
     warnings.push(...kind.deprecated.problems ?? []);
@@ -6472,7 +6635,7 @@ async function loadKinds(bundle) {
   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}`,
+      message: isPermissionDeniedSkip({ reason }) ? `skipped kind convention '${id}' that could not be read: ${reason}` : `skipped kind convention '${id}' with unparseable frontmatter: ${reason}`,
       field: id,
       severity: "warning"
     })