@wp-typia/project-tools 0.22.5 → 0.22.7

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

@@ -10,7 +10,7 @@ import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
 import { appendPhpSnippetBeforeClosingTag, executeWorkspaceMutationPlan, insertPhpSnippetBeforeWorkspaceAnchors, } from "./cli-add-workspace-mutation.js";
 import { updatePluginHeaderCompatibility, } from "./scaffold-compatibility.js";
 import { DEFAULT_WORDPRESS_ABILITIES_VERSION, DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION, } from "./package-versions.js";
-import { escapeRegex, findPhpFunctionRange, hasPhpFunctionDefinition, replacePhpFunctionDefinition, } from "./php-utils.js";
+import { escapeRegex, findPhpFunctionRange, hasPhpFunctionCall, hasPhpFunctionDefinition, replacePhpFunctionDefinition, } from "./php-utils.js";
 import { toPascalCase } from "./string-case.js";
 function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
     if (!existingVersion) {
@@ -130,9 +130,18 @@ function ${enqueueFunctionName}() {
         if (!hasPhpFunctionDefinition(nextSource, enqueueFunctionName)) {
             nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, enqueueFunction);
         }
-        else if (!findPhpFunctionRange(nextSource, enqueueFunctionName)?.source.includes("wp_enqueue_script_module")) {
-            nextSource =
-                replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction, { trimReplacementStart: true }) ?? nextSource;
+        else {
+            const functionRange = findPhpFunctionRange(nextSource, enqueueFunctionName);
+            const functionSource = functionRange
+                ? nextSource.slice(functionRange.start, functionRange.end)
+                : "";
+            if (!hasPhpFunctionCall(functionSource, "wp_enqueue_script_module")) {
+                const replacedSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction, { trimReplacementStart: true });
+                if (!replacedSource) {
+                    throw new Error(`Unable to repair ${path.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
+                }
+                nextSource = replacedSource;
+            }
         }
         if (!nextSource.includes(loadHook)) {
             nextSource = appendPhpSnippetBeforeClosingTag(nextSource, loadHook);
@@ -301,6 +310,7 @@ async function ensureAbilityWebpackAnchors(workspace) {
  * Write generated workflow ability sources and patch shared workspace anchors.
  */
 export async function scaffoldAbilityWorkspace({ abilitySlug, compatibilityPolicy, workspace, }) {
+    const compatibilityWarnings = [];
     const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
     const bootstrapPath = getWorkspaceBootstrapPath(workspace);
     const buildScriptPath = path.join(workspace.projectDir, "scripts", "build-workspace.mjs");
@@ -331,7 +341,11 @@ export async function scaffoldAbilityWorkspace({ abilitySlug, compatibilityPolic
             await fsp.mkdir(abilityDir, { recursive: true });
             await fsp.mkdir(path.dirname(phpFilePath), { recursive: true });
             await ensureAbilityBootstrapAnchors(workspace);
-            await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
+            await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy, {
+                onWarning: (warning) => {
+                    compatibilityWarnings.push(warning);
+                },
+            }));
             await ensureAbilityPackageScripts(workspace);
             await ensureAbilitySyncProjectAnchors(workspace);
             await ensureAbilityBuildScriptAnchors(workspace);
@@ -363,4 +377,7 @@ export async function scaffoldAbilityWorkspace({ abilitySlug, compatibilityPolic
             });
         },
     });
+    return {
+        warnings: compatibilityWarnings,
+    };
 }

package/dist/runtime/cli-add-workspace-ability.d.ts

@@ -1,8 +1,12 @@
 import { type RunAddAbilityCommandOptions } from "./cli-add-shared.js";
 /**
  * Add one typed workflow ability scaffold to an official workspace project.
+ *
+ * @returns Generated ability metadata plus non-fatal scaffold warnings, such
+ * as repaired malformed existing plugin header floor values.
  */
 export declare function runAddAbilityCommand({ abilityName, cwd, }: RunAddAbilityCommandOptions): Promise<{
     abilitySlug: string;
     projectDir: string;
+    warnings: string[];
 }>;

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

@@ -5,6 +5,9 @@ import { resolveWorkspaceProject } from "./workspace-project.js";
 import { REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, } from "./scaffold-compatibility.js";
 /**
  * Add one typed workflow ability scaffold to an official workspace project.
+ *
+ * @returns Generated ability metadata plus non-fatal scaffold warnings, such
+ * as repaired malformed existing plugin header floor values.
  */
 export async function runAddAbilityCommand({ abilityName, cwd = process.cwd(), }) {
     const workspace = resolveWorkspaceProject(cwd);
@@ -12,7 +15,7 @@ export async function runAddAbilityCommand({ abilityName, cwd = process.cwd(), }
     const inventory = readWorkspaceInventory(workspace.projectDir);
     assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
     const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
-    await scaffoldAbilityWorkspace({
+    const scaffoldResult = await scaffoldAbilityWorkspace({
         abilitySlug,
         compatibilityPolicy,
         workspace,
@@ -20,5 +23,6 @@ export async function runAddAbilityCommand({ abilityName, cwd = process.cwd(), }
     return {
         abilitySlug,
         projectDir: workspace.projectDir,
+        warnings: scaffoldResult.warnings,
     };
 }

package/dist/runtime/cli-add-workspace-admin-view-source.d.ts

@@ -1,4 +1,11 @@
 import { type AdminViewRestResource, type AdminViewSource } from './cli-add-workspace-admin-view-types.js';
+/**
+ * Assert that admin-view package dependencies are available before file writes.
+ *
+ * This is a no-op while `@wp-typia/dataviews` is publicly available on npm.
+ * The exported seam is retained so future availability checks can stay
+ * centralized ahead of scaffold mutations.
+ */
 export declare function assertAdminViewPackageAvailability(): void;
 export declare function parseAdminViewSource(source?: string): AdminViewSource | undefined;
 export declare function resolveRestResourceSource(restResources: AdminViewRestResource[], source: AdminViewSource | undefined): AdminViewRestResource | undefined;

package/dist/runtime/cli-add-workspace-admin-view-source.js

@@ -1,15 +1,14 @@
 import { assertValidGeneratedSlug } from './cli-add-shared.js';
-import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from './cli-diagnostics.js';
-import { ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV, ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS, ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN, ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN, ADMIN_VIEW_CORE_DATA_SOURCE_KIND, ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED, ADMIN_VIEW_REST_SOURCE_KIND, ADMIN_VIEW_SOURCE_USAGE, isAdminViewCoreDataSource, isAdminViewRestResourceSource, } from './cli-add-workspace-admin-view-types.js';
-function isAdminViewUnpublishedDataViewsOverrideEnabled() {
-    return (process.env[ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV]?.trim() === '1');
-}
+import { ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS, ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN, ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN, ADMIN_VIEW_CORE_DATA_SOURCE_KIND, ADMIN_VIEW_REST_SOURCE_KIND, ADMIN_VIEW_SOURCE_USAGE, isAdminViewCoreDataSource, isAdminViewRestResourceSource, } from './cli-add-workspace-admin-view-types.js';
+/**
+ * Assert that admin-view package dependencies are available before file writes.
+ *
+ * This is a no-op while `@wp-typia/dataviews` is publicly available on npm.
+ * The exported seam is retained so future availability checks can stay
+ * centralized ahead of scaffold mutations.
+ */
 export function assertAdminViewPackageAvailability() {
-    if (isAdminViewUnpublishedDataViewsOverrideEnabled() ||
-        ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED) {
-        return;
-    }
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, '`wp-typia add admin-view` is temporarily unavailable because `@wp-typia/dataviews` is not published to npm for public installs yet.');
+    return;
 }
 function assertValidCoreDataEntitySegment(label, value) {
     const trimmed = value.trim();

package/dist/runtime/cli-add-workspace-admin-view-types.d.ts

@@ -10,8 +10,6 @@ export declare const ADMIN_VIEWS_ASSET = "build/admin-views/index.asset.php";
 export declare const ADMIN_VIEWS_STYLE = "build/admin-views/style-index.css";
 export declare const ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css";
 export declare const ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php";
-export declare const ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = "WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS";
-export declare const ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false;
 export interface AdminViewRestResourceSource {
     kind: typeof ADMIN_VIEW_REST_SOURCE_KIND;
     slug: string;

package/dist/runtime/cli-add-workspace-admin-view-types.js

@@ -12,9 +12,6 @@ export const ADMIN_VIEWS_ASSET = 'build/admin-views/index.asset.php';
 export const ADMIN_VIEWS_STYLE = 'build/admin-views/style-index.css';
 export const ADMIN_VIEWS_STYLE_RTL = 'build/admin-views/style-index-rtl.css';
 export const ADMIN_VIEWS_PHP_GLOB = '/inc/admin-views/*.php';
-export const ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = 'WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS';
-// Lift this gate in the same release that publishes @wp-typia/dataviews.
-export const ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false;
 export function isAdminViewCoreDataSource(source) {
     return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
 }

package/dist/runtime/cli-add-workspace-ai-scaffold.js

@@ -14,6 +14,7 @@ import { syncAiFeatureRestArtifacts, syncAiFeatureSchemaArtifact, } from "./ai-f
  * Write generated AI feature sources and patch shared workspace anchors.
  */
 export async function scaffoldAiFeatureWorkspace({ aiFeatureSlug, compatibilityPolicy, namespace, workspace, }) {
+    const compatibilityWarnings = [];
     const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
     const bootstrapPath = getWorkspaceBootstrapPath(workspace);
     const packageJsonPath = path.join(workspace.projectDir, "package.json");
@@ -40,7 +41,11 @@ export async function scaffoldAiFeatureWorkspace({ aiFeatureSlug, compatibilityP
             await fsp.mkdir(aiFeatureDir, { recursive: true });
             await fsp.mkdir(path.dirname(phpFilePath), { recursive: true });
             await ensureAiFeatureBootstrapAnchors(workspace);
-            await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
+            await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy, {
+                onWarning: (warning) => {
+                    compatibilityWarnings.push(warning);
+                },
+            }));
             const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
             await ensureAiFeatureSyncProjectAnchors(workspace);
             await ensureAiFeatureSyncRestAnchors(workspace);
@@ -76,11 +81,14 @@ export async function scaffoldAiFeatureWorkspace({ aiFeatureSlug, compatibilityP
                 transformSource: ensureBlockConfigCanAddRestManifests,
             });
             return {
-                warnings: packageScriptChanges.addedProjectToolsDependency
-                    ? [
-                        "Added `@wp-typia/project-tools` to devDependencies for `sync-ai`. If this workspace was already installed, rerun your package manager install command before the first `wp-typia sync ai`.",
-                    ]
-                    : [],
+                warnings: [
+                    ...compatibilityWarnings,
+                    ...(packageScriptChanges.addedProjectToolsDependency
+                        ? [
+                            "Added `@wp-typia/project-tools` to devDependencies for `sync-ai`. If this workspace was already installed, rerun your package manager install command before the first `wp-typia sync ai`.",
+                        ]
+                        : []),
+                ],
             };
         },
     });

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

@@ -1,6 +1,6 @@
-import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
+import { pathExists } from "./fs-async.js";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { appendWorkspaceInventoryEntries, readWorkspaceInventory } from "./workspace-inventory.js";
 import { toKebabCase, toSnakeCase, toTitleCase } from "./string-case.js";
@@ -381,8 +381,7 @@ async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
     const variationsDir = path.join(projectDir, "src", "blocks", blockSlug, "variations");
     const variationsIndexPath = path.join(variationsDir, "index.ts");
     await fsp.mkdir(variationsDir, { recursive: true });
-    const existingVariationSlugs = fs
-        .readdirSync(variationsDir)
+    const existingVariationSlugs = (await fsp.readdir(variationsDir))
         .filter((entry) => entry.endsWith(".ts") && entry !== "index.ts")
         .map((entry) => entry.replace(/\.ts$/u, ""));
     const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
@@ -392,8 +391,7 @@ async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
     const stylesDir = path.join(projectDir, "src", "blocks", blockSlug, "styles");
     const stylesIndexPath = path.join(stylesDir, "index.ts");
     await fsp.mkdir(stylesDir, { recursive: true });
-    const existingStyleSlugs = fs
-        .readdirSync(stylesDir)
+    const existingStyleSlugs = (await fsp.readdir(stylesDir))
         .filter((entry) => entry.endsWith(".ts") && entry !== "index.ts")
         .map((entry) => entry.replace(/\.ts$/u, ""));
     const nextStyleSlugs = Array.from(new Set([...existingStyleSlugs, styleSlug])).sort();
@@ -403,8 +401,7 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
     const transformsDir = path.join(projectDir, "src", "blocks", blockSlug, "transforms");
     const transformsIndexPath = path.join(transformsDir, "index.ts");
     await fsp.mkdir(transformsDir, { recursive: true });
-    const existingTransformSlugs = fs
-        .readdirSync(transformsDir)
+    const existingTransformSlugs = (await fsp.readdir(transformsDir))
         .filter((entry) => entry.endsWith(".ts") && entry !== "index.ts")
         .map((entry) => entry.replace(/\.ts$/u, ""));
     const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
@@ -495,7 +492,7 @@ export async function runAddVariationCommand({ blockName, cwd = process.cwd(), v
     const variationsDir = path.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
     const variationFilePath = path.join(variationsDir, `${variationSlug}.ts`);
     const variationsIndexPath = path.join(variationsDir, "index.ts");
-    const shouldRemoveVariationsDirOnRollback = !fs.existsSync(variationsDir);
+    const shouldRemoveVariationsDirOnRollback = !(await pathExists(variationsDir));
     const mutationSnapshot = {
         fileSources: await snapshotWorkspaceFiles([
             blockConfigPath,
@@ -555,7 +552,7 @@ export async function runAddBlockStyleCommand({ blockName, cwd = process.cwd(),
     const stylesDir = path.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
     const styleFilePath = path.join(stylesDir, `${styleSlug}.ts`);
     const stylesIndexPath = path.join(stylesDir, "index.ts");
-    const shouldRemoveStylesDirOnRollback = !fs.existsSync(stylesDir);
+    const shouldRemoveStylesDirOnRollback = !(await pathExists(stylesDir));
     const mutationSnapshot = {
         fileSources: await snapshotWorkspaceFiles([
             blockConfigPath,
@@ -624,7 +621,7 @@ export async function runAddBlockTransformCommand({ cwd = process.cwd(), fromBlo
     const transformsDir = path.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
     const transformFilePath = path.join(transformsDir, `${transformSlug}.ts`);
     const transformsIndexPath = path.join(transformsDir, "index.ts");
-    const shouldRemoveTransformsDirOnRollback = !fs.existsSync(transformsDir);
+    const shouldRemoveTransformsDirOnRollback = !(await pathExists(transformsDir));
     const mutationSnapshot = {
         fileSources: await snapshotWorkspaceFiles([
             blockConfigPath,
@@ -695,7 +692,7 @@ export async function runAddHookedBlockCommand({ anchorBlockName, blockName, cwd
     if (resolvedAnchorBlockName === selfHookAnchor) {
         throw new Error("`wp-typia add hooked-block` cannot hook a block relative to its own block name.");
     }
-    const { blockJson, blockJsonPath } = readWorkspaceBlockJson(workspace.projectDir, blockSlug);
+    const { blockJson, blockJsonPath } = await readWorkspaceBlockJson(workspace.projectDir, blockSlug);
     const blockJsonRelativePath = path.relative(workspace.projectDir, blockJsonPath);
     const blockHooks = getMutableBlockHooks(blockJson, blockJsonRelativePath);
     if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {

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

@@ -1,11 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
-import { checkExistingFiles, createDoctorCheck, WORKSPACE_BINDING_EDITOR_ASSET, WORKSPACE_BINDING_EDITOR_SCRIPT, WORKSPACE_BINDING_SERVER_GLOB, } from "./cli-doctor-workspace-shared.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_BINDING_EDITOR_ASSET, WORKSPACE_BINDING_EDITOR_SCRIPT, WORKSPACE_BINDING_SERVER_GLOB, } from "./cli-doctor-workspace-shared.js";
 import { escapeRegex } from "./php-utils.js";
 function checkWorkspaceBindingBootstrap(projectDir, packageName) {
-    const packageBaseName = packageName.split("/").pop() ?? packageName;
-    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
     if (!fs.existsSync(bootstrapPath)) {
         return createDoctorCheck("Binding bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
     }

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

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
-import { checkExistingFiles, createDoctorCheck, WORKSPACE_FULL_BLOCK_NAME_PATTERN, WORKSPACE_GENERATED_BLOCK_ARTIFACTS, } from "./cli-doctor-workspace-shared.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_FULL_BLOCK_NAME_PATTERN, WORKSPACE_GENERATED_BLOCK_ARTIFACTS, } from "./cli-doctor-workspace-shared.js";
 import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_SET, } from "./hooked-blocks.js";
 import { hasExecutablePattern, hasUncommentedPattern, maskTypeScriptCommentsAndLiterals, } from "./ts-source-masking.js";
 const WORKSPACE_COLLECTION_IMPORT_LINE = "import '../../collection';";
@@ -306,8 +306,7 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
     ];
 }
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
-    const packageBaseName = packageName.split("/").pop() ?? packageName;
-    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
     if (!fs.existsSync(bootstrapPath)) {
         return createDoctorCheck("Pattern bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
     }

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

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { EDITOR_PLUGIN_SLOT_IDS, REST_RESOURCE_METHOD_IDS, REST_RESOURCE_NAMESPACE_PATTERN, resolveEditorPluginSlotAlias, } from "./cli-add-shared.js";
-import { checkExistingFiles, createDoctorCheck, WORKSPACE_ABILITY_EDITOR_ASSET, WORKSPACE_ABILITY_EDITOR_SCRIPT, WORKSPACE_ABILITY_GLOB, WORKSPACE_ADMIN_VIEW_ASSET, WORKSPACE_ADMIN_VIEW_GLOB, WORKSPACE_ADMIN_VIEW_SCRIPT, WORKSPACE_ADMIN_VIEW_STYLE, WORKSPACE_AI_FEATURE_GLOB, WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET, WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT, WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE, WORKSPACE_REST_RESOURCE_GLOB, } from "./cli-doctor-workspace-shared.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_ABILITY_EDITOR_ASSET, WORKSPACE_ABILITY_EDITOR_SCRIPT, WORKSPACE_ABILITY_GLOB, WORKSPACE_ADMIN_VIEW_ASSET, WORKSPACE_ADMIN_VIEW_GLOB, WORKSPACE_ADMIN_VIEW_SCRIPT, WORKSPACE_ADMIN_VIEW_STYLE, WORKSPACE_AI_FEATURE_GLOB, WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET, WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT, WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE, WORKSPACE_REST_RESOURCE_GLOB, } from "./cli-doctor-workspace-shared.js";
 import { escapeRegex } from "./php-utils.js";
 function getWorkspaceRestResourceRequiredFiles(restResource) {
     const schemaNames = new Set();
@@ -46,8 +46,7 @@ function checkWorkspaceRestResourceConfig(restResource) {
         : "REST resource namespace or methods are invalid");
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
-    const packageBaseName = packageName.split("/").pop() ?? packageName;
-    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
     if (!fs.existsSync(bootstrapPath)) {
         return createDoctorCheck("REST resource bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
     }
@@ -93,8 +92,7 @@ function checkWorkspaceAbilityConfig(projectDir, ability) {
     }
 }
 function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
-    const packageBaseName = packageName.split("/").pop() ?? packageName;
-    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
     if (!fs.existsSync(bootstrapPath)) {
         return createDoctorCheck("Ability bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
     }
@@ -169,8 +167,7 @@ function checkWorkspaceAiFeatureConfig(aiFeature) {
         : "AI feature namespace is invalid");
 }
 function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
-    const packageBaseName = packageName.split("/").pop() ?? packageName;
-    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
     if (!fs.existsSync(bootstrapPath)) {
         return createDoctorCheck("AI feature bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
     }
@@ -204,8 +201,7 @@ function checkWorkspaceEditorPluginConfig(editorPlugin) {
         : `Unsupported editor plugin slot "${editorPlugin.slot}". Expected one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")} or legacy aliases PluginSidebar, PluginDocumentSettingPanel.`);
 }
 function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
-    const packageBaseName = packageName.split("/").pop() ?? packageName;
-    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
     if (!fs.existsSync(bootstrapPath)) {
         return createDoctorCheck("Editor plugin bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
     }
@@ -269,8 +265,7 @@ function checkWorkspaceAdminViewConfig(adminView, inventory) {
         : "Admin view source must use rest-resource:<slug> with a list-capable REST resource or core-data:<postType|taxonomy>/<name>");
 }
 function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
-    const packageBaseName = packageName.split("/").pop() ?? packageName;
-    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
     if (!fs.existsSync(bootstrapPath)) {
         return createDoctorCheck("Admin view bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
     }

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

@@ -58,6 +58,14 @@ export declare function createDoctorScopeCheck(status: DoctorCheck["status"], de
  * @returns Relative PHP bootstrap filename for the workspace root.
  */
 export declare function getWorkspaceBootstrapRelativePath(packageName: string): string;
+/**
+ * Resolve the expected workspace bootstrap file inside a project root.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Absolute PHP bootstrap file path for the workspace root.
+ */
+export declare function resolveWorkspaceBootstrapPath(projectDir: string, packageName: string): string;
 /**
  * Verify that every referenced relative file exists inside a workspace.
  *

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

@@ -71,6 +71,16 @@ export function createDoctorScopeCheck(status, detail) {
 export function getWorkspaceBootstrapRelativePath(packageName) {
     return `${packageName.split("/").pop() ?? packageName}.php`;
 }
+/**
+ * Resolve the expected workspace bootstrap file inside a project root.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Absolute PHP bootstrap file path for the workspace root.
+ */
+export function resolveWorkspaceBootstrapPath(projectDir, packageName) {
+    return path.join(projectDir, getWorkspaceBootstrapRelativePath(packageName));
+}
 /**
  * Verify that every referenced relative file exists inside a workspace.
  *

package/dist/runtime/cli-help.js

@@ -52,7 +52,7 @@ Notes:
   \`add admin-view\` scaffolds an opt-in DataViews-powered WordPress admin screen under \`src/admin-views/\`.
   Pass \`--source rest-resource:<slug>\` to reuse a list-capable REST resource.
   Pass \`--source core-data:postType/post\` or \`--source core-data:taxonomy/category\` to bind a WordPress-owned entity collection.
-  Public installs currently gate this workflow until \`@wp-typia/dataviews\` is published to npm.
+  Generated admin-view workspaces add \`@wp-typia/dataviews\` and the needed WordPress DataViews packages as opt-in dependencies.
   \`query-loop\` is create-only. Use \`wp-typia create <project-dir> --template query-loop\`; \`wp-typia add block\` accepts only basic, interactivity, persistence, and compound families.
   \`add variation\` uses an existing workspace block from \`scripts/block-config.ts\`.
   \`add style\` registers a Block Styles option for an existing generated block.

package/dist/runtime/cli-init-apply.d.ts

@@ -0,0 +1,15 @@
+import { type RetrofitInitPlan } from "./cli-init-types.js";
+/**
+ * Apply the previewed retrofit init plan to disk.
+ *
+ * The command snapshots package.json and generated helper targets before
+ * writing, then rolls those files back automatically if any write fails.
+ *
+ * @param projectDir Project root that should receive the retrofit surface.
+ * @param options Optional package-manager override used for emitted scripts and
+ * follow-up guidance.
+ * @returns The applied retrofit init plan describing the persisted changes.
+ */
+export declare function applyInitPlan(projectDir: string, options?: {
+    packageManager?: string;
+}): Promise<RetrofitInitPlan>;

package/dist/runtime/cli-init-apply.js

@@ -0,0 +1,99 @@
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from "./cli-diagnostics.js";
+import { rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { buildNextProjectPackageJson, buildProjectPackageJsonSource, readProjectPackageJson, } from "./cli-init-package-json.js";
+import { createRetrofitPlan, getInitPlan } from "./cli-init-plan.js";
+import { buildRetrofitHelperFiles } from "./cli-init-templates.js";
+import { RETROFIT_APPLY_PREVIEW_NOTE, RETROFIT_ROLLBACK_NOTE, } from "./cli-init-types.js";
+async function createRetrofitMutationSnapshot(projectDir, filePaths) {
+    const scriptsDir = path.join(projectDir, "scripts");
+    const scriptsDirExisted = fs.existsSync(scriptsDir);
+    const fileSources = await snapshotWorkspaceFiles(filePaths);
+    const targetPaths = fileSources
+        .filter((entry) => entry.source === null)
+        .map((entry) => entry.filePath);
+    if (!scriptsDirExisted) {
+        targetPaths.push(scriptsDir);
+    }
+    return {
+        fileSources,
+        snapshotDirs: [],
+        targetPaths,
+    };
+}
+async function writeRetrofitFiles(options) {
+    const helperFiles = buildRetrofitHelperFiles(options.blockTargets);
+    const scriptsDir = path.join(options.projectDir, "scripts");
+    await fsp.mkdir(scriptsDir, { recursive: true });
+    await fsp.writeFile(path.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
+    for (const [relativePath, source] of Object.entries(helperFiles)) {
+        await fsp.writeFile(path.join(options.projectDir, relativePath), source, "utf8");
+    }
+}
+function buildApplyFailureError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to apply the retrofit init plan safely. The command restored the previous package.json/helper-file snapshot. ${message}`, error instanceof Error ? { cause: error } : undefined);
+}
+function toApplyNotes(previewNotes) {
+    return Array.from(new Set([
+        ...previewNotes.filter((note) => note !== "Preview only: `wp-typia init` does not write files yet." &&
+            note !== RETROFIT_APPLY_PREVIEW_NOTE),
+        RETROFIT_ROLLBACK_NOTE,
+    ]));
+}
+/**
+ * Apply the previewed retrofit init plan to disk.
+ *
+ * The command snapshots package.json and generated helper targets before
+ * writing, then rolls those files back automatically if any write fails.
+ *
+ * @param projectDir Project root that should receive the retrofit surface.
+ * @param options Optional package-manager override used for emitted scripts and
+ * follow-up guidance.
+ * @returns The applied retrofit init plan describing the persisted changes.
+ */
+export async function applyInitPlan(projectDir, options = {}) {
+    const previewPlan = getInitPlan(projectDir, options);
+    if (previewPlan.detectedLayout.kind === "unsupported") {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia init --apply` requires a supported retrofit layout. Run `wp-typia init` first to inspect the preview plan and any blocking notes.");
+    }
+    if (previewPlan.status === "already-initialized") {
+        return createRetrofitPlan({
+            ...previewPlan,
+            commandMode: "apply",
+            notes: toApplyNotes(previewPlan.notes),
+            status: "already-initialized",
+        });
+    }
+    const nextPackageJson = buildNextProjectPackageJson({
+        packageChanges: previewPlan.packageChanges,
+        packageJson: readProjectPackageJson(previewPlan.projectDir),
+        packageManager: previewPlan.packageManager,
+        projectName: previewPlan.projectName,
+    });
+    const helperFiles = buildRetrofitHelperFiles(previewPlan.blockTargets);
+    const filePaths = [
+        path.join(previewPlan.projectDir, "package.json"),
+        ...Object.keys(helperFiles).map((relativePath) => path.join(previewPlan.projectDir, relativePath)),
+    ];
+    const mutationSnapshot = await createRetrofitMutationSnapshot(previewPlan.projectDir, filePaths);
+    try {
+        await writeRetrofitFiles({
+            blockTargets: previewPlan.blockTargets,
+            packageJson: nextPackageJson,
+            projectDir: previewPlan.projectDir,
+        });
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw buildApplyFailureError(error);
+    }
+    return createRetrofitPlan({
+        ...previewPlan,
+        commandMode: "apply",
+        notes: toApplyNotes(previewPlan.notes),
+        status: "applied",
+    });
+}

package/dist/runtime/cli-init-package-json.d.ts

@@ -0,0 +1,19 @@
+import { type PackageManagerId } from "./package-managers.js";
+import type { InitDependencyChange, InitPackageManagerFieldChange, InitScriptChange, ProjectPackageJson, RetrofitInitPlan } from "./cli-init-types.js";
+export declare function readProjectPackageJson(projectDir: string): ProjectPackageJson | null;
+export declare function resolveInitPackageManager(projectDir: string, packageJson: ProjectPackageJson | null, override?: string): PackageManagerId;
+export declare function getWpTypiaCliSpecifier(): string;
+export declare function buildDependencyChanges(packageJson: ProjectPackageJson | null): InitDependencyChange[];
+export declare function buildScriptChanges(packageJson: ProjectPackageJson | null, packageManager: PackageManagerId): InitScriptChange[];
+export declare function buildPackageManagerFieldChange(packageJson: ProjectPackageJson | null, packageManager: PackageManagerId, options?: {
+    persistExplicitOverride?: boolean;
+}): InitPackageManagerFieldChange | undefined;
+export declare function hasExistingWpTypiaProjectSurface(projectDir: string, packageJson: ProjectPackageJson | null): boolean;
+export declare function buildRequiredDevDependencyMapEntries(): string[];
+export declare function buildNextProjectPackageJson(options: {
+    packageChanges: RetrofitInitPlan["packageChanges"];
+    packageJson: ProjectPackageJson | null;
+    packageManager: PackageManagerId;
+    projectName: string;
+}): ProjectPackageJson;
+export declare function buildProjectPackageJsonSource(packageJson: ProjectPackageJson): string;