@wp-typia/project-tools 0.17.0 → 0.18.0

package/dist/runtime/cli-templates.js

@@ -1,5 +1,5 @@
-import { getBuiltInTemplateLayerDirs } from "./template-builtins.js";
-import { getTemplateById, getTemplateSelectOptions, isBuiltInTemplateId, listTemplates, } from "./template-registry.js";
+import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, getTemplateById, getTemplateSelectOptions, isBuiltInTemplateId, listTemplates, } from "./template-registry.js";
+const WORKSPACE_TEMPLATE_ALIAS = "workspace";
 /**
  * Format one line of template list output for a built-in template.
  *
@@ -10,62 +10,102 @@ export function formatTemplateSummary(template) {
     return `${template.id.padEnd(14)} ${template.description}`;
 }
 /**
- * Format the feature hint line shown under a template summary.
+ * Format the feature and capability hint lines shown under a template summary.
  *
  * @param template Template metadata including the `features` list.
- * @returns Indented feature text for CLI list output.
+ * @returns Indented feature and capability text for CLI list output.
  */
 export function formatTemplateFeatures(template) {
-    return `  ${template.features.join(" • ")}`;
+    const lines = [`  Features: ${template.features.join(" • ")}`];
+    const capabilityHints = getTemplateCapabilityHints(template);
+    if (capabilityHints.length > 0) {
+        lines.push(`  Supports: ${capabilityHints.join(" • ")}`);
+    }
+    if (template.id === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+        lines.push(`  Alias: ${WORKSPACE_TEMPLATE_ALIAS} (\`--template ${WORKSPACE_TEMPLATE_ALIAS}\`)`);
+    }
+    return lines.join("\n");
 }
 /**
  * Format the detailed template description for `templates inspect`.
  *
  * This expands special layer combinations for the `persistence` and `compound`
- * templates and returns a multi-line block including category, overlay path,
- * resolved layers, and feature labels.
+ * templates and returns a multi-line block centered on human-facing identity,
+ * capabilities, and logical layer composition.
  *
  * @param template Template metadata including `id`, `defaultCategory`,
  * `templateDir`, and `features`.
  * @returns Multi-line template details text for CLI output.
  */
 export function formatTemplateDetails(template) {
+    const detailLines = [
+        template.id,
+        `Summary: ${template.description}`,
+        ...getTemplateIdentityLines(template),
+        `Category: ${template.defaultCategory}`,
+    ];
+    const capabilityHints = getTemplateCapabilityHints(template);
+    if (capabilityHints.length > 0) {
+        detailLines.push("Capabilities:");
+        for (const capabilityHint of capabilityHints) {
+            detailLines.push(`  - ${capabilityHint}`);
+        }
+    }
+    detailLines.push("Logical layers:");
+    for (const logicalLayer of getTemplateLogicalLayerSummaries(template)) {
+        detailLines.push(`  - ${logicalLayer}`);
+    }
+    detailLines.push(`Features: ${template.features.join(", ")}`);
+    return detailLines.join("\n");
+}
+function getTemplateCapabilityHints(template) {
+    if (template.id === "persistence" || template.id === "compound") {
+        return ["--data-storage", "--persistence-policy", "external layers"];
+    }
+    if (template.id === "query-loop") {
+        return ["--query-post-type", "external layers"];
+    }
+    if (isBuiltInTemplateId(template.id)) {
+        return ["external layers"];
+    }
+    return [];
+}
+function getTemplateIdentityLines(template) {
+    if (template.id === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+        return [
+            "Identity:",
+            `  - Official package: ${OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE}`,
+            `  - Alias: ${WORKSPACE_TEMPLATE_ALIAS} (\`--template ${WORKSPACE_TEMPLATE_ALIAS}\`)`,
+            "Type: official workspace scaffold",
+        ];
+    }
+    return [
+        "Identity:",
+        `  - Built-in template id: ${template.id}`,
+        "Type: built-in block scaffold",
+    ];
+}
+function getTemplateLogicalLayerSummaries(template) {
     if (!isBuiltInTemplateId(template.id)) {
+        return ["workspace package scaffold"];
+    }
+    if (template.id === "persistence") {
+        return [
+            "authenticated write policy: shared/base -> rest helpers (shared) -> persistence core -> authenticated write policy -> persistence overlay",
+            "public write policy: shared/base -> rest helpers (shared) -> persistence core -> public write policy -> persistence overlay",
+        ];
+    }
+    if (template.id === "compound") {
         return [
-            template.id,
-            template.description,
-            `Category: ${template.defaultCategory}`,
-            `Overlay path: ${template.templateDir}`,
-            "Layers: workspace package scaffold",
-            `Features: ${template.features.join(", ")}`,
-        ].join("\n");
+            "pure block family: shared/base -> compound core -> compound overlay",
+            "authenticated persistence: shared/base -> compound core -> rest helpers (shared) -> compound persistence core -> authenticated write policy -> compound overlay",
+            "public persistence: shared/base -> compound core -> rest helpers (shared) -> compound persistence core -> public write policy -> compound overlay",
+        ];
     }
-    const layers = template.id === "persistence"
-        ? [
-            `authenticated: ${getBuiltInTemplateLayerDirs(template.id, { persistencePolicy: "authenticated" }).join(" -> ")}`,
-            `public: ${getBuiltInTemplateLayerDirs(template.id, { persistencePolicy: "public" }).join(" -> ")}`,
-        ]
-        : template.id === "compound"
-            ? [
-                `pure: ${getBuiltInTemplateLayerDirs(template.id).join(" -> ")}`,
-                `authenticated+persistence: ${getBuiltInTemplateLayerDirs(template.id, {
-                    persistenceEnabled: true,
-                    persistencePolicy: "authenticated",
-                }).join(" -> ")}`,
-                `public+persistence: ${getBuiltInTemplateLayerDirs(template.id, {
-                    persistenceEnabled: true,
-                    persistencePolicy: "public",
-                }).join(" -> ")}`,
-            ]
-            : [getBuiltInTemplateLayerDirs(template.id).join(" -> ")];
+    const overlayName = template.id === "query-loop" ? "query-loop overlay" : `${template.id} overlay`;
     return [
-        template.id,
-        template.description,
-        `Category: ${template.defaultCategory}`,
-        `Overlay path: ${template.templateDir}`,
-        `Layers: ${layers.join("\n")}`,
-        `Features: ${template.features.join(", ")}`,
-    ].join("\n");
+        `shared/base -> ${overlayName}`,
+    ];
 }
 export { getTemplateById, getTemplateSelectOptions, listTemplates };
 export { isBuiltInTemplateId };

package/dist/runtime/index.d.ts

@@ -6,7 +6,8 @@
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
  * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`,
- * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * `runAddBindingSourceCommand`, `runAddEditorPluginCommand`,
+ * `runAddHookedBlockCommand`,
  * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
  */
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
@@ -21,5 +22,5 @@ export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, str
 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 { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
-export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
-export type { CliDiagnosticMessage, DoctorCheck, HookedBlockPositionId, ReadlinePrompt, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export type { CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, } from "./cli-core.js";

package/dist/runtime/index.js

@@ -6,7 +6,8 @@
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
  * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`,
- * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * `runAddBindingSourceCommand`, `runAddEditorPluginCommand`,
+ * `runAddHookedBlockCommand`,
  * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
  */
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
@@ -18,4 +19,4 @@ export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJso
 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 { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
-export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/local-dev-presets.js

@@ -8,7 +8,7 @@ import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { formatRunScript, } from "./package-managers.js";
-import { SHARED_TEST_PRESET_TEMPLATE_ROOT, SHARED_WP_ENV_PRESET_TEMPLATE_ROOT, } from "./template-registry.js";
+import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, SHARED_TEST_PRESET_TEMPLATE_ROOT, SHARED_WP_ENV_PRESET_TEMPLATE_ROOT, } from "./template-registry.js";
 import { copyInterpolatedDirectory } from "./template-render.js";
 function templateHasPersistenceSync(templateId, compoundPersistenceEnabled) {
     return templateId === "persistence" || (templateId === "compound" && compoundPersistenceEnabled);
@@ -19,6 +19,11 @@ function templateSupportsGeneratedSyncWatchers(templateId) {
         templateId === "persistence" ||
         templateId === "compound");
 }
+function templateUsesDevAsPrimaryEntrypoint(templateId) {
+    return (templateSupportsGeneratedSyncWatchers(templateId) ||
+        templateId === "query-loop" ||
+        templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE);
+}
 function getWatchSyncTypesScript(packageManager, templateId) {
     if (templateId === "compound") {
         return `chokidar "src/blocks/**/types.ts" "scripts/block-config.ts" --debounce 200 -c "${formatRunScript(packageManager, "sync-types")}"`;
@@ -138,5 +143,5 @@ export async function applyGeneratedProjectDxPackageJson({ compoundPersistenceEn
  * scaffolded template.
  */
 export function getPrimaryDevelopmentScript(templateId) {
-    return templateSupportsGeneratedSyncWatchers(templateId) ? "dev" : "start";
+    return templateUsesDevAsPrimaryEntrypoint(templateId) ? "dev" : "start";
 }

package/dist/runtime/rest-resource-artifacts.d.ts

@@ -0,0 +1,35 @@
+import type { RestResourceMethodId } from "./cli-add-shared.js";
+interface RestResourceTemplateVariablesLike {
+    namespace: string;
+    pascalCase: string;
+    slugKebabCase: string;
+    title: string;
+}
+interface SyncRestResourceArtifactsOptions {
+    clientFile: string;
+    methods: RestResourceMethodId[];
+    outputDir: string;
+    projectDir: string;
+    typesFile: string;
+    validatorsFile: string;
+    variables: RestResourceTemplateVariablesLike;
+}
+/**
+ * Build the endpoint manifest for a workspace-level REST resource scaffold.
+ *
+ * @param variables Template naming data used for contract names, routes, and OpenAPI info.
+ * @param methods Enabled REST methods for the generated resource.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export declare function buildRestResourceEndpointManifest(variables: RestResourceTemplateVariablesLike, methods: RestResourceMethodId[]): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
+    sourceTypeName: string;
+}>, import("@wp-typia/block-runtime/schema-core").EndpointOpenApiEndpointDefinition[]>;
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for
+ * a workspace-level REST resource scaffold.
+ *
+ * @param options Resource file paths, enabled methods, and naming variables.
+ * @returns A promise that resolves after every generated REST artifact has been refreshed.
+ */
+export declare function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncRestResourceArtifactsOptions): Promise<void>;
+export {};

package/dist/runtime/rest-resource-artifacts.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
+/**
+ * Build the endpoint manifest for a workspace-level REST resource scaffold.
+ *
+ * @param variables Template naming data used for contract names, routes, and OpenAPI info.
+ * @param methods Enabled REST methods for the generated resource.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export function buildRestResourceEndpointManifest(variables, methods) {
+    const basePath = `/${variables.namespace}/${variables.slugKebabCase}`;
+    const itemPath = `${basePath}/item`;
+    const contracts = {};
+    const endpoints = [];
+    if (methods.includes("list")) {
+        contracts["list-query"] = {
+            sourceTypeName: `${variables.pascalCase}ListQuery`,
+        };
+        contracts["list-response"] = {
+            sourceTypeName: `${variables.pascalCase}ListResponse`,
+        };
+        endpoints.push({
+            auth: "public",
+            method: "GET",
+            operationId: `list${variables.pascalCase}Resources`,
+            path: basePath,
+            queryContract: "list-query",
+            responseContract: "list-response",
+            summary: `List ${variables.title} resources.`,
+            tags: [variables.title],
+        });
+    }
+    if (methods.includes("read")) {
+        contracts["read-query"] = {
+            sourceTypeName: `${variables.pascalCase}ReadQuery`,
+        };
+        contracts["read-response"] = {
+            sourceTypeName: `${variables.pascalCase}ReadResponse`,
+        };
+        endpoints.push({
+            auth: "public",
+            method: "GET",
+            operationId: `read${variables.pascalCase}Resource`,
+            path: itemPath,
+            queryContract: "read-query",
+            responseContract: "read-response",
+            summary: `Read one ${variables.title} resource.`,
+            tags: [variables.title],
+        });
+    }
+    if (methods.includes("create")) {
+        contracts["create-request"] = {
+            sourceTypeName: `${variables.pascalCase}CreateRequest`,
+        };
+        contracts["create-response"] = {
+            sourceTypeName: `${variables.pascalCase}CreateResponse`,
+        };
+        endpoints.push({
+            auth: "authenticated",
+            bodyContract: "create-request",
+            method: "POST",
+            operationId: `create${variables.pascalCase}Resource`,
+            path: basePath,
+            responseContract: "create-response",
+            summary: `Create one ${variables.title} resource.`,
+            tags: [variables.title],
+            wordpressAuth: {
+                mechanism: "rest-nonce",
+            },
+        });
+    }
+    if (methods.includes("update")) {
+        contracts["update-query"] = {
+            sourceTypeName: `${variables.pascalCase}UpdateQuery`,
+        };
+        contracts["update-request"] = {
+            sourceTypeName: `${variables.pascalCase}UpdateRequest`,
+        };
+        contracts["update-response"] = {
+            sourceTypeName: `${variables.pascalCase}UpdateResponse`,
+        };
+        endpoints.push({
+            auth: "authenticated",
+            bodyContract: "update-request",
+            method: "POST",
+            operationId: `update${variables.pascalCase}Resource`,
+            path: itemPath,
+            queryContract: "update-query",
+            responseContract: "update-response",
+            summary: `Update one ${variables.title} resource.`,
+            tags: [variables.title],
+            wordpressAuth: {
+                mechanism: "rest-nonce",
+            },
+        });
+    }
+    if (methods.includes("delete")) {
+        contracts["delete-query"] = {
+            sourceTypeName: `${variables.pascalCase}DeleteQuery`,
+        };
+        contracts["delete-response"] = {
+            sourceTypeName: `${variables.pascalCase}DeleteResponse`,
+        };
+        endpoints.push({
+            auth: "authenticated",
+            method: "DELETE",
+            operationId: `delete${variables.pascalCase}Resource`,
+            path: itemPath,
+            queryContract: "delete-query",
+            responseContract: "delete-response",
+            summary: `Delete one ${variables.title} resource.`,
+            tags: [variables.title],
+            wordpressAuth: {
+                mechanism: "rest-nonce",
+            },
+        });
+    }
+    return defineEndpointManifest({
+        contracts,
+        endpoints,
+        info: {
+            title: `${variables.title} REST API`,
+            version: "1.0.0",
+        },
+    });
+}
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for
+ * a workspace-level REST resource scaffold.
+ *
+ * @param options Resource file paths, enabled methods, and naming variables.
+ * @returns A promise that resolves after every generated REST artifact has been refreshed.
+ */
+export async function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }) {
+    const manifest = buildRestResourceEndpointManifest(variables, methods);
+    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
+        await syncTypeSchemas({
+            jsonSchemaFile: path.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+            openApiFile: path.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+            projectRoot: projectDir,
+            sourceTypeName: contract.sourceTypeName,
+            typesFile,
+        });
+    }
+    await syncRestOpenApi({
+        manifest,
+        openApiFile: path.join(outputDir, "api.openapi.json"),
+        projectRoot: projectDir,
+        typesFile,
+    });
+    await syncEndpointClient({
+        clientFile,
+        manifest,
+        projectRoot: projectDir,
+        typesFile,
+        validatorsFile,
+    });
+}

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

@@ -1,9 +1,15 @@
+import { execSync } from 'node:child_process';
 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 { 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];
 /**
  * Detect the current author name from local Git config.
  *
@@ -68,6 +74,60 @@ function normalizeTemplateSelection(templateId) {
         ? OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE
         : templateId;
 }
+function looksLikeExplicitExternalTemplateLocator(templateId) {
+    return (templateId.startsWith('./') ||
+        templateId.startsWith('../') ||
+        templateId.startsWith('/') ||
+        templateId.startsWith('@') ||
+        templateId.startsWith('github:') ||
+        templateId.includes('/'));
+}
+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 ||
+        looksLikeExplicitExternalTemplateLocator(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.`;
+}
 /**
  * Resolve the scaffold template id from flags, defaults, and interactive selection.
  *
@@ -80,16 +140,23 @@ export async function resolveTemplateId({ templateId, yes = false, isInteractive
         if (isRemovedBuiltInTemplateId(templateId)) {
             throw new Error(getRemovedBuiltInTemplateMessage(templateId));
         }
+        if (normalizedTemplateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+            return normalizedTemplateId;
+        }
         if (isBuiltInTemplateId(normalizedTemplateId)) {
             return getTemplateById(normalizedTemplateId).id;
         }
+        const mistypedBuiltInTemplateMessage = getMistypedBuiltInTemplateMessage(templateId);
+        if (mistypedBuiltInTemplateMessage) {
+            throw new Error(mistypedBuiltInTemplateMessage);
+        }
         return normalizedTemplateId;
     }
     if (yes) {
         return 'basic';
     }
     if (!isInteractive || !selectTemplate) {
-        throw new Error(`Template is required in non-interactive mode. Use --template <${TEMPLATE_IDS.join('|')}|./path|github:owner/repo/path[#ref]|npm-package>.`);
+        throw new Error(`Template is required in non-interactive mode. Use ${TEMPLATE_SELECTION_HINT}.`);
     }
     return normalizeTemplateSelection(await selectTemplate());
 }
@@ -160,4 +227,3 @@ export async function collectScaffoldAnswers({ projectName, templateId, yes = fa
         title: await promptText('Block title', toTitleCase(identifiers.slug)),
     };
 }
-import { execSync } from 'node:child_process';

package/dist/runtime/scaffold-apply-utils.d.ts

@@ -2,7 +2,7 @@ import { type BuiltInBlockArtifact } from "./built-in-block-artifacts.js";
 import type { BuiltInCodeArtifact } from "./built-in-block-code-artifacts.js";
 import { type BuiltInTemplateId } from "./template-registry.js";
 import type { PackageManagerId } from "./package-managers.js";
-import type { ScaffoldTemplateVariables } from "./scaffold.js";
+import type { ScaffoldProgressEvent, ScaffoldTemplateVariables } from "./scaffold.js";
 export { buildGitignore, buildReadme, mergeTextLines, } from "./scaffold-documents.js";
 export interface InstallDependenciesOptions {
     packageManager: PackageManagerId;
@@ -16,7 +16,7 @@ export declare function writeStarterManifestFiles(targetDir: string, templateId:
  */
 export declare function seedBuiltInPersistenceArtifacts(targetDir: string, templateId: BuiltInTemplateId, variables: ScaffoldTemplateVariables): Promise<void>;
 export declare function normalizePackageManagerFiles(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
-export declare function normalizePackageJson(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
+export declare function removeQueryLoopPlaceholderFiles(projectDir: string, templateId: string): Promise<void>;
 export declare function removeUnexpectedLockfiles(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
 /**
  * Recursively normalizes generated text files for the selected package manager
@@ -33,7 +33,7 @@ export declare function applyWorkspaceMigrationCapability(projectDir: string, pa
  * Applies a built-in scaffold into the target directory, including generated
  * code artifacts, starter manifests, preset files, and placeholder rewrites.
  */
-export declare function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir, templateId, variables, artifacts, codeArtifacts, readmeContent, gitignoreContent, allowExistingDir, packageManager, withMigrationUi, withTestPreset, withWpEnv, noInstall, installDependencies, repositoryReference, }: {
+export declare function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir, templateId, variables, artifacts, codeArtifacts, readmeContent, gitignoreContent, allowExistingDir, packageManager, withMigrationUi, withTestPreset, withWpEnv, noInstall, installDependencies, repositoryReference, onProgress, }: {
     projectDir: string;
     templateDir: string;
     templateId: BuiltInTemplateId;
@@ -50,4 +50,5 @@ export declare function applyBuiltInScaffoldProjectFiles({ projectDir, templateD
     noInstall?: boolean;
     installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
     repositoryReference?: string;
+    onProgress?: ((event: ScaffoldProgressEvent) => void | Promise<void>) | undefined;
 }): Promise<void>;