@wp-typia/project-tools 0.24.10 → 0.24.12

package/dist/runtime/doctor/cli-doctor-wordpress-version.js

@@ -541,6 +541,9 @@ function formatRequirementSummary(requirements, floor) {
         .map((requirement) => requirement.label);
     return labels.length > 0 ? labels.join(", ") : "generated workspace features";
 }
+function formatFeatureMinimumAction(floor) {
+    return `Update the plugin bootstrap \`Requires at least\` header to ${floor} or remove the features that require that floor.`;
+}
 function createFeatureMinimumCheck(workspace, inventory, headers) {
     const { issues, requirements } = collectWordPressVersionRequirements(workspace, inventory);
     const highestFloor = pickHighestRequirementFloor(requirements, issues);
@@ -551,11 +554,11 @@ function createFeatureMinimumCheck(workspace, inventory, headers) {
         return createDoctorCheck("WordPress feature minimum", "pass", "No generated workspace features declare an additional WordPress hard floor.", WORDPRESS_VERSION_CHECK_CODES.featureMinimum);
     }
     if (!headers.requiresAtLeast) {
-        return createDoctorCheck("WordPress feature minimum", "fail", `Plugin bootstrap is missing a Requires at least header but generated features require WordPress ${highestFloor}.`, WORDPRESS_VERSION_CHECK_CODES.featureMinimum);
+        return createDoctorCheck("WordPress feature minimum", "fail", `Plugin bootstrap is missing a Requires at least header but generated features require WordPress ${highestFloor}. ${formatFeatureMinimumAction(highestFloor)}`, WORDPRESS_VERSION_CHECK_CODES.featureMinimum);
     }
     try {
         if (compareVersionFloors(headers.requiresAtLeast, highestFloor) < 0) {
-            return createDoctorCheck("WordPress feature minimum", "fail", `Requires at least ${headers.requiresAtLeast} is below generated feature floor ${highestFloor} (${formatRequirementSummary(requirements, highestFloor)}).`, WORDPRESS_VERSION_CHECK_CODES.featureMinimum);
+            return createDoctorCheck("WordPress feature minimum", "fail", `Requires at least ${headers.requiresAtLeast} is below generated feature floor ${highestFloor} (${formatRequirementSummary(requirements, highestFloor)}). ${formatFeatureMinimumAction(highestFloor)}`, WORDPRESS_VERSION_CHECK_CODES.featureMinimum);
         }
     }
     catch {
@@ -569,7 +572,7 @@ function createTestedTargetCheck(headers, targetVersion) {
     }
     try {
         if (compareVersionFloors(headers.testedUpTo, targetVersion) < 0) {
-            return createDoctorCheck("WordPress tested target", "warn", `Tested up to ${headers.testedUpTo} is below the selected WordPress target ${targetVersion}.`, WORDPRESS_VERSION_CHECK_CODES.testedTarget);
+            return createDoctorCheck("WordPress tested target", "warn", `Tested up to ${headers.testedUpTo} is below the selected WordPress target ${targetVersion}. Update the plugin bootstrap \`Tested up to\` header when the workspace is verified against WordPress ${targetVersion}.`, WORDPRESS_VERSION_CHECK_CODES.testedTarget);
         }
     }
     catch {

package/dist/runtime/doctor/cli-doctor-workspace.d.ts

@@ -7,9 +7,11 @@ export interface WorkspaceDoctorChecksOptions {
 /**
  * Collect workspace-scoped doctor checks for the given working directory.
  *
- * When the directory is not an official workspace, the function returns a
- * "Doctor scope" row explaining that only environment checks ran, plus a
- * failing workspace metadata row when a nearby candidate workspace is invalid.
+ * When the directory is not an official workspace, the function runs supported
+ * standalone single-block diagnostics when that project surface is detected.
+ * Otherwise it returns a "Doctor scope" row explaining that only environment
+ * checks ran, plus a failing workspace metadata row when a nearby candidate
+ * workspace is invalid.
  * When workspace resolution or metadata parsing throws, the corresponding
  * failing rows are returned early and the remaining checks are skipped.
  * When an official workspace is detected, a passing "Doctor scope" row is

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

@@ -4,6 +4,7 @@ import { getWorkspaceFeatureDoctorChecks, } from "./cli-doctor-workspace-feature
 import { getWorkspaceWordPressVersionDoctorChecks, } from "./cli-doctor-wordpress-version.js";
 import { getMigrationWorkspaceHintCheck, getWorkspacePackageMetadataCheck, prepareWorkspacePackageDoctorSnapshot, } from "./cli-doctor-workspace-package.js";
 import { createDoctorCheck, createDoctorScopeCheck, } from "./cli-doctor-workspace-shared.js";
+import { getStandaloneScaffoldDoctorChecks, tryResolveStandaloneScaffoldProject, } from "./cli-doctor-standalone.js";
 import { readWorkspaceInventoryAsync, } from "../workspace/workspace-inventory.js";
 import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, tryResolveWorkspaceProject, } from "../workspace/workspace-project.js";
 function formatWorkspaceInventorySummary(inventory) {
@@ -25,9 +26,11 @@ function formatWorkspaceInventorySummary(inventory) {
 /**
  * Collect workspace-scoped doctor checks for the given working directory.
  *
- * When the directory is not an official workspace, the function returns a
- * "Doctor scope" row explaining that only environment checks ran, plus a
- * failing workspace metadata row when a nearby candidate workspace is invalid.
+ * When the directory is not an official workspace, the function runs supported
+ * standalone single-block diagnostics when that project surface is detected.
+ * Otherwise it returns a "Doctor scope" row explaining that only environment
+ * checks ran, plus a failing workspace metadata row when a nearby candidate
+ * workspace is invalid.
  * When workspace resolution or metadata parsing throws, the corresponding
  * failing rows are returned early and the remaining checks are skipped.
  * When an official workspace is detected, a passing "Doctor scope" row is
@@ -42,6 +45,20 @@ function formatWorkspaceInventorySummary(inventory) {
  */
 export async function getWorkspaceDoctorChecks(cwd, options = {}) {
     const checks = [];
+    let standaloneProject = null;
+    let standaloneDiscoveryError = null;
+    try {
+        // The nearest standalone package boundary wins over unrelated ancestor
+        // workspace metadata. Official workspace manifests are rejected by the
+        // standalone detector and continue through workspace discovery below.
+        standaloneProject = tryResolveStandaloneScaffoldProject(cwd);
+    }
+    catch (error) {
+        standaloneDiscoveryError = error;
+    }
+    if (standaloneProject) {
+        return getStandaloneScaffoldDoctorChecks(standaloneProject);
+    }
     let workspace = null;
     let invalidWorkspaceReason = null;
     try {
@@ -61,6 +78,13 @@ export async function getWorkspaceDoctorChecks(cwd, options = {}) {
             checks.push(createDoctorCheck("Workspace package metadata", "fail", invalidWorkspaceReason));
         }
         else {
+            if (standaloneDiscoveryError) {
+                checks.push(createDoctorScopeCheck("fail", "Scope: blocked before standalone scaffold checks. Environment checks ran, but standalone discovery could not continue. Fix the nearest package metadata and rerun `wp-typia doctor`."));
+                checks.push(createDoctorCheck("Standalone package metadata", "fail", standaloneDiscoveryError instanceof Error
+                    ? standaloneDiscoveryError.message
+                    : String(standaloneDiscoveryError)));
+                return checks;
+            }
             checks.push(createDoctorScopeCheck("pass", "Scope: environment-only. No official wp-typia workspace root was detected, so this run only covered environment readiness. Re-run `wp-typia doctor` from a workspace root if you expected package metadata, inventory, or generated artifact checks."));
         }
         return checks;

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

@@ -56,8 +56,10 @@ export interface GetDoctorChecksOptions {
  *
  * The returned array concatenates environment checks (command availability,
  * directory writability, and built-in template assets) followed by
- * workspace checks (package metadata, inventory, blocks, variations,
- * patterns, bindings, and optional migration hints) in display order.
+ * project checks in display order. Official workspaces cover package metadata,
+ * inventory, blocks, variations, patterns, bindings, and optional migration
+ * hints. Supported standalone scaffolds cover package/bootstrap integrity,
+ * source layout, dependencies, and canonical generated-artifact freshness.
  *
  * @param cwd Working directory to validate for writability.
  * @param options Optional feature gates for additional doctor rows.

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

@@ -42,8 +42,10 @@ function toFailureSummary(check, severity) {
  *
  * The returned array concatenates environment checks (command availability,
  * directory writability, and built-in template assets) followed by
- * workspace checks (package metadata, inventory, blocks, variations,
- * patterns, bindings, and optional migration hints) in display order.
+ * project checks in display order. Official workspaces cover package metadata,
+ * inventory, blocks, variations, patterns, bindings, and optional migration
+ * hints. Supported standalone scaffolds cover package/bootstrap integrity,
+ * source layout, dependencies, and canonical generated-artifact freshness.
  *
  * @param cwd Working directory to validate for writability.
  * @param options Optional feature gates for additional doctor rows.

package/dist/runtime/shared/json-utils.d.ts

@@ -24,6 +24,13 @@
  * @returns A deep-cloned copy created with `JSON.parse(JSON.stringify(...))`.
  */
 export declare function cloneJsonValue<T>(value: T): T;
+/**
+ * Detect the indentation used by a formatted JSON document.
+ *
+ * @param source Raw JSON source text.
+ * @returns The first property indentation, or two spaces for compact/empty JSON.
+ */
+export declare function detectJsonIndent(source: string): string | number;
 /**
  * Optional metadata used to enrich JSON parse errors.
  */

package/dist/runtime/shared/json-utils.js

@@ -28,6 +28,16 @@ import { promises as fsp } from "node:fs";
 export function cloneJsonValue(value) {
     return JSON.parse(JSON.stringify(value));
 }
+/**
+ * Detect the indentation used by a formatted JSON document.
+ *
+ * @param source Raw JSON source text.
+ * @returns The first property indentation, or two spaces for compact/empty JSON.
+ */
+export function detectJsonIndent(source) {
+    const indentMatch = /\n([ \t]+)"/u.exec(source);
+    return indentMatch?.[1] ?? 2;
+}
 function formatJsonParseTarget({ context, filePath }) {
     const operation = context?.trim() || "JSON";
     return filePath ? `${operation} at ${filePath}` : operation;

package/dist/runtime/shared/package-json-types.d.ts

@@ -1,7 +1,7 @@
 export interface GeneratedPackageJson {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
-    packageManager?: string;
+    packageManager?: unknown;
     scripts?: Record<string, string>;
     wpTypia?: {
         projectType?: string;

package/dist/runtime/shared/package-versions.d.ts

@@ -19,6 +19,8 @@ export interface PackageVersions {
  * not drift across runtime modules.
  */
 export declare const DEFAULT_WORDPRESS_ABILITIES_VERSION = "^0.10.0";
+export declare const DEFAULT_WORDPRESS_BLOCKS_TYPES_VERSION = "^12.5.18";
+export declare const DEFAULT_WORDPRESS_BLOCKS_VERSION = "~15.19.0";
 export declare const DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = "^0.9.0";
 export declare const DEFAULT_WORDPRESS_CORE_DATA_VERSION = "~7.46.0";
 export declare const DEFAULT_WORDPRESS_DATA_VERSION = "~10.46.0";

package/dist/runtime/shared/package-versions.js

@@ -17,6 +17,8 @@ const DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = '^12.0.1';
  * not drift across runtime modules.
  */
 export const DEFAULT_WORDPRESS_ABILITIES_VERSION = '^0.10.0';
+export const DEFAULT_WORDPRESS_BLOCKS_TYPES_VERSION = '^12.5.18';
+export const DEFAULT_WORDPRESS_BLOCKS_VERSION = '~15.19.0';
 export const DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = '^0.9.0';
 export const DEFAULT_WORDPRESS_CORE_DATA_VERSION = '~7.46.0';
 export const DEFAULT_WORDPRESS_DATA_VERSION = '~10.46.0';

package/dist/runtime/shared/php-utils.d.ts

@@ -3,7 +3,12 @@ export type PhpFunctionRange = {
     source: string;
     start: number;
 };
-export type PhpFunctionRangeOptions = {
+/** Options controlling whether PHP call helpers scan snippets or full PHP files. */
+export type PhpFunctionCallScanOptions = {
+    /** Ignore text outside explicit PHP open/close tag regions. */
+    requirePhpOpenTag?: boolean;
+};
+export type PhpFunctionRangeOptions = PhpFunctionCallScanOptions & {
     includeTrailingNewlines?: boolean;
 };
 export type ReplacePhpFunctionDefinitionOptions = PhpFunctionRangeOptions & {
@@ -17,9 +22,38 @@ export declare function hasPhpFunctionDefinition(source: string, functionName: s
  *
  * @param source PHP source to scan.
  * @param functionName Literal PHP function identifier to find.
+ * @param options Scanner options for full files that require explicit PHP tags.
  * @returns Whether `source` contains a code-mode call to `functionName`.
  */
-export declare function hasPhpFunctionCall(source: string, functionName: string): boolean;
+export declare function hasPhpFunctionCall(source: string, functionName: string, options?: PhpFunctionCallScanOptions): boolean;
+/**
+ * Find the exclusive end offset of one PHP function call at a known offset.
+ *
+ * Parentheses inside strings, comments, heredoc, and nowdoc blocks are ignored
+ * by the same scanner used by {@link hasPhpFunctionCall}.
+ *
+ * @param source PHP source containing the call.
+ * @param functionOffset Offset where the function identifier starts.
+ * @param functionName Literal PHP function identifier expected at the offset.
+ * @param options Scanner options for full files that require explicit PHP tags.
+ * @returns The offset after the matching closing parenthesis, or `null`.
+ */
+export declare function findPhpFunctionCallEnd(source: string, functionOffset: number, functionName: string, options?: PhpFunctionCallScanOptions): number | null;
+type PhpStringArgumentMatcher = string | ((value: string) => boolean);
+/**
+ * Detect a PHP function call whose leading arguments are literal strings that
+ * satisfy the supplied matchers.
+ *
+ * Each matcher applies to the corresponding argument in the same code-mode
+ * function call. Additional arguments after the matched prefix are allowed.
+ *
+ * @param source PHP source to scan.
+ * @param functionName Literal PHP function identifier to find.
+ * @param argumentMatchers Matchers for the leading literal string arguments.
+ * @param options Scanner options for full files that require explicit PHP tags.
+ * @returns Whether one code-mode call satisfies every supplied matcher.
+ */
+export declare function hasPhpFunctionCallWithStringArguments(source: string, functionName: string, argumentMatchers: readonly PhpStringArgumentMatcher[], options?: PhpFunctionCallScanOptions): boolean;
 /**
  * Detect a PHP function call whose first argument is a variable previously
  * assigned from a literal string prefix in executable PHP code.
@@ -46,6 +80,8 @@ export declare function hasPhpFunctionCallWithStringArgumentPrefix(source: strin
  * global function call consumes the variable.
  */
 export declare function hasPhpCodeStringLiteralPrefix(source: string, literalPrefix: string): boolean;
+/** Return the PHP code-block brace depth at an executable source offset. */
+export declare function getPhpCodeBraceDepth(source: string, offset: number, options?: PhpFunctionCallScanOptions): number | null;
 /**
  * Locate a PHP function body without counting braces in non-code regions.
  *
@@ -56,3 +92,4 @@ export declare function hasPhpCodeStringLiteralPrefix(source: string, literalPre
  */
 export declare function findPhpFunctionRange(source: string, functionName: string, options?: PhpFunctionRangeOptions): PhpFunctionRange | null;
 export declare function replacePhpFunctionDefinition(source: string, functionName: string, replacement: string, options?: ReplacePhpFunctionDefinitionOptions): string | null;
+export {};

package/dist/runtime/shared/php-utils.js

@@ -202,17 +202,43 @@ function getPhpFunctionCallFirstArgumentStart(source, index, functionName) {
     }
     return skipPhpCallTrivia(source, callStart + 1);
 }
-function createPhpScannerState() {
+function createPhpScannerState(options = {}) {
+    const requirePhpOpenTag = options.requirePhpOpenTag === true;
     return {
         heredocDelimiter: "",
+        inPhp: !requirePhpOpenTag,
         interpolationComment: "",
         interpolationDepth: 0,
         interpolationQuote: "",
         mode: "code",
+        requirePhpOpenTag,
     };
 }
+function getPhpOpenTagLength(source, index) {
+    if (source.startsWith("<?=", index)) {
+        return 3;
+    }
+    if (source.slice(index, index + 5).toLowerCase() === "<?php") {
+        const nextCharacter = source[index + 5];
+        return nextCharacter === undefined || isPhpWhitespace(nextCharacter) ? 5 : 0;
+    }
+    return 0;
+}
 function advancePhpScanner(source, index, state) {
     const character = source[index];
+    if (state.requirePhpOpenTag && !state.inPhp) {
+        const openTagLength = getPhpOpenTagLength(source, index);
+        if (openTagLength > 0) {
+            state.inPhp = true;
+            state.mode = "code";
+            return {
+                ambiguous: false,
+                inCode: false,
+                index: index + openTagLength,
+            };
+        }
+        return { ambiguous: false, inCode: false, index: index + 1 };
+    }
     if (state.mode === "heredoc") {
         const closingEnd = findPhpHeredocClosingEnd(source, index, state.heredocDelimiter);
         if (closingEnd !== null) {
@@ -300,6 +326,13 @@ function advancePhpScanner(source, index, state) {
         return { ambiguous: false, inCode: false, index: index + 1 };
     }
     if (state.mode === "line-comment") {
+        if (state.requirePhpOpenTag &&
+            character === "?" &&
+            source[index + 1] === ">") {
+            state.inPhp = false;
+            state.mode = "code";
+            return { ambiguous: false, inCode: false, index: index + 2 };
+        }
         if (character === "\r" || character === "\n") {
             state.mode = "code";
         }
@@ -312,6 +345,13 @@ function advancePhpScanner(source, index, state) {
         }
         return { ambiguous: false, inCode: false, index: index + 1 };
     }
+    if (state.requirePhpOpenTag &&
+        character === "?" &&
+        source[index + 1] === ">") {
+        state.inPhp = false;
+        state.mode = "code";
+        return { ambiguous: false, inCode: false, index: index + 2 };
+    }
     if (character === "'") {
         state.mode = "single-quoted";
         return { ambiguous: false, inCode: false, index: index + 1 };
@@ -351,10 +391,11 @@ function advancePhpScanner(source, index, state) {
  *
  * @param source PHP source to scan.
  * @param functionName Literal PHP function identifier to find.
+ * @param options Scanner options for full files that require explicit PHP tags.
  * @returns Whether `source` contains a code-mode call to `functionName`.
  */
-export function hasPhpFunctionCall(source, functionName) {
-    const scanner = createPhpScannerState();
+export function hasPhpFunctionCall(source, functionName, options = {}) {
+    const scanner = createPhpScannerState(options);
     let index = 0;
     while (index < source.length) {
         const scan = advancePhpScanner(source, index, scanner);
@@ -372,6 +413,125 @@ export function hasPhpFunctionCall(source, functionName) {
     }
     return false;
 }
+/**
+ * Find the exclusive end offset of one PHP function call at a known offset.
+ *
+ * Parentheses inside strings, comments, heredoc, and nowdoc blocks are ignored
+ * by the same scanner used by {@link hasPhpFunctionCall}.
+ *
+ * @param source PHP source containing the call.
+ * @param functionOffset Offset where the function identifier starts.
+ * @param functionName Literal PHP function identifier expected at the offset.
+ * @param options Scanner options for full files that require explicit PHP tags.
+ * @returns The offset after the matching closing parenthesis, or `null`.
+ */
+export function findPhpFunctionCallEnd(source, functionOffset, functionName, options = {}) {
+    if (!matchesPhpFunctionCallAt(source, functionOffset, functionName)) {
+        return null;
+    }
+    const openParenthesis = skipPhpCallTrivia(source, functionOffset + functionName.length);
+    if (openParenthesis === null || source[openParenthesis] !== "(") {
+        return null;
+    }
+    const scanner = createPhpScannerState(options);
+    let depth = 0;
+    let index = 0;
+    while (index < source.length) {
+        const scan = advancePhpScanner(source, index, scanner);
+        if (scan.ambiguous) {
+            return null;
+        }
+        if (!scan.inCode) {
+            index = scan.index;
+            continue;
+        }
+        if (index < openParenthesis) {
+            index += 1;
+            continue;
+        }
+        if (source[index] === "(") {
+            depth += 1;
+        }
+        else if (source[index] === ")") {
+            depth -= 1;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+        index += 1;
+    }
+    return null;
+}
+function matchesPhpStringArgument(matcher, value) {
+    return typeof matcher === "string" ? value === matcher : matcher(value);
+}
+/**
+ * Detect a PHP function call whose leading arguments are literal strings that
+ * satisfy the supplied matchers.
+ *
+ * Each matcher applies to the corresponding argument in the same code-mode
+ * function call. Additional arguments after the matched prefix are allowed.
+ *
+ * @param source PHP source to scan.
+ * @param functionName Literal PHP function identifier to find.
+ * @param argumentMatchers Matchers for the leading literal string arguments.
+ * @param options Scanner options for full files that require explicit PHP tags.
+ * @returns Whether one code-mode call satisfies every supplied matcher.
+ */
+export function hasPhpFunctionCallWithStringArguments(source, functionName, argumentMatchers, options = {}) {
+    if (argumentMatchers.length === 0) {
+        return hasPhpFunctionCall(source, functionName, options);
+    }
+    const scanner = createPhpScannerState(options);
+    let index = 0;
+    while (index < source.length) {
+        const scan = advancePhpScanner(source, index, scanner);
+        if (scan.ambiguous) {
+            return false;
+        }
+        if (!scan.inCode) {
+            index = scan.index;
+            continue;
+        }
+        if (!matchesPhpFunctionCallAt(source, index, functionName)) {
+            index += 1;
+            continue;
+        }
+        let argumentStart = getPhpFunctionCallFirstArgumentStart(source, index, functionName);
+        let argumentsMatch = argumentStart !== null;
+        for (const [argumentIndex, matcher] of argumentMatchers.entries()) {
+            if (!argumentsMatch || argumentStart === null) {
+                argumentsMatch = false;
+                break;
+            }
+            const argument = parsePhpQuotedStringLiteralAt(source, argumentStart);
+            if (!argument ||
+                !matchesPhpStringArgument(matcher, argument.value)) {
+                argumentsMatch = false;
+                break;
+            }
+            const argumentEnd = skipPhpCallTrivia(source, argument.end);
+            const nextToken = argumentEnd === null ? undefined : source[argumentEnd];
+            const isLastMatcher = argumentIndex === argumentMatchers.length - 1;
+            if (isLastMatcher) {
+                argumentsMatch =
+                    argumentEnd !== null && (nextToken === "," || nextToken === ")");
+                break;
+            }
+            if (argumentEnd === null || nextToken !== ",") {
+                argumentsMatch = false;
+                break;
+            }
+            argumentStart = skipPhpCallTrivia(source, argumentEnd + 1);
+            argumentsMatch = argumentStart !== null;
+        }
+        if (argumentsMatch) {
+            return true;
+        }
+        index += functionName.length;
+    }
+    return false;
+}
 function isPhpAssignmentOperatorAt(source, index) {
     if (index === null || source[index] !== "=") {
         return false;
@@ -577,6 +737,36 @@ function hasPhpFunctionCallWithStringArgumentMatching(source, functionName, matc
     }
     return false;
 }
+/** Return the PHP code-block brace depth at an executable source offset. */
+export function getPhpCodeBraceDepth(source, offset, options = {}) {
+    const scanner = createPhpScannerState(options);
+    let depth = 0;
+    let index = 0;
+    while (index < source.length && index <= offset) {
+        const scan = advancePhpScanner(source, index, scanner);
+        if (index === offset) {
+            return !scan.ambiguous && scan.inCode ? depth : null;
+        }
+        if (scan.ambiguous) {
+            return null;
+        }
+        if (!scan.inCode) {
+            index = scan.index;
+            continue;
+        }
+        if (source[index] === "{") {
+            depth += 1;
+        }
+        else if (source[index] === "}") {
+            depth = Math.max(0, depth - 1);
+        }
+        index += 1;
+    }
+    return null;
+}
+function isPhpCodeOffset(source, offset, options) {
+    return getPhpCodeBraceDepth(source, offset, options) !== null;
+}
 /**
  * Locate a PHP function body without counting braces in non-code regions.
  *
@@ -586,8 +776,14 @@ function hasPhpFunctionCallWithStringArgumentMatching(source, functionName, matc
  * @returns The matched {@link PhpFunctionRange}, or `null` when no safe range exists.
  */
 export function findPhpFunctionRange(source, functionName, options = {}) {
-    const signaturePattern = new RegExp(`function\\s+${escapeRegex(functionName)}\\s*\\([^)]*\\)\\s*(?::\\s*[^{};]+)?\\s*\\{`, "u");
-    const signatureMatch = signaturePattern.exec(source);
+    const signaturePattern = new RegExp(`function\\s+&?\\s*${escapeRegex(functionName)}\\s*\\([^)]*\\)\\s*(?::\\s*[^{};]+)?\\s*\\{`, "gu");
+    let signatureMatch = null;
+    for (let candidate = signaturePattern.exec(source); candidate; candidate = signaturePattern.exec(source)) {
+        if (isPhpCodeOffset(source, candidate.index, options)) {
+            signatureMatch = candidate;
+            break;
+        }
+    }
     if (!signatureMatch) {
         return null;
     }
@@ -598,7 +794,10 @@ export function findPhpFunctionRange(source, functionName, options = {}) {
     }
     const openBraceIndex = functionStart + openBraceOffset;
     let depth = 0;
-    const scanner = createPhpScannerState();
+    const scanner = createPhpScannerState(options);
+    // The signature was already verified at a PHP code offset, and the body scan
+    // starts at its opening brace rather than at the beginning of the source.
+    scanner.inPhp = true;
     let index = openBraceIndex;
     while (index < source.length) {
         const scan = advancePhpScanner(source, index, scanner);

package/dist/runtime/templates/block-generator-service-core.d.ts

@@ -4,5 +4,5 @@ export declare class BlockGeneratorService {
     plan({ allowExistingDir, alternateRenderTargets, answers, cwd, dataStorageMode, externalLayerId, externalLayerSource, externalLayerSourceLabel, noInstall, packageManager, persistencePolicy, projectDir, repositoryReference, templateId, variant, withMigrationUi, withTestPreset, withWpEnv, wpVersion, }: PlanBlockInput): Promise<PlanBlockResult>;
     validate({ plan }: ValidateBlockInput): Promise<ValidateBlockResult>;
     render({ validated }: RenderBlockInput): Promise<RenderBlockResult>;
-    apply({ rendered, installDependencies, onProgress, }: ApplyBlockInput): Promise<ScaffoldProjectResult>;
+    apply({ rendered, installDependencies, onProgress, seedCompilerArtifacts, }: ApplyBlockInput): Promise<ScaffoldProjectResult>;
 }

package/dist/runtime/templates/block-generator-service-core.js

@@ -7,6 +7,7 @@ import { resolveTemplateSeed, parseTemplateLocator } from "./template-source.js"
 import { assertExternalTemplateLayersDoNotWriteProtectedOutputs, resolveExternalTemplateLayers, } from "./template-layers.js";
 import { getBuiltInTemplateOverlayDir, getBuiltInTemplateSharedLayerDirs, resolveBuiltInTemplateSource, resolveBuiltInTemplateSourceFromLayerDirs, } from "./template-builtins.js";
 import { buildTemplateVariablesFromBlockSpec, createBuiltInBlockSpec, } from "./block-generator-service-spec.js";
+import { collectBuiltInCompilerArtifactPaths } from "./scaffold-compiler-artifacts.js";
 import { assertBuiltInTemplateVariantAllowed, assertExternalLayerCompositionOptions, } from "../cli/cli-validation.js";
 const renderedArtifactCache = new WeakMap();
 function createVariablesFingerprint(variables) {
@@ -32,6 +33,9 @@ function buildProtectedTemplateOutputPaths({ codeArtifacts, spec, variables, art
         protectedOutputs.add(`${artifact.relativeDir}/block.json`);
         protectedOutputs.add(`${artifact.relativeDir}/types.ts`);
     }
+    for (const artifactPath of collectBuiltInCompilerArtifactPaths(spec.template.family, variables)) {
+        protectedOutputs.add(artifactPath);
+    }
     for (const manifest of getStarterManifestFiles(spec.template.family, variables)) {
         protectedOutputs.add(manifest.relativePath);
     }
@@ -227,7 +231,7 @@ export class BlockGeneratorService {
         });
         return rendered;
     }
-    async apply({ rendered, installDependencies, onProgress, }) {
+    async apply({ rendered, installDependencies, onProgress, seedCompilerArtifacts = true, }) {
         const cachedArtifacts = renderedArtifactCache.get(rendered);
         const currentVariablesFingerprint = createVariablesFingerprint(rendered.variables);
         const artifacts = cachedArtifacts &&
@@ -244,8 +248,9 @@ export class BlockGeneratorService {
                 templateId: rendered.spec.template.family,
                 variables: rendered.variables,
             });
+        let applyWarnings = [];
         try {
-            await applyBuiltInScaffoldProjectFiles({
+            applyWarnings = await applyBuiltInScaffoldProjectFiles({
                 allowExistingDir: rendered.target.allowExistingDir,
                 artifacts,
                 codeArtifacts,
@@ -257,6 +262,7 @@ export class BlockGeneratorService {
                 repositoryReference: rendered.target.repositoryReference,
                 gitignoreContent: rendered.gitignoreContent,
                 readmeContent: rendered.readmeContent,
+                seedCompilerArtifacts,
                 templateDir: rendered.templateDir,
                 templateId: rendered.spec.template.family,
                 variables: rendered.variables,
@@ -274,7 +280,7 @@ export class BlockGeneratorService {
             selectedVariant: rendered.selectedVariant,
             templateId: rendered.spec.template.family,
             variables: rendered.variables,
-            warnings: rendered.warnings,
+            warnings: [...rendered.warnings, ...applyWarnings],
         };
     }
 }

package/dist/runtime/templates/block-generator-service-spec.d.ts

@@ -116,6 +116,11 @@ export interface ApplyBlockInput {
     rendered: RenderBlockResult;
     installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
     onProgress?: ((event: ScaffoldProgressEvent) => void | Promise<void>) | undefined;
+    /**
+     * Whether compiler-backed metadata and REST artifacts should be seeded.
+     * Dry-run previews disable this and report the expected paths separately.
+     */
+    seedCompilerArtifacts?: boolean;
 }
 export declare function createBuiltInBlockSpec({ alternateRenderTargets, answers, dataStorageMode, persistencePolicy, templateId, withMigrationUi, withTestPreset, withWpEnv, wpVersion, }: Omit<PlanBlockInput, "allowExistingDir" | "cwd" | "noInstall" | "packageManager" | "projectDir" | "variant">): BlockSpec;
 export declare function buildTemplateVariablesFromBlockSpec(spec: BlockSpec): ScaffoldTemplateVariables;

package/dist/runtime/templates/built-in-block-artifact-documents.d.ts

@@ -1,3 +1,3 @@
-export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
+export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildBlockJsonExampleAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
 export type { AttributeDescription, EmittedAttributeDefinition, } from "./built-in-block-attribute-emitters.js";
 export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";

package/dist/runtime/templates/built-in-block-artifact-documents.js

@@ -1,2 +1,2 @@
-export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
+export { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildBlockJsonAttributes, buildBlockJsonExampleAttributes, buildManifestDocument, } from "./built-in-block-attribute-emitters.js";
 export { buildBasicAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildPersistenceAttributes, } from "./built-in-block-attribute-specs.js";

package/dist/runtime/templates/built-in-block-artifact-types.js

@@ -5,13 +5,13 @@ const STANDARD_PREAMBLE_LINES = [
     "\tTypiaValidationError,",
     "\tValidationResult,",
     '} from "@wp-typia/block-runtime/validation";',
-    'import { tags } from "typia";',
+    'import type { tags } from "@wp-typia/block-runtime/typia-tags";',
     "",
     'export type { TypiaValidationError, ValidationResult } from "@wp-typia/block-runtime/validation";',
 ];
 const VALIDATION_ONLY_PREAMBLE_LINES = [
     'import type { ValidationResult } from "@wp-typia/block-runtime/validation";',
-    'import { tags } from "typia";',
+    'import type { tags } from "@wp-typia/block-runtime/typia-tags";',
     "",
     'export type { ValidationResult } from "@wp-typia/block-runtime/validation";',
 ];