@wp-typia/project-tools 0.22.4 → 0.22.6

package/dist/runtime/workspace-inventory.js

@@ -4,6 +4,9 @@ import { readFile, writeFile } from "node:fs/promises";
 import ts from "typescript";
 import { REST_RESOURCE_METHOD_IDS } from "./cli-add-shared.js";
 import { escapeRegex } from "./php-utils.js";
+function defineInventoryEntryParser(descriptor) {
+    return descriptor;
+}
 export const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 export const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 export const BLOCK_STYLE_CONFIG_ENTRY_MARKER = "\t// wp-typia add style entries";
@@ -202,102 +205,319 @@ export const EDITOR_PLUGINS: WorkspaceEditorPluginConfig[] = [
 \t// wp-typia add editor-plugin entries
 ];
 `;
+const BLOCK_INVENTORY_SECTION = {
+    append: {
+        marker: BLOCK_CONFIG_ENTRY_MARKER,
+        optionKey: "blockEntries",
+    },
+    parse: {
+        entriesKey: "blocks",
+        entry: defineInventoryEntryParser({
+            entryName: "BLOCKS",
+            fields: [
+                { key: "apiTypesFile" },
+                { key: "attributeTypeName" },
+                { key: "openApiFile" },
+                { key: "slug", required: true },
+                { key: "typesFile", required: true },
+            ],
+        }),
+        exportName: "BLOCKS",
+        required: true,
+    },
+};
 const INVENTORY_SECTIONS = [
     {
+        append: {
+            marker: VARIATION_CONFIG_ENTRY_MARKER,
+            optionKey: "variationEntries",
+        },
         interface: {
             name: "WorkspaceVariationConfig",
             section: VARIATIONS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "variations",
+            entry: defineInventoryEntryParser({
+                entryName: "VARIATIONS",
+                fields: [
+                    { key: "block", required: true },
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasVariationsSection",
+        },
         value: {
             name: "VARIATIONS",
             section: VARIATIONS_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: BLOCK_STYLE_CONFIG_ENTRY_MARKER,
+            optionKey: "blockStyleEntries",
+        },
         interface: {
             name: "WorkspaceBlockStyleConfig",
             section: BLOCK_STYLES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "blockStyles",
+            entry: defineInventoryEntryParser({
+                entryName: "BLOCK_STYLES",
+                fields: [
+                    { key: "block", required: true },
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasBlockStylesSection",
+        },
         value: {
             name: "BLOCK_STYLES",
             section: BLOCK_STYLES_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: BLOCK_TRANSFORM_CONFIG_ENTRY_MARKER,
+            optionKey: "blockTransformEntries",
+        },
         interface: {
             name: "WorkspaceBlockTransformConfig",
             section: BLOCK_TRANSFORMS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "blockTransforms",
+            entry: defineInventoryEntryParser({
+                entryName: "BLOCK_TRANSFORMS",
+                fields: [
+                    { key: "block", required: true },
+                    { key: "file", required: true },
+                    { key: "from", required: true },
+                    { key: "slug", required: true },
+                    { key: "to", required: true },
+                ],
+            }),
+            hasSectionKey: "hasBlockTransformsSection",
+        },
         value: {
             name: "BLOCK_TRANSFORMS",
             section: BLOCK_TRANSFORMS_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: PATTERN_CONFIG_ENTRY_MARKER,
+            optionKey: "patternEntries",
+        },
         interface: {
             name: "WorkspacePatternConfig",
             section: PATTERNS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "patterns",
+            entry: defineInventoryEntryParser({
+                entryName: "PATTERNS",
+                fields: [
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasPatternsSection",
+        },
         value: {
             name: "PATTERNS",
             section: PATTERNS_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: BINDING_SOURCE_CONFIG_ENTRY_MARKER,
+            optionKey: "bindingSourceEntries",
+        },
         interface: {
             name: "WorkspaceBindingSourceConfig",
             section: BINDING_SOURCES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "bindingSources",
+            entry: defineInventoryEntryParser({
+                entryName: "BINDING_SOURCES",
+                fields: [
+                    { key: "attribute" },
+                    { key: "block" },
+                    { key: "editorFile", required: true },
+                    { key: "serverFile", required: true },
+                    { key: "slug", required: true },
+                ],
+            }),
+            hasSectionKey: "hasBindingSourcesSection",
+        },
         value: {
             name: "BINDING_SOURCES",
             section: BINDING_SOURCES_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: REST_RESOURCE_CONFIG_ENTRY_MARKER,
+            optionKey: "restResourceEntries",
+        },
         interface: {
             name: "WorkspaceRestResourceConfig",
             section: REST_RESOURCES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "restResources",
+            entry: defineInventoryEntryParser({
+                entryName: "REST_RESOURCES",
+                fields: [
+                    { key: "apiFile", required: true },
+                    { key: "clientFile", required: true },
+                    { key: "dataFile", required: true },
+                    {
+                        key: "methods",
+                        kind: "stringArray",
+                        required: true,
+                        validate: (value, context) => {
+                            const methods = Array.isArray(value) ? value : [];
+                            const invalidMethods = methods.filter((method) => !REST_RESOURCE_METHOD_IDS.includes(method));
+                            if (invalidMethods.length > 0) {
+                                throw new Error(`${context.entryName}[${context.elementIndex}].${context.key} includes unsupported values: ${invalidMethods.join(", ")}.`);
+                            }
+                        },
+                    },
+                    { key: "namespace", required: true },
+                    { key: "openApiFile", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "typesFile", required: true },
+                    { key: "validatorsFile", required: true },
+                ],
+            }),
+            hasSectionKey: "hasRestResourcesSection",
+        },
         value: {
             name: "REST_RESOURCES",
             section: REST_RESOURCES_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: ABILITY_CONFIG_ENTRY_MARKER,
+            optionKey: "abilityEntries",
+        },
         interface: {
             name: "WorkspaceAbilityConfig",
             section: ABILITIES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "abilities",
+            entry: defineInventoryEntryParser({
+                entryName: "ABILITIES",
+                fields: [
+                    { key: "clientFile", required: true },
+                    { key: "configFile", required: true },
+                    { key: "dataFile", required: true },
+                    { key: "inputSchemaFile", required: true },
+                    { key: "inputTypeName", required: true },
+                    { key: "outputSchemaFile", required: true },
+                    { key: "outputTypeName", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "typesFile", required: true },
+                ],
+            }),
+            hasSectionKey: "hasAbilitiesSection",
+        },
         value: {
             name: "ABILITIES",
             section: ABILITIES_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: AI_FEATURE_CONFIG_ENTRY_MARKER,
+            optionKey: "aiFeatureEntries",
+        },
         interface: {
             name: "WorkspaceAiFeatureConfig",
             section: AI_FEATURES_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "aiFeatures",
+            entry: defineInventoryEntryParser({
+                entryName: "AI_FEATURES",
+                fields: [
+                    { key: "aiSchemaFile", required: true },
+                    { key: "apiFile", required: true },
+                    { key: "clientFile", required: true },
+                    { key: "dataFile", required: true },
+                    { key: "namespace", required: true },
+                    { key: "openApiFile", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "typesFile", required: true },
+                    { key: "validatorsFile", required: true },
+                ],
+            }),
+            hasSectionKey: "hasAiFeaturesSection",
+        },
         value: {
             name: "AI_FEATURES",
             section: AI_FEATURES_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: ADMIN_VIEW_CONFIG_ENTRY_MARKER,
+            optionKey: "adminViewEntries",
+        },
         interface: {
             name: "WorkspaceAdminViewConfig",
             section: ADMIN_VIEWS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "adminViews",
+            entry: defineInventoryEntryParser({
+                entryName: "ADMIN_VIEWS",
+                fields: [
+                    { key: "file", required: true },
+                    { key: "phpFile", required: true },
+                    { key: "slug", required: true },
+                    { key: "source" },
+                ],
+            }),
+            hasSectionKey: "hasAdminViewsSection",
+        },
         value: {
             name: "ADMIN_VIEWS",
             section: ADMIN_VIEWS_CONST_SECTION,
         },
     },
     {
+        append: {
+            marker: EDITOR_PLUGIN_CONFIG_ENTRY_MARKER,
+            optionKey: "editorPluginEntries",
+        },
         interface: {
             name: "WorkspaceEditorPluginConfig",
             section: EDITOR_PLUGINS_INTERFACE_SECTION,
         },
+        parse: {
+            entriesKey: "editorPlugins",
+            entry: defineInventoryEntryParser({
+                entryName: "EDITOR_PLUGINS",
+                fields: [
+                    { key: "file", required: true },
+                    { key: "slug", required: true },
+                    { key: "slot", required: true },
+                ],
+            }),
+            hasSectionKey: "hasEditorPluginsSection",
+        },
         value: {
             name: "EDITOR_PLUGINS",
             section: EDITOR_PLUGINS_CONST_SECTION,
@@ -383,169 +603,60 @@ function getRequiredStringArrayProperty(entryName, elementIndex, objectLiteral,
     }
     throw new Error(`${entryName}[${elementIndex}] is missing required "${key}" in scripts/block-config.ts.`);
 }
-function parseBlockEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`BLOCKS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            apiTypesFile: getOptionalStringProperty("BLOCKS", elementIndex, element, "apiTypesFile"),
-            attributeTypeName: getOptionalStringProperty("BLOCKS", elementIndex, element, "attributeTypeName"),
-            openApiFile: getOptionalStringProperty("BLOCKS", elementIndex, element, "openApiFile"),
-            slug: getRequiredStringProperty("BLOCKS", elementIndex, element, "slug"),
-            typesFile: getRequiredStringProperty("BLOCKS", elementIndex, element, "typesFile"),
-        };
-    });
-}
-function parseVariationEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`VARIATIONS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            block: getRequiredStringProperty("VARIATIONS", elementIndex, element, "block"),
-            file: getRequiredStringProperty("VARIATIONS", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("VARIATIONS", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseBlockStyleEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`BLOCK_STYLES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            block: getRequiredStringProperty("BLOCK_STYLES", elementIndex, element, "block"),
-            file: getRequiredStringProperty("BLOCK_STYLES", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("BLOCK_STYLES", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseBlockTransformEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`BLOCK_TRANSFORMS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            block: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "block"),
-            file: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "file"),
-            from: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "from"),
-            slug: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "slug"),
-            to: getRequiredStringProperty("BLOCK_TRANSFORMS", elementIndex, element, "to"),
-        };
-    });
-}
-function parsePatternEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`PATTERNS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            file: getRequiredStringProperty("PATTERNS", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("PATTERNS", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseBindingSourceEntries(arrayLiteral) {
+function parseInventoryEntries(arrayLiteral, descriptor) {
     return arrayLiteral.elements.map((element, elementIndex) => {
         if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`BINDING_SOURCES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+            throw new Error(`${descriptor.entryName}[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
         }
-        return {
-            attribute: getOptionalStringProperty("BINDING_SOURCES", elementIndex, element, "attribute"),
-            block: getOptionalStringProperty("BINDING_SOURCES", elementIndex, element, "block"),
-            editorFile: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "editorFile"),
-            serverFile: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "serverFile"),
-            slug: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "slug"),
-        };
-    });
-}
-function parseRestResourceEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`REST_RESOURCES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        const entry = {};
+        for (const field of descriptor.fields) {
+            const kind = field.kind ?? "string";
+            const value = kind === "stringArray"
+                ? getRequiredStringArrayProperty(descriptor.entryName, elementIndex, element, field.key)
+                : field.required
+                    ? getRequiredStringProperty(descriptor.entryName, elementIndex, element, field.key)
+                    : getOptionalStringProperty(descriptor.entryName, elementIndex, element, field.key);
+            field.validate?.(value, {
+                elementIndex,
+                entryName: descriptor.entryName,
+                key: field.key,
+            });
+            entry[field.key] = value;
         }
-        const methods = getRequiredStringArrayProperty("REST_RESOURCES", elementIndex, element, "methods");
-        const invalidMethods = methods.filter((method) => !REST_RESOURCE_METHOD_IDS.includes(method));
-        if (invalidMethods.length > 0) {
-            throw new Error(`REST_RESOURCES[${elementIndex}].methods includes unsupported values: ${invalidMethods.join(", ")}.`);
-        }
-        return {
-            apiFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "apiFile"),
-            clientFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "clientFile"),
-            dataFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "dataFile"),
-            methods,
-            namespace: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "namespace"),
-            openApiFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "openApiFile"),
-            phpFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "phpFile"),
-            slug: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "slug"),
-            typesFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "typesFile"),
-            validatorsFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "validatorsFile"),
-        };
+        return entry;
     });
 }
-function parseAiFeatureEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`AI_FEATURES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
+function parseInventorySection(sourceFile, descriptor) {
+    if (!descriptor.parse) {
         return {
-            aiSchemaFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "aiSchemaFile"),
-            apiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "apiFile"),
-            clientFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "clientFile"),
-            dataFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "dataFile"),
-            namespace: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "namespace"),
-            openApiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "openApiFile"),
-            phpFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "phpFile"),
-            slug: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "slug"),
-            typesFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "typesFile"),
-            validatorsFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "validatorsFile"),
+            entries: [],
+            found: false,
         };
-    });
-}
-function parseAbilityEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`ABILITIES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-        }
-        return {
-            clientFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "clientFile"),
-            configFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "configFile"),
-            dataFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "dataFile"),
-            inputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputSchemaFile"),
-            inputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputTypeName"),
-            outputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputSchemaFile"),
-            outputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputTypeName"),
-            phpFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "phpFile"),
-            slug: getRequiredStringProperty("ABILITIES", elementIndex, element, "slug"),
-            typesFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "typesFile"),
-        };
-    });
-}
-function parseEditorPluginEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`EDITOR_PLUGINS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+    }
+    const exportName = descriptor.parse.exportName ?? descriptor.value?.name;
+    if (!exportName) {
+        throw new Error("Inventory parser descriptor is missing an export name.");
+    }
+    const exportedArray = findExportedArrayLiteral(sourceFile, exportName);
+    if (!exportedArray.found) {
+        if (descriptor.parse.required) {
+            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
         }
         return {
-            file: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "file"),
-            slug: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slug"),
-            slot: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slot"),
+            entries: [],
+            found: false,
         };
-    });
-}
-function parseAdminViewEntries(arrayLiteral) {
-    return arrayLiteral.elements.map((element, elementIndex) => {
-        if (!ts.isObjectLiteralExpression(element)) {
-            throw new Error(`ADMIN_VIEWS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+    }
+    if (!exportedArray.array) {
+        if (descriptor.parse.required) {
+            throw new Error(`scripts/block-config.ts must export a ${exportName} array.`);
         }
-        return {
-            file: getRequiredStringProperty("ADMIN_VIEWS", elementIndex, element, "file"),
-            phpFile: getRequiredStringProperty("ADMIN_VIEWS", elementIndex, element, "phpFile"),
-            slug: getRequiredStringProperty("ADMIN_VIEWS", elementIndex, element, "slug"),
-            source: getOptionalStringProperty("ADMIN_VIEWS", elementIndex, element, "source"),
-        };
-    });
+        throw new Error(`scripts/block-config.ts must export ${exportName} as an array literal.`);
+    }
+    return {
+        entries: parseInventoryEntries(exportedArray.array, descriptor.parse.entry),
+        found: true,
+    };
 }
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
@@ -556,82 +667,42 @@ function parseAdminViewEntries(arrayLiteral) {
  */
 export function parseWorkspaceInventorySource(source) {
     const sourceFile = ts.createSourceFile("block-config.ts", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const blockArray = findExportedArrayLiteral(sourceFile, "BLOCKS");
-    if (!blockArray.found || !blockArray.array) {
-        throw new Error("scripts/block-config.ts must export a BLOCKS array.");
-    }
-    const variationArray = findExportedArrayLiteral(sourceFile, "VARIATIONS");
-    const blockStyleArray = findExportedArrayLiteral(sourceFile, "BLOCK_STYLES");
-    const blockTransformArray = findExportedArrayLiteral(sourceFile, "BLOCK_TRANSFORMS");
-    const patternArray = findExportedArrayLiteral(sourceFile, "PATTERNS");
-    const bindingSourceArray = findExportedArrayLiteral(sourceFile, "BINDING_SOURCES");
-    const restResourceArray = findExportedArrayLiteral(sourceFile, "REST_RESOURCES");
-    const abilityArray = findExportedArrayLiteral(sourceFile, "ABILITIES");
-    const aiFeatureArray = findExportedArrayLiteral(sourceFile, "AI_FEATURES");
-    const adminViewArray = findExportedArrayLiteral(sourceFile, "ADMIN_VIEWS");
-    const editorPluginArray = findExportedArrayLiteral(sourceFile, "EDITOR_PLUGINS");
-    if (variationArray.found && !variationArray.array) {
-        throw new Error("scripts/block-config.ts must export VARIATIONS as an array literal.");
-    }
-    if (blockStyleArray.found && !blockStyleArray.array) {
-        throw new Error("scripts/block-config.ts must export BLOCK_STYLES as an array literal.");
-    }
-    if (blockTransformArray.found && !blockTransformArray.array) {
-        throw new Error("scripts/block-config.ts must export BLOCK_TRANSFORMS as an array literal.");
-    }
-    if (patternArray.found && !patternArray.array) {
-        throw new Error("scripts/block-config.ts must export PATTERNS as an array literal.");
-    }
-    if (bindingSourceArray.found && !bindingSourceArray.array) {
-        throw new Error("scripts/block-config.ts must export BINDING_SOURCES as an array literal.");
-    }
-    if (restResourceArray.found && !restResourceArray.array) {
-        throw new Error("scripts/block-config.ts must export REST_RESOURCES as an array literal.");
-    }
-    if (abilityArray.found && !abilityArray.array) {
-        throw new Error("scripts/block-config.ts must export ABILITIES as an array literal.");
-    }
-    if (aiFeatureArray.found && !aiFeatureArray.array) {
-        throw new Error("scripts/block-config.ts must export AI_FEATURES as an array literal.");
-    }
-    if (adminViewArray.found && !adminViewArray.array) {
-        throw new Error("scripts/block-config.ts must export ADMIN_VIEWS as an array literal.");
-    }
-    if (editorPluginArray.found && !editorPluginArray.array) {
-        throw new Error("scripts/block-config.ts must export EDITOR_PLUGINS as an array literal.");
-    }
-    return {
-        abilities: abilityArray.array ? parseAbilityEntries(abilityArray.array) : [],
-        adminViews: adminViewArray.array ? parseAdminViewEntries(adminViewArray.array) : [],
-        aiFeatures: aiFeatureArray.array ? parseAiFeatureEntries(aiFeatureArray.array) : [],
-        bindingSources: bindingSourceArray.array
-            ? parseBindingSourceEntries(bindingSourceArray.array)
-            : [],
-        blockStyles: blockStyleArray.array ? parseBlockStyleEntries(blockStyleArray.array) : [],
-        blockTransforms: blockTransformArray.array
-            ? parseBlockTransformEntries(blockTransformArray.array)
-            : [],
-        blocks: parseBlockEntries(blockArray.array),
-        hasAbilitiesSection: abilityArray.found,
-        hasAdminViewsSection: adminViewArray.found,
-        hasAiFeaturesSection: aiFeatureArray.found,
-        hasBindingSourcesSection: bindingSourceArray.found,
-        hasBlockStylesSection: blockStyleArray.found,
-        hasBlockTransformsSection: blockTransformArray.found,
-        hasEditorPluginsSection: editorPluginArray.found,
-        hasPatternsSection: patternArray.found,
-        hasRestResourcesSection: restResourceArray.found,
-        hasVariationsSection: variationArray.found,
-        editorPlugins: editorPluginArray.array
-            ? parseEditorPluginEntries(editorPluginArray.array)
-            : [],
-        patterns: patternArray.array ? parsePatternEntries(patternArray.array) : [],
-        restResources: restResourceArray.array
-            ? parseRestResourceEntries(restResourceArray.array)
-            : [],
+    const parsedInventory = {
+        abilities: [],
+        adminViews: [],
+        aiFeatures: [],
+        bindingSources: [],
+        blockStyles: [],
+        blockTransforms: [],
+        blocks: parseInventorySection(sourceFile, BLOCK_INVENTORY_SECTION).entries,
+        editorPlugins: [],
+        hasAbilitiesSection: false,
+        hasAdminViewsSection: false,
+        hasAiFeaturesSection: false,
+        hasBindingSourcesSection: false,
+        hasBlockStylesSection: false,
+        hasBlockTransformsSection: false,
+        hasEditorPluginsSection: false,
+        hasPatternsSection: false,
+        hasRestResourcesSection: false,
+        hasVariationsSection: false,
+        patterns: [],
+        restResources: [],
         source,
-        variations: variationArray.array ? parseVariationEntries(variationArray.array) : [],
+        variations: [],
     };
+    const mutableInventory = parsedInventory;
+    for (const section of INVENTORY_SECTIONS) {
+        if (!section.parse) {
+            continue;
+        }
+        const parsedSection = parseInventorySection(sourceFile, section);
+        mutableInventory[section.parse.entriesKey] = parsedSection.entries;
+        if (section.parse.hasSectionKey) {
+            mutableInventory[section.parse.hasSectionKey] = parsedSection.found;
+        }
+    }
+    return parsedInventory;
 }
 /**
  * Read and parse the canonical workspace inventory file.
@@ -704,6 +775,16 @@ function appendEntriesAtMarker(source, marker, entries) {
     }
     return source.replace(marker, `${entries.join("\n")}\n${marker}`);
 }
+function appendInventorySectionEntries(source, options) {
+    let nextSource = source;
+    for (const section of [BLOCK_INVENTORY_SECTION, ...INVENTORY_SECTIONS]) {
+        if (!section.append) {
+            continue;
+        }
+        nextSource = appendEntriesAtMarker(nextSource, section.append.marker, options[section.append.optionKey] ?? []);
+    }
+    return nextSource;
+}
 function ensureInterfaceField(source, interfaceName, fieldName, fieldSource) {
     const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
     return source.replace(interfacePattern, (match, start, body, end) => {
@@ -762,28 +843,18 @@ function normalizeInterfaceFieldBlock(source, interfaceName, fieldName, fieldSou
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export function updateWorkspaceInventorySource(source, { blockEntries = [], blockStyleEntries = [], blockTransformEntries = [], bindingSourceEntries = [], abilityEntries = [], adminViewEntries = [], aiFeatureEntries = [], editorPluginEntries = [], patternEntries = [], restResourceEntries = [], variationEntries = [], transformSource, } = {}) {
+export function updateWorkspaceInventorySource(source, options = {}) {
     let nextSource = ensureWorkspaceInventorySections(source);
-    if (transformSource) {
-        nextSource = transformSource(nextSource);
+    if (options.transformSource) {
+        nextSource = options.transformSource(nextSource);
     }
-    nextSource = appendEntriesAtMarker(nextSource, BLOCK_CONFIG_ENTRY_MARKER, blockEntries);
-    nextSource = appendEntriesAtMarker(nextSource, VARIATION_CONFIG_ENTRY_MARKER, variationEntries);
-    nextSource = appendEntriesAtMarker(nextSource, BLOCK_STYLE_CONFIG_ENTRY_MARKER, blockStyleEntries);
-    nextSource = appendEntriesAtMarker(nextSource, BLOCK_TRANSFORM_CONFIG_ENTRY_MARKER, blockTransformEntries);
-    nextSource = appendEntriesAtMarker(nextSource, PATTERN_CONFIG_ENTRY_MARKER, patternEntries);
-    nextSource = appendEntriesAtMarker(nextSource, BINDING_SOURCE_CONFIG_ENTRY_MARKER, bindingSourceEntries);
-    nextSource = appendEntriesAtMarker(nextSource, REST_RESOURCE_CONFIG_ENTRY_MARKER, restResourceEntries);
-    nextSource = appendEntriesAtMarker(nextSource, ABILITY_CONFIG_ENTRY_MARKER, abilityEntries);
-    nextSource = appendEntriesAtMarker(nextSource, AI_FEATURE_CONFIG_ENTRY_MARKER, aiFeatureEntries);
-    nextSource = appendEntriesAtMarker(nextSource, ADMIN_VIEW_CONFIG_ENTRY_MARKER, adminViewEntries);
+    nextSource = appendInventorySectionEntries(nextSource, options);
     nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "attribute", "\tattribute?: string;");
     nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "block", "\tblock?: string;");
     nextSource = ensureInterfaceField(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
     nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
     nextSource = ensureInterfaceField(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
     nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
-    nextSource = appendEntriesAtMarker(nextSource, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, editorPluginEntries);
     return nextSource;
 }
 /**