wp-typia 0.20.5 → 0.22.0

package/dist-bunli/{cli-add-6byyahb8.js → cli-add-kjhghdqq.js}

@@ -20,13 +20,19 @@ import {
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-j1tyw390.js";
+} from "./cli-1w5vkye4.js";
 import {
+  DEFAULT_WORDPRESS_ABILITIES_VERSION,
+  DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
+  DEFAULT_WORDPRESS_CORE_DATA_VERSION,
+  DEFAULT_WORDPRESS_DATAVIEWS_VERSION,
+  DEFAULT_WORDPRESS_DATA_VERSION,
+  DEFAULT_WP_TYPIA_DATAVIEWS_VERSION,
   getPackageVersions
-} from "./cli-tesygdnr.js";
+} from "./cli-39er8888.js";
 import {
   snapshotProjectVersion
-} from "./cli-2rev5hqm.js";
+} from "./cli-e623rs7g.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
@@ -39,6 +45,7 @@ import {
 } from "./cli-sj5mtyzj.js";
 import"./cli-10pe4mf8.js";
 import {
+  PROJECT_TOOLS_PACKAGE_ROOT,
   SHARED_WORKSPACE_TEMPLATE_ROOT
 } from "./cli-tke8twkn.js";
 import {
@@ -47,6 +54,7 @@ import {
   EDITOR_PLUGIN_SLOT_IDS,
   appendWorkspaceInventoryEntries,
   assertAbilityDoesNotExist,
+  assertAdminViewDoesNotExist,
   assertAiFeatureDoesNotExist,
   assertBindingSourceDoesNotExist,
   assertEditorPluginDoesNotExist,
@@ -59,28 +67,40 @@ import {
   assertValidRestResourceMethods,
   assertVariationDoesNotExist,
   buildWorkspacePhpPrefix,
+  escapeRegex,
+  findPhpFunctionRange,
   formatAddHelpText,
   getMutableBlockHooks,
   getWorkspaceBlockSelectOptions,
   getWorkspaceBootstrapPath,
+  hasPhpFunctionDefinition,
   isAddBlockTemplateId,
   normalizeBlockSlug,
   patchFile,
+  quotePhpString,
   quoteTsString,
   readOptionalFile,
   readWorkspaceBlockJson,
   readWorkspaceInventory,
+  replacePhpFunctionDefinition,
+  require_typescript,
   resolveNonEmptyNormalizedBlockSlug,
   resolveRestResourceNamespace,
   resolveWorkspaceBlock,
   rollbackWorkspaceMutation,
   snapshotWorkspaceFiles,
   toKebabCase,
+  toPascalCase,
+  toSnakeCase,
   toTitleCase
-} from "./cli-3w3qxq9w.js";
+} from "./cli-j180bk07.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
+import {
+  CLI_DIAGNOSTIC_CODES,
+  createCliDiagnosticCodeError
+} from "./cli-p95wr1q8.js";
 import {
   resolveWorkspaceProject
 } from "./cli-pd5pqgre.js";
@@ -669,104 +689,1462 @@ async function runAddBlockCommand({
     externalLayerSource: normalizedExternalLayerSource,
     selectExternalLayerId
   });
-  let tempRoot = "";
-  let cleanupTempRoot;
+  let tempRoot = "";
+  let cleanupTempRoot;
+  try {
+    const normalizedSlug = resolveNonEmptyNormalizedBlockSlug({
+      input: blockName,
+      label: "Block name",
+      usage: "wp-typia add block <name> --template <family>"
+    });
+    const defaults = getDefaultAnswers(normalizedSlug, resolvedTemplateId);
+    ({
+      path: tempRoot,
+      cleanup: cleanupTempRoot
+    } = await createManagedTempRoot("wp-typia-add-block-"));
+    const tempProjectDir = path3.join(tempRoot, normalizedSlug);
+    const blockConfigPath = path3.join(workspace.projectDir, "scripts", "block-config.ts");
+    const migrationConfigPath = path3.join(workspace.projectDir, "src", "migrations", "config.ts");
+    const blockPhpPrefix = buildWorkspacePhpPrefix(workspace.workspace.phpPrefix, normalizedSlug);
+    const migrationConfigSource = await readOptionalFile(migrationConfigPath);
+    const migrationConfig = migrationConfigSource === null ? null : parseMigrationConfig(migrationConfigSource);
+    const compoundSupportPaths = resolvedTemplateId === "compound" ? COMPOUND_SHARED_SUPPORT_FILES.map((fileName) => path3.join(workspace.projectDir, "src", fileName)) : [];
+    const legacyCompoundValidatorPaths = resolvedTemplateId === "compound" ? await collectLegacyCompoundValidatorPaths(workspace.projectDir) : [];
+    const result = await (async () => {
+      const scaffoldResult = await scaffoldProject({
+        alternateRenderTargets,
+        answers: {
+          ...defaults,
+          author: workspace.author,
+          compoundInnerBlocksPreset: resolvedInnerBlocksPreset,
+          namespace: workspace.workspace.namespace,
+          phpPrefix: blockPhpPrefix,
+          slug: normalizedSlug,
+          textDomain: workspace.workspace.textDomain,
+          title: defaults.title
+        },
+        cwd: workspace.projectDir,
+        dataStorageMode,
+        externalLayerId: resolvedExternalLayerSelection.externalLayerId,
+        externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
+        externalLayerSourceLabel: normalizedExternalLayerSource,
+        noInstall: true,
+        packageManager: workspace.packageManager,
+        persistencePolicy,
+        projectDir: tempProjectDir,
+        templateId: resolvedTemplateId
+      });
+      await assertAddBlockSupportsExternalLayerOutputs({
+        callerCwd: cwd,
+        externalLayerId: resolvedExternalLayerSelection.externalLayerId,
+        externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
+        templateId: resolvedTemplateId,
+        variables: scaffoldResult.variables
+      });
+      return scaffoldResult;
+    })();
+    assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
+    const mutationSnapshot = {
+      fileSources: await snapshotWorkspaceFiles([
+        blockConfigPath,
+        migrationConfigPath,
+        ...compoundSupportPaths,
+        ...legacyCompoundValidatorPaths
+      ]),
+      snapshotDirs: migrationConfig === null ? [] : buildMigrationBlocks(resolvedTemplateId, result.variables).map((block) => path3.join(workspace.projectDir, ...migrationConfig.snapshotDir.split("/"), migrationConfig.currentMigrationVersion, block.key)),
+      targetPaths: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables)
+    };
+    try {
+      await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables, legacyCompoundValidatorPaths);
+      await addCollectionImportsForTemplate(workspace.projectDir, resolvedTemplateId, result.variables);
+      await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" || resolvedTemplateId === "compound" && result.variables.compoundPersistenceEnabled === "true");
+      await syncWorkspaceAddedBlockArtifacts(workspace.projectDir, resolvedTemplateId, result.variables);
+      await updateWorkspaceMigrationConfigIfPresent(workspace.projectDir, buildMigrationBlocks(resolvedTemplateId, result.variables));
+      return {
+        blockSlugs: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables).map((targetPath) => path3.basename(targetPath)),
+        projectDir: workspace.projectDir,
+        templateId: resolvedTemplateId,
+        warnings: result.warnings
+      };
+    } catch (error) {
+      await rollbackWorkspaceMutation(mutationSnapshot);
+      throw error;
+    }
+  } finally {
+    try {
+      await resolvedExternalLayerSelection.cleanup?.();
+    } finally {
+      await cleanupTempRoot?.();
+    }
+  }
+}
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
+import fs6 from "fs";
+import { promises as fsp9 } from "fs";
+import path13 from "path";
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
+import fs3 from "fs";
+import { promises as fsp3 } from "fs";
+import { createRequire } from "module";
+import path4 from "path";
+var ADMIN_VIEW_REST_SOURCE_KIND = "rest-resource";
+var ADMIN_VIEW_CORE_DATA_SOURCE_KIND = "core-data";
+var ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS = ["postType", "taxonomy"];
+var ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
+var ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/u;
+var ADMIN_VIEW_SOURCE_USAGE = "wp-typia add admin-view <name> --source <rest-resource:slug|core-data:kind/name>";
+var ADMIN_VIEWS_SCRIPT = "build/admin-views/index.js";
+var ADMIN_VIEWS_ASSET = "build/admin-views/index.asset.php";
+var ADMIN_VIEWS_STYLE = "build/admin-views/style-index.css";
+var ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css";
+var ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php";
+var ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = "WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS";
+var ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false;
+var require2 = createRequire(import.meta.url);
+function toCamelCase(input) {
+  const pascalCase = toPascalCase(input);
+  return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
+}
+function normalizeVersionRange(value, fallback) {
+  const trimmed = value?.trim();
+  if (!trimmed || trimmed.startsWith("workspace:")) {
+    return fallback;
+  }
+  return /^[~^<>=]/u.test(trimmed) ? trimmed : `^${trimmed}`;
+}
+function readPackageManifest(packageJsonPath) {
+  try {
+    return JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return;
+  }
+}
+function readPackageManifestVersion(packageJsonPath) {
+  return readPackageManifest(packageJsonPath)?.version;
+}
+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 resolvePackageVersionRange(packageName, fallback, workspacePackageDirName) {
+  if (workspacePackageDirName) {
+    const workspaceVersion = readPackageManifestVersion(path4.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", workspacePackageDirName, "package.json"));
+    if (workspaceVersion) {
+      return normalizeVersionRange(workspaceVersion, fallback);
+    }
+  }
+  try {
+    return normalizeVersionRange(readPackageManifestVersion(require2.resolve(`${packageName}/package.json`)), fallback);
+  } catch {
+    return fallback;
+  }
+}
+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 = path4.posix.relative(adminViewDir, modulePath);
+  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
+}
+function isAdminViewCoreDataSource(source) {
+  return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
+}
+function isAdminViewRestResourceSource(source) {
+  return source?.kind === ADMIN_VIEW_REST_SOURCE_KIND;
+}
+function assertValidCoreDataEntitySegment(label, value) {
+  const trimmed = value.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 assertValidCoreDataEntityName(value) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`Admin view source entity name is required. Use \`${ADMIN_VIEW_SOURCE_USAGE}\`.`);
+  }
+  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 assertValidCoreDataEntityKind(value) {
+  const normalized = assertValidCoreDataEntitySegment("Admin view source entity kind", value);
+  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 formatAdminViewSourceLocator(source) {
+  if (isAdminViewCoreDataSource(source)) {
+    return `${source.kind}:${source.entityKind}/${source.entityName}`;
+  }
+  return `${source.kind}:${source.slug}`;
+}
+function parseAdminViewSource(source) {
+  const trimmed = source?.trim();
+  if (!trimmed) {
+    return;
+  }
+  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>`.");
+  }
+  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 (!isAdminViewRestResourceSource(source)) {
+    return;
+  }
+  const restResource = restResources.find((entry) => entry.slug === source.slug);
+  if (!restResource) {
+    throw new Error(`Unknown REST resource source "${source.slug}". Choose one of: ${restResources.map((entry) => entry.slug).join(", ") || "<none>"}.`);
+  }
+  if (!restResource.methods.includes("list")) {
+    throw new Error(`REST resource source "${source.slug}" must include the list method for DataViews pagination.`);
+  }
+  return restResource;
+}
+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(formatAdminViewSourceLocator(source))},` : null,
+    "\t},"
+  ].filter((line) => typeof line === "string").join(`
+`);
+}
+function buildAdminViewRegistrySource(adminViewSlugs) {
+  const importLines = adminViewSlugs.map((adminViewSlug) => `import './${adminViewSlug}';`).join(`
+`);
+  return `${importLines}${importLines ? `
+
+` : ""}// wp-typia add admin-view entries
+`;
+}
+function buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const coreDataRecordTypeName = `${pascalName}CoreDataRecord`;
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  if (restResource) {
+    const restPascalName = toPascalCase(restResource.slug);
+    const restTypesModule = getAdminViewRelativeModuleSpecifier(adminViewSlug, restResource.typesFile);
+    return `import type { ${restPascalName}Record } from ${quoteTsString(restTypesModule)};
+
+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: {
+		totalItems: number;
+		totalPages: number;
+	};
+}
+`;
+  }
+  return `export type ${pascalName}AdminViewStatus = 'draft' | 'published';
+
+export interface ${itemTypeName} {
+	id: number;
+	owner: string;
+	status: ${pascalName}AdminViewStatus;
+	title: string;
+	updatedAt: string;
+}
+
+export interface ${dataSetTypeName} {
+	items: ${itemTypeName}[];
+	paginationInfo: {
+		totalItems: number;
+		totalPages: number;
+	};
+}
+`;
+}
+function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const camelName = toCamelCase(adminViewSlug);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  const isCoreDataSource = source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
+  const isTaxonomyCoreDataSource = source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND && 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 ? "" : isTaxonomyCoreDataSource ? `	titleField: 'name',
+` : `	titleField: 'title',
+`;
+  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." : 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' },
+		},
+		status: {
+			filterBy: { operators: ['isAny', 'isNone'] },
+			label: __( 'Status', ${quoteTsString(textDomain)} ),
+			schema: {
+				enum: ['draft', 'published'],
+				enumLabels: {
+					draft: __( 'Draft', ${quoteTsString(textDomain)} ),
+					published: __( 'Published', ${quoteTsString(textDomain)} ),
+				},
+				type: 'string',
+			},
+		},
+		title: {
+			enableGlobalSearch: true,
+			enableSorting: true,
+			label: __( 'Title', ${quoteTsString(textDomain)} ),
+			schema: { type: 'string' },
+		},
+		updatedAt: {
+			enableSorting: true,
+			label: __( 'Updated', ${quoteTsString(textDomain)} ),
+			schema: { format: 'date-time', type: 'string' },
+			type: 'datetime',
+		},`;
+  return `import { defineDataViews } from '@wp-typia/dataviews';
+import { __ } from '@wordpress/i18n';
+
+import type { ${itemTypeName} } from './types';
+
+export const ${dataViewsName} = defineDataViews<${itemTypeName}>({
+	idField: 'id',
+	search: ${searchEnabled},
+	searchLabel: __( 'Search records', ${quoteTsString(textDomain)} ),
+${titleFieldSource}
+	defaultView: {
+		fields: ${defaultViewFields},
+		page: 1,
+		perPage: 10,
+${defaultViewEnhancementsSource}
+		type: 'table',
+	},
+	fields: {
+		id: {
+			enableHiding: false,
+			label: __( 'ID', ${quoteTsString(textDomain)} ),
+			readOnly: true,
+			schema: { type: 'integer' },
+		},
+${additionalFieldsSource}
+	},
+});
+`;
+}
+function buildDefaultAdminViewDataSource(adminViewSlug) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const camelName = toCamelCase(adminViewSlug);
+  const title = toTitleCase(adminViewSlug);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  const queryTypeName = `${pascalName}AdminViewQuery`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  const fetchName = `fetch${pascalName}AdminViewData`;
+  return `import type { DataViewsView } from '@wp-typia/dataviews';
+
+import { ${dataViewsName} } from './config';
+import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
+
+export interface ${queryTypeName} {
+	page?: number;
+	perPage?: number;
+	search?: string;
+}
+
+const STARTER_ITEMS: ${itemTypeName}[] = [
+	{
+		id: 1,
+		owner: 'Editorial',
+		status: 'published',
+		title: ${quoteTsString(`${title} launch checklist`)},
+		updatedAt: '2026-04-01T10:30:00Z',
+	},
+	{
+		id: 2,
+		owner: 'Design',
+		status: 'draft',
+		title: ${quoteTsString(`${title} content refresh`)},
+		updatedAt: '2026-04-03T14:15:00Z',
+	},
+	{
+		id: 3,
+		owner: 'Operations',
+		status: 'published',
+		title: ${quoteTsString(`${title} support handoff`)},
+		updatedAt: '2026-04-08T08:45:00Z',
+	},
+];
+
+function matchesSearch(item: ${itemTypeName}, search: string | undefined): boolean {
+	if (!search) {
+		return true;
+	}
+
+	const needle = search.toLowerCase();
+	return [item.title, item.owner, item.status].some((value) =>
+		value.toLowerCase().includes(needle),
+	);
+}
+
+export async function ${fetchName}(
+	view: DataViewsView<${itemTypeName}>,
+): Promise<${dataSetTypeName}> {
+	const query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
+		perPageParam: 'perPage',
+	});
+	const requestedPage = query.page ?? 1;
+	const page = requestedPage > 0 ? requestedPage : 1;
+	const requestedPerPage = query.perPage ?? view.perPage ?? 10;
+	const perPage = requestedPerPage > 0 ? requestedPerPage : 10;
+	const filteredItems = STARTER_ITEMS.filter((item) =>
+		matchesSearch(item, query.search),
+	);
+	const offset = (page - 1) * perPage;
+	const items = filteredItems.slice(offset, offset + perPage);
+
+	return {
+		items,
+		paginationInfo: {
+			totalItems: filteredItems.length,
+			totalPages: Math.max(1, Math.ceil(filteredItems.length / perPage)),
+		},
+	};
+}
+`;
+}
+function buildRestAdminViewDataSource(adminViewSlug, restResource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const restPascalName = toPascalCase(restResource.slug);
+  const camelName = toCamelCase(adminViewSlug);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  const fetchName = `fetch${pascalName}AdminViewData`;
+  const restApiModule = getAdminViewRelativeModuleSpecifier(adminViewSlug, restResource.apiFile);
+  const restTypesModule = getAdminViewRelativeModuleSpecifier(adminViewSlug, restResource.typesFile);
+  return `import type { DataViewsView } from '@wp-typia/dataviews';
+
+import { listResource } from ${quoteTsString(restApiModule)};
+import type { ${restPascalName}ListQuery } from ${quoteTsString(restTypesModule)};
+import { ${dataViewsName} } from './config';
+import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
+
+function resolveTotalPages(total: number, perPage: number | undefined): number {
+	const resolvedPerPage = perPage && perPage > 0 ? perPage : 1;
+	return Math.max(1, Math.ceil(total / resolvedPerPage));
+}
+
+export async function ${fetchName}(
+	view: DataViewsView<${itemTypeName}>,
+): Promise<${dataSetTypeName}> {
+	const query = ${dataViewsName}.toQueryArgs<${restPascalName}ListQuery>(view, {
+		perPageParam: 'perPage',
+		searchParam: false,
+	});
+	const result = await listResource({
+		page: query.page,
+		perPage: query.perPage,
+	});
+	if (!result.isValid || !result.data) {
+		throw new Error('Unable to load REST resource records.');
+	}
+
+	const response = result.data;
+
+	return {
+		items: response.items,
+		paginationInfo: {
+			totalItems: response.total,
+			totalPages: resolveTotalPages(response.total, response.perPage ?? query.perPage),
+		},
+	};
+}
+`;
+}
+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);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  const componentName = `${pascalName}AdminViewScreen`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  const fetchName = `fetch${pascalName}AdminViewData`;
+  const title = toTitleCase(adminViewSlug);
+  return `import type { DataViewsConfig, DataViewsView } from '@wp-typia/dataviews';
+import { Button, Notice, Spinner } from '@wordpress/components';
+import { useEffect, useState } from '@wordpress/element';
+import { __ } from '@wordpress/i18n';
+import { DataViews } from '@wordpress/dataviews/wp';
+
+import { ${dataViewsName} } from './config';
+import { ${fetchName} } 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, setDataSet] = useState<${dataSetTypeName}>(EMPTY_DATA_SET);
+	const [error, setError] = useState<string | null>(null);
+	const [isLoading, setIsLoading] = useState(true);
+	const [reloadToken, setReloadToken] = useState(0);
+
+	useEffect(() => {
+		let isCurrentRequest = true;
+		setIsLoading(true);
+		setError(null);
+
+		void ${fetchName}(view)
+			.then((nextDataSet) => {
+				if (isCurrentRequest) {
+					setDataSet(nextDataSet);
+				}
+			})
+			.catch((nextError: unknown) => {
+				if (isCurrentRequest) {
+					setError(
+						nextError instanceof Error
+							? nextError.message
+							: __( 'Unable to load records.', ${quoteTsString(textDomain)} ),
+					);
+				}
+			})
+			.finally(() => {
+				if (isCurrentRequest) {
+					setIsLoading(false);
+				}
+			});
+
+		return () => {
+			isCurrentRequest = false;
+		};
+	}, [reloadToken, 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>
+						{ __( 'Replace the fetcher in data.ts with your project data source when this screen graduates from scaffold to product UI.', ${quoteTsString(textDomain)} ) }
+					</p>
+				</div>
+				<div className="wp-typia-admin-view-screen__actions">
+					{ isLoading ? <Spinner /> : null }
+					<Button
+						isBusy={ isLoading }
+						onClick={ () => setReloadToken((token) => token + 1) }
+						variant="secondary"
+					>
+						{ __( 'Reload', ${quoteTsString(textDomain)} ) }
+					</Button>
+				</div>
+			</header>
+			{ error ? (
+				<Notice isDismissible={ false } status="error">
+					{ error }
+				</Notice>
+			) : null }
+			<TypedDataViews<${itemTypeName}> { ...config } />
+		</div>
+	);
+}
+`;
+}
+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`;
+  const rootId = `wp-typia-admin-view-${adminViewSlug}`;
+  return `import { createRoot } from '@wordpress/element';
+
+import '@wordpress/dataviews/build-style/style.css';
+import { ${componentName} } from './Screen';
+import './style.scss';
+
+const ROOT_ELEMENT_ID = ${quoteTsString(rootId)};
+
+function mountAdminView() {
+	const rootElement = document.getElementById(ROOT_ELEMENT_ID);
+	if (!rootElement) {
+		return;
+	}
+
+	createRoot(rootElement).render(<${componentName} />);
+}
+
+if (document.readyState === 'loading') {
+	document.addEventListener('DOMContentLoaded', mountAdminView);
+} else {
+	mountAdminView();
+}
+`;
+}
+function buildAdminViewStyleSource() {
+  return `.wp-typia-admin-view-screen {
+	box-sizing: border-box;
+	max-width: 1180px;
+	padding: 24px 24px 48px 0;
+}
+
+.wp-typia-admin-view-screen__header {
+	align-items: flex-start;
+	display: flex;
+	gap: 24px;
+	justify-content: space-between;
+	margin-bottom: 24px;
+}
+
+.wp-typia-admin-view-screen__header h1 {
+	font-size: 28px;
+	line-height: 1.2;
+	margin: 0 0 8px;
+}
+
+.wp-typia-admin-view-screen__header p {
+	max-width: 680px;
+}
+
+.wp-typia-admin-view-screen__eyebrow {
+	color: #3858e9;
+	font-size: 11px;
+	font-weight: 600;
+	letter-spacing: 0.08em;
+	margin: 0 0 8px;
+	text-transform: uppercase;
+}
+
+.wp-typia-admin-view-screen__actions {
+	align-items: center;
+	display: flex;
+	gap: 12px;
+}
+`;
+}
+function buildAdminViewPhpSource(adminViewSlug, workspace) {
+  const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
+  const phpSlug = adminViewSlug.replace(/-/g, "_");
+  const functionPrefix = `${workspace.workspace.phpPrefix}_${phpSlug}`;
+  const menuSlugFunctionName = `${functionPrefix}_admin_view_menu_slug`;
+  const renderFunctionName = `${functionPrefix}_render_admin_view`;
+  const registerFunctionName = `${functionPrefix}_register_admin_view`;
+  const enqueueFunctionName = `${functionPrefix}_enqueue_admin_view`;
+  const hookGlobalName = `${functionPrefix}_admin_view_hook`;
+  const rootId = `wp-typia-admin-view-${adminViewSlug}`;
+  const title = toTitleCase(adminViewSlug);
+  return `<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	return;
+}
+
+if ( ! function_exists( '${menuSlugFunctionName}' ) ) {
+	function ${menuSlugFunctionName}() : string {
+		return '${workspaceBaseName}-${adminViewSlug}';
+	}
+}
+
+if ( ! function_exists( '${renderFunctionName}' ) ) {
+	function ${renderFunctionName}() : void {
+		?>
+		<div class="wrap">
+			<div id="${rootId}"></div>
+		</div>
+		<?php
+	}
+}
+
+if ( ! function_exists( '${registerFunctionName}' ) ) {
+	function ${registerFunctionName}() : void {
+		$GLOBALS['${hookGlobalName}'] = add_submenu_page(
+			'tools.php',
+			__( ${quotePhpString(title)}, ${quotePhpString(workspace.workspace.textDomain)} ),
+			__( ${quotePhpString(title)}, ${quotePhpString(workspace.workspace.textDomain)} ),
+			'edit_posts',
+			${menuSlugFunctionName}(),
+			'${renderFunctionName}'
+		);
+	}
+}
+
+if ( ! function_exists( '${enqueueFunctionName}' ) ) {
+	function ${enqueueFunctionName}( string $hook_suffix ) : void {
+		$page_hook = isset( $GLOBALS['${hookGlobalName}'] ) && is_string( $GLOBALS['${hookGlobalName}'] )
+			? $GLOBALS['${hookGlobalName}']
+			: '';
+
+		if ( $page_hook !== $hook_suffix ) {
+			return;
+		}
+
+		$plugin_file = dirname( __DIR__, 2 ) . '/${workspaceBaseName}.php';
+		$script_path = dirname( __DIR__, 2 ) . '/${ADMIN_VIEWS_SCRIPT}';
+		$asset_path  = dirname( __DIR__, 2 ) . '/${ADMIN_VIEWS_ASSET}';
+		$style_path  = dirname( __DIR__, 2 ) . '/${ADMIN_VIEWS_STYLE}';
+		$style_rtl_path = dirname( __DIR__, 2 ) . '/${ADMIN_VIEWS_STYLE_RTL}';
+
+		if ( ! file_exists( $script_path ) || ! file_exists( $asset_path ) ) {
+			return;
+		}
+
+		$asset = require $asset_path;
+		if ( ! is_array( $asset ) ) {
+			$asset = array();
+		}
+
+		$dependencies = isset( $asset['dependencies'] ) && is_array( $asset['dependencies'] )
+			? $asset['dependencies']
+			: array();
+
+		wp_enqueue_script(
+			'${workspaceBaseName}-${adminViewSlug}-admin-view',
+			plugins_url( '${ADMIN_VIEWS_SCRIPT}', $plugin_file ),
+			$dependencies,
+			isset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
+			true
+		);
+
+		if ( file_exists( $style_path ) ) {
+			wp_enqueue_style(
+				'${workspaceBaseName}-${adminViewSlug}-admin-view',
+				plugins_url( '${ADMIN_VIEWS_STYLE}', $plugin_file ),
+				array( 'wp-components' ),
+				isset( $asset['version'] ) ? $asset['version'] : filemtime( $style_path )
+			);
+			if ( file_exists( $style_rtl_path ) ) {
+				wp_style_add_data( '${workspaceBaseName}-${adminViewSlug}-admin-view', 'rtl', 'replace' );
+			}
+		}
+	}
+}
+
+add_action( 'admin_menu', '${registerFunctionName}' );
+add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
+`;
+}
+async function ensureAdminViewPackageDependencies(workspace, adminViewSource) {
+  const packageJsonPath = path4.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);
+  const wordpressCoreDataVersion = resolvePackageVersionRange("@wordpress/core-data", DEFAULT_WORDPRESS_CORE_DATA_VERSION);
+  const wordpressDataVersion = resolvePackageVersionRange("@wordpress/data", DEFAULT_WORDPRESS_DATA_VERSION);
+  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,
+      ...coreDataDependencies
+    };
+    const nextDevDependencies = {
+      ...packageJson.devDependencies ?? {},
+      "@wp-typia/dataviews": packageJson.devDependencies?.["@wp-typia/dataviews"] ?? wpTypiaDataViewsVersion
+    };
+    if (JSON.stringify(nextDependencies) === JSON.stringify(packageJson.dependencies ?? {}) && JSON.stringify(nextDevDependencies) === JSON.stringify(packageJson.devDependencies ?? {})) {
+      return source;
+    }
+    packageJson.dependencies = nextDependencies;
+    packageJson.devDependencies = nextDevDependencies;
+    return `${JSON.stringify(packageJson, null, detectJsonIndent(source))}
+`;
+  });
+}
+async function ensureAdminViewBootstrapAnchors(workspace) {
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  await patchFile(bootstrapPath, (source) => {
+    let nextSource = source;
+    const loadFunctionName = `${workspace.workspace.phpPrefix}_load_admin_views`;
+    const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
+    const loadFunction = `
+
+function ${loadFunctionName}() {
+	foreach ( glob( __DIR__ . '${ADMIN_VIEWS_PHP_GLOB}' ) ?: array() as $admin_view_module ) {
+		require_once $admin_view_module;
+	}
+}
+`;
+    const insertionAnchors = [
+      /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
+      /\?>\s*$/u
+    ];
+    const insertPhpSnippet = (snippet) => {
+      for (const anchor of insertionAnchors) {
+        const candidate = nextSource.replace(anchor, (match) => `${snippet}
+${match}`);
+        if (candidate !== nextSource) {
+          nextSource = candidate;
+          return;
+        }
+      }
+      nextSource = `${nextSource.trimEnd()}
+${snippet}
+`;
+    };
+    const appendPhpSnippet = (snippet) => {
+      const closingTagPattern = /\?>\s*$/u;
+      if (closingTagPattern.test(nextSource)) {
+        nextSource = nextSource.replace(closingTagPattern, `${snippet}
+?>`);
+        return;
+      }
+      nextSource = `${nextSource.trimEnd()}
+${snippet}
+`;
+    };
+    if (!hasPhpFunctionDefinition(nextSource, loadFunctionName)) {
+      insertPhpSnippet(loadFunction);
+    } else {
+      const functionRange = findPhpFunctionRange(nextSource, loadFunctionName);
+      const functionSource = functionRange ? nextSource.slice(functionRange.start, functionRange.end) : "";
+      if (!functionSource.includes(ADMIN_VIEWS_PHP_GLOB)) {
+        const replacedSource = replacePhpFunctionDefinition(nextSource, loadFunctionName, loadFunction);
+        if (!replacedSource) {
+          throw new Error(`Unable to repair ${path4.basename(bootstrapPath)} for ${loadFunctionName}.`);
+        }
+        nextSource = replacedSource;
+      }
+    }
+    if (!nextSource.includes(loadHook)) {
+      appendPhpSnippet(loadHook);
+    }
+    return nextSource;
+  });
+}
+async function ensureAdminViewBuildScriptAnchors(workspace) {
+  const buildScriptPath = path4.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  await patchFile(buildScriptPath, (source) => {
+    if (/['"]src\/admin-views\/index\.(?:ts|js)['"]/u.test(source)) {
+      return source;
+    }
+    const currentSharedEntriesPattern = /(\r?\n\s*['"]src\/editor-plugins\/index\.js['"])\s*,?/u;
+    let nextSource = source.replace(currentSharedEntriesPattern, `$1,
+		'src/admin-views/index.ts',
+		'src/admin-views/index.js',`);
+    if (nextSource !== source) {
+      return nextSource;
+    }
+    const legacySharedEntriesPattern = /\[\s*['"]src\/bindings\/index\.ts['"]\s*,\s*['"]src\/bindings\/index\.js['"]\s*(?:,\s*)?\]/u;
+    nextSource = source.replace(legacySharedEntriesPattern, `[
+		'src/bindings/index.ts',
+		'src/bindings/index.js',
+		'src/editor-plugins/index.ts',
+		'src/editor-plugins/index.js',
+		'src/admin-views/index.ts',
+		'src/admin-views/index.js',
+	]`);
+    if (nextSource !== source) {
+      return nextSource;
+    }
+    throw new Error(`Unable to update ${path4.relative(workspace.projectDir, buildScriptPath)} for admin view shared entries.`);
+  });
+}
+async function ensureAdminViewWebpackAnchors(workspace) {
+  const webpackConfigPath = path4.join(workspace.projectDir, "webpack.config.js");
+  await patchFile(webpackConfigPath, (source) => {
+    if (/['"]admin-views\/index['"]/u.test(source)) {
+      return source;
+    }
+    const editorPluginEntryPattern = /(\n\s*\[\s*['"]editor-plugins\/index['"][\s\S]*?['"]src\/editor-plugins\/index\.js['"][\s\S]*?\]\s*\])\s*,?/u;
+    let nextSource = source.replace(editorPluginEntryPattern, `$1,
+		[
+			'admin-views/index',
+			[ 'src/admin-views/index.ts', 'src/admin-views/index.js' ],
+		],`);
+    if (nextSource !== source) {
+      return nextSource;
+    }
+    const legacySharedEntriesBlockPattern = /for\s*\(\s*const\s+relativePath\s+of\s+\[\s*['"]src\/bindings\/index\.ts['"]\s*,\s*['"]src\/bindings\/index\.js['"]\s*(?:,\s*)?\]\s*\)\s*\{[\s\S]*?entries\.push\(\s*\[\s*['"]bindings\/index['"]\s*,\s*entryPath\s*\]\s*\);\s*break;\s*\}/u;
+    const nextSharedEntriesBlock = `	for ( const [ entryName, candidates ] of [
+		[
+			'bindings/index',
+			[ 'src/bindings/index.ts', 'src/bindings/index.js' ],
+		],
+		[
+			'editor-plugins/index',
+			[ 'src/editor-plugins/index.ts', 'src/editor-plugins/index.js' ],
+		],
+		[
+			'admin-views/index',
+			[ 'src/admin-views/index.ts', 'src/admin-views/index.js' ],
+		],
+	] ) {
+		for ( const relativePath of candidates ) {
+			const entryPath = path.resolve( process.cwd(), relativePath );
+			if ( ! fs.existsSync( entryPath ) ) {
+				continue;
+			}
+
+			entries.push( [ entryName, entryPath ] );
+			break;
+		}
+	}`;
+    nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
+    if (nextSource === source) {
+      throw new Error(`Unable to update ${path4.relative(workspace.projectDir, webpackConfigPath)} for admin view shared entries.`);
+    }
+    return nextSource;
+  });
+}
+function resolveAdminViewRegistryPath(projectDir) {
+  const adminViewsDir = path4.join(projectDir, "src", "admin-views");
+  return [
+    path4.join(adminViewsDir, "index.ts"),
+    path4.join(adminViewsDir, "index.js")
+  ].find((candidatePath) => fs3.existsSync(candidatePath)) ?? path4.join(adminViewsDir, "index.ts");
+}
+function readAdminViewRegistrySlugs(registryPath) {
+  if (!fs3.existsSync(registryPath)) {
+    return [];
+  }
+  const source = fs3.readFileSync(registryPath, "utf8");
+  return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match) => match[1]);
+}
+async function writeAdminViewRegistry(projectDir, adminViewSlug) {
+  const adminViewsDir = path4.join(projectDir, "src", "admin-views");
+  const registryPath = resolveAdminViewRegistryPath(projectDir);
+  await fsp3.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();
+  await fsp3.writeFile(registryPath, buildAdminViewRegistrySource(nextAdminViewSlugs), "utf8");
+}
+async function runAddAdminViewCommand({
+  adminViewName,
+  cwd = process.cwd(),
+  source
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  assertAdminViewPackageAvailability();
+  const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]");
+  const parsedSource = parseAdminViewSource(source);
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const restResource = resolveRestResourceSource(inventory.restResources, parsedSource);
+  const coreDataSource = isAdminViewCoreDataSource(parsedSource) ? parsedSource : undefined;
+  assertAdminViewDoesNotExist(workspace.projectDir, adminViewSlug, inventory);
+  const blockConfigPath = path4.join(workspace.projectDir, "scripts", "block-config.ts");
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  const buildScriptPath = path4.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path4.join(workspace.projectDir, "package.json");
+  const webpackConfigPath = path4.join(workspace.projectDir, "webpack.config.js");
+  const adminViewsIndexPath = resolveAdminViewRegistryPath(workspace.projectDir);
+  const adminViewDir = path4.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
+  const adminViewPhpPath = path4.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles([
+      adminViewsIndexPath,
+      blockConfigPath,
+      bootstrapPath,
+      buildScriptPath,
+      packageJsonPath,
+      webpackConfigPath
+    ]),
+    snapshotDirs: [],
+    targetPaths: [adminViewDir, adminViewPhpPath]
+  };
   try {
-    const normalizedSlug = resolveNonEmptyNormalizedBlockSlug({
-      input: blockName,
-      label: "Block name",
-      usage: "wp-typia add block <name> --template <family>"
+    await fsp3.mkdir(adminViewDir, { recursive: true });
+    await fsp3.mkdir(path4.dirname(adminViewPhpPath), { recursive: true });
+    await ensureAdminViewPackageDependencies(workspace, parsedSource);
+    await ensureAdminViewBootstrapAnchors(workspace);
+    await ensureAdminViewBuildScriptAnchors(workspace);
+    await ensureAdminViewWebpackAnchors(workspace);
+    await fsp3.writeFile(path4.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
+    await fsp3.writeFile(path4.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
+    await fsp3.writeFile(path4.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
+    await fsp3.writeFile(path4.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
+    await fsp3.writeFile(path4.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
+    await fsp3.writeFile(path4.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
+    await fsp3.writeFile(adminViewPhpPath, buildAdminViewPhpSource(adminViewSlug, workspace), "utf8");
+    await writeAdminViewRegistry(workspace.projectDir, adminViewSlug);
+    await appendWorkspaceInventoryEntries(workspace.projectDir, {
+      adminViewEntries: [buildAdminViewConfigEntry(adminViewSlug, parsedSource)]
     });
-    const defaults = getDefaultAnswers(normalizedSlug, resolvedTemplateId);
-    ({
-      path: tempRoot,
-      cleanup: cleanupTempRoot
-    } = await createManagedTempRoot("wp-typia-add-block-"));
-    const tempProjectDir = path3.join(tempRoot, normalizedSlug);
-    const blockConfigPath = path3.join(workspace.projectDir, "scripts", "block-config.ts");
-    const migrationConfigPath = path3.join(workspace.projectDir, "src", "migrations", "config.ts");
-    const blockPhpPrefix = buildWorkspacePhpPrefix(workspace.workspace.phpPrefix, normalizedSlug);
-    const migrationConfigSource = await readOptionalFile(migrationConfigPath);
-    const migrationConfig = migrationConfigSource === null ? null : parseMigrationConfig(migrationConfigSource);
-    const compoundSupportPaths = resolvedTemplateId === "compound" ? COMPOUND_SHARED_SUPPORT_FILES.map((fileName) => path3.join(workspace.projectDir, "src", fileName)) : [];
-    const legacyCompoundValidatorPaths = resolvedTemplateId === "compound" ? await collectLegacyCompoundValidatorPaths(workspace.projectDir) : [];
-    const result = await (async () => {
-      const scaffoldResult = await scaffoldProject({
-        alternateRenderTargets,
-        answers: {
-          ...defaults,
-          author: workspace.author,
-          compoundInnerBlocksPreset: resolvedInnerBlocksPreset,
-          namespace: workspace.workspace.namespace,
-          phpPrefix: blockPhpPrefix,
-          slug: normalizedSlug,
-          textDomain: workspace.workspace.textDomain,
-          title: defaults.title
-        },
-        cwd: workspace.projectDir,
-        dataStorageMode,
-        externalLayerId: resolvedExternalLayerSelection.externalLayerId,
-        externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
-        externalLayerSourceLabel: normalizedExternalLayerSource,
-        noInstall: true,
-        packageManager: workspace.packageManager,
-        persistencePolicy,
-        projectDir: tempProjectDir,
-        templateId: resolvedTemplateId
-      });
-      await assertAddBlockSupportsExternalLayerOutputs({
-        callerCwd: cwd,
-        externalLayerId: resolvedExternalLayerSelection.externalLayerId,
-        externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
-        templateId: resolvedTemplateId,
-        variables: scaffoldResult.variables
-      });
-      return scaffoldResult;
-    })();
-    assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
-    const mutationSnapshot = {
-      fileSources: await snapshotWorkspaceFiles([
-        blockConfigPath,
-        migrationConfigPath,
-        ...compoundSupportPaths,
-        ...legacyCompoundValidatorPaths
-      ]),
-      snapshotDirs: migrationConfig === null ? [] : buildMigrationBlocks(resolvedTemplateId, result.variables).map((block) => path3.join(workspace.projectDir, ...migrationConfig.snapshotDir.split("/"), migrationConfig.currentMigrationVersion, block.key)),
-      targetPaths: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables)
+    return {
+      adminViewSlug,
+      projectDir: workspace.projectDir,
+      source: parsedSource ? formatAdminViewSourceLocator(parsedSource) : undefined
     };
-    try {
-      await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables, legacyCompoundValidatorPaths);
-      await addCollectionImportsForTemplate(workspace.projectDir, resolvedTemplateId, result.variables);
-      await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" || resolvedTemplateId === "compound" && result.variables.compoundPersistenceEnabled === "true");
-      await syncWorkspaceAddedBlockArtifacts(workspace.projectDir, resolvedTemplateId, result.variables);
-      await updateWorkspaceMigrationConfigIfPresent(workspace.projectDir, buildMigrationBlocks(resolvedTemplateId, result.variables));
-      return {
-        blockSlugs: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables).map((targetPath) => path3.basename(targetPath)),
-        projectDir: workspace.projectDir,
-        templateId: resolvedTemplateId,
-        warnings: result.warnings
-      };
-    } catch (error) {
-      await rollbackWorkspaceMutation(mutationSnapshot);
-      throw error;
-    }
-  } finally {
-    try {
-      await resolvedExternalLayerSelection.cleanup?.();
-    } finally {
-      await cleanupTempRoot?.();
-    }
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw error;
   }
 }
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
-import fs5 from "fs";
-import { promises as fsp8 } from "fs";
-import path12 from "path";
-
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
-import fs3 from "fs";
-import { promises as fsp3 } from "fs";
-import path4 from "path";
+var import_typescript = __toESM(require_typescript(), 1);
+import fs4 from "fs";
+import { promises as fsp4 } from "fs";
+import path5 from "path";
+import {
+  syncBlockMetadata as syncBlockMetadata2
+} from "@wp-typia/block-runtime/metadata-core";
 var PATTERN_BOOTSTRAP_CATEGORY = "register_block_pattern_category";
 var BINDING_SOURCE_SERVER_GLOB = "/src/bindings/*/server.php";
 var BINDING_SOURCE_EDITOR_SCRIPT = "build/bindings/index.js";
@@ -775,58 +2153,7 @@ var EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
 var EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
 var EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
 var EDITOR_PLUGIN_EDITOR_STYLE_RTL = "build/editor-plugins/style-index-rtl.css";
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-function quotePhpString(value) {
-  return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
-}
-function findPhpFunctionRange(source, functionName) {
-  const signaturePattern = new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\(`, "u");
-  const signatureMatch = signaturePattern.exec(source);
-  if (!signatureMatch || signatureMatch.index === undefined) {
-    return null;
-  }
-  const functionStart = signatureMatch.index;
-  const openBraceIndex = source.indexOf("{", functionStart);
-  if (openBraceIndex === -1) {
-    return null;
-  }
-  let depth = 0;
-  for (let index = openBraceIndex;index < source.length; index += 1) {
-    const character = source[index];
-    if (character === "{") {
-      depth += 1;
-      continue;
-    }
-    if (character !== "}") {
-      continue;
-    }
-    depth -= 1;
-    if (depth === 0) {
-      let functionEnd = index + 1;
-      while (functionEnd < source.length && /[\r\n]/u.test(source[functionEnd] ?? "")) {
-        functionEnd += 1;
-      }
-      return {
-        end: functionEnd,
-        start: functionStart
-      };
-    }
-  }
-  return null;
-}
-function replacePhpFunctionDefinition(source, functionName, replacement) {
-  const functionRange = findPhpFunctionRange(source, functionName);
-  if (!functionRange) {
-    return null;
-  }
-  return [
-    source.slice(0, functionRange.start),
-    replacement,
-    source.slice(functionRange.end)
-  ].join("");
-}
+var BINDING_ATTRIBUTE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
 function buildPatternConfigEntry(patternSlug) {
   return [
     "\t{",
@@ -836,9 +2163,11 @@ function buildPatternConfigEntry(patternSlug) {
   ].join(`
 `);
 }
-function buildBindingSourceConfigEntry(bindingSourceSlug) {
+function buildBindingSourceConfigEntry(bindingSourceSlug, target) {
   return [
     "\t{",
+    ...target ? [`		attribute: ${quoteTsString(target.attributeName)},`] : [],
+    ...target ? [`		block: ${quoteTsString(target.blockSlug)},`] : [],
     `		editorFile: ${quoteTsString(`src/bindings/${bindingSourceSlug}/editor.ts`)},`,
     `		serverFile: ${quoteTsString(`src/bindings/${bindingSourceSlug}/server.php`)},`,
     `		slug: ${quoteTsString(bindingSourceSlug)},`,
@@ -846,6 +2175,34 @@ function buildBindingSourceConfigEntry(bindingSourceSlug) {
   ].join(`
 `);
 }
+function assertValidBindingAttributeName(attributeName) {
+  const trimmed = attributeName.trim();
+  if (!trimmed) {
+    throw new Error("`wp-typia add binding-source` requires --attribute <attribute> to include a value when --block is provided.");
+  }
+  if (!BINDING_ATTRIBUTE_NAME_PATTERN.test(trimmed)) {
+    throw new Error(`Binding attribute "${attributeName}" must start with a letter and use only letters, numbers, underscores, or hyphens.`);
+  }
+  return trimmed;
+}
+function resolveBindingTargetBlockSlug(blockName, namespace) {
+  const trimmed = blockName.trim();
+  if (!trimmed) {
+    throw new Error("`wp-typia add binding-source` requires --block <block-slug|namespace/block-slug> to include a value when --attribute is provided.");
+  }
+  const blockNameSegments = trimmed.split("/");
+  if (blockNameSegments.length > 2) {
+    throw new Error(`Binding target block "${trimmed}" must use <block-slug> or <namespace/block-slug> format.`);
+  }
+  if (blockNameSegments.some((segment) => segment.trim() === "")) {
+    throw new Error(`Binding target block "${trimmed}" must use <block-slug> or <namespace/block-slug> format without empty path segments.`);
+  }
+  const [maybeNamespace, maybeSlug] = blockNameSegments.length === 2 ? blockNameSegments : [undefined, blockNameSegments[0]];
+  if (maybeNamespace && maybeNamespace !== namespace) {
+    throw new Error(`Binding target block "${trimmed}" uses namespace "${maybeNamespace}". Expected "${namespace}".`);
+  }
+  return normalizeBlockSlug(maybeSlug ?? "");
+}
 function buildEditorPluginConfigEntry(editorPluginSlug, slot) {
   return [
     "\t{",
@@ -856,9 +2213,6 @@ function buildEditorPluginConfigEntry(editorPluginSlug, slot) {
   ].join(`
 `);
 }
-function toPascalCaseFromSlug(slug) {
-  return normalizeBlockSlug(slug).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
-}
 function buildPatternSource(patternSlug, namespace, textDomain) {
   const patternTitle = toTitleCase(patternSlug);
   return `<?php
@@ -877,12 +2231,32 @@ register_block_pattern(
 );
 `;
 }
-function buildBindingSourceServerSource(bindingSourceSlug, phpPrefix, namespace, textDomain) {
+function buildBindingSourceServerSource(bindingSourceSlug, phpPrefix, namespace, textDomain, target) {
   const bindingSourceTitle = toTitleCase(bindingSourceSlug);
   const bindingSourcePhpId = bindingSourceSlug.replace(/-/g, "_");
   const bindingSourceValueFunctionName = `${phpPrefix}_${bindingSourcePhpId}_binding_source_values`;
   const bindingSourceResolveFunctionName = `${phpPrefix}_${bindingSourcePhpId}_resolve_binding_source_value`;
+  const bindingSourceSupportedAttributesFunctionName = `${phpPrefix}_${bindingSourcePhpId}_supported_binding_attributes`;
   const starterValue = `${bindingSourceTitle} starter value`;
+  const supportedAttributesSource = target ? `
+if ( ! function_exists( '${bindingSourceSupportedAttributesFunctionName}' ) ) {
+	function ${bindingSourceSupportedAttributesFunctionName}( array $supported_attributes ) : array {
+		if ( ! in_array( ${quotePhpString(target.attributeName)}, $supported_attributes, true ) ) {
+			$supported_attributes[] = ${quotePhpString(target.attributeName)};
+		}
+
+		return $supported_attributes;
+	}
+}
+` : "";
+  const supportedAttributesHook = target ? `
+if ( function_exists( '${bindingSourceSupportedAttributesFunctionName}' ) ) {
+	add_filter(
+		${quotePhpString(`block_bindings_supported_attributes_${namespace}/${target.blockSlug}`)},
+		${quotePhpString(bindingSourceSupportedAttributesFunctionName)}
+	);
+}
+` : "";
   return `<?php
 if ( ! defined( 'ABSPATH' ) ) {
 	return;
@@ -911,6 +2285,7 @@ if ( ! function_exists( '${bindingSourceResolveFunctionName}' ) ) {
 		return is_string( $value ) ? $value : '';
 	}
 }
+${supportedAttributesSource}
 
 register_block_bindings_source(
 	${quotePhpString(`${namespace}/${bindingSourceSlug}`)},
@@ -919,11 +2294,20 @@ register_block_bindings_source(
 		'get_value_callback' => ${quotePhpString(bindingSourceResolveFunctionName)},
 	)
 );
-`;
+${supportedAttributesHook}`;
 }
-function buildBindingSourceEditorSource(bindingSourceSlug, namespace, textDomain) {
+function buildBindingSourceEditorSource(bindingSourceSlug, namespace, textDomain, target) {
   const bindingSourceTitle = toTitleCase(bindingSourceSlug);
   const starterValue = `${bindingSourceTitle} starter value`;
+  const bindingSourceName = `${namespace}/${bindingSourceSlug}`;
+  const targetSource = target ? `
+export const BINDING_SOURCE_TARGET = {
+	attribute: ${quoteTsString(target.attributeName)},
+	block: ${quoteTsString(`${namespace}/${target.blockSlug}`)},
+	field: ${quoteTsString(bindingSourceSlug)},
+	source: ${quoteTsString(bindingSourceName)},
+} as const;
+` : "";
   return `import { registerBlockBindingsSource } from '@wordpress/blocks';
 import { __ } from '@wordpress/i18n';
 
@@ -936,13 +2320,14 @@ interface BindingSourceRegistration {
 const BINDING_SOURCE_VALUES: Record<string, string> = {
 	${quoteTsString(bindingSourceSlug)}: ${quoteTsString(starterValue)},
 };
+${targetSource}
 
 function resolveBindingSourceValue( field: string ): string {
 	return BINDING_SOURCE_VALUES[ field ] ?? '';
 }
 
 registerBlockBindingsSource( {
-	name: ${quoteTsString(`${namespace}/${bindingSourceSlug}`)},
+	name: ${quoteTsString(bindingSourceName)},
 	label: __( ${quoteTsString(bindingSourceTitle)}, ${quoteTsString(textDomain)} ),
 	getFieldsList() {
 		return [
@@ -971,8 +2356,98 @@ registerBlockBindingsSource( {
 } );
 `;
 }
+function resolveBindingTarget(options, namespace) {
+  const hasBlock = options.blockName !== undefined && options.blockName.trim().length > 0;
+  const hasAttribute = options.attributeName !== undefined && options.attributeName.trim().length > 0;
+  if (!hasBlock && !hasAttribute) {
+    return;
+  }
+  if (!hasBlock || !hasAttribute) {
+    throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+  }
+  return {
+    attributeName: assertValidBindingAttributeName(options.attributeName ?? ""),
+    blockSlug: resolveBindingTargetBlockSlug(options.blockName ?? "", namespace)
+  };
+}
+function formatBindingAttributeTypeMember(attributeName) {
+  const propertyName = /^[A-Za-z_$][\w$]*$/u.test(attributeName) ? attributeName : JSON.stringify(attributeName);
+  return [
+    "\t/**",
+    "\t * Starter string attribute declared for WordPress Block Bindings.",
+    "\t */",
+    `	${propertyName}?: string;`
+  ].join(`
+`);
+}
+function getInterfaceDeclaration(source, interfaceName) {
+  const sourceFile = import_typescript.default.createSourceFile("types.ts", source, import_typescript.default.ScriptTarget.Latest, true, import_typescript.default.ScriptKind.TS);
+  let declaration;
+  const visit = (node) => {
+    if (import_typescript.default.isInterfaceDeclaration(node) && node.name.text === interfaceName) {
+      declaration = node;
+      return true;
+    }
+    return import_typescript.default.forEachChild(node, (child) => visit(child) ? true : undefined) ?? false;
+  };
+  visit(sourceFile);
+  return declaration ? { declaration, sourceFile } : undefined;
+}
+function getPropertyNameText(name) {
+  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return;
+}
+function interfaceHasAttributeMember(declaration, attributeName) {
+  return declaration.members.some((member) => import_typescript.default.isPropertySignature(member) && member.name !== undefined && getPropertyNameText(member.name) === attributeName);
+}
+function insertBindingAttributeTypeMember(source, declaration, attributeName) {
+  let closeBracePosition = declaration.end - 1;
+  while (closeBracePosition > declaration.pos && source[closeBracePosition] !== "}") {
+    closeBracePosition -= 1;
+  }
+  if (source[closeBracePosition] !== "}") {
+    throw new Error("Unable to locate the target interface closing brace.");
+  }
+  const lineEnding = source.includes(`\r
+`) ? `\r
+` : `
+`;
+  const beforeCloseBrace = source.slice(0, closeBracePosition);
+  const afterCloseBrace = source.slice(closeBracePosition);
+  const memberSource = formatBindingAttributeTypeMember(attributeName).split(`
+`).join(lineEnding);
+  const prefix = beforeCloseBrace.endsWith(lineEnding) ? "" : lineEnding;
+  return `${beforeCloseBrace}${prefix}${memberSource}${lineEnding}${afterCloseBrace}`;
+}
+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 = path5.join(projectDir, block.typesFile);
+  const source = await fsp4.readFile(typesPath, "utf8");
+  const targetInterface = getInterfaceDeclaration(source, block.attributeTypeName);
+  if (!targetInterface) {
+    throw new Error(`Unable to locate interface ${block.attributeTypeName} in ${block.typesFile}.`);
+  }
+  let nextSource = source;
+  if (!interfaceHasAttributeMember(targetInterface.declaration, target.attributeName)) {
+    nextSource = insertBindingAttributeTypeMember(source, targetInterface.declaration, target.attributeName);
+    await fsp4.writeFile(typesPath, nextSource, "utf8");
+  }
+  await syncBlockMetadata2({
+    blockJsonFile: path5.join("src", "blocks", block.slug, "block.json"),
+    jsonSchemaFile: path5.join("src", "blocks", block.slug, "typia.schema.json"),
+    manifestFile: path5.join("src", "blocks", block.slug, "typia.manifest.json"),
+    openApiFile: path5.join("src", "blocks", block.slug, "typia.openapi.json"),
+    projectRoot: projectDir,
+    sourceTypeName: block.attributeTypeName,
+    typesFile: block.typesFile
+  });
+}
 function buildEditorPluginTypesSource(editorPluginSlug) {
-  const typeName = `${toPascalCaseFromSlug(editorPluginSlug)}SidebarModel`;
+  const typeName = `${toPascalCase(editorPluginSlug)}EditorPluginModel`;
   return `export interface ${typeName} {
 	primaryActionLabel: string;
 	summary: string;
@@ -980,22 +2455,22 @@ function buildEditorPluginTypesSource(editorPluginSlug) {
 `;
 }
 function buildEditorPluginDataSource(editorPluginSlug, slot) {
-  const typeName = `${toPascalCaseFromSlug(editorPluginSlug)}SidebarModel`;
+  const typeName = `${toPascalCase(editorPluginSlug)}EditorPluginModel`;
   const pluginTitle = toTitleCase(editorPluginSlug);
-  const modelFactoryName = `get${toPascalCaseFromSlug(editorPluginSlug)}SidebarModel`;
-  const enabledFactoryName = `is${toPascalCaseFromSlug(editorPluginSlug)}Enabled`;
+  const modelFactoryName = `get${toPascalCase(editorPluginSlug)}EditorPluginModel`;
+  const enabledFactoryName = `is${toPascalCase(editorPluginSlug)}Enabled`;
   return `import type { ${typeName} } from './types';
 
 export const EDITOR_PLUGIN_SLOT = ${quoteTsString(slot)} as const;
 export const REQUIRED_CAPABILITY = 'edit_posts' as const;
 
-const DEFAULT_SIDEBAR_MODEL: ${typeName} = {
+const DEFAULT_EDITOR_PLUGIN_MODEL: ${typeName} = {
 	primaryActionLabel: ${quoteTsString(`Review ${pluginTitle}`)},
 	summary: ${quoteTsString(`Replace this summary with your ${pluginTitle} workflow state.`)},
 };
 
 export function ${modelFactoryName}(): ${typeName} {
-	return DEFAULT_SIDEBAR_MODEL;
+	return DEFAULT_EDITOR_PLUGIN_MODEL;
 }
 
 export function ${enabledFactoryName}(): boolean {
@@ -1003,11 +2478,52 @@ export function ${enabledFactoryName}(): boolean {
 }
 `;
 }
-function buildEditorPluginSidebarSource(editorPluginSlug, textDomain) {
-  const pascalName = toPascalCaseFromSlug(editorPluginSlug);
-  const modelFactoryName = `get${pascalName}SidebarModel`;
+function buildEditorPluginSurfaceSource(editorPluginSlug, slot, textDomain) {
+  const pascalName = toPascalCase(editorPluginSlug);
+  const modelFactoryName = `get${pascalName}EditorPluginModel`;
   const enabledFactoryName = `is${pascalName}Enabled`;
-  const componentName = `${pascalName}Sidebar`;
+  const componentName = `${pascalName}Surface`;
+  if (slot === "document-setting-panel") {
+    return `import { Button } from '@wordpress/components';
+import { PluginDocumentSettingPanel } from '@wordpress/editor';
+import { __ } from '@wordpress/i18n';
+
+import { ${modelFactoryName}, ${enabledFactoryName} } from './data';
+import './style.scss';
+
+export interface ${componentName}Props {
+	surfaceName: string;
+	title: string;
+}
+
+export function ${componentName}( {
+	surfaceName,
+	title,
+}: ${componentName}Props ) {
+	if ( ! ${enabledFactoryName}() ) {
+		return null;
+	}
+
+	const editorPluginModel = ${modelFactoryName}();
+
+	return (
+		<PluginDocumentSettingPanel
+			className="wp-typia-editor-plugin-shell"
+			name={ surfaceName }
+			title={ title }
+		>
+			<p>{ editorPluginModel.summary }</p>
+			<Button variant="secondary">
+				{ editorPluginModel.primaryActionLabel }
+			</Button>
+			<p className="wp-typia-editor-plugin-shell__hint">
+				{ __( 'Use data.ts to add post type, capability, or editor context guards before showing this panel.', ${quoteTsString(textDomain)} ) }
+			</p>
+		</PluginDocumentSettingPanel>
+	);
+}
+`;
+  }
   return `import { Button, PanelBody } from '@wordpress/components';
 import { PluginSidebar, PluginSidebarMoreMenuItem } from '@wordpress/editor';
 import { __ } from '@wordpress/i18n';
@@ -1016,34 +2532,34 @@ import { ${modelFactoryName}, ${enabledFactoryName} } from './data';
 import './style.scss';
 
 export interface ${componentName}Props {
-	pluginName: string;
+	surfaceName: string;
 	title: string;
 }
 
 export function ${componentName}( {
-	pluginName,
+	surfaceName,
 	title,
 }: ${componentName}Props ) {
 	if ( ! ${enabledFactoryName}() ) {
 		return null;
 	}
 
-	const sidebarModel = ${modelFactoryName}();
+	const editorPluginModel = ${modelFactoryName}();
 
 	return (
 		<>
-			<PluginSidebarMoreMenuItem target={ pluginName }>
+			<PluginSidebarMoreMenuItem target={ surfaceName }>
 				{ title }
 			</PluginSidebarMoreMenuItem>
-			<PluginSidebar name={ pluginName } title={ title }>
+			<PluginSidebar name={ surfaceName } title={ title }>
 				<div className="wp-typia-editor-plugin-shell">
 					<PanelBody
 						initialOpen
 						title={ __( 'Document workflow', ${quoteTsString(textDomain)} ) }
 					>
-						<p>{ sidebarModel.summary }</p>
+						<p>{ editorPluginModel.summary }</p>
 						<Button variant="secondary">
-							{ sidebarModel.primaryActionLabel }
+							{ editorPluginModel.primaryActionLabel }
 						</Button>
 					</PanelBody>
 				</div>
@@ -1054,24 +2570,26 @@ export function ${componentName}( {
 `;
 }
 function buildEditorPluginEntrySource(editorPluginSlug, namespace, textDomain) {
-  const pascalName = toPascalCaseFromSlug(editorPluginSlug);
-  const componentName = `${pascalName}Sidebar`;
+  const pascalName = toPascalCase(editorPluginSlug);
+  const componentName = `${pascalName}Surface`;
   const pluginName = `${namespace}-${editorPluginSlug}`;
+  const surfaceName = `${pluginName}-surface`;
   const pluginTitle = toTitleCase(editorPluginSlug);
   return `import { registerPlugin } from '@wordpress/plugins';
 import { __ } from '@wordpress/i18n';
 
 import { REQUIRED_CAPABILITY } from './data';
-import { ${componentName} } from './Sidebar';
+import { ${componentName} } from './Surface';
 
 const EDITOR_PLUGIN_NAME = ${quoteTsString(pluginName)};
+const EDITOR_PLUGIN_SURFACE_NAME = ${quoteTsString(surfaceName)};
 const EDITOR_PLUGIN_TITLE = __( ${quoteTsString(pluginTitle)}, ${quoteTsString(textDomain)} );
 
 registerPlugin( EDITOR_PLUGIN_NAME, {
 	icon: 'admin-generic',
 	render: () => (
 		<${componentName}
-			pluginName={ EDITOR_PLUGIN_NAME }
+			surfaceName={ EDITOR_PLUGIN_SURFACE_NAME }
 			title={ EDITOR_PLUGIN_TITLE }
 		/>
 	),
@@ -1088,6 +2606,11 @@ function buildEditorPluginStyleSource() {
 .wp-typia-editor-plugin-shell p {
 	margin: 0 0 12px;
 }
+
+.wp-typia-editor-plugin-shell__hint {
+	color: #757575;
+	font-size: 12px;
+}
 `;
 }
 function buildBindingSourceIndexSource(bindingSourceSlugs) {
@@ -1156,7 +2679,7 @@ ${patternFunctions}
       }
     }
     if (!nextSource.includes(patternCategoryFunctionName) || !nextSource.includes(patternRegistrationFunctionName)) {
-      throw new Error(`Unable to inject pattern bootstrap functions into ${path4.basename(bootstrapPath)}.`);
+      throw new Error(`Unable to inject pattern bootstrap functions into ${path5.basename(bootstrapPath)}.`);
     }
     if (!nextSource.includes(patternCategoryHook)) {
       nextSource = `${nextSource.trimEnd()}
@@ -1216,7 +2739,6 @@ function ${bindingEditorEnqueueFunctionName}() {
       /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
       /\?>\s*$/u
     ];
-    const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\(`, "u").test(nextSource);
     const insertPhpSnippet = (snippet) => {
       for (const anchor of insertionAnchors) {
         const candidate = nextSource.replace(anchor, (match) => `${snippet}
@@ -1241,10 +2763,10 @@ ${snippet}
 ${snippet}
 `;
     };
-    if (!hasPhpFunctionDefinition(bindingRegistrationFunctionName)) {
+    if (!hasPhpFunctionDefinition(nextSource, bindingRegistrationFunctionName)) {
       insertPhpSnippet(bindingRegistrationFunction);
     }
-    if (!hasPhpFunctionDefinition(bindingEditorEnqueueFunctionName)) {
+    if (!hasPhpFunctionDefinition(nextSource, bindingEditorEnqueueFunctionName)) {
       insertPhpSnippet(bindingEditorEnqueueFunction);
     }
     if (!nextSource.includes(bindingRegistrationHook)) {
@@ -1305,7 +2827,6 @@ function ${enqueueFunctionName}() {
       /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
       /\?>\s*$/u
     ];
-    const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\(`, "u").test(nextSource);
     const insertPhpSnippet = (snippet) => {
       for (const anchor of insertionAnchors) {
         const candidate = nextSource.replace(anchor, (match) => `${snippet}
@@ -1330,7 +2851,7 @@ ${snippet}
 ${snippet}
 `;
     };
-    if (!hasPhpFunctionDefinition(enqueueFunctionName)) {
+    if (!hasPhpFunctionDefinition(nextSource, enqueueFunctionName)) {
       insertPhpSnippet(enqueueFunction);
     } else {
       const requiredReferences = [
@@ -1346,7 +2867,7 @@ ${snippet}
       if (missingReferences.length > 0) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path4.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
+          throw new Error(`Unable to repair ${path5.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
         }
         nextSource = replacedSource;
       }
@@ -1358,7 +2879,7 @@ ${snippet}
   });
 }
 async function ensureEditorPluginBuildScriptAnchors(workspace) {
-  const buildScriptPath = path4.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path5.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/editor-plugins\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -1371,13 +2892,13 @@ async function ensureEditorPluginBuildScriptAnchors(workspace) {
 		'src/editor-plugins/index.js',
 	]`);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path4.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path5.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 async function ensureEditorPluginWebpackAnchors(workspace) {
-  const webpackConfigPath = path4.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path5.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]editor-plugins\/index['"]/u.test(source)) {
       return source;
@@ -1405,45 +2926,45 @@ async function ensureEditorPluginWebpackAnchors(workspace) {
 	}`;
     const nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path4.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path5.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveBindingSourceRegistryPath(projectDir) {
-  const bindingsDir = path4.join(projectDir, "src", "bindings");
-  return [path4.join(bindingsDir, "index.ts"), path4.join(bindingsDir, "index.js")].find((candidatePath) => fs3.existsSync(candidatePath)) ?? path4.join(bindingsDir, "index.ts");
+  const bindingsDir = path5.join(projectDir, "src", "bindings");
+  return [path5.join(bindingsDir, "index.ts"), path5.join(bindingsDir, "index.js")].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path5.join(bindingsDir, "index.ts");
 }
 async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
-  const bindingsDir = path4.join(projectDir, "src", "bindings");
+  const bindingsDir = path5.join(projectDir, "src", "bindings");
   const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
-  await fsp3.mkdir(bindingsDir, { recursive: true });
-  const existingBindingSourceSlugs = fs3.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  await fsp4.mkdir(bindingsDir, { recursive: true });
+  const existingBindingSourceSlugs = fs4.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   const nextBindingSourceSlugs = Array.from(new Set([...existingBindingSourceSlugs, bindingSourceSlug])).sort();
-  await fsp3.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
+  await fsp4.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
 }
 function resolveEditorPluginRegistryPath(projectDir) {
-  const editorPluginsDir = path4.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path5.join(projectDir, "src", "editor-plugins");
   return [
-    path4.join(editorPluginsDir, "index.ts"),
-    path4.join(editorPluginsDir, "index.js")
-  ].find((candidatePath) => fs3.existsSync(candidatePath)) ?? path4.join(editorPluginsDir, "index.ts");
+    path5.join(editorPluginsDir, "index.ts"),
+    path5.join(editorPluginsDir, "index.js")
+  ].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path5.join(editorPluginsDir, "index.ts");
 }
 function readEditorPluginRegistrySlugs(registryPath) {
-  if (!fs3.existsSync(registryPath)) {
+  if (!fs4.existsSync(registryPath)) {
     return [];
   }
-  const source = fs3.readFileSync(registryPath, "utf8");
+  const source = fs4.readFileSync(registryPath, "utf8");
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
-  const editorPluginsDir = path4.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path5.join(projectDir, "src", "editor-plugins");
   const registryPath = resolveEditorPluginRegistryPath(projectDir);
-  await fsp3.mkdir(editorPluginsDir, { recursive: true });
+  await fsp4.mkdir(editorPluginsDir, { recursive: true });
   const existingEditorPluginSlugs = readWorkspaceInventory(projectDir).editorPlugins.map((entry) => entry.slug);
   const existingRegistrySlugs = readEditorPluginRegistrySlugs(registryPath);
   const nextEditorPluginSlugs = Array.from(new Set([...existingEditorPluginSlugs, ...existingRegistrySlugs, editorPluginSlug])).sort();
-  await fsp3.writeFile(registryPath, buildEditorPluginRegistrySource(nextEditorPluginSlugs), "utf8");
+  await fsp4.writeFile(registryPath, buildEditorPluginRegistrySource(nextEditorPluginSlugs), "utf8");
 }
 async function runAddEditorPluginCommand({
   cwd = process.cwd(),
@@ -1451,21 +2972,21 @@ async function runAddEditorPluginCommand({
   slot
 }) {
   const workspace = resolveWorkspaceProject(cwd);
-  const editorPluginSlug = assertValidGeneratedSlug("Editor plugin name", normalizeBlockSlug(editorPluginName), "wp-typia add editor-plugin <name> [--slot <PluginSidebar>]");
+  const editorPluginSlug = assertValidGeneratedSlug("Editor plugin name", normalizeBlockSlug(editorPluginName), "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>]");
   const resolvedSlot = assertValidEditorPluginSlot(slot);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertEditorPluginDoesNotExist(workspace.projectDir, editorPluginSlug, inventory);
-  const blockConfigPath = path4.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path5.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path4.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path5.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   const editorPluginsIndexPath = resolveEditorPluginRegistryPath(workspace.projectDir);
-  const webpackConfigPath = path4.join(workspace.projectDir, "webpack.config.js");
-  const editorPluginDir = path4.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
-  const entryFilePath = path4.join(editorPluginDir, "index.tsx");
-  const sidebarFilePath = path4.join(editorPluginDir, "Sidebar.tsx");
-  const dataFilePath = path4.join(editorPluginDir, "data.ts");
-  const typesFilePath = path4.join(editorPluginDir, "types.ts");
-  const styleFilePath = path4.join(editorPluginDir, "style.scss");
+  const webpackConfigPath = path5.join(workspace.projectDir, "webpack.config.js");
+  const editorPluginDir = path5.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
+  const entryFilePath = path5.join(editorPluginDir, "index.tsx");
+  const surfaceFilePath = path5.join(editorPluginDir, "Surface.tsx");
+  const dataFilePath = path5.join(editorPluginDir, "data.ts");
+  const typesFilePath = path5.join(editorPluginDir, "types.ts");
+  const styleFilePath = path5.join(editorPluginDir, "style.scss");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -1478,15 +2999,15 @@ async function runAddEditorPluginCommand({
     targetPaths: [editorPluginDir]
   };
   try {
-    await fsp3.mkdir(editorPluginDir, { recursive: true });
+    await fsp4.mkdir(editorPluginDir, { recursive: true });
     await ensureEditorPluginBootstrapAnchors(workspace);
     await ensureEditorPluginBuildScriptAnchors(workspace);
     await ensureEditorPluginWebpackAnchors(workspace);
-    await fsp3.writeFile(entryFilePath, buildEditorPluginEntrySource(editorPluginSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
-    await fsp3.writeFile(sidebarFilePath, buildEditorPluginSidebarSource(editorPluginSlug, workspace.workspace.textDomain), "utf8");
-    await fsp3.writeFile(dataFilePath, buildEditorPluginDataSource(editorPluginSlug, resolvedSlot), "utf8");
-    await fsp3.writeFile(typesFilePath, buildEditorPluginTypesSource(editorPluginSlug), "utf8");
-    await fsp3.writeFile(styleFilePath, buildEditorPluginStyleSource(), "utf8");
+    await fsp4.writeFile(entryFilePath, buildEditorPluginEntrySource(editorPluginSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
+    await fsp4.writeFile(surfaceFilePath, buildEditorPluginSurfaceSource(editorPluginSlug, resolvedSlot, workspace.workspace.textDomain), "utf8");
+    await fsp4.writeFile(dataFilePath, buildEditorPluginDataSource(editorPluginSlug, resolvedSlot), "utf8");
+    await fsp4.writeFile(typesFilePath, buildEditorPluginTypesSource(editorPluginSlug), "utf8");
+    await fsp4.writeFile(styleFilePath, buildEditorPluginStyleSource(), "utf8");
     await writeEditorPluginRegistry(workspace.projectDir, editorPluginSlug);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
       editorPluginEntries: [
@@ -1511,18 +3032,18 @@ 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 = path4.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path5.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const patternFilePath = path4.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
+  const patternFilePath = path5.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath]),
     snapshotDirs: [],
     targetPaths: [patternFilePath]
   };
   try {
-    await fsp3.mkdir(path4.dirname(patternFilePath), { recursive: true });
+    await fsp4.mkdir(path5.dirname(patternFilePath), { recursive: true });
     await ensurePatternBootstrapAnchors(workspace);
-    await fsp3.writeFile(patternFilePath, buildPatternSource(patternSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
+    await fsp4.writeFile(patternFilePath, buildPatternSource(patternSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
       patternEntries: [buildPatternConfigEntry(patternSlug)]
     });
@@ -1536,34 +3057,59 @@ async function runAddPatternCommand({
   }
 }
 async function runAddBindingSourceCommand({
+  attributeName,
   bindingSourceName,
+  blockName,
   cwd = process.cwd()
 }) {
   const workspace = resolveWorkspaceProject(cwd);
-  const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name>");
+  const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>]");
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
-  const blockConfigPath = path4.join(workspace.projectDir, "scripts", "block-config.ts");
+  const target = resolveBindingTarget({
+    attributeName,
+    blockName
+  }, workspace.workspace.namespace);
+  const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
+  const blockConfigPath = path5.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
-  const bindingSourceDir = path4.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-  const serverFilePath = path4.join(bindingSourceDir, "server.php");
-  const editorFilePath = path4.join(bindingSourceDir, "editor.ts");
+  const bindingSourceDir = path5.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
+  const serverFilePath = path5.join(bindingSourceDir, "server.php");
+  const editorFilePath = path5.join(bindingSourceDir, "editor.ts");
+  const blockJsonPath = target ? path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
+  const targetGeneratedMetadataPaths = target ? [
+    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
+    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
+    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
+    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
+  ] : [];
   const mutationSnapshot = {
-    fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath, bindingsIndexPath]),
+    fileSources: await snapshotWorkspaceFiles([
+      blockConfigPath,
+      bootstrapPath,
+      bindingsIndexPath,
+      ...blockJsonPath ? [blockJsonPath] : [],
+      ...targetBlock ? [path5.join(workspace.projectDir, targetBlock.typesFile)] : [],
+      ...targetGeneratedMetadataPaths
+    ]),
     snapshotDirs: [],
     targetPaths: [bindingSourceDir]
   };
   try {
-    await fsp3.mkdir(bindingSourceDir, { recursive: true });
+    await fsp4.mkdir(bindingSourceDir, { recursive: true });
     await ensureBindingSourceBootstrapAnchors(workspace);
-    await fsp3.writeFile(serverFilePath, buildBindingSourceServerSource(bindingSourceSlug, workspace.workspace.phpPrefix, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
-    await fsp3.writeFile(editorFilePath, buildBindingSourceEditorSource(bindingSourceSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
+    await fsp4.writeFile(serverFilePath, buildBindingSourceServerSource(bindingSourceSlug, workspace.workspace.phpPrefix, workspace.workspace.namespace, workspace.workspace.textDomain, target), "utf8");
+    await fsp4.writeFile(editorFilePath, buildBindingSourceEditorSource(bindingSourceSlug, workspace.workspace.namespace, workspace.workspace.textDomain, target), "utf8");
+    if (target && targetBlock) {
+      await ensureBindingTargetBlockAttributeType(workspace.projectDir, targetBlock, target);
+    }
     await writeBindingSourceRegistry(workspace.projectDir, bindingSourceSlug);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
-      bindingSourceEntries: [buildBindingSourceConfigEntry(bindingSourceSlug)]
+      bindingSourceEntries: [buildBindingSourceConfigEntry(bindingSourceSlug, target)]
     });
     return {
+      ...target ? { attributeName: target.attributeName, blockSlug: target.blockSlug } : {},
       bindingSourceSlug,
       projectDir: workspace.projectDir
     };
@@ -1573,15 +3119,12 @@ async function runAddBindingSourceCommand({
   }
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
-import { promises as fsp4 } from "fs";
-import path7 from "path";
+import { promises as fsp5 } from "fs";
+import path8 from "path";
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-anchors.ts
-import path5 from "path";
+import path6 from "path";
 var REST_RESOURCE_SERVER_GLOB = "/inc/rest/*.php";
-function escapeRegex2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
 async function ensureRestResourceBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   await patchFile(bootstrapPath, (source) => {
@@ -1600,7 +3143,6 @@ function ${registerFunctionName}() {
       /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
       /\?>\s*$/u
     ];
-    const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex2(functionName)}\\s*\\(`, "u").test(nextSource);
     const insertPhpSnippet = (snippet) => {
       for (const anchor of insertionAnchors) {
         const candidate = nextSource.replace(anchor, (match) => `${snippet}
@@ -1625,11 +3167,11 @@ ${snippet}
 ${snippet}
 `;
     };
-    if (!hasPhpFunctionDefinition(registerFunctionName)) {
+    if (!hasPhpFunctionDefinition(nextSource, registerFunctionName)) {
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(REST_RESOURCE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path5.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
+        `Unable to patch ${path6.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(" "));
@@ -1643,7 +3185,7 @@ ${snippet}
 function assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureRestResourceSyncScriptAnchors could not patch ${path5.basename(syncRestScriptPath)}.`,
+      `ensureRestResourceSyncScriptAnchors could not patch ${path6.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(" "));
@@ -1658,7 +3200,7 @@ function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureRestResourceSyncScriptAnchors(workspace) {
-  const syncRestScriptPath = path5.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path6.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = "import { BLOCKS, type WorkspaceBlockConfig } from './block-config';";
@@ -1776,7 +3318,7 @@ async function ensureRestResourceSyncScriptAnchors(workspace) {
 }
 
 // ../wp-typia-project-tools/src/runtime/rest-resource-artifacts.ts
-import path6 from "path";
+import path7 from "path";
 import {
   defineEndpointManifest,
   syncEndpointClient,
@@ -1912,8 +3454,8 @@ async function syncRestResourceArtifacts({
   const manifest = buildRestResourceEndpointManifest(variables, methods);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas({
-      jsonSchemaFile: path6.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path6.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path7.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path7.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -1921,7 +3463,7 @@ async function syncRestResourceArtifacts({
   }
   await syncRestOpenApi({
     manifest,
-    openApiFile: path6.join(outputDir, "api.openapi.json"),
+    openApiFile: path7.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   });
@@ -1935,16 +3477,13 @@ async function syncRestResourceArtifacts({
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-source-emitters.ts
-function toPascalCaseFromSlug2(slug) {
-  return normalizeBlockSlug(slug).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
-}
 function indentMultiline(source, prefix) {
   return source.split(`
 `).map((line) => `${prefix}${line}`).join(`
 `);
 }
 function buildRestResourceConfigEntry(restResourceSlug, namespace, methods) {
-  const pascalCase = toPascalCaseFromSlug2(restResourceSlug);
+  const pascalCase = toPascalCase(restResourceSlug);
   const title = toTitleCase(restResourceSlug);
   const manifest = buildRestResourceEndpointManifest({
     namespace,
@@ -1972,7 +3511,7 @@ function buildRestResourceConfigEntry(restResourceSlug, namespace, methods) {
 `);
 }
 function buildRestResourceTypesSource(restResourceSlug, methods) {
-  const pascalCase = toPascalCaseFromSlug2(restResourceSlug);
+  const pascalCase = toPascalCase(restResourceSlug);
   const lines = [
     "import { tags } from 'typia';",
     "",
@@ -2006,7 +3545,7 @@ function buildRestResourceTypesSource(restResourceSlug, methods) {
 `;
 }
 function buildRestResourceValidatorsSource(restResourceSlug, methods) {
-  const pascalCase = toPascalCaseFromSlug2(restResourceSlug);
+  const pascalCase = toPascalCase(restResourceSlug);
   const importedTypes = new Set;
   const validatorDeclarations = [];
   const validatorEntries = [];
@@ -2054,7 +3593,7 @@ ${validatorEntries.join(`
 `;
 }
 function buildRestResourceApiSource(restResourceSlug, methods) {
-  const pascalCase = toPascalCaseFromSlug2(restResourceSlug);
+  const pascalCase = toPascalCase(restResourceSlug);
   const typeImports = new Set;
   const clientEndpointImports = [];
   const exportedBindings = [];
@@ -2199,7 +3738,7 @@ ${exportedBindings.join(`
 `;
 }
 function buildRestResourceDataSource(restResourceSlug, methods) {
-  const pascalCase = toPascalCaseFromSlug2(restResourceSlug);
+  const pascalCase = toPascalCase(restResourceSlug);
   const typeImports = new Set;
   const endpointImports = [];
   const exportedBindings = [];
@@ -2320,9 +3859,6 @@ ${exportedBindings.join(`
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
-function quotePhpString2(value) {
-  return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
-}
 function buildRestResourceRouteRegistrations(restResourceSlug, methods, functions) {
   const collectionRoutes = [];
   const itemRoutes = [];
@@ -2418,7 +3954,7 @@ if ( ! defined( 'ABSPATH' ) ) {
 
 if ( ! function_exists( '${getOptionNameFunctionName}' ) ) {
 	function ${getOptionNameFunctionName}() {
-		return ${quotePhpString2(`${phpPrefix}_${restResourcePhpId}_rest_resource_items`)};
+		return ${quotePhpString(`${phpPrefix}_${restResourcePhpId}_rest_resource_items`)};
 	}
 }
 
@@ -2439,8 +3975,8 @@ if ( ! function_exists( '${getItemsFunctionName}' ) ) {
 		$seed_items = array(
 			array(
 				'id'        => 1,
-				'title'     => ${quotePhpString2(`${restResourceTitle} Starter`)},
-				'content'   => ${quotePhpString2(`Replace this seeded ${restResourceTitle.toLowerCase()} content with your plugin data source.`)},
+				'title'     => ${quotePhpString(`${restResourceTitle} Starter`)},
+				'content'   => ${quotePhpString(`Replace this seeded ${restResourceTitle.toLowerCase()} content with your plugin data source.`)},
 				'status'    => 'draft',
 				'updatedAt' => '2026-01-01T00:00:00Z',
 			),
@@ -2731,7 +4267,7 @@ if ( ! function_exists( '${deleteHandlerName}' ) ) {
 
 if ( ! function_exists( '${registerRoutesFunctionName}' ) ) {
 	function ${registerRoutesFunctionName}() {
-		$namespace = ${quotePhpString2(namespace)};
+		$namespace = ${quotePhpString(namespace)};
 
 ${routeRegistrations}
 	}
@@ -2752,15 +4288,15 @@ async function runAddRestResourceCommand({
   const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
-  const blockConfigPath = path7.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path8.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const syncRestScriptPath = path7.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const restResourceDir = path7.join(workspace.projectDir, "src", "rest", restResourceSlug);
-  const typesFilePath = path7.join(restResourceDir, "api-types.ts");
-  const validatorsFilePath = path7.join(restResourceDir, "api-validators.ts");
-  const apiFilePath = path7.join(restResourceDir, "api.ts");
-  const dataFilePath = path7.join(restResourceDir, "data.ts");
-  const phpFilePath = path7.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
+  const syncRestScriptPath = path8.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const restResourceDir = path8.join(workspace.projectDir, "src", "rest", restResourceSlug);
+  const typesFilePath = path8.join(restResourceDir, "api-types.ts");
+  const validatorsFilePath = path8.join(restResourceDir, "api-validators.ts");
+  const apiFilePath = path8.join(restResourceDir, "api.ts");
+  const dataFilePath = path8.join(restResourceDir, "data.ts");
+  const phpFilePath = path8.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -2771,15 +4307,15 @@ async function runAddRestResourceCommand({
     targetPaths: [restResourceDir, phpFilePath]
   };
   try {
-    await fsp4.mkdir(restResourceDir, { recursive: true });
-    await fsp4.mkdir(path7.dirname(phpFilePath), { recursive: true });
+    await fsp5.mkdir(restResourceDir, { recursive: true });
+    await fsp5.mkdir(path8.dirname(phpFilePath), { recursive: true });
     await ensureRestResourceBootstrapAnchors(workspace);
     await ensureRestResourceSyncScriptAnchors(workspace);
-    await fsp4.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp4.writeFile(validatorsFilePath, buildRestResourceValidatorsSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp4.writeFile(apiFilePath, buildRestResourceApiSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp4.writeFile(dataFilePath, buildRestResourceDataSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp4.writeFile(phpFilePath, buildRestResourcePhpSource(restResourceSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain, resolvedMethods), "utf8");
+    await fsp5.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
+    await fsp5.writeFile(validatorsFilePath, buildRestResourceValidatorsSource(restResourceSlug, resolvedMethods), "utf8");
+    await fsp5.writeFile(apiFilePath, buildRestResourceApiSource(restResourceSlug, resolvedMethods), "utf8");
+    await fsp5.writeFile(dataFilePath, buildRestResourceDataSource(restResourceSlug, resolvedMethods), "utf8");
+    await fsp5.writeFile(phpFilePath, buildRestResourcePhpSource(restResourceSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain, resolvedMethods), "utf8");
     await syncRestResourceArtifacts({
       clientFile: `src/rest/${restResourceSlug}/api-client.ts`,
       methods: resolvedMethods,
@@ -2789,7 +4325,7 @@ async function runAddRestResourceCommand({
       validatorsFile: `src/rest/${restResourceSlug}/api-validators.ts`,
       variables: {
         namespace: resolvedNamespace,
-        pascalCase: toPascalCaseFromSlug2(restResourceSlug),
+        pascalCase: toPascalCase(restResourceSlug),
         slugKebabCase: restResourceSlug,
         title: toTitleCase(restResourceSlug)
       }
@@ -2813,58 +4349,17 @@ async function runAddRestResourceCommand({
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
 var import_semver = __toESM(require_semver(), 1);
-import fs4 from "fs";
-import { promises as fsp5 } from "fs";
-import path8 from "path";
+import fs5 from "fs";
+import { promises as fsp6 } from "fs";
+import path9 from "path";
 import { syncTypeSchemas as syncTypeSchemas2 } from "@wp-typia/block-runtime/metadata-core";
 var ABILITY_SERVER_GLOB = "/inc/abilities/*.php";
 var ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
 var ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
 var ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end";
 var ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start";
-var WP_ABILITIES_PACKAGE_VERSION = "^0.10.0";
-var WP_CORE_ABILITIES_PACKAGE_VERSION = "^0.9.0";
 var WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities";
 var WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
-function escapeRegex3(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-function quotePhpString3(value) {
-  return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
-}
-function findPhpFunctionRange2(source, functionName) {
-  const functionPattern = new RegExp(`function\\s+${escapeRegex3(functionName)}\\s*\\([^)]*\\)\\s*\\{`, "u");
-  const match = functionPattern.exec(source);
-  if (!match) {
-    return null;
-  }
-  const openingBraceIndex = match.index + match[0].length - 1;
-  let depth = 0;
-  for (let index = openingBraceIndex;index < source.length; index += 1) {
-    const character = source[index];
-    if (character === "{") {
-      depth += 1;
-    } else if (character === "}") {
-      depth -= 1;
-      if (depth === 0) {
-        const end = index + 1;
-        return {
-          end,
-          source: source.slice(match.index, end),
-          start: match.index
-        };
-      }
-    }
-  }
-  return null;
-}
-function replacePhpFunctionDefinition2(source, functionName, replacement) {
-  const functionRange = findPhpFunctionRange2(source, functionName);
-  if (!functionRange) {
-    return source;
-  }
-  return `${source.slice(0, functionRange.start)}${replacement.trimStart()}${source.slice(functionRange.end)}`;
-}
 function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
   if (!existingVersion) {
     return requiredVersion;
@@ -2876,15 +4371,12 @@ function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
   }
   return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
 }
-function toPascalCaseFromAbilitySlug(abilitySlug) {
-  return normalizeBlockSlug(abilitySlug).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
-}
 function toAbilityCategorySlug(workspaceNamespace) {
   const normalizedNamespace = workspaceNamespace.replace(/[^a-z0-9-]+/gu, "-").replace(/-{2,}/gu, "-").replace(/^-|-$/gu, "");
   return `${normalizedNamespace || "workspace"}-workflows`;
 }
 function buildAbilityConfigEntry(abilitySlug, compatibilityPolicy) {
-  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+  const pascalCase = toPascalCase(abilitySlug);
   return [
     "\t{",
     `		clientFile: ${quoteTsString(`src/abilities/${abilitySlug}/client.ts`)},`,
@@ -2928,7 +4420,7 @@ function buildAbilityConfigSource(abilitySlug, workspaceNamespace) {
 `;
 }
 function buildAbilityTypesSource(abilitySlug) {
-  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+  const pascalCase = toPascalCase(abilitySlug);
   return `export interface ${pascalCase}AbilityInput {
 	contextId: number;
 	note?: string;
@@ -2943,7 +4435,7 @@ export interface ${pascalCase}AbilityOutput {
 `;
 }
 function buildAbilityDataSource(abilitySlug) {
-  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+  const pascalCase = toPascalCase(abilitySlug);
   const abilityConstBase = abilitySlug.toUpperCase().replace(/[^A-Z0-9]+/gu, "_").replace(/_{2,}/gu, "_").replace(/^_|_$/gu, "");
   return `import {
 	executeAbility,
@@ -3039,7 +4531,7 @@ export async function run${pascalCase}Ability(
 `;
 }
 function buildAbilityClientSource(abilitySlug) {
-  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+  const pascalCase = toPascalCase(abilitySlug);
   return `/**
  * Re-export the typed ${pascalCase} ability client helpers.
  *
@@ -3243,8 +4735,8 @@ if ( ! function_exists( '${executeFunctionName}' ) ) {
 			'status'             => 'ready',
 			'summary'            => sprintf(
 				/* translators: 1: workflow title, 2: context id */
-				__( '%1$s processed context %2$d.', ${quotePhpString3(workspace.workspace.textDomain)} ),
-				${quotePhpString3(abilityTitle)},
+				__( '%1$s processed context %2$d.', ${quotePhpString(workspace.workspace.textDomain)} ),
+				${quotePhpString(abilityTitle)},
 				$context_id
 			),
 		);
@@ -3310,11 +4802,11 @@ if ( ! function_exists( '${abilityRegisterFunctionName}' ) ) {
 		$args = array(
 			'category'            => (string) $config['category']['slug'],
 			'description'         => (string) $config['description'],
-			'execute_callback'    => ${quotePhpString3(executeFunctionName)},
+			'execute_callback'    => ${quotePhpString(executeFunctionName)},
 			'label'               => (string) $config['label'],
 			'meta'                => ${metaFactoryFunctionName}( $config ),
 			'output_schema'       => $output_schema,
-			'permission_callback' => ${quotePhpString3(permissionFunctionName)},
+			'permission_callback' => ${quotePhpString(permissionFunctionName)},
 		);
 
 		if ( is_array( $input_schema ) ) {
@@ -3344,30 +4836,30 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `);
 }
 function resolveAbilityRegistryPath(projectDir) {
-  const abilitiesDir = path8.join(projectDir, "src", "abilities");
-  return [path8.join(abilitiesDir, "index.ts"), path8.join(abilitiesDir, "index.js")].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path8.join(abilitiesDir, "index.ts");
+  const abilitiesDir = path9.join(projectDir, "src", "abilities");
+  return [path9.join(abilitiesDir, "index.ts"), path9.join(abilitiesDir, "index.js")].find((candidatePath) => fs5.existsSync(candidatePath)) ?? path9.join(abilitiesDir, "index.ts");
 }
 function readAbilityRegistrySlugs(registryPath) {
-  if (!fs4.existsSync(registryPath)) {
+  if (!fs5.existsSync(registryPath)) {
     return [];
   }
-  const source = fs4.readFileSync(registryPath, "utf8");
+  const source = fs5.readFileSync(registryPath, "utf8");
   return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeAbilityRegistry(projectDir, abilitySlug) {
-  const abilitiesDir = path8.join(projectDir, "src", "abilities");
+  const abilitiesDir = path9.join(projectDir, "src", "abilities");
   const registryPath = resolveAbilityRegistryPath(projectDir);
-  await fsp5.mkdir(abilitiesDir, { recursive: true });
+  await fsp6.mkdir(abilitiesDir, { recursive: true });
   const existingAbilitySlugs = readWorkspaceInventory(projectDir).abilities.map((entry) => entry.slug);
   const existingRegistrySlugs = readAbilityRegistrySlugs(registryPath);
   const nextAbilitySlugs = Array.from(new Set([...existingAbilitySlugs, ...existingRegistrySlugs, abilitySlug])).sort();
   const generatedSection = buildAbilityRegistrySource(nextAbilitySlugs);
-  const existingSource = fs4.existsSync(registryPath) ? fs4.readFileSync(registryPath, "utf8") : "";
-  const generatedSectionPattern = new RegExp(`${escapeRegex3(ABILITY_REGISTRY_START_MARKER)}[\\s\\S]*?${escapeRegex3(ABILITY_REGISTRY_END_MARKER)}\\n?`, "u");
+  const existingSource = fs5.existsSync(registryPath) ? fs5.readFileSync(registryPath, "utf8") : "";
+  const generatedSectionPattern = new RegExp(`${escapeRegex(ABILITY_REGISTRY_START_MARKER)}[\\s\\S]*?${escapeRegex(ABILITY_REGISTRY_END_MARKER)}\\n?`, "u");
   const nextSource = existingSource ? generatedSectionPattern.test(existingSource) ? existingSource.replace(generatedSectionPattern, generatedSection) : `${existingSource.trimEnd()}
 
 ${generatedSection}` : generatedSection;
-  await fsp5.writeFile(registryPath, nextSource, "utf8");
+  await fsp6.writeFile(registryPath, nextSource, "utf8");
 }
 async function ensureAbilityBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
@@ -3442,7 +4934,6 @@ function ${enqueueFunctionName}() {
       /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
       /\?>\s*$/u
     ];
-    const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex3(functionName)}\\s*\\(`, "u").test(nextSource);
     const insertPhpSnippet = (snippet) => {
       for (const anchor of insertionAnchors) {
         const candidate = nextSource.replace(anchor, (match) => `${snippet}
@@ -3467,13 +4958,13 @@ ${snippet}
 ${snippet}
 `;
     };
-    if (!hasPhpFunctionDefinition(loadFunctionName)) {
+    if (!hasPhpFunctionDefinition(nextSource, loadFunctionName)) {
       insertPhpSnippet(loadFunction);
     }
-    if (!hasPhpFunctionDefinition(enqueueFunctionName)) {
+    if (!hasPhpFunctionDefinition(nextSource, enqueueFunctionName)) {
       insertPhpSnippet(enqueueFunction);
-    } else if (!findPhpFunctionRange2(nextSource, enqueueFunctionName)?.source.includes("wp_enqueue_script_module")) {
-      nextSource = replacePhpFunctionDefinition2(nextSource, enqueueFunctionName, enqueueFunction);
+    } else if (!findPhpFunctionRange(nextSource, enqueueFunctionName)?.source.includes("wp_enqueue_script_module")) {
+      nextSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction, { trimReplacementStart: true }) ?? nextSource;
     }
     if (!nextSource.includes(loadHook)) {
       appendPhpSnippet(loadHook);
@@ -3488,27 +4979,27 @@ ${snippet}
   });
 }
 async function ensureAbilityPackageScripts(workspace) {
-  const packageJsonPath = path8.join(workspace.projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp5.readFile(packageJsonPath, "utf8"));
+  const packageJsonPath = path9.join(workspace.projectDir, "package.json");
+  const packageJson = JSON.parse(await fsp6.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
     "sync-abilities": packageJson.scripts?.["sync-abilities"] ?? "tsx scripts/sync-abilities.ts"
   };
   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;
   }
   packageJson.scripts = nextScripts;
   packageJson.dependencies = nextDependencies;
-  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp6.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function ensureAbilitySyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path8.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path9.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' );";
@@ -3523,7 +5014,7 @@ async function ensureAbilitySyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAbilitiesConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path8.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path9.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(" "));
@@ -3534,7 +5025,7 @@ ${syncAbilitiesConst}`);
     if (!nextSource.includes("runSyncScript( syncAbilitiesScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path8.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path9.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(" "));
@@ -3547,7 +5038,7 @@ ${syncAbilitiesBlock}`);
   });
 }
 async function ensureAbilityBuildScriptAnchors(workspace) {
-  const buildScriptPath = path8.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path9.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     let nextSource = source;
     if (/['"]src\/abilities\/index\.(?:ts|js)['"]/u.test(nextSource)) {
@@ -3557,7 +5048,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     const match = nextSource.match(sharedEntriesPattern);
     if (!match || !match[2].includes("src/bindings/index.ts") || !match[2].includes("src/editor-plugins/index.ts")) {
       throw new Error([
-        `ensureAbilityBuildScriptAnchors could not patch ${path8.basename(buildScriptPath)}.`,
+        `ensureAbilityBuildScriptAnchors could not patch ${path9.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(" "));
@@ -3574,7 +5065,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
   });
 }
 async function ensureAbilityWebpackAnchors(workspace) {
-  const webpackConfigPath = path8.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path9.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]abilities\/index['"]/u.test(source)) {
       return source;
@@ -3605,7 +5096,7 @@ $2`);
     const match = source.match(sharedEntriesPattern);
     if (!match || !match[1].includes("bindings/index") || !match[1].includes("editor-plugins/index")) {
       throw new Error([
-        `ensureAbilityWebpackAnchors could not patch ${path8.basename(webpackConfigPath)}.`,
+        `ensureAbilityWebpackAnchors could not patch ${path9.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(" "));
@@ -3635,20 +5126,20 @@ async function runAddAbilityCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
-  const blockConfigPath = path8.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path9.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path8.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path8.join(workspace.projectDir, "package.json");
-  const syncAbilitiesScriptPath = path8.join(workspace.projectDir, "scripts", "sync-abilities.ts");
-  const syncProjectScriptPath = path8.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const webpackConfigPath = path8.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path9.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path9.join(workspace.projectDir, "package.json");
+  const syncAbilitiesScriptPath = path9.join(workspace.projectDir, "scripts", "sync-abilities.ts");
+  const syncProjectScriptPath = path9.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const webpackConfigPath = path9.join(workspace.projectDir, "webpack.config.js");
   const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
-  const abilityDir = path8.join(workspace.projectDir, "src", "abilities", abilitySlug);
-  const configFilePath = path8.join(abilityDir, "ability.config.json");
-  const typesFilePath = path8.join(abilityDir, "types.ts");
-  const dataFilePath = path8.join(abilityDir, "data.ts");
-  const clientFilePath = path8.join(abilityDir, "client.ts");
-  const phpFilePath = path8.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
+  const abilityDir = path9.join(workspace.projectDir, "src", "abilities", abilitySlug);
+  const configFilePath = path9.join(abilityDir, "ability.config.json");
+  const typesFilePath = path9.join(abilityDir, "types.ts");
+  const dataFilePath = path9.join(abilityDir, "data.ts");
+  const clientFilePath = path9.join(abilityDir, "client.ts");
+  const phpFilePath = path9.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -3664,21 +5155,21 @@ async function runAddAbilityCommand({
     targetPaths: [abilityDir, phpFilePath, syncAbilitiesScriptPath]
   };
   try {
-    await fsp5.mkdir(abilityDir, { recursive: true });
-    await fsp5.mkdir(path8.dirname(phpFilePath), { recursive: true });
+    await fsp6.mkdir(abilityDir, { recursive: true });
+    await fsp6.mkdir(path9.dirname(phpFilePath), { recursive: true });
     await ensureAbilityBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     await ensureAbilityPackageScripts(workspace);
     await ensureAbilitySyncProjectAnchors(workspace);
     await ensureAbilityBuildScriptAnchors(workspace);
     await ensureAbilityWebpackAnchors(workspace);
-    await fsp5.writeFile(syncAbilitiesScriptPath, buildAbilitySyncScriptSource(), "utf8");
-    await fsp5.writeFile(configFilePath, buildAbilityConfigSource(abilitySlug, workspace.workspace.namespace), "utf8");
-    await fsp5.writeFile(typesFilePath, buildAbilityTypesSource(abilitySlug), "utf8");
-    await fsp5.writeFile(dataFilePath, buildAbilityDataSource(abilitySlug), "utf8");
-    await fsp5.writeFile(clientFilePath, buildAbilityClientSource(abilitySlug), "utf8");
-    await fsp5.writeFile(phpFilePath, buildAbilityPhpSource(abilitySlug, workspace), "utf8");
-    const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+    await fsp6.writeFile(syncAbilitiesScriptPath, buildAbilitySyncScriptSource(), "utf8");
+    await fsp6.writeFile(configFilePath, buildAbilityConfigSource(abilitySlug, workspace.workspace.namespace), "utf8");
+    await fsp6.writeFile(typesFilePath, buildAbilityTypesSource(abilitySlug), "utf8");
+    await fsp6.writeFile(dataFilePath, buildAbilityDataSource(abilitySlug), "utf8");
+    await fsp6.writeFile(clientFilePath, buildAbilityClientSource(abilitySlug), "utf8");
+    await fsp6.writeFile(phpFilePath, buildAbilityPhpSource(abilitySlug, workspace), "utf8");
+    const pascalCase = toPascalCase(abilitySlug);
     await syncTypeSchemas2({
       jsonSchemaFile: `src/abilities/${abilitySlug}/input.schema.json`,
       projectRoot: workspace.projectDir,
@@ -3705,12 +5196,12 @@ async function runAddAbilityCommand({
   }
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
-import { promises as fsp7 } from "fs";
-import path11 from "path";
+import { promises as fsp8 } from "fs";
+import path12 from "path";
 
 // ../wp-typia-project-tools/src/runtime/ai-feature-artifacts.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest2,
   syncEndpointClient as syncEndpointClient2,
@@ -3736,7 +5227,7 @@ function normalizeGeneratedArtifactContent(content) {
 }
 async function reconcileGeneratedArtifact(options) {
   if (!options.check) {
-    await mkdir(path9.dirname(options.filePath), {
+    await mkdir(path10.dirname(options.filePath), {
       recursive: true
     });
     await writeFile(options.filePath, options.content, "utf8");
@@ -3808,8 +5299,8 @@ async function syncAiFeatureRestArtifacts({
   const manifest = buildAiFeatureEndpointManifest(variables);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas3({
-      jsonSchemaFile: path9.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path9.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path10.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path10.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -3817,7 +5308,7 @@ async function syncAiFeatureRestArtifacts({
   }
   await syncRestOpenApi2({
     manifest,
-    openApiFile: path9.join(outputDir, "api.openapi.json"),
+    openApiFile: path10.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   }, executionOptions);
@@ -3835,35 +5326,32 @@ async function syncAiFeatureSchemaArtifact({
   outputDir,
   projectDir
 }) {
-  const sourceSchemaPath = path9.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
+  const sourceSchemaPath = path10.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
   const responseSchema = assertJsonObject(JSON.parse(await readFile(sourceSchemaPath, "utf8")), sourceSchemaPath);
   const aiSchema = projectWordPressAiSchema(responseSchema);
   await reconcileGeneratedArtifact({
     check,
     content: `${JSON.stringify(aiSchema, null, 2)}
 `,
-    filePath: path9.join(projectDir, aiSchemaFile),
+    filePath: path10.join(projectDir, aiSchemaFile),
     label: "AI feature schema"
   });
   return {
     aiSchema,
-    aiSchemaPath: path9.join(projectDir, aiSchemaFile),
+    aiSchemaPath: path10.join(projectDir, aiSchemaFile),
     check,
     sourceSchemaPath
   };
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-source-emitters.ts
-function toPascalCaseFromAiFeatureSlug(slug) {
-  return normalizeBlockSlug(slug).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
-}
 function indentMultiline2(source, prefix) {
   return source.split(`
 `).map((line) => `${prefix}${line}`).join(`
 `);
 }
 function buildAiFeatureConfigEntry(aiFeatureSlug, namespace) {
-  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  const pascalCase = toPascalCase(aiFeatureSlug);
   const title = toTitleCase(aiFeatureSlug);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
   const manifest = buildAiFeatureEndpointManifest({
@@ -3893,7 +5381,7 @@ function buildAiFeatureConfigEntry(aiFeatureSlug, namespace) {
 `);
 }
 function buildAiFeatureTypesSource(aiFeatureSlug) {
-  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  const pascalCase = toPascalCase(aiFeatureSlug);
   return `import { tags } from 'typia';
 
 export interface ${pascalCase}AiFeatureRequest {
@@ -3931,7 +5419,7 @@ export interface ${pascalCase}AiFeatureResponse {
 `;
 }
 function buildAiFeatureValidatorsSource(aiFeatureSlug) {
-  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  const pascalCase = toPascalCase(aiFeatureSlug);
   return `import typia from 'typia';
 
 import { toValidationResult } from '@wp-typia/rest';
@@ -3962,7 +5450,7 @@ export const apiValidators = {
 `;
 }
 function buildAiFeatureApiSource(aiFeatureSlug) {
-  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  const pascalCase = toPascalCase(aiFeatureSlug);
   return `import {
 	callEndpoint,
 	resolveRestRouteUrl,
@@ -4017,7 +5505,7 @@ export function runAiFeature( request: ${pascalCase}AiFeatureRequest ) {
 `;
 }
 function buildAiFeatureDataSource(aiFeatureSlug) {
-  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  const pascalCase = toPascalCase(aiFeatureSlug);
   return `import {
 	useEndpointMutation,
 	type UseEndpointMutationOptions,
@@ -4173,12 +5661,9 @@ main().catch( ( error ) => {
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-anchors.ts
-import { promises as fsp6 } from "fs";
-import path10 from "path";
+import { promises as fsp7 } from "fs";
+import path11 from "path";
 var AI_FEATURE_SERVER_GLOB = "/inc/ai-features/*.php";
-function escapeRegex4(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
 async function ensureAiFeatureBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   await patchFile(bootstrapPath, (source) => {
@@ -4197,7 +5682,6 @@ function ${registerFunctionName}() {
       /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
       /\?>\s*$/u
     ];
-    const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex4(functionName)}\\s*\\(`, "u").test(nextSource);
     const insertPhpSnippet = (snippet) => {
       for (const anchor of insertionAnchors) {
         const candidate = nextSource.replace(anchor, (match) => `${snippet}
@@ -4222,11 +5706,11 @@ ${snippet}
 ${snippet}
 `;
     };
-    if (!hasPhpFunctionDefinition(registerFunctionName)) {
+    if (!hasPhpFunctionDefinition(nextSource, registerFunctionName)) {
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(AI_FEATURE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path10.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
+        `Unable to patch ${path11.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(" "));
@@ -4238,8 +5722,8 @@ ${snippet}
   });
 }
 async function ensureAiFeaturePackageScripts(workspace) {
-  const packageJsonPath = path10.join(workspace.projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp6.readFile(packageJsonPath, "utf8"));
+  const packageJsonPath = path11.join(workspace.projectDir, "package.json");
+  const packageJson = JSON.parse(await fsp7.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
     "sync-ai": packageJson.scripts?.["sync-ai"] ?? "tsx scripts/sync-ai-features.ts"
@@ -4258,7 +5742,7 @@ async function ensureAiFeaturePackageScripts(workspace) {
   }
   packageJson.scripts = nextScripts;
   packageJson.devDependencies = nextDevDependencies;
-  await fsp6.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp7.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
   return {
     addedProjectToolsDependency,
@@ -4266,7 +5750,7 @@ async function ensureAiFeaturePackageScripts(workspace) {
   };
 }
 async function ensureAiFeatureSyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path10.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path11.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' );";
@@ -4281,7 +5765,7 @@ async function ensureAiFeatureSyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAiConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path10.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path11.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(" "));
@@ -4292,7 +5776,7 @@ ${syncAiConst}`);
     if (!nextSource.includes("runSyncScript( syncAiScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path10.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path11.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(" "));
@@ -4307,7 +5791,7 @@ ${syncAiBlock}`);
 function assertSyncRestAnchor2(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureAiFeatureSyncRestAnchors could not patch ${path10.basename(syncRestScriptPath)}.`,
+      `ensureAiFeatureSyncRestAnchors could not patch ${path11.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(" "));
@@ -4322,7 +5806,7 @@ function replaceRequiredSyncRestSource2(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureAiFeatureSyncRestAnchors(workspace) {
-  const syncRestScriptPath = path10.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path11.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = [
@@ -4451,9 +5935,6 @@ async function ensureAiFeatureSyncRestAnchors(workspace) {
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
-function quotePhpString4(value) {
-  return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
-}
 function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
   const aiFeatureTitle = toTitleCase(aiFeatureSlug);
   const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
@@ -4549,7 +6030,7 @@ if ( ! function_exists( '${buildPromptFunctionName}' ) ) {
 	function ${buildPromptFunctionName}( array $payload ) {
 		return sprintf(
 			'You are helping with the %1$s AI workflow. Read the JSON request payload and return JSON that matches the provided schema. Request payload: %2$s',
-			${quotePhpString4(aiFeatureTitle)},
+			${quotePhpString(aiFeatureTitle)},
 			wp_json_encode( $payload )
 		);
 	}
@@ -4678,8 +6159,8 @@ if ( ! function_exists( '${adminNoticeFunctionName}' ) ) {
 
 		$message = sprintf(
 			/* translators: %s: AI feature name. */
-			__( 'The %s AI feature is optional and remains disabled until the WordPress AI Client is available with structured text generation support for the generated schema.', ${quotePhpString4(textDomain)} ),
-			${quotePhpString4(aiFeatureTitle)}
+			__( 'The %s AI feature is optional and remains disabled until the WordPress AI Client is available with structured text generation support for the generated schema.', ${quotePhpString(textDomain)} ),
+			${quotePhpString(aiFeatureTitle)}
 		);
 		printf( '<div class="notice notice-warning"><p>%s</p></div>', esc_html( $message ) );
 	}
@@ -4814,7 +6295,7 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 if ( ! function_exists( '${registerRoutesFunctionName}' ) ) {
 	function ${registerRoutesFunctionName}() {
 		register_rest_route(
-			${quotePhpString4(namespace)},
+			${quotePhpString(namespace)},
 			'/ai/${aiFeatureSlug}',
 			array(
 				array(
@@ -4842,18 +6323,18 @@ async function runAddAiFeatureCommand({
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
-  const blockConfigPath = path11.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path12.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const packageJsonPath = path11.join(workspace.projectDir, "package.json");
-  const syncAiScriptPath = path11.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
-  const syncProjectScriptPath = path11.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const syncRestScriptPath = path11.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const aiFeatureDir = path11.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
-  const typesFilePath = path11.join(aiFeatureDir, "api-types.ts");
-  const validatorsFilePath = path11.join(aiFeatureDir, "api-validators.ts");
-  const apiFilePath = path11.join(aiFeatureDir, "api.ts");
-  const dataFilePath = path11.join(aiFeatureDir, "data.ts");
-  const phpFilePath = path11.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
+  const packageJsonPath = path12.join(workspace.projectDir, "package.json");
+  const syncAiScriptPath = path12.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
+  const syncProjectScriptPath = path12.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncRestScriptPath = path12.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const aiFeatureDir = path12.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
+  const typesFilePath = path12.join(aiFeatureDir, "api-types.ts");
+  const validatorsFilePath = path12.join(aiFeatureDir, "api-validators.ts");
+  const apiFilePath = path12.join(aiFeatureDir, "api.ts");
+  const dataFilePath = path12.join(aiFeatureDir, "data.ts");
+  const phpFilePath = path12.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -4867,23 +6348,23 @@ async function runAddAiFeatureCommand({
     targetPaths: [aiFeatureDir, phpFilePath, syncAiScriptPath]
   };
   try {
-    await fsp7.mkdir(aiFeatureDir, { recursive: true });
-    await fsp7.mkdir(path11.dirname(phpFilePath), { recursive: true });
+    await fsp8.mkdir(aiFeatureDir, { recursive: true });
+    await fsp8.mkdir(path12.dirname(phpFilePath), { recursive: true });
     await ensureAiFeatureBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
     await ensureAiFeatureSyncProjectAnchors(workspace);
     await ensureAiFeatureSyncRestAnchors(workspace);
-    await fsp7.writeFile(syncAiScriptPath, buildAiFeatureSyncScriptSource(), "utf8");
-    await fsp7.writeFile(typesFilePath, buildAiFeatureTypesSource(aiFeatureSlug), "utf8");
-    await fsp7.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
-    await fsp7.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
-    await fsp7.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
-    await fsp7.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
-    const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+    await fsp8.writeFile(syncAiScriptPath, buildAiFeatureSyncScriptSource(), "utf8");
+    await fsp8.writeFile(typesFilePath, buildAiFeatureTypesSource(aiFeatureSlug), "utf8");
+    await fsp8.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
+    await fsp8.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
+    await fsp8.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
+    await fsp8.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
+    const pascalCase = toPascalCase(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
-      outputDir: path11.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path12.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir,
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
@@ -4896,7 +6377,7 @@ async function runAddAiFeatureCommand({
     });
     await syncAiFeatureSchemaArtifact({
       aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
-      outputDir: path11.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path12.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -4921,7 +6402,168 @@ async function runAddAiFeatureCommand({
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
 var VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
+var VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
 var VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
+var VARIATIONS_CALL_PATTERN = /registerWorkspaceVariations\s*\(\s*\)\s*;?/u;
+var BLOCK_STYLES_IMPORT_LINE = "import { registerWorkspaceBlockStyles } from './styles';";
+var BLOCK_STYLES_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceBlockStyles\s*\}\s*from\s*["']\.\/styles["']\s*;?\s*$/mu;
+var BLOCK_STYLES_CALL_LINE = "registerWorkspaceBlockStyles();";
+var BLOCK_STYLES_CALL_PATTERN = /registerWorkspaceBlockStyles\s*\(\s*\)\s*;?/u;
+var BLOCK_TRANSFORMS_IMPORT_LINE = "import { applyWorkspaceBlockTransforms } from './transforms';";
+var BLOCK_TRANSFORMS_IMPORT_PATTERN = /^\s*import\s*\{\s*applyWorkspaceBlockTransforms\s*\}\s*from\s*["']\.\/transforms["']\s*;?\s*$/mu;
+var BLOCK_TRANSFORMS_CALL_LINE = "applyWorkspaceBlockTransforms(registration.settings);";
+var BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+var SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN = /registerScaffoldBlockType\s*\(\s*registration\s*\.\s*name\s*,\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+var FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+function maskSourceSegment(segment) {
+  return segment.replace(/[^\n\r]/gu, " ");
+}
+function maskTypeScriptComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment).replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
+}
+function maskTypeScriptCommentsAndLiterals(source) {
+  let maskedSource = "";
+  let index = 0;
+  while (index < source.length) {
+    const current = source[index];
+    const next = source[index + 1];
+    if (current === "/" && next === "/") {
+      const start = index;
+      index += 2;
+      while (index < source.length && source[index] !== `
+` && source[index] !== "\r") {
+        index += 1;
+      }
+      maskedSource += maskSourceSegment(source.slice(start, index));
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      const start = index;
+      index += 2;
+      while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
+        index += 1;
+      }
+      index = Math.min(index + 2, source.length);
+      maskedSource += maskSourceSegment(source.slice(start, index));
+      continue;
+    }
+    if (current === "'" || current === '"' || current === "`") {
+      const start = index;
+      const quote = current;
+      index += 1;
+      while (index < source.length) {
+        const char = source[index];
+        if (char === "\\") {
+          index += 2;
+          continue;
+        }
+        index += 1;
+        if (char === quote) {
+          break;
+        }
+      }
+      maskedSource += maskSourceSegment(source.slice(start, index));
+      continue;
+    }
+    maskedSource += current;
+    index += 1;
+  }
+  return maskedSource;
+}
+function hasExecutablePattern(source, pattern) {
+  return pattern.test(maskTypeScriptCommentsAndLiterals(source));
+}
+function hasUncommentedPattern(source, pattern) {
+  return pattern.test(maskTypeScriptComments(source));
+}
+function findExecutablePatternMatch(source, patterns) {
+  const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+  for (const pattern of patterns) {
+    const match = pattern.exec(maskedSource);
+    if (match && match.index !== undefined) {
+      return {
+        end: match.index + match[0].length,
+        start: match.index
+      };
+    }
+  }
+  return;
+}
+function isIdentifierBoundary(source, index) {
+  if (index < 0 || index >= source.length) {
+    return true;
+  }
+  return !/[A-Za-z0-9_$]/u.test(source[index] ?? "");
+}
+function skipWhitespace(source, index) {
+  let cursor = index;
+  while (cursor < source.length && /\s/u.test(source[cursor] ?? "")) {
+    cursor += 1;
+  }
+  return cursor;
+}
+function findMatchingDelimiterEnd(source, openIndex, openDelimiter, closeDelimiter) {
+  let depth = 0;
+  for (let index = openIndex;index < source.length; index += 1) {
+    const char = source[index];
+    if (char === openDelimiter) {
+      depth += 1;
+      continue;
+    }
+    if (char === closeDelimiter) {
+      depth -= 1;
+      if (depth === 0) {
+        return index + 1;
+      }
+    }
+  }
+  return;
+}
+function findExecutableCallRange(source, callName) {
+  const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+  let searchIndex = 0;
+  while (searchIndex < maskedSource.length) {
+    const callNameIndex = maskedSource.indexOf(callName, searchIndex);
+    if (callNameIndex === -1) {
+      return;
+    }
+    const callNameEnd = callNameIndex + callName.length;
+    if (!isIdentifierBoundary(maskedSource, callNameIndex - 1) || !isIdentifierBoundary(maskedSource, callNameEnd)) {
+      searchIndex = callNameEnd;
+      continue;
+    }
+    let cursor = skipWhitespace(maskedSource, callNameEnd);
+    if (maskedSource[cursor] === "<") {
+      const genericEnd = findMatchingDelimiterEnd(maskedSource, cursor, "<", ">");
+      if (genericEnd === undefined) {
+        searchIndex = callNameEnd;
+        continue;
+      }
+      cursor = skipWhitespace(maskedSource, genericEnd);
+    }
+    if (maskedSource[cursor] !== "(") {
+      searchIndex = callNameEnd;
+      continue;
+    }
+    const callEnd = findMatchingDelimiterEnd(maskedSource, cursor, "(", ")");
+    if (callEnd === undefined) {
+      searchIndex = callNameEnd;
+      continue;
+    }
+    let end = skipWhitespace(maskedSource, callEnd);
+    if (maskedSource[end] === ";") {
+      end += 1;
+    }
+    return {
+      end,
+      start: callNameIndex
+    };
+  }
+  return;
+}
+function findBlockRegistrationCallRange(source) {
+  return findExecutableCallRange(source, "registerScaffoldBlockType") ?? findExecutableCallRange(source, "registerBlockType");
+}
 function buildVariationConfigEntry(blockSlug, variationSlug) {
   return [
     "\t{",
@@ -4991,49 +6633,300 @@ export function registerWorkspaceVariations() {
 }
 `;
 }
+function buildWorkspaceConstName(prefix, slug) {
+  return `workspace${prefix}_${toSnakeCase(slug)}`;
+}
+function buildBlockStyleConfigEntry(blockSlug, styleSlug) {
+  return [
+    "\t{",
+    `		block: ${quoteTsString(blockSlug)},`,
+    `		file: ${quoteTsString(`src/blocks/${blockSlug}/styles/${styleSlug}.ts`)},`,
+    `		slug: ${quoteTsString(styleSlug)},`,
+    "\t},"
+  ].join(`
+`);
+}
+function buildBlockTransformConfigEntry(options) {
+  return [
+    "\t{",
+    `		block: ${quoteTsString(options.blockSlug)},`,
+    `		file: ${quoteTsString(`src/blocks/${options.blockSlug}/transforms/${options.transformSlug}.ts`)},`,
+    `		from: ${quoteTsString(options.fromBlockName)},`,
+    `		slug: ${quoteTsString(options.transformSlug)},`,
+    `		to: ${quoteTsString(options.toBlockName)},`,
+    "\t},"
+  ].join(`
+`);
+}
+function getBlockStyleConstBindings(styleSlugs) {
+  const seenConstNames = new Map;
+  return styleSlugs.map((styleSlug) => {
+    const constName = buildWorkspaceConstName("BlockStyle", styleSlug);
+    const previousSlug = seenConstNames.get(constName);
+    if (previousSlug && previousSlug !== styleSlug) {
+      throw new Error(`Style slugs "${previousSlug}" and "${styleSlug}" generate the same registry identifier "${constName}". Rename one of the styles.`);
+    }
+    seenConstNames.set(constName, styleSlug);
+    return { constName, styleSlug };
+  });
+}
+function getBlockTransformConstBindings(transformSlugs) {
+  const seenConstNames = new Map;
+  return transformSlugs.map((transformSlug) => {
+    const constName = buildWorkspaceConstName("BlockTransform", transformSlug);
+    const previousSlug = seenConstNames.get(constName);
+    if (previousSlug && previousSlug !== transformSlug) {
+      throw new Error(`Transform slugs "${previousSlug}" and "${transformSlug}" generate the same registry identifier "${constName}". Rename one of the transforms.`);
+    }
+    seenConstNames.set(constName, transformSlug);
+    return { constName, transformSlug };
+  });
+}
+function buildBlockStyleSource(styleSlug, textDomain) {
+  const styleTitle = toTitleCase(styleSlug);
+  const styleConstName = buildWorkspaceConstName("BlockStyle", styleSlug);
+  return `import { __ } from '@wordpress/i18n';
+
+export const ${styleConstName} = {
+	name: ${quoteTsString(styleSlug)},
+	label: __( ${quoteTsString(styleTitle)}, ${quoteTsString(textDomain)} ),
+} as const;
+`;
+}
+function buildBlockStyleIndexSource(styleSlugs) {
+  const styleBindings = getBlockStyleConstBindings(styleSlugs);
+  const importLines = styleBindings.map(({ constName, styleSlug }) => `import { ${constName} } from './${styleSlug}';`).join(`
+`);
+  const styleConstNames = styleBindings.map(({ constName }) => constName).join(`,
+	`);
+  return `import { registerBlockStyle } from '@wordpress/blocks';
+import metadata from '../block.json';
+${importLines ? `
+${importLines}` : ""}
+
+const WORKSPACE_BLOCK_STYLES = [
+	${styleConstNames}
+	// wp-typia add style entries
+] as const;
+
+export function registerWorkspaceBlockStyles() {
+	for (const style of WORKSPACE_BLOCK_STYLES) {
+		registerBlockStyle(metadata.name, style);
+	}
+}
+`;
+}
+function buildBlockTransformSource(options) {
+  const transformTitle = toTitleCase(options.transformSlug);
+  const transformConstName = buildWorkspaceConstName("BlockTransform", options.transformSlug);
+  return `import { createBlock } from '@wordpress/blocks';
+import { __ } from '@wordpress/i18n';
+import metadata from '../block.json';
+
+type TransformAttributes = Record<string, unknown>;
+type TransformInnerBlock = ReturnType<typeof createBlock>;
+
+function mapTransformAttributes(attributes: TransformAttributes): TransformAttributes {
+	const content = attributes.content;
+
+	return typeof content === 'string' ? { content } : {};
+}
+
+export const ${transformConstName} = {
+	type: 'block',
+	blocks: [${quoteTsString(options.fromBlockName)}],
+	title: __( ${quoteTsString(transformTitle)}, ${quoteTsString(options.textDomain)} ),
+	transform: (
+		attributes: TransformAttributes,
+		innerBlocks: TransformInnerBlock[] = [],
+	) => createBlock(metadata.name, mapTransformAttributes(attributes), innerBlocks),
+} as const;
+`;
+}
+function buildBlockTransformIndexSource(transformSlugs) {
+  const transformBindings = getBlockTransformConstBindings(transformSlugs);
+  const importLines = transformBindings.map(({ constName, transformSlug }) => `import { ${constName} } from './${transformSlug}';`).join(`
+`);
+  const transformConstNames = transformBindings.map(({ constName }) => constName).join(`,
+	`);
+  return `${importLines ? `${importLines}
+
+` : ""}type BlockSettingsWithTransforms = {
+	transforms?: {
+		from?: unknown[];
+		to?: unknown[];
+	};
+};
+
+const WORKSPACE_BLOCK_TRANSFORMS = [
+	${transformConstNames}
+	// wp-typia add transform entries
+] as const;
+
+export function applyWorkspaceBlockTransforms(settings: BlockSettingsWithTransforms) {
+	const transforms = settings.transforms ?? {};
+
+	settings.transforms = {
+		...transforms,
+		from: [...(transforms.from ?? []), ...WORKSPACE_BLOCK_TRANSFORMS],
+	};
+}
+`;
+}
 async function ensureVariationRegistrationHook(blockIndexPath) {
   await patchFile(blockIndexPath, (source) => {
     let nextSource = source;
-    if (!nextSource.includes(VARIATIONS_IMPORT_LINE)) {
+    if (!hasUncommentedPattern(nextSource, VARIATIONS_IMPORT_PATTERN)) {
       nextSource = `${VARIATIONS_IMPORT_LINE}
 ${nextSource}`;
     }
-    if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
-      const callInsertionPatterns = [
-        /(registerBlockType<[\s\S]*?\);\s*)/u,
-        /(registerBlockType\([\s\S]*?\);\s*)/u
-      ];
-      let inserted = false;
-      for (const pattern of callInsertionPatterns) {
-        const candidate = nextSource.replace(pattern, (match) => `${match}
+    if (!hasExecutablePattern(nextSource, VARIATIONS_CALL_PATTERN)) {
+      const callRange = findBlockRegistrationCallRange(nextSource);
+      if (callRange) {
+        nextSource = [
+          nextSource.slice(0, callRange.end),
+          `
 ${VARIATIONS_CALL_LINE}
-`);
-        if (candidate !== nextSource) {
-          nextSource = candidate;
-          inserted = true;
-          break;
-        }
-      }
-      if (!inserted) {
+`,
+          nextSource.slice(callRange.end)
+        ].join("");
+      } else {
         nextSource = `${nextSource.trimEnd()}
 
 ${VARIATIONS_CALL_LINE}
 `;
       }
     }
-    if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
-      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path12.basename(blockIndexPath)}.`);
+    if (!hasExecutablePattern(nextSource, VARIATIONS_CALL_PATTERN)) {
+      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path13.basename(blockIndexPath)}.`);
+    }
+    return nextSource;
+  });
+}
+async function ensureBlockStyleRegistrationHook(blockIndexPath) {
+  await patchFile(blockIndexPath, (source) => {
+    let nextSource = source;
+    if (!hasUncommentedPattern(nextSource, BLOCK_STYLES_IMPORT_PATTERN)) {
+      nextSource = `${BLOCK_STYLES_IMPORT_LINE}
+${nextSource}`;
+    }
+    if (!hasExecutablePattern(nextSource, BLOCK_STYLES_CALL_PATTERN)) {
+      const callRange = findBlockRegistrationCallRange(nextSource);
+      if (callRange) {
+        nextSource = [
+          nextSource.slice(0, callRange.end),
+          `
+${BLOCK_STYLES_CALL_LINE}
+`,
+          nextSource.slice(callRange.end)
+        ].join("");
+      } else {
+        nextSource = `${nextSource.trimEnd()}
+
+${BLOCK_STYLES_CALL_LINE}
+`;
+      }
+    }
+    if (!hasExecutablePattern(nextSource, BLOCK_STYLES_CALL_PATTERN)) {
+      throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path13.basename(blockIndexPath)}.`);
+    }
+    return nextSource;
+  });
+}
+async function ensureBlockTransformRegistrationHook(blockIndexPath) {
+  await patchFile(blockIndexPath, (source) => {
+    let nextSource = source;
+    if (!hasUncommentedPattern(nextSource, BLOCK_TRANSFORMS_IMPORT_PATTERN)) {
+      nextSource = `${BLOCK_TRANSFORMS_IMPORT_LINE}
+${nextSource}`;
+    }
+    if (!hasExecutablePattern(nextSource, BLOCK_TRANSFORMS_CALL_PATTERN)) {
+      const callRange = findExecutablePatternMatch(nextSource, [
+        SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN
+      ]);
+      if (!callRange) {
+        throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path13.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
+      }
+      nextSource = [
+        nextSource.slice(0, callRange.start),
+        `${BLOCK_TRANSFORMS_CALL_LINE}
+`,
+        nextSource.slice(callRange.start)
+      ].join("");
     }
     return nextSource;
   });
 }
 async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
-  const variationsDir = path12.join(projectDir, "src", "blocks", blockSlug, "variations");
-  const variationsIndexPath = path12.join(variationsDir, "index.ts");
-  await fsp8.mkdir(variationsDir, { recursive: true });
-  const existingVariationSlugs = fs5.readdirSync(variationsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const variationsDir = path13.join(projectDir, "src", "blocks", blockSlug, "variations");
+  const variationsIndexPath = path13.join(variationsDir, "index.ts");
+  await fsp9.mkdir(variationsDir, { recursive: true });
+  const existingVariationSlugs = fs6.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 fsp8.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
+  await fsp9.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
+}
+async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
+  const stylesDir = path13.join(projectDir, "src", "blocks", blockSlug, "styles");
+  const stylesIndexPath = path13.join(stylesDir, "index.ts");
+  await fsp9.mkdir(stylesDir, { recursive: true });
+  const existingStyleSlugs = fs6.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 fsp9.writeFile(stylesIndexPath, buildBlockStyleIndexSource(nextStyleSlugs), "utf8");
+}
+async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug) {
+  const transformsDir = path13.join(projectDir, "src", "blocks", blockSlug, "transforms");
+  const transformsIndexPath = path13.join(transformsDir, "index.ts");
+  await fsp9.mkdir(transformsDir, { recursive: true });
+  const existingTransformSlugs = fs6.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 fsp9.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
+}
+function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
+  const stylePath = path13.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
+  if (fs6.existsSync(stylePath)) {
+    throw new Error(`A block style already exists at ${path13.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 = path13.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
+  if (fs6.existsSync(transformPath)) {
+    throw new Error(`A block transform already exists at ${path13.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.`);
+  }
+}
+function assertFullBlockName(blockName, flagName) {
+  const trimmed = blockName.trim();
+  if (!trimmed) {
+    throw new Error(`\`${flagName}\` requires a block name.`);
+  }
+  if (!FULL_BLOCK_NAME_PATTERN.test(trimmed)) {
+    throw new Error(`\`${flagName}\` must use <namespace/block-slug> format.`);
+  }
+  return trimmed;
+}
+function resolveWorkspaceTargetBlockName(blockName, namespace, flagName) {
+  const trimmed = blockName.trim();
+  if (!trimmed) {
+    throw new Error(`\`${flagName}\` requires <block-slug|namespace/block-slug>.`);
+  }
+  const blockNameSegments = trimmed.split("/");
+  if (blockNameSegments.length > 2 || blockNameSegments.some((segment) => segment.trim() === "")) {
+    throw new Error(`\`${flagName}\` must use <block-slug|namespace/block-slug> format.`);
+  }
+  const [maybeNamespace, maybeSlug] = blockNameSegments.length === 2 ? blockNameSegments : [undefined, blockNameSegments[0]];
+  if (maybeNamespace && maybeNamespace !== namespace) {
+    throw new Error(`\`${flagName}\` references namespace "${maybeNamespace}". Expected "${namespace}".`);
+  }
+  const blockSlug = normalizeBlockSlug(maybeSlug ?? "");
+  return {
+    blockName: `${namespace}/${blockSlug}`,
+    blockSlug
+  };
 }
 async function runAddVariationCommand({
   blockName,
@@ -5046,11 +6939,12 @@ async function runAddVariationCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
-  const blockConfigPath = path12.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path12.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const variationsDir = path12.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
-  const variationFilePath = path12.join(variationsDir, `${variationSlug}.ts`);
-  const variationsIndexPath = path12.join(variationsDir, "index.ts");
+  const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const variationsDir = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
+  const variationFilePath = path13.join(variationsDir, `${variationSlug}.ts`);
+  const variationsIndexPath = path13.join(variationsDir, "index.ts");
+  const shouldRemoveVariationsDirOnRollback = !fs6.existsSync(variationsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -5058,11 +6952,14 @@ async function runAddVariationCommand({
       variationsIndexPath
     ]),
     snapshotDirs: [],
-    targetPaths: [variationFilePath]
+    targetPaths: [
+      variationFilePath,
+      ...shouldRemoveVariationsDirOnRollback ? [variationsDir] : []
+    ]
   };
   try {
-    await fsp8.mkdir(variationsDir, { recursive: true });
-    await fsp8.writeFile(variationFilePath, buildVariationSource(variationSlug, workspace.workspace.textDomain), "utf8");
+    await fsp9.mkdir(variationsDir, { recursive: true });
+    await fsp9.writeFile(variationFilePath, buildVariationSource(variationSlug, workspace.workspace.textDomain), "utf8");
     await writeVariationRegistry(workspace.projectDir, blockSlug, variationSlug);
     await ensureVariationRegistrationHook(blockIndexPath);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -5078,6 +6975,115 @@ async function runAddVariationCommand({
     throw error;
   }
 }
+async function runAddBlockStyleCommand({
+  blockName,
+  cwd = process.cwd(),
+  styleName
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const blockSlug = normalizeBlockSlug(blockName);
+  const styleSlug = assertValidGeneratedSlug("Style name", normalizeBlockSlug(styleName), "wp-typia add style <name> --block <block-slug>");
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  resolveWorkspaceBlock(inventory, blockSlug);
+  assertBlockStyleDoesNotExist(workspace.projectDir, blockSlug, styleSlug, inventory);
+  const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const stylesDir = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
+  const styleFilePath = path13.join(stylesDir, `${styleSlug}.ts`);
+  const stylesIndexPath = path13.join(stylesDir, "index.ts");
+  const shouldRemoveStylesDirOnRollback = !fs6.existsSync(stylesDir);
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles([
+      blockConfigPath,
+      blockIndexPath,
+      stylesIndexPath
+    ]),
+    snapshotDirs: [],
+    targetPaths: [
+      styleFilePath,
+      ...shouldRemoveStylesDirOnRollback ? [stylesDir] : []
+    ]
+  };
+  try {
+    await fsp9.mkdir(stylesDir, { recursive: true });
+    await fsp9.writeFile(styleFilePath, buildBlockStyleSource(styleSlug, workspace.workspace.textDomain), "utf8");
+    await writeBlockStyleRegistry(workspace.projectDir, blockSlug, styleSlug);
+    await ensureBlockStyleRegistrationHook(blockIndexPath);
+    await appendWorkspaceInventoryEntries(workspace.projectDir, {
+      blockStyleEntries: [buildBlockStyleConfigEntry(blockSlug, styleSlug)]
+    });
+    return {
+      blockSlug,
+      projectDir: workspace.projectDir,
+      styleSlug
+    };
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw error;
+  }
+}
+async function runAddBlockTransformCommand({
+  cwd = process.cwd(),
+  fromBlockName,
+  toBlockName,
+  transformName
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const transformSlug = assertValidGeneratedSlug("Transform name", normalizeBlockSlug(transformName), "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>");
+  const resolvedFromBlockName = assertFullBlockName(fromBlockName, "--from");
+  const target = resolveWorkspaceTargetBlockName(toBlockName, workspace.workspace.namespace, "--to");
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  resolveWorkspaceBlock(inventory, target.blockSlug);
+  assertBlockTransformDoesNotExist(workspace.projectDir, target.blockSlug, transformSlug, inventory);
+  const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path13.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
+  const transformsDir = path13.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
+  const transformFilePath = path13.join(transformsDir, `${transformSlug}.ts`);
+  const transformsIndexPath = path13.join(transformsDir, "index.ts");
+  const shouldRemoveTransformsDirOnRollback = !fs6.existsSync(transformsDir);
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles([
+      blockConfigPath,
+      blockIndexPath,
+      transformsIndexPath
+    ]),
+    snapshotDirs: [],
+    targetPaths: [
+      transformFilePath,
+      ...shouldRemoveTransformsDirOnRollback ? [transformsDir] : []
+    ]
+  };
+  try {
+    await fsp9.mkdir(transformsDir, { recursive: true });
+    await fsp9.writeFile(transformFilePath, buildBlockTransformSource({
+      fromBlockName: resolvedFromBlockName,
+      textDomain: workspace.workspace.textDomain,
+      transformSlug
+    }), "utf8");
+    await writeBlockTransformRegistry(workspace.projectDir, target.blockSlug, transformSlug);
+    await ensureBlockTransformRegistrationHook(blockIndexPath);
+    await appendWorkspaceInventoryEntries(workspace.projectDir, {
+      blockTransformEntries: [
+        buildBlockTransformConfigEntry({
+          blockSlug: target.blockSlug,
+          fromBlockName: resolvedFromBlockName,
+          toBlockName: target.blockName,
+          transformSlug
+        })
+      ]
+    });
+    return {
+      blockSlug: target.blockSlug,
+      fromBlockName: resolvedFromBlockName,
+      projectDir: workspace.projectDir,
+      toBlockName: target.blockName,
+      transformSlug
+    };
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw error;
+  }
+}
 async function runAddHookedBlockCommand({
   anchorBlockName,
   blockName,
@@ -5095,7 +7101,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 = path12.relative(workspace.projectDir, blockJsonPath);
+  const blockJsonRelativePath = path13.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}".`);
@@ -5107,7 +7113,7 @@ async function runAddHookedBlockCommand({
   };
   try {
     blockHooks[resolvedAnchorBlockName] = resolvedPosition;
-    await fsp8.writeFile(blockJsonPath, JSON.stringify(blockJson, null, "\t"), "utf8");
+    await fsp9.writeFile(blockJsonPath, JSON.stringify(blockJson, null, "\t"), "utf8");
     return {
       anchorBlockName: resolvedAnchorBlockName,
       blockSlug,
@@ -5126,9 +7132,12 @@ export {
   runAddPatternCommand,
   runAddHookedBlockCommand,
   runAddEditorPluginCommand,
+  runAddBlockTransformCommand,
+  runAddBlockStyleCommand,
   runAddBlockCommand,
   runAddBindingSourceCommand,
   runAddAiFeatureCommand,
+  runAddAdminViewCommand,
   runAddAbilityCommand,
   getWorkspaceBlockSelectOptions,
   formatAddHelpText,
@@ -5137,4 +7146,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=497A4F5F67BAF4EF64756E2164756E21
+//# debugId=8932DC6C8A5BAD5564756E2164756E21