mdx-artifacts 0.1.2 → 0.2.0

package/dist/lib/cli/index.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 import path from "node:path";
-import { buildCommand } from "./build.js";
-import { componentsCommand } from "./components.js";
-import { devCommand } from "./dev.js";
-import { reviewCommand } from "./review.js";
-import { initProject } from "./scaffold.js";
-import { printValidationResult, validateMdx } from "./validate.js";
+import { buildCommand } from "./commands/build.js";
+import { componentsCommand } from "./commands/components.js";
+import { devCommand } from "./commands/dev.js";
+import { interactionsCommand } from "./commands/interactions.js";
+import { reviewCommand } from "./commands/review.js";
+import { initProject, parseInitOptions } from "./commands/scaffold.js";
+import { formatValidationJson, printValidationResult, validateMdx } from "./commands/validate.js";
+import { loadConfig } from "./config/config.js";
 const projectRoot = process.cwd();
 const [command, input] = process.argv.slice(2);
 async function main() {
@@ -14,7 +16,7 @@ async function main() {
         return;
     }
     if (command === "init") {
-        await initProject(projectRoot);
+        await initProject(projectRoot, await parseInitOptions(process.argv.slice(3)));
         return;
     }
     if (command === "components") {
@@ -28,12 +30,24 @@ async function main() {
         await reviewCommand(projectRoot, process.argv.slice(3));
         return;
     }
+    if (command === "interactions") {
+        await interactionsCommand(projectRoot, process.argv.slice(3));
+        return;
+    }
     if (!input) {
         throw new Error(`${command} requires a .mdx file path.`);
     }
     if (command === "validate") {
-        const result = await validateMdx(path.resolve(projectRoot, input));
-        printValidationResult(result);
+        const args = process.argv.slice(3);
+        const json = args.includes("--json");
+        const config = await loadConfig(projectRoot);
+        const result = await validateMdx(path.resolve(projectRoot, input), { projectRoot, config });
+        if (json) {
+            console.log(JSON.stringify(formatValidationJson(result), null, 2));
+        }
+        else {
+            printValidationResult(result);
+        }
         if (result.errors.length > 0) {
             process.exitCode = 1;
         }
@@ -50,17 +64,24 @@ async function main() {
     throw new Error(`Unknown command: ${command}`);
 }
 function printHelp() {
-    console.log(`artifact-kit
+    console.log(`mdx-artifacts
 
 Usage:
-  artifact-kit init
-  artifact-kit components [ComponentName] [--json]
-  artifact-kit validate <file.mdx>
-  artifact-kit review add <file.mdx> --anchor <anchorId> --body <message> [--title <title>]
-  artifact-kit review reply <file.mdx> --thread <threadId> --body <message> [...repeat] [--status <status>]
-  artifact-kit review validate <file.mdx>
-  artifact-kit dev <file.mdx>
-  artifact-kit build <file.mdx>
+  mdx-artifacts init [--yes] [--docs-dir <dir>] [--components-dir <dir>] [--agent <generic|codex|claude-code|cursor|all>]
+  mdx-artifacts components [ComponentName] [--json]
+  mdx-artifacts validate <file.mdx> [--json]
+  mdx-artifacts interactions inspect <file.mdx> <id> [--json]
+  mdx-artifacts interactions set-order <file.mdx> <id> --ordered-ids <id> [...id]
+  mdx-artifacts interactions reset <file.mdx> <id>
+  mdx-artifacts interactions promote <file.mdx> <id>
+  mdx-artifacts interactions add-item <file.mdx> <id> --item-id <id> --title <title> [--summary <text>] [--badge <text>] [--tags <tag,tag>] [--disabled true|false] [--after <itemId>]
+  mdx-artifacts interactions remove-item <file.mdx> <id> --item-id <id>
+  mdx-artifacts interactions update-item <file.mdx> <id> --item-id <id> [--title <title>] [--summary <text>] [--badge <text>] [--tags <tag,tag>] [--disabled true|false]
+  mdx-artifacts review add <file.mdx> --anchor <anchorId> --body <message> [--title <title>]
+  mdx-artifacts review reply <file.mdx> --thread <threadId> --body <message> [...repeat] [--status <status>]
+  mdx-artifacts review validate <file.mdx>
+  mdx-artifacts dev <file.mdx>
+  mdx-artifacts build <file.mdx>
 `);
 }
 main().catch((error) => {

package/dist/lib/cli/mdx/sortable-list.d.ts

@@ -0,0 +1,14 @@
+import type { SortableListItem } from "../../react";
+export type SortableListSeed = {
+    id: string;
+    title: string;
+    summary?: string;
+    items: SortableListItem[];
+};
+export declare function extractSortableListSeeds(source: string): SortableListSeed[];
+export declare function promoteSortableListOrder(source: string, listId: string, orderedIds: string[]): string;
+export declare function addSortableListItem(source: string, listId: string, item: SortableListItem, options?: {
+    afterId?: string;
+}): string;
+export declare function removeSortableListItem(source: string, listId: string, itemId: string): string;
+export declare function updateSortableListItem(source: string, listId: string, itemId: string, patch: Partial<Omit<SortableListItem, "id">>): string;

package/dist/lib/cli/mdx/sortable-list.js

@@ -0,0 +1,520 @@
+export function extractSortableListSeeds(source) {
+    return findJsxOpeningTags(source, "SortableList").map((tagSource) => parseSortableListTag(tagSource));
+}
+export function promoteSortableListOrder(source, listId, orderedIds) {
+    const target = findSortableListTags(source).find((tag) => extractStringProp(tag.source, "id") === listId);
+    if (!target) {
+        throw new Error(`SortableList not found: ${listId}.`);
+    }
+    const itemsExpression = extractExpressionPropRange(target.source, "items");
+    if (!itemsExpression) {
+        throw new Error(`SortableList ${listId} is missing required items prop.`);
+    }
+    const expression = target.source.slice(itemsExpression.start, itemsExpression.end);
+    const currentItems = parseSortableListItems(expression, listId);
+    const objectSpans = extractTopLevelObjectSpans(expression);
+    if (objectSpans.length !== currentItems.length) {
+        throw new Error(`SortableList ${listId} items must be a static object array.`);
+    }
+    const chunksById = new Map(currentItems.map((item, index) => [item.id, expression.slice(objectSpans[index].start, objectSpans[index].end)]));
+    const firstSpan = objectSpans[0];
+    const lastSpan = objectSpans[objectSpans.length - 1];
+    if (!firstSpan || !lastSpan) {
+        throw new Error(`SortableList ${listId} items must contain at least one item.`);
+    }
+    const separator = objectSpans.length > 1 ? expression.slice(objectSpans[0].end, objectSpans[1].start) : ",\n";
+    const nextExpression = [
+        expression.slice(0, firstSpan.start),
+        orderedIds.map((itemId) => {
+            const chunk = chunksById.get(itemId);
+            if (!chunk) {
+                throw new Error(`SortableList ${listId} item not found: ${itemId}.`);
+            }
+            return chunk;
+        }).join(separator),
+        expression.slice(lastSpan.end)
+    ].join("");
+    const absoluteStart = target.start + itemsExpression.start;
+    const absoluteEnd = target.start + itemsExpression.end;
+    return `${source.slice(0, absoluteStart)}${nextExpression}${source.slice(absoluteEnd)}`;
+}
+export function addSortableListItem(source, listId, item, options = {}) {
+    const context = createSortableListArrayContext(source, listId);
+    if (context.currentItems.some((currentItem) => currentItem.id === item.id)) {
+        throw new Error(`SortableList ${listId} already contains item: ${item.id}.`);
+    }
+    const objectChunk = formatSortableListItem(item);
+    const separator = createItemSeparator(context.expression, context.objectSpans);
+    const insertIndex = options.afterId
+        ? context.currentItems.findIndex((currentItem) => currentItem.id === options.afterId)
+        : context.currentItems.length - 1;
+    if (options.afterId && insertIndex < 0) {
+        throw new Error(`SortableList ${listId} item not found: ${options.afterId}.`);
+    }
+    const nextExpression = context.objectSpans.length === 0
+        ? insertFirstItem(context.expression, objectChunk)
+        : insertItemAfterSpan(context.expression, context.objectSpans[insertIndex], separator, objectChunk);
+    return replaceExpression(source, context, nextExpression);
+}
+export function removeSortableListItem(source, listId, itemId) {
+    const context = createSortableListArrayContext(source, listId);
+    const itemIndex = context.currentItems.findIndex((item) => item.id === itemId);
+    if (itemIndex < 0) {
+        throw new Error(`SortableList ${listId} item not found: ${itemId}.`);
+    }
+    const nextExpression = removeItemSpan(context.expression, context.objectSpans, itemIndex);
+    return replaceExpression(source, context, nextExpression);
+}
+export function updateSortableListItem(source, listId, itemId, patch) {
+    const context = createSortableListArrayContext(source, listId);
+    const itemIndex = context.currentItems.findIndex((item) => item.id === itemId);
+    if (itemIndex < 0) {
+        throw new Error(`SortableList ${listId} item not found: ${itemId}.`);
+    }
+    const nextItem = {
+        ...context.currentItems[itemIndex],
+        ...patch
+    };
+    const span = context.objectSpans[itemIndex];
+    const nextExpression = `${context.expression.slice(0, span.start)}${formatSortableListItem(nextItem)}${context.expression.slice(span.end)}`;
+    return replaceExpression(source, context, nextExpression);
+}
+function parseSortableListTag(tagSource) {
+    const id = extractStringProp(tagSource, "id");
+    const title = extractStringProp(tagSource, "title");
+    const summary = extractStringProp(tagSource, "summary");
+    const itemsExpression = extractExpressionProp(tagSource, "items");
+    if (!id) {
+        throw new Error("SortableList is missing required id prop.");
+    }
+    if (!title) {
+        throw new Error(`SortableList ${id} is missing required title prop.`);
+    }
+    if (!itemsExpression) {
+        throw new Error(`SortableList ${id} is missing required items prop.`);
+    }
+    return {
+        id,
+        title,
+        ...(summary ? { summary } : {}),
+        items: parseSortableListItems(itemsExpression, id)
+    };
+}
+function createSortableListArrayContext(source, listId) {
+    const target = findSortableListTags(source).find((tag) => extractStringProp(tag.source, "id") === listId);
+    if (!target) {
+        throw new Error(`SortableList not found: ${listId}.`);
+    }
+    const itemsExpression = extractExpressionPropRange(target.source, "items");
+    if (!itemsExpression) {
+        throw new Error(`SortableList ${listId} is missing required items prop.`);
+    }
+    const expression = target.source.slice(itemsExpression.start, itemsExpression.end);
+    const currentItems = parseSortableListItems(expression, listId);
+    const objectSpans = extractTopLevelObjectSpans(expression);
+    if (objectSpans.length !== currentItems.length) {
+        throw new Error(`SortableList ${listId} items must be a static object array.`);
+    }
+    return {
+        absoluteEnd: target.start + itemsExpression.end,
+        absoluteStart: target.start + itemsExpression.start,
+        currentItems,
+        expression,
+        objectSpans
+    };
+}
+function replaceExpression(source, context, nextExpression) {
+    return `${source.slice(0, context.absoluteStart)}${nextExpression}${source.slice(context.absoluteEnd)}`;
+}
+function formatSortableListItem(item) {
+    const fields = [
+        `id: ${quoteString(item.id)}`,
+        `title: ${quoteString(item.title)}`,
+        item.summary !== undefined ? `summary: ${quoteString(item.summary)}` : undefined,
+        item.badge !== undefined ? `badge: ${quoteString(item.badge)}` : undefined,
+        item.tags !== undefined ? `tags: [${item.tags.map(quoteString).join(", ")}]` : undefined,
+        item.disabled !== undefined ? `disabled: ${String(item.disabled)}` : undefined
+    ].filter(Boolean);
+    return `{ ${fields.join(", ")} }`;
+}
+function quoteString(value) {
+    return JSON.stringify(value);
+}
+function createItemSeparator(expression, objectSpans) {
+    if (objectSpans.length > 1) {
+        return expression.slice(objectSpans[0].end, objectSpans[1].start);
+    }
+    const leadingWhitespace = expression.slice(0, objectSpans[0]?.start ?? 0).match(/\n([ \t]*)$/)?.[1];
+    return `,\n${leadingWhitespace ?? "  "}`;
+}
+function insertFirstItem(expression, objectChunk) {
+    const arrayStart = expression.indexOf("[");
+    const arrayEnd = expression.lastIndexOf("]");
+    if (arrayStart < 0 || arrayEnd < arrayStart) {
+        throw new Error("SortableList items must be a static object array.");
+    }
+    const indentation = expression.slice(0, arrayEnd).match(/\n([ \t]*)$/)?.[1] ?? "  ";
+    return `${expression.slice(0, arrayStart + 1)}\n${indentation}  ${objectChunk}\n${indentation}${expression.slice(arrayEnd)}`;
+}
+function insertItemAfterSpan(expression, span, separator, objectChunk) {
+    return `${expression.slice(0, span.end)}${separator}${objectChunk}${expression.slice(span.end)}`;
+}
+function removeItemSpan(expression, objectSpans, itemIndex) {
+    const currentSpan = objectSpans[itemIndex];
+    const previousSpan = objectSpans[itemIndex - 1];
+    const nextSpan = objectSpans[itemIndex + 1];
+    if (!previousSpan && !nextSpan) {
+        return `${expression.slice(0, currentSpan.start)}${expression.slice(currentSpan.end)}`;
+    }
+    if (nextSpan) {
+        return `${expression.slice(0, currentSpan.start)}${expression.slice(nextSpan.start)}`;
+    }
+    return `${expression.slice(0, previousSpan.end)}${expression.slice(currentSpan.end)}`;
+}
+function parseSortableListItems(expression, listId) {
+    const parser = new StaticExpressionParser(expression);
+    const value = parser.parse();
+    if (!Array.isArray(value)) {
+        throw new Error(`SortableList ${listId} items must be a static object array.`);
+    }
+    return value.map((item, index) => normalizeSortableListItem(item, listId, index));
+}
+function normalizeSortableListItem(value, listId, index) {
+    if (!isRecord(value)) {
+        throw new Error(`SortableList ${listId} item at index ${index} must be an object.`);
+    }
+    if (typeof value.id !== "string" || !value.id) {
+        throw new Error(`SortableList ${listId} item at index ${index} is missing string id.`);
+    }
+    if (typeof value.title !== "string" || !value.title) {
+        throw new Error(`SortableList ${listId} item ${value.id} is missing string title.`);
+    }
+    return {
+        id: value.id,
+        title: value.title,
+        ...(typeof value.summary === "string" ? { summary: value.summary } : {}),
+        ...(typeof value.badge === "string" ? { badge: value.badge } : {}),
+        ...(Array.isArray(value.tags) ? { tags: value.tags.filter((tag) => typeof tag === "string") } : {}),
+        ...(typeof value.disabled === "boolean" ? { disabled: value.disabled } : {})
+    };
+}
+function findJsxOpeningTags(source, componentName) {
+    return findJsxOpeningTagSources(source, componentName).map((tag) => tag.source);
+}
+function findSortableListTags(source) {
+    return findJsxOpeningTagSources(source, "SortableList");
+}
+function findJsxOpeningTagSources(source, componentName) {
+    const tags = [];
+    const locatedTags = [];
+    const startPattern = new RegExp(`<${componentName}(?=[\\s>/])`, "g");
+    for (const match of source.matchAll(startPattern)) {
+        const start = match.index ?? 0;
+        const end = findJsxOpeningTagEnd(source, start);
+        if (end >= 0) {
+            const tagSource = source.slice(start, end + 1);
+            tags.push(tagSource);
+            locatedTags.push({ source: tagSource, start, end: end + 1 });
+        }
+    }
+    return locatedTags;
+}
+function findJsxOpeningTagEnd(source, start) {
+    const scanner = new SourceScanner(source, start);
+    let braceDepth = 0;
+    while (!scanner.done()) {
+        const char = scanner.current();
+        if (scanner.consumeString()) {
+            continue;
+        }
+        if (char === "{") {
+            braceDepth += 1;
+        }
+        else if (char === "}") {
+            braceDepth -= 1;
+        }
+        else if (char === ">" && braceDepth === 0) {
+            return scanner.index;
+        }
+        scanner.advance();
+    }
+    return -1;
+}
+function extractStringProp(source, propName) {
+    const direct = source.match(new RegExp(`\\b${propName}\\s*=\\s*["']([^"']*)["']`))?.[1];
+    if (direct !== undefined) {
+        return direct;
+    }
+    return source.match(new RegExp(`\\b${propName}\\s*=\\s*\\{\\s*["']([^"']*)["']\\s*\\}`))?.[1];
+}
+function extractExpressionProp(source, propName) {
+    const range = extractExpressionPropRange(source, propName);
+    return range ? source.slice(range.start, range.end) : undefined;
+}
+function extractExpressionPropRange(source, propName) {
+    const propStart = source.search(new RegExp(`\\b${propName}\\s*=\\s*\\{`));
+    if (propStart < 0) {
+        return undefined;
+    }
+    const expressionStart = source.indexOf("{", propStart);
+    const expressionEnd = findMatchingBrace(source, expressionStart);
+    if (expressionEnd < 0) {
+        return undefined;
+    }
+    return {
+        start: expressionStart + 1,
+        end: expressionEnd
+    };
+}
+function findMatchingBrace(source, start) {
+    const scanner = new SourceScanner(source, start);
+    let depth = 0;
+    while (!scanner.done()) {
+        const char = scanner.current();
+        if (scanner.consumeString()) {
+            continue;
+        }
+        if (char === "{") {
+            depth += 1;
+        }
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return scanner.index;
+            }
+        }
+        scanner.advance();
+    }
+    return -1;
+}
+function extractTopLevelObjectSpans(expression) {
+    const trimmedStart = expression.search(/\S/);
+    if (trimmedStart < 0 || expression[trimmedStart] !== "[") {
+        throw new Error("SortableList items must be a static object array.");
+    }
+    const spans = [];
+    const scanner = new SourceScanner(expression, trimmedStart + 1);
+    let arrayDepth = 1;
+    let braceDepth = 0;
+    while (!scanner.done() && arrayDepth > 0) {
+        const char = scanner.current();
+        if (scanner.consumeString()) {
+            continue;
+        }
+        if (char === "[" && braceDepth === 0) {
+            arrayDepth += 1;
+            scanner.advance();
+            continue;
+        }
+        if (char === "]" && braceDepth === 0) {
+            arrayDepth -= 1;
+            scanner.advance();
+            continue;
+        }
+        if (char === "{" && arrayDepth === 1 && braceDepth === 0) {
+            const start = scanner.index;
+            const end = findMatchingBrace(expression, scanner.index);
+            if (end < 0) {
+                throw new Error("SortableList items contain an unterminated object.");
+            }
+            spans.push({ start, end: end + 1 });
+            scanner.index = end + 1;
+            continue;
+        }
+        if (char === "{") {
+            braceDepth += 1;
+        }
+        else if (char === "}") {
+            braceDepth -= 1;
+        }
+        scanner.advance();
+    }
+    return spans;
+}
+class StaticExpressionParser {
+    source;
+    index = 0;
+    constructor(source) {
+        this.source = source;
+    }
+    parse() {
+        const value = this.parseValue();
+        this.skipWhitespace();
+        if (!this.done()) {
+            throw new Error("SortableList items must use a static object array.");
+        }
+        return value;
+    }
+    parseValue() {
+        this.skipWhitespace();
+        const char = this.current();
+        if (char === "[" || char === "{") {
+            return char === "[" ? this.parseArray() : this.parseObject();
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            return this.parseString();
+        }
+        if (this.source.startsWith("true", this.index)) {
+            this.index += 4;
+            return true;
+        }
+        if (this.source.startsWith("false", this.index)) {
+            this.index += 5;
+            return false;
+        }
+        if (this.source.startsWith("null", this.index)) {
+            this.index += 4;
+            return null;
+        }
+        throw new Error("SortableList items must use only static objects, arrays, strings, booleans, or null.");
+    }
+    parseArray() {
+        const values = [];
+        this.expect("[");
+        this.skipWhitespace();
+        while (this.current() !== "]") {
+            values.push(this.parseValue());
+            this.skipWhitespace();
+            if (this.current() === ",") {
+                this.index += 1;
+                this.skipWhitespace();
+            }
+            else if (this.current() !== "]") {
+                throw new Error("SortableList items array contains unsupported syntax.");
+            }
+        }
+        this.expect("]");
+        return values;
+    }
+    parseObject() {
+        const value = {};
+        this.expect("{");
+        this.skipWhitespace();
+        while (this.current() !== "}") {
+            const key = this.parseObjectKey();
+            this.skipWhitespace();
+            this.expect(":");
+            value[key] = this.parseValue();
+            this.skipWhitespace();
+            if (this.current() === ",") {
+                this.index += 1;
+                this.skipWhitespace();
+            }
+            else if (this.current() !== "}") {
+                throw new Error("SortableList item object contains unsupported syntax.");
+            }
+        }
+        this.expect("}");
+        return value;
+    }
+    parseObjectKey() {
+        this.skipWhitespace();
+        const char = this.current();
+        if (char === '"' || char === "'") {
+            return this.parseString();
+        }
+        const match = this.source.slice(this.index).match(/^[A-Za-z_$][A-Za-z0-9_$-]*/);
+        if (!match) {
+            throw new Error("SortableList item object contains an unsupported key.");
+        }
+        this.index += match[0].length;
+        return match[0];
+    }
+    parseString() {
+        const quote = this.current();
+        let value = "";
+        this.index += 1;
+        while (!this.done()) {
+            const char = this.current();
+            if (char === quote) {
+                this.index += 1;
+                return value;
+            }
+            if (quote === "`" && char === "$" && this.source[this.index + 1] === "{") {
+                throw new Error("SortableList items do not support template interpolation.");
+            }
+            if (char === "\\") {
+                value += this.parseEscape();
+            }
+            else {
+                value += char;
+                this.index += 1;
+            }
+        }
+        throw new Error("SortableList items contain an unterminated string.");
+    }
+    parseEscape() {
+        const next = this.source[this.index + 1];
+        if (next === undefined) {
+            throw new Error("SortableList items contain an invalid string escape.");
+        }
+        this.index += 2;
+        if (next === "n")
+            return "\n";
+        if (next === "r")
+            return "\r";
+        if (next === "t")
+            return "\t";
+        return next;
+    }
+    expect(char) {
+        if (this.current() !== char) {
+            throw new Error(`Expected ${char} in SortableList items.`);
+        }
+        this.index += 1;
+    }
+    skipWhitespace() {
+        while (!this.done() && /\s/.test(this.current())) {
+            this.index += 1;
+        }
+    }
+    current() {
+        return this.source[this.index] ?? "";
+    }
+    done() {
+        return this.index >= this.source.length;
+    }
+}
+class SourceScanner {
+    source;
+    index;
+    constructor(source, index) {
+        this.source = source;
+        this.index = index;
+    }
+    consumeString() {
+        const quote = this.current();
+        if (quote !== '"' && quote !== "'" && quote !== "`") {
+            return false;
+        }
+        this.index += 1;
+        while (!this.done()) {
+            const char = this.current();
+            if (char === "\\") {
+                this.index += 2;
+                continue;
+            }
+            if (quote === "`" && char === "$" && this.source[this.index + 1] === "{") {
+                this.index += 2;
+                continue;
+            }
+            this.index += 1;
+            if (char === quote) {
+                break;
+            }
+        }
+        return true;
+    }
+    current() {
+        return this.source[this.index] ?? "";
+    }
+    advance() {
+        this.index += 1;
+    }
+    done() {
+        return this.index >= this.source.length;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/lib/cli/resources/resource-policy.d.ts

@@ -0,0 +1,15 @@
+import type { ArtifactDiagnostic } from "../diagnostics/diagnostics";
+export declare const resourceTypes: readonly ["style", "data", "artifact", "component-module"];
+export type ResourceType = (typeof resourceTypes)[number];
+export type ResourceReference = {
+    type: ResourceType;
+    path: string;
+    sourcePath: string;
+    fieldName?: string;
+    mustExist?: boolean;
+};
+export type ResourcePolicyInput = {
+    projectRoot: string;
+    references: ResourceReference[];
+};
+export declare function validateResourceReferences(input: ResourcePolicyInput): Promise<ArtifactDiagnostic[]>;

package/dist/lib/cli/resources/resource-policy.js

@@ -0,0 +1,46 @@
+import { access } from "node:fs/promises";
+import { resolveSafeProjectPath } from "./safe-path.js";
+export const resourceTypes = ["style", "data", "artifact", "component-module"];
+export async function validateResourceReferences(input) {
+    const diagnostics = [];
+    for (const reference of input.references) {
+        const safePath = await resolveSafeProjectPath(input.projectRoot, reference.path, { realpath: true });
+        if (!safePath.ok) {
+            diagnostics.push({
+                severity: "error",
+                code: safePath.code,
+                message: resourceMessage(reference, safePath.message),
+                sourcePath: reference.sourcePath,
+                propName: reference.fieldName,
+                suggestion: safePath.suggestion
+            });
+            continue;
+        }
+        if (reference.mustExist === false) {
+            continue;
+        }
+        try {
+            await access(safePath.path);
+        }
+        catch {
+            diagnostics.push({
+                severity: "error",
+                code: "resource_not_found",
+                message: `${resourceLabel(reference.type)} not found: ${reference.path}`,
+                sourcePath: reference.sourcePath,
+                propName: reference.fieldName,
+                suggestion: "Confirm the resource path exists relative to the project root."
+            });
+        }
+    }
+    return diagnostics;
+}
+function resourceMessage(reference, message) {
+    return message.replace("resources", `${resourceLabel(reference.type)}s`).replace("Resource path", resourceLabel(reference.type));
+}
+function resourceLabel(type) {
+    if (type === "component-module") {
+        return "component module resource";
+    }
+    return `${type} resource`;
+}