wp-typia 0.21.0 → 0.22.1

package/dist-bunli/.bunli/commands.gen.js

@@ -36061,6 +36061,10 @@ function toSnakeCase(input) {
 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("");
 }
@@ -36394,7 +36398,7 @@ function assertEditorPluginDoesNotExist(projectDir, editorPluginSlug, inventory)
 }
 function formatAddHelpText() {
   return `Usage:
-  wp-typia add admin-view <name> [--source <rest-resource:slug>] [--dry-run]
+  wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]
   wp-typia add block <name> [--template <${ADD_BLOCK_TEMPLATE_IDS.join("|")}>] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--inner-blocks-preset <freeform|ordered|horizontal|locked-structure>] [--alternate-render-targets <email,mjml,plain-text>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--dry-run]
   wp-typia add variation <name> --block <block-slug> [--dry-run]
   wp-typia add style <name> --block <block-slug> [--dry-run]
@@ -36411,7 +36415,10 @@ Notes:
   \`wp-typia add\` runs only inside official ${WORKSPACE_TEMPLATE_PACKAGE} workspaces scaffolded via \`wp-typia create <project-dir> --template workspace\`.
   Pass \`--dry-run\` to preview the workspace files that would change without writing them.
   Interactive add flows let you choose a template when \`--template\` is omitted; non-interactive runs default to \`basic\`.
-  \`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.
+  \`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.
   \`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.
@@ -213268,6 +213275,16 @@ function readPackageManifest(location) {
   }
   return JSON.parse(location.source);
 }
+function tryReadPackageManifest(location) {
+  if (!location) {
+    return null;
+  }
+  try {
+    return readPackageManifest(location);
+  } catch {
+    return null;
+  }
+}
 function resolveInstalledPackageManifestLocation(packageName) {
   try {
     return resolvePackageManifestLocation(require2.resolve(`${packageName}/package.json`));
@@ -213285,6 +213302,13 @@ function resolveInstalledPackageManifestLocation(packageName) {
 function composePackageVersionsCacheKey(locations) {
   return locations.map((location) => location.cacheKey).join("|");
 }
+function resolveManagedPackageVersionRange(options) {
+  const workspaceManifestLocation = options.workspacePackageDirName ? resolvePackageManifestLocation(path31.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", options.workspacePackageDirName, "package.json")) : null;
+  const installedManifestLocation = resolveInstalledPackageManifestLocation(options.packageName);
+  const workspaceManifest = tryReadPackageManifest(workspaceManifestLocation);
+  const installedManifest = tryReadPackageManifest(installedManifestLocation);
+  return normalizeVersionRangeWithFallback(workspaceManifest?.version ?? installedManifest?.version, options.fallback);
+}
 function getPackageVersions() {
   const createManifestLocation = resolvePackageManifestLocation(path31.join(PROJECT_TOOLS_PACKAGE_ROOT, "package.json"));
   const monorepoManifestLocation = resolvePackageManifestLocation(path31.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", "..", "package.json"));
@@ -213343,7 +213367,7 @@ function getPackageVersions() {
   };
   return versions2;
 }
-var require2, DEFAULT_VERSION_RANGE = "^0.0.0", DEFAULT_EXACT_VERSION = "0.0.0", DEFAULT_TSX_PACKAGE_VERSION = "^4.20.5", DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = "^12.0.1", cachedPackageVersions = null;
+var require2, DEFAULT_VERSION_RANGE = "^0.0.0", DEFAULT_EXACT_VERSION = "0.0.0", DEFAULT_TSX_PACKAGE_VERSION = "^4.20.5", DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = "^12.0.1", DEFAULT_WORDPRESS_ABILITIES_VERSION = "^0.10.0", DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = "^0.9.0", DEFAULT_WORDPRESS_CORE_DATA_VERSION = "^7.44.0", DEFAULT_WORDPRESS_DATA_VERSION = "^9.28.0", DEFAULT_WORDPRESS_DATAVIEWS_VERSION = "^14.1.0", DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = "^0.1.0", cachedPackageVersions = null;
 var init_package_versions = __esm(() => {
   init_template_registry();
   require2 = createRequire(import.meta.url);
@@ -214611,6 +214635,17 @@ function buildInteractivityTypesSource(variables, attributes) {
           { name: "maxClicks", typeExpression: "number" }
         ],
         name: `${variables.pascalCase}Context`
+      },
+      {
+        members: [
+          { name: "clicks", typeExpression: "number" },
+          { name: "isAnimating", typeExpression: "boolean" },
+          { name: "isVisible", typeExpression: "boolean" },
+          { name: "progress", typeExpression: "number" },
+          { name: "clampedClicks", typeExpression: "number" },
+          { name: "isComplete", typeExpression: "boolean" }
+        ],
+        name: `${variables.pascalCase}State`
       }
     ],
     typeAliases: [
@@ -224413,10 +224448,10 @@ var init_compound_inner_blocks = __esm(() => {
   };
 });
 
-// ../wp-typia-project-tools/src/runtime/ai-feature-capability.ts
+// ../wp-typia-project-tools/src/runtime/version-floor.ts
 function parseVersionFloorParts(value2) {
   return value2.split(".").map((part, index) => {
-    if (!/^\d+$/.test(part)) {
+    if (!/^\d+$/u.test(part)) {
       throw new Error(`parseVersionFloorParts received an invalid version floor "${value2}" at segment ${index + 1}.`);
     }
     return Number.parseInt(part, 10);
@@ -224447,6 +224482,8 @@ function pickHigherVersionFloor(current, candidate) {
   }
   return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
 }
+
+// ../wp-typia-project-tools/src/runtime/ai-feature-capability.ts
 function normalizeSelections(selections) {
   const normalized = new Map;
   for (const selection of selections) {
@@ -224556,35 +224593,8 @@ var init_ai_feature_capability = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/scaffold-compatibility.ts
-function parseVersionFloorParts2(value2) {
-  return value2.split(".").map((part, index) => {
-    if (!/^\d+$/u.test(part)) {
-      throw new Error(`parseVersionFloorParts received an invalid version floor "${value2}" at segment ${index + 1}.`);
-    }
-    return Number.parseInt(part, 10);
-  });
-}
-function compareVersionFloors2(left, right) {
-  const leftParts = parseVersionFloorParts2(left);
-  const rightParts = parseVersionFloorParts2(right);
-  const length = Math.max(leftParts.length, rightParts.length);
-  for (let index = 0;index < length; index += 1) {
-    const leftValue = leftParts[index] ?? 0;
-    const rightValue = rightParts[index] ?? 0;
-    if (leftValue > rightValue) {
-      return 1;
-    }
-    if (leftValue < rightValue) {
-      return -1;
-    }
-  }
-  return 0;
-}
-function pickHigherVersionFloor2(current, candidate) {
-  if (!candidate) {
-    return current;
-  }
-  return compareVersionFloors2(current, candidate) >= 0 ? current : candidate;
+function pickHigherScaffoldVersionFloor(current, candidate) {
+  return pickHigherVersionFloor(current, candidate) ?? current;
 }
 function pickHigherHeaderVersionFloor(policyValue, currentValue) {
   const normalizedCurrentValue = currentValue.trim();
@@ -224592,7 +224602,7 @@ function pickHigherHeaderVersionFloor(policyValue, currentValue) {
     return policyValue;
   }
   try {
-    return pickHigherVersionFloor2(policyValue, normalizedCurrentValue);
+    return pickHigherScaffoldVersionFloor(policyValue, normalizedCurrentValue);
   } catch {
     return policyValue;
   }
@@ -224613,9 +224623,9 @@ function resolveScaffoldCompatibilityPolicy(selections, {
   baseline = DEFAULT_SCAFFOLD_COMPATIBILITY
 } = {}) {
   const capabilityPlan = resolveAiFeatureCapabilityPlan(selections);
-  const requiresAtLeast = pickHigherVersionFloor2(baseline.requiresAtLeast, capabilityPlan.hardMinimums.wordpress);
-  const requiresPhp = pickHigherVersionFloor2(baseline.requiresPhp, capabilityPlan.hardMinimums.php);
-  const testedUpTo = pickHigherVersionFloor2(baseline.testedUpTo, requiresAtLeast);
+  const requiresAtLeast = pickHigherScaffoldVersionFloor(baseline.requiresAtLeast, capabilityPlan.hardMinimums.wordpress);
+  const requiresPhp = pickHigherScaffoldVersionFloor(baseline.requiresPhp, capabilityPlan.hardMinimums.php);
+  const testedUpTo = pickHigherScaffoldVersionFloor(baseline.testedUpTo, requiresAtLeast);
   return {
     capabilityPlan,
     pluginHeader: {
@@ -226451,6 +226461,7 @@ import { useBlockProps, InspectorControls, RichText, BlockControls, AlignmentToo
 import { PanelBody, RangeControl, Button, Notice } from '@wordpress/components';
 import { useState } from '@wordpress/element';
 import currentManifest from './manifest-document';
+import { {{slugCamelCase}}Store } from './interactivity-store';
 import {
   InspectorFromManifest,
   useEditorFields,
@@ -226531,17 +226542,22 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
 
   const blockProps = useBlockProps({
     className: \`{{cssClassName}} {{cssClassName}}--\${interactiveMode}\`,
-    'data-wp-interactive': '{{slugKebabCase}}',
-    'data-wp-context': JSON.stringify({
-      clicks: clickCount,
-      isAnimating,
-      isVisible,
-      animation,
-      maxClicks,
-    })
+    'data-wp-interactive': {{slugCamelCase}}Store.directive.interactive,
+    'data-wp-context': JSON.stringify(
+      {{slugCamelCase}}Store.createContext({
+        clicks: clickCount,
+        isAnimating,
+        isVisible,
+        animation,
+        maxClicks,
+      })
+    )
   });
   const previewContentStyle = { textAlign: alignmentValue };
   const progressBarStyle = { width: \`\${(clickCount / maxClicks) * 100}%\` };
+  const clicksDirective = {{slugCamelCase}}Store.directive.state('clicks');
+  const isAnimatingDirective = {{slugCamelCase}}Store.directive.state('isAnimating');
+  const progressDirective = {{slugCamelCase}}Store.directive.state('progress') + " + '%'";
 
   const resetCounter = () => {
     updateField('clickCount', 0);
@@ -226638,9 +226654,9 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
         <div
           className={\`{{cssClassName}}__content \${isAnimating ? 'is-animating' : ''}\`}
           style={previewContentStyle}
-          data-wp-on--click={isPreviewing ? 'actions.handleClick' : undefined}
-          data-wp-on--mouseenter={isPreviewing && interactiveMode === 'hover' ? 'actions.handleMouseEnter' : undefined}
-          data-wp-on--mouseleave={isPreviewing && interactiveMode === 'hover' ? 'actions.handleMouseLeave' : undefined}
+          data-wp-on--click={isPreviewing ? {{slugCamelCase}}Store.directive.action('handleClick') : undefined}
+          data-wp-on--mouseenter={isPreviewing && interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseEnter') : undefined}
+          data-wp-on--mouseleave={isPreviewing && interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseLeave') : undefined}
         >
           <RichText
             tagName="p"
@@ -226669,7 +226685,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
               </span>
               <span
                 className="{{cssClassName}}__counter-value"
-                data-wp-text="state.clicks"
+                data-wp-text={clicksDirective}
               >
                 {clickCount}
               </span>
@@ -226681,7 +226697,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
               <div
                 className="{{cssClassName}}__progress-bar"
                 style={progressBarStyle}
-                data-wp-style--width="state.progress + '%'"
+                data-wp-style--width={progressDirective}
               />
             </div>
           )}
@@ -226689,7 +226705,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
           {animation !== 'none' && (
             <div
               className={\`{{cssClassName}}__animation \${isAnimating ? 'is-active' : ''}\`}
-              data-wp-class--is-active="state.isAnimating"
+              data-wp-class--is-active={isAnimatingDirective}
             >
               {animation}
             </div>
@@ -226701,6 +226717,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
 }
 `, INTERACTIVITY_SAVE_TEMPLATE = `import { useBlockProps, RichText } from '@wordpress/block-editor';
 import { __ } from '@wordpress/i18n';
+import { {{slugCamelCase}}Store } from './interactivity-store';
 import type { {{pascalCase}}Attributes } from './types';
 
 export default function Save({ attributes }: { attributes: {{pascalCase}}Attributes }) {
@@ -226712,27 +226729,41 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
   const maxClicks = attributes.maxClicks ?? 0;
   const showCounter = attributes.showCounter ?? true;
   const contentStyle = { textAlign: attributes.alignment };
+  const clickActionDirective = {{slugCamelCase}}Store.directive.action('handleClick');
+  const visibilityHiddenDirective = {{slugCamelCase}}Store.directive.negate(
+    {{slugCamelCase}}Store.directive.state('isVisible')
+  );
+  const clicksDirective = {{slugCamelCase}}Store.directive.state('clicks');
+  const clampedClicksDirective = {{slugCamelCase}}Store.directive.state('clampedClicks');
+  const isAnimatingDirective = {{slugCamelCase}}Store.directive.state('isAnimating');
+  const completionHiddenDirective = {{slugCamelCase}}Store.directive.negate(
+    {{slugCamelCase}}Store.directive.state('isComplete')
+  );
+  const resetActionDirective = {{slugCamelCase}}Store.directive.action('reset');
   const blockProps = useBlockProps.save({
     className: \`{{cssClassName}} {{cssClassName}}--\${interactiveMode}\`,
-    'data-wp-interactive': '{{slugKebabCase}}',
-    'data-wp-context': JSON.stringify({
-      clicks: clickCount,
-      isAnimating,
-      isVisible,
-      animation,
-      maxClicks,
-    })
+    'data-wp-interactive': {{slugCamelCase}}Store.directive.interactive,
+    'data-wp-context': JSON.stringify(
+      {{slugCamelCase}}Store.createContext({
+        clicks: clickCount,
+        isAnimating,
+        isVisible,
+        animation,
+        maxClicks,
+      })
+    )
   });
+  const progressDirective = {{slugCamelCase}}Store.directive.state('progress') + " + '%'";
 
   return (
     <div {...blockProps}>
       <div
         className={\`{{cssClassName}}__content \${isAnimating ? 'is-animating' : ''}\`}
         style={contentStyle}
-        data-wp-on--click="actions.handleClick"
-        data-wp-on--mouseenter={interactiveMode === 'hover' ? 'actions.handleMouseEnter' : undefined}
-        data-wp-on--mouseleave={interactiveMode === 'hover' ? 'actions.handleMouseLeave' : undefined}
-        data-wp-bind--hidden="!state.isVisible"
+        data-wp-on--click={clickActionDirective}
+        data-wp-on--mouseenter={interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseEnter') : undefined}
+        data-wp-on--mouseleave={interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseLeave') : undefined}
+        data-wp-bind--hidden={visibilityHiddenDirective}
       >
         <RichText.Content
           tagName="p"
@@ -226752,7 +226783,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
             </span>
             <span
               className="{{cssClassName}}__counter-value"
-              data-wp-text="state.clicks"
+              data-wp-text={clicksDirective}
             >
               {clickCount}
             </span>
@@ -226768,8 +226799,8 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
               aria-valuemin={0}
               aria-valuemax={maxClicks}
               aria-valuenow={Math.min(clickCount, maxClicks)}
-              data-wp-bind--aria-valuenow="state.clampedClicks"
-              data-wp-style--width="state.progress + '%'"
+              data-wp-bind--aria-valuenow={clampedClicksDirective}
+              data-wp-style--width={progressDirective}
             />
           </div>
         )}
@@ -226777,7 +226808,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
         <div
           className={\`{{cssClassName}}__animation \${animation}\`}
           aria-hidden="true"
-          data-wp-class--is-active="state.isAnimating"
+          data-wp-class--is-active={isAnimatingDirective}
         />
 
         {maxClicks > 0 && (
@@ -226786,7 +226817,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
             role="status"
             aria-live="polite"
             aria-atomic="true"
-            data-wp-bind--hidden="!state.isComplete"
+            data-wp-bind--hidden={completionHiddenDirective}
           >
             { __( '\uD83C\uDF89 Complete!', '{{textDomain}}' ) }
           </div>
@@ -226794,7 +226825,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
 
         <button
           className="{{cssClassName}}__reset"
-          data-wp-on--click="actions.reset"
+          data-wp-on--click={resetActionDirective}
           aria-label={ __( 'Reset counter', '{{textDomain}}' ) }
         >
           <span aria-hidden="true">\u21BB</span>
@@ -226842,20 +226873,213 @@ const registration = buildScaffoldBlockRegistration(
 );
 
 registerScaffoldBlockType(registration.name, registration.settings);
+`, INTERACTIVITY_STORE_TEMPLATE = `import type {
+  {{pascalCase}}Context,
+  {{pascalCase}}State,
+} from './types';
+
+type InteractivityActionShape = object;
+type InteractivityCallbackShape = object;
+type InteractivityContextShape = object;
+type InteractivityStateShape = object;
+type InteractivityCallable = CallableFunction;
+type InteractivityKey<T extends object> = Extract<keyof T, string>;
+type InteractivityMethodKey<T extends object> = {
+  [Key in InteractivityKey<T>]: T[Key] extends InteractivityCallable ? Key : never;
+}[InteractivityKey<T>];
+
+type InteractivityDirectivePath<
+  Root extends string,
+  Key extends string,
+> = \`\${Root}.\${Key}\`;
+
+type NegatedInteractivityDirectivePath<Path extends string> = \`!\${Path}\`;
+
+export interface TypedInteractivityDirectiveHelpers<
+  State extends InteractivityStateShape,
+  Context extends InteractivityContextShape,
+  Actions extends InteractivityActionShape,
+  Callbacks extends InteractivityCallbackShape,
+  Namespace extends string,
+> {
+  readonly interactive: Namespace;
+  action<Key extends InteractivityMethodKey<Actions>>(
+    key: Key,
+  ): InteractivityDirectivePath<'actions', Key>;
+  callback<Key extends InteractivityMethodKey<Callbacks>>(
+    key: Key,
+  ): InteractivityDirectivePath<'callbacks', Key>;
+  state<Key extends InteractivityKey<State>>(
+    key: Key,
+  ): InteractivityDirectivePath<'state', Key>;
+  context<Key extends InteractivityKey<Context>>(
+    key: Key,
+  ): InteractivityDirectivePath<'context', Key>;
+  negate<Path extends string>(
+    path: Path,
+  ): NegatedInteractivityDirectivePath<Path>;
+}
+
+export interface TypedInteractivityStore<
+  Namespace extends string,
+  State extends InteractivityStateShape,
+  Context extends InteractivityContextShape,
+  Actions extends InteractivityActionShape,
+  Callbacks extends InteractivityCallbackShape,
+> {
+  readonly namespace: Namespace;
+  readonly state: State;
+  readonly context: Context;
+  readonly actions: Actions;
+  readonly callbacks: Callbacks;
+  readonly directive: TypedInteractivityDirectiveHelpers<
+    State,
+    Context,
+    Actions,
+    Callbacks,
+    Namespace
+  >;
+  createContext(value: Context): Context;
+}
+
+export function defineInteractivityStore<
+  Namespace extends string,
+  State extends InteractivityStateShape,
+  Context extends InteractivityContextShape,
+  Actions extends InteractivityActionShape,
+  Callbacks extends InteractivityCallbackShape,
+>(config: {
+  readonly namespace: Namespace;
+  readonly state: State;
+  readonly context: Context;
+  readonly actions: Actions;
+  readonly callbacks: Callbacks;
+}): TypedInteractivityStore<Namespace, State, Context, Actions, Callbacks> {
+  return {
+    namespace: config.namespace,
+    state: config.state,
+    context: config.context,
+    actions: config.actions,
+    callbacks: config.callbacks,
+    directive: {
+      interactive: config.namespace,
+      action<Key extends InteractivityMethodKey<Actions>>(key: Key) {
+        return \`actions.\${key}\` as InteractivityDirectivePath<'actions', Key>;
+      },
+      callback<Key extends InteractivityMethodKey<Callbacks>>(key: Key) {
+        return \`callbacks.\${key}\` as InteractivityDirectivePath<'callbacks', Key>;
+      },
+      state<Key extends InteractivityKey<State>>(key: Key) {
+        return \`state.\${key}\` as InteractivityDirectivePath<'state', Key>;
+      },
+      context<Key extends InteractivityKey<Context>>(key: Key) {
+        return \`context.\${key}\` as InteractivityDirectivePath<'context', Key>;
+      },
+      negate<Path extends string>(path: Path) {
+        return \`!\${path}\` as NegatedInteractivityDirectivePath<Path>;
+      },
+    },
+    createContext(value) {
+      return value;
+    },
+  };
+}
+
+type InteractivityActionHandler = CallableFunction;
+
+export interface {{pascalCase}}StoreActions {
+  handleClick: InteractivityActionHandler;
+  handleMouseEnter: InteractivityActionHandler;
+  handleMouseLeave: InteractivityActionHandler;
+  reset: InteractivityActionHandler;
+}
+
+export interface {{pascalCase}}StoreCallbacks {}
+
+export const {{slugCamelCase}}Store = defineInteractivityStore({
+  namespace: '{{slugKebabCase}}',
+  state: {} as {{pascalCase}}State,
+  context: {} as {{pascalCase}}Context,
+  actions: {} as {{pascalCase}}StoreActions,
+  callbacks: {} as {{pascalCase}}StoreCallbacks,
+});
 `, INTERACTIVITY_SCRIPT_TEMPLATE = `/**
  * WordPress Interactivity API implementation for {{title}} block
  */
 import { store, getContext, getElement, withSyncEvent } from '@wordpress/interactivity';
-import type { {{pascalCase}}Context } from './types';
+import {
+  {{slugCamelCase}}Store,
+  type {{pascalCase}}StoreActions,
+} from './interactivity-store';
+import type { {{pascalCase}}Context, {{pascalCase}}State } from './types';
 
 function getBlockContext() {
   return getContext<{{pascalCase}}Context>();
 }
 
-// Store configuration
-store('{{slugKebabCase}}', {
-  // State - reactive data that updates the UI
-  state: {
+const actions: {{pascalCase}}StoreActions = {
+  // Handle block click
+  handleClick: () => {
+    const context = getBlockContext();
+    const { ref } = getElement();
+
+    if (!ref) {
+      return;
+    }
+
+    if (context.maxClicks > 0 && context.clicks >= context.maxClicks) {
+      return;
+    }
+
+    const previousClicks = context.clicks;
+
+    // Increment click counter
+    context.clicks += 1;
+
+    // Trigger animation
+    if (context.animation !== 'none') {
+      context.isAnimating = true;
+      setTimeout(() => {
+        context.isAnimating = false;
+      }, 1000);
+    }
+
+    // Emit custom event
+    ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:click', {
+      detail: { clicks: context.clicks }
+    }));
+
+    // Check if max clicks reached
+    if (context.maxClicks > 0 && previousClicks < context.maxClicks && context.clicks === context.maxClicks) {
+      ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:complete', {
+        detail: { totalClicks: context.clicks }
+      }));
+    }
+  },
+
+  // Handle hover events
+  handleMouseEnter: () => {
+    const context = getBlockContext();
+    if (context.animation === 'none') return;
+    context.isAnimating = true;
+  },
+
+  handleMouseLeave: () => {
+    const context = getBlockContext();
+    if (context.animation === 'none') return;
+    context.isAnimating = false;
+  },
+
+  // Reset counter
+  reset: withSyncEvent((event: Event) => {
+    event.stopPropagation();
+    const context = getBlockContext();
+    context.clicks = 0;
+    context.isAnimating = false;
+  })
+};
+
+const state = {
     get clicks() {
       return getBlockContext().clicks;
     },
@@ -226883,70 +227107,14 @@ store('{{slugKebabCase}}', {
       const context = getBlockContext();
       return context.clicks >= context.maxClicks && context.maxClicks > 0;
     }
-  },
-
-  // Actions - user interactions
-  actions: {
-    // Handle block click
-    handleClick: () => {
-      const context = getBlockContext();
-      const { ref } = getElement();
-
-      if (!ref) {
-        return;
-      }
-
-      if (context.maxClicks > 0 && context.clicks >= context.maxClicks) {
-        return;
-      }
+} satisfies {{pascalCase}}State;
 
-      const previousClicks = context.clicks;
-
-      // Increment click counter
-      context.clicks += 1;
-
-      // Trigger animation
-      if (context.animation !== 'none') {
-        context.isAnimating = true;
-        setTimeout(() => {
-          context.isAnimating = false;
-        }, 1000);
-      }
-
-      // Emit custom event
-      ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:click', {
-        detail: { clicks: context.clicks }
-      }));
-
-      // Check if max clicks reached
-      if (context.maxClicks > 0 && previousClicks < context.maxClicks && context.clicks === context.maxClicks) {
-        ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:complete', {
-          detail: { totalClicks: context.clicks }
-        }));
-      }
-    },
-
-    // Handle hover events
-    handleMouseEnter: () => {
-      const context = getBlockContext();
-      if (context.animation === 'none') return;
-      context.isAnimating = true;
-    },
-
-    handleMouseLeave: () => {
-      const context = getBlockContext();
-      if (context.animation === 'none') return;
-      context.isAnimating = false;
-    },
-
-    // Reset counter
-    reset: withSyncEvent((event: Event) => {
-      event.stopPropagation();
-      const context = getBlockContext();
-      context.clicks = 0;
-      context.isAnimating = false;
-    })
-  }
+// Store configuration
+store({{slugCamelCase}}Store.namespace, {
+  // State - reactive data that updates the UI
+  state,
+  actions,
+  callbacks: {{slugCamelCase}}Store.callbacks,
 });
 `, INTERACTIVITY_VALIDATORS_TEMPLATE = `import typia from 'typia';
 import currentManifest from "./manifest-defaults-document";
@@ -228757,6 +228925,10 @@ function buildInteractivityCodeArtifacts(variables) {
         relativePath: "src/interactivity.ts",
         template: INTERACTIVITY_SCRIPT_TEMPLATE
       },
+      {
+        relativePath: "src/interactivity-store.ts",
+        template: INTERACTIVITY_STORE_TEMPLATE
+      },
       {
         relativePath: "src/validators.ts",
         template: INTERACTIVITY_VALIDATORS_TEMPLATE
@@ -230133,6 +230305,8 @@ async function resolveOptionalInteractiveExternalLayerId({
   callerCwd,
   externalLayerId,
   externalLayerSource,
+  listExternalTemplateLayers = listSelectableExternalTemplateLayers,
+  resolveExternalTemplateSeed = resolveTemplateSeed,
   selectExternalLayerId
 }) {
   if (!externalLayerSource || externalLayerId || !selectExternalLayerId) {
@@ -230141,9 +230315,9 @@ async function resolveOptionalInteractiveExternalLayerId({
       externalLayerSource
     };
   }
-  const layerSeed = await resolveTemplateSeed(parseTemplateLocator(externalLayerSource), callerCwd);
+  const layerSeed = await resolveExternalTemplateSeed(parseTemplateLocator(externalLayerSource), callerCwd);
   try {
-    const selectableLayers = await listSelectableExternalTemplateLayers(layerSeed.rootDir);
+    const selectableLayers = await listExternalTemplateLayers(layerSeed.rootDir);
     if (selectableLayers.length <= 1) {
       await layerSeed.cleanup?.();
       return {
@@ -230159,7 +230333,6 @@ async function resolveOptionalInteractiveExternalLayerId({
         externalLayerSource: layerSeed.rootDir
       };
     }
-    await layerSeed.cleanup?.();
     throw new Error(`Unknown external layer "${selectedLayerId}". Expected one of: ${selectableLayers.map((layer) => layer.id).join(", ")}`);
   } catch (error48) {
     await layerSeed.cleanup?.();
@@ -230545,70 +230718,98 @@ var init_cli_add_block = __esm(() => {
   WORKSPACE_INSTALL_MARKERS = ["node_modules", ".pnp.cjs", ".pnp.loader.mjs"];
 });
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
-import fs42 from "fs";
-import { promises as fsp18 } from "fs";
-import { createRequire as createRequire4 } from "module";
-import path51 from "path";
-function toCamelCase(input) {
-  const pascalCase = toPascalCase(input);
-  return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-types.ts
+function isAdminViewCoreDataSource(source) {
+  return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
 }
-function normalizeVersionRange2(value2, fallback) {
-  const trimmed = value2?.trim();
-  if (!trimmed || trimmed.startsWith("workspace:")) {
-    return fallback;
+function isAdminViewRestResourceSource(source) {
+  return source?.kind === ADMIN_VIEW_REST_SOURCE_KIND;
+}
+function formatAdminViewSourceLocator(source) {
+  if (isAdminViewCoreDataSource(source)) {
+    return `${source.kind}:${source.entityKind}/${source.entityName}`;
   }
-  return /^[~^<>=]/u.test(trimmed) ? trimmed : `^${trimmed}`;
+  return `${source.kind}:${source.slug}`;
 }
-function readPackageManifestVersion(packageJsonPath) {
-  try {
-    const packageJson = JSON.parse(fs42.readFileSync(packageJsonPath, "utf8"));
-    return packageJson.version;
-  } catch {
+var ADMIN_VIEW_REST_SOURCE_KIND = "rest-resource", ADMIN_VIEW_CORE_DATA_SOURCE_KIND = "core-data", ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS, ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN, ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN, ADMIN_VIEW_SOURCE_USAGE = "wp-typia add admin-view <name> --source <rest-resource:slug|core-data:kind/name>", ADMIN_VIEWS_SCRIPT = "build/admin-views/index.js", ADMIN_VIEWS_ASSET = "build/admin-views/index.asset.php", ADMIN_VIEWS_STYLE = "build/admin-views/style-index.css", ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css", ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php", ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = "WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS", ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false;
+var init_cli_add_workspace_admin_view_types = __esm(() => {
+  ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS = [
+    "postType",
+    "taxonomy"
+  ];
+  ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
+  ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/u;
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-source.ts
+function isAdminViewUnpublishedDataViewsOverrideEnabled() {
+  return process.env[ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV]?.trim() === "1";
+}
+function assertAdminViewPackageAvailability() {
+  if (isAdminViewUnpublishedDataViewsOverrideEnabled() || ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED) {
     return;
   }
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia add admin-view` is temporarily unavailable because `@wp-typia/dataviews` is not published to npm for public installs yet.");
 }
-function detectJsonIndent(source) {
-  const indentMatch = /\n([ \t]+)"/u.exec(source);
-  return indentMatch?.[1] ?? 2;
+function assertValidCoreDataEntitySegment(label, value2) {
+  const trimmed = value2.trim();
+  if (!trimmed) {
+    throw new Error(`${label} is required. Use \`${ADMIN_VIEW_SOURCE_USAGE}\`.`);
+  }
+  if (!ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN.test(trimmed)) {
+    throw new Error(`${label} must start with a letter and contain only letters, numbers, underscores, or hyphens.`);
+  }
+  return trimmed;
 }
-function resolvePackageVersionRange(packageName, fallback, workspacePackageDirName) {
-  if (workspacePackageDirName) {
-    const workspaceVersion = readPackageManifestVersion(path51.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", workspacePackageDirName, "package.json"));
-    if (workspaceVersion) {
-      return normalizeVersionRange2(workspaceVersion, fallback);
-    }
+function assertValidCoreDataEntityName(value2) {
+  const normalized = value2.trim();
+  if (!normalized) {
+    throw new Error(`Admin view source entity name is required. Use \`${ADMIN_VIEW_SOURCE_USAGE}\`.`);
   }
-  try {
-    return normalizeVersionRange2(readPackageManifestVersion(require4.resolve(`${packageName}/package.json`)), fallback);
-  } catch {
-    return fallback;
+  if (!ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN.test(normalized)) {
+    throw new Error("Admin view source entity name must start with a lowercase letter or number and contain only lowercase letters, numbers, underscores, or hyphens.");
   }
+  return normalized;
 }
-function getAdminViewRelativeModuleSpecifier(adminViewSlug, workspaceFile) {
-  const adminViewDir = `src/admin-views/${adminViewSlug}`;
-  const normalizedFile = workspaceFile.replace(/\\/gu, "/");
-  const modulePath = normalizedFile.replace(/\.[cm]?[jt]sx?$/u, "");
-  const relativeModulePath = path51.posix.relative(adminViewDir, modulePath);
-  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
+function assertValidCoreDataEntityKind(value2) {
+  const normalized = assertValidCoreDataEntitySegment("Admin view source entity kind", value2);
+  if (!ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS.includes(normalized)) {
+    throw new Error(`Admin view core-data sources currently support only: ${ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS.join(", ")}.`);
+  }
+  return normalized;
 }
 function parseAdminViewSource(source) {
   const trimmed = source?.trim();
   if (!trimmed) {
     return;
   }
-  const [kind, slug, extra] = trimmed.split(":");
-  if (kind !== ADMIN_VIEW_SOURCE_KIND || !slug || extra !== undefined) {
-    throw new Error("Admin view source must use `rest-resource:<slug>` for now.");
+  const separatorIndex = trimmed.indexOf(":");
+  const kind = separatorIndex === -1 ? trimmed : trimmed.slice(0, separatorIndex);
+  const locator = separatorIndex === -1 ? "" : trimmed.slice(separatorIndex + 1);
+  if (!locator) {
+    throw new Error("Admin view source must use `rest-resource:<slug>` or `core-data:<kind>/<name>`.");
   }
-  return {
-    kind,
-    slug: assertValidGeneratedSlug("Admin view source slug", normalizeBlockSlug(slug), "wp-typia add admin-view <name> --source rest-resource:<slug>")
-  };
+  if (kind === ADMIN_VIEW_REST_SOURCE_KIND) {
+    return {
+      kind,
+      slug: assertValidGeneratedSlug("Admin view source slug", locator, ADMIN_VIEW_SOURCE_USAGE)
+    };
+  }
+  if (kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND) {
+    const [entityKind, entityName, extra] = locator.split("/");
+    if (!entityKind || !entityName || extra !== undefined) {
+      throw new Error("Admin view core-data sources must use `core-data:<kind>/<name>`, for example `core-data:postType/post`.");
+    }
+    return {
+      entityKind: assertValidCoreDataEntityKind(entityKind),
+      entityName: assertValidCoreDataEntityName(entityName),
+      kind
+    };
+  }
+  throw new Error("Admin view source must use `rest-resource:<slug>` or `core-data:<kind>/<name>`.");
 }
 function resolveRestResourceSource(restResources, source) {
-  if (!source) {
+  if (!isAdminViewRestResourceSource(source)) {
     return;
   }
   const restResource = restResources.find((entry) => entry.slug === source.slug);
@@ -230620,13 +230821,31 @@ function resolveRestResourceSource(restResources, source) {
   }
   return restResource;
 }
+function resolveAdminViewCoreDataSource(source) {
+  return isAdminViewCoreDataSource(source) ? source : undefined;
+}
+var init_cli_add_workspace_admin_view_source = __esm(() => {
+  init_cli_add_shared();
+  init_cli_diagnostics();
+  init_cli_add_workspace_admin_view_types();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates.ts
+import path51 from "path";
+function getAdminViewRelativeModuleSpecifier(adminViewSlug, workspaceFile) {
+  const adminViewDir = `src/admin-views/${adminViewSlug}`;
+  const normalizedFile = workspaceFile.replace(/\\/gu, "/");
+  const modulePath = normalizedFile.replace(/\.[cm]?[jt]sx?$/u, "");
+  const relativeModulePath = path51.posix.relative(adminViewDir, modulePath);
+  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
+}
 function buildAdminViewConfigEntry(adminViewSlug, source) {
   return [
     "\t{",
     `		file: ${quoteTsString(`src/admin-views/${adminViewSlug}/index.tsx`)},`,
     `		phpFile: ${quoteTsString(`inc/admin-views/${adminViewSlug}.php`)},`,
     `		slug: ${quoteTsString(adminViewSlug)},`,
-    source ? `		source: ${quoteTsString(`${source.kind}:${source.slug}`)},` : null,
+    source ? `		source: ${quoteTsString(formatAdminViewSourceLocator(source))},` : null,
     "\t},"
   ].filter((line) => typeof line === "string").join(`
 `);
@@ -230639,8 +230858,9 @@ function buildAdminViewRegistrySource(adminViewSlugs) {
 ` : ""}// wp-typia add admin-view entries
 `;
 }
-function buildAdminViewTypesSource(adminViewSlug, restResource) {
+function buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource) {
   const pascalName = toPascalCase(adminViewSlug);
+  const coreDataRecordTypeName = `${pascalName}CoreDataRecord`;
   const itemTypeName = `${pascalName}AdminViewItem`;
   const dataSetTypeName = `${pascalName}AdminViewDataSet`;
   if (restResource) {
@@ -230650,6 +230870,74 @@ function buildAdminViewTypesSource(adminViewSlug, restResource) {
 
 export type ${itemTypeName} = ${restPascalName}Record;
 
+export interface ${dataSetTypeName} {
+	items: ${itemTypeName}[];
+	paginationInfo: {
+		totalItems: number;
+		totalPages: number;
+	};
+}
+`;
+  }
+  if (coreDataSource) {
+    if (coreDataSource.entityKind === "taxonomy") {
+      return `export interface ${coreDataRecordTypeName} {
+	count?: number;
+	description?: string;
+	id: number;
+	link?: string;
+	meta?: Record<string, unknown>;
+	name?: string;
+	parent?: number;
+	slug?: string;
+	taxonomy?: string;
+	[key: string]: unknown;
+}
+
+export interface ${itemTypeName} {
+	count: number;
+	description: string;
+	id: number;
+	link: string;
+	name: string;
+	parent: number;
+	raw: ${coreDataRecordTypeName};
+	slug: string;
+	taxonomy: string;
+}
+
+export interface ${dataSetTypeName} {
+	items: ${itemTypeName}[];
+	paginationInfo: {
+		totalItems: number;
+		totalPages: number;
+	};
+}
+`;
+    }
+    return `export interface ${coreDataRecordTypeName} {
+	id: number;
+	date?: string;
+	modified?: string;
+	name?: string;
+	slug?: string;
+	status?: string;
+	title?: string | {
+		raw?: string;
+		rendered?: string;
+	};
+	[key: string]: unknown;
+}
+
+export interface ${itemTypeName} {
+	id: number;
+	raw: ${coreDataRecordTypeName};
+	slug: string;
+	status: string;
+	title: string;
+	updatedAt: string;
+}
+
 export interface ${dataSetTypeName} {
 	items: ${itemTypeName}[];
 	paginationInfo: {
@@ -230678,22 +230966,74 @@ export interface ${dataSetTypeName} {
 }
 `;
 }
-function buildAdminViewConfigSource(adminViewSlug, textDomain, restResource) {
+function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResource) {
   const pascalName = toPascalCase(adminViewSlug);
   const camelName = toCamelCase(adminViewSlug);
   const itemTypeName = `${pascalName}AdminViewItem`;
   const dataViewsName = `${camelName}AdminDataViews`;
-  const defaultViewFields = restResource ? "['id']" : "['title', 'status', 'updatedAt']";
+  const isCoreDataSource = isAdminViewCoreDataSource(source);
+  const isTaxonomyCoreDataSource = isAdminViewCoreDataSource(source) && source.entityKind === "taxonomy";
+  const defaultViewFields = restResource ? "['id']" : isTaxonomyCoreDataSource ? "['name', 'slug', 'count']" : isCoreDataSource ? "['title', 'slug', 'status', 'updatedAt']" : "['title', 'status', 'updatedAt']";
   const searchEnabled = restResource ? "false" : "true";
-  const titleFieldSource = restResource ? "" : `	titleField: 'title',
+  const titleFieldSource = restResource ? "" : isTaxonomyCoreDataSource ? `	titleField: 'name',
+` : `	titleField: 'title',
 `;
-  const defaultViewEnhancementsSource = restResource ? "" : `		sort: {
+  const defaultViewEnhancementsSource = restResource ? "" : isTaxonomyCoreDataSource ? `		titleField: 'name',
+` : isCoreDataSource ? `		titleField: 'title',
+` : `		sort: {
 			direction: 'desc',
 			field: 'updatedAt',
 		},
 		titleField: 'title',
 `;
-  const additionalFieldsSource = restResource ? "\t\t// REST-backed screens start with the guaranteed ID column. Add project-owned fields here once they are declared on the REST record type." : `		owner: {
+  const additionalFieldsSource = restResource ? "\t\t// REST-backed screens start with the guaranteed ID column. Add project-owned fields here once they are declared on the REST record type." : isTaxonomyCoreDataSource ? `		count: {
+			label: __( 'Count', ${quoteTsString(textDomain)} ),
+			schema: { type: 'integer' },
+		},
+		description: {
+			label: __( 'Description', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},
+		link: {
+			label: __( 'Link', ${quoteTsString(textDomain)} ),
+			schema: { format: 'uri', type: 'string' },
+		},
+		name: {
+			enableGlobalSearch: true,
+			label: __( 'Name', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},
+		parent: {
+			label: __( 'Parent', ${quoteTsString(textDomain)} ),
+			schema: { type: 'integer' },
+		},
+		slug: {
+			enableGlobalSearch: true,
+			label: __( 'Slug', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},
+		taxonomy: {
+			label: __( 'Taxonomy', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},` : isCoreDataSource ? `		slug: {
+			enableGlobalSearch: true,
+			label: __( 'Slug', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},
+		status: {
+			label: __( 'Status', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},
+		title: {
+			enableGlobalSearch: true,
+			label: __( 'Name', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},
+		updatedAt: {
+			label: __( 'Updated', ${quoteTsString(textDomain)} ),
+			schema: { format: 'date-time', type: 'string' },
+			type: 'datetime',
+		},` : `		owner: {
 			label: __( 'Owner', ${quoteTsString(textDomain)} ),
 			schema: { type: 'string' },
 		},
@@ -230880,6 +231220,217 @@ export async function ${fetchName}(
 }
 `;
 }
+function buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const camelName = toCamelCase(adminViewSlug);
+  const coreDataRecordTypeName = `${pascalName}CoreDataRecord`;
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const queryTypeName = `${pascalName}AdminViewQuery`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  const useEntityRecordName = `use${pascalName}EntityRecord`;
+  const useEntityRecordsName = `use${pascalName}EntityRecords`;
+  const useAdminViewDataName = `use${pascalName}AdminViewData`;
+  if (coreDataSource.entityKind === "taxonomy") {
+    return `import type { DataViewsView } from '@wp-typia/dataviews';
+import { useEntityRecord, useEntityRecords } from '@wordpress/core-data';
+import { useMemo } from '@wordpress/element';
+
+import { ${dataViewsName} } from './config';
+import type {
+	${coreDataRecordTypeName},
+	${dataSetTypeName},
+	${itemTypeName},
+} from './types';
+
+export interface ${queryTypeName} {
+	page?: number;
+	per_page?: number;
+	search?: string;
+}
+
+const CORE_DATA_ENTITY_KIND = ${quoteTsString(coreDataSource.entityKind)};
+const CORE_DATA_ENTITY_NAME = ${quoteTsString(coreDataSource.entityName)};
+
+function normalizeCoreDataNumber(value: unknown): number {
+	return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function normalizeCoreDataString(value: unknown): string {
+	return typeof value === 'string' ? value : '';
+}
+
+function normalizeTaxonomyRecord(record: ${coreDataRecordTypeName}): ${itemTypeName} {
+	return {
+		count: normalizeCoreDataNumber(record.count),
+		description: normalizeCoreDataString(record.description),
+		id: record.id,
+		link: normalizeCoreDataString(record.link),
+		name: normalizeCoreDataString(record.name) || normalizeCoreDataString(record.slug),
+		parent: normalizeCoreDataNumber(record.parent),
+		raw: record,
+		slug: normalizeCoreDataString(record.slug),
+		taxonomy: normalizeCoreDataString(record.taxonomy),
+	};
+	}
+
+export function ${useEntityRecordName}(recordId: number | undefined) {
+	return useEntityRecord<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		recordId ?? 0,
+		{ enabled: typeof recordId === 'number' },
+	);
+	}
+
+export function ${useEntityRecordsName}(view: DataViewsView<${itemTypeName}>) {
+	const query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
+		perPageParam: 'per_page',
+	});
+
+	return useEntityRecords<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		query,
+	);
+	}
+
+export function ${useAdminViewDataName}(view: DataViewsView<${itemTypeName}>) {
+	const { hasResolved, isResolving, records, totalItems, totalPages } =
+		${useEntityRecordsName}(view);
+	const items = useMemo(
+		() => (records ?? []).map((record) => normalizeTaxonomyRecord(record)),
+		[records],
+	);
+	const dataSet = useMemo<${dataSetTypeName}>(
+		() => ({
+			items,
+			paginationInfo: {
+				totalItems: totalItems ?? items.length,
+				totalPages: Math.max(1, totalPages ?? 1),
+			},
+		}),
+		[items, totalItems, totalPages],
+	);
+	const error =
+		!isResolving && hasResolved && records === null
+			? 'Unable to load core-data entity records.'
+			: null;
+
+	return {
+		dataSet,
+		error,
+		isLoading: isResolving,
+	};
+	}
+`;
+  }
+  return `import type { DataViewsView } from '@wp-typia/dataviews';
+import { useEntityRecord, useEntityRecords } from '@wordpress/core-data';
+import { useMemo } from '@wordpress/element';
+
+import { ${dataViewsName} } from './config';
+import type {
+	${coreDataRecordTypeName},
+	${dataSetTypeName},
+	${itemTypeName},
+} from './types';
+
+export interface ${queryTypeName} {
+	page?: number;
+	per_page?: number;
+	search?: string;
+}
+
+const CORE_DATA_ENTITY_KIND = ${quoteTsString(coreDataSource.entityKind)};
+const CORE_DATA_ENTITY_NAME = ${quoteTsString(coreDataSource.entityName)};
+
+function normalizeCoreDataString(value: unknown): string {
+	return typeof value === 'string' ? value : '';
+}
+
+function normalizeCoreDataTitle(record: ${coreDataRecordTypeName}): string {
+	if (typeof record.title === 'string') {
+		return record.title;
+	}
+	if (record.title && typeof record.title === 'object') {
+		if (typeof record.title.rendered === 'string') {
+			return record.title.rendered;
+		}
+		if (typeof record.title.raw === 'string') {
+			return record.title.raw;
+		}
+	}
+
+	return normalizeCoreDataString(record.name) || normalizeCoreDataString(record.slug);
+}
+
+function normalizeCoreDataUpdatedAt(record: ${coreDataRecordTypeName}): string {
+	return normalizeCoreDataString(record.modified) || normalizeCoreDataString(record.date);
+}
+
+function normalizeCoreDataRecord(record: ${coreDataRecordTypeName}): ${itemTypeName} {
+	return {
+		id: record.id,
+		raw: record,
+		slug: normalizeCoreDataString(record.slug),
+		status: normalizeCoreDataString(record.status),
+		title: normalizeCoreDataTitle(record),
+		updatedAt: normalizeCoreDataUpdatedAt(record),
+	};
+}
+
+export function ${useEntityRecordName}(recordId: number | undefined) {
+	return useEntityRecord<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		recordId ?? 0,
+		{ enabled: typeof recordId === 'number' },
+	);
+}
+
+export function ${useEntityRecordsName}(view: DataViewsView<${itemTypeName}>) {
+	const query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
+		perPageParam: 'per_page',
+	});
+
+	return useEntityRecords<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		query,
+	);
+}
+
+export function ${useAdminViewDataName}(view: DataViewsView<${itemTypeName}>) {
+	const { hasResolved, isResolving, records, totalItems, totalPages } =
+		${useEntityRecordsName}(view);
+	const items = useMemo(
+		() => (records ?? []).map((record) => normalizeCoreDataRecord(record)),
+		[records],
+	);
+	const dataSet = useMemo<${dataSetTypeName}>(
+		() => ({
+			items,
+			paginationInfo: {
+				totalItems: totalItems ?? items.length,
+				totalPages: Math.max(1, totalPages ?? 1),
+			},
+		}),
+		[items, totalItems, totalPages],
+	);
+	const error =
+		!isResolving && hasResolved && records === null
+			? 'Unable to load core-data entity records.'
+			: null;
+
+	return {
+		dataSet,
+		error,
+		isLoading: isResolving,
+	};
+}
+`;
+}
 function buildAdminViewScreenSource(adminViewSlug, textDomain) {
   const pascalName = toPascalCase(adminViewSlug);
   const camelName = toCamelCase(adminViewSlug);
@@ -230993,6 +231544,81 @@ export function ${componentName}() {
 }
 `;
 }
+function buildCoreDataAdminViewScreenSource(adminViewSlug, textDomain) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const camelName = toCamelCase(adminViewSlug);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  const componentName = `${pascalName}AdminViewScreen`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  const useAdminViewDataName = `use${pascalName}AdminViewData`;
+  const title = toTitleCase(adminViewSlug);
+  return `import type { DataViewsConfig, DataViewsView } from '@wp-typia/dataviews';
+import { Notice, Spinner } from '@wordpress/components';
+import { useState } from '@wordpress/element';
+import { __ } from '@wordpress/i18n';
+import { DataViews } from '@wordpress/dataviews/wp';
+
+import { ${dataViewsName} } from './config';
+import { ${useAdminViewDataName} } from './data';
+import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
+
+const TypedDataViews = DataViews as unknown as <TItem extends object>(
+	props: DataViewsConfig<TItem>,
+) => ReturnType<typeof DataViews>;
+
+const EMPTY_DATA_SET: ${dataSetTypeName} = {
+	items: [],
+	paginationInfo: {
+		totalItems: 0,
+		totalPages: 1,
+	},
+};
+
+export function ${componentName}() {
+	const [view, setView] = useState<DataViewsView<${itemTypeName}>>(
+		${dataViewsName}.defaultView,
+	);
+	const {
+		dataSet = EMPTY_DATA_SET,
+		error,
+		isLoading,
+	} = ${useAdminViewDataName}(view);
+	const config = ${dataViewsName}.createConfig({
+		data: dataSet.items,
+		isLoading,
+		onChangeView: setView,
+		paginationInfo: dataSet.paginationInfo,
+		view,
+	});
+
+	return (
+		<div className="wp-typia-admin-view-screen">
+			<header className="wp-typia-admin-view-screen__header">
+				<div>
+					<p className="wp-typia-admin-view-screen__eyebrow">
+						{ __( 'DataViews admin screen', ${quoteTsString(textDomain)} ) }
+					</p>
+					<h1>{ __( ${quoteTsString(title)}, ${quoteTsString(textDomain)} ) }</h1>
+					<p>
+						{ __( 'This screen reads from the WordPress core-data entity store. Extend data.ts when you need entity-specific field mapping or edit flows.', ${quoteTsString(textDomain)} ) }
+					</p>
+				</div>
+				<div className="wp-typia-admin-view-screen__actions">
+					{ isLoading ? <Spinner /> : null }
+				</div>
+			</header>
+			{ error ? (
+				<Notice isDismissible={ false } status="error">
+					{ error }
+				</Notice>
+			) : null }
+			<TypedDataViews<${itemTypeName}> { ...config } />
+		</div>
+	);
+}
+`;
+}
 function buildAdminViewEntrySource(adminViewSlug) {
   const pascalName = toPascalCase(adminViewSlug);
   const componentName = `${pascalName}AdminViewScreen`;
@@ -231162,15 +231788,48 @@ add_action( 'admin_menu', '${registerFunctionName}' );
 add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
 `;
 }
-async function ensureAdminViewPackageDependencies(workspace) {
-  const packageJsonPath = path51.join(workspace.projectDir, "package.json");
-  const wpTypiaDataViewsVersion = resolvePackageVersionRange("@wp-typia/dataviews", DEFAULT_WP_TYPIA_DATAVIEWS_VERSION, "wp-typia-dataviews");
-  const wordpressDataViewsVersion = resolvePackageVersionRange("@wordpress/dataviews", DEFAULT_WORDPRESS_DATAVIEWS_VERSION);
+var init_cli_add_workspace_admin_view_templates = __esm(() => {
+  init_cli_add_shared();
+  init_cli_add_workspace_admin_view_types();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
+import fs42 from "fs";
+import { promises as fsp18 } from "fs";
+import path52 from "path";
+function detectJsonIndent(source) {
+  const indentMatch = /\n([ \t]+)"/u.exec(source);
+  return indentMatch?.[1] ?? 2;
+}
+async function ensureAdminViewPackageDependencies(workspace, adminViewSource) {
+  const packageJsonPath = path52.join(workspace.projectDir, "package.json");
+  const wpTypiaDataViewsVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WP_TYPIA_DATAVIEWS_VERSION,
+    packageName: "@wp-typia/dataviews",
+    workspacePackageDirName: "wp-typia-dataviews"
+  });
+  const wordpressDataViewsVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WORDPRESS_DATAVIEWS_VERSION,
+    packageName: "@wordpress/dataviews"
+  });
+  const wordpressCoreDataVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WORDPRESS_CORE_DATA_VERSION,
+    packageName: "@wordpress/core-data"
+  });
+  const wordpressDataVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WORDPRESS_DATA_VERSION,
+    packageName: "@wordpress/data"
+  });
   await patchFile(packageJsonPath, (source) => {
     const packageJson = JSON.parse(source);
+    const coreDataDependencies = isAdminViewCoreDataSource(adminViewSource) ? {
+      "@wordpress/core-data": packageJson.dependencies?.["@wordpress/core-data"] ?? wordpressCoreDataVersion,
+      "@wordpress/data": packageJson.dependencies?.["@wordpress/data"] ?? wordpressDataVersion
+    } : {};
     const nextDependencies = {
       ...packageJson.dependencies ?? {},
-      "@wordpress/dataviews": packageJson.dependencies?.["@wordpress/dataviews"] ?? wordpressDataViewsVersion
+      "@wordpress/dataviews": packageJson.dependencies?.["@wordpress/dataviews"] ?? wordpressDataViewsVersion,
+      ...coreDataDependencies
     };
     const nextDevDependencies = {
       ...packageJson.devDependencies ?? {},
@@ -231191,6 +231850,7 @@ async function ensureAdminViewBootstrapAnchors(workspace) {
     let nextSource = source;
     const loadFunctionName = `${workspace.workspace.phpPrefix}_load_admin_views`;
     const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
+    const loadHookPattern = new RegExp(`add_action\\(\\s*['"]plugins_loaded['"]\\s*,\\s*['"]${loadFunctionName}['"]\\s*\\)\\s*;`, "u");
     const loadFunction = `
 
 function ${loadFunctionName}() {
@@ -231235,19 +231895,19 @@ ${snippet}
       if (!functionSource.includes(ADMIN_VIEWS_PHP_GLOB)) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, loadFunctionName, loadFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path51.basename(bootstrapPath)} for ${loadFunctionName}.`);
+          throw new Error(`Unable to repair ${path52.basename(bootstrapPath)} for ${loadFunctionName}.`);
         }
         nextSource = replacedSource;
       }
     }
-    if (!nextSource.includes(loadHook)) {
+    if (!loadHookPattern.test(nextSource)) {
       appendPhpSnippet(loadHook);
     }
     return nextSource;
   });
 }
 async function ensureAdminViewBuildScriptAnchors(workspace) {
-  const buildScriptPath = path51.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/admin-views\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -231271,11 +231931,11 @@ async function ensureAdminViewBuildScriptAnchors(workspace) {
     if (nextSource !== source) {
       return nextSource;
     }
-    throw new Error(`Unable to update ${path51.relative(workspace.projectDir, buildScriptPath)} for admin view shared entries.`);
+    throw new Error(`Unable to update ${path52.relative(workspace.projectDir, buildScriptPath)} for admin view shared entries.`);
   });
 }
 async function ensureAdminViewWebpackAnchors(workspace) {
-  const webpackConfigPath = path51.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]admin-views\/index['"]/u.test(source)) {
       return source;
@@ -231316,17 +231976,17 @@ async function ensureAdminViewWebpackAnchors(workspace) {
 	}`;
     nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path51.relative(workspace.projectDir, webpackConfigPath)} for admin view shared entries.`);
+      throw new Error(`Unable to update ${path52.relative(workspace.projectDir, webpackConfigPath)} for admin view shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveAdminViewRegistryPath(projectDir) {
-  const adminViewsDir = path51.join(projectDir, "src", "admin-views");
+  const adminViewsDir = path52.join(projectDir, "src", "admin-views");
   return [
-    path51.join(adminViewsDir, "index.ts"),
-    path51.join(adminViewsDir, "index.js")
-  ].find((candidatePath) => fs42.existsSync(candidatePath)) ?? path51.join(adminViewsDir, "index.ts");
+    path52.join(adminViewsDir, "index.ts"),
+    path52.join(adminViewsDir, "index.js")
+  ].find((candidatePath) => fs42.existsSync(candidatePath)) ?? path52.join(adminViewsDir, "index.ts");
 }
 function readAdminViewRegistrySlugs(registryPath) {
   if (!fs42.existsSync(registryPath)) {
@@ -231336,33 +231996,34 @@ function readAdminViewRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeAdminViewRegistry(projectDir, adminViewSlug) {
-  const adminViewsDir = path51.join(projectDir, "src", "admin-views");
+  const adminViewsDir = path52.join(projectDir, "src", "admin-views");
   const registryPath = resolveAdminViewRegistryPath(projectDir);
   await fsp18.mkdir(adminViewsDir, { recursive: true });
   const existingAdminViewSlugs = readWorkspaceInventory(projectDir).adminViews.map((entry) => entry.slug);
   const existingRegistrySlugs = readAdminViewRegistrySlugs(registryPath);
-  const nextAdminViewSlugs = Array.from(new Set([...existingAdminViewSlugs, ...existingRegistrySlugs, adminViewSlug])).sort();
+  const nextAdminViewSlugs = Array.from(new Set([
+    ...existingAdminViewSlugs,
+    ...existingRegistrySlugs,
+    adminViewSlug
+  ])).sort();
   await fsp18.writeFile(registryPath, buildAdminViewRegistrySource(nextAdminViewSlugs), "utf8");
 }
-async function runAddAdminViewCommand({
-  adminViewName,
-  cwd = process.cwd(),
-  source
-}) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), "wp-typia add admin-view <name> [--source rest-resource:<slug>]");
-  const parsedSource = parseAdminViewSource(source);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  const restResource = resolveRestResourceSource(inventory.restResources, parsedSource);
-  assertAdminViewDoesNotExist(workspace.projectDir, adminViewSlug, inventory);
-  const blockConfigPath = path51.join(workspace.projectDir, "scripts", "block-config.ts");
+async function scaffoldAdminViewWorkspace(options) {
+  const {
+    adminViewSlug,
+    coreDataSource,
+    parsedSource,
+    restResource,
+    workspace
+  } = options;
+  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path51.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path51.join(workspace.projectDir, "package.json");
-  const webpackConfigPath = path51.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path52.join(workspace.projectDir, "package.json");
+  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
   const adminViewsIndexPath = resolveAdminViewRegistryPath(workspace.projectDir);
-  const adminViewDir = path51.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
-  const adminViewPhpPath = path51.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
+  const adminViewDir = path52.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
+  const adminViewPhpPath = path52.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       adminViewsIndexPath,
@@ -231377,45 +232038,78 @@ async function runAddAdminViewCommand({
   };
   try {
     await fsp18.mkdir(adminViewDir, { recursive: true });
-    await fsp18.mkdir(path51.dirname(adminViewPhpPath), { recursive: true });
-    await ensureAdminViewPackageDependencies(workspace);
+    await fsp18.mkdir(path52.dirname(adminViewPhpPath), { recursive: true });
+    await ensureAdminViewPackageDependencies(workspace, parsedSource);
     await ensureAdminViewBootstrapAnchors(workspace);
     await ensureAdminViewBuildScriptAnchors(workspace);
     await ensureAdminViewWebpackAnchors(workspace);
-    await fsp18.writeFile(path51.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, restResource), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "data.ts"), restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "Screen.tsx"), buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
     await fsp18.writeFile(adminViewPhpPath, buildAdminViewPhpSource(adminViewSlug, workspace), "utf8");
     await writeAdminViewRegistry(workspace.projectDir, adminViewSlug);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
-      adminViewEntries: [buildAdminViewConfigEntry(adminViewSlug, parsedSource)]
+      adminViewEntries: [
+        buildAdminViewConfigEntry(adminViewSlug, parsedSource)
+      ]
     });
-    return {
-      adminViewSlug,
-      projectDir: workspace.projectDir,
-      source: parsedSource ? `${parsedSource.kind}:${parsedSource.slug}` : undefined
-    };
   } catch (error48) {
     await rollbackWorkspaceMutation(mutationSnapshot);
     throw error48;
   }
 }
-var ADMIN_VIEW_SOURCE_KIND = "rest-resource", ADMIN_VIEWS_SCRIPT = "build/admin-views/index.js", ADMIN_VIEWS_ASSET = "build/admin-views/index.asset.php", ADMIN_VIEWS_STYLE = "build/admin-views/style-index.css", ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css", ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php", DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = "^0.1.0", DEFAULT_WORDPRESS_DATAVIEWS_VERSION = "^14.1.0", require4;
-var init_cli_add_workspace_admin_view = __esm(() => {
-  init_workspace_project();
+var init_cli_add_workspace_admin_view_scaffold = __esm(() => {
   init_workspace_inventory();
-  init_template_registry();
+  init_cli_add_workspace_admin_view_templates();
+  init_cli_add_workspace_admin_view_types();
   init_cli_add_shared();
-  require4 = createRequire4(import.meta.url);
+  init_package_versions();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
+async function runAddAdminViewCommand({
+  adminViewName,
+  cwd = process.cwd(),
+  source
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  assertAdminViewPackageAvailability();
+  const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), ADD_ADMIN_VIEW_USAGE);
+  const parsedSource = parseAdminViewSource(source);
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const restResource = resolveRestResourceSource(inventory.restResources, parsedSource);
+  const coreDataSource = resolveAdminViewCoreDataSource(parsedSource);
+  assertAdminViewDoesNotExist(workspace.projectDir, adminViewSlug, inventory);
+  await scaffoldAdminViewWorkspace({
+    adminViewSlug,
+    coreDataSource,
+    parsedSource,
+    restResource,
+    workspace
+  });
+  return {
+    adminViewSlug,
+    projectDir: workspace.projectDir,
+    source: parsedSource ? formatAdminViewSourceLocator(parsedSource) : undefined
+  };
+}
+var ADD_ADMIN_VIEW_USAGE = "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]";
+var init_cli_add_workspace_admin_view = __esm(() => {
+  init_cli_add_shared();
+  init_cli_add_workspace_admin_view_source();
+  init_cli_add_workspace_admin_view_scaffold();
+  init_cli_add_workspace_admin_view_types();
+  init_workspace_inventory();
+  init_workspace_project();
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
 import fs43 from "fs";
 import { promises as fsp19 } from "fs";
-import path52 from "path";
+import path53 from "path";
 import {
   syncBlockMetadata as syncBlockMetadata2
 } from "@wp-typia/block-runtime/metadata-core";
@@ -231690,7 +232384,7 @@ async function ensureBindingTargetBlockAttributeType(projectDir, block, target)
   if (!block.attributeTypeName) {
     throw new Error(`Workspace block "${block.slug}" must include attributeTypeName in scripts/block-config.ts before it can receive binding-source targets.`);
   }
-  const typesPath = path52.join(projectDir, block.typesFile);
+  const typesPath = path53.join(projectDir, block.typesFile);
   const source = await fsp19.readFile(typesPath, "utf8");
   const targetInterface = getInterfaceDeclaration(source, block.attributeTypeName);
   if (!targetInterface) {
@@ -231702,10 +232396,10 @@ async function ensureBindingTargetBlockAttributeType(projectDir, block, target)
     await fsp19.writeFile(typesPath, nextSource, "utf8");
   }
   await syncBlockMetadata2({
-    blockJsonFile: path52.join("src", "blocks", block.slug, "block.json"),
-    jsonSchemaFile: path52.join("src", "blocks", block.slug, "typia.schema.json"),
-    manifestFile: path52.join("src", "blocks", block.slug, "typia.manifest.json"),
-    openApiFile: path52.join("src", "blocks", block.slug, "typia.openapi.json"),
+    blockJsonFile: path53.join("src", "blocks", block.slug, "block.json"),
+    jsonSchemaFile: path53.join("src", "blocks", block.slug, "typia.schema.json"),
+    manifestFile: path53.join("src", "blocks", block.slug, "typia.manifest.json"),
+    openApiFile: path53.join("src", "blocks", block.slug, "typia.openapi.json"),
     projectRoot: projectDir,
     sourceTypeName: block.attributeTypeName,
     typesFile: block.typesFile
@@ -231944,7 +232638,7 @@ ${patternFunctions}
       }
     }
     if (!nextSource.includes(patternCategoryFunctionName) || !nextSource.includes(patternRegistrationFunctionName)) {
-      throw new Error(`Unable to inject pattern bootstrap functions into ${path52.basename(bootstrapPath)}.`);
+      throw new Error(`Unable to inject pattern bootstrap functions into ${path53.basename(bootstrapPath)}.`);
     }
     if (!nextSource.includes(patternCategoryHook)) {
       nextSource = `${nextSource.trimEnd()}
@@ -232132,7 +232826,7 @@ ${snippet}
       if (missingReferences.length > 0) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path52.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
+          throw new Error(`Unable to repair ${path53.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
         }
         nextSource = replacedSource;
       }
@@ -232144,7 +232838,7 @@ ${snippet}
   });
 }
 async function ensureEditorPluginBuildScriptAnchors(workspace) {
-  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path53.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/editor-plugins\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -232157,13 +232851,13 @@ async function ensureEditorPluginBuildScriptAnchors(workspace) {
 		'src/editor-plugins/index.js',
 	]`);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path52.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path53.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 async function ensureEditorPluginWebpackAnchors(workspace) {
-  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path53.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]editor-plugins\/index['"]/u.test(source)) {
       return source;
@@ -232191,17 +232885,17 @@ async function ensureEditorPluginWebpackAnchors(workspace) {
 	}`;
     const nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path52.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path53.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveBindingSourceRegistryPath(projectDir) {
-  const bindingsDir = path52.join(projectDir, "src", "bindings");
-  return [path52.join(bindingsDir, "index.ts"), path52.join(bindingsDir, "index.js")].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path52.join(bindingsDir, "index.ts");
+  const bindingsDir = path53.join(projectDir, "src", "bindings");
+  return [path53.join(bindingsDir, "index.ts"), path53.join(bindingsDir, "index.js")].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path53.join(bindingsDir, "index.ts");
 }
 async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
-  const bindingsDir = path52.join(projectDir, "src", "bindings");
+  const bindingsDir = path53.join(projectDir, "src", "bindings");
   const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
   await fsp19.mkdir(bindingsDir, { recursive: true });
   const existingBindingSourceSlugs = fs43.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -232209,11 +232903,11 @@ async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
   await fsp19.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
 }
 function resolveEditorPluginRegistryPath(projectDir) {
-  const editorPluginsDir = path52.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path53.join(projectDir, "src", "editor-plugins");
   return [
-    path52.join(editorPluginsDir, "index.ts"),
-    path52.join(editorPluginsDir, "index.js")
-  ].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path52.join(editorPluginsDir, "index.ts");
+    path53.join(editorPluginsDir, "index.ts"),
+    path53.join(editorPluginsDir, "index.js")
+  ].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path53.join(editorPluginsDir, "index.ts");
 }
 function readEditorPluginRegistrySlugs(registryPath) {
   if (!fs43.existsSync(registryPath)) {
@@ -232223,7 +232917,7 @@ function readEditorPluginRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
-  const editorPluginsDir = path52.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path53.join(projectDir, "src", "editor-plugins");
   const registryPath = resolveEditorPluginRegistryPath(projectDir);
   await fsp19.mkdir(editorPluginsDir, { recursive: true });
   const existingEditorPluginSlugs = readWorkspaceInventory(projectDir).editorPlugins.map((entry) => entry.slug);
@@ -232241,17 +232935,17 @@ async function runAddEditorPluginCommand({
   const resolvedSlot = assertValidEditorPluginSlot(slot);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertEditorPluginDoesNotExist(workspace.projectDir, editorPluginSlug, inventory);
-  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path53.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   const editorPluginsIndexPath = resolveEditorPluginRegistryPath(workspace.projectDir);
-  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
-  const editorPluginDir = path52.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
-  const entryFilePath = path52.join(editorPluginDir, "index.tsx");
-  const surfaceFilePath = path52.join(editorPluginDir, "Surface.tsx");
-  const dataFilePath = path52.join(editorPluginDir, "data.ts");
-  const typesFilePath = path52.join(editorPluginDir, "types.ts");
-  const styleFilePath = path52.join(editorPluginDir, "style.scss");
+  const webpackConfigPath = path53.join(workspace.projectDir, "webpack.config.js");
+  const editorPluginDir = path53.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
+  const entryFilePath = path53.join(editorPluginDir, "index.tsx");
+  const surfaceFilePath = path53.join(editorPluginDir, "Surface.tsx");
+  const dataFilePath = path53.join(editorPluginDir, "data.ts");
+  const typesFilePath = path53.join(editorPluginDir, "types.ts");
+  const styleFilePath = path53.join(editorPluginDir, "style.scss");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -232297,16 +232991,16 @@ async function runAddPatternCommand({
   const patternSlug = assertValidGeneratedSlug("Pattern name", normalizeBlockSlug(patternName), "wp-typia add pattern <name>");
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertPatternDoesNotExist(workspace.projectDir, patternSlug, inventory);
-  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const patternFilePath = path52.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
+  const patternFilePath = path53.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath]),
     snapshotDirs: [],
     targetPaths: [patternFilePath]
   };
   try {
-    await fsp19.mkdir(path52.dirname(patternFilePath), { recursive: true });
+    await fsp19.mkdir(path53.dirname(patternFilePath), { recursive: true });
     await ensurePatternBootstrapAnchors(workspace);
     await fsp19.writeFile(patternFilePath, buildPatternSource(patternSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -232336,18 +233030,18 @@ async function runAddBindingSourceCommand({
     blockName
   }, workspace.workspace.namespace);
   const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
-  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
-  const bindingSourceDir = path52.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-  const serverFilePath = path52.join(bindingSourceDir, "server.php");
-  const editorFilePath = path52.join(bindingSourceDir, "editor.ts");
-  const blockJsonPath = target ? path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
+  const bindingSourceDir = path53.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
+  const serverFilePath = path53.join(bindingSourceDir, "server.php");
+  const editorFilePath = path53.join(bindingSourceDir, "editor.ts");
+  const blockJsonPath = target ? path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
   const targetGeneratedMetadataPaths = target ? [
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
   ] : [];
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -232355,7 +233049,7 @@ async function runAddBindingSourceCommand({
       bootstrapPath,
       bindingsIndexPath,
       ...blockJsonPath ? [blockJsonPath] : [],
-      ...targetBlock ? [path52.join(workspace.projectDir, targetBlock.typesFile)] : [],
+      ...targetBlock ? [path53.join(workspace.projectDir, targetBlock.typesFile)] : [],
       ...targetGeneratedMetadataPaths
     ]),
     snapshotDirs: [],
@@ -232393,7 +233087,7 @@ var init_cli_add_workspace_assets = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-anchors.ts
-import path53 from "path";
+import path54 from "path";
 async function ensureRestResourceBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   await patchFile(bootstrapPath, (source) => {
@@ -232440,7 +233134,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(REST_RESOURCE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path53.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
+        `Unable to patch ${path54.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
         `The existing ${registerFunctionName}() definition does not include ${REST_RESOURCE_SERVER_GLOB}.`,
         "Restore the generated bootstrap shape or wire the REST resource loader manually before retrying."
       ].join(" "));
@@ -232454,7 +233148,7 @@ ${snippet}
 function assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureRestResourceSyncScriptAnchors could not patch ${path53.basename(syncRestScriptPath)}.`,
+      `ensureRestResourceSyncScriptAnchors could not patch ${path54.basename(syncRestScriptPath)}.`,
       `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
       "Restore the generated template or add the REST_RESOURCES wiring manually before retrying."
     ].join(" "));
@@ -232469,7 +233163,7 @@ function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureRestResourceSyncScriptAnchors(workspace) {
-  const syncRestScriptPath = path53.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path54.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = "import { BLOCKS, type WorkspaceBlockConfig } from './block-config';";
@@ -232591,7 +233285,7 @@ var init_cli_add_workspace_rest_anchors = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/rest-resource-artifacts.ts
-import path54 from "path";
+import path55 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest2,
   syncEndpointClient as syncEndpointClient2,
@@ -232727,8 +233421,8 @@ async function syncRestResourceArtifacts({
   const manifest = buildRestResourceEndpointManifest(variables, methods);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas2({
-      jsonSchemaFile: path54.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path54.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path55.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path55.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -232736,7 +233430,7 @@ async function syncRestResourceArtifacts({
   }
   await syncRestOpenApi2({
     manifest,
-    openApiFile: path54.join(outputDir, "api.openapi.json"),
+    openApiFile: path55.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   });
@@ -233138,7 +233832,7 @@ var init_cli_add_workspace_rest_source_emitters = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
 import { promises as fsp20 } from "fs";
-import path55 from "path";
+import path56 from "path";
 function buildRestResourceRouteRegistrations(restResourceSlug, methods, functions) {
   const collectionRoutes = [];
   const itemRoutes = [];
@@ -233568,15 +234262,15 @@ async function runAddRestResourceCommand({
   const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
-  const blockConfigPath = path55.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path56.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const syncRestScriptPath = path55.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const restResourceDir = path55.join(workspace.projectDir, "src", "rest", restResourceSlug);
-  const typesFilePath = path55.join(restResourceDir, "api-types.ts");
-  const validatorsFilePath = path55.join(restResourceDir, "api-validators.ts");
-  const apiFilePath = path55.join(restResourceDir, "api.ts");
-  const dataFilePath = path55.join(restResourceDir, "data.ts");
-  const phpFilePath = path55.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
+  const syncRestScriptPath = path56.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const restResourceDir = path56.join(workspace.projectDir, "src", "rest", restResourceSlug);
+  const typesFilePath = path56.join(restResourceDir, "api-types.ts");
+  const validatorsFilePath = path56.join(restResourceDir, "api-validators.ts");
+  const apiFilePath = path56.join(restResourceDir, "api.ts");
+  const dataFilePath = path56.join(restResourceDir, "data.ts");
+  const phpFilePath = path56.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -233588,7 +234282,7 @@ async function runAddRestResourceCommand({
   };
   try {
     await fsp20.mkdir(restResourceDir, { recursive: true });
-    await fsp20.mkdir(path55.dirname(phpFilePath), { recursive: true });
+    await fsp20.mkdir(path56.dirname(phpFilePath), { recursive: true });
     await ensureRestResourceBootstrapAnchors(workspace);
     await ensureRestResourceSyncScriptAnchors(workspace);
     await fsp20.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
@@ -233640,7 +234334,7 @@ var init_cli_add_workspace_rest = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
 import fs44 from "fs";
 import { promises as fsp21 } from "fs";
-import path56 from "path";
+import path57 from "path";
 import { syncTypeSchemas as syncTypeSchemas3 } from "@wp-typia/block-runtime/metadata-core";
 function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
   if (!existingVersion) {
@@ -234118,8 +234812,8 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `);
 }
 function resolveAbilityRegistryPath(projectDir) {
-  const abilitiesDir = path56.join(projectDir, "src", "abilities");
-  return [path56.join(abilitiesDir, "index.ts"), path56.join(abilitiesDir, "index.js")].find((candidatePath) => fs44.existsSync(candidatePath)) ?? path56.join(abilitiesDir, "index.ts");
+  const abilitiesDir = path57.join(projectDir, "src", "abilities");
+  return [path57.join(abilitiesDir, "index.ts"), path57.join(abilitiesDir, "index.js")].find((candidatePath) => fs44.existsSync(candidatePath)) ?? path57.join(abilitiesDir, "index.ts");
 }
 function readAbilityRegistrySlugs(registryPath) {
   if (!fs44.existsSync(registryPath)) {
@@ -234129,7 +234823,7 @@ function readAbilityRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeAbilityRegistry(projectDir, abilitySlug) {
-  const abilitiesDir = path56.join(projectDir, "src", "abilities");
+  const abilitiesDir = path57.join(projectDir, "src", "abilities");
   const registryPath = resolveAbilityRegistryPath(projectDir);
   await fsp21.mkdir(abilitiesDir, { recursive: true });
   const existingAbilitySlugs = readWorkspaceInventory(projectDir).abilities.map((entry) => entry.slug);
@@ -234261,7 +234955,7 @@ ${snippet}
   });
 }
 async function ensureAbilityPackageScripts(workspace) {
-  const packageJsonPath = path56.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path57.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp21.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
@@ -234269,8 +234963,8 @@ async function ensureAbilityPackageScripts(workspace) {
   };
   const nextDependencies = {
     ...packageJson.dependencies ?? {},
-    [WP_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_ABILITIES_SCRIPT_MODULE_ID], WP_ABILITIES_PACKAGE_VERSION),
-    [WP_CORE_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_CORE_ABILITIES_SCRIPT_MODULE_ID], WP_CORE_ABILITIES_PACKAGE_VERSION)
+    [WP_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_ABILITIES_SCRIPT_MODULE_ID], DEFAULT_WORDPRESS_ABILITIES_VERSION),
+    [WP_CORE_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_CORE_ABILITIES_SCRIPT_MODULE_ID], DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION)
   };
   if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {}) && JSON.stringify(nextDependencies) === JSON.stringify(packageJson.dependencies ?? {})) {
     return;
@@ -234281,7 +234975,7 @@ async function ensureAbilityPackageScripts(workspace) {
 `, "utf8");
 }
 async function ensureAbilitySyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path56.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path57.join(workspace.projectDir, "scripts", "sync-project.ts");
   await patchFile(syncProjectScriptPath, (source) => {
     let nextSource = source;
     const syncRestConst = "const syncRestScriptPath = path.join( 'scripts', 'sync-rest-contracts.ts' );";
@@ -234296,7 +234990,7 @@ async function ensureAbilitySyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAbilitiesConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path56.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path57.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest script constant in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-abilities manually before retrying."
         ].join(" "));
@@ -234307,7 +235001,7 @@ ${syncAbilitiesConst}`);
     if (!nextSource.includes("runSyncScript( syncAbilitiesScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path56.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path57.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest invocation block in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-abilities manually before retrying."
         ].join(" "));
@@ -234320,7 +235014,7 @@ ${syncAbilitiesBlock}`);
   });
 }
 async function ensureAbilityBuildScriptAnchors(workspace) {
-  const buildScriptPath = path56.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path57.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     let nextSource = source;
     if (/['"]src\/abilities\/index\.(?:ts|js)['"]/u.test(nextSource)) {
@@ -234330,7 +235024,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     const match3 = nextSource.match(sharedEntriesPattern);
     if (!match3 || !match3[2].includes("src/bindings/index.ts") || !match3[2].includes("src/editor-plugins/index.ts")) {
       throw new Error([
-        `ensureAbilityBuildScriptAnchors could not patch ${path56.basename(buildScriptPath)}.`,
+        `ensureAbilityBuildScriptAnchors could not patch ${path57.basename(buildScriptPath)}.`,
         "Missing the expected shared editor entries array in scripts/build-workspace.mjs.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
@@ -234347,7 +235041,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
   });
 }
 async function ensureAbilityWebpackAnchors(workspace) {
-  const webpackConfigPath = path56.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path57.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]abilities\/index['"]/u.test(source)) {
       return source;
@@ -234378,7 +235072,7 @@ $2`);
     const match3 = source.match(sharedEntriesPattern);
     if (!match3 || !match3[1].includes("bindings/index") || !match3[1].includes("editor-plugins/index")) {
       throw new Error([
-        `ensureAbilityWebpackAnchors could not patch ${path56.basename(webpackConfigPath)}.`,
+        `ensureAbilityWebpackAnchors could not patch ${path57.basename(webpackConfigPath)}.`,
         "Missing the expected shared editor entries block in webpack.config.js.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
@@ -234408,20 +235102,20 @@ async function runAddAbilityCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
-  const blockConfigPath = path56.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path57.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path56.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path56.join(workspace.projectDir, "package.json");
-  const syncAbilitiesScriptPath = path56.join(workspace.projectDir, "scripts", "sync-abilities.ts");
-  const syncProjectScriptPath = path56.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const webpackConfigPath = path56.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path57.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path57.join(workspace.projectDir, "package.json");
+  const syncAbilitiesScriptPath = path57.join(workspace.projectDir, "scripts", "sync-abilities.ts");
+  const syncProjectScriptPath = path57.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const webpackConfigPath = path57.join(workspace.projectDir, "webpack.config.js");
   const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
-  const abilityDir = path56.join(workspace.projectDir, "src", "abilities", abilitySlug);
-  const configFilePath = path56.join(abilityDir, "ability.config.json");
-  const typesFilePath = path56.join(abilityDir, "types.ts");
-  const dataFilePath = path56.join(abilityDir, "data.ts");
-  const clientFilePath = path56.join(abilityDir, "client.ts");
-  const phpFilePath = path56.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
+  const abilityDir = path57.join(workspace.projectDir, "src", "abilities", abilitySlug);
+  const configFilePath = path57.join(abilityDir, "ability.config.json");
+  const typesFilePath = path57.join(abilityDir, "types.ts");
+  const dataFilePath = path57.join(abilityDir, "data.ts");
+  const clientFilePath = path57.join(abilityDir, "client.ts");
+  const phpFilePath = path57.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -234438,7 +235132,7 @@ async function runAddAbilityCommand({
   };
   try {
     await fsp21.mkdir(abilityDir, { recursive: true });
-    await fsp21.mkdir(path56.dirname(phpFilePath), { recursive: true });
+    await fsp21.mkdir(path57.dirname(phpFilePath), { recursive: true });
     await ensureAbilityBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     await ensureAbilityPackageScripts(workspace);
@@ -234477,12 +235171,13 @@ async function runAddAbilityCommand({
     throw error48;
   }
 }
-var import_semver2, ABILITY_SERVER_GLOB = "/inc/abilities/*.php", ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end", ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start", WP_ABILITIES_PACKAGE_VERSION = "^0.10.0", WP_CORE_ABILITIES_PACKAGE_VERSION = "^0.9.0", WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities", WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
+var import_semver2, ABILITY_SERVER_GLOB = "/inc/abilities/*.php", ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end", ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start", WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities", WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
 var init_cli_add_workspace_ability = __esm(() => {
   init_workspace_inventory();
   init_workspace_project();
   init_cli_add_shared();
   init_scaffold_compatibility();
+  init_package_versions();
   import_semver2 = __toESM(require_semver2(), 1);
 });
 
@@ -234515,7 +235210,7 @@ var init_ai_artifacts = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/ai-feature-artifacts.ts
 import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path57 from "path";
+import path58 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest3,
   syncEndpointClient as syncEndpointClient3,
@@ -234528,7 +235223,7 @@ function normalizeGeneratedArtifactContent(content) {
 }
 async function reconcileGeneratedArtifact(options) {
   if (!options.check) {
-    await mkdir3(path57.dirname(options.filePath), {
+    await mkdir3(path58.dirname(options.filePath), {
       recursive: true
     });
     await writeFile5(options.filePath, options.content, "utf8");
@@ -234600,8 +235295,8 @@ async function syncAiFeatureRestArtifacts({
   const manifest = buildAiFeatureEndpointManifest(variables);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas4({
-      jsonSchemaFile: path57.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path57.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path58.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path58.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -234609,7 +235304,7 @@ async function syncAiFeatureRestArtifacts({
   }
   await syncRestOpenApi3({
     manifest,
-    openApiFile: path57.join(outputDir, "api.openapi.json"),
+    openApiFile: path58.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   }, executionOptions);
@@ -234627,19 +235322,19 @@ async function syncAiFeatureSchemaArtifact({
   outputDir,
   projectDir
 }) {
-  const sourceSchemaPath = path57.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
+  const sourceSchemaPath = path58.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
   const responseSchema = assertJsonObject(JSON.parse(await readFile5(sourceSchemaPath, "utf8")), sourceSchemaPath);
   const aiSchema = projectWordPressAiSchema(responseSchema);
   await reconcileGeneratedArtifact({
     check: check2,
     content: `${JSON.stringify(aiSchema, null, 2)}
 `,
-    filePath: path57.join(projectDir, aiSchemaFile),
+    filePath: path58.join(projectDir, aiSchemaFile),
     label: "AI feature schema"
   });
   return {
     aiSchema,
-    aiSchemaPath: path57.join(projectDir, aiSchemaFile),
+    aiSchemaPath: path58.join(projectDir, aiSchemaFile),
     check: check2,
     sourceSchemaPath
   };
@@ -234971,7 +235666,7 @@ var init_cli_add_workspace_ai_source_emitters = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-anchors.ts
 import { promises as fsp22 } from "fs";
-import path58 from "path";
+import path59 from "path";
 async function ensureAiFeatureBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   await patchFile(bootstrapPath, (source) => {
@@ -235018,7 +235713,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(AI_FEATURE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path58.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
+        `Unable to patch ${path59.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
         `The existing ${registerFunctionName}() definition does not include ${AI_FEATURE_SERVER_GLOB}.`,
         "Restore the generated bootstrap shape or wire the AI feature loader manually before retrying."
       ].join(" "));
@@ -235030,7 +235725,7 @@ ${snippet}
   });
 }
 async function ensureAiFeaturePackageScripts(workspace) {
-  const packageJsonPath = path58.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path59.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp22.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
@@ -235058,7 +235753,7 @@ async function ensureAiFeaturePackageScripts(workspace) {
   };
 }
 async function ensureAiFeatureSyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path58.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path59.join(workspace.projectDir, "scripts", "sync-project.ts");
   await patchFile(syncProjectScriptPath, (source) => {
     let nextSource = source;
     const syncRestConst = "const syncRestScriptPath = path.join( 'scripts', 'sync-rest-contracts.ts' );";
@@ -235073,7 +235768,7 @@ async function ensureAiFeatureSyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAiConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path58.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path59.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest script constant in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-ai manually before retrying."
         ].join(" "));
@@ -235084,7 +235779,7 @@ ${syncAiConst}`);
     if (!nextSource.includes("runSyncScript( syncAiScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path58.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path59.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest invocation block in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-ai manually before retrying."
         ].join(" "));
@@ -235099,7 +235794,7 @@ ${syncAiBlock}`);
 function assertSyncRestAnchor2(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureAiFeatureSyncRestAnchors could not patch ${path58.basename(syncRestScriptPath)}.`,
+      `ensureAiFeatureSyncRestAnchors could not patch ${path59.basename(syncRestScriptPath)}.`,
       `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
       "Restore the generated template or add the AI feature wiring manually before retrying."
     ].join(" "));
@@ -235114,7 +235809,7 @@ function replaceRequiredSyncRestSource2(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureAiFeatureSyncRestAnchors(workspace) {
-  const syncRestScriptPath = path58.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path59.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = [
@@ -235249,7 +235944,7 @@ var init_cli_add_workspace_ai_anchors = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
 import { promises as fsp23 } from "fs";
-import path59 from "path";
+import path60 from "path";
 function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
   const aiFeatureTitle = toTitleCase(aiFeatureSlug);
   const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
@@ -235638,18 +236333,18 @@ async function runAddAiFeatureCommand({
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
-  const blockConfigPath = path59.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const packageJsonPath = path59.join(workspace.projectDir, "package.json");
-  const syncAiScriptPath = path59.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
-  const syncProjectScriptPath = path59.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const syncRestScriptPath = path59.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const aiFeatureDir = path59.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
-  const typesFilePath = path59.join(aiFeatureDir, "api-types.ts");
-  const validatorsFilePath = path59.join(aiFeatureDir, "api-validators.ts");
-  const apiFilePath = path59.join(aiFeatureDir, "api.ts");
-  const dataFilePath = path59.join(aiFeatureDir, "data.ts");
-  const phpFilePath = path59.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
+  const packageJsonPath = path60.join(workspace.projectDir, "package.json");
+  const syncAiScriptPath = path60.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
+  const syncProjectScriptPath = path60.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncRestScriptPath = path60.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const aiFeatureDir = path60.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
+  const typesFilePath = path60.join(aiFeatureDir, "api-types.ts");
+  const validatorsFilePath = path60.join(aiFeatureDir, "api-validators.ts");
+  const apiFilePath = path60.join(aiFeatureDir, "api.ts");
+  const dataFilePath = path60.join(aiFeatureDir, "data.ts");
+  const phpFilePath = path60.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -235664,7 +236359,7 @@ async function runAddAiFeatureCommand({
   };
   try {
     await fsp23.mkdir(aiFeatureDir, { recursive: true });
-    await fsp23.mkdir(path59.dirname(phpFilePath), { recursive: true });
+    await fsp23.mkdir(path60.dirname(phpFilePath), { recursive: true });
     await ensureAiFeatureBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
@@ -235679,7 +236374,7 @@ async function runAddAiFeatureCommand({
     const pascalCase = toPascalCase(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
-      outputDir: path59.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path60.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir,
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
@@ -235692,7 +236387,7 @@ async function runAddAiFeatureCommand({
     });
     await syncAiFeatureSchemaArtifact({
       aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
-      outputDir: path59.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path60.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -235728,7 +236423,7 @@ var init_cli_add_workspace_ai = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
 import fs45 from "fs";
 import { promises as fsp24 } from "fs";
-import path60 from "path";
+import path61 from "path";
 function maskSourceSegment(segment) {
   return segment.replace(/[^\n\r]/gu, " ");
 }
@@ -236112,7 +236807,7 @@ ${VARIATIONS_CALL_LINE}
       }
     }
     if (!hasExecutablePattern(nextSource, VARIATIONS_CALL_PATTERN)) {
-      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path60.basename(blockIndexPath)}.`);
+      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path61.basename(blockIndexPath)}.`);
     }
     return nextSource;
   });
@@ -236142,7 +236837,7 @@ ${BLOCK_STYLES_CALL_LINE}
       }
     }
     if (!hasExecutablePattern(nextSource, BLOCK_STYLES_CALL_PATTERN)) {
-      throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path60.basename(blockIndexPath)}.`);
+      throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path61.basename(blockIndexPath)}.`);
     }
     return nextSource;
   });
@@ -236159,7 +236854,7 @@ ${nextSource}`;
         SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN
       ]);
       if (!callRange) {
-        throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path60.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
+        throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path61.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
       }
       nextSource = [
         nextSource.slice(0, callRange.start),
@@ -236172,42 +236867,42 @@ ${nextSource}`;
   });
 }
 async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
-  const variationsDir = path60.join(projectDir, "src", "blocks", blockSlug, "variations");
-  const variationsIndexPath = path60.join(variationsDir, "index.ts");
+  const variationsDir = path61.join(projectDir, "src", "blocks", blockSlug, "variations");
+  const variationsIndexPath = path61.join(variationsDir, "index.ts");
   await fsp24.mkdir(variationsDir, { recursive: true });
   const existingVariationSlugs = fs45.readdirSync(variationsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
   await fsp24.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
 async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
-  const stylesDir = path60.join(projectDir, "src", "blocks", blockSlug, "styles");
-  const stylesIndexPath = path60.join(stylesDir, "index.ts");
+  const stylesDir = path61.join(projectDir, "src", "blocks", blockSlug, "styles");
+  const stylesIndexPath = path61.join(stylesDir, "index.ts");
   await fsp24.mkdir(stylesDir, { recursive: true });
   const existingStyleSlugs = fs45.readdirSync(stylesDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextStyleSlugs = Array.from(new Set([...existingStyleSlugs, styleSlug])).sort();
   await fsp24.writeFile(stylesIndexPath, buildBlockStyleIndexSource(nextStyleSlugs), "utf8");
 }
 async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug) {
-  const transformsDir = path60.join(projectDir, "src", "blocks", blockSlug, "transforms");
-  const transformsIndexPath = path60.join(transformsDir, "index.ts");
+  const transformsDir = path61.join(projectDir, "src", "blocks", blockSlug, "transforms");
+  const transformsIndexPath = path61.join(transformsDir, "index.ts");
   await fsp24.mkdir(transformsDir, { recursive: true });
   const existingTransformSlugs = fs45.readdirSync(transformsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
   await fsp24.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
 function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  const stylePath = path60.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
+  const stylePath = path61.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
   if (fs45.existsSync(stylePath)) {
-    throw new Error(`A block style already exists at ${path60.relative(projectDir, stylePath)}. Choose a different name.`);
+    throw new Error(`A block style already exists at ${path61.relative(projectDir, stylePath)}. Choose a different name.`);
   }
   if (inventory.blockStyles.some((entry) => entry.block === blockSlug && entry.slug === styleSlug)) {
     throw new Error(`A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`);
   }
 }
 function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-  const transformPath = path60.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
+  const transformPath = path61.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
   if (fs45.existsSync(transformPath)) {
-    throw new Error(`A block transform already exists at ${path60.relative(projectDir, transformPath)}. Choose a different name.`);
+    throw new Error(`A block transform already exists at ${path61.relative(projectDir, transformPath)}. Choose a different name.`);
   }
   if (inventory.blockTransforms.some((entry) => entry.block === blockSlug && entry.slug === transformSlug)) {
     throw new Error(`A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`);
@@ -236253,11 +236948,11 @@ async function runAddVariationCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
-  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const variationsDir = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
-  const variationFilePath = path60.join(variationsDir, `${variationSlug}.ts`);
-  const variationsIndexPath = path60.join(variationsDir, "index.ts");
+  const blockConfigPath = path61.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const variationsDir = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
+  const variationFilePath = path61.join(variationsDir, `${variationSlug}.ts`);
+  const variationsIndexPath = path61.join(variationsDir, "index.ts");
   const shouldRemoveVariationsDirOnRollback = !fs45.existsSync(variationsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -236300,11 +236995,11 @@ async function runAddBlockStyleCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertBlockStyleDoesNotExist(workspace.projectDir, blockSlug, styleSlug, inventory);
-  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const stylesDir = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
-  const styleFilePath = path60.join(stylesDir, `${styleSlug}.ts`);
-  const stylesIndexPath = path60.join(stylesDir, "index.ts");
+  const blockConfigPath = path61.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const stylesDir = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
+  const styleFilePath = path61.join(stylesDir, `${styleSlug}.ts`);
+  const stylesIndexPath = path61.join(stylesDir, "index.ts");
   const shouldRemoveStylesDirOnRollback = !fs45.existsSync(stylesDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -236349,11 +237044,11 @@ async function runAddBlockTransformCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, target.blockSlug);
   assertBlockTransformDoesNotExist(workspace.projectDir, target.blockSlug, transformSlug, inventory);
-  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path60.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
-  const transformsDir = path60.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
-  const transformFilePath = path60.join(transformsDir, `${transformSlug}.ts`);
-  const transformsIndexPath = path60.join(transformsDir, "index.ts");
+  const blockConfigPath = path61.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path61.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
+  const transformsDir = path61.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
+  const transformFilePath = path61.join(transformsDir, `${transformSlug}.ts`);
+  const transformsIndexPath = path61.join(transformsDir, "index.ts");
   const shouldRemoveTransformsDirOnRollback = !fs45.existsSync(transformsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -236415,7 +237110,7 @@ async function runAddHookedBlockCommand({
     throw new Error("`wp-typia add hooked-block` cannot hook a block relative to its own block name.");
   }
   const { blockJson, blockJsonPath } = readWorkspaceBlockJson(workspace.projectDir, blockSlug);
-  const blockJsonRelativePath = path60.relative(workspace.projectDir, blockJsonPath);
+  const blockJsonRelativePath = path61.relative(workspace.projectDir, blockJsonPath);
   const blockHooks = getMutableBlockHooks(blockJson, blockJsonRelativePath);
   if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {
     throw new Error(`${blockJsonRelativePath} already defines a blockHooks entry for "${resolvedAnchorBlockName}".`);
@@ -236493,7 +237188,7 @@ import { execFileSync as execFileSync3 } from "child_process";
 import { access, constants as fsConstants, rm as rm2, writeFile as writeFile6 } from "fs/promises";
 import fs46 from "fs";
 import os5 from "os";
-import path61 from "path";
+import path62 from "path";
 function readCommandVersion(command, args = ["--version"]) {
   try {
     return execFileSync3(command, args, {
@@ -236517,7 +237212,7 @@ async function checkWritableDirectory(directory) {
   }
 }
 async function checkTempDirectory() {
-  const tempFile = path61.join(os5.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+  const tempFile = path62.join(os5.tmpdir(), `wp-typia-${Date.now()}.tmp`);
   try {
     await writeFile6(tempFile, "ok", "utf8");
     await rm2(tempFile, { force: true });
@@ -236534,7 +237229,7 @@ function getTemplateDoctorChecks() {
   for (const template of listTemplates()) {
     if (!isBuiltInTemplateId(template.id)) {
       const templateDirExists = fs46.existsSync(template.templateDir);
-      const hasAssets2 = templateDirExists && fs46.existsSync(path61.join(template.templateDir, "package.json.mustache"));
+      const hasAssets2 = templateDirExists && fs46.existsSync(path62.join(template.templateDir, "package.json.mustache"));
       checks3.push({
         status: !templateDirExists || hasAssets2 ? "pass" : "fail",
         label: `Template ${template.id}`,
@@ -236559,7 +237254,7 @@ function getTemplateDoctorChecks() {
     ])) : getBuiltInTemplateLayerDirs(builtInTemplateId);
     const missingRequiredLayer = layerDirs.some((layerDir) => !fs46.existsSync(layerDir) && !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
     const existingLayerDirs = layerDirs.filter((layerDir) => fs46.existsSync(layerDir));
-    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs46.existsSync(path61.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs46.existsSync(path61.join(layerDir, "src")));
+    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs46.existsSync(path62.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs46.existsSync(path62.join(layerDir, "src")));
     checks3.push({
       status: hasAssets ? "pass" : "fail",
       label: `Template ${template.id}`,
@@ -236590,7 +237285,7 @@ var init_cli_doctor_environment = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace.ts
 import fs47 from "fs";
-import path62 from "path";
+import path63 from "path";
 import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata2 } from "@wp-typia/block-runtime/blocks";
 function createDoctorCheck2(label, status, detail, code) {
   return code ? { code, detail, label, status } : { detail, label, status };
@@ -236660,7 +237355,7 @@ function hasExecutablePattern2(source, pattern) {
   return pattern.test(maskTypeScriptCommentsAndLiterals2(source));
 }
 function normalizePathSeparators(relativePath) {
-  return relativePath.split(path62.sep).join("/");
+  return relativePath.split(path63.sep).join("/");
 }
 function hasRegisteredBlockAsset(value2) {
   if (typeof value2 === "string") {
@@ -236672,8 +237367,8 @@ function hasRegisteredBlockAsset(value2) {
   return false;
 }
 function readWorkspaceBlockIframeMetadata(projectDir, blockSlug) {
-  const blockJsonRelativePath = path62.join("src", "blocks", blockSlug, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   if (!fs47.existsSync(blockJsonPath)) {
     return {
       blockJsonRelativePath,
@@ -236718,14 +237413,14 @@ function isWorkspaceBlockSaveSource(relativePath) {
   return fileName.replace(/\.[^.]+$/u, "").toLowerCase() === "save";
 }
 function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
-  const blockDir = path62.join(projectDir, "src", "blocks", blockSlug);
+  const blockDir = path63.join(projectDir, "src", "blocks", blockSlug);
   if (!fs47.existsSync(blockDir)) {
     return [];
   }
   const sources = [];
   const visitDirectory = (directory) => {
     for (const entry of fs47.readdirSync(directory, { withFileTypes: true })) {
-      const entryPath = path62.join(directory, entry.name);
+      const entryPath = path63.join(directory, entry.name);
       if (entry.isDirectory()) {
         visitDirectory(entryPath);
         continue;
@@ -236733,8 +237428,8 @@ function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
       if (!entry.isFile()) {
         continue;
       }
-      const relativePath = normalizePathSeparators(path62.relative(projectDir, entryPath));
-      const blockRelativePath = path62.relative(blockDir, entryPath);
+      const relativePath = normalizePathSeparators(path63.relative(projectDir, entryPath));
+      const blockRelativePath = path63.relative(blockDir, entryPath);
       if (!isWorkspaceBlockEditorSource(blockRelativePath)) {
         continue;
       }
@@ -236800,7 +237495,7 @@ function getWorkspaceBootstrapRelativePath(packageName) {
   return `${packageBaseName}.php`;
 }
 function checkExistingFiles(projectDir, label, filePaths) {
-  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs47.existsSync(path62.join(projectDir, filePath)));
+  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs47.existsSync(path63.join(projectDir, filePath)));
   return createDoctorCheck2(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
 }
 function checkWorkspacePackageMetadata(workspace, packageJson) {
@@ -236826,24 +237521,24 @@ function checkWorkspacePackageMetadata(workspace, packageJson) {
   if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
     issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
   }
-  if (!fs47.existsSync(path62.join(workspace.projectDir, bootstrapRelativePath))) {
+  if (!fs47.existsSync(path63.join(workspace.projectDir, bootstrapRelativePath))) {
     issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
   }
   return createDoctorCheck2("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}` : issues.join("; "));
 }
 function getWorkspaceBlockRequiredFiles(block) {
-  const blockDir = path62.join("src", "blocks", block.slug);
+  const blockDir = path63.join("src", "blocks", block.slug);
   return Array.from(new Set([
     block.typesFile,
     block.apiTypesFile,
     block.openApiFile,
-    path62.join(blockDir, "index.tsx"),
-    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path62.join(blockDir, fileName))
+    path63.join(blockDir, "index.tsx"),
+    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path63.join(blockDir, fileName))
   ].filter((filePath) => typeof filePath === "string")));
 }
 function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
-  const blockJsonRelativePath = path62.join("src", "blocks", block.slug, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", block.slug, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   if (!fs47.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
@@ -236864,8 +237559,8 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
   return createDoctorCheck2(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}` : issues.join("; "));
 }
 function checkWorkspaceBlockHooks(projectDir, blockSlug) {
-  const blockJsonRelativePath = path62.join("src", "blocks", blockSlug, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   if (!fs47.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
@@ -236887,8 +237582,8 @@ function checkWorkspaceBlockHooks(projectDir, blockSlug) {
   return createDoctorCheck2(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0 ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0 ? ` (${Object.keys(blockHooks).join(", ")})` : ""}` : `Invalid blockHooks entries: ${invalidEntries.map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`).join(", ")}`);
 }
 function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
-  const entryRelativePath = path62.join("src", "blocks", blockSlug, "index.tsx");
-  const entryPath = path62.join(projectDir, entryRelativePath);
+  const entryRelativePath = path63.join("src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, entryRelativePath);
   if (!fs47.existsSync(entryPath)) {
     return createDoctorCheck2(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
   }
@@ -236905,8 +237600,8 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
   }
   const blockJson = metadataResult.document;
   const apiVersion = typeof blockJson.apiVersion === "number" && Number.isFinite(blockJson.apiVersion) ? blockJson.apiVersion : null;
-  const blockDir = path62.join(projectDir, "src", "blocks", blockSlug);
-  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs47.existsSync(path62.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path62.join("src", "blocks", blockSlug, fileName)));
+  const blockDir = path63.join(projectDir, "src", "blocks", blockSlug);
+  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs47.existsSync(path63.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path63.join("src", "blocks", blockSlug, fileName)));
   const hasRegisteredEditorStyles = hasRegisteredBlockAsset(blockJson.style) || hasRegisteredBlockAsset(blockJson.editorStyle);
   const editorSources = collectWorkspaceBlockEditorSources(projectDir, blockSlug);
   const editorWrapperSources = editorSources.filter((source) => !isWorkspaceBlockSaveSource(source.relativePath));
@@ -236924,9 +237619,9 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
 }
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const hasCategoryAnchor = source.includes("register_block_pattern_category");
@@ -236935,9 +237630,9 @@ function checkWorkspacePatternBootstrap(projectDir, packageName) {
 }
 function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
@@ -236947,11 +237642,11 @@ function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   return createDoctorCheck2("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "Binding source PHP and editor bootstrap hooks are present" : "Missing binding source PHP require glob or editor enqueue hook");
 }
 function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
-  const indexRelativePath = [path62.join("src", "bindings", "index.ts"), path62.join("src", "bindings", "index.js")].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+  const indexRelativePath = [path63.join("src", "bindings", "index.ts"), path63.join("src", "bindings", "index.js")].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
   }
-  const indexPath = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.readFileSync(indexPath, "utf8");
   const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
   return createDoctorCheck2("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Binding source editor registrations are aggregated" : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
@@ -236968,8 +237663,8 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   if (!registeredBlockSlugs.has(bindingSource.block)) {
     return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", `Binding target references unknown block "${bindingSource.block}".`);
   }
-  const blockJsonRelativePath = path62.join("src", "blocks", bindingSource.block, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", bindingSource.block, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   const issues = [];
   try {
     const blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs47.readFileSync(blockJsonPath, "utf8")));
@@ -236985,7 +237680,7 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   } catch (error48) {
     issues.push(error48 instanceof Error ? `Unable to read ${blockJsonRelativePath}: ${error48.message}` : `Unable to read ${blockJsonRelativePath}.`);
   }
-  const serverPath = path62.join(projectDir, bindingSource.serverFile);
+  const serverPath = path63.join(projectDir, bindingSource.serverFile);
   if (fs47.existsSync(serverPath)) {
     const serverSource = fs47.readFileSync(serverPath, "utf8");
     const supportedAttributesFilter = `block_bindings_supported_attributes_${workspace.workspace.namespace}/${bindingSource.block}`;
@@ -236998,7 +237693,7 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   } else {
     issues.push(`Missing ${bindingSource.serverFile}`);
   }
-  const editorPath = path62.join(projectDir, bindingSource.editorFile);
+  const editorPath = path63.join(projectDir, bindingSource.editorFile);
   if (fs47.existsSync(editorPath)) {
     const editorSource = fs47.readFileSync(editorPath, "utf8");
     const blockName = `${workspace.workspace.namespace}/${bindingSource.block}`;
@@ -237046,7 +237741,7 @@ function getWorkspaceRestResourceRequiredFiles(restResource) {
   }
   return Array.from(new Set([
     restResource.apiFile,
-    ...Array.from(schemaNames, (schemaName) => path62.join(path62.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+    ...Array.from(schemaNames, (schemaName) => path63.join(path63.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
     restResource.clientFile,
     restResource.dataFile,
     restResource.openApiFile,
@@ -237062,9 +237757,9 @@ function checkWorkspaceRestResourceConfig(restResource) {
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_rest_resources`;
@@ -237085,7 +237780,7 @@ function getWorkspaceAbilityRequiredFiles(ability) {
   ]));
 }
 function checkWorkspaceAbilityConfig(projectDir, ability) {
-  const configPath = path62.join(projectDir, ability.configFile);
+  const configPath = path63.join(projectDir, ability.configFile);
   if (!fs47.existsSync(configPath)) {
     return createDoctorCheck2(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
   }
@@ -237102,9 +237797,9 @@ function checkWorkspaceAbilityConfig(projectDir, ability) {
 }
 function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
@@ -237123,13 +237818,13 @@ function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
 }
 function checkWorkspaceAbilityIndex(projectDir, abilities) {
   const indexRelativePath = [
-    path62.join("src", "abilities", "index.ts"),
-    path62.join("src", "abilities", "index.js")
-  ].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+    path63.join("src", "abilities", "index.ts"),
+    path63.join("src", "abilities", "index.js")
+  ].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
   }
-  const indexPath = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.readFileSync(indexPath, "utf8");
   const missingExports = abilities.filter((ability) => {
     const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex2(ability.slug)}\\/client['"\`]`, "mu");
@@ -237141,9 +237836,9 @@ function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
   return Array.from(new Set([
     aiFeature.aiSchemaFile,
     aiFeature.apiFile,
-    path62.join(path62.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
-    path62.join(path62.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
-    path62.join(path62.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
+    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
+    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
+    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
     aiFeature.clientFile,
     aiFeature.dataFile,
     aiFeature.openApiFile,
@@ -237158,9 +237853,9 @@ function checkWorkspaceAiFeatureConfig(aiFeature) {
 }
 function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_ai_features`;
@@ -237170,14 +237865,14 @@ function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   return createDoctorCheck2("AI feature bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook ? "AI feature PHP loader hook is present" : "Missing AI feature PHP require glob or init hook");
 }
 function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
-  const editorPluginDir = path62.join("src", "editor-plugins", editorPlugin.slug);
-  const surfaceFile = editorPlugin.slot === "PluginSidebar" ? path62.join(editorPluginDir, "Sidebar.tsx") : path62.join(editorPluginDir, "Surface.tsx");
+  const editorPluginDir = path63.join("src", "editor-plugins", editorPlugin.slug);
+  const surfaceFile = editorPlugin.slot === "PluginSidebar" ? path63.join(editorPluginDir, "Sidebar.tsx") : path63.join(editorPluginDir, "Surface.tsx");
   return Array.from(new Set([
     editorPlugin.file,
     surfaceFile,
-    path62.join(editorPluginDir, "data.ts"),
-    path62.join(editorPluginDir, "types.ts"),
-    path62.join(editorPluginDir, "style.scss")
+    path63.join(editorPluginDir, "data.ts"),
+    path63.join(editorPluginDir, "types.ts"),
+    path63.join(editorPluginDir, "style.scss")
   ]));
 }
 function checkWorkspaceEditorPluginConfig(editorPlugin) {
@@ -237187,9 +237882,9 @@ function checkWorkspaceEditorPluginConfig(editorPlugin) {
 }
 function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
@@ -237202,13 +237897,13 @@ function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix)
 }
 function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   const indexRelativePath = [
-    path62.join("src", "editor-plugins", "index.ts"),
-    path62.join("src", "editor-plugins", "index.js")
-  ].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+    path63.join("src", "editor-plugins", "index.ts"),
+    path63.join("src", "editor-plugins", "index.js")
+  ].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
   }
-  const indexPath = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.readFileSync(indexPath, "utf8");
   const missingImports = editorPlugins.filter((editorPlugin) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
@@ -237217,15 +237912,15 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   return createDoctorCheck2("Editor plugins index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Editor plugin registrations are aggregated" : `Missing editor plugin imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function getWorkspaceAdminViewRequiredFiles(adminView) {
-  const adminViewDir = path62.join("src", "admin-views", adminView.slug);
+  const adminViewDir = path63.join("src", "admin-views", adminView.slug);
   return Array.from(new Set([
     adminView.file,
     adminView.phpFile,
-    path62.join(adminViewDir, "Screen.tsx"),
-    path62.join(adminViewDir, "config.ts"),
-    path62.join(adminViewDir, "data.ts"),
-    path62.join(adminViewDir, "style.scss"),
-    path62.join(adminViewDir, "types.ts")
+    path63.join(adminViewDir, "Screen.tsx"),
+    path63.join(adminViewDir, "config.ts"),
+    path63.join(adminViewDir, "data.ts"),
+    path63.join(adminViewDir, "style.scss"),
+    path63.join(adminViewDir, "types.ts")
   ]));
 }
 function checkWorkspaceAdminViewConfig(adminView, inventory) {
@@ -237233,17 +237928,18 @@ function checkWorkspaceAdminViewConfig(adminView, inventory) {
     return createDoctorCheck2(`Admin view config ${adminView.slug}`, "pass", "Admin view uses a replaceable local fetcher");
   }
   const source = adminView.source.trim();
-  const sourceMatch = /^rest-resource:([a-z][a-z0-9-]*)$/u.exec(source);
-  const restResourceSlug = sourceMatch?.[1];
+  const restSourceMatch = /^rest-resource:([a-z][a-z0-9-]*)$/u.exec(source);
+  const coreDataSourceMatch = /^core-data:(postType|taxonomy)\/([a-z0-9][a-z0-9_-]*)$/u.exec(source);
+  const restResourceSlug = restSourceMatch?.[1];
   const restResource = restResourceSlug ? inventory.restResources.find((entry) => entry.slug === restResourceSlug) : undefined;
-  const isValid2 = Boolean(restResource?.methods.includes("list"));
-  return createDoctorCheck2(`Admin view config ${adminView.slug}`, isValid2 ? "pass" : "fail", isValid2 ? `Admin view source ${source} is list-capable` : "Admin view source must use rest-resource:<slug> and reference a list-capable REST resource");
+  const isValid2 = Boolean(restResource?.methods.includes("list")) || Boolean(coreDataSourceMatch);
+  return createDoctorCheck2(`Admin view config ${adminView.slug}`, isValid2 ? "pass" : "fail", isValid2 ? `Admin view source ${source} is list-capable` : "Admin view source must use rest-resource:<slug> with a list-capable REST resource or core-data:<postType|taxonomy>/<name>");
 }
 function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_admin_views`;
@@ -237254,13 +237950,13 @@ function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
 }
 function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
   const indexRelativePath = [
-    path62.join("src", "admin-views", "index.ts"),
-    path62.join("src", "admin-views", "index.js")
-  ].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+    path63.join("src", "admin-views", "index.ts"),
+    path63.join("src", "admin-views", "index.js")
+  ].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
   }
-  const indexPath = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.readFileSync(indexPath, "utf8");
   const missingImports = adminViews.filter((adminView) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(adminView.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
@@ -237269,7 +237965,7 @@ function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
   return createDoctorCheck2("Admin views index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Admin view registrations are aggregated" : `Missing admin view imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function checkWorkspaceAdminViewPhp(projectDir, adminView) {
-  const phpPath = path62.join(projectDir, adminView.phpFile);
+  const phpPath = path63.join(projectDir, adminView.phpFile);
   if (!fs47.existsSync(phpPath)) {
     return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
   }
@@ -237283,9 +237979,9 @@ function checkWorkspaceAdminViewPhp(projectDir, adminView) {
   return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, hasAdminMenu && hasAdminEnqueue && hasScript && hasAsset && hasStyle && hasComponentsStyleDependency ? "pass" : "fail", hasAdminMenu && hasAdminEnqueue && hasScript && hasAsset && hasStyle && hasComponentsStyleDependency ? "Admin menu, script, style, and wp-components style dependency are wired" : "Missing admin menu, enqueue hook, build/admin-views asset reference, or wp-components style dependency");
 }
 function checkVariationEntrypoint(projectDir, blockSlug) {
-  const entryPath = path62.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path62.relative(projectDir, entryPath)}`);
+    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
   }
   const source = fs47.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern2(source, WORKSPACE_VARIATIONS_IMPORT_PATTERN);
@@ -237293,9 +237989,9 @@ function checkVariationEntrypoint(projectDir, blockSlug) {
   return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Variations registration hook is present" : "Missing ./variations import or registerWorkspaceVariations() call");
 }
 function checkBlockStyleEntrypoint(projectDir, blockSlug) {
-  const entryPath = path62.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path62.relative(projectDir, entryPath)}`);
+    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
   }
   const source = fs47.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN);
@@ -237303,9 +237999,9 @@ function checkBlockStyleEntrypoint(projectDir, blockSlug) {
   return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block style registration hook is present" : "Missing ./styles import or registerWorkspaceBlockStyles() call");
 }
 function checkBlockTransformEntrypoint(projectDir, blockSlug) {
-  const entryPath = path62.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path62.relative(projectDir, entryPath)}`);
+    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
   }
   const source = fs47.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN);
@@ -237325,8 +238021,8 @@ function checkBlockTransformConfig(workspace, transform2) {
 }
 function checkMigrationWorkspaceHint(workspace, packageJson) {
   const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
-  const migrationConfigRelativePath = path62.join("src", "migrations", "config.ts");
-  const hasMigrationConfig = fs47.existsSync(path62.join(workspace.projectDir, migrationConfigRelativePath));
+  const migrationConfigRelativePath = path63.join("src", "migrations", "config.ts");
+  const hasMigrationConfig = fs47.existsSync(path63.join(workspace.projectDir, migrationConfigRelativePath));
   if (!hasMigrationScript && !hasMigrationConfig) {
     return null;
   }
@@ -237396,7 +238092,7 @@ function getWorkspaceDoctorChecks(cwd) {
     }
     for (const blockSlug of blockStyleTargetBlocks) {
       checks3.push(checkExistingFiles(workspace.projectDir, `Block style registry ${blockSlug}`, [
-        path62.join("src", "blocks", blockSlug, "styles", "index.ts")
+        path63.join("src", "blocks", blockSlug, "styles", "index.ts")
       ]));
       checks3.push(checkBlockStyleEntrypoint(workspace.projectDir, blockSlug));
     }
@@ -237412,11 +238108,11 @@ function getWorkspaceDoctorChecks(cwd) {
     }
     for (const blockSlug of blockTransformTargetBlocks) {
       checks3.push(checkExistingFiles(workspace.projectDir, `Block transform registry ${blockSlug}`, [
-        path62.join("src", "blocks", blockSlug, "transforms", "index.ts")
+        path63.join("src", "blocks", blockSlug, "transforms", "index.ts")
       ]));
       checks3.push(checkBlockTransformEntrypoint(workspace.projectDir, blockSlug));
     }
-    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs47.existsSync(path62.join(workspace.projectDir, "src", "patterns"));
+    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs47.existsSync(path63.join(workspace.projectDir, "src", "patterns"));
     if (shouldCheckPatternBootstrap) {
       checks3.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
     }
@@ -237584,13 +238280,13 @@ __export(exports_cli_init, {
 });
 import fs48 from "fs";
 import { promises as fsp25 } from "fs";
-import path63 from "path";
+import path64 from "path";
 import { analyzeSourceTypes } from "@wp-typia/block-runtime/metadata-parser";
 function normalizeRelativePath2(value2) {
   return value2.replace(/\\/gu, "/");
 }
 function readProjectPackageJson(projectDir) {
-  const packageJsonPath = path63.join(projectDir, "package.json");
+  const packageJsonPath = path64.join(projectDir, "package.json");
   if (!fs48.existsSync(packageJsonPath)) {
     return null;
   }
@@ -237606,13 +238302,13 @@ function inferInitPackageManager(projectDir, packageJson) {
   if (packageJson?.packageManager) {
     return parseWorkspacePackageManagerId(packageJson.packageManager);
   }
-  if (fs48.existsSync(path63.join(projectDir, "bun.lock")) || fs48.existsSync(path63.join(projectDir, "bun.lockb"))) {
+  if (fs48.existsSync(path64.join(projectDir, "bun.lock")) || fs48.existsSync(path64.join(projectDir, "bun.lockb"))) {
     return "bun";
   }
-  if (fs48.existsSync(path63.join(projectDir, "pnpm-lock.yaml"))) {
+  if (fs48.existsSync(path64.join(projectDir, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs48.existsSync(path63.join(projectDir, "yarn.lock")) || fs48.existsSync(path63.join(projectDir, ".yarnrc.yml"))) {
+  if (fs48.existsSync(path64.join(projectDir, "yarn.lock")) || fs48.existsSync(path64.join(projectDir, ".yarnrc.yml"))) {
     return "yarn";
   }
   return "npm";
@@ -237696,13 +238392,13 @@ function buildPackageManagerFieldChange(packageJson, packageManager, options = {
   };
 }
 function buildGeneratedArtifactPaths(blockJsonFile, manifestFile) {
-  const manifestDir = path63.dirname(manifestFile);
+  const manifestDir = path64.dirname(manifestFile);
   const artifactPaths = [
     blockJsonFile,
     manifestFile,
-    path63.join(manifestDir, "typia.schema.json"),
-    path63.join(manifestDir, "typia-validator.php"),
-    path63.join(manifestDir, "typia.openapi.json")
+    path64.join(manifestDir, "typia.schema.json"),
+    path64.join(manifestDir, "typia-validator.php"),
+    path64.join(manifestDir, "typia.openapi.json")
   ];
   return Array.from(new Set(artifactPaths.map((filePath) => normalizeRelativePath2(filePath))));
 }
@@ -237723,7 +238419,7 @@ function isObjectLikeSourceType(projectDir, typesFile, sourceTypeName) {
   return analyzedTypes[sourceTypeName]?.kind === "object";
 }
 function inferRetrofitAttributeTypeName(projectDir, block) {
-  const typesPath = path63.join(projectDir, block.typesFile);
+  const typesPath = path64.join(projectDir, block.typesFile);
   const typesSource = fs48.readFileSync(typesPath, "utf8");
   const blockNameSegments = block.blockName.split("/");
   const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
@@ -238029,10 +238725,10 @@ function hasExistingWpTypiaProjectSurface(projectDir, packageJson) {
   const scripts = packageJson?.scripts ?? {};
   const hasSyncSurface = typeof scripts.sync === "string" || typeof scripts["sync-types"] === "string";
   const hasHelperFiles = [
-    path63.join("scripts", "block-config.ts"),
-    path63.join("scripts", "sync-project.ts"),
-    path63.join("scripts", "sync-types-to-block-json.ts")
-  ].every((relativePath) => fs48.existsSync(path63.join(projectDir, relativePath)));
+    path64.join("scripts", "block-config.ts"),
+    path64.join("scripts", "sync-project.ts"),
+    path64.join("scripts", "sync-types-to-block-json.ts")
+  ].every((relativePath) => fs48.existsSync(path64.join(projectDir, relativePath)));
   const hasRuntimeDeps = typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-runtime") === "string" && typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-types") === "string";
   return hasSyncSurface && hasHelperFiles && hasRuntimeDeps;
 }
@@ -238042,17 +238738,17 @@ function buildPlannedFiles(projectDir, layoutKind) {
   }
   return [
     {
-      action: fs48.existsSync(path63.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
+      action: fs48.existsSync(path64.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
       path: "scripts/block-config.ts",
       purpose: "Declare the current retrofit block targets so sync-types can regenerate metadata from the existing TypeScript source of truth."
     },
     {
-      action: fs48.existsSync(path63.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
+      action: fs48.existsSync(path64.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
       path: "scripts/sync-types-to-block-json.ts",
       purpose: "Generate block.json and Typia metadata artifacts from the current TypeScript source of truth."
     },
     {
-      action: fs48.existsSync(path63.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
+      action: fs48.existsSync(path64.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
       path: "scripts/sync-project.ts",
       purpose: "Provide one shared sync entrypoint that can grow into sync-rest or workspace-aware refresh steps later."
     }
@@ -238200,13 +238896,13 @@ function buildProjectPackageJsonSource(packageJson) {
 }
 function buildRetrofitHelperFiles(blockTargets) {
   return {
-    [path63.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
-    [path63.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
-    [path63.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
+    [path64.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
+    [path64.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
+    [path64.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
   };
 }
 async function createRetrofitMutationSnapshot(projectDir, filePaths) {
-  const scriptsDir = path63.join(projectDir, "scripts");
+  const scriptsDir = path64.join(projectDir, "scripts");
   const scriptsDirExisted = fs48.existsSync(scriptsDir);
   const fileSources = await snapshotWorkspaceFiles(filePaths);
   const targetPaths = fileSources.filter((entry) => entry.source === null).map((entry) => entry.filePath);
@@ -238221,11 +238917,11 @@ async function createRetrofitMutationSnapshot(projectDir, filePaths) {
 }
 async function writeRetrofitFiles(options) {
   const helperFiles = buildRetrofitHelperFiles(options.blockTargets);
-  const scriptsDir = path63.join(options.projectDir, "scripts");
+  const scriptsDir = path64.join(options.projectDir, "scripts");
   await fsp25.mkdir(scriptsDir, { recursive: true });
-  await fsp25.writeFile(path63.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
+  await fsp25.writeFile(path64.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
   for (const [relativePath, source] of Object.entries(helperFiles)) {
-    await fsp25.writeFile(path63.join(options.projectDir, relativePath), source, "utf8");
+    await fsp25.writeFile(path64.join(options.projectDir, relativePath), source, "utf8");
   }
 }
 function buildApplyFailureError(error48) {
@@ -238233,7 +238929,7 @@ function buildApplyFailureError(error48) {
   return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to apply the retrofit init plan safely. The command restored the previous package.json/helper-file snapshot. ${message}`, error48 instanceof Error ? { cause: error48 } : undefined);
 }
 function getInitPlan(projectDir, options = {}) {
-  const resolvedProjectDir = path63.resolve(projectDir);
+  const resolvedProjectDir = path64.resolve(projectDir);
   const packageJson = readProjectPackageJson(resolvedProjectDir);
   const packageManager = resolveInitPackageManager(resolvedProjectDir, packageJson, options.packageManager);
   const workspace = tryResolveWorkspaceProject(resolvedProjectDir);
@@ -238269,7 +238965,7 @@ function getInitPlan(projectDir, options = {}) {
       status: "already-initialized"
     });
   }
-  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path63.basename(resolvedProjectDir);
+  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path64.basename(resolvedProjectDir);
   const layout = buildLayoutDetails(resolvedProjectDir);
   const dependencyChanges = buildDependencyChanges(packageJson);
   const scriptChanges = buildScriptChanges(packageJson, packageManager);
@@ -238335,8 +239031,8 @@ async function applyInitPlan(projectDir, options = {}) {
   });
   const helperFiles = buildRetrofitHelperFiles(previewPlan.blockTargets);
   const filePaths = [
-    path63.join(previewPlan.projectDir, "package.json"),
-    ...Object.keys(helperFiles).map((relativePath) => path63.join(previewPlan.projectDir, relativePath))
+    path64.join(previewPlan.projectDir, "package.json"),
+    ...Object.keys(helperFiles).map((relativePath) => path64.join(previewPlan.projectDir, relativePath))
   ];
   const mutationSnapshot = await createRetrofitMutationSnapshot(previewPlan.projectDir, filePaths);
   try {
@@ -238400,18 +239096,18 @@ __export(exports_cli_scaffold, {
 });
 import fs49 from "fs";
 import { promises as fsp26 } from "fs";
-import path64 from "path";
+import path65 from "path";
 async function listRelativeProjectFiles(rootDir) {
   const relativeFiles = [];
   async function visit2(currentDir) {
     const entries = await fsp26.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = path64.join(currentDir, entry.name);
+      const absolutePath = path65.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         await visit2(absolutePath);
         continue;
       }
-      relativeFiles.push(path64.relative(rootDir, absolutePath).replace(path64.sep === "\\" ? /\\/gu : /\//gu, "/"));
+      relativeFiles.push(path65.relative(rootDir, absolutePath).replace(path65.sep === "\\" ? /\\/gu : /\//gu, "/"));
     }
   }
   await visit2(rootDir);
@@ -238449,7 +239145,7 @@ async function buildScaffoldDryRunPlan({
 }) {
   await assertDryRunTargetDirectoryReady(projectDir, allowExistingDir);
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-scaffold-plan-");
-  const previewProjectDir = path64.join(tempRoot, "preview-project");
+  const previewProjectDir = path65.join(tempRoot, "preview-project");
   try {
     const result = await scaffoldProject({
       allowExistingDir: false,
@@ -238489,14 +239185,14 @@ function validateCreateProjectInput(projectInput) {
   if (normalizedProjectInput.length === 0) {
     throw new Error("Project directory is required. Usage: wp-typia create <project-dir> (or wp-typia <project-dir> when <project-dir> is the only positional argument).");
   }
-  const normalizedProjectPath = path64.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path64.normalize(normalizedProjectInput);
+  const normalizedProjectPath = path65.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path65.normalize(normalizedProjectInput);
   if (normalizedProjectPath === "." || normalizedProjectPath === "..") {
     throw new Error("`wp-typia create` requires a new project directory. Use an explicit child directory instead of `.` or `..`.");
   }
 }
 function collectProjectDirectoryWarnings(projectDir) {
   const warnings = [];
-  const projectName = path64.basename(projectDir);
+  const projectName = path65.basename(projectDir);
   if (/\s/u.test(projectName)) {
     warnings.push(`Project directory "${projectName}" contains spaces. The generated next-step commands will be quoted, but a simple kebab-case directory name is usually easier to use with shells and downstream tooling.`);
   }
@@ -238651,7 +239347,7 @@ function getNextSteps({
   noInstall,
   templateId
 }) {
-  const cdTarget = path64.isAbsolute(projectInput) ? projectDir : projectInput;
+  const cdTarget = path65.isAbsolute(projectInput) ? projectDir : projectInput;
   const steps = [`cd ${quoteShellValue(cdTarget)}`];
   if (noInstall) {
     steps.push(formatInstallCommand(packageManager));
@@ -238799,8 +239495,8 @@ async function runScaffoldFlow({
       select: selectWithMigrationUi,
       yes
     });
-    const projectDir = path64.resolve(cwd, projectInput);
-    const projectName = path64.basename(projectDir);
+    const projectDir = path65.resolve(cwd, projectInput);
+    const projectName = path65.basename(projectDir);
     const answers = await collectScaffoldAnswers({
       dataStorageMode: resolvedDataStorage,
       namespace,
@@ -238863,7 +239559,7 @@ async function runScaffoldFlow({
     let availableScripts;
     if (!dryRun) {
       try {
-        const parsedPackageJson = JSON.parse(fs49.readFileSync(path64.join(projectDir, "package.json"), "utf8"));
+        const parsedPackageJson = JSON.parse(fs49.readFileSync(path65.join(projectDir, "package.json"), "utf8"));
         const scripts = parsedPackageJson.scripts && typeof parsedPackageJson.scripts === "object" && !Array.isArray(parsedPackageJson.scripts) ? parsedPackageJson.scripts : {};
         availableScripts = Object.entries(scripts).filter(([, value2]) => typeof value2 === "string").map(([scriptName]) => scriptName);
       } catch {
@@ -291720,7 +292416,7 @@ var ADD_OPTION_METADATA = {
     type: "string"
   },
   source: {
-    description: "Optional data source locator for admin-view workflows, such as rest-resource:products.",
+    description: "Optional data source locator for admin-view workflows, such as rest-resource:products or core-data:postType/post.",
     type: "string"
   },
   template: {
@@ -291780,6 +292476,12 @@ var MIGRATE_OPTION_METADATA = {
     type: "string"
   }
 };
+var MCP_OPTION_METADATA = {
+  "output-dir": {
+    description: "Output directory for generated MCP metadata.",
+    type: "string"
+  }
+};
 var SYNC_OPTION_METADATA = {
   check: {
     argumentKind: "flag",
@@ -291817,10 +292519,6 @@ var GLOBAL_OPTION_METADATA = {
   id: {
     description: "Template id for top-level `templates inspect` convenience.",
     type: "string"
-  },
-  "output-dir": {
-    description: "Output directory for generated MCP metadata.",
-    type: "string"
   }
 };
 var COMMAND_OPTION_METADATA_BY_GROUP = {
@@ -291830,6 +292528,7 @@ var COMMAND_OPTION_METADATA_BY_GROUP = {
   global: GLOBAL_OPTION_METADATA,
   init: INIT_OPTION_METADATA,
   migrate: MIGRATE_OPTION_METADATA,
+  mcp: MCP_OPTION_METADATA,
   sync: SYNC_OPTION_METADATA,
   templates: TEMPLATES_OPTION_METADATA
 };
@@ -291906,13 +292605,17 @@ function resolveCommandOptionValues(metadata2, options) {
 
 // src/cli-diagnostic-output.ts
 init_cli_diagnostics();
+function writeStructuredCliJsonToStderr(payload) {
+  process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+}
 function prefersStructuredCliOutput(args) {
   return args.formatExplicit && args.format !== "toon" || Boolean(args.agent) || Boolean(args.context?.store?.isAIAgent);
 }
 function emitCliDiagnosticFailure(args, options) {
   const diagnostic = createCliCommandError(options);
   if (prefersStructuredCliOutput(args)) {
-    args.output({
+    writeStructuredCliJsonToStderr({
       ...options.extraOutput ?? {},
       error: serializeCliDiagnosticError(diagnostic),
       ok: false
@@ -291962,6 +292665,24 @@ init_cli_diagnostics();
 
 // src/add-kind-registry.ts
 init_cli_diagnostics();
+
+// src/add-kind-ids.ts
+var ADD_KIND_IDS = [
+  "admin-view",
+  "block",
+  "variation",
+  "style",
+  "transform",
+  "pattern",
+  "binding-source",
+  "rest-resource",
+  "ability",
+  "ai-feature",
+  "hooked-block",
+  "editor-plugin"
+];
+
+// src/add-kind-registry.ts
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
   "name",
@@ -291971,6 +292692,54 @@ var BLOCK_VISIBLE_FIELD_ORDER = [
   "data-storage",
   "persistence-policy"
 ];
+var NAME_ONLY_VISIBLE_FIELDS = [
+  "kind",
+  "name"
+];
+var NAME_SOURCE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "source"
+];
+var NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "block",
+  "attribute"
+];
+var NAME_BLOCK_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "block"
+];
+var NAME_SLOT_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "slot"
+];
+var NAME_ANCHOR_POSITION_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "anchor",
+  "position"
+];
+var NAME_FROM_TO_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "from",
+  "to"
+];
+var NAME_NAMESPACE_METHODS_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "namespace",
+  "methods"
+];
+var NAME_NAMESPACE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "namespace"
+];
 function readOptionalStringFlag(flags2, name2) {
   const value2 = flags2[name2];
   if (value2 === undefined || value2 === null) {
@@ -291981,6 +292750,21 @@ function readOptionalStringFlag(flags2, name2) {
   }
   return value2;
 }
+function requireStringFlag(flags2, name2, message) {
+  const value2 = readOptionalStringFlag(flags2, name2);
+  if (!value2) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return value2;
+}
+function readOptionalPairedStringFlags(flags2, leftName, rightName, message) {
+  const leftValue = readOptionalStringFlag(flags2, leftName);
+  const rightValue = readOptionalStringFlag(flags2, rightName);
+  if (Boolean(leftValue) !== Boolean(rightValue)) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return [leftValue, rightValue];
+}
 function requireAddKindName(context, message) {
   if (!context.name) {
     throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
@@ -292004,6 +292788,15 @@ function toExternalLayerPromptOptions(options) {
 function defineAddKindRegistryEntry(entry) {
   return entry;
 }
+function createNamedExecutionPlan(context, options) {
+  const name2 = options.name ?? requireAddKindName(context, options.missingNameMessage);
+  return {
+    execute: (cwd) => options.execute({ cwd, name: name2 }),
+    getValues: options.getValues,
+    ...options.getWarnings ? { getWarnings: options.getWarnings } : {},
+    ...options.warnLine ? { warnLine: options.warnLine } : {}
+  };
+}
 function isAddPersistenceTemplate(template) {
   return template === "persistence" || template === "compound";
 }
@@ -292024,24 +292817,26 @@ var ADD_KIND_REGISTRY = {
     description: "Add an opt-in DataViews-powered admin screen",
     nameLabel: "Admin view name",
     async prepareExecution(context) {
-      const name2 = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug>].");
+      const name2 = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
       const source = readOptionalStringFlag(context.flags, "source");
-      return {
-        execute: (cwd) => context.addRuntime.runAddAdminViewCommand({
-          adminViewName: name2,
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddAdminViewCommand({
+          adminViewName: name3,
           cwd,
           source
         }),
         getValues: (result) => ({
           adminViewSlug: result.adminViewSlug,
           ...result.source ? { source: result.source } : {}
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].",
+        name: name2
+      });
     },
     sortOrder: 10,
     supportsDryRun: true,
-    usage: "wp-typia add admin-view <name> [--source <rest-resource:slug>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "source"]
+    usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
+    visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
   }),
   "binding-source": defineAddKindRegistryEntry({
     completion: {
@@ -292063,15 +292858,11 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Binding source name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
-      const blockName = readOptionalStringFlag(context.flags, "block");
-      const attributeName = readOptionalStringFlag(context.flags, "attribute");
-      if (Boolean(blockName) !== Boolean(attributeName)) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddBindingSourceCommand({
+      const [blockName, attributeName] = readOptionalPairedStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBindingSourceCommand({
           attributeName,
-          bindingSourceName: name2,
+          bindingSourceName: name3,
           blockName,
           cwd
         }),
@@ -292079,13 +292870,15 @@ var ADD_KIND_REGISTRY = {
           ...result.attributeName ? { attributeName: result.attributeName } : {},
           ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
           bindingSourceSlug: result.bindingSourceSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].",
+        name: name2
+      });
     },
     sortOrder: 70,
     supportsDryRun: true,
     usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "block", "attribute"]
+    visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
   }),
   block: defineAddKindRegistryEntry({
     completion: {
@@ -292123,10 +292916,10 @@ var ADD_KIND_REGISTRY = {
         })), 1);
       }
       resolvedTemplateId ??= "basic";
-      return {
-        execute: (cwd) => context.addRuntime.runAddBlockCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockCommand({
           alternateRenderTargets,
-          blockName: name2,
+          blockName: name3,
           cwd,
           dataStorageMode,
           externalLayerId,
@@ -292141,8 +292934,10 @@ var ADD_KIND_REGISTRY = {
           templateId: result.templateId
         }),
         getWarnings: (result) => result.warnings,
+        missingNameMessage: "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]",
+        name: name2,
         warnLine: context.warnLine
-      };
+      });
     },
     sortOrder: 20,
     supportsDryRun: true,
@@ -292175,21 +292970,21 @@ var ADD_KIND_REGISTRY = {
     description: "Add a typed server/client workflow ability scaffold",
     nameLabel: "Ability name",
     async prepareExecution(context) {
-      const name2 = requireAddKindName(context, "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.");
-      return {
-        execute: (cwd) => context.addRuntime.runAddAbilityCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAbilityCommand({
           abilityName: name2,
           cwd
         }),
         getValues: (result) => ({
           abilitySlug: result.abilitySlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>."
+      });
     },
     sortOrder: 90,
     supportsDryRun: true,
     usage: "wp-typia add ability <name> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name"]
+    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
   }),
   "editor-plugin": defineAddKindRegistryEntry({
     completion: {
@@ -292209,22 +293004,24 @@ var ADD_KIND_REGISTRY = {
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
       const slot = readOptionalStringFlag(context.flags, "slot");
-      return {
-        execute: (cwd) => context.addRuntime.runAddEditorPluginCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddEditorPluginCommand({
           cwd,
-          editorPluginName: name2,
+          editorPluginName: name3,
           slot
         }),
         getValues: (result) => ({
           editorPluginSlug: result.editorPluginSlug,
           slot: result.slot
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].",
+        name: name2
+      });
     },
     sortOrder: 120,
     supportsDryRun: true,
     usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "slot"]
+    visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
   }),
   "hooked-block": defineAddKindRegistryEntry({
     completion: {
@@ -292244,18 +293041,12 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Target block",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
-      const anchorBlockName = readOptionalStringFlag(context.flags, "anchor");
-      if (!anchorBlockName) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-      }
-      const position = readOptionalStringFlag(context.flags, "position");
-      if (!position) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddHookedBlockCommand({
+      const anchorBlockName = requireStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+      const position = requireStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddHookedBlockCommand({
           anchorBlockName,
-          blockName: name2,
+          blockName: name3,
           cwd,
           position
         }),
@@ -292263,13 +293054,15 @@ var ADD_KIND_REGISTRY = {
           anchorBlockName: result.anchorBlockName,
           blockSlug: result.blockSlug,
           position: result.position
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.",
+        name: name2
+      });
     },
     sortOrder: 110,
     supportsDryRun: true,
     usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "anchor", "position"]
+    visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
   }),
   pattern: defineAddKindRegistryEntry({
     completion: {
@@ -292286,21 +293079,21 @@ var ADD_KIND_REGISTRY = {
     description: "Add a PHP block pattern shell",
     nameLabel: "Pattern name",
     async prepareExecution(context) {
-      const name2 = requireAddKindName(context, "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.");
-      return {
-        execute: (cwd) => context.addRuntime.runAddPatternCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddPatternCommand({
           cwd,
           patternName: name2
         }),
         getValues: (result) => ({
           patternSlug: result.patternSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>."
+      });
     },
     sortOrder: 60,
     supportsDryRun: true,
     usage: "wp-typia add pattern <name> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name"]
+    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
   }),
   style: defineAddKindRegistryEntry({
     completion: {
@@ -292319,26 +293112,25 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Style name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
-      const blockSlug = readOptionalStringFlag(context.flags, "block");
-      if (!blockSlug) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add style` requires --block <block-slug>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddBlockStyleCommand({
+      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockStyleCommand({
           blockName: blockSlug,
           cwd,
-          styleName: name2
+          styleName: name3
         }),
         getValues: (result) => ({
           blockSlug: result.blockSlug,
           styleSlug: result.styleSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.",
+        name: name2
+      });
     },
     sortOrder: 40,
     supportsDryRun: true,
     usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "block"]
+    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
   }),
   transform: defineAddKindRegistryEntry({
     completion: {
@@ -292358,33 +293150,29 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Transform name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
-      const fromBlockName = readOptionalStringFlag(context.flags, "from");
-      if (!fromBlockName) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add transform` requires --from <namespace/block>.");
-      }
-      const toBlockName = readOptionalStringFlag(context.flags, "to");
-      if (!toBlockName) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddBlockTransformCommand({
+      const fromBlockName = requireStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
+      const toBlockName = requireStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockTransformCommand({
           cwd,
           fromBlockName,
           toBlockName,
-          transformName: name2
+          transformName: name3
         }),
         getValues: (result) => ({
           blockSlug: result.blockSlug,
           fromBlockName: result.fromBlockName,
           toBlockName: result.toBlockName,
           transformSlug: result.transformSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.",
+        name: name2
+      });
     },
     sortOrder: 50,
     supportsDryRun: true,
     usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "from", "to"]
+    visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
   }),
   "rest-resource": defineAddKindRegistryEntry({
     completion: {
@@ -292406,24 +293194,26 @@ var ADD_KIND_REGISTRY = {
       const name2 = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
       const methods = readOptionalStringFlag(context.flags, "methods");
       const namespace = readOptionalStringFlag(context.flags, "namespace");
-      return {
-        execute: (cwd) => context.addRuntime.runAddRestResourceCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddRestResourceCommand({
           cwd,
           methods,
           namespace,
-          restResourceName: name2
+          restResourceName: name3
         }),
         getValues: (result) => ({
           methods: result.methods.join(", "),
           namespace: result.namespace,
           restResourceSlug: result.restResourceSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].",
+        name: name2
+      });
     },
     sortOrder: 80,
     supportsDryRun: true,
     usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "namespace", "methods"]
+    visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
   }),
   "ai-feature": defineAddKindRegistryEntry({
     completion: {
@@ -292443,9 +293233,9 @@ var ADD_KIND_REGISTRY = {
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
       const namespace = readOptionalStringFlag(context.flags, "namespace");
-      return {
-        execute: (cwd) => context.addRuntime.runAddAiFeatureCommand({
-          aiFeatureName: name2,
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddAiFeatureCommand({
+          aiFeatureName: name3,
           cwd,
           namespace
         }),
@@ -292454,13 +293244,15 @@ var ADD_KIND_REGISTRY = {
           namespace: result.namespace
         }),
         getWarnings: (result) => result.warnings,
+        missingNameMessage: "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].",
+        name: name2,
         warnLine: context.warnLine
-      };
+      });
     },
     sortOrder: 100,
     supportsDryRun: true,
     usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "namespace"]
+    visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
   }),
   variation: defineAddKindRegistryEntry({
     completion: {
@@ -292479,29 +293271,27 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Variation name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
-      const blockSlug = readOptionalStringFlag(context.flags, "block");
-      if (!blockSlug) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add variation` requires --block <block-slug>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddVariationCommand({
+      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddVariationCommand({
           blockName: blockSlug,
           cwd,
-          variationName: name2
+          variationName: name3
         }),
         getValues: (result) => ({
           blockSlug: result.blockSlug,
           variationSlug: result.variationSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
+        name: name2
+      });
     },
     sortOrder: 30,
     supportsDryRun: true,
     usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "block"]
+    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
   })
 };
-var ADD_KIND_IDS = Object.keys(ADD_KIND_REGISTRY).sort((left, right) => ADD_KIND_REGISTRY[left].sortOrder - ADD_KIND_REGISTRY[right].sortOrder);
 function isAddKindId(value2) {
   return typeof value2 === "string" && ADD_KIND_IDS.includes(value2);
 }
@@ -292659,7 +293449,7 @@ import path10 from "path";
 // package.json
 var package_default2 = {
   name: "wp-typia",
-  version: "0.21.0",
+  version: "0.22.1",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -292729,7 +293519,7 @@ var package_default2 = {
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/project-tools": "0.21.0",
+    "@wp-typia/project-tools": "0.22.1",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -292899,19 +293689,33 @@ function buildStructuredCompletionSuccessPayload(command, completion, metadata2
       command,
       ...serializedCompletion ? {
         completion: serializedCompletion,
-        files: extractPlannedFiles(serializedCompletion),
-        nextSteps: serializedCompletion.nextSteps,
-        optionalLines: serializedCompletion.optionalLines,
-        optionalNote: serializedCompletion.optionalNote,
-        optionalTitle: serializedCompletion.optionalTitle,
-        preambleLines: serializedCompletion.preambleLines,
-        summaryLines: serializedCompletion.summaryLines,
-        title: serializedCompletion.title,
-        warnings: serializedCompletion.warningLines
+        files: extractPlannedFiles(serializedCompletion)
       } : {}
     }
   };
 }
+function buildStructuredInitSuccessPayload(plan) {
+  const completion = serializeCompletionPayload(buildInitCompletionPayload(plan));
+  const files = Array.from(new Set([
+    ...plan.plannedFiles.map((filePlan) => filePlan.path),
+    ...plan.commandMode === "preview-only" ? plan.generatedArtifacts : []
+  ]));
+  return {
+    ok: true,
+    data: {
+      command: "init",
+      completion,
+      detectedLayout: plan.detectedLayout,
+      files: toNonEmptyArray(files),
+      mode: plan.commandMode === "apply" ? "apply" : "preview",
+      packageManager: plan.packageManager,
+      plan,
+      projectDir: plan.projectDir,
+      status: plan.status,
+      summary: plan.summary
+    }
+  };
+}
 function formatCreateProgressLine(payload, markerOptions) {
   return formatOutputMarker("progress", `${payload.title}: ${payload.detail}`, markerOptions);
 }
@@ -294361,7 +295165,7 @@ var initCommand = defineCommand({
         projectDir: args.positional[0]
       }, { emitOutput: !prefersStructuredOutput });
       if (prefersStructuredOutput) {
-        args.output({ init: plan });
+        args.output(buildStructuredInitSuccessPayload(plan));
       }
     } catch (error48) {
       emitCliDiagnosticFailure(args, {
@@ -294380,7 +295184,7 @@ init_cli_diagnostics();
 
 // src/mcp.ts
 import fs50 from "fs/promises";
-import path65 from "path";
+import path66 from "path";
 
 // ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
 class SchemaConversionError extends TaggedError("SchemaConversionError")() {
@@ -294908,7 +295712,7 @@ function isToolGroup(value2) {
   return isObject3(value2) && typeof value2.namespace === "string" && Array.isArray(value2.tools) && value2.tools.every(isTool);
 }
 async function readSchemaSource(cwd, source) {
-  const schemaPath = path65.resolve(cwd, source.path);
+  const schemaPath = path66.resolve(cwd, source.path);
   const raw = await fs50.readFile(schemaPath, "utf8");
   const parsed = JSON.parse(raw);
   if (isToolGroup(parsed)) {
@@ -294925,7 +295729,7 @@ async function readSchemaSource(cwd, source) {
 async function loadMcpToolGroups(cwd, schemaSources) {
   return Promise.all(schemaSources.map((source) => readSchemaSource(cwd, source)));
 }
-async function syncMcpSchemas(cwd, schemaSources, outputDir = path65.join(cwd, ".bunli", "mcp")) {
+async function syncMcpSchemas(cwd, schemaSources, outputDir = path66.join(cwd, ".bunli", "mcp")) {
   const groups = await loadMcpToolGroups(cwd, schemaSources);
   const result = await generateMCPTypes({
     outputDir,
@@ -294948,7 +295752,7 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path65.join(cwd, "
     }
   }
   await fs50.mkdir(outputDir, { recursive: true });
-  await fs50.writeFile(path65.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
+  await fs50.writeFile(path66.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
 `, "utf8");
   return {
     commandCount: registry2.reduce((count, group) => count + group.tools.length, 0),
@@ -295009,7 +295813,9 @@ var mcpCommand = defineCommand({
       emitCliDiagnosticFailure(args, {
         code: CLI_DIAGNOSTIC_CODES.INVALID_COMMAND,
         command: "mcp",
-        detailLines: [`Unknown mcp subcommand "${subcommand}". Expected list or sync.`]
+        detailLines: [
+          `Unknown mcp subcommand "${subcommand}". Expected list or sync.`
+        ]
       });
     } catch (error48) {
       emitCliDiagnosticFailure(args, {
@@ -295019,12 +295825,7 @@ var mcpCommand = defineCommand({
     }
   },
   name: "mcp",
-  options: {
-    "output-dir": {
-      description: "Output directory for generated MCP metadata during `mcp sync`.",
-      schema: exports_external.string().optional()
-    }
-  }
+  options: buildCommandOptions(MCP_OPTION_METADATA)
 });
 var mcp_default = mcpCommand;
 
@@ -295270,4 +296071,4 @@ export {
   cli
 };
 
-//# debugId=BEEA7448AE2433F864756E2164756E21
+//# debugId=7FC90D52A694344264756E2164756E21