@wp-typia/project-tools 0.24.4 → 0.24.6

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

@@ -0,0 +1,108 @@
+import type { ManualRestContractAuthId, ManualRestContractHttpMethodId, RestResourceMethodId } from "./cli-add-shared.js";
+import type { WorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Normalized metadata returned after `wp-typia add rest-resource` completes.
+ *
+ * @property auth Manual-mode authentication policy when `mode` is `"manual"`.
+ * @property bodyTypeName Optional manual-mode request body type export.
+ * @property controllerClass Optional PHP controller class reference. Generated
+ * mode uses it for callbacks; manual mode records it as route-owner metadata.
+ * @property methods Generated-mode REST operation ids, or an empty array for
+ * manual contracts.
+ * @property mode Whether the scaffold wrote generated REST glue or a type-only
+ * manual contract.
+ * @property namespace REST namespace in `vendor/v1` format.
+ * @property projectDir Absolute workspace project directory.
+ * @property restResourceSlug Normalized kebab-case REST resource slug.
+ * @property secretPreserveOnEmpty Whether blank settings secret submissions
+ * should preserve the stored value when `secretFieldName` is set.
+ */
+export interface RunAddRestResourceCommandResult {
+    auth?: ManualRestContractAuthId;
+    bodyTypeName?: string;
+    controllerClass?: string;
+    controllerExtends?: string;
+    method?: ManualRestContractHttpMethodId;
+    methods: RestResourceMethodId[];
+    mode: "generated" | "manual";
+    namespace: string;
+    permissionCallback?: string;
+    pathPattern?: string;
+    projectDir: string;
+    queryTypeName?: string;
+    restResourceSlug: string;
+    responseTypeName?: string;
+    routePattern?: string;
+    secretFieldName?: string;
+    secretHasValueFieldName?: string;
+    secretMaskedResponseFieldName?: string;
+    secretPreserveOnEmpty?: boolean;
+    secretStateFieldName?: string;
+}
+/**
+ * Raw command options passed from the REST orchestrator into manual-mode
+ * contract scaffolding.
+ *
+ * @property auth Optional raw manual authentication id, validated before use.
+ * @property bodyTypeName Optional exported request body type name.
+ * @property method Optional raw HTTP method id, validated as a manual REST
+ * contract method.
+ * @property namespace Resolved REST namespace in `vendor/v1` format.
+ * @property pathPattern Optional manual route path pattern relative to the
+ * namespace.
+ * @property permissionCallback Optional manual route-owner permission callback
+ * metadata.
+ * @property restResourceSlug Normalized kebab-case REST resource slug.
+ * @property routePattern Optional manual route path alias for `pathPattern`.
+ * @property secretHasValueFieldName Optional alias for `secretStateFieldName`.
+ * @property secretMaskedResponseFieldName Optional alias for
+ * `secretStateFieldName`.
+ * @property secretFieldName Optional write-only request secret field.
+ * @property secretPreserveOnEmpty Optional normalized boolean for blank-secret
+ * preservation. Defaults to true when `secretFieldName` is set.
+ * @property workspace Resolved official workspace project.
+ */
+export interface ManualRestContractScaffoldOptions {
+    auth: string | undefined;
+    bodyTypeName: string | undefined;
+    controllerClass: string | undefined;
+    controllerExtends: string | undefined;
+    method: string | undefined;
+    namespace: string;
+    pathPattern: string | undefined;
+    permissionCallback: string | undefined;
+    queryTypeName: string | undefined;
+    responseTypeName: string | undefined;
+    restResourceSlug: string;
+    routePattern: string | undefined;
+    secretFieldName: string | undefined;
+    secretHasValueFieldName: string | undefined;
+    secretMaskedResponseFieldName: string | undefined;
+    secretPreserveOnEmpty: boolean | undefined;
+    secretStateFieldName: string | undefined;
+    workspace: WorkspaceProject;
+}
+/**
+ * Raw command options passed from the REST orchestrator into generated-mode
+ * resource scaffolding.
+ *
+ * @property controllerClass Optional PHP controller class reference.
+ * @property controllerExtends Optional PHP base class reference; requires
+ * `controllerClass`.
+ * @property methods Optional comma-separated REST method list validated into
+ * `RestResourceMethodId` values.
+ * @property namespace Resolved REST namespace in `vendor/v1` format.
+ * @property permissionCallback Optional PHP permission callback reference.
+ * @property restResourceSlug Normalized kebab-case REST resource slug.
+ * @property workspace Resolved official workspace project.
+ */
+export interface GeneratedRestResourceScaffoldOptions {
+    controllerClass: string | undefined;
+    controllerExtends: string | undefined;
+    methods: string | undefined;
+    namespace: string;
+    permissionCallback: string | undefined;
+    restResourceSlug: string;
+    routePattern: string | undefined;
+    workspace: WorkspaceProject;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,10 @@
+import { type RunAddRestResourceCommandOptions } from "./cli-add-shared.js";
+import { type RunAddRestResourceCommandResult } from "./cli-add-workspace-rest-types.js";
+/**
+ * Scaffold a workspace-level REST resource and synchronize its generated
+ * TypeScript and PHP artifacts.
+ *
+ * @param options Command options for the REST resource scaffold workflow.
+ * @returns Resolved scaffold metadata for the created REST resource.
+ */
+export declare function runAddRestResourceCommand({ auth, bodyTypeName, controllerClass, controllerExtends, cwd, manual, method, methods, namespace, permissionCallback, pathPattern, queryTypeName, restResourceName, responseTypeName, routePattern, secretFieldName, secretHasValueFieldName, secretMaskedResponseFieldName, secretPreserveOnEmpty, secretStateFieldName, }: RunAddRestResourceCommandOptions): Promise<RunAddRestResourceCommandResult>;

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

@@ -0,0 +1,51 @@
+import { assertRestResourceDoesNotExist, assertValidGeneratedSlug, normalizeBlockSlug, resolveRestResourceNamespace, } from "./cli-add-shared.js";
+import { scaffoldGeneratedRestResource } from "./cli-add-workspace-rest-generated.js";
+import { scaffoldManualRestContract } from "./cli-add-workspace-rest-manual.js";
+import { readWorkspaceInventoryAsync } from "../workspace/workspace-inventory.js";
+import { resolveWorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Scaffold a workspace-level REST resource and synchronize its generated
+ * TypeScript and PHP artifacts.
+ *
+ * @param options Command options for the REST resource scaffold workflow.
+ * @returns Resolved scaffold metadata for the created REST resource.
+ */
+export async function runAddRestResourceCommand({ auth, bodyTypeName, controllerClass, controllerExtends, cwd = process.cwd(), manual, method, methods, namespace, permissionCallback, pathPattern, queryTypeName, restResourceName, responseTypeName, routePattern, secretFieldName, secretHasValueFieldName, secretMaskedResponseFieldName, secretPreserveOnEmpty, secretStateFieldName, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const restResourceSlug = assertValidGeneratedSlug("REST resource name", normalizeBlockSlug(restResourceName), "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>]");
+    const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
+    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+    assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
+    if (manual) {
+        return scaffoldManualRestContract({
+            auth,
+            bodyTypeName,
+            controllerClass,
+            controllerExtends,
+            method,
+            namespace: resolvedNamespace,
+            pathPattern,
+            permissionCallback,
+            queryTypeName,
+            responseTypeName,
+            restResourceSlug,
+            routePattern,
+            secretFieldName,
+            secretHasValueFieldName,
+            secretMaskedResponseFieldName,
+            secretPreserveOnEmpty,
+            secretStateFieldName,
+            workspace,
+        });
+    }
+    return scaffoldGeneratedRestResource({
+        controllerClass,
+        controllerExtends,
+        methods,
+        namespace: resolvedNamespace,
+        permissionCallback,
+        restResourceSlug,
+        routePattern,
+        workspace,
+    });
+}

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

@@ -0,0 +1,22 @@
+import { type RunAddVariationCommandOptions } from "./cli-add-shared.js";
+/**
+ * Add one variation entry to an existing workspace block.
+ *
+ * @param options Command options for the variation scaffold workflow.
+ * @param options.blockName Target workspace block slug that will own the variation.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.variationName Human-entered variation name that will be normalized
+ * and validated before files are written.
+ * @returns A promise that resolves with the normalized `blockSlug`,
+ * `variationSlug`, and owning `projectDir` after the variation files and
+ * inventory entry have been written successfully.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the target block is unknown, when the variation slug is invalid, or when a
+ * conflicting file or inventory entry already exists.
+ */
+export declare function runAddVariationCommand({ blockName, cwd, variationName, }: RunAddVariationCommandOptions): Promise<{
+    blockSlug: string;
+    projectDir: string;
+    variationSlug: string;
+}>;

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

@@ -0,0 +1,162 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { pathExists } from "../shared/fs-async.js";
+import { assertVariationDoesNotExist, assertValidGeneratedSlug, normalizeBlockSlug, quoteTsString, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { ensureWorkspaceEntrypointCall } from "./cli-add-workspace-registration-hooks.js";
+import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from "../workspace/workspace-inventory.js";
+import { resolveWorkspaceProject } from "../workspace/workspace-project.js";
+import { toKebabCase, toTitleCase } from "../shared/string-case.js";
+const VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
+const VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
+const VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
+const VARIATIONS_CALL_PATTERN = /registerWorkspaceVariations\s*\(\s*\)\s*;?/u;
+function buildVariationConfigEntry(blockSlug, variationSlug) {
+    return [
+        "\t{",
+        `\t\tblock: ${quoteTsString(blockSlug)},`,
+        `\t\tfile: ${quoteTsString(`src/blocks/${blockSlug}/variations/${variationSlug}.ts`)},`,
+        `\t\tslug: ${quoteTsString(variationSlug)},`,
+        "\t},",
+    ].join("\n");
+}
+function buildVariationConstName(variationSlug) {
+    const identifierSegments = toKebabCase(variationSlug)
+        .split("-")
+        .filter(Boolean);
+    return `workspaceVariation_${identifierSegments.join("_")}`;
+}
+function getVariationConstBindings(variationSlugs) {
+    const seenConstNames = new Map();
+    return variationSlugs.map((variationSlug) => {
+        const constName = buildVariationConstName(variationSlug);
+        const previousSlug = seenConstNames.get(constName);
+        if (previousSlug && previousSlug !== variationSlug) {
+            throw new Error(`Variation slugs "${previousSlug}" and "${variationSlug}" generate the same registry identifier "${constName}". Rename one of the variations.`);
+        }
+        seenConstNames.set(constName, variationSlug);
+        return { constName, variationSlug };
+    });
+}
+function buildVariationSource(variationSlug, textDomain) {
+    const variationTitle = toTitleCase(variationSlug);
+    const variationConstName = buildVariationConstName(variationSlug);
+    return `import type { BlockVariation } from '@wp-typia/block-types/blocks/registration';
+import { __ } from '@wordpress/i18n';
+
+export const ${variationConstName} = {
+\tname: ${quoteTsString(variationSlug)},
+\ttitle: __( ${quoteTsString(variationTitle)}, ${quoteTsString(textDomain)} ),
+\tdescription: __(
+\t\t${quoteTsString(`A starter variation for ${variationTitle}.`)},
+\t\t${quoteTsString(textDomain)},
+\t),
+\tattributes: {},
+\tscope: ['inserter'],
+} satisfies BlockVariation;
+`;
+}
+function buildVariationIndexSource(variationSlugs) {
+    const variationBindings = getVariationConstBindings(variationSlugs);
+    const importLines = variationBindings
+        .map(({ constName, variationSlug }) => {
+        return `import { ${constName} } from './${variationSlug}';`;
+    })
+        .join("\n");
+    const variationConstNames = variationBindings
+        .map(({ constName }) => constName)
+        .join(",\n\t\t");
+    return `import { registerBlockVariation } from '@wordpress/blocks';
+import metadata from '../block.json';
+${importLines ? `\n${importLines}` : ""}
+
+const WORKSPACE_VARIATIONS = [
+\t${variationConstNames}
+\t// wp-typia add variation entries
+];
+
+export function registerWorkspaceVariations() {
+\tfor (const variation of WORKSPACE_VARIATIONS) {
+\t\tregisterBlockVariation(metadata.name, variation);
+\t}
+}
+`;
+}
+async function ensureVariationRegistrationHook(blockIndexPath) {
+    await ensureWorkspaceEntrypointCall({
+        blockIndexPath,
+        callLine: VARIATIONS_CALL_LINE,
+        callPattern: VARIATIONS_CALL_PATTERN,
+        importLine: VARIATIONS_IMPORT_LINE,
+        importPattern: VARIATIONS_IMPORT_PATTERN,
+    });
+}
+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 = (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();
+    await fsp.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
+}
+/**
+ * Add one variation entry to an existing workspace block.
+ *
+ * @param options Command options for the variation scaffold workflow.
+ * @param options.blockName Target workspace block slug that will own the variation.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.variationName Human-entered variation name that will be normalized
+ * and validated before files are written.
+ * @returns A promise that resolves with the normalized `blockSlug`,
+ * `variationSlug`, and owning `projectDir` after the variation files and
+ * inventory entry have been written successfully.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the target block is unknown, when the variation slug is invalid, or when a
+ * conflicting file or inventory entry already exists.
+ */
+export async function runAddVariationCommand({ blockName, cwd = process.cwd(), variationName, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const blockSlug = normalizeBlockSlug(blockName);
+    const variationSlug = assertValidGeneratedSlug("Variation name", normalizeBlockSlug(variationName), "wp-typia add variation <name> --block <block-slug>");
+    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+    resolveWorkspaceBlock(inventory, blockSlug);
+    assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
+    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
+    const blockIndexPath = path.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+    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 = !(await pathExists(variationsDir));
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles([
+            blockConfigPath,
+            blockIndexPath,
+            variationsIndexPath,
+        ]),
+        snapshotDirs: [],
+        targetPaths: [
+            variationFilePath,
+            ...(shouldRemoveVariationsDirOnRollback ? [variationsDir] : []),
+        ],
+    };
+    try {
+        await fsp.mkdir(variationsDir, { recursive: true });
+        await fsp.writeFile(variationFilePath, buildVariationSource(variationSlug, workspace.workspace.textDomain), "utf8");
+        await writeVariationRegistry(workspace.projectDir, blockSlug, variationSlug);
+        await ensureVariationRegistrationHook(blockIndexPath);
+        await appendWorkspaceInventoryEntries(workspace.projectDir, {
+            variationEntries: [buildVariationConfigEntry(blockSlug, variationSlug)],
+        });
+        return {
+            blockSlug,
+            projectDir: workspace.projectDir,
+            variationSlug,
+        };
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw error;
+    }
+}

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

@@ -0,0 +1,71 @@
+/**
+ * Compatibility facade for workspace add commands.
+ *
+ * Keep the public runtime import path stable while each workflow lives in a
+ * focused implementation module.
+ */
+/**
+ * Re-export the typed workflow ability scaffold workflow from the focused
+ * ability runtime helper module.
+ */
+export { runAddAbilityCommand } from "./cli-add-workspace-ability.js";
+/**
+ * Re-export the DataViews admin screen scaffold workflow from the focused
+ * admin-view runtime helper module.
+ */
+export { runAddAdminViewCommand } from "./cli-add-workspace-admin-view.js";
+/**
+ * Re-export the server-only AI feature scaffold workflow from the focused
+ * AI-feature runtime helper module.
+ */
+export { runAddAiFeatureCommand } from "./cli-add-workspace-ai.js";
+/**
+ * Re-export focused workspace asset scaffold commands from the companion
+ * `cli-add-workspace-assets` module.
+ */
+export { runAddBindingSourceCommand, runAddEditorPluginCommand, runAddPatternCommand, } from "./cli-add-workspace-assets.js";
+/**
+ * Re-export the block style scaffold workflow from the focused block-style
+ * runtime helper module.
+ */
+export { runAddBlockStyleCommand } from "./cli-add-workspace-block-style.js";
+/**
+ * Re-export the block transform scaffold workflow from the focused
+ * block-transform runtime helper module.
+ */
+export { runAddBlockTransformCommand, } from "./cli-add-workspace-block-transform.js";
+/**
+ * Re-export the standalone contract scaffold workflow from the focused
+ * contract runtime helper module.
+ */
+export { runAddContractCommand } from "./cli-add-workspace-contract.js";
+/**
+ * Re-export the generic core/external block variation scaffold workflow from
+ * the focused core-variation runtime helper module.
+ */
+export { runAddCoreVariationCommand } from "./cli-add-workspace-core-variation.js";
+/**
+ * Re-export the hooked-block scaffold workflow from the focused hooked-block
+ * runtime helper module.
+ */
+export { runAddHookedBlockCommand } from "./cli-add-workspace-hooked-block.js";
+/**
+ * Re-export the local integration environment scaffold workflow from the
+ * focused integration-env runtime helper module.
+ */
+export { runAddIntegrationEnvCommand } from "./cli-add-workspace-integration-env.js";
+/**
+ * Re-export the typed post-meta contract scaffold workflow from the focused
+ * post-meta runtime helper module.
+ */
+export { runAddPostMetaCommand } from "./cli-add-workspace-post-meta.js";
+/**
+ * Re-export the plugin-level REST resource scaffold workflow from the focused
+ * rest-resource runtime helper module.
+ */
+export { runAddRestResourceCommand } from "./cli-add-workspace-rest.js";
+/**
+ * Re-export the block variation scaffold workflow from the focused variation
+ * runtime helper module.
+ */
+export { runAddVariationCommand } from "./cli-add-workspace-variation.js";

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

@@ -0,0 +1,71 @@
+/**
+ * Compatibility facade for workspace add commands.
+ *
+ * Keep the public runtime import path stable while each workflow lives in a
+ * focused implementation module.
+ */
+/**
+ * Re-export the typed workflow ability scaffold workflow from the focused
+ * ability runtime helper module.
+ */
+export { runAddAbilityCommand } from "./cli-add-workspace-ability.js";
+/**
+ * Re-export the DataViews admin screen scaffold workflow from the focused
+ * admin-view runtime helper module.
+ */
+export { runAddAdminViewCommand } from "./cli-add-workspace-admin-view.js";
+/**
+ * Re-export the server-only AI feature scaffold workflow from the focused
+ * AI-feature runtime helper module.
+ */
+export { runAddAiFeatureCommand } from "./cli-add-workspace-ai.js";
+/**
+ * Re-export focused workspace asset scaffold commands from the companion
+ * `cli-add-workspace-assets` module.
+ */
+export { runAddBindingSourceCommand, runAddEditorPluginCommand, runAddPatternCommand, } from "./cli-add-workspace-assets.js";
+/**
+ * Re-export the block style scaffold workflow from the focused block-style
+ * runtime helper module.
+ */
+export { runAddBlockStyleCommand } from "./cli-add-workspace-block-style.js";
+/**
+ * Re-export the block transform scaffold workflow from the focused
+ * block-transform runtime helper module.
+ */
+export { runAddBlockTransformCommand, } from "./cli-add-workspace-block-transform.js";
+/**
+ * Re-export the standalone contract scaffold workflow from the focused
+ * contract runtime helper module.
+ */
+export { runAddContractCommand } from "./cli-add-workspace-contract.js";
+/**
+ * Re-export the generic core/external block variation scaffold workflow from
+ * the focused core-variation runtime helper module.
+ */
+export { runAddCoreVariationCommand } from "./cli-add-workspace-core-variation.js";
+/**
+ * Re-export the hooked-block scaffold workflow from the focused hooked-block
+ * runtime helper module.
+ */
+export { runAddHookedBlockCommand } from "./cli-add-workspace-hooked-block.js";
+/**
+ * Re-export the local integration environment scaffold workflow from the
+ * focused integration-env runtime helper module.
+ */
+export { runAddIntegrationEnvCommand } from "./cli-add-workspace-integration-env.js";
+/**
+ * Re-export the typed post-meta contract scaffold workflow from the focused
+ * post-meta runtime helper module.
+ */
+export { runAddPostMetaCommand } from "./cli-add-workspace-post-meta.js";
+/**
+ * Re-export the plugin-level REST resource scaffold workflow from the focused
+ * rest-resource runtime helper module.
+ */
+export { runAddRestResourceCommand } from "./cli-add-workspace-rest.js";
+/**
+ * Re-export the block variation scaffold workflow from the focused variation
+ * runtime helper module.
+ */
+export { runAddVariationCommand } from "./cli-add-workspace-variation.js";

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

@@ -0,0 +1,15 @@
+/**
+ * Public `wp-typia add` facade.
+ *
+ * The canonical CLI surface stays stable here while the implementation lives
+ * in focused internal modules:
+ * - `cli-add-shared` as a compatibility barrel around focused add helpers
+ * - `cli-add-block` for built-in block scaffolding
+ * - `cli-add-workspace` for workspace mutation commands
+ */
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, normalizeBlockSlug, PATTERN_CATALOG_SCOPE_IDS, PATTERN_SECTION_ROLE_PATTERN, PATTERN_TAG_PATTERN, suggestAddBlockTemplateId, } from "./cli-add-shared.js";
+export type { AddBlockTemplateId, AddKindId, EditorPluginSlotId, PatternCatalogScope, } from "./cli-add-shared.js";
+export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
+export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddContractCommand, runAddCoreVariationCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddIntegrationEnvCommand, runAddPatternCommand, runAddPostMetaCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
+export { getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, } from "../workspace/workspace-inventory.js";
+export type { WorkspaceBlockSelectOption } from "../workspace/workspace-inventory.js";

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

@@ -0,0 +1,13 @@
+/**
+ * Public `wp-typia add` facade.
+ *
+ * The canonical CLI surface stays stable here while the implementation lives
+ * in focused internal modules:
+ * - `cli-add-shared` as a compatibility barrel around focused add helpers
+ * - `cli-add-block` for built-in block scaffolding
+ * - `cli-add-workspace` for workspace mutation commands
+ */
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, normalizeBlockSlug, PATTERN_CATALOG_SCOPE_IDS, PATTERN_SECTION_ROLE_PATTERN, PATTERN_TAG_PATTERN, suggestAddBlockTemplateId, } from "./cli-add-shared.js";
+export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
+export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddContractCommand, runAddCoreVariationCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddIntegrationEnvCommand, runAddPatternCommand, runAddPostMetaCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
+export { getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, } from "../workspace/workspace-inventory.js";

package/dist/runtime/add/compound-inner-blocks.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Stable preset ids exposed to scaffold and UI consumers for compound
+ * InnerBlocks authoring behavior.
+ */
+export declare const COMPOUND_INNER_BLOCKS_PRESET_IDS: readonly ["freeform", "ordered", "horizontal", "locked-structure"];
+export type CompoundInnerBlocksPresetId = (typeof COMPOUND_INNER_BLOCKS_PRESET_IDS)[number];
+/**
+ * Default preset applied when callers do not provide an explicit compound
+ * InnerBlocks mode.
+ */
+export declare const DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID: CompoundInnerBlocksPresetId;
+export type CompoundInnerBlocksOrientation = "horizontal" | "vertical";
+export type CompoundInnerBlocksTemplateLock = false | "insert" | "all";
+/**
+ * Runtime-facing description of one compound InnerBlocks preset.
+ */
+export interface CompoundInnerBlocksPresetDefinition {
+    description: string;
+    directInsert: boolean;
+    label: string;
+    orientation?: CompoundInnerBlocksOrientation;
+    templateLock: CompoundInnerBlocksTemplateLock;
+}
+/**
+ * Canonical preset registry used by the CLI, generated scaffolds, and
+ * interactive forms.
+ */
+export declare const COMPOUND_INNER_BLOCKS_PRESET_REGISTRY: {
+    readonly freeform: {
+        readonly description: "Unlocked nested authoring with the default inserter and starter child template.";
+        readonly directInsert: false;
+        readonly label: "freeform";
+        readonly orientation: "vertical";
+        readonly templateLock: false;
+    };
+    readonly ordered: {
+        readonly description: "Vertical ordered flow that keeps starter structure fixed while allowing new sibling inserts.";
+        readonly directInsert: true;
+        readonly label: "ordered";
+        readonly orientation: "vertical";
+        readonly templateLock: "insert";
+    };
+    readonly horizontal: {
+        readonly description: "Horizontal nested layout with one-click direct inserts for row or tab style containers.";
+        readonly directInsert: true;
+        readonly label: "horizontal";
+        readonly orientation: "horizontal";
+        readonly templateLock: false;
+    };
+    readonly "locked-structure": {
+        readonly description: "Locked starter structure for guided document shells where authors should only edit seeded children.";
+        readonly directInsert: false;
+        readonly label: "locked-structure";
+        readonly orientation: "vertical";
+        readonly templateLock: "all";
+    };
+};
+/**
+ * Returns whether a string matches one of the supported compound preset ids.
+ */
+export declare function isCompoundInnerBlocksPresetId(value: string): value is CompoundInnerBlocksPresetId;
+/**
+ * Parses a raw CLI or config value into a supported preset id.
+ *
+ * Returns `undefined` for non-string or empty input, and throws when the input
+ * is a non-empty unsupported preset id.
+ */
+export declare function parseCompoundInnerBlocksPreset(value?: string): CompoundInnerBlocksPresetId | undefined;
+/**
+ * Resolves an optional preset id to a concrete preset, defaulting to
+ * `DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID`.
+ */
+export declare function resolveCompoundInnerBlocksPreset(value?: CompoundInnerBlocksPresetId): CompoundInnerBlocksPresetId;
+/**
+ * Looks up the preset definition for the provided preset id, applying the
+ * default preset when the input is omitted.
+ */
+export declare function getCompoundInnerBlocksPresetDefinition(value?: CompoundInnerBlocksPresetId): CompoundInnerBlocksPresetDefinition;