wp-typia 0.23.0 → 0.23.1

package/dist-bunli/{cli-1meywwsy.js → cli-y7w3pybs.js}

@@ -4,7 +4,7 @@ import {
   parseTemplateLocator,
   require_semver,
   validateExplicitCreateTemplateId
-} from "./cli-8reep89s.js";
+} from "./cli-9fx0qgb7.js";
 import {
   getBuiltInSharedTemplateLayerDir,
   getBuiltInTemplateLayerDirs,
@@ -14,10 +14,10 @@ import {
   isOmittableBuiltInTemplateLayerDir,
   resolveBuiltInTemplateSource,
   resolveBuiltInTemplateSourceFromLayerDirs
-} from "./cli-c2acv5dv.js";
+} from "./cli-nvs5atj1.js";
 import {
   getPackageVersions
-} from "./cli-agywa5n6.js";
+} from "./cli-fp16mntv.js";
 import {
   BUILTIN_BLOCK_METADATA_VERSION,
   COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS,
@@ -32,18 +32,20 @@ import {
   getTemplateById,
   isBuiltInTemplateId,
   normalizeTemplateLookupId
-} from "./cli-qse6myha.js";
+} from "./cli-8hxf9qw6.js";
 import {
   seedProjectMigrations
-} from "./cli-9npd9was.js";
+} from "./cli-epsczb1c.js";
 import {
   ensureMigrationDirectories,
   isPlainObject,
   stableJsonStringify,
   writeInitialMigrationScaffold,
   writeMigrationConfig
-} from "./cli-2rqf6t0b.js";
+} from "./cli-e4bwd81c.js";
 import {
+  assertValidGeneratedSlug,
+  assertValidIntegrationEnvService,
   buildBlockCssClassName,
   buildFrontendCssClassName,
   getNodeErrorCode,
@@ -52,20 +54,25 @@ import {
   pathExists,
   readOptionalUtf8File,
   resolveScaffoldIdentifiers,
+  rollbackWorkspaceMutation,
+  snapshotWorkspaceFiles,
   toPascalCase,
   toSegmentPascalCase,
   toSnakeCase,
   toTitleCase,
   validateBlockSlug,
   validateNamespace
-} from "./cli-ts9thts5.js";
+} from "./cli-k5q5v8g6.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
 import {
   CLI_DIAGNOSTIC_CODES,
   createCliDiagnosticCodeError
-} from "./cli-p95wr1q8.js";
+} from "./cli-tq730sqt.js";
+import {
+  resolveWorkspaceProject
+} from "./cli-1170yyve.js";
 import {
   PACKAGE_MANAGER_IDS,
   formatInstallCommand,
@@ -73,7 +80,12 @@ import {
   formatRunScript,
   getPackageManager,
   transformPackageManagerText
-} from "./cli-52ke0ptp.js";
+} from "./cli-am5x7tb4.js";
+import {
+  readJsonFile,
+  readJsonFileSync,
+  safeJsonParse
+} from "./cli-ccax7s0s.js";
 import {
   __toESM
 } from "./cli-xnn9xjcy.js";
@@ -754,7 +766,9 @@ function getDevScript(packageManager, compoundPersistenceEnabled, templateId) {
 }
 async function mutatePackageJson(projectDir, mutate) {
   const packageJsonPath = path2.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp2.readFile(packageJsonPath, "utf8"));
+  const packageJson = await readJsonFile(packageJsonPath, {
+    context: "local dev package manifest"
+  });
   mutate(packageJson);
   await fsp2.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
@@ -2189,7 +2203,9 @@ function readGeneratedPackageJson(projectDir) {
   if (!fs2.existsSync(packageJsonPath)) {
     return null;
   }
-  return JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+  return readJsonFileSync(packageJsonPath, {
+    context: "generated package manifest"
+  });
 }
 function formatNonEmptyTargetDirectoryError(targetDir) {
   return `Target directory is not empty: ${targetDir}. Choose a new project directory, or empty this directory before rerunning the scaffold.`;
@@ -2231,7 +2247,9 @@ function isWorkspaceProject(projectDir) {
 }
 async function applyWorkspaceMigrationCapability(projectDir, packageManager) {
   const packageJsonPath = path4.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp3.readFile(packageJsonPath, "utf8"));
+  const packageJson = await readJsonFile(packageJsonPath, {
+    context: "workspace package manifest"
+  });
   const wpTypiaPackageVersion = getPackageVersions().wpTypiaPackageVersion;
   const canonicalCliSpecifier = wpTypiaPackageVersion === "^0.0.0" ? "wp-typia" : `wp-typia@${wpTypiaPackageVersion.replace(/^[~^]/u, "")}`;
   const migrationCli = (args) => formatPackageExecCommand(packageManager, canonicalCliSpecifier, `migrate ${args}`);
@@ -2288,9 +2306,521 @@ async function withEphemeralScaffoldNodeModules(targetDir, callback) {
   }
 }
 
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-integration-env.ts
+import { promises as fsp4 } from "fs";
+import path5 from "path";
+
+// ../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-integration-env.ts
+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();
+
+// Extend this starter with project-specific generated REST clients or schema
+// checks as the workspace grows. For example, read JSON schemas under
+// src/rest/<resource>/api-schemas or import TS clients through a tsx-powered
+// smoke runner when you need authenticated route coverage.
+
+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,
+  withReleaseZip,
+  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.`,
+    ...withReleaseZip ? [
+      "Run `npm run release:zip` after smoke checks pass to build a distributable plugin zip."
+    ] : []
+  ];
+  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.
+${withReleaseZip ? "- Treat `release:zip:check` as a CI guard before packaging release artifacts.\n" : ""}
+`;
+}
+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 fsp4.mkdir(path5.dirname(filePath), { recursive: true });
+  await fsp4.writeFile(filePath, `${current}${separator}${missingLines.join(`
+`)}
+`, "utf8");
+}
+async function writeFileIfAbsent({
+  filePath,
+  source,
+  warnings
+}) {
+  if (await pathExists(filePath)) {
+    warnings.push(`Preserved existing ${path5.basename(filePath)}; review it manually if you need different local integration settings.`);
+    return;
+  }
+  await fsp4.mkdir(path5.dirname(filePath), { recursive: true });
+  await fsp4.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 fsp4.mkdir(path5.dirname(filePath), { recursive: true });
+  await fsp4.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 mutatePackageJson2(projectDir, mutate) {
+  const packageJsonPath = path5.join(projectDir, "package.json");
+  const packageJson = await readJsonFile(packageJsonPath, {
+    context: "integration env package manifest"
+  });
+  mutate(packageJson);
+  await fsp4.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+`, "utf8");
+}
+function addIntegrationEnvPackageJsonEntries({
+  integrationEnvSlug,
+  packageManager,
+  packageJson,
+  withReleaseZip,
+  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 (withReleaseZip) {
+    addScriptIfMissing({
+      scriptName: "release:zip",
+      scriptValue: `${formatRunScript(packageManager, "sync-rest:package")} && ${formatRunScript(packageManager, "build")} && wp-scripts plugin-zip`,
+      scripts,
+      warnings
+    });
+    addScriptIfMissing({
+      scriptName: "release:zip:check",
+      scriptValue: `${formatRunScript(packageManager, "sync-rest:package:check")} && ${formatRunScript(packageManager, "build")}`,
+      scripts,
+      warnings
+    });
+    addScriptIfMissing({
+      scriptName: "qa:check",
+      scriptValue: `${formatRunScript(packageManager, "wp-typia:doctor:workspace")} && ${formatRunScript(packageManager, "release:zip:check")}`,
+      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,
+  withReleaseZip = false,
+  withWpEnv = false
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const integrationEnvSlug = assertValidGeneratedSlug("Integration environment name", normalizeBlockSlug(integrationEnvName), "wp-typia add integration-env <name> [--wp-env] [--release-zip]");
+  const serviceId = assertValidIntegrationEnvService(service);
+  const warnings = [];
+  const packageJsonPath = path5.join(workspace.projectDir, "package.json");
+  const gitignorePath = path5.join(workspace.projectDir, ".gitignore");
+  const envExamplePath = path5.join(workspace.projectDir, ".env.example");
+  const wpEnvPath = path5.join(workspace.projectDir, ".wp-env.json");
+  const dockerComposePath = path5.join(workspace.projectDir, "docker-compose.integration.yml");
+  const smokeDir = path5.join(workspace.projectDir, "scripts", "integration-smoke");
+  const docsDir = path5.join(workspace.projectDir, "docs", "integration-env");
+  const smokeScriptPath = path5.join(smokeDir, `${integrationEnvSlug}.mjs`);
+  const docsPath = path5.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,
+        withReleaseZip,
+        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 mutatePackageJson2(workspace.projectDir, (packageJson) => addIntegrationEnvPackageJsonEntries({
+        integrationEnvSlug,
+        packageManager: workspace.packageManager,
+        packageJson,
+        service: serviceId,
+        withReleaseZip,
+        warnings,
+        withWpEnv
+      }));
+    }
+  });
+  return {
+    integrationEnvSlug,
+    projectDir: workspace.projectDir,
+    service: serviceId,
+    warnings: warnings.length > 0 ? warnings : undefined,
+    withReleaseZip,
+    withWpEnv
+  };
+}
+
 // ../wp-typia-project-tools/src/runtime/cli-validation.ts
 import fs3 from "fs";
-import path5 from "path";
+import path6 from "path";
 function normalizeOptionalCliString(value) {
   if (typeof value !== "string") {
     return;
@@ -2299,14 +2829,14 @@ function normalizeOptionalCliString(value) {
   return trimmed.length > 0 ? trimmed : undefined;
 }
 function looksLikeLocalCliPath(value) {
-  return path5.isAbsolute(value) || value.startsWith("./") || value.startsWith("../") || value.startsWith(".\\") || value.startsWith("..\\");
+  return path6.isAbsolute(value) || value.startsWith("./") || value.startsWith("../") || value.startsWith(".\\") || value.startsWith("..\\");
 }
 function resolveLocalCliPathOption(options) {
   const normalizedValue = normalizeOptionalCliString(options.value);
   if (!normalizedValue || !looksLikeLocalCliPath(normalizedValue)) {
     return normalizedValue;
   }
-  const resolvedPath = path5.resolve(options.cwd, normalizedValue);
+  const resolvedPath = path6.resolve(options.cwd, normalizedValue);
   if (!fs3.existsSync(resolvedPath)) {
     throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`${options.label}\` path does not exist: ${resolvedPath}. Check the path relative to ${options.cwd}.`);
   }
@@ -2557,35 +3087,37 @@ async function collectScaffoldAnswers({
 }
 
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
-import { promises as fsp12 } from "fs";
-import path17 from "path";
+import { promises as fsp13 } from "fs";
+import path18 from "path";
 
 // ../wp-typia-project-tools/src/runtime/scaffold-apply-utils.ts
-import { promises as fsp6 } from "fs";
-import path9 from "path";
+import { promises as fsp7 } from "fs";
+import path10 from "path";
 import { execSync as execSync3 } from "child_process";
 import { fileURLToPath } from "url";
 
 // ../wp-typia-project-tools/src/runtime/migration-ui-capability.ts
-import { promises as fsp4 } from "fs";
-import path6 from "path";
+import { promises as fsp5 } from "fs";
+import path7 from "path";
 var INITIAL_MIGRATION_VERSION = "v1";
 var BLOCK_METADATA_IMPORT_LINE = "import metadata from './block-metadata';";
 var LEGACY_BLOCK_JSON_IMPORT_LINE = "import metadata from './block.json';";
-async function mutatePackageJson2(projectDir, mutate) {
-  const packageJsonPath = path6.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp4.readFile(packageJsonPath, "utf8"));
+async function mutatePackageJson3(projectDir, mutate) {
+  const packageJsonPath = path7.join(projectDir, "package.json");
+  const packageJson = await readJsonFile(packageJsonPath, {
+    context: "migration UI package manifest"
+  });
   mutate(packageJson);
-  await fsp4.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function patchFile(filePath, transform) {
-  const source = await fsp4.readFile(filePath, "utf8");
+  const source = await fsp5.readFile(filePath, "utf8");
   const nextSource = transform(source);
   if (nextSource === source) {
     throw new Error(`Unable to apply migration UI patch for ${filePath}`);
   }
-  await fsp4.writeFile(filePath, nextSource, "utf8");
+  await fsp5.writeFile(filePath, nextSource, "utf8");
 }
 function injectAfter(source, needle, insertion) {
   if (source.includes(insertion)) {
@@ -2647,8 +3179,8 @@ function buildMigrationBlocks(templateId, variables) {
   ];
 }
 async function applySingleBlockPatches(projectDir, variables) {
-  const editPath = path6.join(projectDir, "src", "edit.tsx");
-  const indexPath = path6.join(projectDir, "src", "index.tsx");
+  const editPath = path7.join(projectDir, "src", "edit.tsx");
+  const indexPath = path7.join(projectDir, "src", "index.tsx");
   const deprecatedImport = `import { deprecated } from './migrations/generated/${variables.slugKebabCase}/deprecated';`;
   const deprecatedLine = "  deprecated,";
   const dashboardImport = `import { MigrationDashboard } from './admin/migration-dashboard';`;
@@ -2669,10 +3201,10 @@ async function applySingleBlockPatches(projectDir, variables) {
   });
 }
 async function applyCompoundPatches(projectDir, variables) {
-  const parentEditPath = path6.join(projectDir, "src", "blocks", variables.slugKebabCase, "edit.tsx");
-  const parentIndexPath = path6.join(projectDir, "src", "blocks", variables.slugKebabCase, "index.tsx");
-  const childIndexPath = path6.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`, "index.tsx");
-  const addChildScriptPath = path6.join(projectDir, "scripts", "add-compound-child.ts");
+  const parentEditPath = path7.join(projectDir, "src", "blocks", variables.slugKebabCase, "edit.tsx");
+  const parentIndexPath = path7.join(projectDir, "src", "blocks", variables.slugKebabCase, "index.tsx");
+  const childIndexPath = path7.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`, "index.tsx");
+  const addChildScriptPath = path7.join(projectDir, "scripts", "add-compound-child.ts");
   await patchFile(parentIndexPath, (source) => {
     let nextSource = injectAfterBlockMetadataImport(source, `import { deprecated } from '../../migrations/generated/${variables.slugKebabCase}/deprecated';`);
     nextSource = injectBefore(nextSource, "\tedit: Edit,", "\tdeprecated,");
@@ -2742,9 +3274,9 @@ async function applyMigrationUiCapability({
   templateId,
   variables
 }) {
-  const commonTemplateDir = path6.join(SHARED_MIGRATION_UI_TEMPLATE_ROOT, "common");
+  const commonTemplateDir = path7.join(SHARED_MIGRATION_UI_TEMPLATE_ROOT, "common");
   await copyInterpolatedDirectory(commonTemplateDir, projectDir, variables);
-  await mutatePackageJson2(projectDir, (packageJson) => {
+  await mutatePackageJson3(projectDir, (packageJson) => {
     const wpTypiaPackageVersion = getPackageVersions().wpTypiaPackageVersion;
     const canonicalCliSpecifier = wpTypiaPackageVersion === "^0.0.0" ? "wp-typia" : `wp-typia@${wpTypiaPackageVersion.replace(/^[~^]/u, "")}`;
     const migrationCli = (args) => formatPackageExecCommand(packageManager, canonicalCliSpecifier, `migrate ${args}`);
@@ -2996,9 +3528,9 @@ function mergeTextLines(primaryContent, existingContent) {
 }
 
 // ../wp-typia-project-tools/src/runtime/scaffold-package-manager-files.ts
-import { promises as fsp5 } from "fs";
+import { promises as fsp6 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import path7 from "path";
+import path8 from "path";
 var LOCKFILES = {
   bun: ["bun.lock", "bun.lockb"],
   npm: ["package-lock.json"],
@@ -3006,22 +3538,25 @@ var LOCKFILES = {
   yarn: ["yarn.lock"]
 };
 async function normalizePackageManagerFiles(targetDir, packageManagerId) {
-  const yarnRcPath = path7.join(targetDir, ".yarnrc.yml");
+  const yarnRcPath = path8.join(targetDir, ".yarnrc.yml");
   if (packageManagerId === "yarn") {
-    await fsp5.writeFile(yarnRcPath, `nodeLinker: node-modules
+    await fsp6.writeFile(yarnRcPath, `nodeLinker: node-modules
 `, "utf8");
     return;
   }
-  await fsp5.rm(yarnRcPath, { force: true });
+  await fsp6.rm(yarnRcPath, { force: true });
 }
 async function normalizePackageJson(targetDir, packageManagerId) {
-  const packageJsonPath = path7.join(targetDir, "package.json");
+  const packageJsonPath = path8.join(targetDir, "package.json");
   const packageJsonSource = await readOptionalUtf8File(packageJsonPath);
   if (packageJsonSource === null) {
     return;
   }
   const packageManager = getPackageManager(packageManagerId);
-  const packageJson = JSON.parse(packageJsonSource);
+  const packageJson = safeJsonParse(packageJsonSource, {
+    context: "generated package manifest",
+    filePath: packageJsonPath
+  });
   if (packageManagerId === "npm") {
     delete packageJson.packageManager;
   } else {
@@ -3034,7 +3569,7 @@ async function normalizePackageJson(targetDir, packageManagerId) {
       }
     }
   }
-  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp6.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
@@ -3044,7 +3579,7 @@ async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
     if (keep.has(filename)) {
       return;
     }
-    await fsp5.rm(path7.join(targetDir, filename), { force: true });
+    await fsp6.rm(path8.join(targetDir, filename), { force: true });
   }));
 }
 async function defaultInstallDependencies({
@@ -3057,14 +3592,15 @@ async function defaultInstallDependencies({
   });
 }
 // ../wp-typia-project-tools/src/runtime/scaffold-repository-reference.ts
-import fs4 from "fs";
 import { createRequire } from "module";
-import path8 from "path";
+import path9 from "path";
 var require2 = createRequire(import.meta.url);
 var DEFAULT_SCAFFOLD_REPOSITORY_REFERENCE = "imjlk/wp-typia";
 function readRepositoryPackageManifest(packageJsonPath) {
   try {
-    return JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
+    return readJsonFileSync(packageJsonPath, {
+      context: "repository package manifest"
+    });
   } catch (error) {
     if (getOptionalNodeErrorCode(error) === "ENOENT") {
       return null;
@@ -3122,9 +3658,9 @@ function parseRepositoryReference(value) {
 }
 function getDefaultRepositoryManifestPaths() {
   const candidatePaths = [
-    path8.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "..", "package.json"),
-    path8.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "wp-typia", "package.json"),
-    path8.join(PROJECT_TOOLS_PACKAGE_ROOT, "package.json"),
+    path9.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "..", "package.json"),
+    path9.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "wp-typia", "package.json"),
+    path9.join(PROJECT_TOOLS_PACKAGE_ROOT, "package.json"),
     resolveInstalledPackageManifestPath("wp-typia"),
     resolveInstalledPackageManifestPath("@wp-typia/project-tools")
   ].filter((candidatePath) => Boolean(candidatePath));
@@ -3151,7 +3687,7 @@ async function reportScaffoldProgress(onProgress, event) {
   await onProgress?.(event);
 }
 var EPHEMERAL_NODE_MODULES_LINK_TYPE2 = process.platform === "win32" ? "junction" : "dir";
-var __dirname2 = path9.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path10.dirname(fileURLToPath(import.meta.url));
 var LOCKFILES2 = {
   bun: ["bun.lock", "bun.lockb"],
   npm: ["package-lock.json"],
@@ -3159,11 +3695,11 @@ var LOCKFILES2 = {
   yarn: ["yarn.lock"]
 };
 async function ensureDirectory(targetDir, allowExisting = false) {
-  await fsp6.mkdir(targetDir, { recursive: true });
+  await fsp7.mkdir(targetDir, { recursive: true });
   if (allowExisting) {
     return;
   }
-  const entries = await fsp6.readdir(targetDir);
+  const entries = await fsp7.readdir(targetDir);
   if (entries.length > 0) {
     throw new Error(formatNonEmptyTargetDirectoryError(targetDir));
   }
@@ -3174,42 +3710,42 @@ async function writeStarterManifestFiles2(targetDir, templateId, variables, arti
     relativePath: `${artifact.relativeDir}/typia.manifest.json`
   })) : getStarterManifestFiles(templateId, variables);
   for (const { document, relativePath } of manifests) {
-    const destinationPath = path9.join(targetDir, relativePath);
-    await fsp6.mkdir(path9.dirname(destinationPath), { recursive: true });
-    await fsp6.writeFile(destinationPath, stringifyStarterManifest(document), "utf8");
+    const destinationPath = path10.join(targetDir, relativePath);
+    await fsp7.mkdir(path10.dirname(destinationPath), { recursive: true });
+    await fsp7.writeFile(destinationPath, stringifyStarterManifest(document), "utf8");
   }
 }
 async function writeBuiltInStructuralArtifacts(targetDir, artifacts) {
   for (const artifact of artifacts) {
-    const destinationDir = path9.join(targetDir, artifact.relativeDir);
-    await fsp6.mkdir(destinationDir, { recursive: true });
-    await fsp6.writeFile(path9.join(destinationDir, "types.ts"), artifact.typesSource, "utf8");
-    await fsp6.writeFile(path9.join(destinationDir, "block.json"), stringifyBuiltInBlockJsonDocument(artifact.blockJsonDocument), "utf8");
+    const destinationDir = path10.join(targetDir, artifact.relativeDir);
+    await fsp7.mkdir(destinationDir, { recursive: true });
+    await fsp7.writeFile(path10.join(destinationDir, "types.ts"), artifact.typesSource, "utf8");
+    await fsp7.writeFile(path10.join(destinationDir, "block.json"), stringifyBuiltInBlockJsonDocument(artifact.blockJsonDocument), "utf8");
   }
 }
 async function writeBuiltInCodeArtifacts(targetDir, codeArtifacts) {
   for (const artifact of codeArtifacts) {
-    const destinationPath = path9.join(targetDir, artifact.relativePath);
-    await fsp6.mkdir(path9.dirname(destinationPath), { recursive: true });
-    await fsp6.writeFile(destinationPath, artifact.source, "utf8");
+    const destinationPath = path10.join(targetDir, artifact.relativePath);
+    await fsp7.mkdir(path10.dirname(destinationPath), { recursive: true });
+    await fsp7.writeFile(destinationPath, artifact.source, "utf8");
   }
 }
 async function resolveScaffoldGeneratorNodeModulesPath2() {
-  const projectToolsPackageRoot = path9.resolve(__dirname2, "..", "..");
+  const projectToolsPackageRoot = path10.resolve(__dirname2, "..", "..");
   const candidates = [
-    path9.join(projectToolsPackageRoot, "node_modules"),
-    path9.resolve(projectToolsPackageRoot, "..", ".."),
-    path9.resolve(projectToolsPackageRoot, "..", "..", "node_modules")
+    path10.join(projectToolsPackageRoot, "node_modules"),
+    path10.resolve(projectToolsPackageRoot, "..", ".."),
+    path10.resolve(projectToolsPackageRoot, "..", "..", "node_modules")
   ];
   for (const candidate of candidates) {
-    if (await pathExists(path9.join(candidate, "typia", "package.json"))) {
+    if (await pathExists(path10.join(candidate, "typia", "package.json"))) {
       return candidate;
     }
   }
   return null;
 }
 async function withEphemeralScaffoldNodeModules2(targetDir, callback) {
-  const targetNodeModulesPath = path9.join(targetDir, "node_modules");
+  const targetNodeModulesPath = path10.join(targetDir, "node_modules");
   if (await pathExists(targetNodeModulesPath)) {
     await callback();
     return;
@@ -3218,11 +3754,11 @@ async function withEphemeralScaffoldNodeModules2(targetDir, callback) {
   if (!sourceNodeModulesPath) {
     throw new Error("Unable to resolve a node_modules directory with typia for scaffold-time REST artifact generation.");
   }
-  await fsp6.symlink(sourceNodeModulesPath, targetNodeModulesPath, EPHEMERAL_NODE_MODULES_LINK_TYPE2);
+  await fsp7.symlink(sourceNodeModulesPath, targetNodeModulesPath, EPHEMERAL_NODE_MODULES_LINK_TYPE2);
   try {
     await callback();
   } finally {
-    await fsp6.rm(targetNodeModulesPath, { force: true, recursive: true });
+    await fsp7.rm(targetNodeModulesPath, { force: true, recursive: true });
   }
 }
 async function seedBuiltInPersistenceArtifacts2(targetDir, templateId, variables) {
@@ -3233,7 +3769,7 @@ async function seedBuiltInPersistenceArtifacts2(targetDir, templateId, variables
   await withEphemeralScaffoldNodeModules2(targetDir, async () => {
     if (templateId === "persistence") {
       await syncPersistenceRestArtifacts({
-        apiTypesFile: path9.join("src", "api-types.ts"),
+        apiTypesFile: path10.join("src", "api-types.ts"),
         outputDir: "src",
         projectDir: targetDir,
         variables
@@ -3241,27 +3777,27 @@ async function seedBuiltInPersistenceArtifacts2(targetDir, templateId, variables
       return;
     }
     await syncPersistenceRestArtifacts({
-      apiTypesFile: path9.join("src", "blocks", variables.slugKebabCase, "api-types.ts"),
-      outputDir: path9.join("src", "blocks", variables.slugKebabCase),
+      apiTypesFile: path10.join("src", "blocks", variables.slugKebabCase, "api-types.ts"),
+      outputDir: path10.join("src", "blocks", variables.slugKebabCase),
       projectDir: targetDir,
       variables
     });
   });
 }
 async function normalizePackageManagerFiles2(targetDir, packageManagerId) {
-  const yarnRcPath = path9.join(targetDir, ".yarnrc.yml");
+  const yarnRcPath = path10.join(targetDir, ".yarnrc.yml");
   if (packageManagerId === "yarn") {
-    await fsp6.writeFile(yarnRcPath, `nodeLinker: node-modules
+    await fsp7.writeFile(yarnRcPath, `nodeLinker: node-modules
 `, "utf8");
     return;
   }
-  await fsp6.rm(yarnRcPath, { force: true });
+  await fsp7.rm(yarnRcPath, { force: true });
 }
 async function removeQueryLoopPlaceholderFiles(projectDir, templateId) {
   if (templateId !== "query-loop") {
     return;
   }
-  await fsp6.rm(path9.join(projectDir, "src", "validator-toolkit.ts"), {
+  await fsp7.rm(path10.join(projectDir, "src", "validator-toolkit.ts"), {
     force: true
   });
 }
@@ -3272,7 +3808,7 @@ async function removeUnexpectedLockfiles2(targetDir, packageManagerId) {
     if (keep.has(filename)) {
       return;
     }
-    await fsp6.rm(path9.join(targetDir, filename), { force: true });
+    await fsp7.rm(path10.join(targetDir, filename), { force: true });
   }));
 }
 async function replaceTextRecursively(targetDir, packageManagerId, {
@@ -3295,21 +3831,21 @@ async function replaceTextRecursively(targetDir, packageManagerId, {
     manifestPaths: repositoryManifestPaths
   });
   async function visit(currentPath) {
-    const stats = await fsp6.stat(currentPath);
+    const stats = await fsp7.stat(currentPath);
     if (stats.isDirectory()) {
-      const entries = await fsp6.readdir(currentPath);
+      const entries = await fsp7.readdir(currentPath);
       for (const entry of entries) {
-        await visit(path9.join(currentPath, entry));
+        await visit(path10.join(currentPath, entry));
       }
       return;
     }
-    if (path9.basename(currentPath) === "package.json" || !textExtensions.has(path9.extname(currentPath))) {
+    if (path10.basename(currentPath) === "package.json" || !textExtensions.has(path10.extname(currentPath))) {
       return;
     }
-    const content = await fsp6.readFile(currentPath, "utf8");
+    const content = await fsp7.readFile(currentPath, "utf8");
     const nextContent = replaceRepositoryReferencePlaceholders(transformPackageManagerText(content, packageManagerId), resolvedRepositoryReference);
     if (nextContent !== content) {
-      await fsp6.writeFile(currentPath, nextContent, "utf8");
+      await fsp7.writeFile(currentPath, nextContent, "utf8");
     }
   }
   await visit(targetDir);
@@ -3381,17 +3917,17 @@ async function applyBuiltInScaffoldProjectFiles({
     phase: "finalize-project",
     title: "Finalizing scaffold output"
   });
-  const readmePath = path9.join(projectDir, "README.md");
+  const readmePath = path10.join(projectDir, "README.md");
   if (!await pathExists(readmePath)) {
-    await fsp6.writeFile(readmePath, readmeContent ?? buildReadme(templateId, variables, packageManager, {
+    await fsp7.writeFile(readmePath, readmeContent ?? buildReadme(templateId, variables, packageManager, {
       withMigrationUi,
       withTestPreset,
       withWpEnv
     }), "utf8");
   }
-  const gitignorePath = path9.join(projectDir, ".gitignore");
+  const gitignorePath = path10.join(projectDir, ".gitignore");
   const existingGitignore = await readOptionalUtf8File(gitignorePath) ?? "";
-  await fsp6.writeFile(gitignorePath, mergeTextLines(gitignoreContent ?? buildGitignore(), existingGitignore), "utf8");
+  await fsp7.writeFile(gitignorePath, mergeTextLines(gitignoreContent ?? buildGitignore(), existingGitignore), "utf8");
   await normalizePackageJson(projectDir, packageManager);
   await applyGeneratedProjectDxPackageJson({
     compoundPersistenceEnabled: isCompoundPersistenceEnabled(variables),
@@ -3422,31 +3958,31 @@ async function applyBuiltInScaffoldProjectFiles({
 }
 
 // ../wp-typia-project-tools/src/runtime/template-source-normalization.ts
-import path13 from "path";
+import path14 from "path";
 
 // ../wp-typia-project-tools/src/runtime/template-layers.ts
-import path10 from "path";
-import { promises as fsp7 } from "fs";
+import path11 from "path";
+import { promises as fsp8 } from "fs";
 var TEMPLATE_LAYER_MANIFEST_FILENAME = "wp-typia.layers.json";
 var TEMPLATE_LAYER_MANIFEST_VERSION = 1;
 function resolveLayerPath(sourceRoot, relativePath) {
-  const targetPath = path10.resolve(sourceRoot, relativePath);
-  const relativeTarget = path10.relative(sourceRoot, targetPath);
-  if (relativeTarget.startsWith("..") || path10.isAbsolute(relativeTarget)) {
+  const targetPath = path11.resolve(sourceRoot, relativePath);
+  const relativeTarget = path11.relative(sourceRoot, targetPath);
+  if (relativeTarget.startsWith("..") || path11.isAbsolute(relativeTarget)) {
     throw new Error(`Template layer path "${relativePath}" must stay within ${sourceRoot}.`);
   }
   return targetPath;
 }
 async function assertNoSymlinks(sourceDir) {
-  const stats = await fsp7.lstat(sourceDir);
+  const stats = await fsp8.lstat(sourceDir);
   if (stats.isSymbolicLink()) {
     throw new Error(`Template layer packages may not include symbolic links: ${sourceDir}`);
   }
   if (!stats.isDirectory()) {
     return;
   }
-  for (const entry of await fsp7.readdir(sourceDir)) {
-    await assertNoSymlinks(path10.join(sourceDir, entry));
+  for (const entry of await fsp8.readdir(sourceDir)) {
+    await assertNoSymlinks(path11.join(sourceDir, entry));
   }
 }
 function parseLayerDefinition(layerId, value) {
@@ -3475,11 +4011,13 @@ function parseLayerDefinition(layerId, value) {
   };
 }
 async function loadExternalTemplateLayerManifest(sourceRoot) {
-  const manifestPath = path10.join(sourceRoot, TEMPLATE_LAYER_MANIFEST_FILENAME);
+  const manifestPath = path11.join(sourceRoot, TEMPLATE_LAYER_MANIFEST_FILENAME);
   if (!await pathExists(manifestPath)) {
     return null;
   }
-  const raw = JSON.parse(await fsp7.readFile(manifestPath, "utf8"));
+  const raw = await readJsonFile(manifestPath, {
+    context: "template layer manifest"
+  });
   if (!isPlainObject(raw)) {
     throw new Error(`${TEMPLATE_LAYER_MANIFEST_FILENAME} must export a JSON object.`);
   }
@@ -3573,7 +4111,7 @@ async function resolveExternalTemplateLayers({
       return;
     }
     const layerDir = resolveLayerPath(sourceRoot, definition.path);
-    const stats = await fsp7.stat(layerDir).catch(() => null);
+    const stats = await fsp8.stat(layerDir).catch(() => null);
     if (!stats || !stats.isDirectory()) {
       throw new Error(`Layer "${layerId}" points to a missing directory: ${definition.path}`);
     }
@@ -3611,12 +4149,12 @@ async function assertExternalTemplateLayersDoNotWriteProtectedOutputs({
 }
 
 // ../wp-typia-project-tools/src/runtime/template-source-external.ts
-import { promises as fsp8 } from "fs";
-import path11 from "path";
+import { promises as fsp9 } from "fs";
+import path12 from "path";
 import { pathToFileURL } from "url";
 
 // ../wp-typia-project-tools/src/runtime/external-template-guards.ts
-import fs5 from "fs";
+import fs4 from "fs";
 var TEMPLATE_SOURCE_TIMEOUT_CODE = "template-source-timeout";
 var TEMPLATE_SOURCE_TOO_LARGE_CODE = "template-source-too-large";
 var DEFAULT_EXTERNAL_TEMPLATE_TIMEOUT_MS = 20000;
@@ -3658,7 +4196,7 @@ function createExternalTemplateTooLargeError(label, maxBytes) {
   return createTemplateGuardError(TEMPLATE_SOURCE_TOO_LARGE_CODE, `${label} exceeded the external template size limit (${maxBytes} bytes).`);
 }
 function assertExternalTemplateFileSize(filePath, options) {
-  const stats = fs5.statSync(filePath);
+  const stats = fs4.statSync(filePath);
   if (stats.size > options.maxBytes) {
     throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
   }
@@ -3734,11 +4272,9 @@ async function readResponseBodyWithLimit(response, options) {
 }
 async function readJsonResponseWithLimit(response, options) {
   const buffer = await readResponseBodyWithLimit(response, options);
-  try {
-    return JSON.parse(buffer.toString("utf8"));
-  } catch (error) {
-    throw new Error(`Failed to parse ${options.label}: ${error instanceof Error ? error.message : String(error)}`);
-  }
+  return safeJsonParse(buffer.toString("utf8"), {
+    context: options.label
+  });
 }
 async function readBufferResponseWithLimit(response, options) {
   return readResponseBodyWithLimit(response, options);
@@ -3756,16 +4292,16 @@ function getTemplateWarning(key) {
   return `Ignoring external template config key "${key}": ${TEMPLATE_WARNING_MESSAGE}`;
 }
 function resolveSourceSubpath(sourceDir, relativePath) {
-  const targetPath = path11.resolve(sourceDir, relativePath);
-  const relativeTarget = path11.relative(sourceDir, targetPath);
-  if (relativeTarget.startsWith("..") || path11.isAbsolute(relativeTarget)) {
+  const targetPath = path12.resolve(sourceDir, relativePath);
+  const relativeTarget = path12.relative(sourceDir, targetPath);
+  if (relativeTarget.startsWith("..") || path12.isAbsolute(relativeTarget)) {
     throw new Error(`Template path "${relativePath}" must stay within ${sourceDir}.`);
   }
   return targetPath;
 }
 async function findExternalTemplateEntry(sourceDir) {
   for (const filename of EXTERNAL_TEMPLATE_ENTRY_CANDIDATES) {
-    const candidate = path11.join(sourceDir, filename);
+    const candidate = path12.join(sourceDir, filename);
     if (await pathExists(candidate)) {
       return candidate;
     }
@@ -3781,7 +4317,7 @@ async function loadExternalTemplateConfig(sourceDir) {
     label: `External template config "${entryPath}"`,
     maxBytes: getExternalTemplateConfigMaxBytes()
   });
-  const entryStats = await fsp8.stat(entryPath);
+  const entryStats = await fsp9.stat(entryPath);
   const moduleUrl = `${pathToFileURL(entryPath).href}?mtime=${entryStats.mtimeMs}`;
   const loadedModule = await withExternalTemplateTimeout(`loading external template config "${entryPath}"`, () => import(moduleUrl));
   const loadedConfig = loadedModule.default ?? loadedModule;
@@ -3888,21 +4424,21 @@ async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVa
   const { folderName, formatHint, templatePath } = resolveConfiguredTemplatePath(config, variantConfig);
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-create-block-external-");
   try {
-    const renderedRoot = path11.join(tempRoot, "rendered");
+    const renderedRoot = path12.join(tempRoot, "rendered");
     const blockDir = resolveSourceSubpath(renderedRoot, folderName);
     const view = await buildExternalTemplateView(context, config, selectedVariant, variantConfig);
     const blockTemplateDir = resolveSourceSubpath(sourceDir, templatePath);
     await copyRenderedDirectory(blockTemplateDir, blockDir, view, {
       filter: async (sourcePath, _destinationPath, entry) => {
-        const mustacheVariantPath = path11.join(path11.dirname(sourcePath), `${entry.name}.mustache`);
+        const mustacheVariantPath = path12.join(path12.dirname(sourcePath), `${entry.name}.mustache`);
         return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && await pathExists(mustacheVariantPath));
       }
     });
     const assetsPath = typeof variantConfig.assetsPath === "string" ? variantConfig.assetsPath : config.assetsPath;
     if (typeof assetsPath === "string" && assetsPath.trim().length > 0) {
-      await copyRawDirectory(resolveSourceSubpath(sourceDir, assetsPath), path11.join(tempRoot, "assets"));
+      await copyRawDirectory(resolveSourceSubpath(sourceDir, assetsPath), path12.join(tempRoot, "assets"));
     }
-    const assetsDir = path11.join(tempRoot, "assets");
+    const assetsDir = path12.join(tempRoot, "assets");
     return {
       assetsDir: await pathExists(assetsDir) ? assetsDir : undefined,
       blockDir,
@@ -3919,8 +4455,8 @@ async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVa
 }
 
 // ../wp-typia-project-tools/src/runtime/template-source-remote.ts
-import { promises as fsp9 } from "fs";
-import path12 from "path";
+import { promises as fsp10 } from "fs";
+import path13 from "path";
 async function cleanupSeedRootPair(cleanup, seedCleanup) {
   let cleanupError;
   try {
@@ -3943,11 +4479,13 @@ function getDefaultCategoryFromBlockJson(blockJson) {
 async function readRemoteBlockJsonAsync(blockDir) {
   const sourceRoot = await getSeedSourceRoot(blockDir);
   for (const candidate of [
-    path12.join(blockDir, "block.json"),
-    path12.join(sourceRoot, "block.json")
+    path13.join(blockDir, "block.json"),
+    path13.join(sourceRoot, "block.json")
   ]) {
     if (await pathExists(candidate)) {
-      return JSON.parse(await fsp9.readFile(candidate, "utf8"));
+      return readJsonFile(candidate, {
+        context: "remote block metadata"
+      });
     }
   }
   throw new Error(`Unable to locate block.json in ${blockDir}`);
@@ -3962,8 +4500,8 @@ async function getDefaultCategoryAsync(sourceDir) {
 }
 async function readTemplatePackageJsonAsync(sourceDir) {
   for (const candidate of [
-    path12.join(sourceDir, "package.json.mustache"),
-    path12.join(sourceDir, "package.json")
+    path13.join(sourceDir, "package.json.mustache"),
+    path13.join(sourceDir, "package.json")
   ]) {
     if (!await pathExists(candidate)) {
       continue;
@@ -3974,7 +4512,10 @@ async function readTemplatePackageJsonAsync(sourceDir) {
         maxBytes: getExternalTemplatePackageJsonMaxBytes()
       });
       return {
-        packageJson: JSON.parse(await fsp9.readFile(candidate, "utf8")),
+        packageJson: safeJsonParse(await fsp10.readFile(candidate, "utf8"), {
+          context: "template metadata file",
+          filePath: candidate
+        }),
         sourcePath: candidate
       };
     } catch (error) {
@@ -4000,16 +4541,16 @@ async function getTemplateProjectTypeAsync(sourceDir) {
 }
 async function normalizeWpTypiaTemplateSeed(seed) {
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
-  const normalizedDir = path12.join(tempRoot, "template");
+  const normalizedDir = path13.join(tempRoot, "template");
   try {
     await copyRawDirectory(seed.blockDir, normalizedDir, {
       filter: async (sourcePath, _targetPath, entry) => {
-        const mustacheVariantPath = path12.join(path12.dirname(sourcePath), `${entry.name}.mustache`);
+        const mustacheVariantPath = path13.join(path13.dirname(sourcePath), `${entry.name}.mustache`);
         return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && await pathExists(mustacheVariantPath));
       }
     });
     if (seed.assetsDir && await pathExists(seed.assetsDir)) {
-      await fsp9.cp(seed.assetsDir, path12.join(normalizedDir, "assets"), {
+      await fsp10.cp(seed.assetsDir, path13.join(normalizedDir, "assets"), {
         recursive: true,
         force: true
       });
@@ -4098,32 +4639,34 @@ function buildRemoteBlockJsonTemplate(blockJson) {
 }
 async function rewriteBlockJsonImports(directory) {
   const textExtensions = new Set([".js", ".jsx", ".ts", ".tsx"]);
-  const targetBlockJsonPath = path12.join(directory, "block.json");
+  const targetBlockJsonPath = path13.join(directory, "block.json");
   async function visit(currentPath) {
-    const stats = await fsp9.stat(currentPath);
+    const stats = await fsp10.stat(currentPath);
     if (stats.isDirectory()) {
-      const entries = await fsp9.readdir(currentPath);
+      const entries = await fsp10.readdir(currentPath);
       for (const entry of entries) {
-        await visit(path12.join(currentPath, entry));
+        await visit(path13.join(currentPath, entry));
       }
       return;
     }
-    if (!textExtensions.has(path12.extname(currentPath))) {
+    if (!textExtensions.has(path13.extname(currentPath))) {
       return;
     }
-    const content = await fsp9.readFile(currentPath, "utf8");
-    const relativeSpecifier = path12.relative(path12.dirname(currentPath), targetBlockJsonPath).replace(/\\/g, "/");
+    const content = await fsp10.readFile(currentPath, "utf8");
+    const relativeSpecifier = path13.relative(path13.dirname(currentPath), targetBlockJsonPath).replace(/\\/g, "/");
     const normalizedSpecifier = relativeSpecifier.startsWith(".") ? relativeSpecifier : `./${relativeSpecifier}`;
     const next = content.replace(/(['"])\.{1,2}\/[^'"]*block\.json\1/g, `$1${normalizedSpecifier}$1`);
     if (next !== content) {
-      await fsp9.writeFile(currentPath, next, "utf8");
+      await fsp10.writeFile(currentPath, next, "utf8");
     }
   }
   await visit(directory);
 }
 async function patchRemotePackageJson(templateDir, needsInteractivity) {
-  const packageJsonPath = path12.join(templateDir, "package.json.mustache");
-  const packageJson = JSON.parse(await fsp9.readFile(packageJsonPath, "utf8"));
+  const packageJsonPath = path13.join(templateDir, "package.json.mustache");
+  const packageJson = await readJsonFile(packageJsonPath, {
+    context: "remote package template manifest"
+  });
   const existingDependencies = { ...packageJson.dependencies ?? {} };
   const existingDevDependencies = { ...packageJson.devDependencies ?? {} };
   delete existingDependencies["@wp-typia/project-tools"];
@@ -4143,16 +4686,16 @@ async function patchRemotePackageJson(templateDir, needsInteractivity) {
   } else {
     delete packageJson.dependencies;
   }
-  await fsp9.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  await fsp10.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `, "utf8");
 }
 async function getSeedSourceRoot(blockDir) {
-  return await pathExists(path12.join(blockDir, "src")) ? path12.join(blockDir, "src") : blockDir;
+  return await pathExists(path13.join(blockDir, "src")) ? path13.join(blockDir, "src") : blockDir;
 }
 async function findSeedRenderPhp(seed) {
   for (const candidate of [
-    path12.join(seed.blockDir, "render.php"),
-    path12.join(seed.rootDir, "render.php")
+    path13.join(seed.blockDir, "render.php"),
+    path13.join(seed.rootDir, "render.php")
   ]) {
     if (await pathExists(candidate)) {
       return candidate;
@@ -4193,16 +4736,16 @@ async function removeSeedEntryConflicts(templateDir) {
     "view.ts",
     "view.tsx"
   ]) {
-    await fsp9.rm(path12.join(templateDir, "src", filename), { force: true });
+    await fsp10.rm(path13.join(templateDir, "src", filename), { force: true });
   }
 }
 async function normalizeCreateBlockSubset(seed, context) {
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-remote-template-");
   try {
-    const templateDir = path12.join(tempRoot, "template");
+    const templateDir = path13.join(tempRoot, "template");
     const blockJson = await readRemoteBlockJsonAsync(seed.blockDir);
     const sourceRoot = await getSeedSourceRoot(seed.blockDir);
-    await fsp9.mkdir(templateDir, { recursive: true });
+    await fsp10.mkdir(templateDir, { recursive: true });
     for (const layerDir of getBuiltInTemplateLayerDirs("basic")) {
       if (!await pathExists(layerDir)) {
         if (isOmittableBuiltInTemplateLayerDir("basic", layerDir)) {
@@ -4210,29 +4753,29 @@ async function normalizeCreateBlockSubset(seed, context) {
         }
         throw new Error(`Built-in template layer is missing: ${layerDir}`);
       }
-      await fsp9.cp(layerDir, templateDir, {
+      await fsp10.cp(layerDir, templateDir, {
         recursive: true,
         force: true
       });
     }
     await removeSeedEntryConflicts(templateDir);
-    await fsp9.cp(sourceRoot, path12.join(templateDir, "src"), {
+    await fsp10.cp(sourceRoot, path13.join(templateDir, "src"), {
       recursive: true,
       force: true
     });
     const remoteRenderPath = await findSeedRenderPhp(seed);
     if (remoteRenderPath) {
-      await fsp9.copyFile(remoteRenderPath, path12.join(templateDir, "render.php"));
+      await fsp10.copyFile(remoteRenderPath, path13.join(templateDir, "render.php"));
     }
     if (seed.assetsDir && await pathExists(seed.assetsDir)) {
-      await fsp9.cp(seed.assetsDir, path12.join(templateDir, "assets"), {
+      await fsp10.cp(seed.assetsDir, path13.join(templateDir, "assets"), {
         recursive: true,
         force: true
       });
     }
-    await fsp9.writeFile(path12.join(templateDir, "src", "types.ts"), buildRemoteTypesSource(blockJson, context), "utf8");
-    await fsp9.writeFile(path12.join(templateDir, "src", "block.json"), buildRemoteBlockJsonTemplate(blockJson), "utf8");
-    await rewriteBlockJsonImports(path12.join(templateDir, "src"));
+    await fsp10.writeFile(path13.join(templateDir, "src", "types.ts"), buildRemoteTypesSource(blockJson, context), "utf8");
+    await fsp10.writeFile(path13.join(templateDir, "src", "block.json"), buildRemoteBlockJsonTemplate(blockJson), "utf8");
+    await rewriteBlockJsonImports(path13.join(templateDir, "src"));
     const needsInteractivity = typeof blockJson.viewScriptModule === "string" || typeof blockJson.viewScript === "string" || (await Promise.all([
       "view.js",
       "view.jsx",
@@ -4240,7 +4783,7 @@ async function normalizeCreateBlockSubset(seed, context) {
       "view.tsx",
       "interactivity.js",
       "interactivity.ts"
-    ].map((filename) => pathExists(path12.join(templateDir, "src", filename))))).some(Boolean);
+    ].map((filename) => pathExists(path13.join(templateDir, "src", filename))))).some(Boolean);
     await patchRemotePackageJson(templateDir, needsInteractivity);
     return {
       id: "remote:create-block-subset",
@@ -4270,7 +4813,8 @@ function getTemplateVariableContext(variables) {
     blockRuntimePackageVersion,
     blockTypesPackageVersion,
     projectToolsPackageVersion,
-    restPackageVersion
+    restPackageVersion,
+    wpTypiaPackageVersion
   } = getPackageVersions();
   return {
     ...variables,
@@ -4278,6 +4822,7 @@ function getTemplateVariableContext(variables) {
     blockRuntimePackageVersion: variables.blockRuntimePackageVersion ?? blockRuntimePackageVersion,
     blockTypesPackageVersion: variables.blockTypesPackageVersion ?? blockTypesPackageVersion,
     projectToolsPackageVersion: variables.projectToolsPackageVersion ?? projectToolsPackageVersion,
+    wpTypiaPackageVersion: variables.wpTypiaPackageVersion ?? wpTypiaPackageVersion,
     description: variables.description,
     keyword: variables.keyword,
     namespace: variables.namespace,
@@ -4290,7 +4835,7 @@ function getTemplateVariableContext(variables) {
   };
 }
 async function detectTemplateSourceFormat(sourceDir) {
-  if (await pathExists(path13.join(sourceDir, "package.json.mustache"))) {
+  if (await pathExists(path14.join(sourceDir, "package.json.mustache"))) {
     return "wp-typia";
   }
   if (await loadExternalTemplateLayerManifest(sourceDir)) {
@@ -4302,15 +4847,15 @@ async function detectTemplateSourceFormat(sourceDir) {
   if (await getTemplateProjectTypeAsync(sourceDir) !== null) {
     return "wp-typia";
   }
-  const sourceRoot = await pathExists(path13.join(sourceDir, "src")) ? path13.join(sourceDir, "src") : sourceDir;
+  const sourceRoot = await pathExists(path14.join(sourceDir, "src")) ? path14.join(sourceDir, "src") : sourceDir;
   const blockJsonCandidates = [
-    path13.join(sourceDir, "block.json"),
-    path13.join(sourceRoot, "block.json")
+    path14.join(sourceDir, "block.json"),
+    path14.join(sourceRoot, "block.json")
   ];
   const hasBlockJson = (await Promise.all(blockJsonCandidates.map((candidate) => pathExists(candidate)))).some(Boolean);
-  const hasIndexFile = (await Promise.all(["index.js", "index.jsx", "index.ts", "index.tsx"].map((filename) => pathExists(path13.join(sourceRoot, filename))))).some(Boolean);
-  const hasEditFile = (await Promise.all(["edit.js", "edit.jsx", "edit.ts", "edit.tsx"].map((filename) => pathExists(path13.join(sourceRoot, filename))))).some(Boolean);
-  const hasSaveFile = (await Promise.all(["save.js", "save.jsx", "save.ts", "save.tsx"].map((filename) => pathExists(path13.join(sourceRoot, filename))))).some(Boolean);
+  const hasIndexFile = (await Promise.all(["index.js", "index.jsx", "index.ts", "index.tsx"].map((filename) => pathExists(path14.join(sourceRoot, filename))))).some(Boolean);
+  const hasEditFile = (await Promise.all(["edit.js", "edit.jsx", "edit.ts", "edit.tsx"].map((filename) => pathExists(path14.join(sourceRoot, filename))))).some(Boolean);
+  const hasSaveFile = (await Promise.all(["save.js", "save.jsx", "save.ts", "save.tsx"].map((filename) => pathExists(path14.join(sourceRoot, filename))))).some(Boolean);
   if (hasBlockJson && hasIndexFile && hasEditFile && hasSaveFile) {
     return "create-block-subset";
   }
@@ -4319,10 +4864,10 @@ async function detectTemplateSourceFormat(sourceDir) {
 
 // ../wp-typia-project-tools/src/runtime/template-source-seeds.ts
 var import_semver = __toESM(require_semver(), 1);
-import fs7 from "fs";
-import { promises as fsp11 } from "fs";
+import fs6 from "fs";
+import { promises as fsp12 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import path16 from "path";
+import path17 from "path";
 import { spawnSync } from "child_process";
 
 // ../../node_modules/.bun/tar@7.5.13/node_modules/tar/dist/esm/index.min.js
@@ -6595,7 +7140,7 @@ var Vn = 512 * 1024;
 var $n = pr | ur | dr | mr;
 var lr = !fr && typeof ar == "number" ? ar | ur | dr | mr : null;
 var cs = lr !== null ? () => lr : Kn ? (s3) => s3 < Vn ? $n : "w" : () => "w";
-var fs6 = (s3, t, e) => {
+var fs5 = (s3, t, e) => {
   try {
     return mi.lchownSync(s3, t, e);
   } catch (i) {
@@ -6644,7 +7189,7 @@ var ds = (s3, t, e, i) => {
   });
 };
 var qn = (s3, t, e, i) => {
-  t.isDirectory() && us(Ee.resolve(s3, t.name), e, i), fs6(Ee.resolve(s3, t.name), e, i);
+  t.isDirectory() && us(Ee.resolve(s3, t.name), e, i), fs5(Ee.resolve(s3, t.name), e, i);
 };
 var us = (s3, t, e) => {
   let i;
@@ -6655,12 +7200,12 @@ var us = (s3, t, e) => {
     if (n?.code === "ENOENT")
       return;
     if (n?.code === "ENOTDIR" || n?.code === "ENOTSUP")
-      return fs6(s3, t, e);
+      return fs5(s3, t, e);
     throw n;
   }
   for (let r of i)
     qn(s3, r, t, e);
-  return fs6(s3, t, e);
+  return fs5(s3, t, e);
 };
 var we = class extends Error {
   path;
@@ -7474,8 +8019,8 @@ var So = (s3) => {
 
 // ../wp-typia-project-tools/src/runtime/template-source-cache.ts
 import { createHash, randomUUID } from "crypto";
-import { promises as fsp10 } from "fs";
-import path15 from "path";
+import { promises as fsp11 } from "fs";
+import path16 from "path";
 
 // ../wp-typia-project-tools/src/runtime/template-source-cache-markers.ts
 var CACHE_MARKER_FILE = "wp-typia-template-cache.json";
@@ -7595,7 +8140,7 @@ function formatExternalTemplateCachePruneMarker({
 
 // ../wp-typia-project-tools/src/runtime/template-source-cache-policy.ts
 import os2 from "os";
-import path14 from "path";
+import path15 from "path";
 var EXTERNAL_TEMPLATE_CACHE_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE";
 var EXTERNAL_TEMPLATE_CACHE_DIR_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR";
 var EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_TTL_DAYS";
@@ -7613,9 +8158,9 @@ function isExternalTemplateCacheEnabled(env = process.env) {
 function getExternalTemplateCacheRoot(env = process.env) {
   const configuredCacheDir = env[EXTERNAL_TEMPLATE_CACHE_DIR_ENV]?.trim();
   if (configuredCacheDir) {
-    return path14.resolve(configuredCacheDir);
+    return path15.resolve(configuredCacheDir);
   }
-  return path14.join(os2.tmpdir(), `wp-typia-template-source-cache-${getCurrentUserCacheSegment()}`);
+  return path15.join(os2.tmpdir(), `wp-typia-template-source-cache-${getCurrentUserCacheSegment()}`);
 }
 function parseExternalTemplateCacheTtlDays(value) {
   if (typeof value !== "string" && typeof value !== "number") {
@@ -7693,7 +8238,7 @@ function createExternalTemplateCacheKey(keyParts) {
 }
 async function isDirectoryPath(directory) {
   try {
-    const stats = await fsp10.lstat(directory);
+    const stats = await fsp11.lstat(directory);
     return stats.isDirectory() && !stats.isSymbolicLink();
   } catch {
     return false;
@@ -7701,7 +8246,7 @@ async function isDirectoryPath(directory) {
 }
 async function removeTemporaryCacheEntry(entryDir) {
   try {
-    await fsp10.rm(entryDir, { force: true, recursive: true });
+    await fsp11.rm(entryDir, { force: true, recursive: true });
   } catch {}
 }
 function getCurrentUid() {
@@ -7709,7 +8254,7 @@ function getCurrentUid() {
 }
 async function isPrivateCacheDirectory(directory) {
   try {
-    const stats = await fsp10.lstat(directory);
+    const stats = await fsp11.lstat(directory);
     if (!stats.isDirectory() || stats.isSymbolicLink()) {
       return false;
     }
@@ -7727,11 +8272,11 @@ async function isPrivateCacheDirectory(directory) {
 }
 async function ensurePrivateCacheDirectory(directory) {
   try {
-    await fsp10.mkdir(directory, {
+    await fsp11.mkdir(directory, {
       mode: PRIVATE_CACHE_DIRECTORY_MODE,
       recursive: true
     });
-    const stats = await fsp10.lstat(directory);
+    const stats = await fsp11.lstat(directory);
     if (!stats.isDirectory() || stats.isSymbolicLink()) {
       return false;
     }
@@ -7741,7 +8286,7 @@ async function ensurePrivateCacheDirectory(directory) {
     }
     if (process.platform !== "win32") {
       if ((stats.mode & 63) !== 0) {
-        await fsp10.chmod(directory, PRIVATE_CACHE_DIRECTORY_MODE);
+        await fsp11.chmod(directory, PRIVATE_CACHE_DIRECTORY_MODE);
       }
     }
     return isPrivateCacheDirectory(directory);
@@ -7753,9 +8298,9 @@ function resolveCacheNamespaceDir(cacheRoot, namespace) {
   if (namespace === "." || namespace === ".." || !SAFE_CACHE_NAMESPACE_SEGMENT.test(namespace)) {
     return null;
   }
-  const namespaceDir = path15.join(cacheRoot, namespace);
-  const relativeNamespaceDir = path15.relative(cacheRoot, namespaceDir);
-  if (relativeNamespaceDir.length === 0 || relativeNamespaceDir.startsWith("..") || path15.isAbsolute(relativeNamespaceDir)) {
+  const namespaceDir = path16.join(cacheRoot, namespace);
+  const relativeNamespaceDir = path16.relative(cacheRoot, namespaceDir);
+  if (relativeNamespaceDir.length === 0 || relativeNamespaceDir.startsWith("..") || path16.isAbsolute(relativeNamespaceDir)) {
     return null;
   }
   return namespaceDir;
@@ -7767,14 +8312,14 @@ function getCacheEntryPaths(descriptor) {
   if (!namespaceDir) {
     return null;
   }
-  const entryDir = path15.join(namespaceDir, cacheKey);
+  const entryDir = path16.join(namespaceDir, cacheKey);
   return {
     cacheKey,
     cacheRoot,
     entryDir,
-    markerPath: path15.join(entryDir, CACHE_MARKER_FILE),
+    markerPath: path16.join(entryDir, CACHE_MARKER_FILE),
     namespaceDir,
-    sourceDir: path15.join(entryDir, "source")
+    sourceDir: path16.join(entryDir, "source")
   };
 }
 async function isReusableCacheEntry(entryDir, markerPath, sourceDir) {
@@ -7782,7 +8327,7 @@ async function isReusableCacheEntry(entryDir, markerPath, sourceDir) {
 }
 async function readCacheEntryMarker(markerPath) {
   try {
-    return parseExternalTemplateCacheEntryMarker(await fsp10.readFile(markerPath, "utf8"));
+    return parseExternalTemplateCacheEntryMarker(await fsp11.readFile(markerPath, "utf8"));
   } catch {
     return null;
   }
@@ -7798,22 +8343,22 @@ async function isReusableFreshCacheEntry(entryDir, markerPath, sourceDir, nowMs,
   return marker !== null && isExternalTemplateCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs);
 }
 function isPathInsideDirectory(directory, candidatePath) {
-  const relativePath = path15.relative(directory, candidatePath);
-  return relativePath.length > 0 && !relativePath.startsWith("..") && !path15.isAbsolute(relativePath);
+  const relativePath = path16.relative(directory, candidatePath);
+  return relativePath.length > 0 && !relativePath.startsWith("..") && !path16.isAbsolute(relativePath);
 }
 async function removeCacheEntryWithinRoot(cacheRoot, entryDir) {
   if (!isPathInsideDirectory(cacheRoot, entryDir)) {
     return false;
   }
   try {
-    await fsp10.rm(entryDir, { force: true, recursive: true });
+    await fsp11.rm(entryDir, { force: true, recursive: true });
     return true;
   } catch {
     return false;
   }
 }
 function getCachePruneMarkerPath(cacheRoot) {
-  return path15.join(cacheRoot, CACHE_PRUNE_MARKER_FILE);
+  return path16.join(cacheRoot, CACHE_PRUNE_MARKER_FILE);
 }
 async function shouldSkipExternalTemplateCachePrune({
   cacheRoot,
@@ -7827,7 +8372,7 @@ async function shouldSkipExternalTemplateCachePrune({
   }
   let markerText;
   try {
-    markerText = await fsp10.readFile(getCachePruneMarkerPath(cacheRoot), "utf8");
+    markerText = await fsp11.readFile(getCachePruneMarkerPath(cacheRoot), "utf8");
   } catch {
     return false;
   }
@@ -7845,7 +8390,7 @@ async function writeExternalTemplateCachePruneMarker({
   ttlMs
 }) {
   try {
-    await fsp10.writeFile(getCachePruneMarkerPath(cacheRoot), formatExternalTemplateCachePruneMarker({
+    await fsp11.writeFile(getCachePruneMarkerPath(cacheRoot), formatExternalTemplateCachePruneMarker({
       nowMs,
       pruneIntervalMs,
       ttlMs
@@ -7887,7 +8432,7 @@ async function pruneExternalTemplateCache(options = {}) {
   }
   let namespaceEntries;
   try {
-    namespaceEntries = await fsp10.readdir(cacheRoot, { withFileTypes: true });
+    namespaceEntries = await fsp11.readdir(cacheRoot, { withFileTypes: true });
   } catch {
     return result;
   }
@@ -7903,7 +8448,7 @@ async function pruneExternalTemplateCache(options = {}) {
     }
     let cacheEntries;
     try {
-      cacheEntries = await fsp10.readdir(namespaceDir, { withFileTypes: true });
+      cacheEntries = await fsp11.readdir(namespaceDir, { withFileTypes: true });
     } catch {
       result.skippedEntries += 1;
       continue;
@@ -7916,14 +8461,14 @@ async function pruneExternalTemplateCache(options = {}) {
         result.skippedEntries += 1;
         continue;
       }
-      const entryDir = path15.join(namespaceDir, cacheEntry.name);
+      const entryDir = path16.join(namespaceDir, cacheEntry.name);
       result.scannedEntries += 1;
       if (!isPathInsideDirectory(cacheRoot, entryDir)) {
         result.skippedEntries += 1;
         continue;
       }
-      const markerPath = path15.join(entryDir, CACHE_MARKER_FILE);
-      const sourceDir = path15.join(entryDir, "source");
+      const markerPath = path16.join(entryDir, CACHE_MARKER_FILE);
+      const sourceDir = path16.join(entryDir, "source");
       const marker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
       if (!marker) {
         result.skippedEntries += 1;
@@ -7963,7 +8508,7 @@ async function findReusableExternalTemplateSourceCache(descriptor) {
   await pruneExternalTemplateCache();
   let entries;
   try {
-    entries = await fsp10.readdir(namespaceDir, { withFileTypes: true });
+    entries = await fsp11.readdir(namespaceDir, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -7972,9 +8517,9 @@ async function findReusableExternalTemplateSourceCache(descriptor) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const entryDir = path15.join(namespaceDir, entry.name);
-    const markerPath = path15.join(entryDir, CACHE_MARKER_FILE);
-    const sourceDir = path15.join(entryDir, "source");
+    const entryDir = path16.join(namespaceDir, entry.name);
+    const markerPath = path16.join(entryDir, CACHE_MARKER_FILE);
+    const sourceDir = path16.join(entryDir, "source");
     const marker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
     if (!marker || !isExternalTemplateCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs) || !externalTemplateCacheMetadataMatches(marker.metadata, descriptor.metadata)) {
       continue;
@@ -8016,16 +8561,16 @@ async function resolveExternalTemplateSourceCache(descriptor, populateSourceDir)
   if (existingMarker) {
     await removeCacheEntryWithinRoot(cacheRoot, entryDir);
   }
-  const temporaryEntryDir = path15.join(namespaceDir, createTemporaryCacheEntryDirName(cacheKey));
-  const temporarySourceDir = path15.join(temporaryEntryDir, "source");
+  const temporaryEntryDir = path16.join(namespaceDir, createTemporaryCacheEntryDirName(cacheKey));
+  const temporarySourceDir = path16.join(temporaryEntryDir, "source");
   let populateFailed = false;
   try {
-    await fsp10.mkdir(temporarySourceDir, {
+    await fsp11.mkdir(temporarySourceDir, {
       mode: PRIVATE_CACHE_DIRECTORY_MODE,
       recursive: true
     });
     if (process.platform !== "win32") {
-      await fsp10.chmod(temporaryEntryDir, PRIVATE_CACHE_DIRECTORY_MODE);
+      await fsp11.chmod(temporaryEntryDir, PRIVATE_CACHE_DIRECTORY_MODE);
     }
     try {
       await populateSourceDir(temporarySourceDir);
@@ -8033,13 +8578,13 @@ async function resolveExternalTemplateSourceCache(descriptor, populateSourceDir)
       populateFailed = true;
       throw error;
     }
-    await fsp10.writeFile(path15.join(temporaryEntryDir, CACHE_MARKER_FILE), formatExternalTemplateCacheEntryMarker({
+    await fsp11.writeFile(path16.join(temporaryEntryDir, CACHE_MARKER_FILE), formatExternalTemplateCacheEntryMarker({
       cacheKey,
       createdAt: new Date,
       metadata: descriptor.metadata,
       namespace: descriptor.namespace
     }), "utf8");
-    await fsp10.rename(temporaryEntryDir, entryDir);
+    await fsp11.rename(temporaryEntryDir, entryDir);
     return {
       cacheHit: false,
       sourceDir
@@ -8110,9 +8655,9 @@ async function downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl,
   if (!tarballResponse.ok) {
     throw new Error(`Failed to download npm template tarball for ${locator.raw}: ${tarballResponse.status}`);
   }
-  const tarballPath = path16.join(path16.dirname(unpackDir), "template.tgz");
-  await fsp11.mkdir(unpackDir, { recursive: true });
-  await fsp11.writeFile(tarballPath, await readBufferResponseWithLimit(tarballResponse, {
+  const tarballPath = path17.join(path17.dirname(unpackDir), "template.tgz");
+  await fsp12.mkdir(unpackDir, { recursive: true });
+  await fsp12.writeFile(tarballPath, await readBufferResponseWithLimit(tarballResponse, {
     label: `npm template tarball for ${locator.raw}@${resolvedVersion}`,
     maxBytes: getExternalTemplateTarballMaxBytes()
   }));
@@ -8121,7 +8666,7 @@ async function downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl,
     file: tarballPath,
     strip: 1
   });
-  await fsp11.rm(tarballPath, { force: true });
+  await fsp12.rm(tarballPath, { force: true });
   await assertNoSymlinks2(unpackDir);
 }
 function selectRegistryVersion(metadata, locator) {
@@ -8216,7 +8761,7 @@ async function fetchNpmTemplateSource(locator) {
   }
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
   try {
-    const unpackDir = path16.join(tempRoot, "source");
+    const unpackDir = path17.join(tempRoot, "source");
     await downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl, unpackDir);
     return {
       blockDir: unpackDir,
@@ -8232,20 +8777,22 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
   if (locator.rawSpec !== "" && locator.rawSpec !== "*") {
     return null;
   }
-  const workspacePackagesRoot = path16.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..");
-  if (fs7.existsSync(workspacePackagesRoot)) {
-    for (const entry of fs7.readdirSync(workspacePackagesRoot, {
+  const workspacePackagesRoot = path17.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..");
+  if (fs6.existsSync(workspacePackagesRoot)) {
+    for (const entry of fs6.readdirSync(workspacePackagesRoot, {
       withFileTypes: true
     })) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const packageDir = path16.join(workspacePackagesRoot, entry.name);
-      const packageJsonPath = path16.join(packageDir, "package.json");
-      if (!fs7.existsSync(packageJsonPath)) {
+      const packageDir = path17.join(workspacePackagesRoot, entry.name);
+      const packageJsonPath = path17.join(packageDir, "package.json");
+      if (!fs6.existsSync(packageJsonPath)) {
         continue;
       }
-      const manifest = JSON.parse(fs7.readFileSync(packageJsonPath, "utf8"));
+      const manifest = readJsonFileSync(packageJsonPath, {
+        context: "workspace template package manifest"
+      });
       if (manifest.name === locator.name) {
         return {
           blockDir: packageDir,
@@ -8254,10 +8801,10 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
       }
     }
   }
-  const workspaceRequire = createRequire2(path16.join(path16.resolve(cwd), "__wp_typia_template_resolver__.cjs"));
+  const workspaceRequire = createRequire2(path17.join(path17.resolve(cwd), "__wp_typia_template_resolver__.cjs"));
   try {
-    const packageJsonPath = fs7.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
-    const sourceDir = path16.dirname(packageJsonPath);
+    const packageJsonPath = fs6.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
+    const sourceDir = path17.dirname(packageJsonPath);
     return {
       blockDir: sourceDir,
       rootDir: sourceDir
@@ -8266,11 +8813,11 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
     const errorCode = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
     if (errorCode === "MODULE_NOT_FOUND" || errorCode === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
       for (const basePath of workspaceRequire.resolve.paths(locator.name) ?? []) {
-        const packageJsonPath = path16.join(basePath, locator.name, "package.json");
-        if (!fs7.existsSync(packageJsonPath)) {
+        const packageJsonPath = path17.join(basePath, locator.name, "package.json");
+        if (!fs6.existsSync(packageJsonPath)) {
           continue;
         }
-        const sourceDir = path16.dirname(fs7.realpathSync(packageJsonPath));
+        const sourceDir = path17.dirname(fs6.realpathSync(packageJsonPath));
         return {
           blockDir: sourceDir,
           rootDir: sourceDir
@@ -8282,27 +8829,29 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
   }
 }
 async function isOfficialWorkspaceTemplateSeedAsync(seed) {
-  const packageJsonPath = path16.join(seed.rootDir, "package.json");
+  const packageJsonPath = path17.join(seed.rootDir, "package.json");
   if (!await pathExists(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson = JSON.parse(await fsp11.readFile(packageJsonPath, "utf8"));
+    const packageJson = await readJsonFile(packageJsonPath, {
+      context: "workspace template seed manifest"
+    });
     return packageJson.name === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE;
   } catch {
     return false;
   }
 }
 async function assertNoSymlinks2(sourceDir) {
-  const stats = await fsp11.lstat(sourceDir);
+  const stats = await fsp12.lstat(sourceDir);
   if (stats.isSymbolicLink()) {
     throw new Error(`Template sources may not include symbolic links: ${sourceDir}`);
   }
   if (!stats.isDirectory()) {
     return;
   }
-  for (const entry of await fsp11.readdir(sourceDir)) {
-    await assertNoSymlinks2(path16.join(sourceDir, entry));
+  for (const entry of await fsp12.readdir(sourceDir)) {
+    await assertNoSymlinks2(path17.join(sourceDir, entry));
   }
 }
 function runGitTemplateCommand(args, label, options = {}) {
@@ -8331,9 +8880,9 @@ function getGitHubTemplateRepositoryUrl(locator) {
   return `https://github.com/${locator.owner}/${locator.repo}.git`;
 }
 async function resolveGitHubTemplateDirectory(checkoutDir, locator) {
-  const sourceDir = path16.resolve(checkoutDir, locator.sourcePath);
-  const relativeSourceDir = path16.relative(checkoutDir, sourceDir);
-  if (relativeSourceDir.startsWith("..") || path16.isAbsolute(relativeSourceDir)) {
+  const sourceDir = path17.resolve(checkoutDir, locator.sourcePath);
+  const relativeSourceDir = path17.relative(checkoutDir, sourceDir);
+  if (relativeSourceDir.startsWith("..") || path17.isAbsolute(relativeSourceDir)) {
     throw new Error("GitHub template path must stay within the cloned repository.");
   }
   if (!await pathExists(sourceDir)) {
@@ -8522,7 +9071,7 @@ async function resolveGitHubTemplateSource(locator) {
     }
   }
   const { path: remoteRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
-  const checkoutDir = path16.join(remoteRoot, "source");
+  const checkoutDir = path17.join(remoteRoot, "source");
   try {
     cloneGitHubTemplateSource(locator, checkoutDir);
     const sourceDir = await resolveGitHubTemplateDirectory(checkoutDir, locator);
@@ -8539,7 +9088,7 @@ async function resolveGitHubTemplateSource(locator) {
 }
 async function resolveTemplateSeed(locator, cwd) {
   if (locator.kind === "path") {
-    const sourceDir = path16.resolve(cwd, locator.templatePath);
+    const sourceDir = path17.resolve(cwd, locator.templatePath);
     if (!await pathExists(sourceDir)) {
       throw new Error(`Template path does not exist: ${sourceDir}`);
     }
@@ -9073,7 +9622,8 @@ function buildTemplateVariablesFromBlockSpec(spec) {
     blockRuntimePackageVersion,
     blockTypesPackageVersion,
     projectToolsPackageVersion,
-    restPackageVersion
+    restPackageVersion,
+    wpTypiaPackageVersion
   } = getPackageVersions();
   const slug = spec.block.slug;
   const slugSnakeCase = toSnakeCase(slug);
@@ -9129,6 +9679,7 @@ function buildTemplateVariablesFromBlockSpec(spec) {
     requiresPhp: compatibility.pluginHeader.requiresPhp,
     testedUpTo: compatibility.pluginHeader.testedUpTo,
     projectToolsPackageVersion,
+    wpTypiaPackageVersion,
     cssClassName,
     dashCase: slug,
     dataStorageMode,
@@ -13642,7 +14193,8 @@ function getTemplateVariables(templateId, answers) {
     blockRuntimePackageVersion,
     blockTypesPackageVersion,
     projectToolsPackageVersion,
-    restPackageVersion
+    restPackageVersion,
+    wpTypiaPackageVersion
   } = getPackageVersions();
   const template = isBuiltInTemplateId(templateId) ? getTemplateById(templateId) : null;
   const metadataDefaults = isBuiltInTemplateId(templateId) ? getBuiltInTemplateMetadataDefaults(templateId) : null;
@@ -13698,6 +14250,7 @@ function getTemplateVariables(templateId, answers) {
     hasAlternatePlainTextRenderTarget: "false",
     hasAlternateRenderTargets: "false",
     projectToolsPackageVersion,
+    wpTypiaPackageVersion,
     requiresAtLeast: compatibility.pluginHeader.requiresAtLeast,
     requiresPhp: compatibility.pluginHeader.requiresPhp,
     cssClassName,
@@ -13801,15 +14354,55 @@ function getTemplateVariables(templateId, answers) {
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
 var DATA_STORAGE_MODES = ["post-meta", "custom-table"];
 var PERSISTENCE_POLICIES = ["authenticated", "public"];
+var CREATE_PROFILE_IDS = ["plugin-qa"];
 function isDataStorageMode(value) {
   return DATA_STORAGE_MODES.includes(value);
 }
 function isPersistencePolicy(value) {
   return PERSISTENCE_POLICIES.includes(value);
 }
+function isCreateProfileId(value) {
+  return CREATE_PROFILE_IDS.includes(value);
+}
+function resolveCreateProfileId(profile) {
+  if (profile === undefined || profile.trim().length === 0) {
+    return;
+  }
+  const normalizedProfile = profile.trim();
+  if (isCreateProfileId(normalizedProfile)) {
+    return normalizedProfile;
+  }
+  throw new Error(`Unknown create profile "${profile}". Expected one of: ${CREATE_PROFILE_IDS.join(", ")}.`);
+}
 function normalizeTemplateSelection(templateId) {
   return normalizeTemplateLookupId(templateId);
 }
+function assertCreateProfileTemplateCompatibility({
+  profile,
+  templateId
+}) {
+  if (!profile) {
+    return;
+  }
+  if (profile === "plugin-qa" && templateId !== OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+    throw new Error("`--profile plugin-qa` currently supports only the official workspace template. Use `--template workspace` or add QA files later with `wp-typia add integration-env <name> --wp-env --release-zip`.");
+  }
+}
+async function applyCreateProfile({
+  profile,
+  projectDir
+}) {
+  if (profile !== "plugin-qa") {
+    return;
+  }
+  await runAddIntegrationEnvCommand({
+    cwd: projectDir,
+    integrationEnvName: "local-smoke",
+    service: "none",
+    withReleaseZip: true,
+    withWpEnv: true
+  });
+}
 async function reportScaffoldProgress2(onProgress, event) {
   await onProgress?.(event);
 }
@@ -13824,6 +14417,7 @@ async function scaffoldProject({
   externalLayerId,
   externalLayerSource,
   externalLayerSourceLabel,
+  profile,
   repositoryReference,
   cwd = process.cwd(),
   allowExistingDir = false,
@@ -13838,6 +14432,10 @@ async function scaffoldProject({
   const resolvedTemplateId = normalizeTemplateSelection(templateId);
   const resolvedPackageManager = getPackageManager(packageManager).id;
   const isBuiltInTemplate = isBuiltInTemplateId(resolvedTemplateId);
+  assertCreateProfileTemplateCompatibility({
+    profile,
+    templateId: resolvedTemplateId
+  });
   assertExternalLayerCompositionOptions({
     externalLayerId,
     externalLayerSource
@@ -13946,17 +14544,17 @@ async function scaffoldProject({
     phase: "finalize-project",
     title: "Finalizing scaffold output"
   });
-  const readmePath = path17.join(projectDir, "README.md");
+  const readmePath = path18.join(projectDir, "README.md");
   if (!await pathExists(readmePath)) {
-    await fsp12.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
+    await fsp13.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
       withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
       withTestPreset: isBuiltInTemplate ? withTestPreset : false,
       withWpEnv: isBuiltInTemplate ? withWpEnv : false
     }), "utf8");
   }
-  const gitignorePath = path17.join(projectDir, ".gitignore");
-  const existingGitignore = await pathExists(gitignorePath) ? await fsp12.readFile(gitignorePath, "utf8") : "";
-  await fsp12.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
+  const gitignorePath = path18.join(projectDir, ".gitignore");
+  const existingGitignore = await pathExists(gitignorePath) ? await fsp13.readFile(gitignorePath, "utf8") : "";
+  await fsp13.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
   await normalizePackageJson(projectDir, resolvedPackageManager);
   if (isBuiltInTemplate) {
     const variableGroups = getScaffoldTemplateVariableGroups(variables);
@@ -13969,6 +14567,10 @@ async function scaffoldProject({
       withWpEnv
     });
   }
+  await applyCreateProfile({
+    profile,
+    projectDir
+  });
   await normalizePackageManagerFiles(projectDir, resolvedPackageManager);
   await removeUnexpectedLockfiles(projectDir, resolvedPackageManager);
   await replaceTextRecursively(projectDir, resolvedPackageManager, {
@@ -14036,6 +14638,6 @@ async function resolveOptionalInteractiveExternalLayerId({
   }
 }
 
-export { syncPersistenceRestArtifacts, copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, getPrimaryDevelopmentScript, getOptionalOnboardingSteps, getOptionalOnboardingNote, getOptionalOnboardingShortNote, isCompoundPersistenceEnabled, formatNonEmptyTargetDirectoryError, resolveExternalTemplateLayers, resolveTemplateSeed, normalizeOptionalCliString, resolveLocalCliPathOption, assertExternalLayerCompositionOptions, assertBuiltInTemplateVariantAllowed, parseAlternateRenderTargets, parseCompoundInnerBlocksPreset, OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY, REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, createScaffoldCompatibilityConfig, renderScaffoldCompatibilityConfig, updatePluginHeaderCompatibility, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
+export { syncPersistenceRestArtifacts, copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, getPrimaryDevelopmentScript, getOptionalOnboardingSteps, getOptionalOnboardingNote, getOptionalOnboardingShortNote, isCompoundPersistenceEnabled, formatNonEmptyTargetDirectoryError, executeWorkspaceMutationPlan, insertPhpSnippetBeforeWorkspaceAnchors, appendPhpSnippetBeforeClosingTag, runAddIntegrationEnvCommand, resolveExternalTemplateLayers, resolveTemplateSeed, normalizeOptionalCliString, resolveLocalCliPathOption, assertExternalLayerCompositionOptions, assertBuiltInTemplateVariantAllowed, parseAlternateRenderTargets, parseCompoundInnerBlocksPreset, OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY, REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, createScaffoldCompatibilityConfig, renderScaffoldCompatibilityConfig, updatePluginHeaderCompatibility, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, resolveCreateProfileId, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
 
-//# debugId=9368065E49298D9E64756E2164756E21
+//# debugId=5D116D118BFF7F2764756E2164756E21