narraeon 0.7.2 → 0.7.5

package/dist/node/protocol/v1.js

@@ -4,10 +4,12 @@ import { maxPortableContentArchiveBase64Characters } from "./contentTree.js";
 export const v1Protocol = "narraeon.runtime/v1";
 export class V1ProtocolError extends Error {
     code;
-    constructor(code, message, options) {
+    details;
+    constructor(code, message, options = {}) {
         super(message, options);
         this.name = "V1ProtocolError";
         this.code = code;
+        this.details = options.details;
     }
 }
 export function parseV1Envelope(value) {
@@ -37,7 +39,11 @@ const requiredFields = {
     "world.package-scripts.set": { worldId: "string", enabled: "boolean" },
     "content.gameplay.set": { packageId: "string", scheme: "string" },
     "content.read": { packageId: "string" },
-    "content.replace": { packageId: "string", files: "array" },
+    "content.replace": {
+        packageId: "string",
+        files: "array",
+        baseTreeRevision: "string",
+    },
     "content.copy": { packageId: "string" },
     "content.delete": { packageId: "string" },
     "content.rename": { packageId: "string", name: "string" },

package/dist/node/runtime/V1Runtime.js

@@ -7,7 +7,7 @@ import { join } from "node:path";
 import { maxPortableContentArchiveBase64Characters, maxPortableContentArchiveBytes, } from "../protocol/contentTree.js";
 import { V1ProtocolError, v1Protocol, } from "../protocol/v1.js";
 import { defaultAppLocale, } from "../protocol/appPreferences.js";
-import { ContentPackageImportError, ContentWorkspace, InvalidContentTreeError, } from "./content/ContentWorkspace.js";
+import { ContentPackageImportError, ContentTreeConflictError, ContentWorkspace, InvalidContentTreeError, } from "./content/ContentWorkspace.js";
 import { contentTreeFingerprint } from "./content/ContentTreeFingerprint.js";
 import { inspectContentPackageCurrentTree } from "./content/FileNativeContentTree.js";
 import { FileNativeModelHost } from "./model/FileNativeModelAdapters.js";
@@ -197,7 +197,7 @@ export class V1Runtime {
         const chain = result;
         if (chain?.status !== "interrupted" ||
             typeof chain.lastFailure !== "string" ||
-            chain.events?.at(-1)?.kind === "cancellation")
+            chain.lastCancelled === true)
             return;
         await this.#errorLog.recordPlayInterruption(request, {
             message: chain.lastFailure,
@@ -215,6 +215,10 @@ export class V1Runtime {
                 : {}),
         }, error);
     }
+    /** Archive routes sit outside `handle`, so they record their own failures. */
+    async recordArchiveFailure(target, error) {
+        await this.#errorLog?.recordRequestFailure(target, error);
+    }
     subscribeConversation(target, changed) {
         return this.#conversationChanges.subscribe(`${target.kind}:${target.id}`, changed);
     }
@@ -324,13 +328,18 @@ export class V1Runtime {
                 return this.#content.readCurrentTreeContentPackage(request.packageId);
             case "content.replace":
                 try {
-                    return await this.#content.replaceCurrentTreeContentPackage(request.packageId, request.files);
+                    return await this.#content.replaceCurrentTreeContentPackage(request.packageId, request.files, { baseTreeRevision: request.baseTreeRevision });
                 }
                 catch (error) {
                     if (error instanceof InvalidContentTreeError)
                         throw new V1ProtocolError("invalid_request", error.message, {
                             cause: error,
                         });
+                    if (error instanceof ContentTreeConflictError)
+                        throw new V1ProtocolError("content_conflict", error.message, {
+                            cause: error,
+                            details: { current: error.current },
+                        });
                     throw error;
                 }
             case "content.copy":

package/dist/node/runtime/archive/WorldArchives.js

@@ -108,7 +108,23 @@ export class WorldArchives {
             }
         });
     }
+    /**
+     * Confirms that `download` can serve this export without consuming it, so the
+     * browser can check before it starts the one-time download.
+     */
+    async checkDownload(archiveId) {
+        const { root } = await this.#readExport(archiveId);
+        await stat(join(root, "archive.zip"));
+    }
     async download(archiveId) {
+        const { root, metadata } = await this.#readExport(archiveId);
+        return {
+            metadata,
+            stream: createReadStream(join(root, "archive.zip")),
+            cleanup: () => rm(root, { recursive: true, force: true }),
+        };
+    }
+    async #readExport(archiveId) {
         identity(archiveId);
         const root = join(this.#root, "exports", archiveId);
         const metadata = JSON.parse(await readFile(join(root, "download.json"), "utf8"));
@@ -117,11 +133,7 @@ export class WorldArchives {
             await rm(root, { recursive: true, force: true });
             throw new WorldArchiveError("invalid_archive", "The download has expired; export the world again");
         }
-        return {
-            metadata,
-            stream: createReadStream(join(root, "archive.zip")),
-            cleanup: () => rm(root, { recursive: true, force: true }),
-        };
+        return { root, metadata };
     }
     async importWorld(input) {
         identity(input.operationId);

package/dist/node/runtime/content/ContentWorkspace.js

@@ -7,7 +7,7 @@ import { defaultContentWorkspaceLimits, maximumPortableContentArchiveBytes, } fr
 import { CurrentTreeContentLibrary, InvalidContentTreeError, normalizeCurrentContentTreeFiles, } from "./CurrentTreeContentLibrary.js";
 import { sampleContentPackageForLocale } from "../../shared/sample-packages/index.js";
 import { inspectContentPackageCurrentTree, isContentPackageWorldDocumentPath, worldDocumentTextRequirement, } from "./FileNativeContentTree.js";
-export { CurrentTreeContentPackageBusyError, CurrentTreeContentLibraryError, CurrentTreeContentPackageNotFoundError, InvalidContentTreeError, } from "./CurrentTreeContentLibrary.js";
+export { ContentTreeConflictError, CurrentTreeContentPackageBusyError, CurrentTreeContentLibraryError, CurrentTreeContentPackageNotFoundError, InvalidContentTreeError, } from "./CurrentTreeContentLibrary.js";
 const portableTreeUtf8Decoder = new TextDecoder("utf-8", {
     fatal: true,
     ignoreBOM: true,
@@ -78,7 +78,7 @@ export class ContentWorkspace {
     validateCurrentTreeContentPackage(files) {
         normalizeCurrentContentTreeFiles(files, this.#limits);
     }
-    replaceCurrentTreeContentPackage(localId, files, options = {}) {
+    replaceCurrentTreeContentPackage(localId, files, options) {
         return this.#currentTreeLibrary.replaceCurrentTree(localId, files, options);
     }
     setCurrentTreeContentGameplayScheme(localId, scheme, options = {}) {

package/dist/node/runtime/content/CurrentTreeContentLibrary.js

@@ -1,6 +1,5 @@
 import { PackageScriptPermissions } from "../extension/PackageScriptPermissions.js";
-import { randomUUID } from "node:crypto";
-import { readFileSync, unlinkSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
 import { open, mkdir, readFile, readdir, rename, rm, stat, unlink, } from "node:fs/promises";
 import { linkExclusive } from "../FileNativeExclusiveLink.js";
 import { basename, dirname, isAbsolute, join, posix, win32 } from "node:path";
@@ -31,6 +30,18 @@ export class CurrentTreeContentPackageBusyError extends CurrentTreeContentLibrar
         this.name = "CurrentTreeContentPackageBusyError";
     }
 }
+/**
+ * The current tree changed after the caller's base revision. Nothing was
+ * written; `current` is the tree the caller must reload before saving again.
+ */
+export class ContentTreeConflictError extends CurrentTreeContentLibraryError {
+    current;
+    constructor(current) {
+        super("The content package changed after this draft was opened; load the latest tree before saving");
+        this.name = "ContentTreeConflictError";
+        this.current = current;
+    }
+}
 export class InvalidContentTreeError extends Error {
     constructor(message) {
         super(message);
@@ -42,15 +53,16 @@ export class InvalidContentTreeError extends Error {
  * single replaceable envelope so saving cannot expose half of two file sets.
  */
 export class CurrentTreeContentLibrary {
-    #locksRoot;
+    #legacyLocksRoot;
     #packagesRoot;
     #stagingRoot;
     #limits;
     #beforePackagePublish;
     #beforeCurrentTreeReplace;
     #mutationTail = Promise.resolve();
+    #legacyLocksRemoval;
     constructor(dataRoot, options = {}) {
-        this.#locksRoot = join(dataRoot, "content", ".package-locks");
+        this.#legacyLocksRoot = join(dataRoot, "content", ".package-locks");
         this.#packagesRoot = join(dataRoot, "content", "packages");
         this.#stagingRoot = join(dataRoot, "content", ".package-staging");
         this.#limits = normalizeLimits(options.limits);
@@ -216,12 +228,19 @@ export class CurrentTreeContentLibrary {
             }
         });
     }
-    replaceCurrentTree(localId, files, options = {}) {
+    /**
+     * Replace the whole tree only if it is still the revision the draft was
+     * based on. The comparison runs under the package lease, so a publish that
+     * landed after the draft opened cannot be overwritten.
+     */
+    replaceCurrentTree(localId, files, options) {
         return this.#mutate(async () => {
             const lease = await this.acquireOperationLease(localId, {
                 wait: options.waitForLease !== false,
             });
             try {
+                if (lease.package.treeRevision !== options.baseTreeRevision)
+                    throw new ContentTreeConflictError(lease.package);
                 return await lease.replace(files, options);
             }
             finally {
@@ -253,48 +272,16 @@ export class CurrentTreeContentLibrary {
         });
     }
     async acquireOperationLease(localId, options = {}) {
-        this.#packageRoot(localId);
-        await mkdir(this.#locksRoot, { recursive: true, mode: 0o700 });
-        const lockPath = this.#packageLockPath(localId);
-        const reclaimPath = this.#packageReclaimPath(localId);
-        await clearDeadPackageLockMarker(reclaimPath);
-        if (await pathExists(reclaimPath)) {
-            throw new CurrentTreeContentPackageBusyError();
-        }
-        const marker = createPackageLockMarker();
-        const temporaryPath = join(this.#locksRoot, `.${localId}.${marker.token}.tmp`);
-        let handle;
-        try {
-            handle = await open(temporaryPath, "wx", 0o600);
-            await handle.writeFile(`${JSON.stringify(marker)}\n`, "utf8");
-            await handle.close();
-            handle = undefined;
-            try {
-                await linkExclusive(temporaryPath, lockPath);
-            }
-            catch (error) {
-                if (!isNodeErrorCode(error, "EEXIST"))
-                    throw error;
-                if (options.wait === true) {
-                    await this.#waitForPackageLock(lockPath, reclaimPath, temporaryPath);
-                }
-                else if (!(await this.#tryReplaceDeadPackageLock(lockPath, reclaimPath, temporaryPath))) {
-                    throw new CurrentTreeContentPackageBusyError();
-                }
-            }
-        }
-        catch (error) {
-            await handle?.close().catch(() => undefined);
-            if (error instanceof CurrentTreeContentPackageBusyError)
-                throw error;
-            throw new CurrentTreeContentLibraryError("Unable to acquire the source-package save owner", {
-                cause: error instanceof Error ? error : undefined,
-            });
-        }
-        finally {
-            await unlink(temporaryPath).catch(() => undefined);
-        }
+        const packageRoot = this.#packageRoot(localId);
+        await this.#removeLegacyPackageLocks();
+        await acquireInProcessPackageLease(packageRoot, options.wait === true);
         let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            releaseInProcessPackageLease(packageRoot);
+        };
         try {
             const package_ = (await this.#readPackageSnapshot(localId)).package;
             return {
@@ -307,19 +294,25 @@ export class CurrentTreeContentLibrary {
                     assertGameplayModeUnchanged(package_.files, normalized);
                     return this.#replaceNormalizedCurrentTree(localId, package_.title, normalized, options.signal);
                 },
-                release: () => {
-                    if (released)
-                        return;
-                    released = true;
-                    releasePackageOperationLockSync(lockPath, marker.token);
-                },
+                release,
             };
         }
         catch (error) {
-            releasePackageOperationLockSync(lockPath, marker.token);
+            release();
             throw error;
         }
     }
+    /**
+     * Lock files written by versions that leased packages across processes. No
+     * code reads them any more, so the first lease in a library removes them.
+     */
+    #removeLegacyPackageLocks() {
+        this.#legacyLocksRemoval ??= rm(this.#legacyLocksRoot, {
+            recursive: true,
+            force: true,
+        }).catch(() => undefined);
+        return this.#legacyLocksRemoval;
+    }
     async #replaceNormalizedCurrentTree(localId, title, normalized, signal) {
         const packageRoot = this.#packageRoot(localId);
         const temporaryPath = join(packageRoot, `.current-tree-${randomUUID()}.tmp`);
@@ -408,70 +401,6 @@ export class CurrentTreeContentLibrary {
         }
         return join(this.#packagesRoot, localId);
     }
-    #packageLockPath(localId) {
-        return join(this.#locksRoot, `${localId}.mutation`);
-    }
-    #packageReclaimPath(localId) {
-        return join(this.#locksRoot, `${localId}.reclaim`);
-    }
-    async #tryReplaceDeadPackageLock(lockPath, reclaimPath, replacementPath) {
-        const current = await readPackageLockMarker(lockPath);
-        if (current === null || isProcessAlive(current.pid))
-            return false;
-        const reclaim = createPackageLockMarker();
-        const temporaryPath = join(this.#locksRoot, `.reclaim.${reclaim.token}.tmp`);
-        let handle;
-        try {
-            handle = await open(temporaryPath, "wx", 0o600);
-            await handle.writeFile(`${JSON.stringify(reclaim)}\n`, "utf8");
-            await handle.close();
-            handle = undefined;
-            await linkExclusive(temporaryPath, reclaimPath);
-        }
-        catch (error) {
-            await handle?.close().catch(() => undefined);
-            if (isNodeErrorCode(error, "EEXIST"))
-                return false;
-            throw error;
-        }
-        finally {
-            await unlink(temporaryPath).catch(() => undefined);
-        }
-        try {
-            const verified = await readPackageLockMarker(lockPath);
-            if (verified?.token !== current.token || isProcessAlive(current.pid)) {
-                return false;
-            }
-            await unlink(lockPath).catch((error) => {
-                if (!isNodeErrorCode(error, "ENOENT"))
-                    throw error;
-            });
-            await linkExclusive(replacementPath, lockPath);
-            return true;
-        }
-        finally {
-            const owner = await readPackageLockMarker(reclaimPath);
-            if (owner?.token === reclaim.token) {
-                await unlink(reclaimPath).catch(() => undefined);
-            }
-        }
-    }
-    async #waitForPackageLock(lockPath, reclaimPath, replacementPath) {
-        for (let attempt = 0; attempt < 2_000; attempt += 1) {
-            if ((await this.#tryReplaceDeadPackageLock(lockPath, reclaimPath, replacementPath)) ||
-                (await linkExclusive(replacementPath, lockPath)
-                    .then(() => true)
-                    .catch((error) => {
-                    if (isNodeErrorCode(error, "EEXIST"))
-                        return false;
-                    throw error;
-                }))) {
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 5));
-        }
-        throw new CurrentTreeContentPackageBusyError();
-    }
     async #mutate(operation) {
         const previous = this.#mutationTail;
         let release = () => undefined;
@@ -490,6 +419,7 @@ export class CurrentTreeContentLibrary {
 function detail(localId, title, files, inspection) {
     return {
         ...summary(localId, title, readGameplay(files), inspection),
+        treeRevision: treeRevisionOf(files),
         files: files.map((file) => ({ ...file })),
         documents: structuredClone(inspection.documents),
         issues: structuredClone(inspection.issues),
@@ -497,6 +427,18 @@ function detail(localId, title, files, inspection) {
         control: structuredClone(inspection.control),
     };
 }
+/**
+ * Digest of every file's path, encoding and contents, independent of file
+ * order. Equal trees always share a revision; a tree that returns to earlier
+ * content is equal to it, so a draft based on that content loses nothing.
+ */
+function treeRevisionOf(files) {
+    const hash = createHash("sha256");
+    for (const file of [...files].sort((left, right) => compareStrings(left.path, right.path))) {
+        hash.update(JSON.stringify([file.path, file.encoding ?? null, file.contents]));
+    }
+    return hash.digest("hex");
+}
 function summary(localId, title, gameplay, inspection) {
     return {
         gameplay: { ...gameplay },
@@ -731,47 +673,47 @@ function isPlainObject(value) {
 function serialize(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
 }
-function createPackageLockMarker() {
-    return { schemaVersion: 1, pid: process.pid, token: randomUUID() };
-}
-async function readPackageLockMarker(path) {
-    try {
-        const value = JSON.parse(await readFile(path, "utf8"));
-        return parsePackageLockMarker(value);
-    }
-    catch {
-        return null;
-    }
-}
-function parsePackageLockMarker(value) {
-    if (isPlainObject(value) &&
-        value.schemaVersion === 1 &&
-        typeof value.pid === "number" &&
-        Number.isSafeInteger(value.pid) &&
-        value.pid > 0 &&
-        typeof value.token === "string" &&
-        /^[0-9a-f-]{36}$/u.test(value.token)) {
-        return { schemaVersion: 1, pid: value.pid, token: value.token };
-    }
-    return null;
-}
-function releasePackageOperationLockSync(path, token) {
-    try {
-        const current = parsePackageLockMarker(JSON.parse(readFileSync(path, "utf8")));
-        if (current?.token === token)
-            unlinkSync(path);
-    }
-    catch (error) {
-        if (!isNodeErrorCode(error, "ENOENT"))
-            throw error;
+const packageLeaseWaitMs = 10_000;
+/**
+ * Package leases held by this process, keyed by package root. A key is present
+ * while its lease is held; its array queues waiters in arrival order, and a
+ * release hands the lease straight to the first of them.
+ */
+const heldPackageLeases = new Map();
+async function acquireInProcessPackageLease(packageRoot, wait) {
+    const queue = heldPackageLeases.get(packageRoot);
+    if (queue === undefined) {
+        heldPackageLeases.set(packageRoot, []);
+        return;
     }
+    if (!wait)
+        throw new CurrentTreeContentPackageBusyError();
+    await new Promise((resolve, reject) => {
+        const waiter = {
+            grant: () => {
+                clearTimeout(timer);
+                resolve();
+            },
+        };
+        const timer = setTimeout(() => {
+            const index = queue.indexOf(waiter);
+            if (index === -1)
+                return;
+            queue.splice(index, 1);
+            reject(new CurrentTreeContentPackageBusyError());
+        }, packageLeaseWaitMs);
+        queue.push(waiter);
+    });
 }
-async function clearDeadPackageLockMarker(path) {
-    const marker = await readPackageLockMarker(path);
-    if ((marker !== null && !isProcessAlive(marker.pid)) ||
-        (marker === null && (await pathExists(path)))) {
-        await unlink(path).catch(() => undefined);
-    }
+function releaseInProcessPackageLease(packageRoot) {
+    const queue = heldPackageLeases.get(packageRoot);
+    if (queue === undefined)
+        return;
+    const next = queue.shift();
+    if (next === undefined)
+        heldPackageLeases.delete(packageRoot);
+    else
+        next.grant();
 }
 async function pathExists(path) {
     try {
@@ -784,15 +726,6 @@ async function pathExists(path) {
         throw error;
     }
 }
-function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return !isNodeErrorCode(error, "ESRCH");
-    }
-}
 function isNodeErrorCode(error, code) {
     return (typeof error === "object" &&
         error !== null &&

package/dist/node/runtime/content/FileNativeContentTree.js

@@ -14,8 +14,11 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
             layout: "content_package",
             files,
         });
-    if (worldDocumentSnapshot.layout !== "content_package")
-        throw new Error("Content-package inspection accepts only content_package document snapshots");
+    if (worldDocumentSnapshot.layout === "world_state")
+        throw new Error("Authoring inspection accepts only content_package or world_revision document snapshots");
+    const subject = worldDocumentSnapshot.layout === "world_revision"
+        ? "world revision"
+        : "content package";
     const snapshotFiles = worldDocumentSnapshot.files;
     const issues = [];
     const documents = worldDocumentSnapshotDocuments(worldDocumentSnapshot);
@@ -26,11 +29,11 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
     let opening = "missing";
     if (openingFiles.length === 0) {
         if (options.requireOpening !== false)
-            issue(issues, "missing_opening", "opening.md", "The content package is missing a root-level opening.md introduction");
+            issue(issues, "missing_opening", "opening.md", `The ${subject} is missing a root-level opening.md introduction`);
     }
     else if (openingFiles.length > 1) {
         opening = "invalid";
-        issue(issues, "invalid_opening", "opening.md", "A content package may contain only one root-level opening.md file");
+        issue(issues, "invalid_opening", "opening.md", `A ${subject} may contain only one root-level opening.md file`);
     }
     else {
         const openingFile = openingFiles[0];
@@ -48,19 +51,19 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
     for (const file of snapshotFiles) {
         if (/\.json$/iu.test(file.path) && file.path !== gameplayPath) {
             unsupportedPaths.add(file.path);
-            issue(issues, "unsupported_content_file", file.path, "The current content package does not accept manifest, seven-field JSON, schema, record, or revision files");
+            issue(issues, "unsupported_content_file", file.path, `The current ${subject} does not accept manifest, seven-field JSON, schema, record, or revision files`);
         }
     }
     issues.push(...worldDocumentSnapshot.diagnostics
         .filter(({ logicalPath }) => logicalPath === undefined || !unsupportedPaths.has(logicalPath))
-        .map(worldDocumentIssue));
+        .map((diagnostic) => worldDocumentIssue(diagnostic, worldDocumentSnapshot.logicalRoot)));
     const index = documentIndex(documents);
     const frameSource = textFiles.get("control/frame.yaml");
     let worldFrame = "missing";
     let currentSituation = "missing";
     if (frameSource === undefined) {
-        issue(issues, "missing_world_frame", "control/frame.yaml", "The content package is missing its world prompt frame");
-        issue(issues, "missing_current_situation", "control/frame.yaml", "The content package has not bound a current-situation document");
+        issue(issues, "missing_world_frame", "control/frame.yaml", `The ${subject} is missing its world prompt frame`);
+        issue(issues, "missing_current_situation", "control/frame.yaml", `The ${subject} has not bound a current-situation document`);
     }
     else {
         const frame = parseRestrictedYaml("control/frame.yaml", frameSource, issues);
@@ -97,7 +100,7 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
     const playerSource = textFiles.get("control/player-views.yaml");
     let playerView = "missing";
     if (playerSource === undefined) {
-        issue(issues, "missing_player_view", "control/player-views.yaml", "The content package is missing its player-view control file");
+        issue(issues, "missing_player_view", "control/player-views.yaml", `The ${subject} is missing its player-view control file`);
     }
     else {
         const player = parseRestrictedYaml("control/player-views.yaml", playerSource, issues);
@@ -218,10 +221,10 @@ function contentDocument(document) {
         codec: document.codec,
     };
 }
-function worldDocumentIssue(diagnostic) {
+function worldDocumentIssue(diagnostic, root) {
     return {
         code: contentIssueCode(diagnostic),
-        path: diagnostic.logicalPath ?? "world",
+        path: diagnostic.logicalPath ?? root,
         message: diagnostic.code === "document_reference_invalid"
             ? "An explicit $ref points to a missing document, or the target identity is not unique in the snapshot"
             : diagnostic.message,
@@ -430,9 +433,9 @@ function validateFrameContext(value, index, snapshot, issues) {
         }
         if (entry.slot.kind === "catalog" &&
             entry.slot.required !== false &&
-            catalogDocuments(entry.slot.directory, index.documents(), "world").length === 0) {
+            catalogDocuments(entry.slot.directory, index.documents(), snapshot.logicalRoot).length === 0) {
             const directory = entry.slot.directory;
-            issue(issues, "invalid_world_frame", "control/frame.yaml", `Required catalog ${directory} has no associated documents; it matches only direct children named world/${directory}/<file>.yaml, .yml, or .md, and dots in file names do not create directories`);
+            issue(issues, "invalid_world_frame", "control/frame.yaml", `Required catalog ${directory} has no associated documents; it matches only direct children named ${snapshot.logicalRoot}/${directory}/<file>.yaml, .yml, or .md, and dots in file names do not create directories`);
             continue;
         }
         kinds.push(entry.slot.kind);