mdkg 0.0.8 → 0.0.9

package/dist/commands/workspace.js

@@ -6,11 +6,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runWorkspaceListCommand = runWorkspaceListCommand;
 exports.runWorkspaceAddCommand = runWorkspaceAddCommand;
 exports.runWorkspaceRemoveCommand = runWorkspaceRemoveCommand;
+exports.runWorkspaceEnableCommand = runWorkspaceEnableCommand;
+exports.runWorkspaceDisableCommand = runWorkspaceDisableCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
+const migrate_1 = require("../core/migrate");
+const workspace_path_1 = require("../core/workspace_path");
 const errors_1 = require("../util/errors");
 const ALIAS_RE = /^[a-z][a-z0-9_]*$/;
+function workspaceReceipt(alias, workspace) {
+    return {
+        alias,
+        path: workspace.path,
+        enabled: workspace.enabled,
+        mdkg_dir: workspace.mdkg_dir,
+    };
+}
+function printWorkspaceMutationReceipt(action, workspace, json) {
+    if (json) {
+        console.log(JSON.stringify({ action, workspace }, null, 2));
+        return;
+    }
+    if (action === "added") {
+        console.log(`workspace added: ${workspace.alias} (${workspace.path})`);
+        return;
+    }
+    console.log(`workspace ${action}: ${workspace.alias}`);
+}
 function readRawConfig(root) {
     const configPath = path_1.default.join(root, ".mdkg", "config.json");
     if (!fs_1.default.existsSync(configPath)) {
@@ -27,24 +50,51 @@ function readRawConfig(root) {
     if (typeof raw !== "object" || raw === null) {
         throw new errors_1.UsageError("config must be a JSON object");
     }
-    return { path: configPath, raw: raw };
+    const migrated = (0, migrate_1.migrateConfig)(raw).config;
+    (0, config_1.validateConfigSchema)(migrated);
+    if (typeof migrated !== "object" || migrated === null || Array.isArray(migrated)) {
+        throw new errors_1.UsageError("config must be a JSON object");
+    }
+    return { path: configPath, raw: migrated };
 }
 function writeRawConfig(configPath, raw) {
     fs_1.default.writeFileSync(configPath, JSON.stringify(raw, null, 2), "utf8");
 }
 function normalizeAlias(alias) {
-    const normalized = alias.toLowerCase();
-    if (normalized === "all") {
+    if (alias.toLowerCase() === "all") {
         throw new errors_1.UsageError("workspace alias cannot be 'all'");
     }
-    if (!ALIAS_RE.test(normalized)) {
+    if (alias !== alias.toLowerCase() || !ALIAS_RE.test(alias)) {
         throw new errors_1.UsageError("workspace alias must be lowercase and use [a-z0-9_]");
     }
-    return normalized;
+    return alias;
+}
+function normalizeCommandWorkspacePath(value, label) {
+    try {
+        return (0, workspace_path_1.normalizeContainedWorkspacePath)(value, label);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new errors_1.UsageError(message);
+    }
 }
 function runWorkspaceListCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const aliases = Object.keys(config.workspaces).sort();
+    if (options.json) {
+        console.log(JSON.stringify({
+            workspaces: aliases.map((alias) => {
+                const ws = config.workspaces[alias];
+                return {
+                    alias,
+                    path: ws.path,
+                    enabled: ws.enabled,
+                    mdkg_dir: ws.mdkg_dir,
+                };
+            }),
+        }, null, 2));
+        return;
+    }
     if (aliases.length === 0) {
         console.log("no workspaces registered");
         return;
@@ -57,11 +107,11 @@ function runWorkspaceListCommand(options) {
 }
 function runWorkspaceAddCommand(options) {
     const alias = normalizeAlias(options.alias);
-    const workspacePath = options.workspacePath.trim();
-    if (!workspacePath) {
-        throw new errors_1.UsageError("workspace path cannot be empty");
+    const workspacePath = normalizeCommandWorkspacePath(options.workspacePath, "workspace path");
+    const mdkgDir = normalizeCommandWorkspacePath(options.mdkgDir ?? ".mdkg", "workspace mdkg dir");
+    if ((0, workspace_path_1.isRootWorkspacePath)(workspacePath)) {
+        throw new errors_1.UsageError('workspace path must not be "." for non-root workspaces');
     }
-    const mdkgDir = options.mdkgDir?.trim() || ".mdkg";
     const { path: configPath, raw } = readRawConfig(options.root);
     const workspacesRaw = raw.workspaces;
     if (typeof workspacesRaw !== "object" || workspacesRaw === null) {
@@ -71,14 +121,27 @@ function runWorkspaceAddCommand(options) {
     if (workspaces[alias]) {
         throw new errors_1.UsageError(`workspace already exists: ${alias}`);
     }
-    workspaces[alias] = { path: workspacePath, enabled: true, mdkg_dir: mdkgDir };
+    const docRootKey = (0, workspace_path_1.workspaceDocumentRootKey)(workspacePath, mdkgDir);
+    for (const [existingAlias, entry] of Object.entries(workspaces)) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            continue;
+        }
+        const existing = entry;
+        if (typeof existing.path === "string" &&
+            typeof existing.mdkg_dir === "string" &&
+            (0, workspace_path_1.workspaceDocumentRootKey)(existing.path, existing.mdkg_dir) === docRootKey) {
+            throw new errors_1.UsageError(`workspace document root already registered by ${existingAlias}`);
+        }
+    }
+    const workspace = { path: workspacePath, enabled: true, mdkg_dir: mdkgDir };
+    workspaces[alias] = workspace;
     raw.workspaces = workspaces;
     writeRawConfig(configPath, raw);
     const wsRoot = path_1.default.resolve(options.root, workspacePath, mdkgDir);
     fs_1.default.mkdirSync(path_1.default.join(wsRoot, "core"), { recursive: true });
     fs_1.default.mkdirSync(path_1.default.join(wsRoot, "design"), { recursive: true });
     fs_1.default.mkdirSync(path_1.default.join(wsRoot, "work"), { recursive: true });
-    console.log(`workspace added: ${alias} (${workspacePath})`);
+    printWorkspaceMutationReceipt("added", workspaceReceipt(alias, workspace), options.json);
 }
 function runWorkspaceRemoveCommand(options) {
     const alias = normalizeAlias(options.alias);
@@ -91,11 +154,40 @@ function runWorkspaceRemoveCommand(options) {
         throw new errors_1.UsageError("config.workspaces must be an object");
     }
     const workspaces = workspacesRaw;
-    if (!workspaces[alias]) {
+    const workspace = workspaces[alias];
+    if (!workspace || typeof workspace !== "object" || Array.isArray(workspace)) {
         throw new errors_1.NotFoundError(`workspace not found: ${alias}`);
     }
+    const removed = workspaceReceipt(alias, workspace);
     delete workspaces[alias];
     raw.workspaces = workspaces;
     writeRawConfig(configPath, raw);
-    console.log(`workspace removed: ${alias}`);
+    printWorkspaceMutationReceipt("removed", removed, options.json);
+}
+function setWorkspaceEnabled(options, enabled) {
+    const alias = normalizeAlias(options.alias);
+    if (alias === "root" && !enabled) {
+        throw new errors_1.UsageError("cannot disable root workspace");
+    }
+    const { path: configPath, raw } = readRawConfig(options.root);
+    const workspacesRaw = raw.workspaces;
+    if (typeof workspacesRaw !== "object" || workspacesRaw === null) {
+        throw new errors_1.UsageError("config.workspaces must be an object");
+    }
+    const workspaces = workspacesRaw;
+    const workspace = workspaces[alias];
+    if (!workspace || typeof workspace !== "object" || Array.isArray(workspace)) {
+        throw new errors_1.NotFoundError(`workspace not found: ${alias}`);
+    }
+    const updated = { ...workspace, enabled };
+    workspaces[alias] = updated;
+    raw.workspaces = workspaces;
+    writeRawConfig(configPath, raw);
+    printWorkspaceMutationReceipt(enabled ? "enabled" : "disabled", workspaceReceipt(alias, updated), options.json);
+}
+function runWorkspaceEnableCommand(options) {
+    setWorkspaceEnabled(options, true);
+}
+function runWorkspaceDisableCommand(options) {
+    setWorkspaceEnabled(options, false);
 }

package/dist/core/config.js

@@ -3,10 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfigSchema = validateConfigSchema;
 exports.loadConfig = loadConfig;
 const fs_1 = __importDefault(require("fs"));
 const paths_1 = require("./paths");
 const migrate_1 = require("./migrate");
+const workspace_path_1 = require("./workspace_path");
+const WORKSPACE_ALIAS_RE = /^[a-z][a-z0-9_]*$/;
+const PACK_EDGE_KEYS = new Set([
+    "parent",
+    "epic",
+    "relates",
+    "blocked_by",
+    "blocks",
+    "prev",
+    "next",
+]);
+const NEXT_WORK_STRATEGIES = new Set(["chain_then_priority"]);
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -17,6 +30,17 @@ function requireString(value, path, errors) {
     }
     return value;
 }
+function requireStringInSet(value, path, allowed, errors) {
+    const raw = requireString(value, path, errors);
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (!allowed.has(raw)) {
+        errors.push(`${path} must be one of ${Array.from(allowed).join(", ")}`);
+        return undefined;
+    }
+    return raw;
+}
 function requireBoolean(value, path, errors) {
     if (typeof value !== "boolean") {
         errors.push(`${path} must be a boolean`);
@@ -31,6 +55,39 @@ function requireNumber(value, path, errors) {
     }
     return value;
 }
+function requireInteger(value, path, errors) {
+    const number = requireNumber(value, path, errors);
+    if (number === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(number)) {
+        errors.push(`${path} must be an integer`);
+        return undefined;
+    }
+    return number;
+}
+function requireNonNegativeInteger(value, path, errors) {
+    const integer = requireInteger(value, path, errors);
+    if (integer === undefined) {
+        return undefined;
+    }
+    if (integer < 0) {
+        errors.push(`${path} must be a non-negative integer`);
+        return undefined;
+    }
+    return integer;
+}
+function requirePositiveInteger(value, path, errors) {
+    const integer = requireInteger(value, path, errors);
+    if (integer === undefined) {
+        return undefined;
+    }
+    if (integer <= 0) {
+        errors.push(`${path} must be a positive integer`);
+        return undefined;
+    }
+    return integer;
+}
 function requireStringArray(value, path, errors) {
     if (!Array.isArray(value)) {
         errors.push(`${path} must be an array of strings`);
@@ -46,6 +103,53 @@ function requireStringArray(value, path, errors) {
     }
     return items;
 }
+function requireLowercaseUniqueStringArray(value, path, errors, allowEmpty = false) {
+    const items = requireStringArray(value, path, errors);
+    if (items === undefined) {
+        return undefined;
+    }
+    if (items.length === 0) {
+        if (!allowEmpty) {
+            errors.push(`${path} must not be empty`);
+        }
+        return items;
+    }
+    const seen = new Set();
+    for (let i = 0; i < items.length; i += 1) {
+        const item = items[i];
+        if (item.trim().length === 0) {
+            errors.push(`${path}[${i}] must not be empty`);
+            continue;
+        }
+        if (item !== item.trim()) {
+            errors.push(`${path}[${i}] must not include surrounding whitespace`);
+        }
+        if (item !== item.toLowerCase()) {
+            errors.push(`${path}[${i}] must be lowercase`);
+        }
+        if (seen.has(item)) {
+            errors.push(`${path} must not contain duplicate value "${item}"`);
+            continue;
+        }
+        seen.add(item);
+    }
+    return items;
+}
+function requireKnownLowercaseUniqueStringArray(value, path, allowed, errors, allowEmpty = false) {
+    const items = requireLowercaseUniqueStringArray(value, path, errors, allowEmpty);
+    if (items === undefined) {
+        return undefined;
+    }
+    for (let i = 0; i < items.length; i += 1) {
+        if (items[i].trim().length === 0) {
+            continue;
+        }
+        if (!allowed.has(items[i])) {
+            errors.push(`${path}[${i}] must be one of ${Array.from(allowed).join(", ")}`);
+        }
+    }
+    return items;
+}
 function requireObject(value, path, errors) {
     if (!isObject(value)) {
         errors.push(`${path} must be an object`);
@@ -53,6 +157,29 @@ function requireObject(value, path, errors) {
     }
     return value;
 }
+function validateWorkspaceAlias(alias, errors) {
+    if (alias === "all") {
+        errors.push("workspaces.all alias is reserved");
+        return;
+    }
+    if (alias !== alias.toLowerCase() || !WORKSPACE_ALIAS_RE.test(alias)) {
+        errors.push(`workspaces.${alias} alias must be lowercase and use [a-z0-9_]`);
+    }
+}
+function requireContainedPath(value, path, errors) {
+    const raw = requireString(value, path, errors);
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return (0, workspace_path_1.normalizeContainedWorkspacePath)(raw, path);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push(message);
+        return undefined;
+    }
+}
 function validateConfigSchema(raw) {
     const errors = [];
     if (!isObject(raw)) {
@@ -70,50 +197,70 @@ function validateConfigSchema(raw) {
         ? {
             auto_reindex: requireBoolean(indexRaw.auto_reindex, "index.auto_reindex", errors),
             tolerant: requireBoolean(indexRaw.tolerant, "index.tolerant", errors),
-            global_index_path: requireString(indexRaw.global_index_path, "index.global_index_path", errors),
+            global_index_path: requireContainedPath(indexRaw.global_index_path, "index.global_index_path", errors),
         }
         : undefined;
     const packLimitsRaw = packRaw ? requireObject(packRaw.limits, "pack.limits", errors) : undefined;
     const pack = packRaw
         ? {
-            default_depth: requireNumber(packRaw.default_depth, "pack.default_depth", errors),
-            default_edges: requireStringArray(packRaw.default_edges, "pack.default_edges", errors),
-            verbose_core_list_path: requireString(packRaw.verbose_core_list_path, "pack.verbose_core_list_path", errors),
+            default_depth: requireNonNegativeInteger(packRaw.default_depth, "pack.default_depth", errors),
+            default_edges: requireKnownLowercaseUniqueStringArray(packRaw.default_edges, "pack.default_edges", PACK_EDGE_KEYS, errors, true),
+            verbose_core_list_path: requireContainedPath(packRaw.verbose_core_list_path, "pack.verbose_core_list_path", errors),
             limits: packLimitsRaw
                 ? {
-                    max_nodes: requireNumber(packLimitsRaw.max_nodes, "pack.limits.max_nodes", errors),
-                    max_bytes: requireNumber(packLimitsRaw.max_bytes, "pack.limits.max_bytes", errors),
+                    max_nodes: requirePositiveInteger(packLimitsRaw.max_nodes, "pack.limits.max_nodes", errors),
+                    max_bytes: requirePositiveInteger(packLimitsRaw.max_bytes, "pack.limits.max_bytes", errors),
                 }
                 : undefined,
         }
         : undefined;
     const templates = templatesRaw
         ? {
-            root_path: requireString(templatesRaw.root_path, "templates.root_path", errors),
+            root_path: requireContainedPath(templatesRaw.root_path, "templates.root_path", errors),
             default_set: requireString(templatesRaw.default_set, "templates.default_set", errors),
             workspace_overrides_enabled: requireBoolean(templatesRaw.workspace_overrides_enabled, "templates.workspace_overrides_enabled", errors),
         }
         : undefined;
     const workNextRaw = workRaw ? requireObject(workRaw.next, "work.next", errors) : undefined;
     const work = workRaw
-        ? {
-            status_enum: requireStringArray(workRaw.status_enum, "work.status_enum", errors),
-            priority_min: requireNumber(workRaw.priority_min, "work.priority_min", errors),
-            priority_max: requireNumber(workRaw.priority_max, "work.priority_max", errors),
-            next: workNextRaw
-                ? {
-                    strategy: requireString(workNextRaw.strategy, "work.next.strategy", errors),
-                    status_preference: requireStringArray(workNextRaw.status_preference, "work.next.status_preference", errors),
+        ? (() => {
+            const statusEnum = requireLowercaseUniqueStringArray(workRaw.status_enum, "work.status_enum", errors);
+            const priorityMin = requireInteger(workRaw.priority_min, "work.priority_min", errors);
+            const priorityMax = requireInteger(workRaw.priority_max, "work.priority_max", errors);
+            if (priorityMin !== undefined &&
+                priorityMax !== undefined &&
+                priorityMin > priorityMax) {
+                errors.push("work.priority_min must be less than or equal to work.priority_max");
+            }
+            const statusPreference = workNextRaw
+                ? requireLowercaseUniqueStringArray(workNextRaw.status_preference, "work.next.status_preference", errors)
+                : undefined;
+            if (statusEnum !== undefined && statusPreference !== undefined) {
+                const allowedStatuses = new Set(statusEnum);
+                for (let i = 0; i < statusPreference.length; i += 1) {
+                    if (!allowedStatuses.has(statusPreference[i])) {
+                        errors.push(`work.next.status_preference[${i}] must be listed in work.status_enum`);
+                    }
                 }
-                : undefined,
-        }
+            }
+            return {
+                status_enum: statusEnum,
+                priority_min: priorityMin,
+                priority_max: priorityMax,
+                next: workNextRaw
+                    ? {
+                        strategy: requireStringInSet(workNextRaw.strategy, "work.next.strategy", NEXT_WORK_STRATEGIES, errors),
+                        status_preference: statusPreference,
+                    }
+                    : undefined,
+            };
+        })()
         : undefined;
     const workspaces = {};
+    const workspaceDocRootOwners = new Map();
     if (workspacesRaw) {
         for (const [alias, entry] of Object.entries(workspacesRaw)) {
-            if (alias !== alias.toLowerCase()) {
-                errors.push(`workspaces.${alias} alias must be lowercase`);
-            }
+            validateWorkspaceAlias(alias, errors);
             const ws = requireObject(entry, `workspaces.${alias}`, errors);
             if (!ws) {
                 continue;
@@ -122,14 +269,62 @@ function validateConfigSchema(raw) {
             const wsEnabled = requireBoolean(ws.enabled, `workspaces.${alias}.enabled`, errors);
             const wsMdkgDir = requireString(ws.mdkg_dir, `workspaces.${alias}.mdkg_dir`, errors);
             if (wsPath && wsEnabled !== undefined && wsMdkgDir) {
+                let normalizedPath;
+                let normalizedMdkgDir;
+                try {
+                    normalizedPath = (0, workspace_path_1.normalizeContainedWorkspacePath)(wsPath, `workspaces.${alias}.path`);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    errors.push(message);
+                }
+                try {
+                    normalizedMdkgDir = (0, workspace_path_1.normalizeContainedWorkspacePath)(wsMdkgDir, `workspaces.${alias}.mdkg_dir`);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    errors.push(message);
+                }
+                if (!normalizedPath || !normalizedMdkgDir) {
+                    continue;
+                }
+                if (alias !== "root" && (0, workspace_path_1.isRootWorkspacePath)(normalizedPath)) {
+                    errors.push(`workspaces.${alias}.path must not be "." for non-root workspaces`);
+                    continue;
+                }
+                const docRootKey = (0, workspace_path_1.workspaceDocumentRootKey)(normalizedPath, normalizedMdkgDir);
+                const existingAlias = workspaceDocRootOwners.get(docRootKey);
+                if (existingAlias) {
+                    errors.push(`workspaces.${alias} document root duplicates workspaces.${existingAlias}`);
+                    continue;
+                }
+                workspaceDocRootOwners.set(docRootKey, alias);
                 workspaces[alias] = {
-                    path: wsPath,
+                    path: normalizedPath,
                     enabled: wsEnabled,
-                    mdkg_dir: wsMdkgDir,
+                    mdkg_dir: normalizedMdkgDir,
                 };
             }
         }
     }
+    const rootWorkspace = workspaces.root;
+    if (root_required !== undefined && root_required !== true) {
+        errors.push("root_required must be true");
+    }
+    if (!rootWorkspace) {
+        errors.push("workspaces.root is required");
+    }
+    else {
+        if (rootWorkspace.path !== ".") {
+            errors.push('workspaces.root.path must be "."');
+        }
+        if (rootWorkspace.enabled !== true) {
+            errors.push("workspaces.root.enabled must be true");
+        }
+        if (rootWorkspace.mdkg_dir !== ".mdkg") {
+            errors.push('workspaces.root.mdkg_dir must be ".mdkg"');
+        }
+    }
     if (errors.length > 0) {
         throw new Error(`config validation failed:\n${errors.join("\n")}`);
     }

package/dist/core/migrate.js

@@ -3,15 +3,49 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LATEST_SCHEMA_VERSION = void 0;
 exports.migrateConfig = migrateConfig;
 exports.LATEST_SCHEMA_VERSION = 1;
-const MIGRATIONS = {};
-function migrateConfig(raw) {
-    if (typeof raw !== "object" || raw === null) {
-        throw new Error("config must be a JSON object");
-    }
+const LEGACY_SCHEMA_VERSION = 0;
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getSchemaVersion(raw) {
     const version = raw.schema_version;
+    if (version === undefined) {
+        return LEGACY_SCHEMA_VERSION;
+    }
     if (typeof version !== "number" || !Number.isInteger(version)) {
         throw new Error("config schema_version must be an integer");
     }
+    if (version < LEGACY_SCHEMA_VERSION) {
+        throw new Error("config schema_version must be non-negative");
+    }
+    return version;
+}
+function migrateLegacyConfig(input) {
+    if (!isJsonObject(input)) {
+        throw new Error("config must be a JSON object");
+    }
+    return {
+        ...input,
+        schema_version: 1,
+        workspaces: input.workspaces === undefined
+            ? {
+                root: {
+                    path: ".",
+                    enabled: true,
+                    mdkg_dir: ".mdkg",
+                },
+            }
+            : input.workspaces,
+    };
+}
+const MIGRATIONS = {
+    [LEGACY_SCHEMA_VERSION]: migrateLegacyConfig,
+};
+function migrateConfig(raw) {
+    if (!isJsonObject(raw)) {
+        throw new Error("config must be a JSON object");
+    }
+    const version = getSchemaVersion(raw);
     if (version > exports.LATEST_SCHEMA_VERSION) {
         throw new Error(`config schema_version ${version} is newer than supported ${exports.LATEST_SCHEMA_VERSION}`);
     }

package/dist/core/workspace_path.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeContainedWorkspacePath = normalizeContainedWorkspacePath;
+exports.isRootWorkspacePath = isRootWorkspacePath;
+exports.workspaceDocumentRootKey = workspaceDocumentRootKey;
+const path_1 = __importDefault(require("path"));
+function isAbsoluteOnSupportedPlatform(value) {
+    return path_1.default.isAbsolute(value) || path_1.default.posix.isAbsolute(value) || path_1.default.win32.isAbsolute(value);
+}
+function normalizeContainedWorkspacePath(value, label) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`${label} cannot be empty`);
+    }
+    if (normalized.includes("\0")) {
+        throw new Error(`${label} cannot contain NUL bytes`);
+    }
+    if (isAbsoluteOnSupportedPlatform(normalized)) {
+        throw new Error(`${label} must be relative`);
+    }
+    if (normalized.split(/[\\/]+/).some((part) => part === "..")) {
+        throw new Error(`${label} cannot contain parent-directory components`);
+    }
+    return normalized;
+}
+function isRootWorkspacePath(value) {
+    const parts = value
+        .trim()
+        .split(/[\\/]+/)
+        .filter(Boolean);
+    return parts.length > 0 && parts.every((part) => part === ".");
+}
+function workspaceDocumentRootKey(workspacePath, mdkgDir) {
+    return [workspacePath, mdkgDir]
+        .flatMap((value) => value.trim().split(/[\\/]+/))
+        .filter((part) => part && part !== ".")
+        .join("/");
+}