@wp-typia/project-tools 0.20.0 → 0.20.2

package/dist/runtime/cli-add-block.js

@@ -281,7 +281,7 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
         throw new Error("`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
     }
     if (!isAddBlockTemplateId(templateId)) {
-        throw new Error(`Unknown add-block template "${templateId}". Expected one of: ${ADD_BLOCK_TEMPLATE_IDS.join(", ")}`);
+        throw new Error(`Unknown add-block template "${templateId}". Expected one of: ${ADD_BLOCK_TEMPLATE_IDS.join(", ")}. Run \`wp-typia templates list\` to inspect available templates.`);
     }
     const resolvedTemplateId = templateId;
     assertPersistenceFlagsAllowed(resolvedTemplateId, {

package/dist/runtime/cli-add-workspace-ability.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { syncTypeSchemas } from "@wp-typia/block-runtime/metadata-core";
+import semver from "semver";
 import { appendWorkspaceInventoryEntries, readWorkspaceInventory, } from "./workspace-inventory.js";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { toTitleCase } from "./string-case.js";
@@ -12,14 +13,63 @@ const ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
 const ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
 const ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end";
 const ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start";
-const WP_ABILITIES_SCRIPT_HANDLE = "wp-abilities";
-const WP_CORE_ABILITIES_SCRIPT_HANDLE = "wp-core-abilities";
+const WP_ABILITIES_PACKAGE_VERSION = "^0.10.0";
+const WP_CORE_ABILITIES_PACKAGE_VERSION = "^0.9.0";
+const WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities";
+const WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 function quotePhpString(value) {
     return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
 }
+function findPhpFunctionRange(source, functionName) {
+    const functionPattern = new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\([^)]*\\)\\s*\\{`, "u");
+    const match = functionPattern.exec(source);
+    if (!match) {
+        return null;
+    }
+    const openingBraceIndex = match.index + match[0].length - 1;
+    let depth = 0;
+    for (let index = openingBraceIndex; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === "{") {
+            depth += 1;
+        }
+        else if (character === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                const end = index + 1;
+                return {
+                    end,
+                    source: source.slice(match.index, end),
+                    start: match.index,
+                };
+            }
+        }
+    }
+    return null;
+}
+function replacePhpFunctionDefinition(source, functionName, replacement) {
+    const functionRange = findPhpFunctionRange(source, functionName);
+    if (!functionRange) {
+        return source;
+    }
+    return `${source.slice(0, functionRange.start)}${replacement.trimStart()}${source.slice(functionRange.end)}`;
+}
+function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
+    if (!existingVersion) {
+        return requiredVersion;
+    }
+    const existingMinimum = semver.minVersion(existingVersion);
+    const requiredMinimum = semver.minVersion(requiredVersion);
+    if (!existingMinimum || !requiredMinimum) {
+        return requiredVersion;
+    }
+    return semver.gte(existingMinimum, requiredMinimum)
+        ? existingVersion
+        : requiredVersion;
+}
 function toPascalCaseFromAbilitySlug(abilitySlug) {
     return normalizeBlockSlug(abilitySlug)
         .split("-")
@@ -98,7 +148,14 @@ function buildAbilityDataSource(abilitySlug) {
         .replace(/[^A-Z0-9]+/gu, "_")
         .replace(/_{2,}/gu, "_")
         .replace(/^_|_$/gu, "");
-    return `import abilityConfig from './ability.config.json';
+    return `import {
+\texecuteAbility,
+\tgetAbilities,
+\tgetAbility as getRegisteredAbility,
+} from '@wordpress/abilities';
+import '@wordpress/core-abilities';
+
+import abilityConfig from './ability.config.json';
 
 import type { ${pascalCase}AbilityInput, ${pascalCase}AbilityOutput } from './types';
 
@@ -110,55 +167,56 @@ interface WordPressAbilityDefinition {
 \tname?: string;
 }
 
-interface WordPressAbilitiesClient {
-\texecuteAbility( name: string, input?: unknown ): Promise< unknown >;
-\tgetAbilities( args?: { category?: string } ): WordPressAbilityDefinition[];
-\tgetAbility( name: string ): WordPressAbilityDefinition | undefined;
-}
-
-const ABILITY_CLIENT_UNAVAILABLE_MESSAGE =
-\t'The WordPress abilities client is unavailable on this screen. Ensure the Abilities API and @wordpress/core-abilities integration are loaded before using this scaffold.';
-
 export const ${abilityConstBase}_ABILITY = abilityConfig;
 export const ${abilityConstBase}_ABILITY_CATEGORY = abilityConfig.category;
 export const ${abilityConstBase}_ABILITY_ID = abilityConfig.abilityId;
 export const ${abilityConstBase}_ABILITY_META = abilityConfig.meta;
+const ABILITY_DISCOVERY_POLL_INTERVAL_MS = 50;
+const ABILITY_DISCOVERY_TIMEOUT_MS = 5000;
 
 export type {
 \t${pascalCase}AbilityInput,
 \t${pascalCase}AbilityOutput,
 };
 
-function resolveAbilitiesClient(): WordPressAbilitiesClient {
-\tconst runtime = globalThis as typeof globalThis & {
-\t\twindow?: {
-\t\t\twp?: {
-\t\t\t\tabilities?: WordPressAbilitiesClient;
-\t\t\t};
-\t\t};
-\t};
-\tconst client = runtime.window?.wp?.abilities;
-\tif ( ! client ) {
-\t\tthrow new Error( ABILITY_CLIENT_UNAVAILABLE_MESSAGE );
-\t}
+function sleep( milliseconds: number ): Promise< void > {
+\treturn new Promise( ( resolve ) => {
+\t\tsetTimeout( resolve, milliseconds );
+\t} );
+}
 
-\treturn client;
+async function waitFor${pascalCase}AbilityRegistration(): Promise< void > {
+\tconst deadline = Date.now() + ABILITY_DISCOVERY_TIMEOUT_MS;
+\twhile ( ! getRegisteredAbility( ${abilityConstBase}_ABILITY_ID ) ) {
+\t\tif ( Date.now() >= deadline ) {
+\t\t\treturn;
+\t\t}
+
+\t\tawait sleep( ABILITY_DISCOVERY_POLL_INTERVAL_MS );
+\t}
 }
 
-export function list${pascalCase}CategoryAbilities(): WordPressAbilityDefinition[] {
-\treturn resolveAbilitiesClient().getAbilities( {
+export async function list${pascalCase}CategoryAbilities(): Promise< WordPressAbilityDefinition[] > {
+\tawait waitFor${pascalCase}AbilityRegistration();
+
+\treturn getAbilities( {
 \t\tcategory: ${abilityConstBase}_ABILITY_CATEGORY.slug,
-\t} );
+\t} ) as WordPressAbilityDefinition[];
 }
 
-export function get${pascalCase}Ability():
+export async function get${pascalCase}Ability(): Promise<
 \t| WordPressAbilityDefinition
-\t| undefined {
-\treturn resolveAbilitiesClient().getAbility( ${abilityConstBase}_ABILITY_ID );
+\t| undefined
+> {
+\tawait waitFor${pascalCase}AbilityRegistration();
+
+\treturn getRegisteredAbility( ${abilityConstBase}_ABILITY_ID ) as
+\t\t| WordPressAbilityDefinition
+\t\t| undefined;
 }
 
-export function require${pascalCase}Ability(): WordPressAbilityDefinition {
-\tconst ability = get${pascalCase}Ability();
+export async function require${pascalCase}Ability(): Promise< WordPressAbilityDefinition > {
+\tconst ability = await get${pascalCase}Ability();
 \tif ( ability ) {
 \t\treturn ability;
 \t}
@@ -174,7 +232,9 @@ export function require${pascalCase}Ability(): WordPressAbilityDefinition {
 export async function run${pascalCase}Ability(
 \tinput: ${pascalCase}AbilityInput
 ): Promise< ${pascalCase}AbilityOutput > {
-\treturn ( await resolveAbilitiesClient().executeAbility(
+\tawait waitFor${pascalCase}AbilityRegistration();
+
+\treturn ( await executeAbility(
 \t\t${abilityConstBase}_ABILITY_ID,
 \t\tinput
 \t) ) as ${pascalCase}AbilityOutput;
@@ -186,8 +246,8 @@ function buildAbilityClientSource(abilitySlug) {
     return `/**
  * Re-export the typed ${pascalCase} ability client helpers.
  *
- * The underlying WordPress abilities client is expected to have been hydrated
- * by the site's admin/editor bootstrap before these helpers execute.
+ * The helper methods load the WordPress core abilities integration and wait for
+ * this server-registered ability before reading or executing it.
  */
 export * from './data';
 `;
@@ -559,22 +619,31 @@ function ${enqueueFunctionName}() {
 \t\t? $asset['dependencies']
 \t\t: array();
 
-\tforeach ( array( '${WP_CORE_ABILITIES_SCRIPT_HANDLE}', '${WP_ABILITIES_SCRIPT_HANDLE}' ) as $ability_dependency ) {
-\t\tif (
-\t\t\tfunction_exists( 'wp_script_is' ) &&
-\t\t\twp_script_is( $ability_dependency, 'registered' ) &&
-\t\t\t! in_array( $ability_dependency, $dependencies, true )
-\t\t) {
+\tforeach ( array( '${WP_CORE_ABILITIES_SCRIPT_MODULE_ID}', '${WP_ABILITIES_SCRIPT_MODULE_ID}' ) as $ability_dependency ) {
+\t\t$has_dependency = false;
+\t\tforeach ( $dependencies as $dependency ) {
+\t\t\t$dependency_id = is_array( $dependency ) && isset( $dependency['id'] )
+\t\t\t\t? $dependency['id']
+\t\t\t\t: $dependency;
+\t\t\tif ( $dependency_id === $ability_dependency ) {
+\t\t\t\t$has_dependency = true;
+\t\t\t\tbreak;
+\t\t\t}
+\t\t}
+\t\tif ( ! $has_dependency ) {
 \t\t\t$dependencies[] = $ability_dependency;
 \t\t}
 \t}
 
-\twp_enqueue_script(
+\tif ( ! function_exists( 'wp_enqueue_script_module' ) ) {
+\t\treturn;
+\t}
+
+\twp_enqueue_script_module(
 \t\t'${workspaceBaseName}-abilities',
 \t\tplugins_url( '${ABILITY_EDITOR_SCRIPT}', __FILE__ ),
 \t\t$dependencies,
-\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
-\t\ttrue
+\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path )
 \t);
 }
 `;
@@ -607,6 +676,9 @@ function ${enqueueFunctionName}() {
         if (!hasPhpFunctionDefinition(enqueueFunctionName)) {
             insertPhpSnippet(enqueueFunction);
         }
+        else if (!findPhpFunctionRange(nextSource, enqueueFunctionName)?.source.includes("wp_enqueue_script_module")) {
+            nextSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
+        }
         if (!nextSource.includes(loadHook)) {
             appendPhpSnippet(loadHook);
         }
@@ -626,10 +698,17 @@ async function ensureAbilityPackageScripts(workspace) {
         ...(packageJson.scripts ?? {}),
         "sync-abilities": packageJson.scripts?.["sync-abilities"] ?? "tsx scripts/sync-abilities.ts",
     };
-    if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {})) {
+    const nextDependencies = {
+        ...(packageJson.dependencies ?? {}),
+        [WP_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_ABILITIES_SCRIPT_MODULE_ID], WP_ABILITIES_PACKAGE_VERSION),
+        [WP_CORE_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_CORE_ABILITIES_SCRIPT_MODULE_ID], WP_CORE_ABILITIES_PACKAGE_VERSION),
+    };
+    if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {}) &&
+        JSON.stringify(nextDependencies) === JSON.stringify(packageJson.dependencies ?? {})) {
         return;
     }
     packageJson.scripts = nextScripts;
+    packageJson.dependencies = nextDependencies;
     await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}\n`, "utf8");
 }
 async function ensureAbilitySyncProjectAnchors(workspace) {
@@ -702,6 +781,28 @@ async function ensureAbilityWebpackAnchors(workspace) {
         if (/['"]abilities\/index['"]/u.test(source)) {
             return source;
         }
+        const optionalModuleReturnPattern = /(function\s+getOptionalModuleEntries\s*\(\)\s*\{[\s\S]*?)(\n\treturn Object\.fromEntries\(\s*entries\s*\);\n\})/u;
+        if (optionalModuleReturnPattern.test(source)) {
+            return source.replace(optionalModuleReturnPattern, `$1
+
+\tfor ( const [ entryName, candidates ] of [
+\t\t[
+\t\t\t'abilities/index',
+\t\t\t[ 'src/abilities/index.ts', 'src/abilities/index.js' ],
+\t\t],
+\t] ) {
+\t\tfor ( const relativePath of candidates ) {
+\t\t\tconst entryPath = path.resolve( process.cwd(), relativePath );
+\t\t\tif ( ! fs.existsSync( entryPath ) ) {
+\t\t\t\tcontinue;
+\t\t\t}
+
+\t\t\tentries.push( [ entryName, entryPath ] );
+\t\t\tbreak;
+\t\t}
+\t}
+$2`);
+        }
         const sharedEntriesPattern = /for\s*\(\s*const\s+\[\s*entryName\s*,\s*candidates\s*\]\s+of\s+\[([\s\S]*?)\]\s*\)\s*\{/u;
         const match = source.match(sharedEntriesPattern);
         if (!match ||

package/dist/runtime/cli-add-workspace-rest.js

@@ -446,7 +446,6 @@ export async function runAddRestResourceCommand({ cwd = process.cwd(), methods,
     const validatorsFilePath = path.join(restResourceDir, "api-validators.ts");
     const apiFilePath = path.join(restResourceDir, "api.ts");
     const dataFilePath = path.join(restResourceDir, "data.ts");
-    const clientFilePath = path.join(restResourceDir, "api-client.ts");
     const phpFilePath = path.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
     const mutationSnapshot = {
         fileSources: await snapshotWorkspaceFiles([

package/dist/runtime/cli-diagnostics.d.ts

@@ -19,6 +19,7 @@ export declare const CLI_DIAGNOSTIC_CODES: {
     readonly OUTSIDE_PROJECT_ROOT: "outside-project-root";
     readonly TEMPLATE_SOURCE_TIMEOUT: "template-source-timeout";
     readonly TEMPLATE_SOURCE_TOO_LARGE: "template-source-too-large";
+    readonly UNKNOWN_TEMPLATE: "unknown-template";
     readonly UNSUPPORTED_COMMAND: "unsupported-command";
 };
 export type CliDiagnosticCode = (typeof CLI_DIAGNOSTIC_CODES)[keyof typeof CLI_DIAGNOSTIC_CODES];

package/dist/runtime/cli-diagnostics.js

@@ -10,6 +10,7 @@ export const CLI_DIAGNOSTIC_CODES = {
     OUTSIDE_PROJECT_ROOT: "outside-project-root",
     TEMPLATE_SOURCE_TIMEOUT: "template-source-timeout",
     TEMPLATE_SOURCE_TOO_LARGE: "template-source-too-large",
+    UNKNOWN_TEMPLATE: "unknown-template",
     UNSUPPORTED_COMMAND: "unsupported-command",
 };
 const DEFAULT_CLI_FAILURE_SUMMARIES = {
@@ -183,7 +184,10 @@ function inferCliDiagnosticCode(options) {
     if (/requires <|requires --|requires a value/u.test(haystack)) {
         return CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT;
     }
-    if (/Unknown .*subcommand|Unknown add kind|Unknown template|removed in favor|does not support|The Bun-free fallback runtime does not support|The positional alias only accepts/u.test(haystack)) {
+    if (/Unknown (?:add-block )?template\s+(?:"|\\")/u.test(haystack)) {
+        return CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE;
+    }
+    if (/Unknown .*subcommand|Unknown add kind|removed in favor|does not support|The Bun-free fallback runtime does not support|The positional alias only accepts/u.test(haystack)) {
         return haystack.includes("does not support") ||
             haystack.includes("The Bun-free fallback runtime does not support")
             ? CLI_DIAGNOSTIC_CODES.UNSUPPORTED_COMMAND

package/dist/runtime/cli-doctor-workspace.js

@@ -303,21 +303,24 @@ function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
     const hasServerGlob = source.includes(WORKSPACE_ABILITY_GLOB);
     const hasEditorScript = source.includes(WORKSPACE_ABILITY_EDITOR_SCRIPT);
     const hasEditorAsset = source.includes(WORKSPACE_ABILITY_EDITOR_ASSET);
+    const hasScriptModuleEnqueue = source.includes("wp_enqueue_script_module");
     return createDoctorCheck("Ability bootstrap", hasLoaderHook &&
         hasAdminEnqueueHook &&
         hasEditorEnqueueHook &&
         hasServerGlob &&
         hasEditorScript &&
-        hasEditorAsset
+        hasEditorAsset &&
+        hasScriptModuleEnqueue
         ? "pass"
         : "fail", hasLoaderHook &&
         hasAdminEnqueueHook &&
         hasEditorEnqueueHook &&
         hasServerGlob &&
         hasEditorScript &&
-        hasEditorAsset
-        ? "Ability loader and admin/editor client bootstrap hooks are present"
-        : "Missing ability loader hook or build/abilities script asset references");
+        hasEditorAsset &&
+        hasScriptModuleEnqueue
+        ? "Ability loader and admin/editor script-module bootstrap hooks are present"
+        : "Missing ability loader hook, script-module enqueue, or build/abilities asset references");
 }
 function checkWorkspaceAbilityIndex(projectDir, abilities) {
     const indexRelativePath = [

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

@@ -1,8 +1,10 @@
 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 { 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 { toSnakeCase, toTitleCase, } from './string-case.js';
 const WORKSPACE_TEMPLATE_ALIAS = 'workspace';
 const TEMPLATE_SELECTION_HINT = `--template <${[
@@ -11,6 +13,10 @@ const TEMPLATE_SELECTION_HINT = `--template <${[
 ].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.
  *
@@ -78,14 +84,22 @@ function normalizeTemplateSelection(templateId) {
         ? OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE
         : templateId;
 }
-function looksLikeExplicitExternalTemplateLocator(templateId) {
-    return (templateId.startsWith('./') ||
+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('@') ||
         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);
@@ -104,7 +118,7 @@ function getEditDistance(left, right) {
 function findMistypedBuiltInTemplateSuggestion(templateId) {
     const normalizedTemplateId = templateId.trim().toLowerCase();
     if (normalizedTemplateId.length === 0 ||
-        looksLikeExplicitExternalTemplateLocator(normalizedTemplateId)) {
+        looksLikeExplicitNonNpmExternalTemplateLocator(normalizedTemplateId)) {
         return null;
     }
     let bestCandidate = null;
@@ -132,6 +146,13 @@ function getMistypedBuiltInTemplateMessage(templateId) {
         : '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.
  *
@@ -154,6 +175,9 @@ export async function resolveTemplateId({ templateId, yes = false, isInteractive
         if (mistypedBuiltInTemplateMessage) {
             throw new Error(mistypedBuiltInTemplateMessage);
         }
+        if (!looksLikeExplicitExternalTemplateLocator(normalizedTemplateId)) {
+            throw new Error(getUnknownTemplateMessage(templateId));
+        }
         return normalizedTemplateId;
     }
     if (yes) {
@@ -190,7 +214,7 @@ export async function resolvePackageManagerId({ packageManager, yes = false, isI
  */
 export async function collectScaffoldAnswers({ projectName, templateId, yes = false, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, queryPostType, textDomain, }) {
     const defaults = getDefaultAnswers(projectName, templateId);
-    if (yes) {
+    if (yes || (!isBuiltInTemplateId(templateId) && !promptText)) {
         const identifiers = resolveScaffoldIdentifiers({
             namespace: namespace ?? defaults.namespace,
             phpPrefix,

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

@@ -6,9 +6,20 @@ import { spawnSync } from 'node:child_process';
 import semver from 'semver';
 import { x as extractTarball } from 'tar';
 import { createExternalTemplateTimeoutError, fetchWithExternalTemplateTimeout, getExternalTemplateMetadataMaxBytes, getExternalTemplateTarballMaxBytes, getExternalTemplateTimeoutMs, readBufferResponseWithLimit, readJsonResponseWithLimit, } from './external-template-guards.js';
-import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, PROJECT_TOOLS_PACKAGE_ROOT, } from './template-registry.js';
+import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, OFFICIAL_WORKSPACE_TEMPLATE_ALIAS, PROJECT_TOOLS_PACKAGE_ROOT, TEMPLATE_IDS, } from './template-registry.js';
 import { isPlainObject } from './object-utils.js';
 import { createManagedTempRoot } from './temp-roots.js';
+const USER_FACING_TEMPLATE_IDS = [
+    ...TEMPLATE_IDS,
+    OFFICIAL_WORKSPACE_TEMPLATE_ALIAS,
+];
+function getUnknownNpmTemplateMessage(templateId) {
+    return [
+        `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS.join(', ')}.`,
+        'Run `wp-typia templates list` to inspect available templates.',
+        'If you meant an npm template package, verify the package name and configured npm registry.',
+    ].join(' ');
+}
 function selectRegistryVersion(metadata, locator) {
     const distTags = isPlainObject(metadata['dist-tags'])
         ? metadata['dist-tags']
@@ -49,6 +60,9 @@ async function fetchNpmTemplateSource(locator) {
         label: metadataLabel,
     });
     if (!metadataResponse.ok) {
+        if (metadataResponse.status === 404) {
+            throw new Error(getUnknownNpmTemplateMessage(locator.raw));
+        }
         throw new Error(`Failed to fetch npm template metadata for ${locator.raw}: ${metadataResponse.status}`);
     }
     const metadata = await readJsonResponseWithLimit(metadataResponse, {

package/dist/runtime/typia-llm.d.ts

@@ -14,6 +14,8 @@ export interface TypiaLlmEndpointMethodDescriptor {
     description?: string;
     /** Input type used by the generated controller method, or null for no input. */
     inputTypeName: string | null;
+    /** Type names that must be imported when inputTypeName is an inline composite. */
+    inputTypeImportNames?: readonly string[];
     /** HTTP method from the source endpoint manifest. */
     method: EndpointManifestEndpointDefinition['method'];
     /** Stable operation identifier used as the generated method name. */

package/dist/runtime/typia-llm.js

@@ -84,21 +84,36 @@ const TYPESCRIPT_RESERVED_WORDS = new Set([
 function cloneJsonValueIfDefined(value) {
     return value === undefined ? undefined : cloneJsonValue(value);
 }
-function getEndpointInputTypeName(manifest, endpoint) {
+function getContractSourceTypeName(manifest, endpoint, contractName) {
+    const contract = manifest.contracts[contractName];
+    if (!contract) {
+        throw new Error(`Endpoint "${endpoint.operationId}" references missing input contract "${contractName}".`);
+    }
+    return contract.sourceTypeName;
+}
+function getEndpointInputTypeDescriptor(manifest, endpoint) {
     if (endpoint.bodyContract && endpoint.queryContract) {
-        throw new Error(`Endpoint "${endpoint.operationId}" defines both bodyContract and queryContract; typia.llm input mapping is ambiguous.`);
+        const bodyTypeName = getContractSourceTypeName(manifest, endpoint, endpoint.bodyContract);
+        const queryTypeName = getContractSourceTypeName(manifest, endpoint, endpoint.queryContract);
+        return {
+            importTypeNames: [bodyTypeName, queryTypeName],
+            signatureTypeName: `{ body: ${bodyTypeName}; query: ${queryTypeName} }`,
+        };
     }
     const contractName = endpoint.method === 'GET'
         ? endpoint.queryContract ?? null
         : endpoint.bodyContract ?? endpoint.queryContract ?? null;
     if (!contractName) {
-        return null;
-    }
-    const contract = manifest.contracts[contractName];
-    if (!contract) {
-        throw new Error(`Endpoint "${endpoint.operationId}" references missing input contract "${contractName}".`);
+        return {
+            importTypeNames: [],
+            signatureTypeName: null,
+        };
     }
-    return contract.sourceTypeName;
+    const sourceTypeName = getContractSourceTypeName(manifest, endpoint, contractName);
+    return {
+        importTypeNames: [sourceTypeName],
+        signatureTypeName: sourceTypeName,
+    };
 }
 function getEndpointOutputTypeName(manifest, endpoint) {
     const contract = manifest.contracts[endpoint.responseContract];
@@ -157,7 +172,12 @@ function renderTypiaLlmModuleFromMethodDescriptors({ applicationExportName, inte
     const importedTypeNames = new Set([structuredOutputTypeName]);
     for (const method of methods) {
         importedTypeNames.add(method.outputTypeName);
-        if (method.inputTypeName) {
+        if (method.inputTypeImportNames) {
+            for (const inputTypeImportName of method.inputTypeImportNames) {
+                importedTypeNames.add(inputTypeImportName);
+            }
+        }
+        else if (method.inputTypeName) {
             importedTypeNames.add(method.inputTypeName);
         }
     }
@@ -233,11 +253,19 @@ async function reconcileGeneratedTypiaLlmArtifacts(artifacts, check) {
 export function buildTypiaLlmEndpointMethodDescriptors(manifest) {
     return manifest.endpoints.map((endpoint) => {
         const normalizedAuth = normalizeEndpointAuthDefinition(endpoint);
+        const inputTypeDescriptor = getEndpointInputTypeDescriptor(manifest, endpoint);
+        const inputTypeName = inputTypeDescriptor.signatureTypeName;
+        const shouldUseInlineInputImports = inputTypeName !== null &&
+            inputTypeDescriptor.importTypeNames.length > 0 &&
+            inputTypeDescriptor.importTypeNames[0] !== inputTypeName;
         return {
             authIntent: normalizedAuth.auth,
             ...(normalizedAuth.authMode ? { authMode: normalizedAuth.authMode } : {}),
             description: endpoint.summary,
-            inputTypeName: getEndpointInputTypeName(manifest, endpoint),
+            inputTypeName,
+            ...(shouldUseInlineInputImports
+                ? { inputTypeImportNames: inputTypeDescriptor.importTypeNames }
+                : {}),
             method: endpoint.method,
             operationId: endpoint.operationId,
             outputTypeName: getEndpointOutputTypeName(manifest, endpoint),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",