@mulmoclaude/core 4.5.0 → 4.7.0

package/dist/{server-Wz4_ALLl.cjs → server-DXUt34Rt.cjs}

@@ -33,27 +33,78 @@ let zod = require("zod");
 async function readCustomViewHtml(collection, viewFile, opts = {}) {
 	return readSourceAwareFile(collection, viewFile, opts);
 }
-/** Internal helper: read a file using the same source-aware base fallback as
-*  `readCustomViewHtml`. Used by both `readCustomViewHtml` and
-*  `readCustomViewI18n` so the two stay in lockstep. */
-async function readSourceAwareFile(collection, relPath, opts) {
-	const safeSlug = require_discovery.safeSlugName(collection.slug);
-	if (safeSlug === null) return null;
-	const workspaceRoot = opts.workspaceRoot ?? require_discovery.getWorkspaceRoot();
-	const staging = collection.source === "project" ? require_discovery.stagingSkillDir(workspaceRoot, safeSlug) : null;
-	const bases = staging === null ? [collection.skillDir] : [staging, collection.skillDir];
+/** `<staging>/<slug>` when THAT slug is actually staged there, else null.
+*
+*  `stagingSkillDir` only says whether the ROOT has a staging tree, and then
+*  joins the slug — so on its own it claims every collection in a staged
+*  workspace is staged. That is wrong for the two layouts that coexist there:
+*  a collection IMPORTED via the discover panel, and one committed directly
+*  under `.claude/skills/`, neither of which has a staging copy. A stale
+*  `data/skills/<slug>/views/x.html` left beside them then SHADOWED the real
+*  view on every read (#3031).
+*
+*  The evidence is the slug's own `schema.json`, because that is what the
+*  authoring layout actually produces — `putSchema` writes it, and the delete
+*  path below has always keyed on it. It must be a REGULAR FILE — `lstat`, not
+*  `stat` — so a symlink standing in for the schema is not evidence.
+*
+*  Exported so the DELETE path uses this exact function rather than a second
+*  copy of the expression: "reads and deletes agree" is a claim `views.ts` has
+*  made in its comments since #1836, and sharing the predicate is what makes
+*  it structurally true instead of a convention two files have to remember. */
+async function stagedSkillDir(workspaceRoot, safeSlug) {
+	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
+	if (staging === null) return null;
+	return await isStagedSchema(node_path.default.join(staging, "schema.json")) ? staging : null;
+}
+/** Is the staged `schema.json` there, as a regular file?
+*
+*  NOT `isRegularFile` from `io.ts`, which answers `false` for every `lstat`
+*  failure. Here "no schema" and "the schema could not be inspected" must not
+*  collapse into one answer: the second would quietly downgrade a staged slug
+*  to unstaged and serve the OTHER base's copy — the same masking the read loop
+*  below refuses, and for the same reason (Sourcery review on #3032). Only the
+*  missing-here codes mean "not staged"; anything else propagates. */
+async function isStagedSchema(target) {
+	try {
+		return (await (0, node_fs_promises.lstat)(target)).isFile();
+	} catch (err) {
+		if (!isMissingHere(err)) throw err;
+		return false;
+	}
+}
+/** The two codes that mean "not at this path" rather than "this path failed".
+*  A permission denial / disk error must propagate — silently treating it as
+*  absent masks a real failure as a stale-from-another-base success or a
+*  misleading 404 (CodeRabbit review on #1836). */
+function isMissingHere(err) {
+	return require_dist.isErrorWithCode(err) && (err.code === "ENOENT" || err.code === "ENOTDIR");
+}
+/** Read `relPath` from the first base that holds it, or null when none does.
+*  Bases are tried in order and each is containment-checked on its own, so the
+*  fallback never widens what a single base would have allowed. */
+async function readFromBases(bases, relPath) {
 	for (const base of bases) {
 		const resolved = require_discovery.resolveTemplatePath(base, relPath);
 		if (resolved === null) continue;
 		try {
 			return await (0, node_fs_promises.readFile)(resolved, "utf-8");
 		} catch (err) {
-			if (!require_dist.isErrorWithCode(err)) throw err;
-			if (err.code !== "ENOENT" && err.code !== "ENOTDIR") throw err;
+			if (!isMissingHere(err)) throw err;
 		}
 	}
 	return null;
 }
+/** Internal helper: read a file using the same source-aware base fallback as
+*  `readCustomViewHtml`. Used by both `readCustomViewHtml` and
+*  `readCustomViewI18n` so the two stay in lockstep. */
+async function readSourceAwareFile(collection, relPath, opts) {
+	const safeSlug = require_discovery.safeSlugName(collection.slug);
+	if (safeSlug === null) return null;
+	const workspaceRoot = opts.workspaceRoot ?? require_discovery.getWorkspaceRoot();
+	const staging = collection.source === "project" ? await stagedSkillDir(workspaceRoot, safeSlug) : null;
+	return readFromBases(staging === null ? [collection.skillDir] : [staging, collection.skillDir], relPath);
+}
 var I18N_FALLBACK_LOCALE = "en";
 var EMPTY_I18N = {
 	locale: "",
@@ -1267,27 +1318,20 @@ async function deleteCollection(collection, opts = {}) {
 }
 //#endregion
 //#region src/collection/server/views.ts
-async function fileExists(target) {
-	try {
-		await (0, node_fs_promises.stat)(target);
-		return true;
-	} catch (err) {
-		if (!require_dist.isErrorWithCode(err)) throw err;
-		if (err.code === "ENOENT" || err.code === "ENOTDIR") return false;
-		throw err;
-	}
-}
 /** The authoritative base dir for a collection's schema.json + view HTML.
 *  For a project collection, prefer the staging tree when its schema.json is
 *  present (authoring layout); otherwise fall back to the active skill dir
 *  (imported layout — staging never materialised). For feed / user, it's
-*  always the discovered skillDir. Matches `readCustomViewHtml` so reads and
-*  deletes agree on both layouts. */
+*  always the discovered skillDir.
+*
+*  Matches `readCustomViewHtml` so reads and deletes agree on both layouts —
+*  through the SAME function now (`stagedSkillDir`), not through two copies of
+*  one expression. The read side had drifted off it and was preferring staging
+*  per root rather than per slug (#3031), which is precisely the drift a shared
+*  predicate makes unrepresentable. */
 async function canonicalBase(collection, workspaceRoot, safeSlug) {
 	if (collection.source !== "project") return collection.skillDir;
-	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
-	if (staging !== null && await fileExists(node_path.default.join(staging, "schema.json"))) return staging;
-	return collection.skillDir;
+	return await stagedSkillDir(workspaceRoot, safeSlug) ?? collection.skillDir;
 }
 /** Every on-disk schema.json that must reflect the removal. The active
 *  `<skillDir>/schema.json` is the discovery anchor and is always present.
@@ -1297,9 +1341,9 @@ async function canonicalBase(collection, workspaceRoot, safeSlug) {
 async function schemaWriteTargets(collection, workspaceRoot, safeSlug) {
 	const active = node_path.default.join(collection.skillDir, require_discovery.SCHEMA_FILE);
 	if (collection.source !== "project") return [active];
-	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
+	const staging = await stagedSkillDir(workspaceRoot, safeSlug);
 	const targets = [];
-	if (staging !== null && await fileExists(node_path.default.join(staging, "schema.json"))) targets.push(node_path.default.join(staging, require_discovery.SCHEMA_FILE));
+	if (staging !== null) targets.push(node_path.default.join(staging, require_discovery.SCHEMA_FILE));
 	targets.push(active);
 	return targets;
 }
@@ -2603,6 +2647,12 @@ Object.defineProperty(exports, "schemaRelations", {
 		return schemaRelations;
 	}
 });
+Object.defineProperty(exports, "stagedSkillDir", {
+	enumerable: true,
+	get: function() {
+		return stagedSkillDir;
+	}
+});
 Object.defineProperty(exports, "successorId", {
 	enumerable: true,
 	get: function() {
@@ -2622,4 +2672,4 @@ Object.defineProperty(exports, "validateRecordObject", {
 	}
 });
 
-//# sourceMappingURL=server-Wz4_ALLl.cjs.map
+//# sourceMappingURL=server-DXUt34Rt.cjs.map