@wp-typia/project-tools 0.22.6 → 0.22.8

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/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

@@ -1,10 +1,14 @@
+// Keep this list fixed so generated slugs and file paths do not drift when
+// project config changes. Domain-specific acronyms should use separators.
 const COMMON_ACRONYM_PREFIXES = [
     'HTML',
     'HTTP',
     'JSON',
     'REST',
     'UUID',
+    'AJAX',
     'API',
+    'CPT',
     'CSS',
     'CTA',
     'DOM',
@@ -18,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;
@@ -36,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;
         }
@@ -50,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-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;

package/dist/runtime/template-source-cache-policy.js

@@ -0,0 +1,135 @@
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Environment variable that disables external template cache reads and writes.
+ *
+ * Set to `0`, `false`, `no`, or `off` to bypass the cache.
+ */
+export const EXTERNAL_TEMPLATE_CACHE_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE';
+/**
+ * Environment variable that overrides the external template cache root.
+ */
+export 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 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 const EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS';
+/**
+ * Milliseconds in one TTL day.
+ */
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+/**
+ * Default minimum interval between full external template cache prune scans.
+ */
+const DEFAULT_CACHE_PRUNE_INTERVAL_MS = 60 * 60 * 1000;
+/**
+ * Normalized environment values that disable the cache.
+ */
+const DISABLED_CACHE_VALUES = new Set(['0', 'false', 'no', 'off']);
+/**
+ * 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 function isExternalTemplateCacheEnabled(env = process.env) {
+    const rawValue = env[EXTERNAL_TEMPLATE_CACHE_ENV];
+    if (rawValue === undefined) {
+        return true;
+    }
+    return !DISABLED_CACHE_VALUES.has(rawValue.trim().toLowerCase());
+}
+/**
+ * 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 function getExternalTemplateCacheRoot(env = process.env) {
+    const configuredCacheDir = env[EXTERNAL_TEMPLATE_CACHE_DIR_ENV]?.trim();
+    if (configuredCacheDir) {
+        return path.resolve(configuredCacheDir);
+    }
+    return path.join(os.tmpdir(), `wp-typia-template-source-cache-${getCurrentUserCacheSegment()}`);
+}
+function parseExternalTemplateCacheTtlDays(value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        return null;
+    }
+    const ttlDays = typeof value === 'number' ? value : Number(value.trim());
+    if (!Number.isFinite(ttlDays) || ttlDays <= 0) {
+        return null;
+    }
+    return ttlDays;
+}
+export function resolveExternalTemplateCacheTtlMs(options = {}) {
+    const env = options.env ?? process.env;
+    const ttlDays = options.ttlDays === undefined
+        ? parseExternalTemplateCacheTtlDays(env[EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV])
+        : parseExternalTemplateCacheTtlDays(options.ttlDays);
+    if (ttlDays === null) {
+        return null;
+    }
+    const ttlMs = ttlDays * MILLISECONDS_PER_DAY;
+    return Number.isFinite(ttlMs) ? ttlMs : null;
+}
+function parseExternalTemplateCachePruneIntervalMs(value) {
+    if (typeof value !== 'string' && typeof value !== 'number') {
+        return null;
+    }
+    const intervalMs = typeof value === 'number' ? value : Number(value.trim());
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+        return null;
+    }
+    return intervalMs;
+}
+export function resolveExternalTemplateCachePruneIntervalMs(options = {}) {
+    if (options.pruneIntervalMs !== undefined) {
+        return parseExternalTemplateCachePruneIntervalMs(options.pruneIntervalMs);
+    }
+    const env = options.env ?? process.env;
+    const envValue = env[EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV];
+    if (envValue === undefined) {
+        return DEFAULT_CACHE_PRUNE_INTERVAL_MS;
+    }
+    return parseExternalTemplateCachePruneIntervalMs(envValue);
+}
+export function getExternalTemplateCacheNowMs(now) {
+    const nowMs = now instanceof Date
+        ? now.getTime()
+        : typeof now === 'number'
+            ? now
+            : Date.now();
+    return Number.isFinite(nowMs) ? nowMs : Date.now();
+}
+function getCurrentUserCacheSegment() {
+    if (typeof process.getuid === 'function') {
+        return String(process.getuid());
+    }
+    try {
+        const safeUsername = os
+            .userInfo()
+            .username.trim()
+            .replace(/[^A-Za-z0-9._-]+/gu, '-');
+        return safeUsername.length > 0 ? safeUsername : 'user';
+    }
+    catch {
+        return 'user';
+    }
+}

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

@@ -1,26 +1,4 @@
-/**
- * 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";
+export { EXTERNAL_TEMPLATE_CACHE_DIR_ENV, EXTERNAL_TEMPLATE_CACHE_ENV, EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV, EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, getExternalTemplateCacheRoot, isExternalTemplateCacheEnabled, } from './template-source-cache-policy.js';
 /**
  * Serializable metadata recorded in the cache marker for diagnostics.
  */
@@ -125,27 +103,6 @@ export interface ExternalTemplateCachePruneResult {
      */
     ttlMs: number | null;
 }
-/**
- * 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;
 /**
  * Creates a deterministic cache key from source identity and integrity parts.
  *
@@ -187,4 +144,3 @@ export declare function findReusableExternalTemplateSourceCache(descriptor: Exte
  * @returns Cache resolution details, or `null` when caching is disabled.
  */
 export declare function resolveExternalTemplateSourceCache(descriptor: ExternalTemplateCacheDescriptor, populateSourceDir: (sourceDir: string) => Promise<void>): Promise<ExternalTemplateCacheResolution | null>;
-export {};

package/dist/runtime/template-source-cache.js

@@ -1,31 +1,9 @@
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
 import { promises as fsp } from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
-/**
- * Environment variable that disables external template cache reads and writes.
- *
- * Set to `0`, `false`, `no`, or `off` to bypass the cache.
- */
-export const EXTERNAL_TEMPLATE_CACHE_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE';
-/**
- * Environment variable that overrides the external template cache root.
- */
-export 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 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 const EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS';
+import { getNodeErrorCode, pathExists } from './fs-async.js';
+import { getExternalTemplateCacheNowMs, getExternalTemplateCacheRoot, isExternalTemplateCacheEnabled, resolveExternalTemplateCachePruneIntervalMs, resolveExternalTemplateCacheTtlMs, } from './template-source-cache-policy.js';
+export { EXTERNAL_TEMPLATE_CACHE_DIR_ENV, EXTERNAL_TEMPLATE_CACHE_ENV, EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV, EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, getExternalTemplateCacheRoot, isExternalTemplateCacheEnabled, } from './template-source-cache-policy.js';
 /**
  * Marker file written after a cache entry is fully populated.
  */
@@ -34,14 +12,6 @@ const CACHE_MARKER_FILE = 'wp-typia-template-cache.json';
  * Marker file written after a full TTL prune scan completes.
  */
 const CACHE_PRUNE_MARKER_FILE = 'wp-typia-template-cache-prune.json';
-/**
- * Milliseconds in one TTL day.
- */
-const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
-/**
- * Default minimum interval between full external template cache prune scans.
- */
-const DEFAULT_CACHE_PRUNE_INTERVAL_MS = 60 * 60 * 1000;
 /**
  * Private directory mode used for cache roots and entries on POSIX platforms.
  */
@@ -50,10 +20,6 @@ const PRIVATE_CACHE_DIRECTORY_MODE = 0o700;
  * Marker value used when URL-like metadata cannot be safely normalized.
  */
 const REDACTED_CACHE_METADATA_VALUE = '[redacted]';
-/**
- * Normalized environment values that disable the cache.
- */
-const DISABLED_CACHE_VALUES = new Set(['0', 'false', 'no', 'off']);
 /**
  * Filesystem errors that mean another writer published the same cache entry.
  */
@@ -80,80 +46,10 @@ const SAFE_CACHE_NAMESPACE_SEGMENT = /^[A-Za-z0-9_.-]+$/u;
  * Cache entries are deterministic SHA-256 digest directory names.
  */
 const SAFE_CACHE_ENTRY_SEGMENT = /^[a-f0-9]{64}$/u;
-/**
- * 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 function isExternalTemplateCacheEnabled(env = process.env) {
-    const rawValue = env[EXTERNAL_TEMPLATE_CACHE_ENV];
-    if (rawValue === undefined) {
-        return true;
-    }
-    return !DISABLED_CACHE_VALUES.has(rawValue.trim().toLowerCase());
-}
-/**
- * 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 function getExternalTemplateCacheRoot(env = process.env) {
-    const configuredCacheDir = env[EXTERNAL_TEMPLATE_CACHE_DIR_ENV]?.trim();
-    if (configuredCacheDir) {
-        return path.resolve(configuredCacheDir);
-    }
-    return path.join(os.tmpdir(), `wp-typia-template-source-cache-${getCurrentUserCacheSegment()}`);
-}
-function parseExternalTemplateCacheTtlDays(value) {
-    if (typeof value !== 'string' && typeof value !== 'number') {
-        return null;
-    }
-    const ttlDays = typeof value === 'number' ? value : Number(value.trim());
-    if (!Number.isFinite(ttlDays) || ttlDays <= 0) {
-        return null;
-    }
-    return ttlDays;
-}
-function resolveExternalTemplateCacheTtlMs(options = {}) {
-    const env = options.env ?? process.env;
-    const ttlDays = options.ttlDays === undefined
-        ? parseExternalTemplateCacheTtlDays(env[EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV])
-        : parseExternalTemplateCacheTtlDays(options.ttlDays);
-    if (ttlDays === null) {
-        return null;
-    }
-    const ttlMs = ttlDays * MILLISECONDS_PER_DAY;
-    return Number.isFinite(ttlMs) ? ttlMs : null;
-}
-function parseExternalTemplateCachePruneIntervalMs(value) {
-    if (typeof value !== 'string' && typeof value !== 'number') {
-        return null;
-    }
-    const intervalMs = typeof value === 'number' ? value : Number(value.trim());
-    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
-        return null;
-    }
-    return intervalMs;
-}
-function resolveExternalTemplateCachePruneIntervalMs(options = {}) {
-    if (options.pruneIntervalMs !== undefined) {
-        return parseExternalTemplateCachePruneIntervalMs(options.pruneIntervalMs);
-    }
-    const env = options.env ?? process.env;
-    const envValue = env[EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV];
-    if (envValue === undefined) {
-        return DEFAULT_CACHE_PRUNE_INTERVAL_MS;
-    }
-    return parseExternalTemplateCachePruneIntervalMs(envValue);
+function createTemporaryCacheEntryDirName(cacheKey) {
+    // Crypto randomness keeps concurrent cache populators from colliding on the
+    // staging directory before the final atomic rename publishes the cache entry.
+    return `.tmp-${cacheKey}-${process.pid}-${Date.now()}-${randomUUID()}`;
 }
 /**
  * Creates a deterministic cache key from source identity and integrity parts.
@@ -166,15 +62,6 @@ export function createExternalTemplateCacheKey(keyParts) {
         .update(JSON.stringify(keyParts))
         .digest('hex');
 }
-async function pathExists(filePath) {
-    try {
-        await fsp.access(filePath, fs.constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function isDirectoryPath(directory) {
     try {
         const stats = await fsp.lstat(directory);
@@ -184,11 +71,6 @@ async function isDirectoryPath(directory) {
         return false;
     }
 }
-function getNodeErrorCode(error) {
-    return typeof error === 'object' && error !== null && 'code' in error
-        ? String(error.code)
-        : '';
-}
 async function removeTemporaryCacheEntry(entryDir) {
     try {
         await fsp.rm(entryDir, { force: true, recursive: true });
@@ -197,21 +79,6 @@ async function removeTemporaryCacheEntry(entryDir) {
         // Cache cleanup is best-effort; the caller can still continue uncached.
     }
 }
-function getCurrentUserCacheSegment() {
-    if (typeof process.getuid === 'function') {
-        return String(process.getuid());
-    }
-    try {
-        const safeUsername = os
-            .userInfo()
-            .username.trim()
-            .replace(/[^A-Za-z0-9._-]+/gu, '-');
-        return safeUsername.length > 0 ? safeUsername : 'user';
-    }
-    catch {
-        return 'user';
-    }
-}
 function getCurrentUid() {
     return typeof process.getuid === 'function' ? process.getuid() : null;
 }
@@ -360,14 +227,6 @@ async function readCacheEntryMarker(markerPath) {
 function cacheMetadataMatches(actual, expected) {
     return Object.entries(expected).every(([key, value]) => actual[key] === value);
 }
-function getExternalTemplateCacheNowMs(now) {
-    const nowMs = now instanceof Date
-        ? now.getTime()
-        : typeof now === 'number'
-            ? now
-            : Date.now();
-    return Number.isFinite(nowMs) ? nowMs : Date.now();
-}
 function isCacheEntryFreshForTtl(createdAtMs, nowMs, ttlMs) {
     return ttlMs === null || createdAtMs >= nowMs - ttlMs;
 }
@@ -673,9 +532,7 @@ export async function resolveExternalTemplateSourceCache(descriptor, populateSou
     if (existingMarker) {
         await removeCacheEntryWithinRoot(cacheRoot, entryDir);
     }
-    const temporaryEntryDir = path.join(namespaceDir, `.tmp-${cacheKey}-${process.pid}-${Date.now()}-${Math.random()
-        .toString(16)
-        .slice(2)}`);
+    const temporaryEntryDir = path.join(namespaceDir, createTemporaryCacheEntryDirName(cacheKey));
     const temporarySourceDir = path.join(temporaryEntryDir, 'source');
     let populateFailed = false;
     try {

package/dist/runtime/ts-property-names.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+/**
+ * Extract the literal text for TypeScript property names this runtime supports.
+ *
+ * Computed property names are intentionally not resolved because their runtime
+ * values are not statically knowable from the syntax node alone.
+ *
+ * @param name TypeScript property name node.
+ * @returns Identifier, string-literal, or numeric-literal text; otherwise `null`.
+ */
+export declare function getPropertyNameText(name: ts.PropertyName): string | null;

package/dist/runtime/ts-property-names.js

@@ -0,0 +1,16 @@
+import ts from "typescript";
+/**
+ * Extract the literal text for TypeScript property names this runtime supports.
+ *
+ * Computed property names are intentionally not resolved because their runtime
+ * values are not statically knowable from the syntax node alone.
+ *
+ * @param name TypeScript property name node.
+ * @returns Identifier, string-literal, or numeric-literal text; otherwise `null`.
+ */
+export function getPropertyNameText(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}