@wp-typia/project-tools 0.16.14 → 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,11 +8,22 @@ 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);
 }
+function templateSupportsGeneratedSyncWatchers(templateId) {
+    return (templateId === "basic" ||
+        templateId === "interactivity" ||
+        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")}"`;
@@ -80,11 +91,16 @@ export async function applyLocalDevPresetFiles({ projectDir, variables, withTest
  */
 export async function applyGeneratedProjectDxPackageJson({ compoundPersistenceEnabled = false, packageManager, projectDir, templateId, withTestPreset = false, withWpEnv = false, }) {
     const hasPersistenceSync = templateHasPersistenceSync(templateId, compoundPersistenceEnabled);
+    const supportsGeneratedSyncWatchers = templateSupportsGeneratedSyncWatchers(templateId);
     await mutatePackageJson(projectDir, (packageJson) => {
         packageJson.devDependencies = {
             ...(packageJson.devDependencies ?? {}),
-            "chokidar-cli": "^3.0.0",
-            concurrently: "^9.0.1",
+            ...(supportsGeneratedSyncWatchers
+                ? {
+                    "chokidar-cli": "^3.0.0",
+                    concurrently: "^9.0.1",
+                }
+                : {}),
         };
         if (withWpEnv || withTestPreset) {
             packageJson.devDependencies["@wordpress/env"] = "^11.2.0";
@@ -95,12 +111,16 @@ export async function applyGeneratedProjectDxPackageJson({ compoundPersistenceEn
         const scripts = {
             ...(packageJson.scripts ?? {}),
         };
-        scripts["start:editor"] = "wp-scripts start --experimental-modules";
-        scripts["watch:sync-types"] = getWatchSyncTypesScript(packageManager, templateId);
+        if (supportsGeneratedSyncWatchers) {
+            scripts["start:editor"] = "wp-scripts start --experimental-modules";
+            scripts["watch:sync-types"] = getWatchSyncTypesScript(packageManager, templateId);
+        }
         if (hasPersistenceSync) {
             scripts["watch:sync-rest"] = getWatchSyncRestScript(packageManager, templateId);
         }
-        scripts.dev = getDevScript(packageManager, compoundPersistenceEnabled, templateId);
+        if (supportsGeneratedSyncWatchers) {
+            scripts.dev = getDevScript(packageManager, compoundPersistenceEnabled, templateId);
+        }
         if (withWpEnv) {
             scripts["wp-env:start"] = "wp-env start";
             scripts["wp-env:stop"] = "wp-env stop";
@@ -123,10 +143,5 @@ export async function applyGeneratedProjectDxPackageJson({ compoundPersistenceEn
  * scaffolded template.
  */
 export function getPrimaryDevelopmentScript(templateId) {
-    return templateId === "basic" ||
-        templateId === "interactivity" ||
-        templateId === "persistence" ||
-        templateId === "compound"
-        ? "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.d.ts

@@ -34,4 +34,4 @@ export declare function resolvePackageManagerId({ packageManager, yes, isInterac
  * @param options Answer collection inputs including prompt callbacks and explicit overrides.
  * @returns The normalized scaffold answers used for rendering and file generation.
  */
-export declare function collectScaffoldAnswers({ projectName, templateId, yes, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, textDomain, }: CollectScaffoldAnswersOptions): Promise<ScaffoldAnswers>;
+export declare function collectScaffoldAnswers({ projectName, templateId, yes, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, queryPostType, textDomain, }: CollectScaffoldAnswersOptions): Promise<ScaffoldAnswers>;

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.
  *
@@ -37,16 +43,91 @@ export function getDefaultAnswers(projectName, templateId) {
         namespace: slugDefault,
         persistencePolicy: templateId === 'persistence' ? 'authenticated' : undefined,
         phpPrefix: toSnakeCase(slugDefault),
+        queryPostType: templateId === 'query-loop' ? 'post' : undefined,
         slug: slugDefault,
         textDomain: slugDefault,
         title: toTitleCase(slugDefault),
     };
 }
+function validateQueryPostType(value) {
+    const normalizedValue = value.trim().toLowerCase();
+    if (normalizedValue.length === 0) {
+        return 'Query post type is required.';
+    }
+    if (!/^[a-z0-9_-]{1,20}$/u.test(normalizedValue)) {
+        return 'Query post type must be lowercase, 1-20 chars, and only a-z, 0-9, "_" or "-".';
+    }
+    return true;
+}
+function normalizeQueryPostType(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalizedValue = value.trim().toLowerCase();
+    if (validateQueryPostType(normalizedValue) !== true) {
+        throw new Error('Query post type must be lowercase, 1-20 chars, and only a-z, 0-9, "_" or "-".');
+    }
+    return normalizedValue;
+}
 function normalizeTemplateSelection(templateId) {
     return templateId === WORKSPACE_TEMPLATE_ALIAS
         ? 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.
  *
@@ -59,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());
 }
@@ -96,7 +184,7 @@ export async function resolvePackageManagerId({ packageManager, yes = false, isI
  * @param options Answer collection inputs including prompt callbacks and explicit overrides.
  * @returns The normalized scaffold answers used for rendering and file generation.
  */
-export async function collectScaffoldAnswers({ projectName, templateId, yes = false, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, textDomain, }) {
+export async function collectScaffoldAnswers({ projectName, templateId, yes = false, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, queryPostType, textDomain, }) {
     const defaults = getDefaultAnswers(projectName, templateId);
     if (yes) {
         const identifiers = resolveScaffoldIdentifiers({
@@ -111,6 +199,7 @@ export async function collectScaffoldAnswers({ projectName, templateId, yes = fa
             namespace: identifiers.namespace,
             persistencePolicy: persistencePolicy ?? defaults.persistencePolicy,
             phpPrefix: identifiers.phpPrefix,
+            queryPostType: normalizeQueryPostType(queryPostType ?? defaults.queryPostType),
             textDomain: identifiers.textDomain,
         };
     }
@@ -130,9 +219,11 @@ export async function collectScaffoldAnswers({ projectName, templateId, yes = fa
         namespace: identifiers.namespace,
         persistencePolicy: persistencePolicy ?? defaults.persistencePolicy,
         phpPrefix: identifiers.phpPrefix,
+        queryPostType: templateId === 'query-loop'
+            ? normalizeQueryPostType(await promptText('Query post type', queryPostType ?? defaults.queryPostType ?? 'post', validateQueryPostType))
+            : normalizeQueryPostType(queryPostType ?? defaults.queryPostType),
         slug: identifiers.slug,
         textDomain: identifiers.textDomain,
         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>;