@wp-typia/project-tools 0.11.1 → 0.13.0

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

@@ -6,7 +6,10 @@
  * `packages/wp-typia`.
  *
  * Import `formatAddHelpText`, `runAddBlockCommand`,
- * `createAddPlaceholderMessage`, and `seedWorkspaceMigrationProject` for
+ * `runAddVariationCommand`, `runAddPatternCommand`,
+ * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * and `HOOKED_BLOCK_POSITION_IDS`,
+ * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
  * `formatHelpText` for top-level CLI usage output, scaffold helpers such as
@@ -18,7 +21,9 @@
  * template inspection flows.
  */
 export { getDoctorChecks, runDoctor, type DoctorCheck } from "./cli-doctor.js";
-export { createAddPlaceholderMessage, formatAddHelpText, runAddBlockCommand, seedWorkspaceMigrationProject } from "./cli-add.js";
+export { formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
+export { HOOKED_BLOCK_POSITION_IDS } from "./hooked-blocks.js";
+export type { HookedBlockPositionId } from "./hooked-blocks.js";
 export { formatHelpText } from "./cli-help.js";
 export { getNextSteps, getOptionalOnboarding, runScaffoldFlow, } from "./cli-scaffold.js";
 export { createReadlinePrompt, type ReadlinePrompt } from "./cli-prompt.js";

package/dist/runtime/cli-core.js

@@ -6,7 +6,10 @@
  * `packages/wp-typia`.
  *
  * Import `formatAddHelpText`, `runAddBlockCommand`,
- * `createAddPlaceholderMessage`, and `seedWorkspaceMigrationProject` for
+ * `runAddVariationCommand`, `runAddPatternCommand`,
+ * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * and `HOOKED_BLOCK_POSITION_IDS`,
+ * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
  * `formatHelpText` for top-level CLI usage output, scaffold helpers such as
@@ -18,7 +21,8 @@
  * template inspection flows.
  */
 export { getDoctorChecks, runDoctor } from "./cli-doctor.js";
-export { createAddPlaceholderMessage, formatAddHelpText, runAddBlockCommand, seedWorkspaceMigrationProject } from "./cli-add.js";
+export { formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
+export { HOOKED_BLOCK_POSITION_IDS } from "./hooked-blocks.js";
 export { formatHelpText } from "./cli-help.js";
 export { getNextSteps, getOptionalOnboarding, runScaffoldFlow, } from "./cli-scaffold.js";
 export { createReadlinePrompt } from "./cli-prompt.js";

package/dist/runtime/cli-doctor.js

@@ -4,7 +4,22 @@ import path from "node:path";
 import { execFileSync } from "node:child_process";
 import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
 import { getBuiltInTemplateLayerDirs } from "./template-builtins.js";
+import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_SET, } from "./hooked-blocks.js";
 import { listTemplates } from "./template-registry.js";
+import { readWorkspaceInventory } from "./workspace-inventory.js";
+import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, WORKSPACE_TEMPLATE_PACKAGE, tryResolveWorkspaceProject, } from "./workspace-project.js";
+const WORKSPACE_COLLECTION_IMPORT_LINE = "import '../../collection';";
+const WORKSPACE_COLLECTION_IMPORT_PATTERN = /^\s*import\s+["']\.\.\/\.\.\/collection["']\s*;?\s*$/m;
+const WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
+const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
+const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
+const WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
+    "block.json",
+    "typia.manifest.json",
+    "typia.schema.json",
+    "typia-validator.php",
+    "typia.openapi.json",
+];
 function readCommandVersion(command, args = ["--version"]) {
     try {
         return execFileSync(command, args, {
@@ -40,6 +55,194 @@ async function checkTempDirectory() {
         return false;
     }
 }
+function createDoctorCheck(label, status, detail) {
+    return { detail, label, status };
+}
+function getWorkspaceBootstrapRelativePath(packageName) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    return `${packageBaseName}.php`;
+}
+function checkExistingFiles(projectDir, label, filePaths) {
+    const missing = filePaths
+        .filter((filePath) => typeof filePath === "string")
+        .filter((filePath) => !fs.existsSync(path.join(projectDir, filePath)));
+    return createDoctorCheck(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
+}
+function checkWorkspacePackageMetadata(workspace, packageJson) {
+    const issues = [];
+    const packageName = packageJson.name;
+    const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0 ? packageName : workspace.packageName);
+    const wpTypia = packageJson.wpTypia;
+    if (typeof packageName !== "string" || packageName.length === 0) {
+        issues.push("package.json must define a string name for workspace bootstrap resolution");
+    }
+    if (wpTypia?.projectType !== "workspace") {
+        issues.push('wpTypia.projectType must be "workspace"');
+    }
+    if (wpTypia?.templatePackage !== WORKSPACE_TEMPLATE_PACKAGE) {
+        issues.push(`wpTypia.templatePackage must be "${WORKSPACE_TEMPLATE_PACKAGE}"`);
+    }
+    if (wpTypia?.namespace !== workspace.workspace.namespace) {
+        issues.push(`wpTypia.namespace must equal "${workspace.workspace.namespace}"`);
+    }
+    if (wpTypia?.textDomain !== workspace.workspace.textDomain) {
+        issues.push(`wpTypia.textDomain must equal "${workspace.workspace.textDomain}"`);
+    }
+    if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
+        issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
+    }
+    if (!fs.existsSync(path.join(workspace.projectDir, bootstrapRelativePath))) {
+        issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
+    }
+    return createDoctorCheck("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}`
+        : issues.join("; "));
+}
+function getWorkspaceBlockRequiredFiles(block) {
+    const blockDir = path.join("src", "blocks", block.slug);
+    return Array.from(new Set([
+        block.typesFile,
+        block.apiTypesFile,
+        block.openApiFile,
+        path.join(blockDir, "index.tsx"),
+        ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path.join(blockDir, fileName)),
+    ].filter((filePath) => typeof filePath === "string")));
+}
+function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
+    const blockJsonRelativePath = path.join("src", "blocks", block.slug, "block.json");
+    const blockJsonPath = path.join(projectDir, blockJsonRelativePath);
+    if (!fs.existsSync(blockJsonPath)) {
+        return createDoctorCheck(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
+    }
+    let blockJson;
+    try {
+        blockJson = JSON.parse(fs.readFileSync(blockJsonPath, "utf8"));
+    }
+    catch (error) {
+        return createDoctorCheck(`Block metadata ${block.slug}`, "fail", error instanceof Error ? error.message : String(error));
+    }
+    const expectedName = `${workspace.workspace.namespace}/${block.slug}`;
+    const issues = [];
+    if (blockJson.name !== expectedName) {
+        issues.push(`block.json name must equal "${expectedName}"`);
+    }
+    if (blockJson.textdomain !== workspace.workspace.textDomain) {
+        issues.push(`block.json textdomain must equal "${workspace.workspace.textDomain}"`);
+    }
+    return createDoctorCheck(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}`
+        : issues.join("; "));
+}
+function checkWorkspaceBlockHooks(projectDir, blockSlug) {
+    const blockJsonRelativePath = path.join("src", "blocks", blockSlug, "block.json");
+    const blockJsonPath = path.join(projectDir, blockJsonRelativePath);
+    if (!fs.existsSync(blockJsonPath)) {
+        return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
+    }
+    let blockJson;
+    try {
+        blockJson = JSON.parse(fs.readFileSync(blockJsonPath, "utf8"));
+    }
+    catch (error) {
+        return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", error instanceof Error ? error.message : String(error));
+    }
+    const blockHooks = blockJson.blockHooks;
+    if (blockHooks === undefined) {
+        return createDoctorCheck(`Block hooks ${blockSlug}`, "pass", "No blockHooks metadata configured");
+    }
+    if (!blockHooks || typeof blockHooks !== "object" || Array.isArray(blockHooks)) {
+        return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", `${blockJsonRelativePath} must define blockHooks as an object when present.`);
+    }
+    const blockName = typeof blockJson.name === "string" && blockJson.name.trim().length > 0
+        ? blockJson.name.trim()
+        : null;
+    const invalidEntries = Object.entries(blockHooks).filter(([anchor, position]) => (blockName !== null && anchor.trim() === blockName) ||
+        anchor.trim().length === 0 ||
+        anchor !== anchor.trim() ||
+        !HOOKED_BLOCK_ANCHOR_PATTERN.test(anchor) ||
+        typeof position !== "string" ||
+        !HOOKED_BLOCK_POSITION_SET.has(position));
+    return createDoctorCheck(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0
+        ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0 ? ` (${Object.keys(blockHooks).join(", ")})` : ""}`
+        : `Invalid blockHooks entries: ${invalidEntries
+            .map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`)
+            .join(", ")}`);
+}
+function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
+    const entryRelativePath = path.join("src", "blocks", blockSlug, "index.tsx");
+    const entryPath = path.join(projectDir, entryRelativePath);
+    if (!fs.existsSync(entryPath)) {
+        return createDoctorCheck(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
+    }
+    const source = fs.readFileSync(entryPath, "utf8");
+    const hasCollectionImport = WORKSPACE_COLLECTION_IMPORT_PATTERN.test(source);
+    return createDoctorCheck(`Block collection ${blockSlug}`, hasCollectionImport ? "pass" : "fail", hasCollectionImport
+        ? "Shared block collection import is present"
+        : `Missing a shared collection import like ${WORKSPACE_COLLECTION_IMPORT_LINE}`);
+}
+function checkWorkspacePatternBootstrap(projectDir, packageName) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Pattern bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const hasCategoryAnchor = source.includes("register_block_pattern_category");
+    const hasPatternGlob = source.includes("/src/patterns/*.php");
+    return createDoctorCheck("Pattern bootstrap", hasCategoryAnchor && hasPatternGlob ? "pass" : "fail", hasCategoryAnchor && hasPatternGlob
+        ? "Pattern category and loader hooks are present"
+        : "Missing pattern category registration or src/patterns loader hook");
+}
+function checkWorkspaceBindingBootstrap(projectDir, packageName) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Binding bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
+    const hasEditorEnqueueHook = source.includes("enqueue_block_editor_assets");
+    const hasEditorScript = source.includes(WORKSPACE_BINDING_EDITOR_SCRIPT);
+    const hasEditorAsset = source.includes(WORKSPACE_BINDING_EDITOR_ASSET);
+    return createDoctorCheck("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset
+        ? "Binding source PHP and editor bootstrap hooks are present"
+        : "Missing binding source PHP require glob or editor enqueue hook");
+}
+function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
+    const indexRelativePath = [path.join("src", "bindings", "index.ts"), path.join("src", "bindings", "index.js")].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+    if (!indexRelativePath) {
+        return createDoctorCheck("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
+    }
+    const indexPath = path.join(projectDir, indexRelativePath);
+    const source = fs.readFileSync(indexPath, "utf8");
+    const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
+    return createDoctorCheck("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0
+        ? "Binding source editor registrations are aggregated"
+        : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
+}
+function checkVariationEntrypoint(projectDir, blockSlug) {
+    const entryPath = path.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+    if (!fs.existsSync(entryPath)) {
+        return createDoctorCheck(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path.relative(projectDir, entryPath)}`);
+    }
+    const source = fs.readFileSync(entryPath, "utf8");
+    const hasImport = source.includes("./variations");
+    const hasCall = source.includes("registerWorkspaceVariations()");
+    return createDoctorCheck(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall
+        ? "Variations registration hook is present"
+        : "Missing ./variations import or registerWorkspaceVariations() call");
+}
+function checkMigrationWorkspaceHint(workspace, packageJson) {
+    const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
+    const migrationConfigRelativePath = path.join("src", "migrations", "config.ts");
+    const hasMigrationConfig = fs.existsSync(path.join(workspace.projectDir, migrationConfigRelativePath));
+    if (!hasMigrationScript && !hasMigrationConfig) {
+        return null;
+    }
+    return createDoctorCheck("Migration workspace", hasMigrationConfig ? "pass" : "fail", hasMigrationConfig
+        ? "Run `wp-typia migrate doctor --all` for migration target, snapshot, fixture, and generated artifact checks"
+        : `Missing ${migrationConfigRelativePath} for the configured migration workspace`);
+}
 /**
  * Collect all runtime doctor checks for the current environment.
  *
@@ -109,6 +312,82 @@ export async function getDoctorChecks(cwd) {
             detail: hasAssets ? layerDirs.join(" + ") : "Missing core template assets",
         });
     }
+    let workspace = null;
+    let invalidWorkspaceReason = null;
+    try {
+        invalidWorkspaceReason = getInvalidWorkspaceProjectReason(cwd);
+        workspace = tryResolveWorkspaceProject(cwd);
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+        return checks;
+    }
+    if (!workspace) {
+        if (invalidWorkspaceReason) {
+            checks.push(createDoctorCheck("Workspace package metadata", "fail", invalidWorkspaceReason));
+        }
+        return checks;
+    }
+    checks.push(createDoctorCheck("Workspace marker", "pass", `Official workspace detected for ${workspace.workspace.namespace}`));
+    let workspacePackageJson;
+    try {
+        workspacePackageJson = parseWorkspacePackageJson(workspace.projectDir);
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+        return checks;
+    }
+    checks.push(checkWorkspacePackageMetadata(workspace, workspacePackageJson));
+    try {
+        const inventory = readWorkspaceInventory(workspace.projectDir);
+        checks.push(createDoctorCheck("Workspace inventory", "pass", `${inventory.blocks.length} block(s), ${inventory.variations.length} variation(s), ${inventory.patterns.length} pattern(s), ${inventory.bindingSources.length} binding source(s)`));
+        for (const block of inventory.blocks) {
+            checks.push(checkExistingFiles(workspace.projectDir, `Block ${block.slug}`, [
+                ...getWorkspaceBlockRequiredFiles(block),
+            ]));
+            checks.push(checkWorkspaceBlockMetadata(workspace.projectDir, workspace, block));
+            checks.push(checkWorkspaceBlockHooks(workspace.projectDir, block.slug));
+            checks.push(checkWorkspaceBlockCollectionImport(workspace.projectDir, block.slug));
+        }
+        const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
+        const variationTargetBlocks = new Set();
+        for (const variation of inventory.variations) {
+            if (!registeredBlockSlugs.has(variation.block)) {
+                checks.push(createDoctorCheck(`Variation ${variation.block}/${variation.slug}`, "fail", `Variation references unknown block "${variation.block}"`));
+                continue;
+            }
+            variationTargetBlocks.add(variation.block);
+            checks.push(checkExistingFiles(workspace.projectDir, `Variation ${variation.block}/${variation.slug}`, [variation.file]));
+        }
+        for (const blockSlug of variationTargetBlocks) {
+            checks.push(checkVariationEntrypoint(workspace.projectDir, blockSlug));
+        }
+        const shouldCheckPatternBootstrap = inventory.patterns.length > 0 ||
+            fs.existsSync(path.join(workspace.projectDir, "src", "patterns"));
+        if (shouldCheckPatternBootstrap) {
+            checks.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
+        }
+        for (const pattern of inventory.patterns) {
+            checks.push(checkExistingFiles(workspace.projectDir, `Pattern ${pattern.slug}`, [pattern.file]));
+        }
+        if (inventory.bindingSources.length > 0) {
+            checks.push(checkWorkspaceBindingBootstrap(workspace.projectDir, workspace.packageName));
+            checks.push(checkWorkspaceBindingSourcesIndex(workspace.projectDir, inventory.bindingSources));
+        }
+        for (const bindingSource of inventory.bindingSources) {
+            checks.push(checkExistingFiles(workspace.projectDir, `Binding source ${bindingSource.slug}`, [
+                bindingSource.serverFile,
+                bindingSource.editorFile,
+            ]));
+        }
+        const migrationWorkspaceCheck = checkMigrationWorkspaceHint(workspace, workspacePackageJson);
+        if (migrationWorkspaceCheck) {
+            checks.push(migrationWorkspaceCheck);
+        }
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace inventory", "fail", error instanceof Error ? error.message : String(error)));
+    }
     return checks;
 }
 /**

package/dist/runtime/cli-help.js

@@ -17,8 +17,10 @@ export function formatHelpText() {
   wp-typia create <project-dir> [--template compound] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
   wp-typia <project-dir> [create flags...]
   wp-typia add block <name> --template <basic|interactivity|persistence|compound> [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
-  wp-typia add variation
-  wp-typia add pattern
+  wp-typia add variation <name> --block <block-slug>
+  wp-typia add pattern <name>
+  wp-typia add binding-source <name>
+  wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>
   wp-typia migrate <init|snapshot|diff|scaffold|verify|doctor|fixtures|fuzz> [...]
   wp-typia templates list
   wp-typia templates inspect <id>
@@ -32,6 +34,11 @@ Package managers: ${PACKAGE_MANAGER_IDS.join(", ")}
 Notes:
   \`wp-typia create\` is the canonical scaffold command.
   \`wp-typia <project-dir>\` remains a backward-compatible alias to \`create\`.
-  \`add variation\` and \`add pattern\` are reserved placeholders in this release.
+  \`add variation\` uses an existing workspace block from \`scripts/block-config.ts\`.
+  \`add pattern\` scaffolds a namespaced PHP pattern shell under \`src/patterns/\`.
+  \`add binding-source\` scaffolds shared PHP and editor registration under \`src/bindings/\`.
+  \`add hooked-block\` patches an existing workspace block's \`block.json\` \`blockHooks\` metadata.
+  \`wp-typia doctor\` checks environment readiness plus workspace inventory and source-tree drift.
+  \`wp-typia migrate doctor --all\` checks migration target alignment, snapshots, fixtures, and generated migration artifacts.
   \`migrate\` is the canonical migration command; \`migrations\` is no longer supported.`;
 }

package/dist/runtime/hooked-blocks.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared hooked-block metadata primitives used by add flows, doctor checks,
+ * and interactive prompts.
+ */
+export declare const HOOKED_BLOCK_POSITION_IDS: readonly ["before", "after", "firstChild", "lastChild"];
+/**
+ * Union of valid `blockHooks` positions accepted by wp-typia workspace flows.
+ */
+export type HookedBlockPositionId = (typeof HOOKED_BLOCK_POSITION_IDS)[number];
+/**
+ * Fast lookup set for validating hooked-block positions across runtime surfaces.
+ */
+export declare const HOOKED_BLOCK_POSITION_SET: Set<string>;
+/**
+ * Canonical `namespace/slug` block name format required for hooked-block anchors.
+ */
+export declare const HOOKED_BLOCK_ANCHOR_PATTERN: RegExp;

package/dist/runtime/hooked-blocks.js

@@ -0,0 +1,13 @@
+/**
+ * Shared hooked-block metadata primitives used by add flows, doctor checks,
+ * and interactive prompts.
+ */
+export const HOOKED_BLOCK_POSITION_IDS = ["before", "after", "firstChild", "lastChild"];
+/**
+ * Fast lookup set for validating hooked-block positions across runtime surfaces.
+ */
+export const HOOKED_BLOCK_POSITION_SET = new Set(HOOKED_BLOCK_POSITION_IDS);
+/**
+ * Canonical `namespace/slug` block name format required for hooked-block anchors.
+ */
+export const HOOKED_BLOCK_ANCHOR_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/;

package/dist/runtime/index.d.ts

@@ -1,9 +1,21 @@
+/**
+ * Public runtime surface for wp-typia project tools.
+ *
+ * This barrel exposes the stable orchestration APIs that power the `wp-typia`
+ * CLI while keeping reusable project logic out of the CLI package itself.
+ * Consumers should prefer these exports for scaffold, add, migrate, doctor,
+ * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`,
+ * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
+ */
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand, } from "./migrations.js";
+export { parseWorkspacePackageManagerId, resolveWorkspaceProject, tryResolveWorkspaceProject, } from "./workspace-project.js";
 export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, } from "./schema-core.js";
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 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 { createAddPlaceholderMessage, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, runAddBlockCommand, runDoctor, runScaffoldFlow, } from "./cli-core.js";
-export type { DoctorCheck, ReadlinePrompt } from "./cli-core.js";
+export { createReadlinePrompt, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export type { DoctorCheck, HookedBlockPositionId, ReadlinePrompt } from "./cli-core.js";

package/dist/runtime/index.js

@@ -1,7 +1,19 @@
+/**
+ * Public runtime surface for wp-typia project tools.
+ *
+ * This barrel exposes the stable orchestration APIs that power the `wp-typia`
+ * CLI while keeping reusable project logic out of the CLI package itself.
+ * Consumers should prefer these exports for scaffold, add, migrate, doctor,
+ * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`,
+ * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
+ */
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand, } from "./migrations.js";
+export { parseWorkspacePackageManagerId, resolveWorkspaceProject, tryResolveWorkspaceProject, } from "./workspace-project.js";
 export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, } from "./schema-core.js";
 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 { createAddPlaceholderMessage, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, runAddBlockCommand, runDoctor, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/migrations.d.ts

@@ -1,7 +1,7 @@
 import { createMigrationDiff } from "./migration-diff.js";
 import { formatDiffReport } from "./migration-render.js";
 import { createMigrationRiskSummary } from "./migration-risk.js";
-import type { MigrationBlockConfig, ParsedMigrationArgs, RenderLine } from "./migration-types.js";
+import type { MigrationBlockConfig, MigrationProjectState, ParsedMigrationArgs, RenderLine } from "./migration-types.js";
 import type { ReadlinePrompt } from "./cli-prompt.js";
 type CommandRenderOptions = {
     prompt?: ReadlinePrompt;
@@ -78,7 +78,7 @@ export { formatDiffReport };
  * @param options Optional prompt/render hooks for testable and interactive execution.
  * @returns The command result, or a promise when the selected command is interactive.
  */
-export declare function runMigrationCommand(command: ParsedMigrationArgs, cwd: string, { prompt, renderLine }?: CommandRenderOptions): import("./migration-types.js").MigrationProjectState | import("./migration-types.js").MigrationDiff | MigrationPlanSummary | Promise<MigrationPlanSummary | {
+export declare function runMigrationCommand(command: ParsedMigrationArgs, cwd: string, { prompt, renderLine }?: CommandRenderOptions): MigrationProjectState | import("./migration-types.js").MigrationDiff | MigrationPlanSummary | Promise<MigrationPlanSummary | {
     cancelled: true;
 }> | {
     block: import("./migration-types.js").ResolvedMigrationBlockTarget;
@@ -139,7 +139,7 @@ export declare function wizardProjectMigrations(projectDir: string, { isInteract
  * @returns The loaded migration project state after the config, snapshots, and generated files are written.
  * @throws Error When the project layout is unsupported or the migration version label is invalid.
  */
-export declare function initProjectMigrations(projectDir: string, currentMigrationVersion: string, { renderLine }?: CommandRenderOptions): import("./migration-types.js").MigrationProjectState;
+export declare function initProjectMigrations(projectDir: string, currentMigrationVersion: string, { renderLine }?: CommandRenderOptions): MigrationProjectState;
 /**
  * Captures the current project state as a named migration snapshot and refreshes generated artifacts.
  *
@@ -152,7 +152,7 @@ export declare function initProjectMigrations(projectDir: string, currentMigrati
 export declare function snapshotProjectVersion(projectDir: string, migrationVersion: string, { renderLine, skipConfigUpdate, skipSyncTypes, }?: CommandRenderOptions & {
     skipConfigUpdate?: boolean;
     skipSyncTypes?: boolean;
-}): import("./migration-types.js").MigrationProjectState;
+}): MigrationProjectState;
 /**
  * Computes and renders migration diffs for a selected legacy-to-target edge.
  *
@@ -246,4 +246,4 @@ export declare function fuzzProjectMigrations(projectDir: string, { all, fromMig
  * @param options Console rendering options for initialization output.
  * @returns The loaded migration project state after initialization completes.
  */
-export declare function seedProjectMigrations(projectDir: string, currentMigrationVersion: string, blocks: MigrationBlockConfig[], { renderLine }?: CommandRenderOptions): import("./migration-types.js").MigrationProjectState;
+export declare function seedProjectMigrations(projectDir: string, currentMigrationVersion: string, blocks: MigrationBlockConfig[], { renderLine }?: CommandRenderOptions): MigrationProjectState;

package/dist/runtime/migrations.js

@@ -11,6 +11,8 @@ import { assertRuleHasNoTodos, assertNoLegacySemverMigrationWorkspace, discoverM
 import { formatDiffReport, renderFuzzFile, renderGeneratedDeprecatedFile, renderGeneratedMigrationIndexFile, renderMigrationRegistryFile, renderMigrationRuleFile, renderPhpMigrationRegistryFile, renderVerifyFile, } from "./migration-render.js";
 import { createMigrationRiskSummary, formatMigrationRiskSummary } from "./migration-risk.js";
 import { assertMigrationVersionLabel, compareMigrationVersionLabels, copyFile, detectPackageManagerId, formatLegacyMigrationWorkspaceResetGuidance, getLocalTsxBinary, isInteractiveTerminal, readJson, resolveTargetMigrationVersion, runProjectScriptIfPresent, sanitizeSaveSnapshotSource, sanitizeSnapshotBlockJson, } from "./migration-utils.js";
+import { readWorkspaceInventory } from "./workspace-inventory.js";
+import { getInvalidWorkspaceProjectReason, tryResolveWorkspaceProject } from "./workspace-project.js";
 /**
  * Returns the formatted help text for migration CLI commands and flags.
  *
@@ -561,6 +563,48 @@ export function verifyProjectMigrations(projectDir, { all = false, fromMigration
     }
     return { verifiedVersions: targetVersions };
 }
+function recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck) {
+    let invalidWorkspaceReason = null;
+    let workspace;
+    try {
+        invalidWorkspaceReason = getInvalidWorkspaceProjectReason(projectDir);
+        workspace = tryResolveWorkspaceProject(projectDir);
+    }
+    catch (error) {
+        recordCheck("fail", "Workspace migration targets", error instanceof Error ? error.message : String(error));
+        return;
+    }
+    if (!workspace) {
+        if (invalidWorkspaceReason) {
+            recordCheck("fail", "Workspace migration targets", invalidWorkspaceReason);
+        }
+        return;
+    }
+    try {
+        const inventory = readWorkspaceInventory(workspace.projectDir);
+        const expectedTargets = inventory.blocks.map((block) => `${workspace.workspace.namespace}/${block.slug}`);
+        const configuredTargets = state.blocks.map((block) => block.blockName);
+        const expectedTargetSet = new Set(expectedTargets);
+        const configuredTargetSet = new Set(configuredTargets);
+        const missingTargets = expectedTargets.filter((target) => !configuredTargetSet.has(target));
+        const staleTargets = configuredTargets.filter((target) => !expectedTargetSet.has(target));
+        recordCheck(missingTargets.length === 0 && staleTargets.length === 0 ? "pass" : "fail", "Workspace migration targets", missingTargets.length === 0 && staleTargets.length === 0
+            ? `${expectedTargets.length} workspace block target(s) align with migration config`
+            : [
+                missingTargets.length > 0
+                    ? `Missing from migration config: ${missingTargets.join(", ")}`
+                    : null,
+                staleTargets.length > 0
+                    ? `Not present in scripts/block-config.ts: ${staleTargets.join(", ")}`
+                    : null,
+            ]
+                .filter((detail) => typeof detail === "string")
+                .join("; "));
+    }
+    catch (error) {
+        recordCheck("fail", "Workspace migration targets", error instanceof Error ? error.message : String(error));
+    }
+}
 /**
  * Validate the migration workspace without mutating files.
  *
@@ -591,6 +635,7 @@ export function doctorProjectMigrations(projectDir, { all = false, fromMigration
     const snapshotVersions = new Set(targetVersions.length > 0
         ? [state.config.currentMigrationVersion, ...targetVersions]
         : state.config.supportedMigrationVersions);
+    recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck);
     for (const version of snapshotVersions) {
         for (const block of state.blocks) {
             const snapshotRoot = getSnapshotRoot(projectDir, block, version);

package/dist/runtime/package-managers.js

@@ -2,7 +2,7 @@ const PACKAGE_MANAGER_DATA = [
     {
         id: "bun",
         label: "Bun",
-        packageManagerField: "bun@1.3.10",
+        packageManagerField: "bun@1.3.11",
         installCommand: "bun install",
         frozenInstallCommand: "bun install --frozen-lockfile",
     },