wp-typia 0.23.0 → 0.23.1

package/dist-bunli/{cli-add-21bvpfgw.js → cli-add-xjaaa01x.js}

@@ -2,10 +2,13 @@
 import {
   OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY,
   REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY,
+  appendPhpSnippetBeforeClosingTag,
   assertExternalLayerCompositionOptions,
   copyInterpolatedDirectory,
   createScaffoldCompatibilityConfig,
+  executeWorkspaceMutationPlan,
   getDefaultAnswers,
+  insertPhpSnippetBeforeWorkspaceAnchors,
   isCompoundPersistenceEnabled,
   listInterpolatedDirectoryOutputs,
   normalizeOptionalCliString,
@@ -17,14 +20,15 @@ import {
   resolveOptionalInteractiveExternalLayerId,
   resolveScaffoldCompatibilityPolicy,
   resolveTemplateSeed,
+  runAddIntegrationEnvCommand,
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-1meywwsy.js";
+} from "./cli-y7w3pybs.js";
 import {
   parseTemplateLocator,
   require_semver
-} from "./cli-8reep89s.js";
+} from "./cli-9fx0qgb7.js";
 import {
   ADMIN_VIEWS_ASSET,
   ADMIN_VIEWS_PHP_GLOB,
@@ -47,7 +51,7 @@ import {
   isAdminViewRestResourceSource,
   maskTypeScriptCommentsAndLiterals
 } from "./cli-j8et6jvr.js";
-import"./cli-c2acv5dv.js";
+import"./cli-nvs5atj1.js";
 import {
   DEFAULT_WORDPRESS_ABILITIES_VERSION,
   DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
@@ -57,19 +61,19 @@ import {
   DEFAULT_WP_TYPIA_DATAVIEWS_VERSION,
   getPackageVersions,
   resolveManagedPackageVersionRange
-} from "./cli-agywa5n6.js";
+} from "./cli-fp16mntv.js";
 import {
   SHARED_WORKSPACE_TEMPLATE_ROOT
-} from "./cli-qse6myha.js";
+} from "./cli-8hxf9qw6.js";
 import {
   snapshotProjectVersion
-} from "./cli-9npd9was.js";
+} from "./cli-epsczb1c.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
   writeInitialMigrationScaffold,
   writeMigrationConfig
-} from "./cli-2rqf6t0b.js";
+} from "./cli-e4bwd81c.js";
 import {
   ADD_BLOCK_TEMPLATE_IDS,
   EDITOR_PLUGIN_SLOT_IDS,
@@ -89,7 +93,6 @@ import {
   assertValidGeneratedSlug,
   assertValidHookAnchor,
   assertValidHookedBlockPosition,
-  assertValidIntegrationEnvService,
   assertValidManualRestContractAuth,
   assertValidManualRestContractHttpMethod,
   assertValidPostMetaPostType,
@@ -97,6 +100,7 @@ import {
   assertValidTypeScriptIdentifier,
   assertVariationDoesNotExist,
   buildWorkspacePhpPrefix,
+  collectRestRouteNamedCaptureNames,
   escapeRegex,
   findPhpFunctionRange,
   formatAddHelpText,
@@ -136,7 +140,7 @@ import {
   toPascalCase,
   toSnakeCase,
   toTitleCase
-} from "./cli-ts9thts5.js";
+} from "./cli-k5q5v8g6.js";
 import"./cli-cvxvcw7c.js";
 import {
   createManagedTempRoot
@@ -144,15 +148,18 @@ import {
 import {
   ADD_KIND_IDS
 } from "./cli-43mx1vfb.js";
-import"./cli-p95wr1q8.js";
+import"./cli-tq730sqt.js";
 import {
   resolveWorkspaceProject
-} from "./cli-hhp1d348.js";
+} from "./cli-1170yyve.js";
+import {
+  formatInstallCommand
+} from "./cli-am5x7tb4.js";
 import {
-  formatInstallCommand,
-  formatRunScript
-} from "./cli-52ke0ptp.js";
-import"./cli-bq2v559b.js";
+  readJsonFile,
+  safeJsonParse
+} from "./cli-ccax7s0s.js";
+import"./cli-rdcga1bd.js";
 import {
   __reExport,
   __toESM
@@ -980,58 +987,14 @@ function resolveAdminViewCoreDataSource(source) {
 import { promises as fsp3 } from "fs";
 import path6 from "path";
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates.ts
-import path4 from "path";
-function getAdminViewRelativeModuleSpecifier(adminViewSlug, workspaceFile) {
-  const adminViewDir = `src/admin-views/${adminViewSlug}`;
-  const normalizedFile = workspaceFile.replace(/\\/gu, "/");
-  const modulePath = normalizedFile.replace(/\.[cm]?[jt]sx?$/u, "");
-  const relativeModulePath = path4.posix.relative(adminViewDir, modulePath);
-  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
-}
-function buildAdminViewConfigEntry(adminViewSlug, source) {
-  return [
-    "\t{",
-    `		file: ${quoteTsString(`src/admin-views/${adminViewSlug}/index.tsx`)},`,
-    `		phpFile: ${quoteTsString(`inc/admin-views/${adminViewSlug}.php`)},`,
-    `		slug: ${quoteTsString(adminViewSlug)},`,
-    source ? `		source: ${quoteTsString(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) {
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates-core-data.ts
+function buildCoreDataAdminViewTypesSource(adminViewSlug, 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} {
+  if (coreDataSource.entityKind === "taxonomy") {
+    return `export interface ${coreDataRecordTypeName} {
 	count?: number;
 	description?: string;
 	id: number;
@@ -1064,8 +1027,8 @@ export interface ${dataSetTypeName} {
 	};
 }
 `;
-    }
-    return `export interface ${coreDataRecordTypeName} {
+  }
+  return `export interface ${coreDataRecordTypeName} {
 	id: number;
 	date?: string;
 	modified?: string;
@@ -1088,25 +1051,6 @@ export interface ${itemTypeName} {
 	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: {
@@ -1116,27 +1060,20 @@ export interface ${dataSetTypeName} {
 }
 `;
 }
-function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResource) {
+function buildCoreDataAdminViewConfigSource(adminViewSlug, textDomain, coreDataSource) {
   const pascalName = toPascalCase(adminViewSlug);
   const camelName = toCamelCase(adminViewSlug);
   const itemTypeName = `${pascalName}AdminViewItem`;
   const dataViewsName = `${camelName}AdminDataViews`;
-  const isCoreDataSource = isAdminViewCoreDataSource(source);
-  const isTaxonomyCoreDataSource = isAdminViewCoreDataSource(source) && source.entityKind === "taxonomy";
-  const defaultViewFields = restResource ? "['id']" : isTaxonomyCoreDataSource ? "['name', 'slug', 'count']" : isCoreDataSource ? "['title', 'slug', 'status', 'updatedAt']" : "['title', 'status', 'updatedAt']";
-  const searchEnabled = restResource ? "false" : "true";
-  const titleFieldSource = restResource ? "" : isTaxonomyCoreDataSource ? `	titleField: 'name',
+  const isTaxonomyCoreDataSource = coreDataSource.entityKind === "taxonomy";
+  const defaultViewFields = isTaxonomyCoreDataSource ? "['name', 'slug', 'count']" : "['title', 'slug', 'status', 'updatedAt']";
+  const titleFieldSource = isTaxonomyCoreDataSource ? `	titleField: 'name',
 ` : `	titleField: 'title',
 `;
-  const defaultViewEnhancementsSource = restResource ? "" : isTaxonomyCoreDataSource ? `		titleField: 'name',
-` : isCoreDataSource ? `		titleField: 'title',
-` : `		sort: {
-			direction: 'desc',
-			field: 'updatedAt',
-		},
-		titleField: 'title',
+  const defaultViewEnhancementsSource = isTaxonomyCoreDataSource ? `		titleField: 'name',
+` : `		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: {
+  const additionalFieldsSource = isTaxonomyCoreDataSource ? `		count: {
 			label: __( 'Count', ${quoteTsString(textDomain)} ),
 			schema: { type: 'integer' },
 		},
@@ -1165,7 +1102,7 @@ function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResou
 		taxonomy: {
 			label: __( 'Taxonomy', ${quoteTsString(textDomain)} ),
 			schema: { type: 'string' },
-		},` : isCoreDataSource ? `		slug: {
+		},` : `		slug: {
 			enableGlobalSearch: true,
 			label: __( 'Slug', ${quoteTsString(textDomain)} ),
 			schema: { type: 'string' },
@@ -1176,37 +1113,10 @@ function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResou
 		},
 		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',
@@ -1218,7 +1128,7 @@ import type { ${itemTypeName} } from './types';
 
 export const ${dataViewsName} = defineDataViews<${itemTypeName}>({
 	idField: 'id',
-	search: ${searchEnabled},
+	search: true,
 	searchLabel: __( 'Search records', ${quoteTsString(textDomain)} ),
 ${titleFieldSource}
 	defaultView: {
@@ -1240,406 +1150,279 @@ ${additionalFieldsSource}
 });
 `;
 }
-function buildDefaultAdminViewDataSource(adminViewSlug) {
+function buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) {
   const pascalName = toPascalCase(adminViewSlug);
   const camelName = toCamelCase(adminViewSlug);
-  const title = toTitleCase(adminViewSlug);
-  const itemTypeName = `${pascalName}AdminViewItem`;
+  const coreDataRecordTypeName = `${pascalName}CoreDataRecord`;
   const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  const itemTypeName = `${pascalName}AdminViewItem`;
   const queryTypeName = `${pascalName}AdminViewQuery`;
   const dataViewsName = `${camelName}AdminDataViews`;
-  const fetchName = `fetch${pascalName}AdminViewData`;
-  return `import type { DataViewsView } from '@wp-typia/dataviews';
+  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 { ${dataSetTypeName}, ${itemTypeName} } from './types';
+import type {
+	${coreDataRecordTypeName},
+	${dataSetTypeName},
+	${itemTypeName},
+} from './types';
 
 export interface ${queryTypeName} {
 	page?: number;
-	perPage?: number;
+	per_page?: 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',
-	},
-];
+const CORE_DATA_ENTITY_KIND = ${quoteTsString(coreDataSource.entityKind)};
+const CORE_DATA_ENTITY_NAME = ${quoteTsString(coreDataSource.entityName)};
 
-function matchesSearch(item: ${itemTypeName}, search: string | undefined): boolean {
-	if (!search) {
-		return true;
+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),
+	};
 	}
 
-	const needle = search.toLowerCase();
-	return [item.title, item.owner, item.status].some((value) =>
-		value.toLowerCase().includes(needle),
+export function ${useEntityRecordName}(recordId: number | undefined) {
+	return useEntityRecord<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		recordId ?? 0,
+		{ enabled: typeof recordId === 'number' },
 	);
-}
+	}
 
-export async function ${fetchName}(
-	view: DataViewsView<${itemTypeName}>,
-): Promise<${dataSetTypeName}> {
+export function ${useEntityRecordsName}(view: DataViewsView<${itemTypeName}>) {
 	const query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
-		perPageParam: 'perPage',
+		perPageParam: 'per_page',
 	});
-	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),
+
+	return useEntityRecords<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		query,
 	);
-	const offset = (page - 1) * perPage;
-	const items = filteredItems.slice(offset, offset + perPage);
+	}
+
+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 {
-		items,
-		paginationInfo: {
-			totalItems: filteredItems.length,
-			totalPages: Math.max(1, Math.ceil(filteredItems.length / perPage)),
-		},
+		dataSet,
+		error,
+		isLoading: isResolving,
 	};
-}
+	}
 `;
-}
-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 { useEntityRecord, useEntityRecords } from '@wordpress/core-data';
+import { useMemo } from '@wordpress/element';
 
-import { listResource } from ${quoteTsString(restApiModule)};
-import type { ${restPascalName}ListQuery } from ${quoteTsString(restTypesModule)};
 import { ${dataViewsName} } from './config';
-import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
+import type {
+	${coreDataRecordTypeName},
+	${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 interface ${queryTypeName} {
+	page?: number;
+	per_page?: number;
+	search?: string;
 }
 
-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;
+const CORE_DATA_ENTITY_KIND = ${quoteTsString(coreDataSource.entityKind)};
+const CORE_DATA_ENTITY_NAME = ${quoteTsString(coreDataSource.entityName)};
 
-	return {
-		items: response.items,
-		paginationInfo: {
-			totalItems: response.total,
-			totalPages: resolveTotalPages(response.total, response.perPage ?? query.perPage),
-		},
-	};
-}
-`;
+function normalizeCoreDataString(value: unknown): string {
+	return typeof value === 'string' ? value : '';
 }
-function buildRestSettingsAdminViewTypesSource(adminViewSlug, restResource) {
-  const pascalName = toPascalCase(adminViewSlug);
-  const restTypesModule = getAdminViewRelativeModuleSpecifier(adminViewSlug, restResource.typesFile);
-  const formStateTypeName = `${pascalName}SettingsFormState`;
-  const loadResultTypeName = `${pascalName}SettingsLoadResult`;
-  return `import type {
-	${restResource.bodyTypeName},
-	${restResource.queryTypeName},
-	${restResource.responseTypeName},
-} from ${quoteTsString(restTypesModule)};
 
-export type ${pascalName}SettingsRequest = ${restResource.bodyTypeName};
-export type ${pascalName}SettingsQuery = ${restResource.queryTypeName};
-export type ${pascalName}SettingsResponse = ${restResource.responseTypeName};
-export type ${formStateTypeName} = Partial<${pascalName}SettingsRequest>;
+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;
+		}
+	}
 
-export interface ${loadResultTypeName} {
-	form: ${formStateTypeName};
-	response: ${pascalName}SettingsResponse | null;
-}
-`;
+	return normalizeCoreDataString(record.name) || normalizeCoreDataString(record.slug);
 }
-function buildRestSettingsAdminViewConfigSource(adminViewSlug, textDomain, restResource) {
-  const pascalName = toPascalCase(adminViewSlug);
-  const camelName = toCamelCase(adminViewSlug);
-  const title = toTitleCase(adminViewSlug);
-  const configName = `${camelName}SettingsConfig`;
-  const formStateTypeName = `${pascalName}SettingsFormState`;
-  const secretFieldSource = restResource.secretFieldName && restResource.secretStateFieldName ? `	{
-		description: __( 'Write-only secret value. Leave blank to keep the existing secret unless your route treats blank values as removal.', ${quoteTsString(textDomain)} ),
-		id: ${quoteTsString(restResource.secretFieldName)},
-		label: __( ${quoteTsString(toTitleCase(restResource.secretFieldName))}, ${quoteTsString(textDomain)} ),
-		secretStateField: ${quoteTsString(restResource.secretStateFieldName)},
-		type: 'secret',
-	},` : "";
-  return `import { __ } from '@wordpress/i18n';
-
-import type { ${formStateTypeName} } from './types';
 
-export type ${pascalName}SettingsFieldType = 'secret' | 'text' | 'textarea';
+function normalizeCoreDataUpdatedAt(record: ${coreDataRecordTypeName}): string {
+	return normalizeCoreDataString(record.modified) || normalizeCoreDataString(record.date);
+}
 
-export interface ${pascalName}SettingsField {
-	description?: string;
-	id: Extract<keyof ${formStateTypeName}, string> | string;
-	label: string;
-	secretStateField?: string;
-	type: ${pascalName}SettingsFieldType;
+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 const ${configName} = {
-	description: __( 'This generated settings form is backed by the ${restResource.slug} REST contract. Adjust config.ts and data.ts as the contract becomes product-specific.', ${quoteTsString(textDomain)} ),
-	fields: [
-		{
-			description: __( 'Primary settings payload for this integration.', ${quoteTsString(textDomain)} ),
-			id: 'payload',
-			label: __( 'Payload', ${quoteTsString(textDomain)} ),
-			type: 'textarea',
-		},
-		{
-			description: __( 'Optional operator note included with the save request.', ${quoteTsString(textDomain)} ),
-			id: 'comment',
-			label: __( 'Comment', ${quoteTsString(textDomain)} ),
-			type: 'text',
-		},
-${secretFieldSource}
-	] satisfies ${pascalName}SettingsField[],
-	secretFieldName: ${restResource.secretFieldName ? quoteTsString(restResource.secretFieldName) : "undefined"},
-	secretStateFieldName: ${restResource.secretStateFieldName ? quoteTsString(restResource.secretStateFieldName) : "undefined"},
-	title: __( ${quoteTsString(title)}, ${quoteTsString(textDomain)} ),
-};
-`;
+export function ${useEntityRecordName}(recordId: number | undefined) {
+	return useEntityRecord<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		recordId ?? 0,
+		{ enabled: typeof recordId === 'number' },
+	);
 }
-function buildRestSettingsAdminViewDataSource(adminViewSlug, restResource) {
-  const pascalName = toPascalCase(adminViewSlug);
-  const restApiModule = getAdminViewRelativeModuleSpecifier(adminViewSlug, restResource.apiFile);
-  const formStateTypeName = `${pascalName}SettingsFormState`;
-  const loadResultTypeName = `${pascalName}SettingsLoadResult`;
-  const loadName = `load${pascalName}Settings`;
-  const saveName = `save${pascalName}Settings`;
-  const initialFields = [
-    "\tpayload: '',",
-    "\tcomment: '',"
-  ].join(`
-`);
-  const requestBodySource = restResource.secretFieldName ? `	const requestBody = { ...form } as Record<string, unknown>;
-	if (requestBody[${quoteTsString(restResource.secretFieldName)}] === '') {
-		delete requestBody[${quoteTsString(restResource.secretFieldName)}];
-	}
-` : `	const requestBody = form as Record<string, unknown>;
-`;
-  return `import { callManualRestContract } from ${quoteTsString(restApiModule)};
-import type {
-	${formStateTypeName},
-	${loadResultTypeName},
-	${pascalName}SettingsQuery,
-	${pascalName}SettingsRequest,
-	${pascalName}SettingsResponse,
-} from './types';
 
-function formatValidationError(prefix: string, errors: unknown): string {
-	if (!Array.isArray(errors) || errors.length === 0) {
-		return prefix;
-	}
+export function ${useEntityRecordsName}(view: DataViewsView<${itemTypeName}>) {
+	const query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
+		perPageParam: 'per_page',
+	});
 
-	return \`\${prefix} \${JSON.stringify(errors)}\`;
+	return useEntityRecords<${coreDataRecordTypeName}>(
+		CORE_DATA_ENTITY_KIND,
+		CORE_DATA_ENTITY_NAME,
+		query,
+	);
 }
 
-export function createInitial${pascalName}SettingsFormState(): ${formStateTypeName} {
-	return {
-${initialFields}
-	} as ${formStateTypeName};
-}
+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;
 
-export async function ${loadName}(): Promise<${loadResultTypeName}> {
 	return {
-		form: createInitial${pascalName}SettingsFormState(),
-		response: null,
+		dataSet,
+		error,
+		isLoading: isResolving,
 	};
 }
-
-export async function ${saveName}(
-	form: ${formStateTypeName},
-	query: Partial<${pascalName}SettingsQuery> = {},
-): Promise<${pascalName}SettingsResponse> {
-${requestBodySource}
-	const result = await callManualRestContract({
-		body: requestBody as unknown as ${pascalName}SettingsRequest,
-		query: query as ${pascalName}SettingsQuery,
-	});
-	if (!result.isValid) {
-		const message =
-			result.validationTarget === 'request'
-				? 'Settings request failed validation.'
-				: 'Settings response failed validation.';
-		throw new Error(formatValidationError(message, result.errors));
-	}
-
-	return result.data as ${pascalName}SettingsResponse;
-}
 `;
 }
-function buildRestSettingsAdminViewScreenSource(adminViewSlug, textDomain) {
+function buildCoreDataAdminViewScreenSource(adminViewSlug, textDomain) {
   const pascalName = toPascalCase(adminViewSlug);
-  const componentName = `${pascalName}AdminViewScreen`;
-  const formStateTypeName = `${pascalName}SettingsFormState`;
-  const responseTypeName = `${pascalName}SettingsResponse`;
   const camelName = toCamelCase(adminViewSlug);
-  const configName = `${camelName}SettingsConfig`;
-  const loadName = `load${pascalName}Settings`;
-  const saveName = `save${pascalName}Settings`;
-  return `import {
-	Button,
-	Notice,
-	Spinner,
-	TextControl,
-	TextareaControl,
-} from '@wordpress/components';
-import { useEffect, useState } from '@wordpress/element';
+  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 { ${configName} } from './config';
-import { ${loadName}, ${saveName} } from './data';
-import type { ${formStateTypeName}, ${responseTypeName} } from './types';
+import { ${dataViewsName} } from './config';
+import { ${useAdminViewDataName} } from './data';
+import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
 
-function getFieldValue(form: ${formStateTypeName}, fieldId: string): string {
-	const value = (form as Record<string, unknown>)[fieldId];
-	if (typeof value === 'string') {
-		return value;
-	}
-	if (value == null) {
-		return '';
-	}
-
-	return String(value);
-}
-
-function getSecretState(response: ${responseTypeName} | null): boolean | null {
-	const stateField = ${configName}.secretStateFieldName;
-	if (!stateField || !response) {
-		return null;
-	}
+const TypedDataViews = DataViews as unknown as <TItem extends object>(
+	props: DataViewsConfig<TItem>,
+) => ReturnType<typeof DataViews>;
 
-	const value = (response as unknown as Record<string, unknown>)[stateField];
-	return typeof value === 'boolean' ? value : null;
-}
+const EMPTY_DATA_SET: ${dataSetTypeName} = {
+	items: [],
+	paginationInfo: {
+		totalItems: 0,
+		totalPages: 1,
+	},
+};
 
 export function ${componentName}() {
-	const [form, setForm] = useState<${formStateTypeName}>({});
-	const [response, setResponse] = useState<${responseTypeName} | null>(null);
-	const [error, setError] = useState<string | null>(null);
-	const [isLoading, setIsLoading] = useState(true);
-	const [isSaving, setIsSaving] = useState(false);
-	const [successMessage, setSuccessMessage] = useState<string | null>(null);
-
-	useEffect(() => {
-		let isCurrent = true;
-		setIsLoading(true);
-		setError(null);
-
-		void ${loadName}()
-			.then((result) => {
-				if (isCurrent) {
-					setForm(result.form);
-					setResponse(result.response);
-				}
-			})
-			.catch((nextError: unknown) => {
-				if (isCurrent) {
-					setError(
-						nextError instanceof Error
-							? nextError.message
-							: __( 'Unable to prepare settings form.', ${quoteTsString(textDomain)} ),
-					);
-				}
-			})
-			.finally(() => {
-				if (isCurrent) {
-					setIsLoading(false);
-				}
-			});
-
-		return () => {
-			isCurrent = false;
-		};
-	}, []);
-
-	const setFormValue = (fieldId: string, value: string) => {
-		setForm(
-			(current) =>
-				({
-					...current,
-					[fieldId]: value,
-				}) as ${formStateTypeName},
-		);
-	};
-	const secretState = getSecretState(response);
-
-	const handleSubmit = (event: { preventDefault: () => void }) => {
-		event.preventDefault();
-		setError(null);
-		setSuccessMessage(null);
-		setIsSaving(true);
-
-		void ${saveName}(form)
-			.then((nextResponse) => {
-				setResponse(nextResponse);
-				setSuccessMessage(__( 'Settings saved.', ${quoteTsString(textDomain)} ));
-			})
-			.catch((nextError: unknown) => {
-				setError(
-					nextError instanceof Error
-						? nextError.message
-						: __( 'Unable to save settings.', ${quoteTsString(textDomain)} ),
-				);
-			})
-			.finally(() => setIsSaving(false));
-	};
+	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 wp-typia-admin-view-screen--settings">
+		<div className="wp-typia-admin-view-screen">
 			<header className="wp-typia-admin-view-screen__header">
 				<div>
 					<p className="wp-typia-admin-view-screen__eyebrow">
-						{ __( 'Typed settings screen', ${quoteTsString(textDomain)} ) }
+						{ __( '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>
-					<h1>{ ${configName}.title }</h1>
-					<p>{ ${configName}.description }</p>
 				</div>
 				<div className="wp-typia-admin-view-screen__actions">
-					{ isLoading || isSaving ? <Spinner /> : null }
+					{ isLoading ? <Spinner /> : null }
 				</div>
 			</header>
 			{ error ? (
@@ -1647,260 +1430,179 @@ export function ${componentName}() {
 					{ error }
 				</Notice>
 			) : null }
-			{ successMessage ? (
-				<Notice isDismissible={ false } status="success">
-					{ successMessage }
-				</Notice>
-			) : null }
-			{ secretState !== null ? (
-				<Notice isDismissible={ false } status="info">
-					{ secretState
-						? __( 'A secret is currently configured for this integration.', ${quoteTsString(textDomain)} )
-						: __( 'No secret is currently configured for this integration.', ${quoteTsString(textDomain)} ) }
-				</Notice>
-			) : null }
-			<form className="wp-typia-admin-view-screen__settings-form" onSubmit={ handleSubmit }>
-				{ ${configName}.fields.map((field) => (
-					<div className="wp-typia-admin-view-screen__field" key={ field.id }>
-						{ field.type === 'textarea' ? (
-							<TextareaControl
-								help={ field.description }
-								label={ field.label }
-								onChange={ (value) => setFormValue(field.id, value) }
-								value={ getFieldValue(form, field.id) }
-							/>
-						) : (
-							<TextControl
-								help={ field.description }
-								label={ field.label }
-								onChange={ (value) => setFormValue(field.id, value) }
-								type={ field.type === 'secret' ? 'password' : 'text' }
-								value={ getFieldValue(form, field.id) }
-							/>
-						) }
-					</div>
-				)) }
-				<Button
-					disabled={ isLoading || isSaving }
-					isBusy={ isSaving }
-					type="submit"
-					variant="primary"
-				>
-					{ __( 'Save settings', ${quoteTsString(textDomain)} ) }
-				</Button>
-			</form>
+			<TypedDataViews<${itemTypeName}> { ...config } />
 		</div>
 	);
 }
 `;
 }
-function buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) {
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates-default.ts
+function buildDefaultAdminViewTypesSource(adminViewSlug) {
   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';
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  return `export type ${pascalName}AdminViewStatus = 'draft' | 'published';
 
-export interface ${queryTypeName} {
-	page?: number;
-	per_page?: number;
-	search?: string;
+export interface ${itemTypeName} {
+	id: number;
+	owner: string;
+	status: ${pascalName}AdminViewStatus;
+	title: string;
+	updatedAt: 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;
+export interface ${dataSetTypeName} {
+	items: ${itemTypeName}[];
+	paginationInfo: {
+		totalItems: number;
+		totalPages: number;
+	};
 }
-
-function normalizeCoreDataString(value: unknown): string {
-	return typeof value === 'string' ? value : '';
+`;
 }
+function buildDefaultAdminViewConfigSource(adminViewSlug, textDomain) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const camelName = toCamelCase(adminViewSlug);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  return `import { defineDataViews } from '@wp-typia/dataviews';
+import { __ } from '@wordpress/i18n';
 
-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,
-	);
-	}
+import type { ${itemTypeName} } from './types';
 
-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),
+export const ${dataViewsName} = defineDataViews<${itemTypeName}>({
+	idField: 'id',
+	search: true,
+	searchLabel: __( 'Search records', ${quoteTsString(textDomain)} ),
+	titleField: 'title',
+	defaultView: {
+		fields: ['title', 'status', 'updatedAt'],
+		page: 1,
+		perPage: 10,
+		sort: {
+			direction: 'desc',
+			field: 'updatedAt',
+		},
+		titleField: 'title',
+		type: 'table',
+	},
+	fields: {
+		id: {
+			enableHiding: false,
+			label: __( 'ID', ${quoteTsString(textDomain)} ),
+			readOnly: true,
+			schema: { type: 'integer' },
+		},
+		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',
 			},
-		}),
-		[items, totalItems, totalPages],
-	);
-	const error =
-		!isResolving && hasResolved && records === null
-			? 'Unable to load core-data entity records.'
-			: null;
-
-	return {
-		dataSet,
-		error,
-		isLoading: isResolving,
-	};
-	}
+		},
+		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',
+		},
+	},
+});
 `;
-  }
+}
+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 { useEntityRecord, useEntityRecords } from '@wordpress/core-data';
-import { useMemo } from '@wordpress/element';
 
 import { ${dataViewsName} } from './config';
-import type {
-	${coreDataRecordTypeName},
-	${dataSetTypeName},
-	${itemTypeName},
-} from './types';
+import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
 
 export interface ${queryTypeName} {
 	page?: number;
-	per_page?: number;
+	perPage?: 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 : '';
-}
+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 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;
-		}
+function matchesSearch(item: ${itemTypeName}, search: string | undefined): boolean {
+	if (!search) {
+		return true;
 	}
 
-	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' },
+	const needle = search.toLowerCase();
+	return [item.title, item.owner, item.status].some((value) =>
+		value.toLowerCase().includes(needle),
 	);
 }
 
-export function ${useEntityRecordsName}(view: DataViewsView<${itemTypeName}>) {
+export async function ${fetchName}(
+	view: DataViewsView<${itemTypeName}>,
+): Promise<${dataSetTypeName}> {
 	const query = ${dataViewsName}.toQueryArgs<${queryTypeName}>(view, {
-		perPageParam: 'per_page',
+		perPageParam: 'perPage',
 	});
-
-	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 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 error =
-		!isResolving && hasResolved && records === null
-			? 'Unable to load core-data entity records.'
-			: null;
+	const offset = (page - 1) * perPage;
+	const items = filteredItems.slice(offset, offset + perPage);
 
 	return {
-		dataSet,
-		error,
-		isLoading: isResolving,
+		items,
+		paginationInfo: {
+			totalItems: filteredItems.length,
+			totalPages: Math.max(1, Math.ceil(filteredItems.length / perPage)),
+		},
 	};
 }
 `;
@@ -2018,79 +1720,33 @@ export function ${componentName}() {
 }
 `;
 }
-function buildCoreDataAdminViewScreenSource(adminViewSlug, textDomain) {
-  const pascalName = toPascalCase(adminViewSlug);
-  const camelName = toCamelCase(adminViewSlug);
-  const itemTypeName = `${pascalName}AdminViewItem`;
-  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
-  const componentName = `${pascalName}AdminViewScreen`;
-  const dataViewsName = `${camelName}AdminDataViews`;
-  const useAdminViewDataName = `use${pascalName}AdminViewData`;
-  const title = toTitleCase(adminViewSlug);
-  return `import type { DataViewsConfig, DataViewsView } from '@wp-typia/dataviews';
-import { Notice, Spinner } from '@wordpress/components';
-import { useState } from '@wordpress/element';
-import { __ } from '@wordpress/i18n';
-import { DataViews } from '@wordpress/dataviews/wp';
 
-import { ${dataViewsName} } from './config';
-import { ${useAdminViewDataName} } from './data';
-import type { ${dataSetTypeName}, ${itemTypeName} } from './types';
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates-shared.ts
+import path4 from "path";
+function getAdminViewRelativeModuleSpecifier(adminViewSlug, workspaceFile) {
+  const adminViewDir = `src/admin-views/${adminViewSlug}`;
+  const normalizedFile = workspaceFile.replace(/\\/gu, "/");
+  const modulePath = normalizedFile.replace(/\.[cm]?[jt]sx?$/u, "");
+  const relativeModulePath = path4.posix.relative(adminViewDir, modulePath);
+  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
+}
+function buildAdminViewConfigEntry(adminViewSlug, source) {
+  return [
+    "\t{",
+    `		file: ${quoteTsString(`src/admin-views/${adminViewSlug}/index.tsx`)},`,
+    `		phpFile: ${quoteTsString(`inc/admin-views/${adminViewSlug}.php`)},`,
+    `		slug: ${quoteTsString(adminViewSlug)},`,
+    source ? `		source: ${quoteTsString(formatAdminViewSourceLocator(source))},` : null,
+    "\t},"
+  ].filter((line) => typeof line === "string").join(`
+`);
+}
+function buildAdminViewRegistrySource(adminViewSlugs) {
+  const importLines = adminViewSlugs.map((adminViewSlug) => `import './${adminViewSlug}';`).join(`
+`);
+  return `${importLines}${importLines ? `
 
-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>
-	);
-}
+` : ""}// wp-typia add admin-view entries
 `;
 }
 function buildAdminViewEntrySource(adminViewSlug, options = {}) {
@@ -2273,12 +1929,473 @@ if ( ! function_exists( '${enqueueFunctionName}' ) ) {
 		}
 	}
 }
-
-add_action( 'admin_menu', '${registerFunctionName}' );
-add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
+
+add_action( 'admin_menu', '${registerFunctionName}' );
+add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
+`;
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates-rest.ts
+function buildRestAdminViewTypesSource(adminViewSlug, restResource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const restPascalName = toPascalCase(restResource.slug);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataSetTypeName = `${pascalName}AdminViewDataSet`;
+  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;
+	};
+}
+`;
+}
+function buildRestAdminViewConfigSource(adminViewSlug, textDomain) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const camelName = toCamelCase(adminViewSlug);
+  const itemTypeName = `${pascalName}AdminViewItem`;
+  const dataViewsName = `${camelName}AdminDataViews`;
+  return `import { defineDataViews } from '@wp-typia/dataviews';
+import { __ } from '@wordpress/i18n';
+
+import type { ${itemTypeName} } from './types';
+
+export const ${dataViewsName} = defineDataViews<${itemTypeName}>({
+	idField: 'id',
+	search: false,
+	searchLabel: __( 'Search records', ${quoteTsString(textDomain)} ),
+	defaultView: {
+		fields: ['id'],
+		page: 1,
+		perPage: 10,
+		type: 'table',
+	},
+	fields: {
+		id: {
+			enableHiding: false,
+			label: __( 'ID', ${quoteTsString(textDomain)} ),
+			readOnly: true,
+			schema: { type: 'integer' },
+		},
+		// REST-backed screens start with the guaranteed ID column. Add project-owned fields here once they are declared on the REST record type.
+	},
+});
+`;
+}
+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),
+		},
+	};
+}
+`;
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates-settings.ts
+function buildRestSettingsAdminViewTypesSource(adminViewSlug, restResource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const restTypesModule = getAdminViewRelativeModuleSpecifier(adminViewSlug, restResource.typesFile);
+  const formStateTypeName = `${pascalName}SettingsFormState`;
+  const loadResultTypeName = `${pascalName}SettingsLoadResult`;
+  return `import type {
+	${restResource.bodyTypeName},
+	${restResource.queryTypeName},
+	${restResource.responseTypeName},
+} from ${quoteTsString(restTypesModule)};
+
+export type ${pascalName}SettingsRequest = ${restResource.bodyTypeName};
+export type ${pascalName}SettingsQuery = ${restResource.queryTypeName};
+export type ${pascalName}SettingsResponse = ${restResource.responseTypeName};
+export type ${formStateTypeName} = Partial<${pascalName}SettingsRequest>;
+
+export interface ${loadResultTypeName} {
+	form: ${formStateTypeName};
+	response: ${pascalName}SettingsResponse | null;
+}
+`;
+}
+function buildRestSettingsAdminViewConfigSource(adminViewSlug, textDomain, restResource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const camelName = toCamelCase(adminViewSlug);
+  const title = toTitleCase(adminViewSlug);
+  const configName = `${camelName}SettingsConfig`;
+  const formStateTypeName = `${pascalName}SettingsFormState`;
+  const secretPreserveOnEmpty = restResource.secretPreserveOnEmpty !== false;
+  const secretFieldSource = restResource.secretFieldName && restResource.secretStateFieldName ? `	{
+		description: __( ${quoteTsString(secretPreserveOnEmpty ? "Write-only secret value. Leave blank to keep the existing secret." : "Write-only secret value. Blank submissions are sent to the REST route.")}, ${quoteTsString(textDomain)} ),
+		id: ${quoteTsString(restResource.secretFieldName)},
+		label: __( ${quoteTsString(toTitleCase(restResource.secretFieldName))}, ${quoteTsString(textDomain)} ),
+		preserveOnEmpty: ${secretPreserveOnEmpty},
+		secretStateField: ${quoteTsString(restResource.secretStateFieldName)},
+		type: 'secret',
+	},` : "";
+  return `import { __ } from '@wordpress/i18n';
+
+import type { ${formStateTypeName} } from './types';
+
+export type ${pascalName}SettingsFieldType = 'secret' | 'text' | 'textarea';
+
+export interface ${pascalName}SettingsField {
+	description?: string;
+	id: Extract<keyof ${formStateTypeName}, string> | string;
+	label: string;
+	preserveOnEmpty?: boolean;
+	secretStateField?: string;
+	type: ${pascalName}SettingsFieldType;
+}
+
+export const ${configName} = {
+	description: __( 'This generated settings form is backed by the ${restResource.slug} REST contract. Adjust config.ts and data.ts as the contract becomes product-specific.', ${quoteTsString(textDomain)} ),
+	fields: [
+		{
+			description: __( 'Primary settings payload for this integration.', ${quoteTsString(textDomain)} ),
+			id: 'payload',
+			label: __( 'Payload', ${quoteTsString(textDomain)} ),
+			type: 'textarea',
+		},
+		{
+			description: __( 'Optional operator note included with the save request.', ${quoteTsString(textDomain)} ),
+			id: 'comment',
+			label: __( 'Comment', ${quoteTsString(textDomain)} ),
+			type: 'text',
+		},
+${secretFieldSource}
+	] satisfies ${pascalName}SettingsField[],
+	secretFieldName: ${restResource.secretFieldName ? quoteTsString(restResource.secretFieldName) : "undefined"},
+	secretPreserveOnEmpty: ${restResource.secretFieldName ? secretPreserveOnEmpty : "undefined"},
+	secretStateFieldName: ${restResource.secretStateFieldName ? quoteTsString(restResource.secretStateFieldName) : "undefined"},
+	title: __( ${quoteTsString(title)}, ${quoteTsString(textDomain)} ),
+};
+`;
+}
+function buildRestSettingsAdminViewDataSource(adminViewSlug, restResource) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const restApiModule = getAdminViewRelativeModuleSpecifier(adminViewSlug, restResource.apiFile);
+  const formStateTypeName = `${pascalName}SettingsFormState`;
+  const loadResultTypeName = `${pascalName}SettingsLoadResult`;
+  const loadName = `load${pascalName}Settings`;
+  const saveName = `save${pascalName}Settings`;
+  const secretPreserveOnEmpty = restResource.secretPreserveOnEmpty !== false;
+  const initialFieldLines = [
+    "\tpayload: '',",
+    "\tcomment: '',",
+    ...restResource.secretFieldName && !secretPreserveOnEmpty ? [`	${quoteTsString(restResource.secretFieldName)}: '',`] : []
+  ];
+  const initialFields = initialFieldLines.join(`
+`);
+  const requestBodySource = restResource.secretFieldName && secretPreserveOnEmpty ? `	const requestBody = { ...form } as Record<string, unknown>;
+	if (requestBody[${quoteTsString(restResource.secretFieldName)}] === '') {
+		delete requestBody[${quoteTsString(restResource.secretFieldName)}];
+	}
+` : `	const requestBody = form as Record<string, unknown>;
+`;
+  return `import { callManualRestContract } from ${quoteTsString(restApiModule)};
+import type {
+	${formStateTypeName},
+	${loadResultTypeName},
+	${pascalName}SettingsQuery,
+	${pascalName}SettingsRequest,
+	${pascalName}SettingsResponse,
+} from './types';
+
+function formatValidationError(prefix: string, errors: unknown): string {
+	if (!Array.isArray(errors) || errors.length === 0) {
+		return prefix;
+	}
+
+	return \`\${prefix} \${JSON.stringify(errors)}\`;
+}
+
+export function createInitial${pascalName}SettingsFormState(): ${formStateTypeName} {
+	return {
+${initialFields}
+	} as ${formStateTypeName};
+}
+
+export async function ${loadName}(): Promise<${loadResultTypeName}> {
+	return {
+		form: createInitial${pascalName}SettingsFormState(),
+		response: null,
+	};
+}
+
+export async function ${saveName}(
+	form: ${formStateTypeName},
+	query: Partial<${pascalName}SettingsQuery> = {},
+): Promise<${pascalName}SettingsResponse> {
+${requestBodySource}
+	const result = await callManualRestContract({
+		body: requestBody as unknown as ${pascalName}SettingsRequest,
+		query: query as ${pascalName}SettingsQuery,
+	});
+	if (!result.isValid) {
+		const message =
+			result.validationTarget === 'request'
+				? 'Settings request failed validation.'
+				: 'Settings response failed validation.';
+		throw new Error(formatValidationError(message, result.errors));
+	}
+
+	return result.data as ${pascalName}SettingsResponse;
+}
+`;
+}
+function buildRestSettingsAdminViewScreenSource(adminViewSlug, textDomain) {
+  const pascalName = toPascalCase(adminViewSlug);
+  const componentName = `${pascalName}AdminViewScreen`;
+  const formStateTypeName = `${pascalName}SettingsFormState`;
+  const responseTypeName = `${pascalName}SettingsResponse`;
+  const camelName = toCamelCase(adminViewSlug);
+  const configName = `${camelName}SettingsConfig`;
+  const loadName = `load${pascalName}Settings`;
+  const saveName = `save${pascalName}Settings`;
+  return `import {
+	Button,
+	Notice,
+	Spinner,
+	TextControl,
+	TextareaControl,
+} from '@wordpress/components';
+import { useEffect, useState } from '@wordpress/element';
+import { __ } from '@wordpress/i18n';
+
+import { ${configName} } from './config';
+import { ${loadName}, ${saveName} } from './data';
+import type { ${formStateTypeName}, ${responseTypeName} } from './types';
+
+function getFieldValue(form: ${formStateTypeName}, fieldId: string): string {
+	const value = (form as Record<string, unknown>)[fieldId];
+	if (typeof value === 'string') {
+		return value;
+	}
+	if (value == null) {
+		return '';
+	}
+
+	return String(value);
+}
+
+function getSecretState(response: ${responseTypeName} | null): boolean | null {
+	const stateField = ${configName}.secretStateFieldName;
+	if (!stateField || !response) {
+		return null;
+	}
+
+	const value = (response as unknown as Record<string, unknown>)[stateField];
+	return typeof value === 'boolean' ? value : null;
+}
+
+export function ${componentName}() {
+	const [form, setForm] = useState<${formStateTypeName}>({});
+	const [response, setResponse] = useState<${responseTypeName} | null>(null);
+	const [error, setError] = useState<string | null>(null);
+	const [isLoading, setIsLoading] = useState(true);
+	const [isSaving, setIsSaving] = useState(false);
+	const [successMessage, setSuccessMessage] = useState<string | null>(null);
+
+	useEffect(() => {
+		let isCurrent = true;
+		setIsLoading(true);
+		setError(null);
+
+		void ${loadName}()
+			.then((result) => {
+				if (isCurrent) {
+					setForm(result.form);
+					setResponse(result.response);
+				}
+			})
+			.catch((nextError: unknown) => {
+				if (isCurrent) {
+					setError(
+						nextError instanceof Error
+							? nextError.message
+							: __( 'Unable to prepare settings form.', ${quoteTsString(textDomain)} ),
+					);
+				}
+			})
+			.finally(() => {
+				if (isCurrent) {
+					setIsLoading(false);
+				}
+			});
+
+		return () => {
+			isCurrent = false;
+		};
+	}, []);
+
+	const setFormValue = (fieldId: string, value: string) => {
+		setForm(
+			(current) =>
+				({
+					...current,
+					[fieldId]: value,
+				}) as ${formStateTypeName},
+		);
+	};
+	const secretState = getSecretState(response);
+
+	const handleSubmit = (event: { preventDefault: () => void }) => {
+		event.preventDefault();
+		setError(null);
+		setSuccessMessage(null);
+		setIsSaving(true);
+
+		void ${saveName}(form)
+			.then((nextResponse) => {
+				setResponse(nextResponse);
+				setSuccessMessage(__( 'Settings saved.', ${quoteTsString(textDomain)} ));
+			})
+			.catch((nextError: unknown) => {
+				setError(
+					nextError instanceof Error
+						? nextError.message
+						: __( 'Unable to save settings.', ${quoteTsString(textDomain)} ),
+				);
+			})
+			.finally(() => setIsSaving(false));
+	};
+
+	return (
+		<div className="wp-typia-admin-view-screen wp-typia-admin-view-screen--settings">
+			<header className="wp-typia-admin-view-screen__header">
+				<div>
+					<p className="wp-typia-admin-view-screen__eyebrow">
+						{ __( 'Typed settings screen', ${quoteTsString(textDomain)} ) }
+					</p>
+					<h1>{ ${configName}.title }</h1>
+					<p>{ ${configName}.description }</p>
+				</div>
+				<div className="wp-typia-admin-view-screen__actions">
+					{ isLoading || isSaving ? <Spinner /> : null }
+				</div>
+			</header>
+			{ error ? (
+				<Notice isDismissible={ false } status="error">
+					{ error }
+				</Notice>
+			) : null }
+			{ successMessage ? (
+				<Notice isDismissible={ false } status="success">
+					{ successMessage }
+				</Notice>
+			) : null }
+			{ secretState !== null ? (
+				<Notice isDismissible={ false } status="info">
+					{ secretState
+						? __( 'A secret is currently configured for this integration.', ${quoteTsString(textDomain)} )
+						: __( 'No secret is currently configured for this integration.', ${quoteTsString(textDomain)} ) }
+				</Notice>
+			) : null }
+			<form className="wp-typia-admin-view-screen__settings-form" onSubmit={ handleSubmit }>
+				{ ${configName}.fields.map((field) => (
+					<div className="wp-typia-admin-view-screen__field" key={ field.id }>
+						{ field.type === 'textarea' ? (
+							<TextareaControl
+								help={ field.description }
+								label={ field.label }
+								onChange={ (value) => setFormValue(field.id, value) }
+								value={ getFieldValue(form, field.id) }
+							/>
+						) : (
+							<TextControl
+								help={ field.description }
+								label={ field.label }
+								onChange={ (value) => setFormValue(field.id, value) }
+								type={ field.type === 'secret' ? 'password' : 'text' }
+								value={ getFieldValue(form, field.id) }
+							/>
+						) }
+					</div>
+				)) }
+				<Button
+					disabled={ isLoading || isSaving }
+					isBusy={ isSaving }
+					type="submit"
+					variant="primary"
+				>
+					{ __( 'Save settings', ${quoteTsString(textDomain)} ) }
+				</Button>
+			</form>
+		</div>
+	);
+}
 `;
 }
 
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates.ts
+function buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource) {
+  if (restResource) {
+    return buildRestAdminViewTypesSource(adminViewSlug, restResource);
+  }
+  if (coreDataSource) {
+    return buildCoreDataAdminViewTypesSource(adminViewSlug, coreDataSource);
+  }
+  return buildDefaultAdminViewTypesSource(adminViewSlug);
+}
+function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResource) {
+  if (restResource) {
+    return buildRestAdminViewConfigSource(adminViewSlug, textDomain);
+  }
+  if (isAdminViewCoreDataSource(source)) {
+    return buildCoreDataAdminViewConfigSource(adminViewSlug, textDomain, source);
+  }
+  return buildDefaultAdminViewConfigSource(adminViewSlug, textDomain);
+}
+function buildAdminViewScreenSource2(adminViewSlug, textDomain) {
+  return buildAdminViewScreenSource(adminViewSlug, textDomain);
+}
+function buildAdminViewPhpSource2(adminViewSlug, workspace) {
+  return buildAdminViewPhpSource(adminViewSlug, workspace);
+}
+
 // ../wp-typia-project-tools/src/runtime/rest-resource-artifacts.ts
 import path5 from "path";
 import {
@@ -2581,18 +2698,22 @@ function buildManualRestContractConfigEntry(options) {
     `		auth: ${quoteTsString(options.auth)},`,
     ...options.bodyTypeName ? [`		bodyTypeName: ${quoteTsString(options.bodyTypeName)},`] : [],
     `		clientFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api-client.ts`)},`,
+    ...options.controllerClass ? [`		controllerClass: ${quoteTsString(options.controllerClass)},`] : [],
+    ...options.controllerExtends ? [`		controllerExtends: ${quoteTsString(options.controllerExtends)},`] : [],
     `		method: ${quoteTsString(options.method)},`,
     "\t\tmethods: [],",
     "\t\tmode: 'manual',",
     `		namespace: ${quoteTsString(options.namespace)},`,
     `		openApiFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api.openapi.json`)},`,
     `		pathPattern: ${quoteTsString(options.pathPattern)},`,
+    ...options.permissionCallback ? [`		permissionCallback: ${quoteTsString(options.permissionCallback)},`] : [],
     `		queryTypeName: ${quoteTsString(options.queryTypeName)},`,
     "\t\trestManifest: defineEndpointManifest(",
     indentMultiline(JSON.stringify(manifest, null, "\t"), "\t\t\t"),
     "\t\t),",
     `		responseTypeName: ${quoteTsString(options.responseTypeName)},`,
     ...options.secretFieldName ? [`		secretFieldName: ${quoteTsString(options.secretFieldName)},`] : [],
+    ...options.secretPreserveOnEmpty !== undefined ? [`		secretPreserveOnEmpty: ${options.secretPreserveOnEmpty},`] : [],
     ...options.secretStateFieldName ? [`		secretStateFieldName: ${quoteTsString(options.secretStateFieldName)},`] : [],
     `		slug: ${quoteTsString(options.restResourceSlug)},`,
     `		typesFile: ${quoteTsString(`src/rest/${options.restResourceSlug}/api-types.ts`)},`,
@@ -2603,18 +2724,21 @@ function buildManualRestContractConfigEntry(options) {
 }
 function buildManualRestContractTypesSource(options) {
   const title = toTitleCase(options.restResourceSlug);
+  const pathParameterNames = Array.from(new Set(options.pathParameterNames ?? []));
+  const queryFields = pathParameterNames.length > 0 ? pathParameterNames.map((parameterName) => `	${parameterName}: string & tags.MinLength< 1 >;`) : ["\tid?: string & tags.MinLength< 1 >;"];
   const lines = [
     "import type { tags } from '@wp-typia/block-runtime/typia-tags';",
     "",
     `export interface ${options.queryTypeName} {`,
-    "\tid?: string & tags.MinLength< 1 >;",
-    "\tpreview?: boolean;",
+    ...queryFields,
+    ...pathParameterNames.includes("preview") ? [] : ["\tpreview?: boolean;"],
     "}"
   ];
   if (options.bodyTypeName) {
+    const secretPreserveOnEmpty = options.secretPreserveOnEmpty ?? true;
     const secretLines = options.secretFieldName && options.secretStateFieldName ? [
-      `	${options.secretFieldName}?: string & tags.MinLength< 1 > & tags.MaxLength< 4096 > & tags.Secret< ${quoteTsString(options.secretStateFieldName)} >;`,
-      `	// ${options.secretFieldName} is write-only: persist it server-side and expose ${options.secretStateFieldName} in responses instead of returning the raw value.`
+      `	${options.secretFieldName}?: string${secretPreserveOnEmpty ? " & tags.MinLength< 1 >" : ""} & tags.MaxLength< 4096 > & tags.Secret< ${quoteTsString(options.secretStateFieldName)} >${secretPreserveOnEmpty ? " & tags.PreserveOnEmpty< true >" : ""};`,
+      secretPreserveOnEmpty ? `	// ${options.secretFieldName} is write-only: omit or submit an empty value to preserve the stored secret, and expose ${options.secretStateFieldName} in responses instead of returning the raw value.` : `	// ${options.secretFieldName} is write-only: persist it server-side and expose ${options.secretStateFieldName} in responses instead of returning the raw value.`
     ] : [];
     lines.push("", `export interface ${options.bodyTypeName} {`, ...secretLines, "\tpayload: string & tags.MinLength< 1 >;", "\tcomment?: string & tags.MaxLength< 500 >;", "}");
   }
@@ -3105,67 +3229,6 @@ ${exportedBindings.join(`
 `;
 }
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-mutation.ts
-var DEFAULT_PHP_SNIPPET_INSERTION_ANCHORS = [
-  /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-  /\?>\s*$/u
-];
-
-class WorkspaceMutationRollbackError extends Error {
-  mutationError;
-  rollbackError;
-  constructor(mutationError, rollbackError) {
-    super("Workspace mutation failed and rollback also failed.");
-    this.name = "WorkspaceMutationRollbackError";
-    this.mutationError = mutationError;
-    this.rollbackError = rollbackError;
-  }
-}
-async function executeWorkspaceMutationPlan({
-  filePaths,
-  run,
-  snapshotDirs = [],
-  targetPaths = []
-}) {
-  const mutationSnapshot = {
-    fileSources: await snapshotWorkspaceFiles(filePaths),
-    snapshotDirs: [...snapshotDirs],
-    targetPaths: [...targetPaths]
-  };
-  try {
-    return await run();
-  } catch (error) {
-    try {
-      await rollbackWorkspaceMutation(mutationSnapshot);
-    } catch (rollbackError) {
-      throw new WorkspaceMutationRollbackError(error, rollbackError);
-    }
-    throw error;
-  }
-}
-function insertPhpSnippetBeforeWorkspaceAnchors(source, snippet) {
-  for (const anchor of DEFAULT_PHP_SNIPPET_INSERTION_ANCHORS) {
-    const candidate = source.replace(anchor, (match) => `${snippet}
-${match}`);
-    if (candidate !== source) {
-      return candidate;
-    }
-  }
-  return `${source.trimEnd()}
-${snippet}
-`;
-}
-function appendPhpSnippetBeforeClosingTag(source, snippet) {
-  const closingTagPattern = /\?>\s*$/u;
-  if (closingTagPattern.test(source)) {
-    return source.replace(closingTagPattern, `${snippet}
-?>`);
-  }
-  return `${source.trimEnd()}
-${snippet}
-`;
-}
-
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
 function detectJsonIndent(source) {
   const indentMatch = /\n([ \t]+)"/u.exec(source);
@@ -3218,7 +3281,10 @@ async function ensureAdminViewPackageDependencies(workspace, adminViewSource, re
     packageName: "@wordpress/data"
   });
   await patchFile(packageJsonPath, (source) => {
-    const packageJson = JSON.parse(source);
+    const packageJson = safeJsonParse(source, {
+      context: "admin view package manifest",
+      filePath: packageJsonPath
+    });
     const needsDataViews = !isAdminViewManualSettingsRestResource(restResource);
     const coreDataDependencies = isAdminViewCoreDataSource(adminViewSource) ? {
       "@wordpress/core-data": packageJson.dependencies?.["@wordpress/core-data"] ?? wordpressCoreDataVersion,
@@ -3429,12 +3495,12 @@ async function scaffoldAdminViewWorkspace(options) {
       await fsp3.writeFile(path6.join(adminViewDir, "types.ts"), manualSettingsRestResource ? buildRestSettingsAdminViewTypesSource(adminViewSlug, manualSettingsRestResource) : buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
       await fsp3.writeFile(path6.join(adminViewDir, "config.ts"), manualSettingsRestResource ? buildRestSettingsAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, manualSettingsRestResource) : buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
       await fsp3.writeFile(path6.join(adminViewDir, "data.ts"), manualSettingsRestResource ? buildRestSettingsAdminViewDataSource(adminViewSlug, manualSettingsRestResource) : coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
-      await fsp3.writeFile(path6.join(adminViewDir, "Screen.tsx"), manualSettingsRestResource ? buildRestSettingsAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
+      await fsp3.writeFile(path6.join(adminViewDir, "Screen.tsx"), manualSettingsRestResource ? buildRestSettingsAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource2(adminViewSlug, workspace.workspace.textDomain), "utf8");
       await fsp3.writeFile(path6.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug, {
         includeDataViewsStyle: !manualSettingsRestResource
       }), "utf8");
       await fsp3.writeFile(path6.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
-      await fsp3.writeFile(adminViewPhpPath, buildAdminViewPhpSource(adminViewSlug, workspace), "utf8");
+      await fsp3.writeFile(adminViewPhpPath, buildAdminViewPhpSource2(adminViewSlug, workspace), "utf8");
       await writeAdminViewRegistry(workspace.projectDir, adminViewSlug);
       await appendWorkspaceInventoryEntries(workspace.projectDir, {
         adminViewEntries: [
@@ -4332,486 +4398,107 @@ async function runAddPatternCommand({
     throw error;
   }
 }
-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> [--block <block-slug|namespace/block-slug> --attribute <attribute>]");
-  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
-  assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
-  const target = resolveBindingTarget({
-    attributeName,
-    blockName
-  }, workspace.workspace.namespace);
-  const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
-  const blockConfigPath = path7.join(workspace.projectDir, "scripts", "block-config.ts");
-  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const bindingsIndexPath = await resolveBindingSourceRegistryPath(workspace.projectDir);
-  const bindingSourceDir = path7.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-  const serverFilePath = path7.join(bindingSourceDir, "server.php");
-  const editorFilePath = path7.join(bindingSourceDir, "editor.ts");
-  const blockJsonPath = target ? path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
-  const targetGeneratedMetadataPaths = target ? [
-    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
-    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
-    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
-    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
-  ] : [];
-  const mutationSnapshot = {
-    fileSources: await snapshotWorkspaceFiles([
-      blockConfigPath,
-      bootstrapPath,
-      bindingsIndexPath,
-      ...blockJsonPath ? [blockJsonPath] : [],
-      ...targetBlock ? [path7.join(workspace.projectDir, targetBlock.typesFile)] : [],
-      ...targetGeneratedMetadataPaths
-    ]),
-    snapshotDirs: [],
-    targetPaths: [bindingSourceDir]
-  };
-  try {
-    await fsp4.mkdir(bindingSourceDir, { recursive: true });
-    await ensureBindingSourceBootstrapAnchors(workspace);
-    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, target)]
-    });
-    return {
-      ...target ? { attributeName: target.attributeName, blockSlug: target.blockSlug } : {},
-      bindingSourceSlug,
-      projectDir: workspace.projectDir
-    };
-  } catch (error) {
-    await rollbackWorkspaceMutation(mutationSnapshot);
-    throw error;
-  }
-}
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-integration-env.ts
-import { promises as fsp5 } from "fs";
-import path8 from "path";
-var WP_ENV_PACKAGE_VERSION = "^11.2.0";
-function buildWpEnvConfigSource() {
-  return `${JSON.stringify({
-    $schema: "https://schemas.wp.org/trunk/wp-env.json",
-    core: null,
-    port: 8888,
-    testsEnvironment: false,
-    plugins: ["."],
-    config: {
-      WP_DEBUG: true,
-      WP_DEBUG_LOG: true,
-      WP_DEBUG_DISPLAY: false,
-      SCRIPT_DEBUG: true,
-      WP_ENVIRONMENT_TYPE: "local"
-    }
-  }, null, 2)}
-`;
-}
-function buildDockerComposeSource() {
-  return `services:
-  integration-service:
-    image: node:22-alpine
-    working_dir: /workspace
-    volumes:
-      - .:/workspace
-    command: >
-      node -e "require('node:http').createServer((request, response) => {
-        response.writeHead(request.url === '/health' ? 200 : 404, {
-          'content-type': 'application/json'
-        });
-        response.end(JSON.stringify({
-          ok: request.url === '/health',
-          service: 'wp-typia-integration-starter'
-        }));
-      }).listen(3000, '0.0.0.0')"
-    ports:
-      - "3000:3000"
-`;
-}
-function buildIntegrationSmokeScriptSource(integrationEnvSlug) {
-  return `import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const ROOT_DIR = path.resolve(
-	fileURLToPath(new URL("../..", import.meta.url)),
-);
-const ENV_FILE = path.join(ROOT_DIR, ".env");
-
-function parseEnvValue(value) {
-	const trimmed = value.trim();
-	if (
-		(trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-		(trimmed.startsWith("'") && trimmed.endsWith("'"))
-	) {
-		return trimmed.slice(1, -1);
-	}
-
-	return trimmed;
-}
-
-function readEnvFile(filePath) {
-	if (!fs.existsSync(filePath)) {
-		return {};
-	}
-
-	return Object.fromEntries(
-		fs
-			.readFileSync(filePath, "utf8")
-			.split(/\\r?\\n/u)
-			.map((line) => line.trim())
-			.filter((line) => line.length > 0 && !line.startsWith("#"))
-			.map((line) => {
-				const separatorIndex = line.indexOf("=");
-				if (separatorIndex === -1) {
-					return null;
-				}
-
-				return [
-					line.slice(0, separatorIndex).trim(),
-					parseEnvValue(line.slice(separatorIndex + 1)),
-				];
-			})
-			.filter(Boolean),
-	);
-}
-
-const envFile = readEnvFile(ENV_FILE);
-
-function getEnv(name, fallback) {
-	return process.env[name] ?? envFile[name] ?? fallback;
-}
-
-function resolveEndpointUrl(baseUrl, endpointPath) {
-	const normalizedBaseUrl = new URL(baseUrl);
-	if (!normalizedBaseUrl.pathname.endsWith("/")) {
-		normalizedBaseUrl.pathname = \`\${normalizedBaseUrl.pathname}/\`;
-	}
-
-	const relativePath = endpointPath.replace(/^\\/+/u, "");
-	return new URL(relativePath, normalizedBaseUrl);
-}
-
-async function assertJsonEndpoint(label, url) {
-	const response = await fetch(url, {
-		headers: {
-			accept: "application/json",
-		},
-	});
-
-	if (!response.ok) {
-		throw new Error(
-			\`\${label} failed at \${url} with HTTP \${response.status}.\`,
-		);
-	}
-
-	const contentType = response.headers.get("content-type") ?? "";
-	if (!contentType.includes("application/json")) {
-		throw new Error(
-			\`\${label} at \${url} did not return JSON (content-type: \${contentType || "missing"}).\`,
-		);
-	}
-
-	return response.json();
-}
-
-const baseUrl = new URL(
-	getEnv("WP_TYPIA_SMOKE_BASE_URL", "http://localhost:8888"),
-);
-const serviceUrl = getEnv("WP_TYPIA_SERVICE_URL", "").trim();
-
-await assertJsonEndpoint(
-	"WordPress REST index",
-	resolveEndpointUrl(baseUrl, "wp-json/"),
-);
-
-if (serviceUrl.length > 0) {
-	await assertJsonEndpoint(
-		"Local integration service healthcheck",
-		resolveEndpointUrl(serviceUrl, "health"),
-	);
-}
-
-console.log("wp-typia integration smoke passed: ${integrationEnvSlug}");
-`;
-}
-function buildEnvExampleSource(service) {
-  return [
-    "# wp-typia integration smoke settings",
-    "WP_TYPIA_SMOKE_BASE_URL=http://localhost:8888",
-    "WP_TYPIA_SMOKE_USERNAME=admin",
-    "WP_TYPIA_SMOKE_PASSWORD=password",
-    ...service === "docker-compose" ? [
-      "",
-      "# Optional docker-compose integration service starter.",
-      "WP_TYPIA_SERVICE_URL=http://localhost:3000"
-    ] : [
-      "",
-      "# Set this when your smoke test needs a project-specific service.",
-      "# WP_TYPIA_SERVICE_URL=http://localhost:3000"
-    ],
-    ""
-  ].join(`
-`);
-}
-function buildIntegrationEnvReadmeSource({
-  integrationEnvSlug,
-  service,
-  withWpEnv
-}) {
-  const title = toTitleCase(integrationEnvSlug);
-  const setupSteps = [
-    "Copy `.env.example` to `.env` and adjust the URLs or credentials for your local project.",
-    ...withWpEnv ? [
-      "Run `npm run wp-env:start` to start the generated WordPress environment."
-    ] : [
-      "Point `WP_TYPIA_SMOKE_BASE_URL` at the WordPress environment you already run locally."
-    ],
-    ...service === "docker-compose" ? [
-      "Run `npm run service:start` if you want the placeholder docker-compose service available at `WP_TYPIA_SERVICE_URL`."
-    ] : [
-      "Set `WP_TYPIA_SERVICE_URL` only when your integration smoke needs a local service dependency."
-    ],
-    `Run \`npm run smoke:${integrationEnvSlug}\` to execute the starter smoke check.`
-  ];
-  return `# ${title} Integration Environment
-
-This starter keeps local WordPress integration smoke checks opt-in and editable.
-It does not change default block scaffolds or require wp-env unless this add
-workflow was run with \`--wp-env\`.
-
-## Setup
-
-${setupSteps.map((step, index) => `${index + 1}. ${step}`).join(`
-`)}
-
-## Adapting the Starter
-
-- Extend \`scripts/integration-smoke/${integrationEnvSlug}.mjs\` with the REST,
-  editor, or service assertions that matter for this project.
-- Keep secrets in \`.env\`; \`.env.example\` should document only safe defaults.
-- If your project uses a real service stack, replace the placeholder
-  \`docker-compose.integration.yml\` service with your database, queue, API, or
-  emulator containers.
-- Keep the smoke script focused on high-signal integration checks so CI and
-  local debugging stay fast.
-`;
-}
-async function appendMissingLines(filePath, lines) {
-  const current = await readOptionalUtf8File(filePath) ?? "";
-  const missingLines = lines.filter((line) => !current.includes(`${line}
-`) && !current.endsWith(line));
-  if (missingLines.length === 0) {
-    return;
-  }
-  const separator = current.length === 0 || current.endsWith(`
-`) ? "" : `
-`;
-  await fsp5.mkdir(path8.dirname(filePath), { recursive: true });
-  await fsp5.writeFile(filePath, `${current}${separator}${missingLines.join(`
-`)}
-`, "utf8");
-}
-async function writeFileIfAbsent({
-  filePath,
-  source,
-  warnings
-}) {
-  if (await pathExists(filePath)) {
-    warnings.push(`Preserved existing ${path8.basename(filePath)}; review it manually if you need different local integration settings.`);
-    return;
-  }
-  await fsp5.mkdir(path8.dirname(filePath), { recursive: true });
-  await fsp5.writeFile(filePath, source, "utf8");
-}
-async function writeNewScaffoldFile(filePath, source) {
-  if (await pathExists(filePath)) {
-    throw new Error(`An integration environment scaffold already exists at ${filePath}. Choose a different name.`);
-  }
-  await fsp5.mkdir(path8.dirname(filePath), { recursive: true });
-  await fsp5.writeFile(filePath, source, "utf8");
-}
-function addScriptIfMissing({
-  scriptName,
-  scripts,
-  scriptValue,
-  warnings
-}) {
-  if (scripts[scriptName] === undefined) {
-    scripts[scriptName] = scriptValue;
-    return;
-  }
-  if (scripts[scriptName] !== scriptValue) {
-    warnings.push(`Preserved existing package script "${scriptName}"; add "${scriptValue}" manually if you want the generated integration command.`);
-  }
-}
-async function mutatePackageJson(projectDir, mutate) {
-  const packageJsonPath = path8.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp5.readFile(packageJsonPath, "utf8"));
-  mutate(packageJson);
-  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
-`, "utf8");
-}
-function addIntegrationEnvPackageJsonEntries({
-  integrationEnvSlug,
-  packageManager,
-  packageJson,
-  service,
-  warnings,
-  withWpEnv
-}) {
-  const devDependencies = {
-    ...packageJson.devDependencies ?? {}
-  };
-  if (withWpEnv && devDependencies["@wordpress/env"] === undefined) {
-    devDependencies["@wordpress/env"] = WP_ENV_PACKAGE_VERSION;
-  }
-  packageJson.devDependencies = devDependencies;
-  const scripts = {
-    ...packageJson.scripts ?? {}
-  };
-  addScriptIfMissing({
-    scriptName: `smoke:${integrationEnvSlug}`,
-    scriptValue: `node scripts/integration-smoke/${integrationEnvSlug}.mjs`,
-    scripts,
-    warnings
-  });
-  addScriptIfMissing({
-    scriptName: "smoke:integration",
-    scriptValue: formatRunScript(packageManager, `smoke:${integrationEnvSlug}`),
-    scripts,
-    warnings
-  });
-  if (withWpEnv) {
-    addScriptIfMissing({
-      scriptName: "wp-env:start",
-      scriptValue: "wp-env start",
-      scripts,
-      warnings
-    });
-    addScriptIfMissing({
-      scriptName: "wp-env:stop",
-      scriptValue: "wp-env stop",
-      scripts,
-      warnings
-    });
-    addScriptIfMissing({
-      scriptName: "wp-env:reset",
-      scriptValue: "wp-env destroy all && wp-env start",
-      scripts,
-      warnings
-    });
-  }
-  if (service === "docker-compose") {
-    addScriptIfMissing({
-      scriptName: "service:start",
-      scriptValue: "docker compose -f docker-compose.integration.yml up -d",
-      scripts,
-      warnings
-    });
-    addScriptIfMissing({
-      scriptName: "service:stop",
-      scriptValue: "docker compose -f docker-compose.integration.yml down",
-      scripts,
-      warnings
-    });
-  }
-  packageJson.scripts = scripts;
-}
-async function runAddIntegrationEnvCommand({
-  cwd = process.cwd(),
-  integrationEnvName,
-  service,
-  withWpEnv = false
+async function runAddBindingSourceCommand({
+  attributeName,
+  bindingSourceName,
+  blockName,
+  cwd = process.cwd()
 }) {
   const workspace = resolveWorkspaceProject(cwd);
-  const integrationEnvSlug = assertValidGeneratedSlug("Integration environment name", normalizeBlockSlug(integrationEnvName), "wp-typia add integration-env <name> [--wp-env]");
-  const serviceId = assertValidIntegrationEnvService(service);
-  const warnings = [];
-  const packageJsonPath = path8.join(workspace.projectDir, "package.json");
-  const gitignorePath = path8.join(workspace.projectDir, ".gitignore");
-  const envExamplePath = path8.join(workspace.projectDir, ".env.example");
-  const wpEnvPath = path8.join(workspace.projectDir, ".wp-env.json");
-  const dockerComposePath = path8.join(workspace.projectDir, "docker-compose.integration.yml");
-  const smokeDir = path8.join(workspace.projectDir, "scripts", "integration-smoke");
-  const docsDir = path8.join(workspace.projectDir, "docs", "integration-env");
-  const smokeScriptPath = path8.join(smokeDir, `${integrationEnvSlug}.mjs`);
-  const docsPath = path8.join(docsDir, `${integrationEnvSlug}.md`);
-  const shouldRemoveSmokeDirOnRollback = !await pathExists(smokeDir);
-  const shouldRemoveDocsDirOnRollback = !await pathExists(docsDir);
-  await executeWorkspaceMutationPlan({
-    filePaths: [
-      packageJsonPath,
-      gitignorePath,
-      envExamplePath,
-      ...withWpEnv ? [wpEnvPath] : [],
-      ...serviceId === "docker-compose" ? [dockerComposePath] : []
-    ],
-    targetPaths: [
-      smokeScriptPath,
-      docsPath,
-      ...shouldRemoveSmokeDirOnRollback ? [smokeDir] : [],
-      ...shouldRemoveDocsDirOnRollback ? [docsDir] : []
-    ],
-    run: async () => {
-      await writeNewScaffoldFile(smokeScriptPath, buildIntegrationSmokeScriptSource(integrationEnvSlug));
-      await writeNewScaffoldFile(docsPath, buildIntegrationEnvReadmeSource({
-        integrationEnvSlug,
-        service: serviceId,
-        withWpEnv
-      }));
-      await appendMissingLines(envExamplePath, [
-        ...buildEnvExampleSource(serviceId).trimEnd().split(`
-`)
-      ]);
-      await appendMissingLines(gitignorePath, [".env", ".env.local"]);
-      if (withWpEnv) {
-        await writeFileIfAbsent({
-          filePath: wpEnvPath,
-          source: buildWpEnvConfigSource(),
-          warnings
-        });
-      }
-      if (serviceId === "docker-compose") {
-        await writeFileIfAbsent({
-          filePath: dockerComposePath,
-          source: buildDockerComposeSource(),
-          warnings
-        });
-      }
-      await mutatePackageJson(workspace.projectDir, (packageJson) => addIntegrationEnvPackageJsonEntries({
-        integrationEnvSlug,
-        packageManager: workspace.packageManager,
-        packageJson,
-        service: serviceId,
-        warnings,
-        withWpEnv
-      }));
-    }
-  });
-  return {
-    integrationEnvSlug,
-    projectDir: workspace.projectDir,
-    service: serviceId,
-    warnings: warnings.length > 0 ? warnings : undefined,
-    withWpEnv
+  const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>]");
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+  assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
+  const target = resolveBindingTarget({
+    attributeName,
+    blockName
+  }, workspace.workspace.namespace);
+  const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
+  const blockConfigPath = path7.join(workspace.projectDir, "scripts", "block-config.ts");
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  const bindingsIndexPath = await resolveBindingSourceRegistryPath(workspace.projectDir);
+  const bindingSourceDir = path7.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
+  const serverFilePath = path7.join(bindingSourceDir, "server.php");
+  const editorFilePath = path7.join(bindingSourceDir, "editor.ts");
+  const blockJsonPath = target ? path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
+  const targetGeneratedMetadataPaths = target ? [
+    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
+    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
+    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
+    path7.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
+  ] : [];
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles([
+      blockConfigPath,
+      bootstrapPath,
+      bindingsIndexPath,
+      ...blockJsonPath ? [blockJsonPath] : [],
+      ...targetBlock ? [path7.join(workspace.projectDir, targetBlock.typesFile)] : [],
+      ...targetGeneratedMetadataPaths
+    ]),
+    snapshotDirs: [],
+    targetPaths: [bindingSourceDir]
   };
+  try {
+    await fsp4.mkdir(bindingSourceDir, { recursive: true });
+    await ensureBindingSourceBootstrapAnchors(workspace);
+    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, target)]
+    });
+    return {
+      ...target ? { attributeName: target.attributeName, blockSlug: target.blockSlug } : {},
+      bindingSourceSlug,
+      projectDir: workspace.projectDir
+    };
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw error;
+  }
 }
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
-import { promises as fsp6 } from "fs";
-import path10 from "path";
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-generated.ts
+import { promises as fsp5 } from "fs";
+import path9 from "path";
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-anchors.ts
-import path9 from "path";
+import path8 from "path";
 var REST_RESOURCE_SERVER_GLOB = "/inc/rest/*.php";
+var REST_SCHEMA_HELPER_PATH = "/inc/rest-schema.php";
+async function ensureRestSchemaHelperBootstrapAnchors(workspace) {
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  await patchFile(bootstrapPath, (source) => {
+    let nextSource = source;
+    const loadFunctionName = `${workspace.workspace.phpPrefix}_load_rest_schema_helpers`;
+    const loadCall = `${loadFunctionName}();`;
+    const helperFunction = `
+
+function ${loadFunctionName}() {
+	$helper_path = __DIR__ . '${REST_SCHEMA_HELPER_PATH}';
+	if ( is_readable( $helper_path ) ) {
+		require_once $helper_path;
+	}
+}
+
+${loadCall}
+`;
+    if (!hasPhpFunctionDefinition(nextSource, loadFunctionName)) {
+      nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, helperFunction);
+    } else if (!nextSource.includes(REST_SCHEMA_HELPER_PATH)) {
+      throw new Error([
+        `Unable to patch ${path8.basename(bootstrapPath)} in ensureRestSchemaHelperBootstrapAnchors.`,
+        `The existing ${loadFunctionName}() definition does not include ${REST_SCHEMA_HELPER_PATH}.`,
+        "Restore the generated bootstrap shape or load inc/rest-schema.php manually before retrying."
+      ].join(" "));
+    } else if (!nextSource.includes(loadCall)) {
+      nextSource = appendPhpSnippetBeforeClosingTag(nextSource, loadCall);
+    }
+    return nextSource;
+  });
+}
 async function ensureRestResourceBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   await patchFile(bootstrapPath, (source) => {
@@ -4830,7 +4517,7 @@ function ${registerFunctionName}() {
       nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, registerFunction);
     } else if (!nextSource.includes(REST_RESOURCE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path9.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
+        `Unable to patch ${path8.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(" "));
@@ -4844,7 +4531,7 @@ function ${registerFunctionName}() {
 function assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureRestResourceSyncScriptAnchors could not patch ${path9.basename(syncRestScriptPath)}.`,
+      `ensureRestResourceSyncScriptAnchors could not patch ${path8.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(" "));
@@ -4860,7 +4547,7 @@ function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement,
 }
 function getSyncRestPatchErrorMessage(functionName, syncRestScriptPath, anchorDescription, subject) {
   return [
-    `${functionName} could not patch ${path9.basename(syncRestScriptPath)}.`,
+    `${functionName} could not patch ${path8.basename(syncRestScriptPath)}.`,
     `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
     `Restore the generated template or add the ${subject} wiring manually before retrying.`
   ].join(" ");
@@ -5123,7 +4810,7 @@ ${resourceLoopAnchor}`);
 `), "success log insertion point", syncRestScriptPath);
 }
 async function ensureContractSyncScriptAnchors(workspace) {
-  const syncRestScriptPath = path9.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path8.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = replaceBlockConfigImportForContracts(source, syncRestScriptPath);
     const helperInsertionAnchor = "async function assertTypeArtifactsCurrent";
@@ -5156,7 +4843,7 @@ async function ensureContractSyncScriptAnchors(workspace) {
   });
 }
 async function ensureRestResourceSyncScriptAnchors(workspace) {
-  const syncRestScriptPath = path9.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path8.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = replaceBlockConfigImportForRestResources(source, syncRestScriptPath);
     const helperInsertionAnchor = "async function assertTypeArtifactsCurrent";
@@ -5252,14 +4939,7 @@ async function ensureRestResourceSyncScriptAnchors(workspace) {
   });
 }
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
-var MANUAL_REST_REQUEST_BODY_FIELD_NAMES = new Set(["payload", "comment"]);
-var MANUAL_REST_RESPONSE_FIELD_NAMES = new Set([
-  "id",
-  "status",
-  "message",
-  "updatedAt"
-]);
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-php-templates.ts
 function buildRestResourceRouteRegistrations(restResourceSlug, methods, functions, options) {
   const collectionRoutes = [];
   const itemRoutes = [];
@@ -5370,13 +5050,11 @@ if ( ! class_exists( ${quotePhpString(controllerClassName)} ) ) {
 }
 `;
 }
-function buildRestResourcePhpSource(restResourceSlug, namespace, phpPrefix, textDomain, methods, options) {
+function buildRestResourcePhpSource(restResourceSlug, namespace, phpPrefix, methods, options) {
   const restResourceTitle = toTitleCase(restResourceSlug);
   const restResourcePhpId = restResourceSlug.replace(/-/g, "_");
   const canWriteFunctionName = `${phpPrefix}_${restResourcePhpId}_can_manage_rest_resource`;
   const getItemsFunctionName = `${phpPrefix}_${restResourcePhpId}_get_rest_resource_items`;
-  const loadSchemaFunctionName = `${phpPrefix}_${restResourcePhpId}_load_rest_resource_schema`;
-  const normalizeSchemaFunctionName = `${phpPrefix}_${restResourcePhpId}_sanitize_rest_resource_schema`;
   const validatePayloadFunctionName = `${phpPrefix}_${restResourcePhpId}_validate_rest_resource_payload`;
   const normalizeItemFunctionName = `${phpPrefix}_${restResourcePhpId}_normalize_rest_resource_item`;
   const saveItemsFunctionName = `${phpPrefix}_${restResourcePhpId}_save_rest_resource_items`;
@@ -5486,55 +5164,22 @@ if ( ! function_exists( '${saveItemsFunctionName}' ) ) {
 	}
 }
 
-if ( ! function_exists( '${loadSchemaFunctionName}' ) ) {
-	function ${loadSchemaFunctionName}( $schema_name ) {
-		$project_root = dirname( __DIR__, 2 );
-		$schema_path  = $project_root . '/src/rest/${restResourceSlug}/api-schemas/' . $schema_name . '.schema.json';
-		if ( ! file_exists( $schema_path ) ) {
-			return null;
-		}
-
-		$decoded = json_decode( file_get_contents( $schema_path ), true );
-		return is_array( $decoded ) ? $decoded : null;
-	}
-}
-
-if ( ! function_exists( '${normalizeSchemaFunctionName}' ) ) {
-	function ${normalizeSchemaFunctionName}( $schema ) {
-		if ( ! is_array( $schema ) ) {
-			return $schema;
-		}
-
-		unset( $schema['$schema'], $schema['title'] );
-
-		if ( isset( $schema['properties'] ) && is_array( $schema['properties'] ) ) {
-			foreach ( $schema['properties'] as $key => $property_schema ) {
-				$schema['properties'][ $key ] = ${normalizeSchemaFunctionName}( $property_schema );
-			}
-		}
-
-		if ( isset( $schema['items'] ) && is_array( $schema['items'] ) ) {
-			$schema['items'] = ${normalizeSchemaFunctionName}( $schema['items'] );
-		}
-
-		return $schema;
-	}
-}
-
 if ( ! function_exists( '${validatePayloadFunctionName}' ) ) {
 	function ${validatePayloadFunctionName}( $value, $schema_name, $param_name ) {
-		$schema = ${loadSchemaFunctionName}( $schema_name );
-		if ( ! is_array( $schema ) ) {
-			return new WP_Error( 'missing_schema', 'Missing REST schema.', array( 'status' => 500 ) );
-		}
-
-		$rest_schema = ${normalizeSchemaFunctionName}( $schema );
-		$validation  = rest_validate_value_from_schema( $value, $rest_schema, $param_name );
-		if ( is_wp_error( $validation ) ) {
-			return $validation;
+		if ( ! function_exists( '${phpPrefix}_validate_and_sanitize_rest_payload' ) ) {
+			return new WP_Error(
+				'missing_rest_schema_helper',
+				'Missing REST schema helper. Ensure inc/rest-schema.php is loaded before REST resources.',
+				array( 'status' => 500 )
+			);
 		}
 
-		return rest_sanitize_value_from_schema( $value, $rest_schema, $param_name );
+		return ${phpPrefix}_validate_and_sanitize_rest_payload(
+			$value,
+			$schema_name,
+			$param_name,
+			array( 'resource' => ${quotePhpString(restResourceSlug)} )
+		);
 	}
 }
 
@@ -5742,170 +5387,247 @@ if ( ! function_exists( '${registerRoutesFunctionName}' ) ) {
 	function ${registerRoutesFunctionName}() {
 		$namespace = ${quotePhpString(namespace)};
 
-${controllerBootstrapSource}
-${routeRegistrations}
+${controllerBootstrapSource}
+${routeRegistrations}
+	}
+}
+
+add_action( 'rest_api_init', '${registerRoutesFunctionName}' );
+`;
+}
+function buildWorkspaceRestSchemaHelperPhpSource(phpPrefix) {
+  return `<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	return;
+}
+
+if ( ! function_exists( '${phpPrefix}_is_valid_rest_schema_key' ) ) {
+	function ${phpPrefix}_is_valid_rest_schema_key( $value ) {
+		return is_string( $value ) && 1 === preg_match( '/\\A[A-Za-z0-9_-]+\\z/', $value );
+	}
+}
+
+if ( ! function_exists( '${phpPrefix}_is_valid_rest_resource_slug' ) ) {
+	function ${phpPrefix}_is_valid_rest_resource_slug( $value ) {
+		return is_string( $value ) && 1 === preg_match( '/\\A[a-z0-9]+(?:-[a-z0-9]+)*\\z/', $value );
+	}
+}
+
+if ( ! function_exists( '${phpPrefix}_resolve_rest_schema_paths' ) ) {
+	function ${phpPrefix}_resolve_rest_schema_paths( $schema_name, $options = array() ) {
+		if ( ! ${phpPrefix}_is_valid_rest_schema_key( $schema_name ) ) {
+			return new WP_Error(
+				'invalid_rest_schema_name',
+				'Invalid REST schema name.',
+				array( 'status' => 500 )
+			);
+		}
+
+		$options      = is_array( $options ) ? $options : array();
+		$project_root = dirname( __DIR__ );
+		$paths        = array();
+
+		if ( isset( $options['resource'] ) && '' !== $options['resource'] ) {
+			if ( ! ${phpPrefix}_is_valid_rest_resource_slug( $options['resource'] ) ) {
+				return new WP_Error(
+					'invalid_rest_schema_resource',
+					'Invalid REST schema resource slug.',
+					array( 'status' => 500 )
+				);
+			}
+
+			$resource_slug = $options['resource'];
+			$paths[]       = __DIR__ . '/rest-schemas/rest/' . $resource_slug . '/' . $schema_name . '.schema.json';
+			$paths[]       = $project_root . '/src/rest/' . $resource_slug . '/api-schemas/' . $schema_name . '.schema.json';
+		}
+
+		if ( isset( $options['paths'] ) && is_array( $options['paths'] ) ) {
+			foreach ( $options['paths'] as $schema_path ) {
+				if ( is_string( $schema_path ) && '' !== $schema_path && ! in_array( $schema_path, $paths, true ) ) {
+					$paths[] = $schema_path;
+				}
+			}
+		}
+
+		return $paths;
+	}
+}
+
+if ( ! function_exists( '${phpPrefix}_load_rest_schema' ) ) {
+	function ${phpPrefix}_load_rest_schema( $schema_name, $options = array() ) {
+		$schema_paths = ${phpPrefix}_resolve_rest_schema_paths( $schema_name, $options );
+		if ( is_wp_error( $schema_paths ) ) {
+			return $schema_paths;
+		}
+
+		foreach ( $schema_paths as $schema_path ) {
+			if ( ! is_file( $schema_path ) ) {
+				continue;
+			}
+
+			if ( ! is_readable( $schema_path ) ) {
+				return new WP_Error(
+					'unreadable_rest_schema',
+					'Generated REST schema is not readable.',
+					array(
+						'path'   => $schema_path,
+						'status' => 500,
+					)
+				);
+			}
+
+			$schema_json = file_get_contents( $schema_path );
+			if ( false === $schema_json ) {
+				return new WP_Error(
+					'rest_schema_read_failed',
+					'Generated REST schema could not be read.',
+					array(
+						'path'   => $schema_path,
+						'status' => 500,
+					)
+				);
+			}
+
+			$decoded = json_decode( $schema_json, true );
+			if ( ! is_array( $decoded ) ) {
+				return new WP_Error(
+					'malformed_rest_schema',
+					'Generated REST schema contains malformed JSON.',
+					array(
+						'json_error' => json_last_error_msg(),
+						'path'       => $schema_path,
+						'status'     => 500,
+					)
+				);
+			}
+
+			return $decoded;
+		}
+
+		return new WP_Error(
+			'missing_rest_schema',
+			'Generated REST schema could not be found.',
+			array(
+				'paths'  => $schema_paths,
+				'schema' => $schema_name,
+				'status' => 500,
+			)
+		);
+	}
+}
+
+if ( ! function_exists( '${phpPrefix}_prepare_rest_schema_for_wordpress' ) ) {
+	function ${phpPrefix}_prepare_rest_schema_for_wordpress( $schema ) {
+		if ( ! is_array( $schema ) ) {
+			return $schema;
+		}
+
+		unset( $schema['$schema'], $schema['title'] );
+
+		foreach ( array( 'properties', 'patternProperties', 'definitions', '$defs' ) as $schema_map_key ) {
+			if ( ! isset( $schema[ $schema_map_key ] ) || ! is_array( $schema[ $schema_map_key ] ) ) {
+				continue;
+			}
+
+			foreach ( $schema[ $schema_map_key ] as $key => $property_schema ) {
+				$schema[ $schema_map_key ][ $key ] = ${phpPrefix}_prepare_rest_schema_for_wordpress( $property_schema );
+			}
+		}
+
+		foreach ( array( 'items', 'additionalProperties', 'contains', 'propertyNames', 'not', 'if', 'then', 'else' ) as $nested_schema_key ) {
+			if ( isset( $schema[ $nested_schema_key ] ) && is_array( $schema[ $nested_schema_key ] ) ) {
+				$schema[ $nested_schema_key ] = ${phpPrefix}_prepare_rest_schema_for_wordpress( $schema[ $nested_schema_key ] );
+			}
+		}
+
+		foreach ( array( 'allOf', 'anyOf', 'oneOf' ) as $schema_list_key ) {
+			if ( ! isset( $schema[ $schema_list_key ] ) || ! is_array( $schema[ $schema_list_key ] ) ) {
+				continue;
+			}
+
+			foreach ( $schema[ $schema_list_key ] as $index => $variant_schema ) {
+				$schema[ $schema_list_key ][ $index ] = ${phpPrefix}_prepare_rest_schema_for_wordpress( $variant_schema );
+			}
+		}
+
+		return $schema;
+	}
+}
+
+if ( ! function_exists( '${phpPrefix}_get_wordpress_rest_schema' ) ) {
+	function ${phpPrefix}_get_wordpress_rest_schema( $schema_name, $options = array() ) {
+		$schema = ${phpPrefix}_load_rest_schema( $schema_name, $options );
+		if ( is_wp_error( $schema ) ) {
+			return $schema;
+		}
+
+		return ${phpPrefix}_prepare_rest_schema_for_wordpress( $schema );
+	}
+}
+
+if ( ! function_exists( '${phpPrefix}_validate_and_sanitize_rest_payload' ) ) {
+	function ${phpPrefix}_validate_and_sanitize_rest_payload( $value, $schema_name, $param_name, $options = array() ) {
+		$rest_schema = ${phpPrefix}_get_wordpress_rest_schema( $schema_name, $options );
+		if ( is_wp_error( $rest_schema ) ) {
+			return $rest_schema;
+		}
+
+		$validation = rest_validate_value_from_schema( $value, $rest_schema, $param_name );
+		if ( is_wp_error( $validation ) ) {
+			return $validation;
+		}
+
+		return rest_sanitize_value_from_schema( $value, $rest_schema, $param_name );
 	}
 }
-
-add_action( 'rest_api_init', '${registerRoutesFunctionName}' );
 `;
 }
-async function runAddRestResourceCommand({
-  auth,
-  bodyTypeName,
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-generated.ts
+async function ensureWorkspaceRestSchemaHelperFile(helperFilePath, phpPrefix) {
+  let currentSource = null;
+  try {
+    currentSource = await fsp5.readFile(helperFilePath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (currentSource === null) {
+    await fsp5.mkdir(path9.dirname(helperFilePath), { recursive: true });
+    await fsp5.writeFile(helperFilePath, buildWorkspaceRestSchemaHelperPhpSource(phpPrefix), "utf8");
+    return;
+  }
+  const requiredFunctions = [
+    `${phpPrefix}_load_rest_schema`,
+    `${phpPrefix}_prepare_rest_schema_for_wordpress`,
+    `${phpPrefix}_get_wordpress_rest_schema`,
+    `${phpPrefix}_validate_and_sanitize_rest_payload`
+  ];
+  const missingFunctions = requiredFunctions.filter((functionName) => !hasPhpFunctionDefinition(currentSource, functionName));
+  if (missingFunctions.length > 0) {
+    throw new Error([
+      `Existing ${path9.relative(process.cwd(), helperFilePath)} is missing generated REST schema helper functions: ${missingFunctions.join(", ")}.`,
+      "Restore the generated inc/rest-schema.php helper or add these functions manually before retrying."
+    ].join(" "));
+  }
+}
+async function scaffoldGeneratedRestResource({
   controllerClass,
   controllerExtends,
-  cwd = process.cwd(),
-  manual,
-  method,
   methods,
   namespace,
   permissionCallback,
-  pathPattern,
-  queryTypeName,
-  restResourceName,
-  responseTypeName,
+  restResourceSlug,
   routePattern,
-  secretFieldName,
-  secretStateFieldName
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const restResourceSlug = assertValidGeneratedSlug("REST resource name", normalizeBlockSlug(restResourceName), "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>]");
-  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
-  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
-  assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
-  const blockConfigPath = path10.join(workspace.projectDir, "scripts", "block-config.ts");
-  const syncRestScriptPath = path10.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const restResourceDir = path10.join(workspace.projectDir, "src", "rest", restResourceSlug);
-  const typesFilePath = path10.join(restResourceDir, "api-types.ts");
-  const validatorsFilePath = path10.join(restResourceDir, "api-validators.ts");
-  const apiFilePath = path10.join(restResourceDir, "api.ts");
-  if (manual) {
-    if (controllerClass || controllerExtends || permissionCallback || routePattern) {
-      throw new Error("Manual REST contracts do not generate PHP route glue. Use generated rest-resource mode for --route-pattern, --permission-callback, --controller-class, or --controller-extends.");
-    }
-    const pascalCase = toPascalCase(restResourceSlug);
-    const resolvedAuth = assertValidManualRestContractAuth(auth);
-    const resolvedMethod = assertValidManualRestContractHttpMethod(method);
-    const resolvedPathPattern = resolveManualRestContractPathPattern(restResourceSlug, pathPattern);
-    const resolvedQueryTypeName = assertValidTypeScriptIdentifier("Manual REST contract query type", queryTypeName ?? `${pascalCase}Query`, "wp-typia add rest-resource <name> --manual [--query-type <ExportedQueryType>]");
-    const resolvedResponseTypeName = assertValidTypeScriptIdentifier("Manual REST contract response type", responseTypeName ?? `${pascalCase}Response`, "wp-typia add rest-resource <name> --manual [--response-type <ExportedResponseType>]");
-    const defaultsToBody = bodyTypeName == null && ["PATCH", "POST", "PUT"].includes(resolvedMethod);
-    const resolvedBodyTypeName = bodyTypeName != null || defaultsToBody ? assertValidTypeScriptIdentifier("Manual REST contract body type", bodyTypeName ?? `${pascalCase}Request`, "wp-typia add rest-resource <name> --manual [--body-type <ExportedBodyType>]") : undefined;
-    if (resolvedMethod === "GET" && resolvedBodyTypeName) {
-      throw new Error("Manual REST contract GET routes cannot define a body type. Remove --body-type or use POST, PUT, or PATCH.");
-    }
-    if (secretStateFieldName && !secretFieldName) {
-      throw new Error("Manual REST contract --secret-state-field requires --secret-field.");
-    }
-    if (secretFieldName && !resolvedBodyTypeName) {
-      throw new Error("Manual REST contract secret fields require a request body. Use POST, PUT, or PATCH so a request body is generated.");
-    }
-    const resolvedSecretFieldName = secretFieldName ? assertValidTypeScriptIdentifier("Manual REST contract secret field", secretFieldName, "wp-typia add rest-resource <name> --manual --method POST --secret-field <field>") : undefined;
-    const resolvedSecretStateFieldName = resolvedSecretFieldName ? assertValidTypeScriptIdentifier("Manual REST contract secret state field", secretStateFieldName ?? `has${toPascalCase(resolvedSecretFieldName)}`, "wp-typia add rest-resource <name> --manual --method POST --secret-state-field <field>") : undefined;
-    if (resolvedSecretFieldName && MANUAL_REST_REQUEST_BODY_FIELD_NAMES.has(resolvedSecretFieldName)) {
-      throw new Error(`Manual REST contract secret field must not reuse scaffolded request body fields: ${Array.from(MANUAL_REST_REQUEST_BODY_FIELD_NAMES).join(", ")}.`);
-    }
-    if (resolvedSecretStateFieldName && MANUAL_REST_RESPONSE_FIELD_NAMES.has(resolvedSecretStateFieldName)) {
-      throw new Error(`Manual REST contract secret state field must not reuse scaffolded response fields: ${Array.from(MANUAL_REST_RESPONSE_FIELD_NAMES).join(", ")}.`);
-    }
-    if (resolvedSecretFieldName && resolvedSecretStateFieldName && resolvedSecretFieldName === resolvedSecretStateFieldName) {
-      throw new Error("Manual REST contract secret state field must be different from the raw secret field.");
-    }
-    const manualTypeNames = [
-      resolvedQueryTypeName,
-      resolvedResponseTypeName,
-      resolvedBodyTypeName
-    ].filter((value) => value != null);
-    const duplicateManualTypeNames = manualTypeNames.filter((name, index) => manualTypeNames.indexOf(name) !== index);
-    if (duplicateManualTypeNames.length > 0) {
-      throw new Error(`Manual REST contract type names must be unique: ${Array.from(new Set(duplicateManualTypeNames)).join(", ")}. Use distinct --query-type, --body-type, and --response-type values.`);
-    }
-    const mutationSnapshot2 = {
-      fileSources: await snapshotWorkspaceFiles([
-        blockConfigPath,
-        syncRestScriptPath
-      ]),
-      snapshotDirs: [],
-      targetPaths: [restResourceDir]
-    };
-    try {
-      await fsp6.mkdir(restResourceDir, { recursive: true });
-      await ensureRestResourceSyncScriptAnchors(workspace);
-      await fsp6.writeFile(typesFilePath, buildManualRestContractTypesSource({
-        ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
-        queryTypeName: resolvedQueryTypeName,
-        responseTypeName: resolvedResponseTypeName,
-        restResourceSlug,
-        ...resolvedSecretFieldName ? { secretFieldName: resolvedSecretFieldName } : {},
-        ...resolvedSecretStateFieldName ? { secretStateFieldName: resolvedSecretStateFieldName } : {}
-      }), "utf8");
-      await fsp6.writeFile(validatorsFilePath, buildManualRestContractValidatorsSource({
-        ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
-        queryTypeName: resolvedQueryTypeName,
-        responseTypeName: resolvedResponseTypeName
-      }), "utf8");
-      await fsp6.writeFile(apiFilePath, buildManualRestContractApiSource({
-        ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
-        queryTypeName: resolvedQueryTypeName,
-        restResourceSlug
-      }), "utf8");
-      await syncManualRestContractArtifacts({
-        clientFile: `src/rest/${restResourceSlug}/api-client.ts`,
-        outputDir: restResourceDir,
-        projectDir: workspace.projectDir,
-        typesFile: `src/rest/${restResourceSlug}/api-types.ts`,
-        validatorsFile: `src/rest/${restResourceSlug}/api-validators.ts`,
-        variables: {
-          auth: resolvedAuth,
-          ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
-          method: resolvedMethod,
-          namespace: resolvedNamespace,
-          pascalCase,
-          pathPattern: resolvedPathPattern,
-          queryTypeName: resolvedQueryTypeName,
-          responseTypeName: resolvedResponseTypeName,
-          slugKebabCase: restResourceSlug,
-          title: toTitleCase(restResourceSlug)
-        }
-      });
-      await appendWorkspaceInventoryEntries(workspace.projectDir, {
-        restResourceEntries: [
-          buildManualRestContractConfigEntry({
-            auth: resolvedAuth,
-            ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
-            method: resolvedMethod,
-            namespace: resolvedNamespace,
-            pathPattern: resolvedPathPattern,
-            queryTypeName: resolvedQueryTypeName,
-            responseTypeName: resolvedResponseTypeName,
-            restResourceSlug,
-            ...resolvedSecretFieldName ? { secretFieldName: resolvedSecretFieldName } : {},
-            ...resolvedSecretStateFieldName ? { secretStateFieldName: resolvedSecretStateFieldName } : {}
-          })
-        ],
-        transformSource: ensureBlockConfigCanAddRestManifests
-      });
-      return {
-        auth: resolvedAuth,
-        ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
-        method: resolvedMethod,
-        methods: [],
-        mode: "manual",
-        namespace: resolvedNamespace,
-        pathPattern: resolvedPathPattern,
-        projectDir: workspace.projectDir,
-        queryTypeName: resolvedQueryTypeName,
-        restResourceSlug,
-        responseTypeName: resolvedResponseTypeName,
-        ...resolvedSecretFieldName ? { secretFieldName: resolvedSecretFieldName } : {},
-        ...resolvedSecretStateFieldName ? { secretStateFieldName: resolvedSecretStateFieldName } : {}
-      };
-    } catch (error) {
-      await rollbackWorkspaceMutation(mutationSnapshot2);
-      throw error;
-    }
-  }
+  const blockConfigPath = path9.join(workspace.projectDir, "scripts", "block-config.ts");
+  const syncRestScriptPath = path9.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const restResourceDir = path9.join(workspace.projectDir, "src", "rest", restResourceSlug);
+  const typesFilePath = path9.join(restResourceDir, "api-types.ts");
+  const validatorsFilePath = path9.join(restResourceDir, "api-validators.ts");
+  const apiFilePath = path9.join(restResourceDir, "api.ts");
   const resolvedMethods = assertValidRestResourceMethods(methods);
   const resolvedRoutePattern = resolveGeneratedRestResourceRoutePattern(restResourceSlug, routePattern);
   const hasCustomRoutePattern = typeof routePattern === "string" && routePattern.trim().length > 0;
@@ -5916,27 +5638,31 @@ async function runAddRestResourceCommand({
     throw new Error("Generated REST resource controller base class requires --controller-class.");
   }
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const dataFilePath = path10.join(restResourceDir, "data.ts");
-  const phpFilePath = path10.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
+  const dataFilePath = path9.join(restResourceDir, "data.ts");
+  const restSchemaHelperPath = path9.join(workspace.projectDir, "inc", "rest-schema.php");
+  const phpFilePath = path9.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
       bootstrapPath,
+      restSchemaHelperPath,
       syncRestScriptPath
     ]),
     snapshotDirs: [],
-    targetPaths: [restResourceDir, phpFilePath]
+    targetPaths: [restResourceDir, restSchemaHelperPath, phpFilePath]
   };
   try {
-    await fsp6.mkdir(restResourceDir, { recursive: true });
-    await fsp6.mkdir(path10.dirname(phpFilePath), { recursive: true });
+    await fsp5.mkdir(restResourceDir, { recursive: true });
+    await fsp5.mkdir(path9.dirname(phpFilePath), { recursive: true });
+    await ensureWorkspaceRestSchemaHelperFile(restSchemaHelperPath, workspace.workspace.phpPrefix);
+    await ensureRestSchemaHelperBootstrapAnchors(workspace);
     await ensureRestResourceBootstrapAnchors(workspace);
     await ensureRestResourceSyncScriptAnchors(workspace);
-    await fsp6.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp6.writeFile(validatorsFilePath, buildRestResourceValidatorsSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp6.writeFile(apiFilePath, buildRestResourceApiSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp6.writeFile(dataFilePath, buildRestResourceDataSource(restResourceSlug, resolvedMethods), "utf8");
-    await fsp6.writeFile(phpFilePath, buildRestResourcePhpSource(restResourceSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain, resolvedMethods, {
+    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, namespace, workspace.workspace.phpPrefix, resolvedMethods, {
       ...resolvedControllerClass ? { controllerClass: resolvedControllerClass } : {},
       ...resolvedControllerExtends ? { controllerExtends: resolvedControllerExtends } : {},
       ...resolvedPermissionCallback ? { permissionCallback: resolvedPermissionCallback } : {},
@@ -5950,7 +5676,7 @@ async function runAddRestResourceCommand({
       typesFile: `src/rest/${restResourceSlug}/api-types.ts`,
       validatorsFile: `src/rest/${restResourceSlug}/api-validators.ts`,
       variables: {
-        namespace: resolvedNamespace,
+        namespace,
         pascalCase: toPascalCase(restResourceSlug),
         ...hasCustomRoutePattern ? { routePattern: resolvedRoutePattern } : {},
         slugKebabCase: restResourceSlug,
@@ -5963,7 +5689,7 @@ async function runAddRestResourceCommand({
           ...resolvedControllerClass ? { controllerClass: resolvedControllerClass } : {},
           ...resolvedControllerExtends ? { controllerExtends: resolvedControllerExtends } : {},
           methods: resolvedMethods,
-          namespace: resolvedNamespace,
+          namespace,
           ...resolvedPermissionCallback ? { permissionCallback: resolvedPermissionCallback } : {},
           restResourceSlug,
           ...hasCustomRoutePattern ? { routePattern: resolvedRoutePattern } : {}
@@ -5976,7 +5702,7 @@ async function runAddRestResourceCommand({
       ...resolvedControllerExtends ? { controllerExtends: resolvedControllerExtends } : {},
       methods: resolvedMethods,
       mode: "generated",
-      namespace: resolvedNamespace,
+      namespace,
       ...resolvedPermissionCallback ? { permissionCallback: resolvedPermissionCallback } : {},
       projectDir: workspace.projectDir,
       restResourceSlug,
@@ -5987,6 +5713,293 @@ async function runAddRestResourceCommand({
     throw error;
   }
 }
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-manual.ts
+import { promises as fsp6 } from "fs";
+import path10 from "path";
+var MANUAL_REST_REQUEST_BODY_FIELD_NAMES = new Set(["payload", "comment"]);
+var MANUAL_REST_RESPONSE_FIELD_NAMES = new Set([
+  "id",
+  "status",
+  "message",
+  "updatedAt"
+]);
+function resolveManualRestSecretPreserveOnEmpty(value) {
+  if (value === undefined) {
+    return true;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no"].includes(normalized)) {
+    return false;
+  }
+  throw new Error("Manual REST contract --secret-preserve-on-empty must be true or false.");
+}
+function resolveManualRestSecretStateFieldCandidate(options) {
+  const candidates = [
+    options.secretStateFieldName,
+    options.secretHasValueFieldName,
+    options.secretMaskedResponseFieldName
+  ].filter((value) => typeof value === "string");
+  const distinct = Array.from(new Set(candidates));
+  if (distinct.length > 1) {
+    throw new Error("Manual REST contract secret state, has-value, and masked response field flags must match when combined.");
+  }
+  return distinct[0];
+}
+function resolveManualRestRoutePathPattern(options) {
+  const trimmedPathPattern = typeof options.pathPattern === "string" ? options.pathPattern.trim() : undefined;
+  const trimmedRoutePattern = typeof options.routePattern === "string" ? options.routePattern.trim() : undefined;
+  if (trimmedPathPattern && trimmedRoutePattern && trimmedPathPattern !== trimmedRoutePattern) {
+    throw new Error("Manual REST contract --path and --route-pattern must match when both are provided. Use one route pattern flag for provider routes.");
+  }
+  return resolveManualRestContractPathPattern(options.restResourceSlug, options.pathPattern ?? options.routePattern);
+}
+async function scaffoldManualRestContract({
+  auth,
+  bodyTypeName,
+  controllerClass,
+  controllerExtends,
+  method,
+  namespace,
+  pathPattern,
+  permissionCallback,
+  queryTypeName,
+  responseTypeName,
+  restResourceSlug,
+  routePattern,
+  secretFieldName,
+  secretHasValueFieldName,
+  secretMaskedResponseFieldName,
+  secretPreserveOnEmpty,
+  secretStateFieldName,
+  workspace
+}) {
+  const blockConfigPath = path10.join(workspace.projectDir, "scripts", "block-config.ts");
+  const syncRestScriptPath = path10.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const restResourceDir = path10.join(workspace.projectDir, "src", "rest", restResourceSlug);
+  const typesFilePath = path10.join(restResourceDir, "api-types.ts");
+  const validatorsFilePath = path10.join(restResourceDir, "api-validators.ts");
+  const apiFilePath = path10.join(restResourceDir, "api.ts");
+  const pascalCase = toPascalCase(restResourceSlug);
+  const resolvedAuth = assertValidManualRestContractAuth(auth);
+  const resolvedMethod = assertValidManualRestContractHttpMethod(method);
+  const resolvedPathPattern = resolveManualRestRoutePathPattern({
+    pathPattern,
+    restResourceSlug,
+    routePattern
+  });
+  const pathParameterNames = collectRestRouteNamedCaptureNames(resolvedPathPattern);
+  const resolvedPermissionCallback = resolveOptionalPhpCallbackReference("Manual REST contract permission callback", permissionCallback);
+  const resolvedControllerClass = resolveOptionalPhpClassReference("Manual REST contract controller class", controllerClass);
+  const resolvedControllerExtends = resolveOptionalPhpClassReference("Manual REST contract controller base class", controllerExtends);
+  if (resolvedControllerExtends && !resolvedControllerClass) {
+    throw new Error("Manual REST contract controller base class requires --controller-class.");
+  }
+  const resolvedQueryTypeName = assertValidTypeScriptIdentifier("Manual REST contract query type", queryTypeName ?? `${pascalCase}Query`, "wp-typia add rest-resource <name> --manual [--query-type <ExportedQueryType>]");
+  const resolvedResponseTypeName = assertValidTypeScriptIdentifier("Manual REST contract response type", responseTypeName ?? `${pascalCase}Response`, "wp-typia add rest-resource <name> --manual [--response-type <ExportedResponseType>]");
+  const defaultsToBody = bodyTypeName == null && ["PATCH", "POST", "PUT"].includes(resolvedMethod);
+  const resolvedBodyTypeName = bodyTypeName != null || defaultsToBody ? assertValidTypeScriptIdentifier("Manual REST contract body type", bodyTypeName ?? `${pascalCase}Request`, "wp-typia add rest-resource <name> --manual [--body-type <ExportedBodyType>]") : undefined;
+  if (resolvedMethod === "GET" && resolvedBodyTypeName) {
+    throw new Error("Manual REST contract GET routes cannot define a body type. Remove --body-type or use POST, PUT, or PATCH.");
+  }
+  const secretStateFieldCandidate = resolveManualRestSecretStateFieldCandidate({
+    secretHasValueFieldName,
+    secretMaskedResponseFieldName,
+    secretStateFieldName
+  });
+  if (secretPreserveOnEmpty !== undefined && !secretFieldName) {
+    throw new Error("Manual REST contract --secret-preserve-on-empty requires --secret-field.");
+  }
+  if (secretStateFieldCandidate !== undefined && !secretFieldName) {
+    throw new Error("Manual REST contract secret state, has-value, and masked response field flags require --secret-field.");
+  }
+  if (secretFieldName && !resolvedBodyTypeName) {
+    throw new Error("Manual REST contract secret fields require a request body. Use POST, PUT, or PATCH so a request body is generated.");
+  }
+  const resolvedSecretFieldName = secretFieldName ? assertValidTypeScriptIdentifier("Manual REST contract secret field", secretFieldName, "wp-typia add rest-resource <name> --manual --method POST --secret-field <field>") : undefined;
+  const resolvedSecretPreserveOnEmpty = resolvedSecretFieldName ? resolveManualRestSecretPreserveOnEmpty(secretPreserveOnEmpty) : undefined;
+  const resolvedSecretStateFieldName = resolvedSecretFieldName ? assertValidTypeScriptIdentifier("Manual REST contract secret state field", secretStateFieldCandidate ?? `has${toPascalCase(resolvedSecretFieldName)}`, "wp-typia add rest-resource <name> --manual --method POST --secret-state-field <field>") : undefined;
+  if (resolvedSecretFieldName && MANUAL_REST_REQUEST_BODY_FIELD_NAMES.has(resolvedSecretFieldName)) {
+    throw new Error(`Manual REST contract secret field must not reuse scaffolded request body fields: ${Array.from(MANUAL_REST_REQUEST_BODY_FIELD_NAMES).join(", ")}.`);
+  }
+  if (resolvedSecretStateFieldName && MANUAL_REST_RESPONSE_FIELD_NAMES.has(resolvedSecretStateFieldName)) {
+    throw new Error(`Manual REST contract secret state field must not reuse scaffolded response fields: ${Array.from(MANUAL_REST_RESPONSE_FIELD_NAMES).join(", ")}.`);
+  }
+  if (resolvedSecretFieldName && resolvedSecretStateFieldName && resolvedSecretFieldName === resolvedSecretStateFieldName) {
+    throw new Error("Manual REST contract secret state field must be different from the raw secret field.");
+  }
+  const manualTypeNames = [
+    resolvedQueryTypeName,
+    resolvedResponseTypeName,
+    resolvedBodyTypeName
+  ].filter((value) => value != null);
+  const duplicateManualTypeNames = manualTypeNames.filter((name, index) => manualTypeNames.indexOf(name) !== index);
+  if (duplicateManualTypeNames.length > 0) {
+    throw new Error(`Manual REST contract type names must be unique: ${Array.from(new Set(duplicateManualTypeNames)).join(", ")}. Use distinct --query-type, --body-type, and --response-type values.`);
+  }
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles([
+      blockConfigPath,
+      syncRestScriptPath
+    ]),
+    snapshotDirs: [],
+    targetPaths: [restResourceDir]
+  };
+  try {
+    await fsp6.mkdir(restResourceDir, { recursive: true });
+    await ensureRestResourceSyncScriptAnchors(workspace);
+    await fsp6.writeFile(typesFilePath, buildManualRestContractTypesSource({
+      ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
+      pathParameterNames,
+      queryTypeName: resolvedQueryTypeName,
+      responseTypeName: resolvedResponseTypeName,
+      restResourceSlug,
+      ...resolvedSecretFieldName ? { secretFieldName: resolvedSecretFieldName } : {},
+      ...resolvedSecretPreserveOnEmpty !== undefined ? { secretPreserveOnEmpty: resolvedSecretPreserveOnEmpty } : {},
+      ...resolvedSecretStateFieldName ? { secretStateFieldName: resolvedSecretStateFieldName } : {}
+    }), "utf8");
+    await fsp6.writeFile(validatorsFilePath, buildManualRestContractValidatorsSource({
+      ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
+      queryTypeName: resolvedQueryTypeName,
+      responseTypeName: resolvedResponseTypeName
+    }), "utf8");
+    await fsp6.writeFile(apiFilePath, buildManualRestContractApiSource({
+      ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
+      queryTypeName: resolvedQueryTypeName,
+      restResourceSlug
+    }), "utf8");
+    await syncManualRestContractArtifacts({
+      clientFile: `src/rest/${restResourceSlug}/api-client.ts`,
+      outputDir: restResourceDir,
+      projectDir: workspace.projectDir,
+      typesFile: `src/rest/${restResourceSlug}/api-types.ts`,
+      validatorsFile: `src/rest/${restResourceSlug}/api-validators.ts`,
+      variables: {
+        auth: resolvedAuth,
+        ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
+        method: resolvedMethod,
+        namespace,
+        pascalCase,
+        pathPattern: resolvedPathPattern,
+        queryTypeName: resolvedQueryTypeName,
+        responseTypeName: resolvedResponseTypeName,
+        slugKebabCase: restResourceSlug,
+        title: toTitleCase(restResourceSlug)
+      }
+    });
+    await appendWorkspaceInventoryEntries(workspace.projectDir, {
+      restResourceEntries: [
+        buildManualRestContractConfigEntry({
+          auth: resolvedAuth,
+          ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
+          ...resolvedControllerClass ? { controllerClass: resolvedControllerClass } : {},
+          ...resolvedControllerExtends ? { controllerExtends: resolvedControllerExtends } : {},
+          method: resolvedMethod,
+          namespace,
+          pathPattern: resolvedPathPattern,
+          ...resolvedPermissionCallback ? { permissionCallback: resolvedPermissionCallback } : {},
+          queryTypeName: resolvedQueryTypeName,
+          responseTypeName: resolvedResponseTypeName,
+          restResourceSlug,
+          ...resolvedSecretFieldName ? { secretFieldName: resolvedSecretFieldName } : {},
+          ...resolvedSecretPreserveOnEmpty !== undefined ? { secretPreserveOnEmpty: resolvedSecretPreserveOnEmpty } : {},
+          ...resolvedSecretStateFieldName ? { secretStateFieldName: resolvedSecretStateFieldName } : {}
+        })
+      ],
+      transformSource: ensureBlockConfigCanAddRestManifests
+    });
+    return {
+      auth: resolvedAuth,
+      ...resolvedBodyTypeName ? { bodyTypeName: resolvedBodyTypeName } : {},
+      ...resolvedControllerClass ? { controllerClass: resolvedControllerClass } : {},
+      ...resolvedControllerExtends ? { controllerExtends: resolvedControllerExtends } : {},
+      method: resolvedMethod,
+      methods: [],
+      mode: "manual",
+      namespace,
+      pathPattern: resolvedPathPattern,
+      ...resolvedPermissionCallback ? { permissionCallback: resolvedPermissionCallback } : {},
+      projectDir: workspace.projectDir,
+      queryTypeName: resolvedQueryTypeName,
+      restResourceSlug,
+      responseTypeName: resolvedResponseTypeName,
+      ...resolvedSecretFieldName ? { secretFieldName: resolvedSecretFieldName } : {},
+      ...resolvedSecretPreserveOnEmpty !== undefined ? { secretPreserveOnEmpty: resolvedSecretPreserveOnEmpty } : {},
+      ...resolvedSecretStateFieldName ? { secretStateFieldName: resolvedSecretStateFieldName } : {}
+    };
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw error;
+  }
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
+async function runAddRestResourceCommand({
+  auth,
+  bodyTypeName,
+  controllerClass,
+  controllerExtends,
+  cwd = process.cwd(),
+  manual,
+  method,
+  methods,
+  namespace,
+  permissionCallback,
+  pathPattern,
+  queryTypeName,
+  restResourceName,
+  responseTypeName,
+  routePattern,
+  secretFieldName,
+  secretHasValueFieldName,
+  secretMaskedResponseFieldName,
+  secretPreserveOnEmpty,
+  secretStateFieldName
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const restResourceSlug = assertValidGeneratedSlug("REST resource name", normalizeBlockSlug(restResourceName), "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>]");
+  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+  assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
+  if (manual) {
+    return scaffoldManualRestContract({
+      auth,
+      bodyTypeName,
+      controllerClass,
+      controllerExtends,
+      method,
+      namespace: resolvedNamespace,
+      pathPattern,
+      permissionCallback,
+      queryTypeName,
+      responseTypeName,
+      restResourceSlug,
+      routePattern,
+      secretFieldName,
+      secretHasValueFieldName,
+      secretMaskedResponseFieldName,
+      secretPreserveOnEmpty,
+      secretStateFieldName,
+      workspace
+    });
+  }
+  return scaffoldGeneratedRestResource({
+    controllerClass,
+    controllerExtends,
+    methods,
+    namespace: resolvedNamespace,
+    permissionCallback,
+    restResourceSlug,
+    routePattern,
+    workspace
+  });
+}
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-contract.ts
 import { promises as fsp7 } from "fs";
 import path11 from "path";
@@ -7189,7 +7202,9 @@ function ${enqueueFunctionName}() {
 }
 async function ensureAbilityPackageScripts(workspace) {
   const packageJsonPath = path14.join(workspace.projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp9.readFile(packageJsonPath, "utf8"));
+  const packageJson = await readJsonFile(packageJsonPath, {
+    context: "workspace package manifest"
+  });
   const nextScripts = {
     ...packageJson.scripts ?? {},
     "sync-abilities": packageJson.scripts?.["sync-abilities"] ?? "tsx scripts/sync-abilities.ts"
@@ -7568,7 +7583,9 @@ async function syncAiFeatureSchemaArtifact({
   projectDir
 }) {
   const sourceSchemaPath = path15.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
-  const responseSchema = assertJsonObject(JSON.parse(await readFile(sourceSchemaPath, "utf8")), sourceSchemaPath);
+  const responseSchema = assertJsonObject(await readJsonFile(sourceSchemaPath, {
+    context: "AI feature response schema"
+  }), sourceSchemaPath);
   const aiSchema = projectWordPressAiSchema(responseSchema);
   await reconcileGeneratedArtifact({
     check,
@@ -7963,7 +7980,23 @@ async function reconcileGeneratedArtifact( options: {
 }
 
 async function loadJsonDocument( filePath: string ) {
-	const decoded = JSON.parse( await readFile( filePath, 'utf8' ) ) as unknown;
+	let source: string;
+	try {
+		source = await readFile( filePath, 'utf8' );
+	} catch ( error ) {
+		throw new Error(
+			\`Failed to read AI schema document at \${ filePath }: \${ error instanceof Error ? error.message : String( error ) }\`
+		);
+	}
+
+	let decoded: unknown;
+	try {
+		decoded = JSON.parse( source ) as unknown;
+	} catch ( error ) {
+		throw new Error(
+			\`Failed to parse AI schema document at \${ filePath }: \${ error instanceof Error ? error.message : String( error ) }\`
+		);
+	}
 	if ( ! decoded || typeof decoded !== 'object' || Array.isArray( decoded ) ) {
 		throw new Error( \`Expected \${ filePath } to decode to a JSON object.\` );
 	}
@@ -8054,7 +8087,9 @@ function ${registerFunctionName}() {
 }
 async function ensureAiFeaturePackageScripts(workspace) {
   const packageJsonPath = path16.join(workspace.projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp10.readFile(packageJsonPath, "utf8"));
+  const packageJson = await readJsonFile(packageJsonPath, {
+    context: "workspace package manifest"
+  });
   const nextScripts = {
     ...packageJson.scripts ?? {},
     "sync-ai": packageJson.scripts?.["sync-ai"] ?? "tsx scripts/sync-ai-features.ts"
@@ -9695,4 +9730,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=DC64DBB36FA16B4964756E2164756E21
+//# debugId=6B83DC9C0043FA6264756E2164756E21