@wp-typia/project-tools 0.12.0 → 0.13.1

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

@@ -1,8 +1,9 @@
 import { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";
+import { type HookedBlockPositionId } from "./hooked-blocks.js";
 /**
  * Supported top-level `wp-typia add` kinds exposed by the canonical CLI.
  */
-export declare const ADD_KIND_IDS: readonly ["block", "variation", "pattern"];
+export declare const ADD_KIND_IDS: readonly ["block", "variation", "pattern", "binding-source", "hooked-block"];
 export type AddKindId = (typeof ADD_KIND_IDS)[number];
 /**
  * Supported built-in block families accepted by `wp-typia add block --template`.
@@ -18,6 +19,16 @@ interface RunAddPatternCommandOptions {
     cwd?: string;
     patternName: string;
 }
+interface RunAddBindingSourceCommandOptions {
+    bindingSourceName: string;
+    cwd?: string;
+}
+interface RunAddHookedBlockCommandOptions {
+    anchorBlockName: string;
+    blockName: string;
+    cwd?: string;
+    position: string;
+}
 interface RunAddBlockCommandOptions {
     blockName: string;
     cwd?: string;
@@ -81,4 +92,43 @@ export declare function runAddPatternCommand({ cwd, patternName, }: RunAddPatter
     patternSlug: string;
     projectDir: string;
 }>;
+/**
+ * Add one block binding source scaffold to an official workspace project.
+ *
+ * @param options Command options for the binding-source scaffold workflow.
+ * @param options.bindingSourceName Human-entered binding source name that will
+ * be normalized and validated before files are written.
+ * @param options.cwd Working directory used to resolve the nearest official
+ * workspace. Defaults to `process.cwd()`.
+ * @returns A promise that resolves with the normalized `bindingSourceSlug` and
+ * owning `projectDir` after the server/editor files and inventory entry have
+ * been written successfully.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the slug is invalid, or when a conflicting file or inventory entry exists.
+ */
+export declare function runAddBindingSourceCommand({ bindingSourceName, cwd, }: RunAddBindingSourceCommandOptions): Promise<{
+    bindingSourceSlug: string;
+    projectDir: string;
+}>;
+/**
+ * Add one `blockHooks` entry to an existing official workspace block.
+ *
+ * @param options Command options for the hooked-block workflow.
+ * @param options.anchorBlockName Full block name that will anchor the insertion.
+ * @param options.blockName Existing workspace block slug to patch.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.position Hook position to store in `block.json`.
+ * @returns A promise that resolves with the normalized target block slug, anchor
+ * block name, position, and owning project directory after `block.json` is written.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the target block is unknown, when required flags are missing, or when the
+ * block already defines a hook for the requested anchor.
+ */
+export declare function runAddHookedBlockCommand({ anchorBlockName, blockName, cwd, position, }: RunAddHookedBlockCommandOptions): Promise<{
+    anchorBlockName: string;
+    blockSlug: string;
+    position: HookedBlockPositionId;
+    projectDir: string;
+}>;
 export { getWorkspaceBlockSelectOptions };

package/dist/runtime/cli-add.js

@@ -10,11 +10,12 @@ import { SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
 import { copyInterpolatedDirectory } from "./template-render.js";
 import { toKebabCase, toTitleCase, toSnakeCase, } from "./string-case.js";
 import { appendWorkspaceInventoryEntries, getWorkspaceBlockSelectOptions, readWorkspaceInventory, } from "./workspace-inventory.js";
+import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_IDS, } from "./hooked-blocks.js";
 import { resolveWorkspaceProject, WORKSPACE_TEMPLATE_PACKAGE, } from "./workspace-project.js";
 /**
  * Supported top-level `wp-typia add` kinds exposed by the canonical CLI.
  */
-export const ADD_KIND_IDS = ["block", "variation", "pattern"];
+export const ADD_KIND_IDS = ["block", "variation", "pattern", "binding-source", "hooked-block"];
 /**
  * Supported built-in block families accepted by `wp-typia add block --template`.
  */
@@ -29,6 +30,9 @@ const REST_MANIFEST_IMPORT_PATTERN = /import\s*\{[^}]*\bdefineEndpointManifest\b
 const VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
 const VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
 const PATTERN_BOOTSTRAP_CATEGORY = "register_block_pattern_category";
+const BINDING_SOURCE_SERVER_GLOB = "/src/bindings/*/server.php";
+const BINDING_SOURCE_EDITOR_SCRIPT = "build/bindings/index.js";
+const BINDING_SOURCE_EDITOR_ASSET = "build/bindings/index.asset.php";
 const WORKSPACE_GENERATED_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
 function normalizeBlockSlug(input) {
     return toKebabCase(input);
@@ -42,6 +46,12 @@ function assertValidGeneratedSlug(label, slug, usage) {
     }
     return slug;
 }
+function assertValidHookedBlockPosition(position) {
+    if (HOOKED_BLOCK_POSITION_IDS.includes(position)) {
+        return position;
+    }
+    throw new Error(`Hook position must be one of: ${HOOKED_BLOCK_POSITION_IDS.join(", ")}.`);
+}
 function getWorkspaceBootstrapPath(workspace) {
     const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
     return path.join(workspace.projectDir, `${workspaceBaseName}.php`);
@@ -284,6 +294,15 @@ function buildPatternConfigEntry(patternSlug) {
         "\t},",
     ].join("\n");
 }
+function buildBindingSourceConfigEntry(bindingSourceSlug) {
+    return [
+        "\t{",
+        `\t\teditorFile: ${quoteTsString(`src/bindings/${bindingSourceSlug}/editor.ts`)},`,
+        `\t\tserverFile: ${quoteTsString(`src/bindings/${bindingSourceSlug}/server.php`)},`,
+        `\t\tslug: ${quoteTsString(bindingSourceSlug)},`,
+        "\t},",
+    ].join("\n");
+}
 function buildVariationConstName(variationSlug) {
     const identifierSegments = toKebabCase(variationSlug)
         .split("-")
@@ -364,6 +383,70 @@ register_block_pattern(
 );
 `;
 }
+function buildBindingSourceServerSource(bindingSourceSlug, namespace, textDomain) {
+    const bindingSourceTitle = toTitleCase(bindingSourceSlug);
+    return `<?php
+if ( ! defined( 'ABSPATH' ) ) {
+\treturn;
+}
+
+if ( ! function_exists( 'register_block_bindings_source' ) ) {
+\treturn;
+}
+
+register_block_bindings_source(
+\t'${namespace}/${bindingSourceSlug}',
+\tarray(
+\t\t'label' => __( ${JSON.stringify(bindingSourceTitle)}, '${textDomain}' ),
+\t\t'get_value_callback' => static function( array $source_args ) : string {
+\t\t\t$field = isset( $source_args['field'] ) && is_string( $source_args['field'] )
+\t\t\t\t? $source_args['field']
+\t\t\t\t: '${bindingSourceSlug}';
+
+\t\t\treturn sprintf(
+\t\t\t\t__( 'Replace %s with real binding source data.', '${textDomain}' ),
+\t\t\t\t$field
+\t\t\t);
+\t\t},
+\t)
+);
+`;
+}
+function buildBindingSourceEditorSource(bindingSourceSlug, namespace, textDomain) {
+    const bindingSourceTitle = toTitleCase(bindingSourceSlug);
+    return `import { registerBlockBindingsSource } from '@wordpress/blocks';
+import { __ } from '@wordpress/i18n';
+
+registerBlockBindingsSource( {
+\tname: ${quoteTsString(`${namespace}/${bindingSourceSlug}`)},
+\tlabel: __( ${quoteTsString(bindingSourceTitle)}, ${quoteTsString(textDomain)} ),
+\tgetFieldsList() {
+\t\treturn [
+\t\t\t{
+\t\t\t\tlabel: __( ${quoteTsString(bindingSourceTitle)}, ${quoteTsString(textDomain)} ),
+\t\t\t\ttype: 'string',
+\t\t\t\targs: {
+\t\t\t\t\tfield: ${quoteTsString(bindingSourceSlug)},
+\t\t\t\t},
+\t\t\t},
+\t\t];
+\t},
+\tgetValues( { bindings } ) {
+\t\tconst values: Record<string, string> = {};
+\t\tfor ( const attributeName of Object.keys( bindings ) ) {
+\t\t\tvalues[ attributeName ] = ${quoteTsString(`TODO: replace ${bindingSourceSlug} with real editor-side values.`)};
+\t\t}
+\t\treturn values;
+\t},
+} );
+`;
+}
+function buildBindingSourceIndexSource(bindingSourceSlugs) {
+    const importLines = bindingSourceSlugs
+        .map((bindingSourceSlug) => `import './${bindingSourceSlug}/editor';`)
+        .join("\n");
+    return `${importLines}${importLines ? "\n\n" : ""}// wp-typia add binding-source entries\n`;
+}
 async function ensureVariationRegistrationHook(blockIndexPath) {
     await patchFile(blockIndexPath, (source) => {
         let nextSource = source;
@@ -466,6 +549,85 @@ function ${patternRegistrationFunctionName}() {
         return nextSource;
     });
 }
+async function ensureBindingSourceBootstrapAnchors(workspace) {
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    await patchFile(bootstrapPath, (source) => {
+        let nextSource = source;
+        const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
+        const bindingRegistrationFunctionName = `${workspace.workspace.phpPrefix}_register_binding_sources`;
+        const bindingEditorEnqueueFunctionName = `${workspace.workspace.phpPrefix}_enqueue_binding_sources_editor`;
+        const bindingRegistrationHook = `add_action( 'init', '${bindingRegistrationFunctionName}', 20 );`;
+        const bindingEditorEnqueueHook = `add_action( 'enqueue_block_editor_assets', '${bindingEditorEnqueueFunctionName}' );`;
+        const bindingRegistrationFunction = `
+
+function ${bindingRegistrationFunctionName}() {
+\tforeach ( glob( __DIR__ . '${BINDING_SOURCE_SERVER_GLOB}' ) ?: array() as $binding_source_module ) {
+\t\trequire_once $binding_source_module;
+\t}
+}
+`;
+        const bindingEditorEnqueueFunction = `
+
+function ${bindingEditorEnqueueFunctionName}() {
+\t$script_path = __DIR__ . '/${BINDING_SOURCE_EDITOR_SCRIPT}';
+\t$asset_path  = __DIR__ . '/${BINDING_SOURCE_EDITOR_ASSET}';
+
+\tif ( ! file_exists( $script_path ) || ! file_exists( $asset_path ) ) {
+\t\treturn;
+\t}
+
+\t$asset = require $asset_path;
+\tif ( ! is_array( $asset ) ) {
+\t\t$asset = array();
+\t}
+
+\twp_enqueue_script(
+\t\t'${workspaceBaseName}-binding-sources',
+\t\tplugins_url( '${BINDING_SOURCE_EDITOR_SCRIPT}', __FILE__ ),
+\t\tisset( $asset['dependencies'] ) && is_array( $asset['dependencies'] ) ? $asset['dependencies'] : array(),
+\t\tisset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
+\t\ttrue
+\t);
+}
+`;
+        const insertionAnchors = [
+            /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
+            /\?>\s*$/u,
+        ];
+        const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${functionName}\\s*\\(`, "u").test(nextSource);
+        const insertPhpSnippet = (snippet) => {
+            for (const anchor of insertionAnchors) {
+                const candidate = nextSource.replace(anchor, (match) => `${snippet}\n${match}`);
+                if (candidate !== nextSource) {
+                    nextSource = candidate;
+                    return;
+                }
+            }
+            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
+        };
+        const appendPhpSnippet = (snippet) => {
+            const closingTagPattern = /\?>\s*$/u;
+            if (closingTagPattern.test(nextSource)) {
+                nextSource = nextSource.replace(closingTagPattern, `${snippet}\n?>`);
+                return;
+            }
+            nextSource = `${nextSource.trimEnd()}\n${snippet}\n`;
+        };
+        if (!hasPhpFunctionDefinition(bindingRegistrationFunctionName)) {
+            insertPhpSnippet(bindingRegistrationFunction);
+        }
+        if (!hasPhpFunctionDefinition(bindingEditorEnqueueFunctionName)) {
+            insertPhpSnippet(bindingEditorEnqueueFunction);
+        }
+        if (!nextSource.includes(bindingRegistrationHook)) {
+            appendPhpSnippet(bindingRegistrationHook);
+        }
+        if (!nextSource.includes(bindingEditorEnqueueHook)) {
+            appendPhpSnippet(bindingEditorEnqueueHook);
+        }
+        return nextSource;
+    });
+}
 function ensureBlockConfigCanAddRestManifests(source) {
     const importLine = "import { defineEndpointManifest } from '@wp-typia/block-runtime/metadata-core';";
     if (REST_MANIFEST_IMPORT_PATTERN.test(source)) {
@@ -479,6 +641,23 @@ async function appendBlockConfigEntries(projectDir, entries, needsRestManifestIm
         transformSource: needsRestManifestImport ? ensureBlockConfigCanAddRestManifests : undefined,
     });
 }
+async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
+    const bindingsDir = path.join(projectDir, "src", "bindings");
+    const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
+    await fsp.mkdir(bindingsDir, { recursive: true });
+    const existingBindingSourceSlugs = fs.existsSync(bindingsDir)
+        ? fs
+            .readdirSync(bindingsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+        : [];
+    const nextBindingSourceSlugs = Array.from(new Set([...existingBindingSourceSlugs, bindingSourceSlug])).sort();
+    await fsp.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
+}
+function resolveBindingSourceRegistryPath(projectDir) {
+    const bindingsDir = path.join(projectDir, "src", "bindings");
+    return [path.join(bindingsDir, "index.ts"), path.join(bindingsDir, "index.js")].find((candidatePath) => fs.existsSync(candidatePath)) ?? path.join(bindingsDir, "index.ts");
+}
 async function snapshotWorkspaceFiles(filePaths) {
     const uniquePaths = Array.from(new Set(filePaths));
     return Promise.all(uniquePaths.map(async (filePath) => ({
@@ -616,11 +795,15 @@ export function formatAddHelpText() {
   wp-typia add block <name> --template <${ADD_BLOCK_TEMPLATE_IDS.join("|")}> [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
   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 <${HOOKED_BLOCK_POSITION_IDS.join("|")}>
 
 Notes:
   \`wp-typia add\` runs only inside official ${WORKSPACE_TEMPLATE_PACKAGE} workspaces.
   \`add variation\` targets an existing block slug from \`scripts/block-config.ts\`.
-  \`add pattern\` scaffolds a namespaced PHP pattern shell under \`src/patterns/\`.`;
+  \`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.`;
 }
 /**
  * Seeds an empty official workspace migration project before any blocks are added.
@@ -728,6 +911,50 @@ function resolveWorkspaceBlock(inventory, blockSlug) {
     }
     return block;
 }
+function assertValidHookAnchor(anchorBlockName) {
+    const trimmed = anchorBlockName.trim();
+    if (!trimmed) {
+        throw new Error("`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+    }
+    if (!HOOKED_BLOCK_ANCHOR_PATTERN.test(trimmed)) {
+        throw new Error("`wp-typia add hooked-block` requires --anchor <anchor-block-name> to use the full `namespace/slug` block name format.");
+    }
+    return trimmed;
+}
+function readWorkspaceBlockJson(projectDir, blockSlug) {
+    const blockJsonPath = path.join(projectDir, "src", "blocks", blockSlug, "block.json");
+    if (!fs.existsSync(blockJsonPath)) {
+        throw new Error(`Missing ${path.relative(projectDir, blockJsonPath)} for workspace block "${blockSlug}".`);
+    }
+    let blockJson;
+    try {
+        blockJson = JSON.parse(fs.readFileSync(blockJsonPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(error instanceof Error
+            ? `Failed to parse ${path.relative(projectDir, blockJsonPath)}: ${error.message}`
+            : `Failed to parse ${path.relative(projectDir, blockJsonPath)}.`);
+    }
+    if (!blockJson || typeof blockJson !== "object" || Array.isArray(blockJson)) {
+        throw new Error(`${path.relative(projectDir, blockJsonPath)} must contain a JSON object.`);
+    }
+    return {
+        blockJson: blockJson,
+        blockJsonPath,
+    };
+}
+function getMutableBlockHooks(blockJson, blockJsonRelativePath) {
+    const blockHooks = blockJson.blockHooks;
+    if (blockHooks === undefined) {
+        const nextHooks = {};
+        blockJson.blockHooks = nextHooks;
+        return nextHooks;
+    }
+    if (!blockHooks || typeof blockHooks !== "object" || Array.isArray(blockHooks)) {
+        throw new Error(`${blockJsonRelativePath} must define blockHooks as an object when present.`);
+    }
+    return blockHooks;
+}
 function assertVariationDoesNotExist(projectDir, blockSlug, variationSlug, inventory) {
     const variationPath = path.join(projectDir, "src", "blocks", blockSlug, "variations", `${variationSlug}.ts`);
     if (fs.existsSync(variationPath)) {
@@ -746,6 +973,15 @@ function assertPatternDoesNotExist(projectDir, patternSlug, inventory) {
         throw new Error(`A pattern inventory entry already exists for ${patternSlug}. Choose a different name.`);
     }
 }
+function assertBindingSourceDoesNotExist(projectDir, bindingSourceSlug, inventory) {
+    const bindingSourceDir = path.join(projectDir, "src", "bindings", bindingSourceSlug);
+    if (fs.existsSync(bindingSourceDir)) {
+        throw new Error(`A binding source already exists at ${path.relative(projectDir, bindingSourceDir)}. Choose a different name.`);
+    }
+    if (inventory.bindingSources.some((entry) => entry.slug === bindingSourceSlug)) {
+        throw new Error(`A binding source inventory entry already exists for ${bindingSourceSlug}. Choose a different name.`);
+    }
+}
 /**
  * Add one variation entry to an existing workspace block.
  *
@@ -847,4 +1083,105 @@ export async function runAddPatternCommand({ cwd = process.cwd(), patternName, }
         throw error;
     }
 }
+/**
+ * Add one block binding source scaffold to an official workspace project.
+ *
+ * @param options Command options for the binding-source scaffold workflow.
+ * @param options.bindingSourceName Human-entered binding source name that will
+ * be normalized and validated before files are written.
+ * @param options.cwd Working directory used to resolve the nearest official
+ * workspace. Defaults to `process.cwd()`.
+ * @returns A promise that resolves with the normalized `bindingSourceSlug` and
+ * owning `projectDir` after the server/editor files and inventory entry have
+ * been written successfully.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the slug is invalid, or when a conflicting file or inventory entry exists.
+ */
+export async function runAddBindingSourceCommand({ bindingSourceName, cwd = process.cwd(), }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name>");
+    const inventory = readWorkspaceInventory(workspace.projectDir);
+    assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
+    const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
+    const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+    const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
+    const bindingSourceDir = path.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
+    const serverFilePath = path.join(bindingSourceDir, "server.php");
+    const editorFilePath = path.join(bindingSourceDir, "editor.ts");
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath, bindingsIndexPath]),
+        snapshotDirs: [],
+        targetPaths: [bindingSourceDir],
+    };
+    try {
+        await fsp.mkdir(bindingSourceDir, { recursive: true });
+        await ensureBindingSourceBootstrapAnchors(workspace);
+        await fsp.writeFile(serverFilePath, buildBindingSourceServerSource(bindingSourceSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
+        await fsp.writeFile(editorFilePath, buildBindingSourceEditorSource(bindingSourceSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
+        await writeBindingSourceRegistry(workspace.projectDir, bindingSourceSlug);
+        await appendWorkspaceInventoryEntries(workspace.projectDir, {
+            bindingSourceEntries: [buildBindingSourceConfigEntry(bindingSourceSlug)],
+        });
+        return {
+            bindingSourceSlug,
+            projectDir: workspace.projectDir,
+        };
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw error;
+    }
+}
+/**
+ * Add one `blockHooks` entry to an existing official workspace block.
+ *
+ * @param options Command options for the hooked-block workflow.
+ * @param options.anchorBlockName Full block name that will anchor the insertion.
+ * @param options.blockName Existing workspace block slug to patch.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.position Hook position to store in `block.json`.
+ * @returns A promise that resolves with the normalized target block slug, anchor
+ * block name, position, and owning project directory after `block.json` is written.
+ * @throws {Error} When the command is run outside an official workspace, when
+ * the target block is unknown, when required flags are missing, or when the
+ * block already defines a hook for the requested anchor.
+ */
+export async function runAddHookedBlockCommand({ anchorBlockName, blockName, cwd = process.cwd(), position, }) {
+    const workspace = resolveWorkspaceProject(cwd);
+    const blockSlug = normalizeBlockSlug(blockName);
+    const inventory = readWorkspaceInventory(workspace.projectDir);
+    resolveWorkspaceBlock(inventory, blockSlug);
+    const resolvedAnchorBlockName = assertValidHookAnchor(anchorBlockName);
+    const resolvedPosition = assertValidHookedBlockPosition(position);
+    const selfHookAnchor = `${workspace.workspace.namespace}/${blockSlug}`;
+    if (resolvedAnchorBlockName === selfHookAnchor) {
+        throw new Error("`wp-typia add hooked-block` cannot hook a block relative to its own block name.");
+    }
+    const { blockJson, blockJsonPath } = readWorkspaceBlockJson(workspace.projectDir, blockSlug);
+    const blockJsonRelativePath = path.relative(workspace.projectDir, blockJsonPath);
+    const blockHooks = getMutableBlockHooks(blockJson, blockJsonRelativePath);
+    if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {
+        throw new Error(`${blockJsonRelativePath} already defines a blockHooks entry for "${resolvedAnchorBlockName}".`);
+    }
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles([blockJsonPath]),
+        snapshotDirs: [],
+        targetPaths: [],
+    };
+    try {
+        blockHooks[resolvedAnchorBlockName] = resolvedPosition;
+        await fsp.writeFile(blockJsonPath, JSON.stringify(blockJson, null, "\t"), "utf8");
+        return {
+            anchorBlockName: resolvedAnchorBlockName,
+            blockSlug,
+            position: resolvedPosition,
+            projectDir: workspace.projectDir,
+        };
+    }
+    catch (error) {
+        await rollbackWorkspaceMutation(mutationSnapshot);
+        throw error;
+    }
+}
 export { getWorkspaceBlockSelectOptions };

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

@@ -7,6 +7,8 @@
  *
  * Import `formatAddHelpText`, `runAddBlockCommand`,
  * `runAddVariationCommand`, `runAddPatternCommand`,
+ * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * and `HOOKED_BLOCK_POSITION_IDS`,
  * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
@@ -19,7 +21,9 @@
  * template inspection flows.
  */
 export { getDoctorChecks, runDoctor, type DoctorCheck } from "./cli-doctor.js";
-export { formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBlockCommand, runAddPatternCommand, runAddVariationCommand, 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

@@ -7,6 +7,8 @@
  *
  * Import `formatAddHelpText`, `runAddBlockCommand`,
  * `runAddVariationCommand`, `runAddPatternCommand`,
+ * `runAddBindingSourceCommand`, `runAddHookedBlockCommand`,
+ * and `HOOKED_BLOCK_POSITION_IDS`,
  * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
@@ -19,7 +21,8 @@
  * template inspection flows.
  */
 export { getDoctorChecks, runDoctor } from "./cli-doctor.js";
-export { formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBlockCommand, runAddPatternCommand, runAddVariationCommand, 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,11 +4,15 @@ 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",
@@ -129,6 +133,41 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
         ? `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);
@@ -154,6 +193,33 @@ function checkWorkspacePatternBootstrap(projectDir, packageName) {
         ? "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)) {
@@ -274,12 +340,13 @@ export async function getDoctorChecks(cwd) {
     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)`));
+        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));
@@ -303,6 +370,16 @@ export async function getDoctorChecks(cwd) {
         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);

package/dist/runtime/cli-help.js

@@ -19,6 +19,8 @@ export function formatHelpText() {
   wp-typia add block <name> --template <basic|interactivity|persistence|compound> [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
   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>
@@ -34,6 +36,8 @@ Notes:
   \`wp-typia <project-dir>\` remains a backward-compatible alias to \`create\`.
   \`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

@@ -5,8 +5,9 @@
  * 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`, and
- * `runDoctor`.
+ * `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";
@@ -16,5 +17,5 @@ export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, str
 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 { createReadlinePrompt, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, runAddBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, 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

@@ -5,8 +5,9 @@
  * 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`, and
- * `runDoctor`.
+ * `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";
@@ -15,4 +16,4 @@ export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJso
 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 { createReadlinePrompt, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, runAddBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, 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/workspace-inventory.d.ts

@@ -14,9 +14,16 @@ export interface WorkspacePatternInventoryEntry {
     file: string;
     slug: string;
 }
+export interface WorkspaceBindingSourceInventoryEntry {
+    editorFile: string;
+    serverFile: string;
+    slug: string;
+}
 export interface WorkspaceInventory {
+    bindingSources: WorkspaceBindingSourceInventoryEntry[];
     blockConfigPath: string;
     blocks: WorkspaceBlockInventoryEntry[];
+    hasBindingSourcesSection: boolean;
     hasPatternsSection: boolean;
     hasVariationsSection: boolean;
     patterns: WorkspacePatternInventoryEntry[];
@@ -26,6 +33,7 @@ export interface WorkspaceInventory {
 export declare const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 export declare const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 export declare const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
+export declare const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *
@@ -67,8 +75,9 @@ export declare function getWorkspaceBlockSelectOptions(projectDir: string): Arra
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export declare function updateWorkspaceInventorySource(source: string, { blockEntries, patternEntries, variationEntries, transformSource, }?: {
+export declare function updateWorkspaceInventorySource(source: string, { blockEntries, bindingSourceEntries, patternEntries, variationEntries, transformSource, }?: {
     blockEntries?: string[];
+    bindingSourceEntries?: string[];
     patternEntries?: string[];
     transformSource?: (source: string) => string;
     variationEntries?: string[];

package/dist/runtime/workspace-inventory.js

@@ -5,29 +5,48 @@ import ts from "typescript";
 export const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 export const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 export const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
-const VARIATIONS_SECTION = `
+export const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
+const VARIATIONS_INTERFACE_SECTION = `
 
 export interface WorkspaceVariationConfig {
 \tblock: string;
 \tfile: string;
 \tslug: string;
 }
+`;
+const VARIATIONS_CONST_SECTION = `
 
 export const VARIATIONS: WorkspaceVariationConfig[] = [
 \t// wp-typia add variation entries
 ];
 `;
-const PATTERNS_SECTION = `
+const PATTERNS_INTERFACE_SECTION = `
 
 export interface WorkspacePatternConfig {
 \tfile: string;
 \tslug: string;
 }
+`;
+const PATTERNS_CONST_SECTION = `
 
 export const PATTERNS: WorkspacePatternConfig[] = [
 \t// wp-typia add pattern entries
 ];
 `;
+const BINDING_SOURCES_INTERFACE_SECTION = `
+
+export interface WorkspaceBindingSourceConfig {
+\teditorFile: string;
+\tserverFile: string;
+\tslug: string;
+}
+`;
+const BINDING_SOURCES_CONST_SECTION = `
+
+export const BINDING_SOURCES: WorkspaceBindingSourceConfig[] = [
+\t// wp-typia add binding-source entries
+];
+`;
 function getPropertyNameText(name) {
     if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
         return name.text;
@@ -123,6 +142,18 @@ function parsePatternEntries(arrayLiteral) {
         };
     });
 }
+function parseBindingSourceEntries(arrayLiteral) {
+    return arrayLiteral.elements.map((element, elementIndex) => {
+        if (!ts.isObjectLiteralExpression(element)) {
+            throw new Error(`BINDING_SOURCES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        }
+        return {
+            editorFile: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "editorFile"),
+            serverFile: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "serverFile"),
+            slug: getRequiredStringProperty("BINDING_SOURCES", elementIndex, element, "slug"),
+        };
+    });
+}
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *
@@ -138,14 +169,22 @@ export function parseWorkspaceInventorySource(source) {
     }
     const variationArray = findExportedArrayLiteral(sourceFile, "VARIATIONS");
     const patternArray = findExportedArrayLiteral(sourceFile, "PATTERNS");
+    const bindingSourceArray = findExportedArrayLiteral(sourceFile, "BINDING_SOURCES");
     if (variationArray.found && !variationArray.array) {
         throw new Error("scripts/block-config.ts must export VARIATIONS as an array literal.");
     }
     if (patternArray.found && !patternArray.array) {
         throw new Error("scripts/block-config.ts must export PATTERNS as an array literal.");
     }
+    if (bindingSourceArray.found && !bindingSourceArray.array) {
+        throw new Error("scripts/block-config.ts must export BINDING_SOURCES as an array literal.");
+    }
     return {
+        bindingSources: bindingSourceArray.array
+            ? parseBindingSourceEntries(bindingSourceArray.array)
+            : [],
         blocks: parseBlockEntries(blockArray.array),
+        hasBindingSourcesSection: bindingSourceArray.found,
         hasPatternsSection: patternArray.found,
         hasVariationsSection: variationArray.found,
         patterns: patternArray.array ? parsePatternEntries(patternArray.array) : [],
@@ -199,26 +238,22 @@ export function getWorkspaceBlockSelectOptions(projectDir) {
 function ensureWorkspaceInventorySections(source) {
     let nextSource = source.trimEnd();
     if (!/export\s+interface\s+WorkspaceVariationConfig\b/u.test(nextSource)) {
-        nextSource += VARIATIONS_SECTION;
+        nextSource += VARIATIONS_INTERFACE_SECTION;
     }
-    else if (!/export\s+const\s+VARIATIONS\b/u.test(nextSource)) {
-        nextSource += `
-
-export const VARIATIONS: WorkspaceVariationConfig[] = [
-\t// wp-typia add variation entries
-];
-`;
+    if (!/export\s+const\s+VARIATIONS\b/u.test(nextSource)) {
+        nextSource += VARIATIONS_CONST_SECTION;
     }
     if (!/export\s+interface\s+WorkspacePatternConfig\b/u.test(nextSource)) {
-        nextSource += PATTERNS_SECTION;
+        nextSource += PATTERNS_INTERFACE_SECTION;
     }
-    else if (!/export\s+const\s+PATTERNS\b/u.test(nextSource)) {
-        nextSource += `
-
-export const PATTERNS: WorkspacePatternConfig[] = [
-\t// wp-typia add pattern entries
-];
-`;
+    if (!/export\s+const\s+PATTERNS\b/u.test(nextSource)) {
+        nextSource += PATTERNS_CONST_SECTION;
+    }
+    if (!/export\s+interface\s+WorkspaceBindingSourceConfig\b/u.test(nextSource)) {
+        nextSource += BINDING_SOURCES_INTERFACE_SECTION;
+    }
+    if (!/export\s+const\s+BINDING_SOURCES\b/u.test(nextSource)) {
+        nextSource += BINDING_SOURCES_CONST_SECTION;
     }
     return `${nextSource}\n`;
 }
@@ -242,7 +277,7 @@ function appendEntriesAtMarker(source, marker, entries) {
  * @param options Entry lists plus an optional source transformer.
  * @returns Updated source text with all requested inventory entries appended.
  */
-export function updateWorkspaceInventorySource(source, { blockEntries = [], patternEntries = [], variationEntries = [], transformSource, } = {}) {
+export function updateWorkspaceInventorySource(source, { blockEntries = [], bindingSourceEntries = [], patternEntries = [], variationEntries = [], transformSource, } = {}) {
     let nextSource = ensureWorkspaceInventorySections(source);
     if (transformSource) {
         nextSource = transformSource(nextSource);
@@ -250,6 +285,7 @@ export function updateWorkspaceInventorySource(source, { blockEntries = [], patt
     nextSource = appendEntriesAtMarker(nextSource, BLOCK_CONFIG_ENTRY_MARKER, blockEntries);
     nextSource = appendEntriesAtMarker(nextSource, VARIATION_CONFIG_ENTRY_MARKER, variationEntries);
     nextSource = appendEntriesAtMarker(nextSource, PATTERN_CONFIG_ENTRY_MARKER, patternEntries);
+    nextSource = appendEntriesAtMarker(nextSource, BINDING_SOURCE_CONFIG_ENTRY_MARKER, bindingSourceEntries);
     return nextSource;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -63,7 +63,7 @@
   "dependencies": {
     "@wp-typia/api-client": "^0.4.0",
     "@wp-typia/block-runtime": "^0.4.0",
-    "@wp-typia/rest": "^0.3.1",
+    "@wp-typia/rest": "^0.3.2",
     "@wp-typia/block-types": "^0.2.0",
     "mustache": "^4.2.0",
     "npm-package-arg": "^13.0.0",