mdx-artifacts 0.1.1 → 0.2.0

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`;
+}

package/dist/lib/cli/resources/safe-path.d.ts

@@ -0,0 +1,13 @@
+export type SafeProjectPathResult = {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    code: "remote_resource_blocked" | "home_resource_blocked" | "resource_path_escape";
+    message: string;
+    suggestion: string;
+};
+export type SafeProjectPathOptions = {
+    realpath?: boolean;
+};
+export declare function resolveSafeProjectPath(projectRoot: string, resourcePath: string, options?: SafeProjectPathOptions): Promise<SafeProjectPathResult>;

package/dist/lib/cli/resources/safe-path.js

@@ -0,0 +1,55 @@
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+export async function resolveSafeProjectPath(projectRoot, resourcePath, options = {}) {
+    if (isUrlLike(resourcePath)) {
+        return {
+            ok: false,
+            code: "remote_resource_blocked",
+            message: `Remote resources are not allowed: ${resourcePath}`,
+            suggestion: "Use a local project-relative resource path."
+        };
+    }
+    if (resourcePath === "~" || resourcePath.startsWith("~/")) {
+        return {
+            ok: false,
+            code: "home_resource_blocked",
+            message: `Home-relative resources are not allowed: ${resourcePath}`,
+            suggestion: "Move the resource inside the project and reference it with a project-relative path."
+        };
+    }
+    const rootPath = path.resolve(projectRoot);
+    const resolvedPath = path.resolve(rootPath, resourcePath);
+    if (!isInsidePath(rootPath, resolvedPath)) {
+        return {
+            ok: false,
+            code: "resource_path_escape",
+            message: `Resource path must stay inside the project root: ${resourcePath}`,
+            suggestion: "Move the resource inside the project root before referencing it."
+        };
+    }
+    if (!options.realpath) {
+        return { ok: true, path: resolvedPath };
+    }
+    try {
+        const [realRootPath, realResolvedPath] = await Promise.all([realpath(rootPath), realpath(resolvedPath)]);
+        if (!isInsidePath(realRootPath, realResolvedPath)) {
+            return {
+                ok: false,
+                code: "resource_path_escape",
+                message: `Resource path must stay inside the project root: ${resourcePath}`,
+                suggestion: "Do not reference symlinks that resolve outside the project root."
+            };
+        }
+        return { ok: true, path: realResolvedPath };
+    }
+    catch {
+        return { ok: true, path: resolvedPath };
+    }
+}
+function isUrlLike(resourcePath) {
+    return /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(resourcePath) || /^(data|blob):/.test(resourcePath) || resourcePath.startsWith("//");
+}
+function isInsidePath(rootPath, candidatePath) {
+    const relativePath = path.relative(rootPath, candidatePath);
+    return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}

package/dist/lib/cli/services/interaction-service.d.ts

@@ -0,0 +1,40 @@
+import { type ArtifactState } from "../state/artifact-state";
+import { type SortableListSeed } from "../mdx/sortable-list";
+import type { SortableListItem } from "../../react";
+export type InteractionsInspectResult = {
+    component: SortableListSeed;
+    order: {
+        source: "mdx" | "state";
+        orderedIds: string[];
+        staleIds: string[];
+        appendedIds: string[];
+    };
+    state: {
+        path: string;
+        exists: boolean;
+    };
+    source: {
+        path: string;
+    };
+    warnings: string[];
+};
+export type InteractionMutationResult = {
+    action: string;
+    component: string;
+    sourcePath: string;
+    statePath: string;
+    state: ArtifactState;
+    itemId?: string;
+    orderedIds?: string[];
+    status?: "ok" | "noop";
+    reason?: string;
+};
+export declare function inspectInteractionService(projectRoot: string, input: string, id: string): Promise<InteractionsInspectResult>;
+export declare function setInteractionOrderService(projectRoot: string, input: string, id: string, orderedIds: string[]): Promise<InteractionMutationResult>;
+export declare function resetInteractionService(projectRoot: string, input: string, id: string): Promise<InteractionMutationResult>;
+export declare function promoteInteractionService(projectRoot: string, input: string, id: string): Promise<InteractionMutationResult>;
+export declare function addInteractionItemService(projectRoot: string, input: string, id: string, item: SortableListItem, options?: {
+    afterId?: string;
+}): Promise<InteractionMutationResult>;
+export declare function removeInteractionItemService(projectRoot: string, input: string, id: string, itemId: string): Promise<InteractionMutationResult>;
+export declare function updateInteractionItemService(projectRoot: string, input: string, id: string, itemId: string, patch: Partial<Omit<SortableListItem, "id">>): Promise<InteractionMutationResult>;