@wp-typia/project-tools 0.16.8 → 0.16.10

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

@@ -29,8 +29,9 @@ export declare function seedWorkspaceMigrationProject(projectDir: string, curren
  * with unsupported templates, the command runs outside an official workspace,
  * or target block paths already exist.
  */
-export declare function runAddBlockCommand({ blockName, cwd, dataStorageMode, persistencePolicy, templateId, }: RunAddBlockCommandOptions): Promise<{
+export declare function runAddBlockCommand({ blockName, cwd, dataStorageMode, externalLayerId, externalLayerSource, persistencePolicy, selectExternalLayerId, templateId, }: RunAddBlockCommandOptions): Promise<{
     blockSlugs: string[];
     projectDir: string;
     templateId: AddBlockTemplateId;
+    warnings: string[];
 }>;

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

@@ -7,11 +7,14 @@ import { ensureMigrationDirectories, parseMigrationConfig, writeInitialMigration
 import { syncPersistenceRestArtifacts, } from "./persistence-rest-artifacts.js";
 import { snapshotProjectVersion } from "./migrations.js";
 import { getDefaultAnswers, scaffoldProject } from "./scaffold.js";
-import { copyInterpolatedDirectory, } from "./template-render.js";
+import { copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, } from "./template-render.js";
 import { SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
 import { appendWorkspaceInventoryEntries, } from "./workspace-inventory.js";
 import { resolveWorkspaceProject, } from "./workspace-project.js";
 import { ADD_BLOCK_TEMPLATE_IDS, buildWorkspacePhpPrefix, isAddBlockTemplateId, normalizeBlockSlug, patchFile, quoteTsString, readOptionalFile, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { parseTemplateLocator, resolveTemplateSeed, } from "./template-source.js";
+import { resolveExternalTemplateLayers, } from "./template-layers.js";
+import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
 const COLLECTION_IMPORT_LINE = "import '../../collection';";
 const REST_MANIFEST_IMPORT_PATTERN = /import\s*\{[^}]*\bdefineEndpointManifest\b[^}]*\}\s*from\s*["']@wp-typia\/block-runtime\/metadata-core["'];?/m;
 function buildServerTemplateRoot(persistencePolicy) {
@@ -159,6 +162,9 @@ async function ensureCollectionImport(filePath) {
         if (source.includes(COLLECTION_IMPORT_LINE)) {
             return source;
         }
+        if (source.includes("import metadata from './block-metadata';")) {
+            return source.replace("import metadata from './block-metadata';", `${COLLECTION_IMPORT_LINE}\nimport metadata from './block-metadata';`);
+        }
         if (source.includes("import metadata from './block.json';")) {
             return source.replace("import metadata from './block.json';", `${COLLECTION_IMPORT_LINE}\nimport metadata from './block.json';`);
         }
@@ -198,6 +204,7 @@ async function renderWorkspacePersistenceServerModule(projectDir, variables) {
 const COMPOUND_SHARED_SUPPORT_FILES = ["hooks.ts", "validator-toolkit.ts"];
 const LEGACY_ASSERT_PATTERN = /assert:\s*typia\.createAssert</u;
 const LEGACY_MANIFEST_PATTERN = /\r?\n[ \t]*manifest:\s*currentManifest,/u;
+const LEGACY_VALIDATOR_MANIFEST_IMPORT_PATTERN = /^[\uFEFF \t]*import\s+currentManifest\s+from\s*["']\.\/typia\.manifest\.json["'];?$/u;
 const LEGACY_TOOLKIT_CALL_PATTERN = /createTemplateValidatorToolkit<\s*(?<typeName>[A-Za-z0-9_]+)\s*>\s*\(\s*\{/u;
 const LEGACY_VALIDATOR_TOOLKIT_IMPORT_PATTERN = /from\s*["']\.\.\/\.\.\/validator-toolkit["']/u;
 const TYPIA_IMPORT_PATTERN = /^[\uFEFF \t]*import\s+typia\s+from\s*["']typia["'];?/mu;
@@ -211,6 +218,21 @@ const COMPATIBLE_COMPOUND_TOOLKIT_PATTERNS = [
     /\bvalidate\s*:\s*ScaffoldValidatorToolkitOptions\s*<\s*T\s*>\s*\[\s*["']validate["']\s*\]/u,
     /createTemplateValidatorToolkit\s*<\s*T\s+extends\s+object\s*>\s*\(\s*\{/u,
 ];
+function normalizeExternalLayerOption(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveExternalLayerSourceFromCaller(source, callerCwd) {
+    if (typeof source !== "string" ||
+        source.length === 0 ||
+        !(path.isAbsolute(source) || source.startsWith("./") || source.startsWith("../"))) {
+        return source;
+    }
+    return path.resolve(callerCwd, source);
+}
 function shouldRefreshCompoundValidatorToolkit(source) {
     return (source === null ||
         !COMPATIBLE_COMPOUND_TOOLKIT_PATTERNS.every((pattern) => pattern.test(source)));
@@ -223,6 +245,36 @@ function isLegacyCompoundValidatorSource(source) {
 function hasTypiaImport(source) {
     return TYPIA_IMPORT_PATTERN.test(source.replace(/\/\*[\s\S]*?\*\//gu, ""));
 }
+function replaceFirstNonCommentLine(source, pattern, replacement) {
+    const lineEnding = source.includes("\r\n") ? "\r\n" : "\n";
+    const lines = source.split(/\r?\n/);
+    let inBlockComment = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trimStart();
+        if (inBlockComment) {
+            if (trimmed.includes("*/")) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        if (trimmed.startsWith("//")) {
+            continue;
+        }
+        if (trimmed.startsWith("/*")) {
+            if (!trimmed.includes("*/")) {
+                inBlockComment = true;
+            }
+            continue;
+        }
+        if (!pattern.test(line)) {
+            continue;
+        }
+        lines[index] = replacement;
+        return lines.join(lineEnding);
+    }
+    return source;
+}
 function upgradeLegacyCompoundValidatorSource(source) {
     const typeNameMatch = source.match(LEGACY_TOOLKIT_CALL_PATTERN);
     const typeName = typeNameMatch?.groups?.typeName;
@@ -233,6 +285,7 @@ function upgradeLegacyCompoundValidatorSource(source) {
     if (!hasTypiaImport(nextSource)) {
         nextSource = `import typia from 'typia';\n${nextSource}`;
     }
+    nextSource = replaceFirstNonCommentLine(nextSource, LEGACY_VALIDATOR_MANIFEST_IMPORT_PATTERN, "import currentManifest from './manifest-defaults-document';");
     nextSource = nextSource.replace(LEGACY_TOOLKIT_CALL_PATTERN, [
         `createTemplateValidatorToolkit< ${typeName} >( {`,
         `\tassert: typia.createAssert< ${typeName} >(),`,
@@ -255,6 +308,26 @@ function upgradeLegacyCompoundValidatorSource(source) {
     }
     return replacedManifest;
 }
+function renderLegacyManifestDefaultsWrapperSource() {
+    return [
+        "import rawCurrentManifest from './typia.manifest.json';",
+        "import { defineManifestDefaultsDocument } from '@wp-typia/block-runtime/defaults';",
+        "",
+        "const currentManifest = defineManifestDefaultsDocument( rawCurrentManifest );",
+        "",
+        "export default currentManifest;",
+        "",
+    ].join("\n");
+}
+async function ensureLegacyCompoundValidatorManifestDefaultsWrapper(validatorPath) {
+    const validatorDir = path.dirname(validatorPath);
+    const wrapperPath = path.join(validatorDir, "manifest-defaults-document.ts");
+    const manifestPath = path.join(validatorDir, "typia.manifest.json");
+    if (fs.existsSync(wrapperPath) || !fs.existsSync(manifestPath)) {
+        return;
+    }
+    await fsp.writeFile(wrapperPath, renderLegacyManifestDefaultsWrapperSource(), "utf8");
+}
 async function collectLegacyCompoundValidatorPaths(projectDir) {
     const blocksDir = path.join(projectDir, "src", "blocks");
     if (!fs.existsSync(blocksDir)) {
@@ -290,6 +363,7 @@ async function ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, l
         if (!isLegacyCompoundValidatorSource(currentSource)) {
             continue;
         }
+        await ensureLegacyCompoundValidatorManifestDefaultsWrapper(validatorPath);
         await fsp.writeFile(validatorPath, upgradeLegacyCompoundValidatorSource(currentSource), "utf8");
     }
 }
@@ -308,6 +382,47 @@ async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir,
         await renderWorkspacePersistenceServerModule(projectDir, variables);
     }
 }
+function isSupportedAddBlockLayerOutput(options) {
+    const { relativePath, templateId, variables } = options;
+    if (templateId === "compound") {
+        return (relativePath === "src/hooks.ts" ||
+            relativePath === "src/validator-toolkit.ts" ||
+            relativePath.startsWith(`src/blocks/${variables.slugKebabCase}/`) ||
+            relativePath.startsWith(`src/blocks/${variables.slugKebabCase}-item/`));
+    }
+    return relativePath.startsWith("src/");
+}
+async function assertAddBlockSupportsExternalLayerOutputs(options) {
+    const { callerCwd, externalLayerId, externalLayerSource, templateId, variables, } = options;
+    if (!externalLayerSource) {
+        return;
+    }
+    const layerSeed = await resolveTemplateSeed(parseTemplateLocator(externalLayerSource), callerCwd);
+    try {
+        const resolvedLayers = await resolveExternalTemplateLayers({
+            externalLayerId,
+            sourceRoot: layerSeed.rootDir,
+        });
+        for (const entry of resolvedLayers.entries) {
+            if (entry.kind !== "external") {
+                continue;
+            }
+            for (const relativePath of await listInterpolatedDirectoryOutputs(entry.dir, variables)) {
+                if (isSupportedAddBlockLayerOutput({
+                    relativePath,
+                    templateId,
+                    variables,
+                })) {
+                    continue;
+                }
+                throw new Error(`External layer "${entry.id}" writes workspace-level output "${relativePath}", which \`wp-typia add block\` cannot merge safely. Restrict the layer to block-local files or scaffold it through \`wp-typia create\` instead.`);
+            }
+        }
+    }
+    finally {
+        await layerSeed.cleanup?.();
+    }
+}
 function collectWorkspaceBlockPaths(projectDir, templateId, variables) {
     if (templateId === "compound") {
         return [
@@ -433,20 +548,28 @@ export async function seedWorkspaceMigrationProject(projectDir, currentMigration
  * with unsupported templates, the command runs outside an official workspace,
  * or target block paths already exist.
  */
-export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataStorageMode, persistencePolicy, templateId = "basic", }) {
+export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataStorageMode, externalLayerId, externalLayerSource, persistencePolicy, selectExternalLayerId, templateId = "basic", }) {
     if (!isAddBlockTemplateId(templateId)) {
         throw new Error(`Unknown add-block template "${templateId}". Expected one of: ${ADD_BLOCK_TEMPLATE_IDS.join(", ")}`);
     }
     const resolvedTemplateId = templateId;
     assertPersistenceFlagsAllowed(resolvedTemplateId, { dataStorageMode, persistencePolicy });
     const workspace = resolveWorkspaceProject(cwd);
-    const normalizedSlug = normalizeBlockSlug(blockName);
-    if (!normalizedSlug) {
-        throw new Error("Block name is required. Use `wp-typia add block <name> --template <family>`.");
-    }
-    const defaults = getDefaultAnswers(normalizedSlug, resolvedTemplateId);
+    const normalizedExternalLayerId = normalizeExternalLayerOption(externalLayerId);
+    const normalizedExternalLayerSource = resolveExternalLayerSourceFromCaller(normalizeExternalLayerOption(externalLayerSource), cwd);
+    const resolvedExternalLayerSelection = await resolveOptionalInteractiveExternalLayerId({
+        callerCwd: cwd,
+        externalLayerId: normalizedExternalLayerId,
+        externalLayerSource: normalizedExternalLayerSource,
+        selectExternalLayerId,
+    });
     let tempRoot = "";
     try {
+        const normalizedSlug = normalizeBlockSlug(blockName);
+        if (!normalizedSlug) {
+            throw new Error("Block name is required. Use `wp-typia add block <name> --template <family>`.");
+        }
+        const defaults = getDefaultAnswers(normalizedSlug, resolvedTemplateId);
         tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "wp-typia-add-block-"));
         const tempProjectDir = path.join(tempRoot, normalizedSlug);
         const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
@@ -460,24 +583,37 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
         const legacyCompoundValidatorPaths = resolvedTemplateId === "compound"
             ? await collectLegacyCompoundValidatorPaths(workspace.projectDir)
             : [];
-        const result = await scaffoldProject({
-            answers: {
-                ...defaults,
-                author: workspace.author,
-                namespace: workspace.workspace.namespace,
-                phpPrefix: blockPhpPrefix,
-                slug: normalizedSlug,
-                textDomain: workspace.workspace.textDomain,
-                title: defaults.title,
-            },
-            cwd: workspace.projectDir,
-            dataStorageMode: dataStorageMode,
-            noInstall: true,
-            packageManager: workspace.packageManager,
-            persistencePolicy: persistencePolicy,
-            projectDir: tempProjectDir,
-            templateId: resolvedTemplateId,
-        });
+        const result = await (async () => {
+            const scaffoldResult = await scaffoldProject({
+                answers: {
+                    ...defaults,
+                    author: workspace.author,
+                    namespace: workspace.workspace.namespace,
+                    phpPrefix: blockPhpPrefix,
+                    slug: normalizedSlug,
+                    textDomain: workspace.workspace.textDomain,
+                    title: defaults.title,
+                },
+                cwd: workspace.projectDir,
+                dataStorageMode: dataStorageMode,
+                externalLayerId: resolvedExternalLayerSelection.externalLayerId,
+                externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
+                externalLayerSourceLabel: normalizedExternalLayerSource,
+                noInstall: true,
+                packageManager: workspace.packageManager,
+                persistencePolicy: persistencePolicy,
+                projectDir: tempProjectDir,
+                templateId: resolvedTemplateId,
+            });
+            await assertAddBlockSupportsExternalLayerOutputs({
+                callerCwd: cwd,
+                externalLayerId: resolvedExternalLayerSelection.externalLayerId,
+                externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
+                templateId: resolvedTemplateId,
+                variables: scaffoldResult.variables,
+            });
+            return scaffoldResult;
+        })();
         assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
         const mutationSnapshot = {
             fileSources: await snapshotWorkspaceFiles([
@@ -503,6 +639,7 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
                 blockSlugs: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables).map((targetPath) => path.basename(targetPath)),
                 projectDir: workspace.projectDir,
                 templateId: resolvedTemplateId,
+                warnings: result.warnings,
             };
         }
         catch (error) {
@@ -511,6 +648,7 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
         }
     }
     finally {
+        await resolvedExternalLayerSelection.cleanup?.();
         if (tempRoot) {
             await fsp.rm(tempRoot, { force: true, recursive: true });
         }

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

@@ -34,7 +34,14 @@ export interface RunAddBlockCommandOptions {
     blockName: string;
     cwd?: string;
     dataStorageMode?: string;
+    externalLayerId?: string;
+    externalLayerSource?: string;
     persistencePolicy?: string;
+    selectExternalLayerId?: (options: Array<{
+        description?: string;
+        extends: string[];
+        id: string;
+    }>) => Promise<string>;
     templateId?: string;
 }
 export interface WorkspaceMutationSnapshot {

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

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
+import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
 import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_IDS, } from "./hooked-blocks.js";
 import { toKebabCase, toSnakeCase, } from "./string-case.js";
 import { WORKSPACE_TEMPLATE_PACKAGE, } from "./workspace-project.js";
@@ -127,18 +128,15 @@ export function readWorkspaceBlockJson(projectDir, blockSlug) {
     }
     let blockJson;
     try {
-        blockJson = JSON.parse(fs.readFileSync(blockJsonPath, "utf8"));
+        blockJson = parseScaffoldBlockMetadata(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,
+        blockJson,
         blockJsonPath,
     };
 }
@@ -186,7 +184,7 @@ export function assertBindingSourceDoesNotExist(projectDir, bindingSourceSlug, i
  */
 export function formatAddHelpText() {
     return `Usage:
-  wp-typia add block <name> --template <${ADD_BLOCK_TEMPLATE_IDS.join("|")}> [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
+  wp-typia add block <name> --template <${ADD_BLOCK_TEMPLATE_IDS.join("|")}> [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--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>

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

@@ -14,6 +14,9 @@ const BINDING_SOURCE_EDITOR_ASSET = "build/bindings/index.asset.php";
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
+function quotePhpString(value) {
+    return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
+}
 function buildVariationConfigEntry(blockSlug, variationSlug) {
     return [
         "\t{",
@@ -61,7 +64,7 @@ function getVariationConstBindings(variationSlugs) {
 function buildVariationSource(variationSlug, textDomain) {
     const variationTitle = toTitleCase(variationSlug);
     const variationConstName = buildVariationConstName(variationSlug);
-    return `import type { BlockVariation } from '@wordpress/blocks';
+    return `import type { BlockVariation } from '@wp-typia/block-types/blocks/registration';
 import { __ } from '@wordpress/i18n';
 
 export const ${variationConstName} = {
@@ -120,8 +123,12 @@ register_block_pattern(
 );
 `;
 }
-function buildBindingSourceServerSource(bindingSourceSlug, namespace, textDomain) {
+function buildBindingSourceServerSource(bindingSourceSlug, phpPrefix, namespace, textDomain) {
     const bindingSourceTitle = toTitleCase(bindingSourceSlug);
+    const bindingSourcePhpId = bindingSourceSlug.replace(/-/g, "_");
+    const bindingSourceValueFunctionName = `${phpPrefix}_${bindingSourcePhpId}_binding_source_values`;
+    const bindingSourceResolveFunctionName = `${phpPrefix}_${bindingSourcePhpId}_resolve_binding_source_value`;
+    const starterValue = `${bindingSourceTitle} starter value`;
     return `<?php
 if ( ! defined( 'ABSPATH' ) ) {
 \treturn;
@@ -131,29 +138,55 @@ if ( ! function_exists( 'register_block_bindings_source' ) ) {
 \treturn;
 }
 
+if ( ! function_exists( '${bindingSourceValueFunctionName}' ) ) {
+\tfunction ${bindingSourceValueFunctionName}() : array {
+\t\treturn array(
+\t\t\t${quotePhpString(bindingSourceSlug)} => ${quotePhpString(starterValue)},
+\t\t);
+\t}
+}
+
+if ( ! function_exists( '${bindingSourceResolveFunctionName}' ) ) {
+\tfunction ${bindingSourceResolveFunctionName}( array $source_args ) : string {
+\t\t$field = isset( $source_args['field'] ) && is_string( $source_args['field'] )
+\t\t\t? $source_args['field']
+\t\t\t: '${bindingSourceSlug}';
+\t\t$binding_source_values = ${bindingSourceValueFunctionName}();
+\t\t$value = $binding_source_values[ $field ] ?? '';
+
+\t\treturn is_string( $value ) ? $value : '';
+\t}
+}
+
 register_block_bindings_source(
-\t'${namespace}/${bindingSourceSlug}',
+\t${quotePhpString(`${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\t'label' => __( ${quotePhpString(bindingSourceTitle)}, ${quotePhpString(textDomain)} ),
+\t\t'get_value_callback' => ${quotePhpString(bindingSourceResolveFunctionName)},
 \t)
 );
 `;
 }
 function buildBindingSourceEditorSource(bindingSourceSlug, namespace, textDomain) {
     const bindingSourceTitle = toTitleCase(bindingSourceSlug);
+    const starterValue = `${bindingSourceTitle} starter value`;
     return `import { registerBlockBindingsSource } from '@wordpress/blocks';
 import { __ } from '@wordpress/i18n';
 
+interface BindingSourceRegistration {
+\targs?: {
+\t\tfield?: string;
+\t};
+}
+
+const BINDING_SOURCE_VALUES: Record<string, string> = {
+\t${quoteTsString(bindingSourceSlug)}: ${quoteTsString(starterValue)},
+};
+
+function resolveBindingSourceValue( field: string ): string {
+\treturn BINDING_SOURCE_VALUES[ field ] ?? '';
+}
+
 registerBlockBindingsSource( {
 \tname: ${quoteTsString(`${namespace}/${bindingSourceSlug}`)},
 \tlabel: __( ${quoteTsString(bindingSourceTitle)}, ${quoteTsString(textDomain)} ),
@@ -170,8 +203,14 @@ registerBlockBindingsSource( {
 \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\tfor ( const [ attributeName, binding ] of Object.entries(
+\t\t\tbindings as Record<string, BindingSourceRegistration>
+\t\t) ) {
+\t\t\tconst field =
+\t\t\t\ttypeof binding?.args?.field === 'string'
+\t\t\t\t\t? binding.args.field
+\t\t\t\t\t: ${quoteTsString(bindingSourceSlug)};
+\t\t\tvalues[ attributeName ] = resolveBindingSourceValue( field );
 \t\t}
 \t\treturn values;
 \t},
@@ -512,7 +551,7 @@ export async function runAddBindingSourceCommand({ bindingSourceName, cwd = proc
     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(serverFilePath, buildBindingSourceServerSource(bindingSourceSlug, workspace.workspace.phpPrefix, 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, {

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

@@ -12,6 +12,8 @@
  * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
+ * `createCliCommandError` and `formatCliDiagnosticError` for shared
+ * non-interactive failure rendering,
  * `formatHelpText` for top-level CLI usage output, scaffold helpers such as
  * `createReadlinePrompt`, `getNextSteps`, `getOptionalOnboarding`,
  * `runScaffoldFlow`, and `ReadlinePrompt` for interactive project creation,
@@ -21,6 +23,8 @@
  * template inspection flows.
  */
 export { getDoctorChecks, runDoctor, type DoctorCheck } from "./cli-doctor.js";
+export { createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatDoctorCheckLine, formatDoctorSummaryLine, getDoctorFailureDetailLines, getFailingDoctorChecks, isCliDiagnosticError, } from "./cli-diagnostics.js";
+export type { CliDiagnosticMessage } from "./cli-diagnostics.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";

package/dist/runtime/cli-core.js

@@ -12,6 +12,8 @@
  * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
+ * `createCliCommandError` and `formatCliDiagnosticError` for shared
+ * non-interactive failure rendering,
  * `formatHelpText` for top-level CLI usage output, scaffold helpers such as
  * `createReadlinePrompt`, `getNextSteps`, `getOptionalOnboarding`,
  * `runScaffoldFlow`, and `ReadlinePrompt` for interactive project creation,
@@ -21,6 +23,7 @@
  * template inspection flows.
  */
 export { getDoctorChecks, runDoctor } from "./cli-doctor.js";
+export { createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatDoctorCheckLine, formatDoctorSummaryLine, getDoctorFailureDetailLines, getFailingDoctorChecks, isCliDiagnosticError, } from "./cli-diagnostics.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";

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

@@ -0,0 +1,58 @@
+/**
+ * Shared human-readable diagnostics for non-interactive `wp-typia` CLI flows.
+ */
+export interface CliDiagnosticMessage {
+    command: string;
+    detailLines: string[];
+    summary: string;
+}
+type DoctorCheckLike = {
+    detail: string;
+    label: string;
+    status: "pass" | "fail";
+};
+/**
+ * Structured CLI failure carrying a stable summary/detail layout.
+ */
+export declare class CliDiagnosticError extends Error {
+    readonly command: string;
+    readonly detailLines: string[];
+    readonly summary: string;
+    constructor(message: CliDiagnosticMessage, options?: ErrorOptions);
+}
+/**
+ * Narrow an unknown error to the shared CLI diagnostic error shape.
+ */
+export declare function isCliDiagnosticError(error: unknown): error is CliDiagnosticError;
+/**
+ * Build a shared diagnostic error for one CLI command failure.
+ */
+export declare function createCliCommandError(options: {
+    command: string;
+    detailLines?: string[];
+    error?: unknown;
+    summary?: string;
+}): CliDiagnosticError;
+/**
+ * Render a CLI diagnostic block. Non-diagnostic errors fall back to their
+ * plain message so existing non-command failures keep working.
+ */
+export declare function formatCliDiagnosticError(error: unknown): string;
+/**
+ * Format one human-readable doctor check row.
+ */
+export declare function formatDoctorCheckLine(check: DoctorCheckLike): string;
+/**
+ * Return the failing doctor checks from one doctor run.
+ */
+export declare function getFailingDoctorChecks<TCheck extends DoctorCheckLike>(checks: readonly TCheck[]): TCheck[];
+/**
+ * Format the final doctor summary row.
+ */
+export declare function formatDoctorSummaryLine(checks: readonly DoctorCheckLike[]): string;
+/**
+ * Build detail lines for doctor failures so the non-interactive formatter can
+ * restate the failed checks after the streaming rows.
+ */
+export declare function getDoctorFailureDetailLines(checks: readonly DoctorCheckLike[]): string[];
+export {};