@wp-typia/project-tools 0.22.5 → 0.22.6

package/dist/runtime/ai-feature-capability.js

@@ -74,6 +74,25 @@ function normalizeSelections(selections) {
     }
     return [...normalized.values()];
 }
+function validateFeatureMinimumVersions(definition) {
+    for (const [platform, value] of [
+        ['wordpress', definition.minimumVersions?.wordpress],
+        ['php', definition.minimumVersions?.php],
+    ]) {
+        if (value === undefined) {
+            continue;
+        }
+        try {
+            pickHigherVersionFloor(value, undefined);
+        }
+        catch (error) {
+            throw new Error([
+                `Invalid ${platform} minimum version floor for AI feature "${definition.id}": "${value}".`,
+                'Expected dotted numeric segments such as "6.7" or "8.1.2".',
+            ].join(' '), { cause: error });
+        }
+    }
+}
 /**
  * Resolves a normalized AI feature capability plan from a list of selections.
  *
@@ -96,6 +115,7 @@ export function resolveAiFeatureCapabilityPlan(selections, registry = DEFAULT_AI
         if (!definition) {
             throw new Error(`Unknown AI feature capability "${selection.featureId}".`);
         }
+        validateFeatureMinimumVersions(definition);
         const resolvedDefinition = {
             ...definition,
             mode: selection.mode,

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

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { syncBlockMetadata, } from "@wp-typia/block-runtime/metadata-core";
@@ -21,6 +20,7 @@ import { parseCompoundInnerBlocksPreset } from "./compound-inner-blocks.js";
 import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
 import { parseAlternateRenderTargets } from "./alternate-render-targets.js";
 import { assertExternalLayerCompositionOptions, normalizeOptionalCliString, resolveLocalCliPathOption, } from "./cli-validation.js";
+import { pathExists } from "./fs-async.js";
 const COLLECTION_IMPORT_LINE = "import '../../collection';";
 // This is a lightweight preflight heuristic for the common install layouts:
 // node_modules for npm/pnpm/bun/yarn-classic and Yarn PnP marker files.
@@ -65,11 +65,16 @@ async function renderWorkspacePersistenceServerModule(projectDir, variables) {
     const templateDir = buildServerTemplateRoot(variables.persistencePolicy);
     await copyInterpolatedDirectory(templateDir, targetDir, variables);
 }
-function hasInstalledWorkspaceDependencies(projectDir) {
-    return WORKSPACE_INSTALL_MARKERS.some((marker) => fs.existsSync(path.join(projectDir, marker)));
+async function hasInstalledWorkspaceDependencies(projectDir) {
+    for (const marker of WORKSPACE_INSTALL_MARKERS) {
+        if (await pathExists(path.join(projectDir, marker))) {
+            return true;
+        }
+    }
+    return false;
 }
-function assertWorkspaceDependenciesInstalled(workspace) {
-    if (hasInstalledWorkspaceDependencies(workspace.projectDir)) {
+async function assertWorkspaceDependenciesInstalled(workspace) {
+    if (await hasInstalledWorkspaceDependencies(workspace.projectDir)) {
         return;
     }
     throw new Error(`Workspace dependencies have not been installed yet. Run \`${formatInstallCommand(workspace.packageManager)}\` from the workspace root before using \`wp-typia add block ...\`.`);
@@ -139,19 +144,19 @@ function collectWorkspaceBlockPaths(projectDir, templateId, variables) {
     }
     return [path.join(projectDir, "src", "blocks", variables.slugKebabCase)];
 }
-function assertBlockTargetsDoNotExist(projectDir, templateId, variables) {
+async function assertBlockTargetsDoNotExist(projectDir, templateId, variables) {
     for (const targetPath of collectWorkspaceBlockPaths(projectDir, templateId, variables)) {
-        if (fs.existsSync(targetPath)) {
+        if (await pathExists(targetPath)) {
             throw new Error(`A block already exists at ${path.relative(projectDir, targetPath)}. Choose a different name.`);
         }
     }
 }
 async function updateWorkspaceMigrationConfigIfPresent(projectDir, newBlocks) {
     const configPath = path.join(projectDir, "src", "migrations", "config.ts");
-    if (!fs.existsSync(configPath)) {
+    const configSource = await readOptionalFile(configPath);
+    if (configSource === null) {
         return;
     }
-    const configSource = await fsp.readFile(configPath, "utf8");
     const config = parseMigrationConfig(configSource);
     const existingBlocks = Array.isArray(config.blocks) ? config.blocks : [];
     const nextBlocks = [
@@ -292,7 +297,7 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
     assertCompoundInnerBlocksPresetAllowed(resolvedTemplateId, innerBlocksPreset);
     const resolvedInnerBlocksPreset = parseCompoundInnerBlocksPreset(innerBlocksPreset);
     const workspace = resolveWorkspaceProject(cwd);
-    assertWorkspaceDependenciesInstalled(workspace);
+    await assertWorkspaceDependenciesInstalled(workspace);
     const normalizedExternalLayerId = normalizeOptionalCliString(externalLayerId);
     const normalizedExternalLayerSource = resolveLocalCliPathOption({
         cwd,
@@ -367,7 +372,7 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
             });
             return scaffoldResult;
         })();
-        assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
+        await assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
         const mutationSnapshot = {
             fileSources: await snapshotWorkspaceFiles([
                 blockConfigPath,

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

@@ -18,6 +18,179 @@ export function assertScaffoldDoesNotExist(options) {
         throw new Error(options.inventoryCollision.message);
     }
 }
+/**
+ * Run descriptor-backed add-kind collision checks.
+ *
+ * Use descriptors when an add kind only needs predictable filesystem and
+ * inventory targets. Keep custom checks for add kinds that depend on rendered
+ * template outputs, compound scaffolds, or other command-specific state.
+ *
+ * @param options Descriptor, context, inventory, and project root for the check.
+ * @throws {Error} When any descriptor-backed target already exists.
+ */
+function assertAddKindScaffoldDoesNotExist(options) {
+    const inventoryCollision = options.descriptor.inventoryCollision;
+    assertScaffoldDoesNotExist({
+        filesystemCollisions: options.descriptor.filesystemCollisions.map((collision) => ({
+            label: collision.label,
+            relativePath: collision.relativePath(options.context),
+        })),
+        inventoryCollision: inventoryCollision
+            ? {
+                entries: inventoryCollision.entries(options.inventory),
+                exists: (entry) => inventoryCollision.exists(entry, options.context),
+                message: inventoryCollision.message(options.context),
+            }
+            : undefined,
+        projectDir: options.projectDir,
+    });
+}
+const VARIATION_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "A variation",
+            relativePath: ({ blockSlug, slug }) => path.join("src", "blocks", blockSlug, "variations", `${slug}.ts`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.variations,
+        exists: (entry, { blockSlug, slug }) => entry.block === blockSlug && entry.slug === slug,
+        message: ({ blockSlug, slug }) => `A variation inventory entry already exists for ${blockSlug}/${slug}. Choose a different name.`,
+    },
+};
+const BLOCK_STYLE_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "A block style",
+            relativePath: ({ blockSlug, slug }) => path.join("src", "blocks", blockSlug, "styles", `${slug}.ts`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.blockStyles,
+        exists: (entry, { blockSlug, slug }) => entry.block === blockSlug && entry.slug === slug,
+        message: ({ blockSlug, slug }) => `A block style inventory entry already exists for ${blockSlug}/${slug}. Choose a different name.`,
+    },
+};
+const BLOCK_TRANSFORM_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "A block transform",
+            relativePath: ({ blockSlug, slug }) => path.join("src", "blocks", blockSlug, "transforms", `${slug}.ts`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.blockTransforms,
+        exists: (entry, { blockSlug, slug }) => entry.block === blockSlug && entry.slug === slug,
+        message: ({ blockSlug, slug }) => `A block transform inventory entry already exists for ${blockSlug}/${slug}. Choose a different name.`,
+    },
+};
+const PATTERN_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "A pattern",
+            relativePath: ({ slug }) => path.join("src", "patterns", `${slug}.php`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.patterns,
+        exists: (entry, { slug }) => entry.slug === slug,
+        message: ({ slug }) => `A pattern inventory entry already exists for ${slug}. Choose a different name.`,
+    },
+};
+const BINDING_SOURCE_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "A binding source",
+            relativePath: ({ slug }) => path.join("src", "bindings", slug),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.bindingSources,
+        exists: (entry, { slug }) => entry.slug === slug,
+        message: ({ slug }) => `A binding source inventory entry already exists for ${slug}. Choose a different name.`,
+    },
+};
+const REST_RESOURCE_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "A REST resource",
+            relativePath: ({ slug }) => path.join("src", "rest", slug),
+        },
+        {
+            label: "A REST resource bootstrap",
+            relativePath: ({ slug }) => path.join("inc", "rest", `${slug}.php`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.restResources,
+        exists: (entry, { slug }) => entry.slug === slug,
+        message: ({ slug }) => `A REST resource inventory entry already exists for ${slug}. Choose a different name.`,
+    },
+};
+const ADMIN_VIEW_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "An admin view",
+            relativePath: ({ slug }) => path.join("src", "admin-views", slug),
+        },
+        {
+            label: "An admin view bootstrap",
+            relativePath: ({ slug }) => path.join("inc", "admin-views", `${slug}.php`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.adminViews,
+        exists: (entry, { slug }) => entry.slug === slug,
+        message: ({ slug }) => `An admin view inventory entry already exists for ${slug}. Choose a different name.`,
+    },
+};
+const ABILITY_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "An ability scaffold",
+            relativePath: ({ slug }) => path.join("src", "abilities", slug),
+        },
+        {
+            label: "An ability bootstrap",
+            relativePath: ({ slug }) => path.join("inc", "abilities", `${slug}.php`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.abilities,
+        exists: (entry, { slug }) => entry.slug === slug,
+        message: ({ slug }) => `An ability inventory entry already exists for ${slug}. Choose a different name.`,
+    },
+};
+const AI_FEATURE_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "An AI feature",
+            relativePath: ({ slug }) => path.join("src", "ai-features", slug),
+        },
+        {
+            label: "An AI feature bootstrap",
+            relativePath: ({ slug }) => path.join("inc", "ai-features", `${slug}.php`),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.aiFeatures,
+        exists: (entry, { slug }) => entry.slug === slug,
+        message: ({ slug }) => `An AI feature inventory entry already exists for ${slug}. Choose a different name.`,
+    },
+};
+const EDITOR_PLUGIN_COLLISION_DESCRIPTOR = {
+    filesystemCollisions: [
+        {
+            label: "An editor plugin",
+            relativePath: ({ slug }) => path.join("src", "editor-plugins", slug),
+        },
+    ],
+    inventoryCollision: {
+        entries: (inventory) => inventory.editorPlugins,
+        exists: (entry, { slug }) => entry.slug === slug,
+        message: ({ slug }) => `An editor plugin inventory entry already exists for ${slug}. Choose a different name.`,
+    },
+};
 /**
  * Ensure a block variation scaffold does not already exist.
  *
@@ -28,18 +201,10 @@ export function assertScaffoldDoesNotExist(options) {
  * @throws {Error} When the variation file or inventory entry already exists.
  */
 export function assertVariationDoesNotExist(projectDir, blockSlug, variationSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "A variation",
-                relativePath: path.join("src", "blocks", blockSlug, "variations", `${variationSlug}.ts`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.variations,
-            exists: (entry) => entry.block === blockSlug && entry.slug === variationSlug,
-            message: `A variation inventory entry already exists for ${blockSlug}/${variationSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { blockSlug, slug: variationSlug },
+        descriptor: VARIATION_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -53,18 +218,10 @@ export function assertVariationDoesNotExist(projectDir, blockSlug, variationSlug
  * @throws {Error} When the style file or inventory entry already exists.
  */
 export function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "A block style",
-                relativePath: path.join("src", "blocks", blockSlug, "styles", `${styleSlug}.ts`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.blockStyles,
-            exists: (entry) => entry.block === blockSlug && entry.slug === styleSlug,
-            message: `A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { blockSlug, slug: styleSlug },
+        descriptor: BLOCK_STYLE_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -78,18 +235,10 @@ export function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, i
  * @throws {Error} When the transform file or inventory entry already exists.
  */
 export function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "A block transform",
-                relativePath: path.join("src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.blockTransforms,
-            exists: (entry) => entry.block === blockSlug && entry.slug === transformSlug,
-            message: `A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { blockSlug, slug: transformSlug },
+        descriptor: BLOCK_TRANSFORM_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -104,18 +253,10 @@ export function assertBlockTransformDoesNotExist(projectDir, blockSlug, transfor
  * @throws {Error} When the pattern file or inventory entry already exists.
  */
 export function assertPatternDoesNotExist(projectDir, patternSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "A pattern",
-                relativePath: path.join("src", "patterns", `${patternSlug}.php`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.patterns,
-            exists: (entry) => entry.slug === patternSlug,
-            message: `A pattern inventory entry already exists for ${patternSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { slug: patternSlug },
+        descriptor: PATTERN_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -130,18 +271,10 @@ export function assertPatternDoesNotExist(projectDir, patternSlug, inventory) {
  * @throws {Error} When the binding directory or inventory entry already exists.
  */
 export function assertBindingSourceDoesNotExist(projectDir, bindingSourceSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "A binding source",
-                relativePath: path.join("src", "bindings", bindingSourceSlug),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.bindingSources,
-            exists: (entry) => entry.slug === bindingSourceSlug,
-            message: `A binding source inventory entry already exists for ${bindingSourceSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { slug: bindingSourceSlug },
+        descriptor: BINDING_SOURCE_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -156,22 +289,10 @@ export function assertBindingSourceDoesNotExist(projectDir, bindingSourceSlug, i
  * @throws {Error} When REST resource files or inventory entry already exist.
  */
 export function assertRestResourceDoesNotExist(projectDir, restResourceSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "A REST resource",
-                relativePath: path.join("src", "rest", restResourceSlug),
-            },
-            {
-                label: "A REST resource bootstrap",
-                relativePath: path.join("inc", "rest", `${restResourceSlug}.php`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.restResources,
-            exists: (entry) => entry.slug === restResourceSlug,
-            message: `A REST resource inventory entry already exists for ${restResourceSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { slug: restResourceSlug },
+        descriptor: REST_RESOURCE_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -185,22 +306,10 @@ export function assertRestResourceDoesNotExist(projectDir, restResourceSlug, inv
  * @throws {Error} When the directory, PHP bootstrap, or inventory entry already exists.
  */
 export function assertAdminViewDoesNotExist(projectDir, adminViewSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "An admin view",
-                relativePath: path.join("src", "admin-views", adminViewSlug),
-            },
-            {
-                label: "An admin view bootstrap",
-                relativePath: path.join("inc", "admin-views", `${adminViewSlug}.php`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.adminViews,
-            exists: (entry) => entry.slug === adminViewSlug,
-            message: `An admin view inventory entry already exists for ${adminViewSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { slug: adminViewSlug },
+        descriptor: ADMIN_VIEW_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -217,22 +326,10 @@ export function assertAdminViewDoesNotExist(projectDir, adminViewSlug, inventory
  * @throws {Error} When the ability directory, PHP bootstrap, or inventory entry already exists.
  */
 export function assertAbilityDoesNotExist(projectDir, abilitySlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "An ability scaffold",
-                relativePath: path.join("src", "abilities", abilitySlug),
-            },
-            {
-                label: "An ability bootstrap",
-                relativePath: path.join("inc", "abilities", `${abilitySlug}.php`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.abilities,
-            exists: (entry) => entry.slug === abilitySlug,
-            message: `An ability inventory entry already exists for ${abilitySlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { slug: abilitySlug },
+        descriptor: ABILITY_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -247,22 +344,10 @@ export function assertAbilityDoesNotExist(projectDir, abilitySlug, inventory) {
  * @throws {Error} When AI feature files or inventory entry already exist.
  */
 export function assertAiFeatureDoesNotExist(projectDir, aiFeatureSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "An AI feature",
-                relativePath: path.join("src", "ai-features", aiFeatureSlug),
-            },
-            {
-                label: "An AI feature bootstrap",
-                relativePath: path.join("inc", "ai-features", `${aiFeatureSlug}.php`),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.aiFeatures,
-            exists: (entry) => entry.slug === aiFeatureSlug,
-            message: `An AI feature inventory entry already exists for ${aiFeatureSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { slug: aiFeatureSlug },
+        descriptor: AI_FEATURE_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }
@@ -276,18 +361,10 @@ export function assertAiFeatureDoesNotExist(projectDir, aiFeatureSlug, inventory
  * @throws {Error} When the directory or inventory entry already exists.
  */
 export function assertEditorPluginDoesNotExist(projectDir, editorPluginSlug, inventory) {
-    assertScaffoldDoesNotExist({
-        filesystemCollisions: [
-            {
-                label: "An editor plugin",
-                relativePath: path.join("src", "editor-plugins", editorPluginSlug),
-            },
-        ],
-        inventoryCollision: {
-            entries: inventory.editorPlugins,
-            exists: (entry) => entry.slug === editorPluginSlug,
-            message: `An editor plugin inventory entry already exists for ${editorPluginSlug}. Choose a different name.`,
-        },
+    assertAddKindScaffoldDoesNotExist({
+        context: { slug: editorPluginSlug },
+        descriptor: EDITOR_PLUGIN_COLLISION_DESCRIPTOR,
+        inventory,
         projectDir,
     });
 }

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

@@ -26,7 +26,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 a create-time scaffold family. Use \`wp-typia create <project-dir> --template query-loop\` instead of \`wp-typia add block\`.
   \`add variation\` targets an existing block slug from \`scripts/block-config.ts\`.
   \`add style\` registers a Block Styles option for an existing generated block.

package/dist/runtime/cli-add-kind-ids.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Canonical top-level `wp-typia add` kind ids shared by the CLI command
+ * registry, routing metadata generation, and project-tools runtime helpers.
+ *
+ * Keep this order stable because it drives help output and command metadata.
+ */
+export declare const ADD_KIND_IDS: readonly ["admin-view", "block", "variation", "style", "transform", "pattern", "binding-source", "rest-resource", "ability", "ai-feature", "hooked-block", "editor-plugin"];
+/**
+ * Union of supported top-level `wp-typia add` kind ids.
+ */
+export type AddKindId = (typeof ADD_KIND_IDS)[number];

package/dist/runtime/cli-add-kind-ids.js

@@ -0,0 +1,20 @@
+/**
+ * Canonical top-level `wp-typia add` kind ids shared by the CLI command
+ * registry, routing metadata generation, and project-tools runtime helpers.
+ *
+ * Keep this order stable because it drives help output and command metadata.
+ */
+export const ADD_KIND_IDS = [
+    "admin-view",
+    "block",
+    "variation",
+    "style",
+    "transform",
+    "pattern",
+    "binding-source",
+    "rest-resource",
+    "ability",
+    "ai-feature",
+    "hooked-block",
+    "editor-plugin",
+];

package/dist/runtime/cli-add-types.d.ts

@@ -1,11 +1,5 @@
-/**
- * Supported top-level `wp-typia add` kinds exposed by the canonical CLI.
- */
-export declare const ADD_KIND_IDS: readonly ["admin-view", "block", "variation", "style", "transform", "pattern", "binding-source", "rest-resource", "ability", "ai-feature", "hooked-block", "editor-plugin"];
-/**
- * Union of supported top-level `wp-typia add` kind ids.
- */
-export type AddKindId = (typeof ADD_KIND_IDS)[number];
+export { ADD_KIND_IDS } from "./cli-add-kind-ids.js";
+export type { AddKindId } from "./cli-add-kind-ids.js";
 /**
  * Supported plugin-level REST resource methods accepted by
  * `wp-typia add rest-resource --methods`.

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

@@ -1,20 +1,4 @@
-/**
- * Supported top-level `wp-typia add` kinds exposed by the canonical CLI.
- */
-export const ADD_KIND_IDS = [
-    "admin-view",
-    "block",
-    "variation",
-    "style",
-    "transform",
-    "pattern",
-    "binding-source",
-    "rest-resource",
-    "ability",
-    "ai-feature",
-    "hooked-block",
-    "editor-plugin",
-];
+export { ADD_KIND_IDS } from "./cli-add-kind-ids.js";
 /**
  * Supported plugin-level REST resource methods accepted by
  * `wp-typia add rest-resource --methods`.

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

@@ -2,4 +2,6 @@ import { type ScaffoldAbilityWorkspaceOptions } from "./cli-add-workspace-abilit
 /**
  * Write generated workflow ability sources and patch shared workspace anchors.
  */
-export declare function scaffoldAbilityWorkspace({ abilitySlug, compatibilityPolicy, workspace, }: ScaffoldAbilityWorkspaceOptions): Promise<void>;
+export declare function scaffoldAbilityWorkspace({ abilitySlug, compatibilityPolicy, workspace, }: ScaffoldAbilityWorkspaceOptions): Promise<{
+    warnings: string[];
+}>;