wp-typia 0.19.0 → 0.20.0

package/dist-bunli/{cli-7svz19s1.js → cli-2ybmc22r.js}

@@ -24,7 +24,7 @@ import {
   isOmittableBuiltInTemplateLayerDir,
   resolveBuiltInTemplateSource,
   resolveBuiltInTemplateSourceFromLayerDirs
-} from "./cli-wtrvnce5.js";
+} from "./cli-w4r0rr8a.js";
 import {
   BUILTIN_BLOCK_METADATA_VERSION,
   BUILTIN_TEMPLATE_IDS,
@@ -40,7 +40,7 @@ import {
   getTemplateById,
   isBuiltInTemplateId,
   isRemovedBuiltInTemplateId
-} from "./cli-kan7a6db.js";
+} from "./cli-a6dwqnhq.js";
 import {
   buildBlockCssClassName,
   buildFrontendCssClassName,
@@ -53,6 +53,9 @@ import {
   validateBlockSlug,
   validateNamespace
 } from "./cli-rg481yks.js";
+import {
+  createManagedTempRoot
+} from "./cli-t73q5aqz.js";
 import {
   __commonJS,
   __require,
@@ -5476,6 +5479,21 @@ function buildCompoundChildTypesSource(variables, attributes) {
   });
 }
 
+// ../wp-typia-project-tools/src/runtime/scaffold-template-variable-groups.ts
+var SCAFFOLD_TEMPLATE_VARIABLE_GROUPS = Symbol("wp-typia.scaffold-template-variable-groups");
+function attachScaffoldTemplateVariableGroups(variables, groups) {
+  Object.defineProperty(variables, SCAFFOLD_TEMPLATE_VARIABLE_GROUPS, {
+    configurable: false,
+    enumerable: false,
+    value: groups,
+    writable: false
+  });
+  return variables;
+}
+function getScaffoldTemplateVariableGroups(variables) {
+  return variables[SCAFFOLD_TEMPLATE_VARIABLE_GROUPS];
+}
+
 // ../wp-typia-project-tools/src/runtime/built-in-block-artifacts.ts
 function stringifyBlockJsonDocument(document) {
   return `${JSON.stringify(document, null, "\t")}
@@ -5581,7 +5599,8 @@ function buildPersistenceArtifact(variables) {
 }
 function buildCompoundParentArtifact(variables) {
   const attributes = buildCompoundParentAttributes(variables);
-  const persistenceEnabled = variables.compoundPersistenceEnabled === "true";
+  const compoundGroup = getScaffoldTemplateVariableGroups(variables).compound;
+  const persistenceEnabled = compoundGroup.enabled && compoundGroup.persistenceEnabled;
   return {
     blockJsonDocument: {
       $schema: "https://schemas.wp.org/trunk/block.json",
@@ -5723,7 +5742,8 @@ async function writeStarterManifestFiles(targetDir, templateId, variables) {
   }
 }
 async function seedBuiltInPersistenceArtifacts(targetDir, templateId, variables) {
-  const needsPersistenceArtifacts = templateId === "persistence" || templateId === "compound" && variables.compoundPersistenceEnabled === "true";
+  const compoundGroup = getScaffoldTemplateVariableGroups(variables).compound;
+  const needsPersistenceArtifacts = templateId === "persistence" || templateId === "compound" && compoundGroup.enabled && compoundGroup.persistenceEnabled;
   if (!needsPersistenceArtifacts) {
     return;
   }
@@ -6143,7 +6163,7 @@ async function collectScaffoldAnswers({
 
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
 import fs14 from "fs";
-import { promises as fsp11 } from "fs";
+import { promises as fsp10 } from "fs";
 import path17 from "path";
 
 // ../wp-typia-project-tools/src/runtime/scaffold-apply-utils.ts
@@ -6365,21 +6385,22 @@ function buildReadme(templateId, variables, packageManager, {
   withTestPreset = false,
   withWpEnv = false
 } = {}) {
+  const variableGroups = getScaffoldTemplateVariableGroups(variables);
+  const compoundPersistenceEnabled = variableGroups.compound.enabled && variableGroups.compound.persistenceEnabled;
   const optionalOnboardingSteps = getOptionalOnboardingSteps(packageManager, templateId, {
-    compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true"
+    compoundPersistenceEnabled
   });
   const initialCommitCommands = getInitialCommitCommands();
   const sourceOfTruthNote = getTemplateSourceOfTruthNote(templateId, {
-    compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true"
+    compoundPersistenceEnabled
   });
-  const compoundPersistenceEnabled = variables.compoundPersistenceEnabled === "true";
-  const publicPersistencePolicyNote = variables.isPublicPersistencePolicy === "true" ? "Public persistence writes use signed short-lived tokens, per-request ids, and coarse rate limiting by default. Add application-specific abuse controls before using the same pattern for high-value metrics or experiments." : null;
-  const alternateRenderTargetSection = variables.hasAlternateRenderTargets === "true" ? `## Alternate Render Targets
+  const publicPersistencePolicyNote = variableGroups.persistence.enabled && variableGroups.persistence.auth.isPublic ? "Public persistence writes use signed short-lived tokens, per-request ids, and coarse rate limiting by default. Add application-specific abuse controls before using the same pattern for high-value metrics or experiments." : null;
+  const alternateRenderTargetSection = variableGroups.alternateRenderTargets.enabled ? `## Alternate Render Targets
 
 This scaffold keeps \`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render.php` : "src/render.php"}\` as the default web render boundary and also generates ${[
-    variables.hasAlternateEmailRenderTarget === "true" ? `\`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render-email.php` : "src/render-email.php"}\`` : null,
-    variables.hasAlternateMjmlRenderTarget === "true" ? `\`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render-mjml.php` : "src/render-mjml.php"}\`` : null,
-    variables.hasAlternatePlainTextRenderTarget === "true" ? `\`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render-text.php` : "src/render-text.php"}\`` : null
+    variableGroups.alternateRenderTargets.hasEmail ? `\`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render-email.php` : "src/render-email.php"}\`` : null,
+    variableGroups.alternateRenderTargets.hasMjml ? `\`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render-mjml.php` : "src/render-mjml.php"}\`` : null,
+    variableGroups.alternateRenderTargets.hasPlainText ? `\`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render-text.php` : "src/render-text.php"}\`` : null
   ].filter((value) => Boolean(value)).join(", ")}. All of those entries delegate through \`${templateId === "compound" ? `src/blocks/${variables.slugKebabCase}/render-targets.php` : "src/render-targets.php"}\`, so attribute normalization, validation, and render-target adapter hooks stay aligned across web, email, MJML, and plain-text integrations.` : "";
   const compoundExtensionWorkflowSection = getCompoundExtensionWorkflowSection(packageManager, templateId);
   const compoundInnerBlocksSection = templateId === "compound" ? `## Compound InnerBlocks Presets
@@ -7241,8 +7262,6 @@ async function assertExternalTemplateLayersDoNotWriteProtectedOutputs({
 
 // ../wp-typia-project-tools/src/runtime/template-source-external.ts
 import fs9 from "fs";
-import { promises as fsp8 } from "fs";
-import os from "os";
 import path13 from "path";
 import { pathToFileURL } from "url";
 var EXTERNAL_TEMPLATE_ENTRY_CANDIDATES = [
@@ -7250,6 +7269,7 @@ var EXTERNAL_TEMPLATE_ENTRY_CANDIDATES = [
   "index.cjs",
   "index.mjs"
 ];
+var EXTERNAL_TEMPLATE_TRUST_WARNING = "External template configs execute trusted JavaScript during scaffolding. Review the template source before using local paths, GitHub repos, or npm packages you do not already trust.";
 var TEMPLATE_WARNING_MESSAGE = "wp-typia owns package/tooling/sync setup for generated projects, so this external template setting is ignored.";
 function getTemplateWarning(key) {
   return `Ignoring external template config key "${key}": ${TEMPLATE_WARNING_MESSAGE}`;
@@ -7282,7 +7302,7 @@ async function loadExternalTemplateConfig(sourceDir) {
   if (!isPlainObject(loadedConfig)) {
     throw new Error(`External template config must export an object: ${entryPath}`);
   }
-  const warnings = [];
+  const warnings = [EXTERNAL_TEMPLATE_TRUST_WARNING];
   for (const ignoredKey of [
     "wpScripts",
     "wpEnv",
@@ -7379,10 +7399,7 @@ async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVa
   const { config, warnings } = await loadExternalTemplateConfig(sourceDir);
   const { selectedVariant, variantConfig } = getVariantConfig(config, requestedVariant);
   const { folderName, formatHint, templatePath } = resolveConfiguredTemplatePath(config, variantConfig);
-  const tempRoot = await fsp8.mkdtemp(path13.join(os.tmpdir(), "wp-typia-create-block-external-"));
-  const cleanup = async () => {
-    await fsp8.rm(tempRoot, { force: true, recursive: true });
-  };
+  const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-create-block-external-");
   try {
     const renderedRoot = path13.join(tempRoot, "rendered");
     const blockDir = resolveSourceSubpath(renderedRoot, folderName);
@@ -7415,9 +7432,24 @@ async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVa
 
 // ../wp-typia-project-tools/src/runtime/template-source-remote.ts
 import fs10 from "fs";
-import { promises as fsp9 } from "fs";
-import os2 from "os";
+import { promises as fsp8 } from "fs";
 import path14 from "path";
+async function cleanupSeedRootPair(cleanup, seedCleanup) {
+  let cleanupError;
+  try {
+    await cleanup();
+  } catch (error) {
+    cleanupError = error;
+  }
+  try {
+    await seedCleanup?.();
+  } catch (error) {
+    cleanupError ??= error;
+  }
+  if (cleanupError !== undefined) {
+    throw cleanupError;
+  }
+}
 function getDefaultCategoryFromBlockJson(blockJson) {
   return typeof blockJson.category === "string" && blockJson.category.trim().length > 0 ? blockJson.category.trim() : "widgets";
 }
@@ -7450,19 +7482,33 @@ function readTemplatePackageJson(sourceDir) {
       continue;
     }
     try {
-      return JSON.parse(fs10.readFileSync(candidate, "utf8"));
-    } catch {
-      continue;
+      return {
+        packageJson: JSON.parse(fs10.readFileSync(candidate, "utf8")),
+        sourcePath: candidate
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown parse failure";
+      throw new Error(`Failed to parse template metadata file "${candidate}": ${message}`);
     }
   }
   return null;
 }
 function getTemplateProjectType(sourceDir) {
-  const packageJson = readTemplatePackageJson(sourceDir);
-  return typeof packageJson?.wpTypia?.projectType === "string" ? packageJson.wpTypia.projectType : null;
+  const packageJsonEntry = readTemplatePackageJson(sourceDir);
+  if (!packageJsonEntry) {
+    return null;
+  }
+  const projectType = packageJsonEntry.packageJson.wpTypia?.projectType;
+  if (projectType === undefined) {
+    return null;
+  }
+  if (typeof projectType !== "string" || projectType.trim().length === 0) {
+    throw new Error(`Template metadata file "${packageJsonEntry.sourcePath}" defines wpTypia.projectType, but it must be a non-empty string.`);
+  }
+  return projectType;
 }
 async function normalizeWpTypiaTemplateSeed(seed) {
-  const tempRoot = await fsp9.mkdtemp(path14.join(os2.tmpdir(), "wp-typia-template-source-"));
+  const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
   const normalizedDir = path14.join(tempRoot, "template");
   try {
     await copyRawDirectory(seed.blockDir, normalizedDir, {
@@ -7472,21 +7518,18 @@ async function normalizeWpTypiaTemplateSeed(seed) {
       }
     });
     if (seed.assetsDir && fs10.existsSync(seed.assetsDir)) {
-      await fsp9.cp(seed.assetsDir, path14.join(normalizedDir, "assets"), {
+      await fsp8.cp(seed.assetsDir, path14.join(normalizedDir, "assets"), {
         recursive: true,
         force: true
       });
     }
   } catch (error) {
-    await fsp9.rm(tempRoot, { force: true, recursive: true });
+    await Promise.allSettled([cleanup(), seed.cleanup?.()]);
     throw error;
   }
   return {
     blockDir: normalizedDir,
-    cleanup: async () => {
-      await fsp9.rm(tempRoot, { force: true, recursive: true });
-      await seed.cleanup?.();
-    },
+    cleanup: async () => cleanupSeedRootPair(cleanup, seed.cleanup),
     rootDir: normalizedDir,
     selectedVariant: seed.selectedVariant,
     warnings: seed.warnings
@@ -7566,9 +7609,9 @@ async function rewriteBlockJsonImports(directory) {
   const textExtensions = new Set([".js", ".jsx", ".ts", ".tsx"]);
   const targetBlockJsonPath = path14.join(directory, "block.json");
   async function visit(currentPath) {
-    const stats = await fsp9.stat(currentPath);
+    const stats = await fsp8.stat(currentPath);
     if (stats.isDirectory()) {
-      const entries = await fsp9.readdir(currentPath);
+      const entries = await fsp8.readdir(currentPath);
       for (const entry of entries) {
         await visit(path14.join(currentPath, entry));
       }
@@ -7577,19 +7620,19 @@ async function rewriteBlockJsonImports(directory) {
     if (!textExtensions.has(path14.extname(currentPath))) {
       return;
     }
-    const content = await fsp9.readFile(currentPath, "utf8");
+    const content = await fsp8.readFile(currentPath, "utf8");
     const relativeSpecifier = path14.relative(path14.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 fsp8.writeFile(currentPath, next, "utf8");
     }
   }
   await visit(directory);
 }
 async function patchRemotePackageJson(templateDir, needsInteractivity) {
   const packageJsonPath = path14.join(templateDir, "package.json.mustache");
-  const packageJson = JSON.parse(await fsp9.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fsp8.readFile(packageJsonPath, "utf8"));
   const existingDependencies = { ...packageJson.dependencies ?? {} };
   const existingDevDependencies = { ...packageJson.devDependencies ?? {} };
   delete existingDependencies["@wp-typia/project-tools"];
@@ -7609,7 +7652,7 @@ async function patchRemotePackageJson(templateDir, needsInteractivity) {
   } else {
     delete packageJson.dependencies;
   }
-  await fsp9.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  await fsp8.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `, "utf8");
 }
 function getSeedSourceRoot(blockDir) {
@@ -7659,16 +7702,16 @@ async function removeSeedEntryConflicts(templateDir) {
     "view.ts",
     "view.tsx"
   ]) {
-    await fsp9.rm(path14.join(templateDir, "src", filename), { force: true });
+    await fsp8.rm(path14.join(templateDir, "src", filename), { force: true });
   }
 }
 async function normalizeCreateBlockSubset(seed, context) {
-  const tempRoot = await fsp9.mkdtemp(path14.join(os2.tmpdir(), "wp-typia-remote-template-"));
+  const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-remote-template-");
   try {
     const templateDir = path14.join(tempRoot, "template");
     const blockJson = readRemoteBlockJson(seed.blockDir);
     const sourceRoot = getSeedSourceRoot(seed.blockDir);
-    await fsp9.mkdir(templateDir, { recursive: true });
+    await fsp8.mkdir(templateDir, { recursive: true });
     for (const layerDir of getBuiltInTemplateLayerDirs("basic")) {
       if (!fs10.existsSync(layerDir)) {
         if (isOmittableBuiltInTemplateLayerDir("basic", layerDir)) {
@@ -7676,28 +7719,28 @@ async function normalizeCreateBlockSubset(seed, context) {
         }
         throw new Error(`Built-in template layer is missing: ${layerDir}`);
       }
-      await fsp9.cp(layerDir, templateDir, {
+      await fsp8.cp(layerDir, templateDir, {
         recursive: true,
         force: true
       });
     }
     await removeSeedEntryConflicts(templateDir);
-    await fsp9.cp(sourceRoot, path14.join(templateDir, "src"), {
+    await fsp8.cp(sourceRoot, path14.join(templateDir, "src"), {
       recursive: true,
       force: true
     });
     const remoteRenderPath = findSeedRenderPhp(seed);
     if (remoteRenderPath) {
-      await fsp9.copyFile(remoteRenderPath, path14.join(templateDir, "render.php"));
+      await fsp8.copyFile(remoteRenderPath, path14.join(templateDir, "render.php"));
     }
     if (seed.assetsDir && fs10.existsSync(seed.assetsDir)) {
-      await fsp9.cp(seed.assetsDir, path14.join(templateDir, "assets"), {
+      await fsp8.cp(seed.assetsDir, path14.join(templateDir, "assets"), {
         recursive: true,
         force: true
       });
     }
-    await fsp9.writeFile(path14.join(templateDir, "src", "types.ts"), buildRemoteTypesSource(blockJson, context), "utf8");
-    await fsp9.writeFile(path14.join(templateDir, "src", "block.json"), buildRemoteBlockJsonTemplate(blockJson), "utf8");
+    await fsp8.writeFile(path14.join(templateDir, "src", "types.ts"), buildRemoteTypesSource(blockJson, context), "utf8");
+    await fsp8.writeFile(path14.join(templateDir, "src", "block.json"), buildRemoteBlockJsonTemplate(blockJson), "utf8");
     await rewriteBlockJsonImports(path14.join(templateDir, "src"));
     const needsInteractivity = typeof blockJson.viewScriptModule === "string" || typeof blockJson.viewScript === "string" || fs10.existsSync(path14.join(templateDir, "src", "view.js")) || fs10.existsSync(path14.join(templateDir, "src", "view.ts")) || fs10.existsSync(path14.join(templateDir, "src", "view.tsx")) || fs10.existsSync(path14.join(templateDir, "src", "interactivity.js")) || fs10.existsSync(path14.join(templateDir, "src", "interactivity.ts"));
     await patchRemotePackageJson(templateDir, needsInteractivity);
@@ -7714,16 +7757,10 @@ async function normalizeCreateBlockSubset(seed, context) {
       selectedVariant: seed.selectedVariant ?? null,
       templateDir,
       warnings: seed.warnings ?? [],
-      cleanup: async () => {
-        await fsp9.rm(tempRoot, { force: true, recursive: true });
-        if (seed.cleanup) {
-          await seed.cleanup();
-        }
-      }
+      cleanup: async () => cleanupSeedRootPair(cleanup, seed.cleanup)
     };
   } catch (error) {
-    await fsp9.rm(tempRoot, { force: true, recursive: true });
-    await seed.cleanup?.();
+    await Promise.allSettled([cleanup(), seed.cleanup?.()]);
     throw error;
   }
 }
@@ -7785,9 +7822,8 @@ async function detectTemplateSourceFormat(sourceDir) {
 // ../wp-typia-project-tools/src/runtime/template-source-seeds.ts
 var import_semver = __toESM(require_semver2(), 1);
 import fs13 from "fs";
-import { promises as fsp10 } from "fs";
+import { promises as fsp9 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import os4 from "os";
 import path16 from "path";
 import { execFileSync } from "child_process";
 
@@ -9821,7 +9857,7 @@ var ls = Symbol("readdir");
 var ai = Symbol("onreaddir");
 var li = Symbol("pipe");
 var ir = Symbol("entry");
-var os3 = Symbol("entryOpt");
+var os = Symbol("entryOpt");
 var ci = Symbol("writeEntryClass");
 var rr = Symbol("write");
 var hs = Symbol("ondrain");
@@ -9884,7 +9920,7 @@ var Et = class extends D {
       t.resume();
     else {
       let i = new di(t.path, e);
-      i.entry = new ri(t, this[os3](i)), i.entry.on("end", () => this[ns](i)), this[G] += 1, this[W].push(i);
+      i.entry = new ri(t, this[os](i)), i.entry.on("end", () => this[ns](i)), this[G] += 1, this[W].push(i);
     }
     this[Ft]();
   }
@@ -9953,13 +9989,13 @@ var Et = class extends D {
       }
     }
   }
-  [os3](t) {
+  [os](t) {
     return { onwarn: (e, i, r) => this.warn(e, i, r), noPax: this.noPax, cwd: this.cwd, absolute: t.absolute, preservePaths: this.preservePaths, maxReadSize: this.maxReadSize, strict: this.strict, portable: this.portable, linkCache: this.linkCache, statCache: this.statCache, noMtime: this.noMtime, mtime: this.mtime, prefix: this.prefix, onWriteEntry: this.onWriteEntry };
   }
   [ir](t) {
     this[G] += 1;
     try {
-      return new this[ci](t.path, this[os3](t)).on("end", () => this[ns](t)).on("error", (i) => this.emit("error", i));
+      return new this[ci](t.path, this[os](t)).on("end", () => this[ns](t)).on("error", (i) => this.emit("error", i));
     } catch (e) {
       this.emit("error", e);
     }
@@ -10987,10 +11023,7 @@ async function fetchNpmTemplateSource(locator) {
   if (typeof tarballUrl !== "string" || tarballUrl.length === 0) {
     throw new Error(`npm template metadata is missing tarball URL for ${locator.raw}@${resolvedVersion}.`);
   }
-  const tempRoot = await fsp10.mkdtemp(path16.join(os4.tmpdir(), "wp-typia-template-source-"));
-  const cleanup = async () => {
-    await fsp10.rm(tempRoot, { force: true, recursive: true });
-  };
+  const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
   try {
     const tarballResponse = await fetch(tarballUrl);
     if (!tarballResponse.ok) {
@@ -10998,8 +11031,8 @@ async function fetchNpmTemplateSource(locator) {
     }
     const tarballPath = path16.join(tempRoot, "template.tgz");
     const unpackDir = path16.join(tempRoot, "source");
-    await fsp10.mkdir(unpackDir, { recursive: true });
-    await fsp10.writeFile(tarballPath, Buffer.from(await tarballResponse.arrayBuffer()));
+    await fsp9.mkdir(unpackDir, { recursive: true });
+    await fsp9.writeFile(tarballPath, Buffer.from(await tarballResponse.arrayBuffer()));
     await co({
       cwd: unpackDir,
       file: tarballPath,
@@ -11082,22 +11115,19 @@ function isOfficialWorkspaceTemplateSeed(seed) {
   }
 }
 async function assertNoSymlinks2(sourceDir) {
-  const stats = await fsp10.lstat(sourceDir);
+  const stats = await fsp9.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 fsp10.readdir(sourceDir)) {
+  for (const entry of await fsp9.readdir(sourceDir)) {
     await assertNoSymlinks2(path16.join(sourceDir, entry));
   }
 }
 async function resolveGitHubTemplateSource(locator) {
-  const remoteRoot = await fsp10.mkdtemp(path16.join(os4.tmpdir(), "wp-typia-template-source-"));
-  const cleanup = async () => {
-    await fsp10.rm(remoteRoot, { force: true, recursive: true });
-  };
+  const { path: remoteRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
   const checkoutDir = path16.join(remoteRoot, "source");
   try {
     const args = ["clone", "--depth", "1"];
@@ -11151,13 +11181,14 @@ async function resolveTemplateSeed(locator, cwd) {
 // ../wp-typia-project-tools/src/runtime/template-source.ts
 async function resolveTemplateSource(templateId, cwd, variables, variant) {
   if (isBuiltInTemplateId(templateId)) {
+    const variableGroups = getScaffoldTemplateVariableGroups(variables);
     assertBuiltInTemplateVariantAllowed({
       templateId,
       variant
     });
     return resolveBuiltInTemplateSource(templateId, {
-      persistenceEnabled: variables.compoundPersistenceEnabled === "true",
-      persistencePolicy: variables.persistencePolicy === "public" ? "public" : "authenticated"
+      persistenceEnabled: variableGroups.compound.enabled && variableGroups.compound.persistenceEnabled,
+      persistencePolicy: variableGroups.persistence.enabled && variableGroups.persistence.policy === "public" ? "public" : "authenticated"
     });
   }
   const locator = parseTemplateLocator(templateId);
@@ -11375,11 +11406,12 @@ function buildTemplateVariablesFromBlockSpec(spec) {
   const compoundChildCssClassName = buildBlockCssClassName(namespace, `${slug}-item`);
   const compoundInnerBlocksPreset = spec.compound.innerBlocksPreset;
   const compoundInnerBlocksPresetDefinition = getCompoundInnerBlocksPresetDefinition(compoundInnerBlocksPreset);
+  const compoundInnerBlocksOrientation = compoundInnerBlocksPresetDefinition.orientation ?? "";
   const persistenceEnabled = spec.persistence.enabled;
   const dataStorageMode = persistenceEnabled ? spec.persistence.dataStorageMode : "custom-table";
   const persistencePolicy = persistenceEnabled ? spec.persistence.persistencePolicy : "authenticated";
   const queryVariationNamespace = `${namespace}/${slug}`;
-  return {
+  const flatVariables = {
     alternateRenderTargetsCsv: formatAlternateRenderTargets(alternateRenderTargets),
     alternateRenderTargetsJson: JSON.stringify(alternateRenderTargets),
     apiClientPackageVersion,
@@ -11396,7 +11428,7 @@ function buildTemplateVariablesFromBlockSpec(spec) {
     compoundChildTitleJson: JSON.stringify(compoundChildTitle),
     compoundPersistenceEnabled: spec.template.family === "compound" && persistenceEnabled ? "true" : "false",
     compoundInnerBlocksDirectInsert: compoundInnerBlocksPresetDefinition.directInsert ? "true" : "false",
-    compoundInnerBlocksOrientation: compoundInnerBlocksPresetDefinition.orientation ?? "",
+    compoundInnerBlocksOrientation,
     compoundInnerBlocksOrientationExpression: compoundInnerBlocksPresetDefinition.orientation ? `'${compoundInnerBlocksPresetDefinition.orientation}'` : "undefined",
     compoundInnerBlocksPreset,
     compoundInnerBlocksPresetDescription: compoundInnerBlocksPresetDefinition.description,
@@ -11445,6 +11477,200 @@ function buildTemplateVariablesFromBlockSpec(spec) {
     titleCase: pascalCase,
     persistencePolicy
   };
+  const shared = {
+    author: spec.project.author,
+    blockMetadataVersion: BUILTIN_BLOCK_METADATA_VERSION,
+    category: spec.metadata.category,
+    cssClassName,
+    description: spec.metadata.description,
+    descriptionJson: flatVariables.descriptionJson,
+    frontendCssClassName: flatVariables.frontendCssClassName,
+    icon: spec.metadata.icon,
+    keyword: spec.metadata.keyword,
+    namespace,
+    pascalCase,
+    phpPrefix,
+    phpPrefixUpper,
+    slug,
+    slugCamelCase: flatVariables.slugCamelCase,
+    slugKebabCase: slug,
+    slugSnakeCase,
+    textDomain,
+    title,
+    titleCase: pascalCase,
+    titleJson: flatVariables.titleJson,
+    versions: {
+      apiClient: apiClientPackageVersion,
+      blockRuntime: blockRuntimePackageVersion,
+      blockTypes: blockTypesPackageVersion,
+      projectTools: projectToolsPackageVersion,
+      rest: restPackageVersion
+    }
+  };
+  const alternateRenderTargetsGroup = {
+    csv: flatVariables.alternateRenderTargetsCsv,
+    enabled: alternateRenderTargets.length > 0,
+    hasEmail: hasAlternateEmailRenderTarget,
+    hasMjml: hasAlternateMjmlRenderTarget,
+    hasPlainText: hasAlternatePlainTextRenderTarget,
+    json: flatVariables.alternateRenderTargetsJson,
+    targets: alternateRenderTargets
+  };
+  const compoundGroup = {
+    child: {
+      category: COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS.category,
+      cssClassName: compoundChildCssClassName,
+      icon: COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS.icon,
+      title: compoundChildTitle,
+      titleJson: JSON.stringify(compoundChildTitle)
+    },
+    enabled: true,
+    innerBlocks: {
+      description: compoundInnerBlocksPresetDefinition.description,
+      directInsert: compoundInnerBlocksPresetDefinition.directInsert,
+      label: compoundInnerBlocksPresetDefinition.label,
+      orientation: compoundInnerBlocksOrientation,
+      orientationExpression: compoundInnerBlocksPresetDefinition.orientation ? `'${compoundInnerBlocksPresetDefinition.orientation}'` : "undefined",
+      preset: compoundInnerBlocksPreset,
+      templateLockExpression: compoundInnerBlocksPresetDefinition.templateLock === false ? "false" : `'${compoundInnerBlocksPresetDefinition.templateLock}'`
+    },
+    persistenceEnabled
+  };
+  const persistenceGroup = persistenceEnabled ? {
+    auth: {
+      bootstrapCredentialDeclarations: flatVariables.bootstrapCredentialDeclarations,
+      descriptionJson: flatVariables.persistencePolicyDescriptionJson,
+      intent: flatVariables.restWriteAuthIntent,
+      isAuthenticated: persistencePolicy === "authenticated",
+      isPublic: persistencePolicy === "public",
+      mechanism: flatVariables.restWriteAuthMechanism,
+      mode: flatVariables.restWriteAuthMode,
+      publicWriteRequestIdDeclaration: flatVariables.publicWriteRequestIdDeclaration
+    },
+    dataStorageMode,
+    enabled: true,
+    policy: persistencePolicy,
+    scope: spec.persistence.scope
+  } : null;
+  const queryLoopGroup = {
+    allowedControls: spec.queryLoop.allowedControls,
+    allowedControlsJson: flatVariables.queryAllowedControlsJson,
+    enabled: true,
+    postType: spec.queryLoop.postType,
+    postTypeJson: flatVariables.queryPostTypeJson,
+    variationNamespace: queryVariationNamespace,
+    variationNamespaceJson: flatVariables.queryVariationNamespaceJson
+  };
+  switch (spec.template.family) {
+    case "basic":
+      return attachScaffoldTemplateVariableGroups(flatVariables, {
+        alternateRenderTargets: alternateRenderTargetsGroup,
+        compound: {
+          enabled: false,
+          persistenceEnabled: false
+        },
+        persistence: {
+          enabled: false,
+          scope: "none"
+        },
+        queryLoop: {
+          enabled: false
+        },
+        shared,
+        template: {
+          description: spec.template.description
+        },
+        templateFamily: "basic"
+      });
+    case "interactivity":
+      return attachScaffoldTemplateVariableGroups(flatVariables, {
+        alternateRenderTargets: alternateRenderTargetsGroup,
+        compound: {
+          enabled: false,
+          persistenceEnabled: false
+        },
+        persistence: {
+          enabled: false,
+          scope: "none"
+        },
+        queryLoop: {
+          enabled: false
+        },
+        shared,
+        template: {
+          description: spec.template.description
+        },
+        templateFamily: "interactivity"
+      });
+    case "persistence": {
+      if (persistenceGroup === null) {
+        throw new Error("Persistence scaffolds must provide persistence template variables.");
+      }
+      return attachScaffoldTemplateVariableGroups(flatVariables, {
+        alternateRenderTargets: alternateRenderTargetsGroup,
+        compound: {
+          enabled: false,
+          persistenceEnabled: false
+        },
+        persistence: {
+          ...persistenceGroup,
+          scope: "single"
+        },
+        queryLoop: {
+          enabled: false
+        },
+        shared,
+        template: {
+          description: spec.template.description
+        },
+        templateFamily: "persistence"
+      });
+    }
+    case "compound": {
+      const compoundPersistenceGroup = persistenceGroup === null ? {
+        enabled: false,
+        scope: "none"
+      } : {
+        ...persistenceGroup,
+        scope: "compound-parent"
+      };
+      return attachScaffoldTemplateVariableGroups(flatVariables, {
+        alternateRenderTargets: alternateRenderTargetsGroup,
+        compound: compoundGroup,
+        persistence: compoundPersistenceGroup,
+        queryLoop: {
+          enabled: false
+        },
+        shared,
+        template: {
+          description: spec.template.description
+        },
+        templateFamily: "compound"
+      });
+    }
+    case "query-loop":
+      return attachScaffoldTemplateVariableGroups(flatVariables, {
+        alternateRenderTargets: alternateRenderTargetsGroup,
+        compound: {
+          enabled: false,
+          persistenceEnabled: false
+        },
+        persistence: {
+          enabled: false,
+          scope: "none"
+        },
+        queryLoop: queryLoopGroup,
+        shared,
+        template: {
+          description: spec.template.description
+        },
+        templateFamily: "query-loop"
+      });
+    default: {
+      const unreachableTemplateFamily = spec.template.family;
+      throw new Error(`Unhandled scaffold template family: ${unreachableTemplateFamily}`);
+    }
+  }
 }
 // ../wp-typia-project-tools/src/runtime/built-in-block-non-ts-artifacts.ts
 var BASIC_STYLE_TEMPLATE = `/**
@@ -15130,7 +15356,8 @@ function buildInteractivityCodeArtifacts(variables) {
 function buildCompoundCodeArtifacts(variables) {
   const parentBasePath = `src/blocks/${variables.slugKebabCase}`;
   const childBasePath = `src/blocks/${variables.slugKebabCase}-item`;
-  const compoundPersistenceEnabled = variables.compoundPersistenceEnabled === "true";
+  const compoundGroup = getScaffoldTemplateVariableGroups(variables).compound;
+  const compoundPersistenceEnabled = compoundGroup.enabled && compoundGroup.persistenceEnabled;
   return ensureUniqueArtifactPaths([
     createCodeArtifact("src/hooks.ts", SHARED_HOOKS_TEMPLATE, variables),
     ...createTypedJsonWrapperArtifacts(parentBasePath, variables),
@@ -15548,7 +15775,7 @@ function getTemplateVariables(templateId, answers) {
   const compoundPersistenceEnabled = templateId === "persistence" ? true : templateId === "compound" ? Boolean(answers.dataStorageMode || answers.persistencePolicy) : false;
   const dataStorageMode = templateId === "persistence" || compoundPersistenceEnabled ? answers.dataStorageMode ?? "custom-table" : "custom-table";
   const persistencePolicy = templateId === "persistence" || compoundPersistenceEnabled ? answers.persistencePolicy ?? "authenticated" : "authenticated";
-  return {
+  const flatVariables = {
     alternateRenderTargetsCsv: "",
     alternateRenderTargetsJson: "[]",
     apiClientPackageVersion,
@@ -15614,6 +15841,62 @@ function getTemplateVariables(templateId, answers) {
     titleCase: pascalCase,
     persistencePolicy
   };
+  return attachScaffoldTemplateVariableGroups(flatVariables, {
+    alternateRenderTargets: {
+      csv: "",
+      enabled: false,
+      hasEmail: false,
+      hasMjml: false,
+      hasPlainText: false,
+      json: "[]",
+      targets: []
+    },
+    compound: {
+      enabled: false,
+      persistenceEnabled: false
+    },
+    persistence: {
+      enabled: false,
+      scope: "none"
+    },
+    queryLoop: {
+      enabled: false
+    },
+    shared: {
+      author: answers.author.trim(),
+      blockMetadataVersion: BUILTIN_BLOCK_METADATA_VERSION,
+      category: metadataDefaults?.category ?? template?.defaultCategory ?? "widgets",
+      cssClassName,
+      description,
+      descriptionJson: JSON.stringify(description),
+      frontendCssClassName: buildFrontendCssClassName(cssClassName),
+      icon: metadataDefaults?.icon ?? "smiley",
+      keyword: slug.replace(/-/g, " "),
+      namespace,
+      pascalCase,
+      phpPrefix,
+      phpPrefixUpper,
+      slug,
+      slugCamelCase: pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1),
+      slugKebabCase: slug,
+      slugSnakeCase,
+      textDomain,
+      title,
+      titleCase: pascalCase,
+      titleJson: JSON.stringify(title),
+      versions: {
+        apiClient: apiClientPackageVersion,
+        blockRuntime: blockRuntimePackageVersion,
+        blockTypes: blockTypesPackageVersion,
+        projectTools: projectToolsPackageVersion,
+        rest: restPackageVersion
+      }
+    },
+    template: {
+      description: template?.description ?? "External scaffold template variables"
+    },
+    templateFamily: "external"
+  });
 }
 
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
@@ -15767,19 +16050,20 @@ async function scaffoldProject({
   });
   const readmePath = path17.join(projectDir, "README.md");
   if (!fs14.existsSync(readmePath)) {
-    await fsp11.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
+    await fsp10.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 = fs14.existsSync(gitignorePath) ? await fsp11.readFile(gitignorePath, "utf8") : "";
-  await fsp11.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
+  const existingGitignore = fs14.existsSync(gitignorePath) ? await fsp10.readFile(gitignorePath, "utf8") : "";
+  await fsp10.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
   await normalizePackageJson(projectDir, resolvedPackageManager);
   if (isBuiltInTemplate) {
+    const variableGroups = getScaffoldTemplateVariableGroups(variables);
     await applyGeneratedProjectDxPackageJson({
-      compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true",
+      compoundPersistenceEnabled: variableGroups.compound.enabled && variableGroups.compound.persistenceEnabled,
       packageManager: resolvedPackageManager,
       projectDir,
       templateId: resolvedTemplateId,
@@ -15855,4 +16139,4 @@ async function resolveOptionalInteractiveExternalLayerId({
 
 export { syncPersistenceRestArtifacts, copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, getPrimaryDevelopmentScript, getOptionalOnboardingSteps, getOptionalOnboardingNote, formatNonEmptyTargetDirectoryError, parseTemplateLocator, resolveExternalTemplateLayers, resolveTemplateSeed, normalizeOptionalCliString, resolveLocalCliPathOption, assertExternalLayerCompositionOptions, assertBuiltInTemplateVariantAllowed, parseAlternateRenderTargets, parseCompoundInnerBlocksPreset, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
 
-//# debugId=23F201B1C2B788B264756E2164756E21
+//# debugId=95394D76AFA9A70D64756E2164756E21