@wp-typia/project-tools 0.22.7 → 0.22.9

package/dist/runtime/index.d.ts

@@ -5,6 +5,7 @@
  * CLI while keeping reusable project logic out of the CLI package itself.
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `getWorkspaceBlockSelectOptionsAsync`,
  * `runAddBlockCommand`, `runAddBlockStyleCommand`,
  * `runAddBlockTransformCommand`, `runAddVariationCommand`,
  * `runAddPatternCommand`, `runAddBindingSourceCommand`,
@@ -29,11 +30,13 @@ export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJso
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 export type { EndpointAuthIntent, EndpointOpenApiAuthMode, EndpointOpenApiContractDocument, EndpointOpenApiDocumentOptions, EndpointOpenApiEndpointDefinition, EndpointOpenApiMethod, EndpointWordPressAuthDefinition, EndpointWordPressAuthMechanism, JsonSchemaDocument, JsonSchemaProjectionProfile, JsonSchemaObject, NormalizedEndpointAuthDefinition, OpenApiDocument, OpenApiInfo, OpenApiOperation, OpenApiParameter, OpenApiPathItem, OpenApiSecurityScheme, } from "./schema-core.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
+export { suggestCloseId } from "./id-suggestions.js";
+export type { SuggestCloseIdOptions } from "./id-suggestions.js";
 export { clearPackageVersionsCache, getPackageVersions, invalidatePackageVersionsCache, } from "./package-versions.js";
 export type { PackageVersions } from "./package-versions.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
 export { EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, pruneExternalTemplateCache, } from "./template-source-cache.js";
 export type { ExternalTemplateCachePruneOptions, ExternalTemplateCachePruneResult, } from "./template-source-cache.js";
 export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
-export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
-export type { CliDiagnosticCode, CliDiagnosticCodeError, CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export type { CliDiagnosticCode, CliDiagnosticCodeError, CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, WorkspaceBlockSelectOption, } from "./cli-core.js";

package/dist/runtime/index.js

@@ -5,6 +5,7 @@
  * CLI while keeping reusable project logic out of the CLI package itself.
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `getWorkspaceBlockSelectOptionsAsync`,
  * `runAddBlockCommand`, `runAddBlockStyleCommand`,
  * `runAddBlockTransformCommand`, `runAddVariationCommand`,
  * `runAddPatternCommand`, `runAddBindingSourceCommand`,
@@ -23,8 +24,9 @@ export { parseWorkspacePackageManagerId, resolveWorkspaceProject, tryResolveWork
 export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, } from "./schema-core.js";
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
+export { suggestCloseId } from "./id-suggestions.js";
 export { clearPackageVersionsCache, getPackageVersions, invalidatePackageVersionsCache, } from "./package-versions.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
 export { EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, pruneExternalTemplateCache, } from "./template-source-cache.js";
 export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
-export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/migration-maintenance-verify.js

@@ -76,6 +76,8 @@ function recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck)
         return;
     }
     try {
+        // Maintenance verification is intentionally synchronous so it can compare
+        // migration state against a single inventory snapshot.
         const inventory = readWorkspaceInventory(workspace.projectDir);
         const expectedTargets = inventory.blocks.map((block) => `${workspace.workspace.namespace}/${block.slug}`);
         const configuredTargets = state.blocks.map((block) => block.blockName);

package/dist/runtime/package-versions.js

@@ -58,10 +58,23 @@ function createContentFingerprint(source) {
     }
     return (hash >>> 0).toString(16);
 }
+function readPackageManifestFile(packageJsonPath) {
+    const fileDescriptor = fs.openSync(packageJsonPath, 'r');
+    try {
+        // Keep cache metadata and manifest contents tied to one opened file, so a
+        // concurrent path replacement cannot mix stats from one manifest with
+        // contents from another. The content fingerprint remains the final guard.
+        const stats = fs.fstatSync(fileDescriptor);
+        const source = fs.readFileSync(fileDescriptor, 'utf8');
+        return { source, stats };
+    }
+    finally {
+        fs.closeSync(fileDescriptor);
+    }
+}
 function resolvePackageManifestLocation(packageJsonPath) {
     try {
-        const stats = fs.statSync(packageJsonPath);
-        const source = fs.readFileSync(packageJsonPath, 'utf8');
+        const { source, stats } = readPackageManifestFile(packageJsonPath);
         return {
             cacheKey: `file:${packageJsonPath}:${stats.ino}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.size}:${createContentFingerprint(source)}`,
             packageJsonPath,

package/dist/runtime/php-utils.js

@@ -142,6 +142,9 @@ function matchesPhpFunctionCallAt(source, index, functionName) {
 function createPhpScannerState() {
     return {
         heredocDelimiter: "",
+        interpolationComment: "",
+        interpolationDepth: 0,
+        interpolationQuote: "",
         mode: "code",
     };
 }
@@ -165,11 +168,74 @@ function advancePhpScanner(source, index, state) {
         if (character === "\\") {
             return { ambiguous: false, inCode: false, index: index + 2 };
         }
+        if (state.mode === "double-quoted" &&
+            character === "{" &&
+            source[index + 1] === "$") {
+            state.mode = "double-quoted-interpolation";
+            state.interpolationComment = "";
+            state.interpolationDepth = 1;
+            state.interpolationQuote = "";
+            return { ambiguous: false, inCode: false, index: index + 2 };
+        }
         if (character === quote) {
             state.mode = "code";
         }
         return { ambiguous: false, inCode: false, index: index + 1 };
     }
+    if (state.mode === "double-quoted-interpolation") {
+        if (state.interpolationQuote) {
+            if (character === "\\") {
+                return { ambiguous: false, inCode: false, index: index + 2 };
+            }
+            if (character === state.interpolationQuote) {
+                state.interpolationQuote = "";
+            }
+            return { ambiguous: false, inCode: false, index: index + 1 };
+        }
+        if (state.interpolationComment === "line") {
+            if (character === "\r" || character === "\n") {
+                state.interpolationComment = "";
+            }
+            return { ambiguous: false, inCode: false, index: index + 1 };
+        }
+        if (state.interpolationComment === "block") {
+            if (character === "*" && source[index + 1] === "/") {
+                state.interpolationComment = "";
+                return { ambiguous: false, inCode: false, index: index + 2 };
+            }
+            return { ambiguous: false, inCode: false, index: index + 1 };
+        }
+        if (character === "/" && source[index + 1] === "/") {
+            state.interpolationComment = "line";
+            return { ambiguous: false, inCode: false, index: index + 2 };
+        }
+        if (character === "#" && source[index + 1] !== "[") {
+            state.interpolationComment = "line";
+            return { ambiguous: false, inCode: false, index: index + 1 };
+        }
+        if (character === "/" && source[index + 1] === "*") {
+            state.interpolationComment = "block";
+            return { ambiguous: false, inCode: false, index: index + 2 };
+        }
+        if (character === "'" || character === '"') {
+            state.interpolationQuote = character;
+            return { ambiguous: false, inCode: false, index: index + 1 };
+        }
+        if (character === "{") {
+            state.interpolationDepth += 1;
+            return { ambiguous: false, inCode: false, index: index + 1 };
+        }
+        if (character === "}") {
+            state.interpolationDepth -= 1;
+            if (state.interpolationDepth <= 0) {
+                state.interpolationComment = "";
+                state.interpolationDepth = 0;
+                state.mode = "double-quoted";
+            }
+            return { ambiguous: false, inCode: false, index: index + 1 };
+        }
+        return { ambiguous: false, inCode: false, index: index + 1 };
+    }
     if (state.mode === "line-comment") {
         if (character === "\r" || character === "\n") {
             state.mode = "code";

package/dist/runtime/scaffold-answer-resolution.js

@@ -1,23 +1,11 @@
 import { execSync } from 'node:child_process';
-import path from 'node:path';
 import { PACKAGE_MANAGER_IDS, getPackageManager, } from './package-managers.js';
 import { normalizeBlockSlug, resolveScaffoldIdentifiers, validateBlockSlug, validateNamespace, } from './scaffold-identifiers.js';
 import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from './cli-diagnostics.js';
-import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, TEMPLATE_IDS, getTemplateById, isBuiltInTemplateId, } from './template-registry.js';
-import { getRemovedBuiltInTemplateMessage, isRemovedBuiltInTemplateId, } from './template-defaults.js';
-import { parseNpmTemplateLocator } from './template-source-locators.js';
+import { getTemplateById, isBuiltInTemplateId, } from './template-registry.js';
+import { CREATE_TEMPLATE_SELECTION_HINT, validateExplicitCreateTemplateId, } from './create-template-validation.js';
 import { toSnakeCase, toTitleCase, } from './string-case.js';
-const WORKSPACE_TEMPLATE_ALIAS = 'workspace';
-const TEMPLATE_SELECTION_HINT = `--template <${[
-    ...TEMPLATE_IDS,
-    WORKSPACE_TEMPLATE_ALIAS,
-].join('|')}|./path|github:owner/repo/path[#ref]|npm-package>`;
-const TEMPLATE_SUGGESTION_IDS = [...TEMPLATE_IDS, WORKSPACE_TEMPLATE_ALIAS];
 const QUERY_POST_TYPE_RULE = 'Use lowercase, 1-20 chars, and only a-z, 0-9, "_" or "-".';
-const USER_FACING_TEMPLATE_IDS = [
-    ...TEMPLATE_IDS,
-    WORKSPACE_TEMPLATE_ALIAS,
-];
 /**
  * Detect the current author name from local Git config.
  *
@@ -80,80 +68,6 @@ function normalizeQueryPostType(value) {
     }
     return value.trim().toLowerCase();
 }
-function normalizeTemplateSelection(templateId) {
-    return templateId === WORKSPACE_TEMPLATE_ALIAS
-        ? OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE
-        : templateId;
-}
-function looksLikeWindowsAbsoluteTemplatePath(templateId) {
-    return /^[a-z]:[\\/]/iu.test(templateId) || /^\\\\[^\\]+\\[^\\]+/u.test(templateId);
-}
-function looksLikeExplicitNonNpmExternalTemplateLocator(templateId) {
-    return (path.isAbsolute(templateId) ||
-        looksLikeWindowsAbsoluteTemplatePath(templateId) ||
-        templateId.startsWith('./') ||
-        templateId.startsWith('../') ||
-        templateId.startsWith('@') ||
-        templateId.startsWith('github:') ||
-        templateId.includes('/'));
-}
-function looksLikeExplicitExternalTemplateLocator(templateId) {
-    return (looksLikeExplicitNonNpmExternalTemplateLocator(templateId) ||
-        parseNpmTemplateLocator(templateId) !== null);
-}
-function getEditDistance(left, right) {
-    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
-    const current = new Array(right.length + 1);
-    for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
-        current[0] = leftIndex + 1;
-        for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
-            const substitutionCost = left[leftIndex] === right[rightIndex] ? 0 : 1;
-            current[rightIndex + 1] = Math.min(current[rightIndex] + 1, previous[rightIndex + 1] + 1, previous[rightIndex] + substitutionCost);
-        }
-        for (let index = 0; index < current.length; index += 1) {
-            previous[index] = current[index];
-        }
-    }
-    return previous[right.length];
-}
-function findMistypedBuiltInTemplateSuggestion(templateId) {
-    const normalizedTemplateId = templateId.trim().toLowerCase();
-    if (normalizedTemplateId.length === 0 ||
-        looksLikeExplicitNonNpmExternalTemplateLocator(normalizedTemplateId)) {
-        return null;
-    }
-    let bestCandidate = null;
-    for (const candidateId of TEMPLATE_SUGGESTION_IDS) {
-        const distance = getEditDistance(normalizedTemplateId, candidateId);
-        if (bestCandidate === null ||
-            distance < bestCandidate.distance) {
-            bestCandidate = {
-                distance,
-                id: candidateId,
-            };
-        }
-    }
-    return bestCandidate && bestCandidate.distance <= 2
-        ? bestCandidate.id
-        : null;
-}
-function getMistypedBuiltInTemplateMessage(templateId) {
-    const suggestion = findMistypedBuiltInTemplateSuggestion(templateId);
-    if (!suggestion) {
-        return null;
-    }
-    const suggestionDescription = suggestion === WORKSPACE_TEMPLATE_ALIAS
-        ? 'official workspace scaffold'
-        : 'built-in scaffold';
-    return `Unknown template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\` for the ${suggestionDescription}, or pass a local path, \`github:owner/repo/path[#ref]\`, or an npm package spec for an external template.`;
-}
-function getUnknownTemplateMessage(templateId) {
-    return [
-        `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS.join(', ')}.`,
-        'Run `wp-typia templates list` to inspect available templates.',
-        'Pass an explicit external template locator such as `./path`, `github:owner/repo/path[#ref]`, or `@scope/template` for custom templates.',
-    ].join(' ');
-}
 /**
  * Resolve the scaffold template id from flags, defaults, and interactive selection.
  *
@@ -162,32 +76,15 @@ function getUnknownTemplateMessage(templateId) {
  */
 export async function resolveTemplateId({ templateId, yes = false, isInteractive = false, selectTemplate, }) {
     if (templateId) {
-        const normalizedTemplateId = normalizeTemplateSelection(templateId);
-        if (isRemovedBuiltInTemplateId(templateId)) {
-            throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getRemovedBuiltInTemplateMessage(templateId));
-        }
-        if (normalizedTemplateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
-            return normalizedTemplateId;
-        }
-        if (isBuiltInTemplateId(normalizedTemplateId)) {
-            return getTemplateById(normalizedTemplateId).id;
-        }
-        const mistypedBuiltInTemplateMessage = getMistypedBuiltInTemplateMessage(templateId);
-        if (mistypedBuiltInTemplateMessage) {
-            throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, mistypedBuiltInTemplateMessage);
-        }
-        if (!looksLikeExplicitExternalTemplateLocator(normalizedTemplateId)) {
-            throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getUnknownTemplateMessage(templateId));
-        }
-        return normalizedTemplateId;
+        return validateExplicitCreateTemplateId(templateId);
     }
     if (yes) {
         return 'basic';
     }
     if (!isInteractive || !selectTemplate) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Template is required in non-interactive mode. Use ${TEMPLATE_SELECTION_HINT}.`);
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Template is required in non-interactive mode. Use ${CREATE_TEMPLATE_SELECTION_HINT}.`);
     }
-    return normalizeTemplateSelection(await selectTemplate());
+    return validateExplicitCreateTemplateId(await selectTemplate());
 }
 /**
  * Resolve the package manager id from flags, defaults, and interactive selection.

package/dist/runtime/scaffold-apply-utils.js

@@ -15,6 +15,7 @@ import { pathExists, readOptionalUtf8File, } from "./fs-async.js";
 import { normalizePackageJson } from "./scaffold-package-manager-files.js";
 export { applyWorkspaceMigrationCapability, isOfficialWorkspaceProject, } from "./scaffold-bootstrap.js";
 import { replaceRepositoryReferencePlaceholders, resolveScaffoldRepositoryReference, } from "./scaffold-repository-reference.js";
+import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
 export { buildGitignore, buildReadme, mergeTextLines } from "./scaffold-documents.js";
 async function reportScaffoldProgress(onProgress, event) {
     await onProgress?.(event);
@@ -103,7 +104,7 @@ async function withEphemeralScaffoldNodeModules(targetDir, callback) {
  */
 export async function seedBuiltInPersistenceArtifacts(targetDir, templateId, variables) {
     const needsPersistenceArtifacts = templateId === "persistence" ||
-        (templateId === "compound" && variables.compoundPersistenceEnabled === "true");
+        (templateId === "compound" && isCompoundPersistenceEnabled(variables));
     if (!needsPersistenceArtifacts) {
         return;
     }
@@ -256,7 +257,7 @@ export async function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir
     await fsp.writeFile(gitignorePath, mergeTextLines(gitignoreContent ?? buildGitignore(), existingGitignore), "utf8");
     await normalizePackageJson(projectDir, packageManager);
     await applyGeneratedProjectDxPackageJson({
-        compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true",
+        compoundPersistenceEnabled: isCompoundPersistenceEnabled(variables),
         packageManager,
         projectDir,
         templateId,

package/dist/runtime/scaffold-identifiers.js

@@ -1,3 +1,4 @@
+import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from "./cli-diagnostics.js";
 import { toKebabCase, toSnakeCase, } from "./string-case.js";
 const BLOCK_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
 const PHP_PREFIX_PATTERN = /^[a-z_][a-z0-9_]*$/;
@@ -27,7 +28,7 @@ export function validatePhpPrefix(input) {
 export function assertValidIdentifier(label, value, validate) {
     const result = validate(value);
     if (result !== true) {
-        throw new Error(typeof result === "string" ? `${label}: ${result}` : `${label} is invalid`);
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, typeof result === "string" ? `${label}: ${result}` : `${label} is invalid`);
     }
     return value;
 }
@@ -52,9 +53,9 @@ export function resolveNonEmptyNormalizedBlockSlug(options) {
         return normalizedSlug;
     }
     if (options.input.trim().length === 0) {
-        throw new Error(`${options.label} is required. Use \`${options.usage}\`.`);
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `${options.label} is required. Use \`${options.usage}\`.`);
     }
-    throw new Error(`${options.label} "${options.input.trim()}" normalizes to an empty slug. Use letters or numbers so wp-typia can generate a block slug.`);
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `${options.label} "${options.input.trim()}" normalizes to an empty slug. Use letters or numbers so wp-typia can generate a block slug.`);
 }
 export function resolveValidatedBlockSlug(value) {
     return assertValidIdentifier("Block slug", normalizeBlockSlug(value), validateBlockSlug);

package/dist/runtime/scaffold-template-assertions.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Revalidates target-language identifiers at the built-in template builder
+ * boundary so generated PHP and TypeScript never rely only on upstream CLI
+ * normalization.
+ */
+export declare function assertScaffoldTemplateCodeIdentifiers(view: Record<string, unknown>): void;

package/dist/runtime/scaffold-template-assertions.js

@@ -0,0 +1,33 @@
+const BLOCK_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/u;
+const PHP_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]*$/u;
+const PHP_CONSTANT_IDENTIFIER_PATTERN = /^[A-Z_][A-Z0-9_]*$/u;
+const JAVASCRIPT_IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
+const QUERY_POST_TYPE_PATTERN = /^[a-z0-9_-]{1,20}$/u;
+function assertOptionalStringPattern(view, key, pattern, description) {
+    const value = view[key];
+    if (typeof value === "undefined") {
+        return;
+    }
+    if (typeof value !== "string" || !pattern.test(value)) {
+        throw new Error(`Unsafe scaffold template variable "${key}" for ${description}: ${JSON.stringify(value)}.`);
+    }
+}
+/**
+ * Revalidates target-language identifiers at the built-in template builder
+ * boundary so generated PHP and TypeScript never rely only on upstream CLI
+ * normalization.
+ */
+export function assertScaffoldTemplateCodeIdentifiers(view) {
+    assertOptionalStringPattern(view, "namespace", BLOCK_SLUG_PATTERN, "block namespace");
+    assertOptionalStringPattern(view, "slug", BLOCK_SLUG_PATTERN, "block slug");
+    assertOptionalStringPattern(view, "slugKebabCase", BLOCK_SLUG_PATTERN, "block slug");
+    assertOptionalStringPattern(view, "textDomain", BLOCK_SLUG_PATTERN, "text domain");
+    assertOptionalStringPattern(view, "textdomain", BLOCK_SLUG_PATTERN, "text domain");
+    assertOptionalStringPattern(view, "queryPostType", QUERY_POST_TYPE_PATTERN, "query post type");
+    assertOptionalStringPattern(view, "phpPrefix", PHP_IDENTIFIER_PATTERN, "PHP identifier");
+    assertOptionalStringPattern(view, "slugSnakeCase", PHP_IDENTIFIER_PATTERN, "PHP identifier");
+    assertOptionalStringPattern(view, "phpPrefixUpper", PHP_CONSTANT_IDENTIFIER_PATTERN, "PHP constant identifier");
+    assertOptionalStringPattern(view, "pascalCase", JAVASCRIPT_IDENTIFIER_PATTERN, "JavaScript identifier");
+    assertOptionalStringPattern(view, "slugCamelCase", JAVASCRIPT_IDENTIFIER_PATTERN, "JavaScript identifier");
+    assertOptionalStringPattern(view, "titleCase", JAVASCRIPT_IDENTIFIER_PATTERN, "JavaScript identifier");
+}

package/dist/runtime/scaffold-template-variable-groups.d.ts

@@ -153,4 +153,6 @@ export type PersistenceScaffoldTemplateVariablesLike = ScaffoldTemplateVariableG
 };
 export declare function attachScaffoldTemplateVariableGroups<TVariables extends Record<string, string>>(variables: TVariables, groups: ScaffoldTemplateVariableGroups): TVariables & ScaffoldTemplateVariableGroupsCarrier;
 export declare function getScaffoldTemplateVariableGroups(variables: ScaffoldTemplateVariableGroupsCarrier): ScaffoldTemplateVariableGroups;
+export declare function isCompoundPersistenceEnabled(variables: ScaffoldTemplateVariableGroupsCarrier): boolean;
+export declare function getScaffoldAlternateRenderTargets(variables: ScaffoldTemplateVariableGroupsCarrier): ScaffoldAlternateRenderTargetVariableGroup;
 export {};

package/dist/runtime/scaffold-template-variable-groups.js

@@ -11,3 +11,10 @@ export function attachScaffoldTemplateVariableGroups(variables, groups) {
 export function getScaffoldTemplateVariableGroups(variables) {
     return variables[SCAFFOLD_TEMPLATE_VARIABLE_GROUPS];
 }
+export function isCompoundPersistenceEnabled(variables) {
+    const compound = getScaffoldTemplateVariableGroups(variables).compound;
+    return compound.enabled && compound.persistenceEnabled;
+}
+export function getScaffoldAlternateRenderTargets(variables) {
+    return getScaffoldTemplateVariableGroups(variables).alternateRenderTargets;
+}

package/dist/runtime/scaffold.js

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { getPackageManager } from "./package-managers.js";
@@ -14,6 +13,7 @@ import { BlockGeneratorService, } from "./block-generator-service.js";
 import { getTemplateVariables } from "./scaffold-template-variables.js";
 import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 import { assertExternalLayerCompositionOptions, } from "./cli-validation.js";
+import { pathExists } from "./fs-async.js";
 export const DATA_STORAGE_MODES = ["post-meta", "custom-table"];
 export const PERSISTENCE_POLICIES = ["authenticated", "public"];
 export { buildBlockCssClassName } from "./scaffold-identifiers.js";
@@ -149,7 +149,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, alterna
         title: "Finalizing scaffold output",
     });
     const readmePath = path.join(projectDir, "README.md");
-    if (!fs.existsSync(readmePath)) {
+    if (!(await pathExists(readmePath))) {
         await fsp.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
             withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
             withTestPreset: isBuiltInTemplate ? withTestPreset : false,
@@ -157,7 +157,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, alterna
         }), "utf8");
     }
     const gitignorePath = path.join(projectDir, ".gitignore");
-    const existingGitignore = fs.existsSync(gitignorePath)
+    const existingGitignore = (await pathExists(gitignorePath))
         ? await fsp.readFile(gitignorePath, "utf8")
         : "";
     await fsp.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");

package/dist/runtime/string-case.d.ts

@@ -1,10 +1,8 @@
 /**
  * Normalize arbitrary text into a kebab-case identifier.
  * Common acronym runs stay grouped, with a boundary before the next
- * capitalized word.
- * Ambiguous acronym+lowercase inputs like `URLslug` intentionally stay as one
- * word because there is no PascalCase boundary marker before the lowercase
- * suffix.
+ * capitalized word or before a narrow allow-list of lowercase WordPress slug
+ * terms. Naturalized words such as `RESTful` intentionally stay as one word.
  *
  * @param input Raw text that may contain spaces, punctuation, or camelCase.
  * @returns A lowercase kebab-case string with collapsed separators.

package/dist/runtime/string-case.js

@@ -6,7 +6,9 @@ const COMMON_ACRONYM_PREFIXES = [
     'JSON',
     'REST',
     'UUID',
+    'AJAX',
     'API',
+    'CPT',
     'CSS',
     'CTA',
     'DOM',
@@ -20,12 +22,18 @@ const COMMON_ACRONYM_PREFIXES = [
     'UI',
     'WP',
 ];
+// Keep lowercase suffix splitting narrow so naturalized words such as
+// `RESTful` remain stable while WordPress slug terms like `URLslug` read well.
+const COMMON_ACRONYM_LOWERCASE_SUFFIXES = ['slug'];
 function capitalizeSegment(segment) {
     return segment.charAt(0).toUpperCase() + segment.slice(1);
 }
 function findCommonAcronymPrefix(segment) {
     return COMMON_ACRONYM_PREFIXES.find((prefix) => segment.startsWith(prefix));
 }
+function isCommonAcronymLowercaseSuffix(suffix) {
+    return COMMON_ACRONYM_LOWERCASE_SUFFIXES.includes(suffix);
+}
 function splitKnownAcronymSegment(segment) {
     const prefixes = [];
     let remaining = segment;
@@ -38,6 +46,9 @@ function splitKnownAcronymSegment(segment) {
         if (/^[A-Z][a-z]/.test(suffix)) {
             return [...prefixes, prefix, suffix].join('-');
         }
+        if (/^[a-z]+$/.test(suffix) && isCommonAcronymLowercaseSuffix(suffix)) {
+            return [...prefixes, prefix, suffix].join('-');
+        }
         if (!findCommonAcronymPrefix(suffix)) {
             break;
         }
@@ -52,10 +63,8 @@ function splitAcronymBoundary(value) {
 /**
  * Normalize arbitrary text into a kebab-case identifier.
  * Common acronym runs stay grouped, with a boundary before the next
- * capitalized word.
- * Ambiguous acronym+lowercase inputs like `URLslug` intentionally stay as one
- * word because there is no PascalCase boundary marker before the lowercase
- * suffix.
+ * capitalized word or before a narrow allow-list of lowercase WordPress slug
+ * terms. Naturalized words such as `RESTful` intentionally stay as one word.
  *
  * @param input Raw text that may contain spaces, punctuation, or camelCase.
  * @returns A lowercase kebab-case string with collapsed separators.

package/dist/runtime/template-builtins.js

@@ -1,6 +1,6 @@
-import fs from "node:fs";
 import path from "node:path";
 import { promises as fsp } from "node:fs";
+import { pathExists } from "./fs-async.js";
 import { createManagedTempRoot } from "./temp-roots.js";
 import { getTemplateById, SHARED_BASE_TEMPLATE_ROOT, SHARED_COMPOUND_TEMPLATE_ROOT, SHARED_MIGRATION_UI_TEMPLATE_ROOT, SHARED_PERSISTENCE_TEMPLATE_ROOT, SHARED_PRESET_TEMPLATE_ROOT, SHARED_REST_HELPER_TEMPLATE_ROOT, SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
 const BUILT_IN_SHARED_TEMPLATE_LAYERS = Object.freeze([
@@ -138,20 +138,23 @@ export function isOmittableBuiltInTemplateLayerDir(templateId, layerDir) {
     return (OMITTABLE_BUILT_IN_OVERLAY_TEMPLATE_IDS.has(templateId) &&
         layerDir === getTemplateById(templateId).templateDir);
 }
-function resolveMaterializedTemplateLayerDirs(templateId, layerDirs) {
-    return layerDirs.flatMap((layerDir) => {
-        if (fs.existsSync(layerDir)) {
-            return [layerDir];
+async function resolveMaterializedTemplateLayerDirs(templateId, layerDirs) {
+    const materializedLayerDirs = [];
+    for (const layerDir of layerDirs) {
+        if (await pathExists(layerDir)) {
+            materializedLayerDirs.push(layerDir);
+            continue;
         }
         if (isOmittableBuiltInTemplateLayerDir(templateId, layerDir)) {
-            return [];
+            continue;
         }
         throw new Error(`Built-in template layer is missing: ${layerDir}`);
-    });
+    }
+    return materializedLayerDirs;
 }
 async function materializeBuiltInTemplateSource(templateId, layerDirs) {
     const template = getTemplateById(templateId);
-    const materializedLayerDirs = resolveMaterializedTemplateLayerDirs(templateId, layerDirs);
+    const materializedLayerDirs = await resolveMaterializedTemplateLayerDirs(templateId, layerDirs);
     const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-");
     const templateDir = path.join(tempRoot, templateId);
     try {

package/dist/runtime/template-layers.js

@@ -1,6 +1,6 @@
-import fs from "node:fs";
 import path from "node:path";
 import { promises as fsp } from "node:fs";
+import { pathExists } from "./fs-async.js";
 import { isPlainObject } from "./object-utils.js";
 import { getBuiltInSharedTemplateLayerDir, isBuiltInSharedTemplateLayerId, } from "./template-builtins.js";
 import { listInterpolatedDirectoryOutputs } from "./template-render.js";
@@ -56,7 +56,7 @@ function parseLayerDefinition(layerId, value) {
 }
 export async function loadExternalTemplateLayerManifest(sourceRoot) {
     const manifestPath = path.join(sourceRoot, TEMPLATE_LAYER_MANIFEST_FILENAME);
-    if (!fs.existsSync(manifestPath)) {
+    if (!(await pathExists(manifestPath))) {
         return null;
     }
     const raw = JSON.parse(await fsp.readFile(manifestPath, "utf8"));

package/dist/runtime/template-source-cache-policy.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Environment variable that disables external template cache reads and writes.
+ *
+ * Set to `0`, `false`, `no`, or `off` to bypass the cache.
+ */
+export declare const EXTERNAL_TEMPLATE_CACHE_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE";
+/**
+ * Environment variable that overrides the external template cache root.
+ */
+export declare const EXTERNAL_TEMPLATE_CACHE_DIR_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR";
+/**
+ * Environment variable that enables TTL-based external template cache pruning.
+ *
+ * Unset, empty, zero, negative, and non-numeric values keep pruning disabled.
+ */
+export declare const EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_TTL_DAYS";
+/**
+ * Environment variable that overrides how often TTL pruning may scan the cache.
+ *
+ * Unset values use the default interval. Zero, negative, and non-numeric values
+ * disable scan throttling.
+ */
+export declare const EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS";
+/**
+ * Checks whether remote external template source caching is enabled.
+ *
+ * Caching is enabled by default. Set `WP_TYPIA_EXTERNAL_TEMPLATE_CACHE` to
+ * `0`, `false`, `no`, or `off` to force uncached resolution.
+ *
+ * @param env Environment object to inspect, defaulting to `process.env`.
+ * @returns Whether external template source cache reads and writes are enabled.
+ */
+export declare function isExternalTemplateCacheEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolves the external template source cache root directory.
+ *
+ * `WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR` overrides the location. Without an
+ * override, wp-typia uses a per-user `wp-typia-template-source-cache-*`
+ * directory inside the operating system temp directory.
+ *
+ * @param env Environment object to inspect, defaulting to `process.env`.
+ * @returns Absolute cache root directory path.
+ */
+export declare function getExternalTemplateCacheRoot(env?: NodeJS.ProcessEnv): string;
+export declare function resolveExternalTemplateCacheTtlMs(options?: {
+    env?: NodeJS.ProcessEnv;
+    ttlDays?: number;
+}): number | null;
+export declare function resolveExternalTemplateCachePruneIntervalMs(options?: {
+    env?: NodeJS.ProcessEnv;
+    pruneIntervalMs?: number;
+}): number | null;
+export declare function getExternalTemplateCacheNowMs(now: Date | number | undefined): number;