wp-typia 0.22.4 → 0.22.6

package/dist-bunli/{cli-qr2ek735.js → cli-5kn2p7ee.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   WORKSPACE_TEMPLATE_PACKAGE
-} from "./cli-btbpt84c.js";
+} from "./cli-hhp1d348.js";
 import {
   __commonJS,
   __require,
@@ -170911,45 +170911,7 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
   } });
 });
 
-// ../wp-typia-project-tools/src/runtime/string-case.ts
-function capitalizeSegment(segment) {
-  return segment.charAt(0).toUpperCase() + segment.slice(1);
-}
-function toKebabCase(input) {
-  return input.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").toLowerCase();
-}
-function toSnakeCase(input) {
-  return toKebabCase(input).replace(/-/g, "_");
-}
-function toPascalCase(input) {
-  return toKebabCase(input).split("-").filter(Boolean).map(capitalizeSegment).join("");
-}
-function toCamelCase(input) {
-  const pascalCase = toPascalCase(input);
-  return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
-}
-function toSegmentPascalCase(input) {
-  return input.replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).map(capitalizeSegment).join("");
-}
-function toTitleCase(input) {
-  return toKebabCase(input).split("-").filter(Boolean).map(capitalizeSegment).join(" ");
-}
-
 // ../wp-typia-project-tools/src/runtime/cli-add-types.ts
-var ADD_KIND_IDS = [
-  "admin-view",
-  "block",
-  "variation",
-  "style",
-  "transform",
-  "pattern",
-  "binding-source",
-  "rest-resource",
-  "ability",
-  "ai-feature",
-  "hooked-block",
-  "editor-plugin"
-];
 var REST_RESOURCE_METHOD_IDS = [
   "list",
   "read",
@@ -170983,6 +170945,76 @@ var HOOKED_BLOCK_POSITION_IDS = ["before", "after", "firstChild", "lastChild"];
 var HOOKED_BLOCK_POSITION_SET = new Set(HOOKED_BLOCK_POSITION_IDS);
 var HOOKED_BLOCK_ANCHOR_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/;
 
+// ../wp-typia-project-tools/src/runtime/string-case.ts
+var COMMON_ACRONYM_PREFIXES = [
+  "HTML",
+  "HTTP",
+  "JSON",
+  "REST",
+  "UUID",
+  "API",
+  "CSS",
+  "CTA",
+  "DOM",
+  "PHP",
+  "SQL",
+  "SVG",
+  "URL",
+  "XML",
+  "ID",
+  "JS",
+  "UI",
+  "WP"
+];
+function capitalizeSegment(segment) {
+  return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+function findCommonAcronymPrefix(segment) {
+  return COMMON_ACRONYM_PREFIXES.find((prefix) => segment.startsWith(prefix));
+}
+function splitKnownAcronymSegment(segment) {
+  const prefixes = [];
+  let remaining = segment;
+  while (remaining.length > 0) {
+    const prefix = findCommonAcronymPrefix(remaining);
+    if (!prefix) {
+      break;
+    }
+    const suffix = remaining.slice(prefix.length);
+    if (/^[A-Z][a-z]/.test(suffix)) {
+      return [...prefixes, prefix, suffix].join("-");
+    }
+    if (!findCommonAcronymPrefix(suffix)) {
+      break;
+    }
+    prefixes.push(prefix);
+    remaining = suffix;
+  }
+  return segment;
+}
+function splitAcronymBoundary(value) {
+  return value.replace(/[A-Z]{2,}[a-z]+/g, splitKnownAcronymSegment);
+}
+function toKebabCase(input) {
+  return splitAcronymBoundary(input.trim()).replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").toLowerCase();
+}
+function toSnakeCase(input) {
+  return toKebabCase(input).replace(/-/g, "_");
+}
+function toPascalCase(input) {
+  return toKebabCase(input).split("-").filter(Boolean).map(capitalizeSegment).join("");
+}
+function toCamelCase(input) {
+  const pascalCase = toPascalCase(input);
+  return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
+}
+function toSegmentPascalCase(input) {
+  return input.replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).map(capitalizeSegment).join("");
+}
+function toTitleCase(input) {
+  return toKebabCase(input).split("-").filter(Boolean).map(capitalizeSegment).join(" ");
+}
+
 // ../wp-typia-project-tools/src/runtime/cli-add-validation.ts
 var WORKSPACE_GENERATED_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
 var REST_RESOURCE_NAMESPACE_PATTERN = /^[a-z][a-z0-9-]*(?:\/[a-z0-9-]+)+$/u;
@@ -171053,60 +171085,6 @@ function assertValidEditorPluginSlot(slot = "sidebar") {
   throw new Error(`Editor plugin slot must be one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")}. Legacy aliases: PluginSidebar, PluginDocumentSettingPanel.`);
 }
 
-// ../wp-typia-project-tools/src/runtime/cli-add-filesystem.ts
-import { promises as fsp } from "fs";
-import path from "path";
-function getWorkspaceBootstrapPath(workspace) {
-  const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
-  return path.join(workspace.projectDir, `${workspaceBaseName}.php`);
-}
-async function patchFile(filePath, transform) {
-  const currentSource = await fsp.readFile(filePath, "utf8");
-  const nextSource = transform(currentSource);
-  if (nextSource !== currentSource) {
-    await fsp.writeFile(filePath, nextSource, "utf8");
-  }
-}
-async function readOptionalFile(filePath) {
-  try {
-    return await fsp.readFile(filePath, "utf8");
-  } catch (error) {
-    if (isFileNotFoundError(error)) {
-      return null;
-    }
-    throw error;
-  }
-}
-async function restoreOptionalFile(filePath, source) {
-  if (source === null) {
-    await fsp.rm(filePath, { force: true });
-    return;
-  }
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, source, "utf8");
-}
-async function snapshotWorkspaceFiles(filePaths) {
-  const uniquePaths = Array.from(new Set(filePaths));
-  return Promise.all(uniquePaths.map(async (filePath) => ({
-    filePath,
-    source: await readOptionalFile(filePath)
-  })));
-}
-async function rollbackWorkspaceMutation(snapshot) {
-  for (const targetPath of snapshot.targetPaths) {
-    await fsp.rm(targetPath, { force: true, recursive: true });
-  }
-  for (const snapshotDir of snapshot.snapshotDirs) {
-    await fsp.rm(snapshotDir, { force: true, recursive: true });
-  }
-  for (const { filePath, source } of snapshot.fileSources) {
-    await restoreOptionalFile(filePath, source);
-  }
-}
-function isFileNotFoundError(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-
 // ../wp-typia-project-tools/src/runtime/cli-add-help.ts
 function formatAddHelpText() {
   return `Usage:
@@ -171130,7 +171108,7 @@ Notes:
   \`add admin-view\` scaffolds an opt-in DataViews-powered WordPress admin screen under \`src/admin-views/\`.
   Pass \`--source rest-resource:<slug>\` to reuse a list-capable REST resource.
   Pass \`--source core-data:postType/post\` or \`--source core-data:taxonomy/category\` to bind a WordPress-owned entity collection.
-  Public installs currently gate this workflow until \`@wp-typia/dataviews\` is published to npm.
+  Generated admin-view workspaces add \`@wp-typia/dataviews\` and the needed WordPress DataViews packages as opt-in dependencies.
   \`query-loop\` is a create-time scaffold family. Use \`wp-typia create <project-dir> --template query-loop\` instead of \`wp-typia add block\`.
   \`add variation\` targets an existing block slug from \`scripts/block-config.ts\`.
   \`add style\` registers a Block Styles option for an existing generated block.
@@ -171221,6 +171199,59 @@ function resolveScaffoldIdentifiers({
     textDomain: resolveValidatedTextDomain(textDomain ?? normalizedSlug)
   };
 }
+// ../wp-typia-project-tools/src/runtime/cli-add-filesystem.ts
+import { promises as fsp } from "fs";
+import path from "path";
+function getWorkspaceBootstrapPath(workspace) {
+  const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
+  return path.join(workspace.projectDir, `${workspaceBaseName}.php`);
+}
+async function patchFile(filePath, transform) {
+  const currentSource = await fsp.readFile(filePath, "utf8");
+  const nextSource = transform(currentSource);
+  if (nextSource !== currentSource) {
+    await fsp.writeFile(filePath, nextSource, "utf8");
+  }
+}
+async function readOptionalFile(filePath) {
+  try {
+    return await fsp.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function restoreOptionalFile(filePath, source) {
+  if (source === null) {
+    await fsp.rm(filePath, { force: true });
+    return;
+  }
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  await fsp.writeFile(filePath, source, "utf8");
+}
+async function snapshotWorkspaceFiles(filePaths) {
+  const uniquePaths = Array.from(new Set(filePaths));
+  return Promise.all(uniquePaths.map(async (filePath) => ({
+    filePath,
+    source: await readOptionalFile(filePath)
+  })));
+}
+async function rollbackWorkspaceMutation(snapshot) {
+  for (const targetPath of snapshot.targetPaths) {
+    await fsp.rm(targetPath, { force: true, recursive: true });
+  }
+  for (const snapshotDir of snapshot.snapshotDirs) {
+    await fsp.rm(snapshotDir, { force: true, recursive: true });
+  }
+  for (const { filePath, source } of snapshot.fileSources) {
+    await restoreOptionalFile(filePath, source);
+  }
+}
+function isFileNotFoundError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
 // ../wp-typia-project-tools/src/runtime/cli-add-block-json.ts
 import fs from "fs";
 import path2 from "path";
@@ -171274,179 +171305,244 @@ function assertScaffoldDoesNotExist(options) {
     throw new Error(options.inventoryCollision.message);
   }
 }
-function assertVariationDoesNotExist(projectDir, blockSlug, variationSlug, inventory) {
+function assertAddKindScaffoldDoesNotExist(options) {
+  const inventoryCollision = options.descriptor.inventoryCollision;
   assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "A variation",
-        relativePath: path3.join("src", "blocks", blockSlug, "variations", `${variationSlug}.ts`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.variations,
-      exists: (entry) => entry.block === blockSlug && entry.slug === variationSlug,
-      message: `A variation inventory entry already exists for ${blockSlug}/${variationSlug}. Choose a different name.`
+    filesystemCollisions: options.descriptor.filesystemCollisions.map((collision) => ({
+      label: collision.label,
+      relativePath: collision.relativePath(options.context)
+    })),
+    inventoryCollision: inventoryCollision ? {
+      entries: inventoryCollision.entries(options.inventory),
+      exists: (entry) => inventoryCollision.exists(entry, options.context),
+      message: inventoryCollision.message(options.context)
+    } : undefined,
+    projectDir: options.projectDir
+  });
+}
+var VARIATION_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "A variation",
+      relativePath: ({ blockSlug, slug }) => path3.join("src", "blocks", blockSlug, "variations", `${slug}.ts`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.variations,
+    exists: (entry, { blockSlug, slug }) => entry.block === blockSlug && entry.slug === slug,
+    message: ({ blockSlug, slug }) => `A variation inventory entry already exists for ${blockSlug}/${slug}. Choose a different name.`
+  }
+};
+var BLOCK_STYLE_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "A block style",
+      relativePath: ({ blockSlug, slug }) => path3.join("src", "blocks", blockSlug, "styles", `${slug}.ts`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.blockStyles,
+    exists: (entry, { blockSlug, slug }) => entry.block === blockSlug && entry.slug === slug,
+    message: ({ blockSlug, slug }) => `A block style inventory entry already exists for ${blockSlug}/${slug}. Choose a different name.`
+  }
+};
+var BLOCK_TRANSFORM_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "A block transform",
+      relativePath: ({ blockSlug, slug }) => path3.join("src", "blocks", blockSlug, "transforms", `${slug}.ts`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.blockTransforms,
+    exists: (entry, { blockSlug, slug }) => entry.block === blockSlug && entry.slug === slug,
+    message: ({ blockSlug, slug }) => `A block transform inventory entry already exists for ${blockSlug}/${slug}. Choose a different name.`
+  }
+};
+var PATTERN_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "A pattern",
+      relativePath: ({ slug }) => path3.join("src", "patterns", `${slug}.php`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.patterns,
+    exists: (entry, { slug }) => entry.slug === slug,
+    message: ({ slug }) => `A pattern inventory entry already exists for ${slug}. Choose a different name.`
+  }
+};
+var BINDING_SOURCE_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "A binding source",
+      relativePath: ({ slug }) => path3.join("src", "bindings", slug)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.bindingSources,
+    exists: (entry, { slug }) => entry.slug === slug,
+    message: ({ slug }) => `A binding source inventory entry already exists for ${slug}. Choose a different name.`
+  }
+};
+var REST_RESOURCE_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "A REST resource",
+      relativePath: ({ slug }) => path3.join("src", "rest", slug)
+    },
+    {
+      label: "A REST resource bootstrap",
+      relativePath: ({ slug }) => path3.join("inc", "rest", `${slug}.php`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.restResources,
+    exists: (entry, { slug }) => entry.slug === slug,
+    message: ({ slug }) => `A REST resource inventory entry already exists for ${slug}. Choose a different name.`
+  }
+};
+var ADMIN_VIEW_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "An admin view",
+      relativePath: ({ slug }) => path3.join("src", "admin-views", slug)
+    },
+    {
+      label: "An admin view bootstrap",
+      relativePath: ({ slug }) => path3.join("inc", "admin-views", `${slug}.php`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.adminViews,
+    exists: (entry, { slug }) => entry.slug === slug,
+    message: ({ slug }) => `An admin view inventory entry already exists for ${slug}. Choose a different name.`
+  }
+};
+var ABILITY_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "An ability scaffold",
+      relativePath: ({ slug }) => path3.join("src", "abilities", slug)
+    },
+    {
+      label: "An ability bootstrap",
+      relativePath: ({ slug }) => path3.join("inc", "abilities", `${slug}.php`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.abilities,
+    exists: (entry, { slug }) => entry.slug === slug,
+    message: ({ slug }) => `An ability inventory entry already exists for ${slug}. Choose a different name.`
+  }
+};
+var AI_FEATURE_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "An AI feature",
+      relativePath: ({ slug }) => path3.join("src", "ai-features", slug)
     },
+    {
+      label: "An AI feature bootstrap",
+      relativePath: ({ slug }) => path3.join("inc", "ai-features", `${slug}.php`)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.aiFeatures,
+    exists: (entry, { slug }) => entry.slug === slug,
+    message: ({ slug }) => `An AI feature inventory entry already exists for ${slug}. Choose a different name.`
+  }
+};
+var EDITOR_PLUGIN_COLLISION_DESCRIPTOR = {
+  filesystemCollisions: [
+    {
+      label: "An editor plugin",
+      relativePath: ({ slug }) => path3.join("src", "editor-plugins", slug)
+    }
+  ],
+  inventoryCollision: {
+    entries: (inventory) => inventory.editorPlugins,
+    exists: (entry, { slug }) => entry.slug === slug,
+    message: ({ slug }) => `An editor plugin inventory entry already exists for ${slug}. Choose a different name.`
+  }
+};
+function assertVariationDoesNotExist(projectDir, blockSlug, variationSlug, inventory) {
+  assertAddKindScaffoldDoesNotExist({
+    context: { blockSlug, slug: variationSlug },
+    descriptor: VARIATION_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "A block style",
-        relativePath: path3.join("src", "blocks", blockSlug, "styles", `${styleSlug}.ts`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.blockStyles,
-      exists: (entry) => entry.block === blockSlug && entry.slug === styleSlug,
-      message: `A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { blockSlug, slug: styleSlug },
+    descriptor: BLOCK_STYLE_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "A block transform",
-        relativePath: path3.join("src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.blockTransforms,
-      exists: (entry) => entry.block === blockSlug && entry.slug === transformSlug,
-      message: `A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { blockSlug, slug: transformSlug },
+    descriptor: BLOCK_TRANSFORM_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertPatternDoesNotExist(projectDir, patternSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "A pattern",
-        relativePath: path3.join("src", "patterns", `${patternSlug}.php`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.patterns,
-      exists: (entry) => entry.slug === patternSlug,
-      message: `A pattern inventory entry already exists for ${patternSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { slug: patternSlug },
+    descriptor: PATTERN_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertBindingSourceDoesNotExist(projectDir, bindingSourceSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "A binding source",
-        relativePath: path3.join("src", "bindings", bindingSourceSlug)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.bindingSources,
-      exists: (entry) => entry.slug === bindingSourceSlug,
-      message: `A binding source inventory entry already exists for ${bindingSourceSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { slug: bindingSourceSlug },
+    descriptor: BINDING_SOURCE_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertRestResourceDoesNotExist(projectDir, restResourceSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "A REST resource",
-        relativePath: path3.join("src", "rest", restResourceSlug)
-      },
-      {
-        label: "A REST resource bootstrap",
-        relativePath: path3.join("inc", "rest", `${restResourceSlug}.php`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.restResources,
-      exists: (entry) => entry.slug === restResourceSlug,
-      message: `A REST resource inventory entry already exists for ${restResourceSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { slug: restResourceSlug },
+    descriptor: REST_RESOURCE_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertAdminViewDoesNotExist(projectDir, adminViewSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "An admin view",
-        relativePath: path3.join("src", "admin-views", adminViewSlug)
-      },
-      {
-        label: "An admin view bootstrap",
-        relativePath: path3.join("inc", "admin-views", `${adminViewSlug}.php`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.adminViews,
-      exists: (entry) => entry.slug === adminViewSlug,
-      message: `An admin view inventory entry already exists for ${adminViewSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { slug: adminViewSlug },
+    descriptor: ADMIN_VIEW_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertAbilityDoesNotExist(projectDir, abilitySlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "An ability scaffold",
-        relativePath: path3.join("src", "abilities", abilitySlug)
-      },
-      {
-        label: "An ability bootstrap",
-        relativePath: path3.join("inc", "abilities", `${abilitySlug}.php`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.abilities,
-      exists: (entry) => entry.slug === abilitySlug,
-      message: `An ability inventory entry already exists for ${abilitySlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { slug: abilitySlug },
+    descriptor: ABILITY_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertAiFeatureDoesNotExist(projectDir, aiFeatureSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "An AI feature",
-        relativePath: path3.join("src", "ai-features", aiFeatureSlug)
-      },
-      {
-        label: "An AI feature bootstrap",
-        relativePath: path3.join("inc", "ai-features", `${aiFeatureSlug}.php`)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.aiFeatures,
-      exists: (entry) => entry.slug === aiFeatureSlug,
-      message: `An AI feature inventory entry already exists for ${aiFeatureSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { slug: aiFeatureSlug },
+    descriptor: AI_FEATURE_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
 function assertEditorPluginDoesNotExist(projectDir, editorPluginSlug, inventory) {
-  assertScaffoldDoesNotExist({
-    filesystemCollisions: [
-      {
-        label: "An editor plugin",
-        relativePath: path3.join("src", "editor-plugins", editorPluginSlug)
-      }
-    ],
-    inventoryCollision: {
-      entries: inventory.editorPlugins,
-      exists: (entry) => entry.slug === editorPluginSlug,
-      message: `An editor plugin inventory entry already exists for ${editorPluginSlug}. Choose a different name.`
-    },
+  assertAddKindScaffoldDoesNotExist({
+    context: { slug: editorPluginSlug },
+    descriptor: EDITOR_PLUGIN_COLLISION_DESCRIPTOR,
+    inventory,
     projectDir
   });
 }
@@ -171466,6 +171562,229 @@ function quotePhpString(value) {
 function hasPhpFunctionDefinition(source, functionName) {
   return new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\(`, "u").test(source);
 }
+function isPhpIdentifierStart(character) {
+  return /^[A-Za-z_]$/u.test(character ?? "");
+}
+function isPhpIdentifierPart(character) {
+  return /^[A-Za-z0-9_]$/u.test(character ?? "");
+}
+function isPhpLineStart(source, index) {
+  return index === 0 || source[index - 1] === `
+`;
+}
+function isPhpHorizontalWhitespace(character) {
+  return character === " " || character === "\t";
+}
+function isPhpWhitespace(character) {
+  return typeof character === "string" && /\s/u.test(character);
+}
+function findPhpLineBoundary(source, index) {
+  const newlineIndex = source.indexOf(`
+`, index);
+  if (newlineIndex === -1) {
+    return {
+      contentEnd: source.endsWith("\r") ? source.length - 1 : source.length,
+      nextStart: source.length
+    };
+  }
+  return {
+    contentEnd: source[newlineIndex - 1] === "\r" ? newlineIndex - 1 : newlineIndex,
+    nextStart: newlineIndex + 1
+  };
+}
+function parsePhpHeredocStart(source, index) {
+  if (!source.startsWith("<<<", index)) {
+    return null;
+  }
+  let cursor = index + 3;
+  while (isPhpHorizontalWhitespace(source[cursor])) {
+    cursor += 1;
+  }
+  const quote = source[cursor] === "'" || source[cursor] === '"' ? source[cursor] : "";
+  if (quote) {
+    cursor += 1;
+  }
+  if (!isPhpIdentifierStart(source[cursor])) {
+    return null;
+  }
+  const delimiterStart = cursor;
+  cursor += 1;
+  while (isPhpIdentifierPart(source[cursor])) {
+    cursor += 1;
+  }
+  const delimiter = source.slice(delimiterStart, cursor);
+  if (quote) {
+    if (source[cursor] !== quote) {
+      return null;
+    }
+    cursor += 1;
+  }
+  const lineBoundary = findPhpLineBoundary(source, cursor);
+  if (source.slice(cursor, lineBoundary.contentEnd).trim() !== "") {
+    return null;
+  }
+  return {
+    contentStart: lineBoundary.nextStart,
+    delimiter
+  };
+}
+function findPhpHeredocClosingEnd(source, index, delimiter) {
+  if (!isPhpLineStart(source, index)) {
+    return null;
+  }
+  let cursor = index;
+  while (isPhpHorizontalWhitespace(source[cursor])) {
+    cursor += 1;
+  }
+  if (!source.startsWith(delimiter, cursor)) {
+    return null;
+  }
+  cursor += delimiter.length;
+  if (isPhpIdentifierPart(source[cursor])) {
+    return null;
+  }
+  let continuationCursor = cursor;
+  while (isPhpHorizontalWhitespace(source[continuationCursor])) {
+    continuationCursor += 1;
+  }
+  const continuation = source[continuationCursor];
+  if (continuationCursor >= source.length || continuation === "\r" || continuation === `
+` || !isPhpIdentifierPart(continuation)) {
+    return cursor;
+  }
+  return null;
+}
+function skipPhpCallTrivia(source, index) {
+  let cursor = index;
+  while (cursor < source.length) {
+    while (isPhpWhitespace(source[cursor])) {
+      cursor += 1;
+    }
+    if (source[cursor] === "/" && source[cursor + 1] === "*") {
+      const commentEnd = source.indexOf("*/", cursor + 2);
+      if (commentEnd === -1) {
+        return null;
+      }
+      cursor = commentEnd + 2;
+      continue;
+    }
+    if (source[cursor] === "/" && source[cursor + 1] === "/") {
+      cursor = findPhpLineBoundary(source, cursor + 2).nextStart;
+      continue;
+    }
+    if (source[cursor] === "#" && source[cursor + 1] !== "[") {
+      cursor = findPhpLineBoundary(source, cursor + 1).nextStart;
+      continue;
+    }
+    return cursor;
+  }
+  return cursor;
+}
+function matchesPhpFunctionCallAt(source, index, functionName) {
+  if (!source.startsWith(functionName, index)) {
+    return false;
+  }
+  if (isPhpIdentifierPart(source[index - 1])) {
+    return false;
+  }
+  const cursor = index + functionName.length;
+  if (isPhpIdentifierPart(source[cursor])) {
+    return false;
+  }
+  const callStart = skipPhpCallTrivia(source, cursor);
+  return callStart !== null && source[callStart] === "(";
+}
+function hasPhpFunctionCall(source, functionName) {
+  let mode = "code";
+  let heredocDelimiter = "";
+  let index = 0;
+  while (index < source.length) {
+    const character = source[index];
+    if (mode === "heredoc") {
+      const closingEnd = findPhpHeredocClosingEnd(source, index, heredocDelimiter);
+      if (closingEnd !== null) {
+        mode = "code";
+        heredocDelimiter = "";
+        index = closingEnd;
+        continue;
+      }
+      const nextLineStart = findPhpLineBoundary(source, index).nextStart;
+      if (nextLineStart <= index) {
+        return false;
+      }
+      index = nextLineStart;
+      continue;
+    }
+    if (mode === "single-quoted" || mode === "double-quoted") {
+      const quote = mode === "single-quoted" ? "'" : '"';
+      if (character === "\\") {
+        index += 2;
+        continue;
+      }
+      if (character === quote) {
+        mode = "code";
+      }
+      index += 1;
+      continue;
+    }
+    if (mode === "line-comment") {
+      if (character === "\r" || character === `
+`) {
+        mode = "code";
+      }
+      index += 1;
+      continue;
+    }
+    if (mode === "block-comment") {
+      if (character === "*" && source[index + 1] === "/") {
+        mode = "code";
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    if (character === "'") {
+      mode = "single-quoted";
+      index += 1;
+      continue;
+    }
+    if (character === '"') {
+      mode = "double-quoted";
+      index += 1;
+      continue;
+    }
+    if (character === "/" && source[index + 1] === "/") {
+      mode = "line-comment";
+      index += 2;
+      continue;
+    }
+    if (character === "#" && source[index + 1] !== "[") {
+      mode = "line-comment";
+      index += 1;
+      continue;
+    }
+    if (character === "/" && source[index + 1] === "*") {
+      mode = "block-comment";
+      index += 2;
+      continue;
+    }
+    if (character === "<") {
+      const heredocStart = parsePhpHeredocStart(source, index);
+      if (heredocStart) {
+        mode = "heredoc";
+        heredocDelimiter = heredocStart.delimiter;
+        index = heredocStart.contentStart;
+        continue;
+      }
+    }
+    if (matchesPhpFunctionCallAt(source, index, functionName)) {
+      return true;
+    }
+    index += 1;
+  }
+  return false;
+}
 function findPhpFunctionRange(source, functionName, options = {}) {
   const signaturePattern = new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\([^)]*\\)\\s*(?::\\s*[^{};]+)?\\s*\\{`, "u");
   const signatureMatch = signaturePattern.exec(source);
@@ -171479,13 +171798,96 @@ function findPhpFunctionRange(source, functionName, options = {}) {
   }
   const openBraceIndex = functionStart + openBraceOffset;
   let depth = 0;
-  for (let index = openBraceIndex;index < source.length; index += 1) {
+  let mode = "code";
+  let heredocDelimiter = "";
+  let index = openBraceIndex;
+  while (index < source.length) {
     const character = source[index];
+    if (mode === "heredoc") {
+      const closingEnd = findPhpHeredocClosingEnd(source, index, heredocDelimiter);
+      if (closingEnd !== null) {
+        mode = "code";
+        heredocDelimiter = "";
+        index = closingEnd;
+        continue;
+      }
+      const nextLineStart = findPhpLineBoundary(source, index).nextStart;
+      if (nextLineStart <= index) {
+        return null;
+      }
+      index = nextLineStart;
+      continue;
+    }
+    if (mode === "single-quoted" || mode === "double-quoted") {
+      const quote = mode === "single-quoted" ? "'" : '"';
+      if (character === "\\") {
+        index += 2;
+        continue;
+      }
+      if (character === quote) {
+        mode = "code";
+      }
+      index += 1;
+      continue;
+    }
+    if (mode === "line-comment") {
+      if (character === "\r" || character === `
+`) {
+        mode = "code";
+      }
+      index += 1;
+      continue;
+    }
+    if (mode === "block-comment") {
+      if (character === "*" && source[index + 1] === "/") {
+        mode = "code";
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    if (character === "'") {
+      mode = "single-quoted";
+      index += 1;
+      continue;
+    }
+    if (character === '"') {
+      mode = "double-quoted";
+      index += 1;
+      continue;
+    }
+    if (character === "/" && source[index + 1] === "/") {
+      mode = "line-comment";
+      index += 2;
+      continue;
+    }
+    if (character === "#" && source[index + 1] !== "[") {
+      mode = "line-comment";
+      index += 1;
+      continue;
+    }
+    if (character === "/" && source[index + 1] === "*") {
+      mode = "block-comment";
+      index += 2;
+      continue;
+    }
+    if (character === "<") {
+      const heredocStart = parsePhpHeredocStart(source, index);
+      if (heredocStart) {
+        mode = "heredoc";
+        heredocDelimiter = heredocStart.delimiter;
+        index = heredocStart.contentStart;
+        continue;
+      }
+    }
     if (character === "{") {
       depth += 1;
+      index += 1;
       continue;
     }
     if (character !== "}") {
+      index += 1;
       continue;
     }
     depth -= 1;
@@ -171502,6 +171904,7 @@ function findPhpFunctionRange(source, functionName, options = {}) {
         start: functionStart
       };
     }
+    index += 1;
   }
   return null;
 }
@@ -171518,6 +171921,9 @@ function replacePhpFunctionDefinition(source, functionName, replacement, options
 }
 
 // ../wp-typia-project-tools/src/runtime/workspace-inventory.ts
+function defineInventoryEntryParser(descriptor) {
+  return descriptor;
+}
 var BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 var VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 var BLOCK_STYLE_CONFIG_ENTRY_MARKER = "\t// wp-typia add style entries";
@@ -171713,102 +172119,319 @@ export const EDITOR_PLUGINS: WorkspaceEditorPluginConfig[] = [
 	// wp-typia add editor-plugin entries
 ];
 `;
+var 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
+  }
+};
 var 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
@@ -171894,240 +172517,95 @@ 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 (!import_typescript.default.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 (!import_typescript.default.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 (!import_typescript.default.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 (!import_typescript.default.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 (!import_typescript.default.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) {
-  return arrayLiteral.elements.map((element, elementIndex) => {
-    if (!import_typescript.default.isObjectLiteralExpression(element)) {
-      throw new Error(`BINDING_SOURCES[${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) {
+function parseInventoryEntries(arrayLiteral, descriptor) {
   return arrayLiteral.elements.map((element, elementIndex) => {
     if (!import_typescript.default.isObjectLiteralExpression(element)) {
-      throw new Error(`REST_RESOURCES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-    }
-    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")
-    };
-  });
-}
-function parseAiFeatureEntries(arrayLiteral) {
-  return arrayLiteral.elements.map((element, elementIndex) => {
-    if (!import_typescript.default.isObjectLiteralExpression(element)) {
-      throw new Error(`AI_FEATURES[${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.`);
+    }
+    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;
     }
-    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")
-    };
+    return entry;
   });
 }
-function parseAbilityEntries(arrayLiteral) {
-  return arrayLiteral.elements.map((element, elementIndex) => {
-    if (!import_typescript.default.isObjectLiteralExpression(element)) {
-      throw new Error(`ABILITIES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
-    }
+function parseInventorySection(sourceFile, descriptor) {
+  if (!descriptor.parse) {
     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")
+      entries: [],
+      found: false
     };
-  });
-}
-function parseEditorPluginEntries(arrayLiteral) {
-  return arrayLiteral.elements.map((element, elementIndex) => {
-    if (!import_typescript.default.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 (!import_typescript.default.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
+  };
 }
 function parseWorkspaceInventorySource(source) {
   const sourceFile = import_typescript.default.createSourceFile("block-config.ts", source, import_typescript.default.ScriptTarget.Latest, true, import_typescript.default.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;
 }
 function readWorkspaceInventory(projectDir) {
   const blockConfigPath = path4.join(projectDir, "scripts", "block-config.ts");
@@ -172182,6 +172660,16 @@ function appendEntriesAtMarker(source, marker, entries) {
 `)}
 ${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) => {
@@ -172229,41 +172717,18 @@ function normalizeInterfaceFieldBlock(source, interfaceName, fieldName, fieldSou
     return `${start}${body.slice(0, fieldMatch.index)}${formattedFieldSource}${body.slice(fieldMatch.index + existingFieldSource.length)}${end}`;
   });
 }
-function updateWorkspaceInventorySource(source, {
-  blockEntries = [],
-  blockStyleEntries = [],
-  blockTransformEntries = [],
-  bindingSourceEntries = [],
-  abilityEntries = [],
-  adminViewEntries = [],
-  aiFeatureEntries = [],
-  editorPluginEntries = [],
-  patternEntries = [],
-  restResourceEntries = [],
-  variationEntries = [],
-  transformSource
-} = {}) {
+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;
 }
 async function appendWorkspaceInventoryEntries(projectDir, options) {
@@ -172275,6 +172740,6 @@ async function appendWorkspaceInventoryEntries(projectDir, options) {
   }
 }
 
-export { toKebabCase, toSnakeCase, toPascalCase, toCamelCase, toSegmentPascalCase, toTitleCase, validateBlockSlug, validateNamespace, normalizeBlockSlug, resolveNonEmptyNormalizedBlockSlug, buildBlockCssClassName, buildFrontendCssClassName, resolveScaffoldIdentifiers, ADD_KIND_IDS, REST_RESOURCE_METHOD_IDS, EDITOR_PLUGIN_SLOT_IDS, resolveEditorPluginSlotAlias, ADD_BLOCK_TEMPLATE_IDS, HOOKED_BLOCK_POSITION_SET, HOOKED_BLOCK_ANCHOR_PATTERN, REST_RESOURCE_NAMESPACE_PATTERN, assertValidGeneratedSlug, resolveRestResourceNamespace, assertValidRestResourceMethods, assertValidHookedBlockPosition, buildWorkspacePhpPrefix, isAddBlockTemplateId, quoteTsString, assertValidHookAnchor, assertValidEditorPluginSlot, getWorkspaceBootstrapPath, patchFile, readOptionalFile, snapshotWorkspaceFiles, rollbackWorkspaceMutation, resolveWorkspaceBlock, readWorkspaceBlockJson, getMutableBlockHooks, assertVariationDoesNotExist, assertBlockStyleDoesNotExist, assertBlockTransformDoesNotExist, assertPatternDoesNotExist, assertBindingSourceDoesNotExist, assertRestResourceDoesNotExist, assertAdminViewDoesNotExist, assertAbilityDoesNotExist, assertAiFeatureDoesNotExist, assertEditorPluginDoesNotExist, formatAddHelpText, require_typescript, escapeRegex, quotePhpString, hasPhpFunctionDefinition, findPhpFunctionRange, replacePhpFunctionDefinition, readWorkspaceInventory, getWorkspaceBlockSelectOptions, updateWorkspaceInventorySource, appendWorkspaceInventoryEntries };
+export { toKebabCase, toSnakeCase, toPascalCase, toCamelCase, toSegmentPascalCase, toTitleCase, validateBlockSlug, validateNamespace, normalizeBlockSlug, resolveNonEmptyNormalizedBlockSlug, buildBlockCssClassName, buildFrontendCssClassName, resolveScaffoldIdentifiers, REST_RESOURCE_METHOD_IDS, EDITOR_PLUGIN_SLOT_IDS, resolveEditorPluginSlotAlias, ADD_BLOCK_TEMPLATE_IDS, HOOKED_BLOCK_POSITION_SET, HOOKED_BLOCK_ANCHOR_PATTERN, REST_RESOURCE_NAMESPACE_PATTERN, assertValidGeneratedSlug, resolveRestResourceNamespace, assertValidRestResourceMethods, assertValidHookedBlockPosition, buildWorkspacePhpPrefix, isAddBlockTemplateId, quoteTsString, assertValidHookAnchor, assertValidEditorPluginSlot, getWorkspaceBootstrapPath, patchFile, readOptionalFile, snapshotWorkspaceFiles, rollbackWorkspaceMutation, resolveWorkspaceBlock, readWorkspaceBlockJson, getMutableBlockHooks, assertVariationDoesNotExist, assertBlockStyleDoesNotExist, assertBlockTransformDoesNotExist, assertPatternDoesNotExist, assertBindingSourceDoesNotExist, assertRestResourceDoesNotExist, assertAdminViewDoesNotExist, assertAbilityDoesNotExist, assertAiFeatureDoesNotExist, assertEditorPluginDoesNotExist, formatAddHelpText, require_typescript, escapeRegex, quotePhpString, hasPhpFunctionDefinition, hasPhpFunctionCall, findPhpFunctionRange, replacePhpFunctionDefinition, readWorkspaceInventory, getWorkspaceBlockSelectOptions, updateWorkspaceInventorySource, appendWorkspaceInventoryEntries };
 
-//# debugId=42C4B300381ECACF64756E2164756E21
+//# debugId=17AFFAD165D90DE964756E2164756E21