@wp-typia/project-tools 0.16.14 → 0.18.0

package/dist/runtime/template-render.js

@@ -66,15 +66,19 @@ function stripTemplateExtension(entryName) {
 function renderTemplateDestinationName(entryName, view, renderString) {
     return renderString(stripTemplateExtension(entryName), view);
 }
-async function traverseTemplateDirectory({ prepareDirectory, renderString, sourceDir, targetDir, view, visitFile, }) {
+async function traverseTemplateDirectory({ filter, prepareDirectory, renderString, sourceDir, targetDir, view, visitFile, }) {
     const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
         const sourcePath = path.join(sourceDir, entry.name);
         const destinationName = renderTemplateDestinationName(entry.name, view, renderString);
         const destinationPath = resolveRenderedPath(targetDir, destinationName);
+        if (filter && !(await filter(sourcePath, destinationPath, entry))) {
+            continue;
+        }
         if (entry.isDirectory()) {
             await prepareDirectory?.(destinationPath);
             await traverseTemplateDirectory({
+                filter,
                 prepareDirectory,
                 renderString,
                 sourceDir: sourcePath,
@@ -90,9 +94,10 @@ async function traverseTemplateDirectory({ prepareDirectory, renderString, sourc
         });
     }
 }
-async function copyTemplateDirectory({ renderString, sourceDir, targetDir, view, }) {
+async function copyTemplateDirectory({ filter, renderString, sourceDir, targetDir, view, }) {
     await fsp.mkdir(targetDir, { recursive: true });
     await traverseTemplateDirectory({
+        filter,
         prepareDirectory: async (directoryPath) => {
             await fsp.mkdir(directoryPath, { recursive: true });
         },
@@ -134,8 +139,9 @@ export async function copyRawDirectory(sourceDir, targetDir, options = {}) {
  * Copy a template directory using full Mustache semantics for filenames and
  * text-file contents while leaving rendered values unescaped.
  */
-export async function copyRenderedDirectory(sourceDir, targetDir, view) {
+export async function copyRenderedDirectory(sourceDir, targetDir, view, options = {}) {
     await copyTemplateDirectory({
+        filter: options.filter,
         renderString: renderMustacheTemplateString,
         sourceDir,
         targetDir,

package/dist/runtime/template-source-contracts.d.ts

@@ -35,6 +35,11 @@ export interface ResolvedTemplateSource {
     features: string[];
     format: TemplateSourceFormat;
     isOfficialWorkspaceTemplate?: boolean;
+    /**
+     * True when the resolved template can participate in scaffold migration UI
+     * seeding, such as rendered wp-typia workspace templates.
+     */
+    supportsMigrationUi?: boolean;
     templateDir: string;
     cleanup?: () => Promise<void>;
     selectedVariant?: string | null;
@@ -58,6 +63,11 @@ export interface ExternalTemplateConfig<TView extends UnknownRecord = TemplateVa
     blockTemplatesPath?: string;
     defaultValues?: Partial<TView>;
     folderName?: string;
+    /**
+     * Relative template root that renders a fuller wp-typia plugin/workspace
+     * scaffold instead of a create-block subset.
+     */
+    pluginTemplatesPath?: string;
     transformer?: (view: TView) => UnknownRecord | Promise<UnknownRecord>;
     variants?: Record<string, Partial<TView>>;
 }
@@ -65,6 +75,7 @@ export interface SeedSource {
     assetsDir?: string;
     blockDir: string;
     cleanup?: () => Promise<void>;
+    formatHint?: 'create-block-subset' | 'wp-typia';
     rootDir: string;
     selectedVariant?: string | null;
     warnings?: string[];

package/dist/runtime/template-source-external.d.ts

@@ -11,7 +11,7 @@ export declare const EXTERNAL_TEMPLATE_ENTRY_CANDIDATES: readonly ["index.js", "
  */
 export declare function getExternalTemplateEntry(sourceDir: string): string | null;
 /**
- * Load an official external create-block template config and render its seed.
+ * Load an official external template config and render its seed.
  *
  * @param sourceDir Source directory that contains the external template config.
  * @param context Template render context used for the selected variant.

package/dist/runtime/template-source-external.js

@@ -55,7 +55,6 @@ async function loadExternalTemplateConfig(sourceDir) {
     }
     const warnings = [];
     for (const ignoredKey of [
-        'pluginTemplatesPath',
         'wpScripts',
         'wpEnv',
         'customScripts',
@@ -105,9 +104,42 @@ function extractVariantRenderValues(variantConfig) {
     delete values.assetsPath;
     delete values.blockTemplatesPath;
     delete values.folderName;
+    delete values.pluginTemplatesPath;
     delete values.transformer;
     return values;
 }
+function resolveConfiguredTemplatePath(config, variantConfig) {
+    const variantPluginTemplatesPath = typeof variantConfig.pluginTemplatesPath === 'string'
+        ? variantConfig.pluginTemplatesPath
+        : null;
+    const variantBlockTemplatesPath = typeof variantConfig.blockTemplatesPath === 'string'
+        ? variantConfig.blockTemplatesPath
+        : null;
+    const configBlockTemplatesPath = typeof config.blockTemplatesPath === 'string'
+        ? config.blockTemplatesPath
+        : null;
+    const configPluginTemplatesPath = typeof config.pluginTemplatesPath === 'string'
+        ? config.pluginTemplatesPath
+        : null;
+    const templatePath = variantPluginTemplatesPath ??
+        variantBlockTemplatesPath ??
+        configBlockTemplatesPath ??
+        configPluginTemplatesPath;
+    if (!templatePath) {
+        throw new Error('External template config must define blockTemplatesPath or pluginTemplatesPath.');
+    }
+    const configuredFolderName = (typeof variantConfig.folderName === 'string'
+        ? variantConfig.folderName
+        : config.folderName) ?? null;
+    return {
+        folderName: configuredFolderName || '.',
+        formatHint: templatePath === variantPluginTemplatesPath ||
+            templatePath === configPluginTemplatesPath
+            ? 'wp-typia'
+            : 'create-block-subset',
+        templatePath,
+    };
+}
 async function buildExternalTemplateView(context, config, selectedVariant, variantConfig) {
     const mergedView = {
         ...(config.defaultValues ?? {}),
@@ -131,7 +163,7 @@ async function buildExternalTemplateView(context, config, selectedVariant, varia
     };
 }
 /**
- * Load an official external create-block template config and render its seed.
+ * Load an official external template config and render its seed.
  *
  * @param sourceDir Source directory that contains the external template config.
  * @param context Template render context used for the selected variant.
@@ -141,25 +173,24 @@ async function buildExternalTemplateView(context, config, selectedVariant, varia
 export async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVariant) {
     const { config, warnings } = await loadExternalTemplateConfig(sourceDir);
     const { selectedVariant, variantConfig } = getVariantConfig(config, requestedVariant);
-    const blockTemplatesPath = (typeof variantConfig.blockTemplatesPath === 'string'
-        ? variantConfig.blockTemplatesPath
-        : config.blockTemplatesPath) ?? null;
-    if (!blockTemplatesPath) {
-        throw new Error('External template config must define blockTemplatesPath.');
-    }
+    const { folderName, formatHint, templatePath } = resolveConfiguredTemplatePath(config, variantConfig);
     const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-create-block-external-'));
     const cleanup = async () => {
         await fsp.rm(tempRoot, { force: true, recursive: true });
     };
     try {
         const renderedRoot = path.join(tempRoot, 'rendered');
-        const folderName = (typeof variantConfig.folderName === 'string'
-            ? variantConfig.folderName
-            : config.folderName) || '.';
         const blockDir = resolveSourceSubpath(renderedRoot, folderName);
         const view = await buildExternalTemplateView(context, config, selectedVariant, variantConfig);
-        const blockTemplateDir = resolveSourceSubpath(sourceDir, blockTemplatesPath);
-        await copyRenderedDirectory(blockTemplateDir, blockDir, view);
+        const blockTemplateDir = resolveSourceSubpath(sourceDir, templatePath);
+        await copyRenderedDirectory(blockTemplateDir, blockDir, view, {
+            filter: (sourcePath, _destinationPath, entry) => {
+                const mustacheVariantPath = path.join(path.dirname(sourcePath), `${entry.name}.mustache`);
+                return !(entry.isFile() &&
+                    (entry.name === 'package.json' || entry.name === 'README.md') &&
+                    fs.existsSync(mustacheVariantPath));
+            },
+        });
         const assetsPath = typeof variantConfig.assetsPath === 'string'
             ? variantConfig.assetsPath
             : config.assetsPath;
@@ -172,6 +203,7 @@ export async function renderCreateBlockExternalTemplate(sourceDir, context, requ
                 : undefined,
             blockDir,
             cleanup,
+            formatHint,
             rootDir: tempRoot,
             selectedVariant,
             warnings,

package/dist/runtime/template-source-normalization.d.ts

@@ -1,5 +1,5 @@
 export { renderCreateBlockExternalTemplate } from './template-source-external.js';
-export { getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
+export { getTemplateProjectType, getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
 import type { TemplateSourceFormat, TemplateVariableContext } from './template-source-contracts.js';
 export declare function getTemplateVariableContext(variables: {
     [key: string]: string;

package/dist/runtime/template-source-normalization.js

@@ -4,8 +4,9 @@ import path from 'node:path';
 import { loadExternalTemplateLayerManifest } from './template-layers.js';
 import { getPackageVersions } from './package-versions.js';
 import { getExternalTemplateEntry } from './template-source-external.js';
+import { getTemplateProjectType } from './template-source-remote.js';
 export { renderCreateBlockExternalTemplate } from './template-source-external.js';
-export { getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
+export { getTemplateProjectType, getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
 export function getTemplateVariableContext(variables) {
     const { apiClientPackageVersion, blockRuntimePackageVersion, blockTypesPackageVersion, projectToolsPackageVersion, restPackageVersion, } = getPackageVersions();
     return {
@@ -35,6 +36,9 @@ export async function detectTemplateSourceFormat(sourceDir) {
     if (getExternalTemplateEntry(sourceDir)) {
         return 'create-block-external';
     }
+    if (getTemplateProjectType(sourceDir) !== null) {
+        return 'wp-typia';
+    }
     const sourceRoot = fs.existsSync(path.join(sourceDir, 'src'))
         ? path.join(sourceDir, 'src')
         : sourceDir;

package/dist/runtime/template-source-remote.d.ts

@@ -6,6 +6,11 @@ import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from
  * @returns The declared block category, or "widgets" when detection fails.
  */
 export declare function getDefaultCategory(sourceDir: string): string;
+/**
+ * Read `wpTypia.projectType` from a rendered or source template package
+ * manifest and return it when present.
+ */
+export declare function getTemplateProjectType(sourceDir: string): string | null;
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *

package/dist/runtime/template-source-remote.js

@@ -39,6 +39,33 @@ export function getDefaultCategory(sourceDir) {
         return 'widgets';
     }
 }
+function readTemplatePackageJson(sourceDir) {
+    for (const candidate of [
+        path.join(sourceDir, 'package.json.mustache'),
+        path.join(sourceDir, 'package.json'),
+    ]) {
+        if (!fs.existsSync(candidate)) {
+            continue;
+        }
+        try {
+            return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Read `wpTypia.projectType` from a rendered or source template package
+ * manifest and return it when present.
+ */
+export function getTemplateProjectType(sourceDir) {
+    const packageJson = readTemplatePackageJson(sourceDir);
+    return typeof packageJson?.wpTypia?.projectType === 'string'
+        ? packageJson.wpTypia.projectType
+        : null;
+}
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *
@@ -57,6 +84,12 @@ export async function normalizeWpTypiaTemplateSeed(seed) {
                     fs.existsSync(mustacheVariantPath));
             },
         });
+        if (seed.assetsDir && fs.existsSync(seed.assetsDir)) {
+            await fsp.cp(seed.assetsDir, path.join(normalizedDir, 'assets'), {
+                recursive: true,
+                force: true,
+            });
+        }
     }
     catch (error) {
         await fsp.rm(tempRoot, { force: true, recursive: true });

package/dist/runtime/template-source.js

@@ -1,7 +1,7 @@
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from './template-registry.js';
 import { resolveBuiltInTemplateSource } from './template-builtins.js';
 import { parseTemplateLocator, } from './template-source-locators.js';
-import { detectTemplateSourceFormat, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
+import { detectTemplateSourceFormat, getTemplateProjectType, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
 import { isOfficialWorkspaceTemplateSeed, resolveTemplateSeed, } from './template-source-seeds.js';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
 export { resolveTemplateSeed } from './template-source-seeds.js';
@@ -28,6 +28,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
             }
             normalizedSeed = await normalizeWpTypiaTemplateSeed(seed);
+            const supportsMigrationUi = getTemplateProjectType(seed.blockDir) === 'workspace';
             return {
                 id: templateId,
                 defaultCategory: getDefaultCategory(seed.blockDir),
@@ -35,6 +36,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 features: ['Remote source', 'wp-typia format'],
                 format,
                 isOfficialWorkspaceTemplate,
+                supportsMigrationUi,
                 templateDir: normalizedSeed.blockDir,
                 cleanup: normalizedSeed.cleanup,
             };
@@ -48,6 +50,33 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                     })()
                     : seed;
         if (format === 'create-block-external') {
+            const renderedFormat = normalizedSeed.formatHint ??
+                (await detectTemplateSourceFormat(normalizedSeed.blockDir));
+            if (renderedFormat === 'wp-typia') {
+                const normalized = await normalizeWpTypiaTemplateSeed(normalizedSeed);
+                const supportsMigrationUi = getTemplateProjectType(normalizedSeed.blockDir) === 'workspace';
+                return {
+                    cleanup: async () => {
+                        await normalized.cleanup?.();
+                        await seed.cleanup?.();
+                    },
+                    defaultCategory: getDefaultCategory(normalizedSeed.blockDir),
+                    description: 'A wp-typia scaffold normalized from an official external template config',
+                    features: [
+                        'Remote source',
+                        'official external template',
+                        'wp-typia format',
+                        ...(supportsMigrationUi ? ['workspace-capable scaffold'] : []),
+                    ],
+                    format,
+                    id: 'remote:create-block-external',
+                    isOfficialWorkspaceTemplate,
+                    selectedVariant: normalizedSeed.selectedVariant ?? null,
+                    supportsMigrationUi,
+                    templateDir: normalized.blockDir,
+                    warnings: normalizedSeed.warnings ?? [],
+                };
+            }
             const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
             return {
                 ...normalized,

package/dist/runtime/workspace-inventory.d.ts

@@ -19,14 +19,49 @@ export interface WorkspaceBindingSourceInventoryEntry {
     serverFile: string;
     slug: string;
 }
+/**
+ * REST-resource entry parsed from `scripts/block-config.ts`.
+ *
+ * Each file path is stored relative to the workspace root so doctor checks and
+ * workspace mutation helpers can resolve the generated TypeScript, OpenAPI, and
+ * PHP route artifacts without guessing their locations.
+ */
+export interface WorkspaceRestResourceInventoryEntry {
+    apiFile: string;
+    clientFile: string;
+    dataFile: string;
+    methods: string[];
+    namespace: string;
+    openApiFile: string;
+    phpFile: string;
+    slug: string;
+    typesFile: string;
+    validatorsFile: string;
+}
+/**
+ * Editor-plugin entry parsed from `scripts/block-config.ts`.
+ *
+ * @property file Relative path to the generated editor plugin entry file.
+ * @property slug Normalized editor plugin slug.
+ * @property slot Canonical editor shell slot for the plugin scaffold.
+ */
+export interface WorkspaceEditorPluginInventoryEntry {
+    file: string;
+    slug: string;
+    slot: string;
+}
 export interface WorkspaceInventory {
     bindingSources: WorkspaceBindingSourceInventoryEntry[];
     blockConfigPath: string;
     blocks: WorkspaceBlockInventoryEntry[];
     hasBindingSourcesSection: boolean;
+    hasEditorPluginsSection: boolean;
     hasPatternsSection: boolean;
+    hasRestResourcesSection: boolean;
     hasVariationsSection: boolean;
+    editorPlugins: WorkspaceEditorPluginInventoryEntry[];
     patterns: WorkspacePatternInventoryEntry[];
+    restResources: WorkspaceRestResourceInventoryEntry[];
     source: string;
     variations: WorkspaceVariationInventoryEntry[];
 }
@@ -34,6 +69,11 @@ export declare const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entrie
 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";
+export declare const REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
+/**
+ * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
+ */
+export declare const EDITOR_PLUGIN_CONFIG_ENTRY_MARKER = "\t// wp-typia add editor-plugin entries";
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *
@@ -75,10 +115,12 @@ 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, bindingSourceEntries, patternEntries, variationEntries, transformSource, }?: {
+export declare function updateWorkspaceInventorySource(source: string, { blockEntries, bindingSourceEntries, editorPluginEntries, patternEntries, restResourceEntries, variationEntries, transformSource, }?: {
     blockEntries?: string[];
     bindingSourceEntries?: string[];
+    editorPluginEntries?: string[];
     patternEntries?: string[];
+    restResourceEntries?: string[];
     transformSource?: (source: string) => string;
     variationEntries?: string[];
 }): string;

package/dist/runtime/workspace-inventory.js

@@ -2,10 +2,16 @@ import fs from "node:fs";
 import path from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
 import ts from "typescript";
+import { REST_RESOURCE_METHOD_IDS } from "./cli-add-shared.js";
 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";
 export const BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
+export const REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
+/**
+ * Marker used to append generated editor-plugin entries into `EDITOR_PLUGINS`.
+ */
+export const EDITOR_PLUGIN_CONFIG_ENTRY_MARKER = "\t// wp-typia add editor-plugin entries";
 const VARIATIONS_INTERFACE_SECTION = `
 
 export interface WorkspaceVariationConfig {
@@ -47,6 +53,44 @@ export const BINDING_SOURCES: WorkspaceBindingSourceConfig[] = [
 \t// wp-typia add binding-source entries
 ];
 `;
+const REST_RESOURCES_INTERFACE_SECTION = `
+
+export interface WorkspaceRestResourceConfig {
+\tapiFile: string;
+\tclientFile: string;
+\tdataFile: string;
+\tmethods: Array< 'list' | 'read' | 'create' | 'update' | 'delete' >;
+\tnamespace: string;
+\topenApiFile: string;
+\tphpFile: string;
+\trestManifest?: ReturnType<
+\t\ttypeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
+\t>;
+\tslug: string;
+\ttypesFile: string;
+\tvalidatorsFile: string;
+}
+`;
+const REST_RESOURCES_CONST_SECTION = `
+
+export const REST_RESOURCES: WorkspaceRestResourceConfig[] = [
+\t// wp-typia add rest-resource entries
+];
+`;
+const EDITOR_PLUGINS_INTERFACE_SECTION = `
+
+export interface WorkspaceEditorPluginConfig {
+\tfile: string;
+\tslug: string;
+\tslot: string;
+}
+`;
+const EDITOR_PLUGINS_CONST_SECTION = `
+
+export const EDITOR_PLUGINS: WorkspaceEditorPluginConfig[] = [
+\t// wp-typia add editor-plugin entries
+];
+`;
 function getPropertyNameText(name) {
     if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
         return name.text;
@@ -105,6 +149,27 @@ function getRequiredStringProperty(entryName, elementIndex, objectLiteral, key)
     }
     return value;
 }
+function getRequiredStringArrayProperty(entryName, elementIndex, objectLiteral, key) {
+    for (const property of objectLiteral.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            continue;
+        }
+        const propertyName = getPropertyNameText(property.name);
+        if (propertyName !== key) {
+            continue;
+        }
+        if (!ts.isArrayLiteralExpression(property.initializer)) {
+            throw new Error(`${entryName}[${elementIndex}] must use an array literal for "${key}" in scripts/block-config.ts.`);
+        }
+        return property.initializer.elements.map((element, itemIndex) => {
+            if (!ts.isStringLiteralLike(element)) {
+                throw new Error(`${entryName}[${elementIndex}].${key}[${itemIndex}] must use a string literal in scripts/block-config.ts.`);
+            }
+            return element.text;
+        });
+    }
+    throw new Error(`${entryName}[${elementIndex}] is missing required "${key}" in scripts/block-config.ts.`);
+}
 function parseBlockEntries(arrayLiteral) {
     return arrayLiteral.elements.map((element, elementIndex) => {
         if (!ts.isObjectLiteralExpression(element)) {
@@ -154,6 +219,42 @@ function parseBindingSourceEntries(arrayLiteral) {
         };
     });
 }
+function parseRestResourceEntries(arrayLiteral) {
+    return arrayLiteral.elements.map((element, elementIndex) => {
+        if (!ts.isObjectLiteralExpression(element)) {
+            throw new Error(`REST_RESOURCES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        }
+        const methods = getRequiredStringArrayProperty("REST_RESOURCES", elementIndex, element, "methods");
+        const invalidMethods = methods.filter((method) => !REST_RESOURCE_METHOD_IDS.includes(method));
+        if (invalidMethods.length > 0) {
+            throw new Error(`REST_RESOURCES[${elementIndex}].methods includes unsupported values: ${invalidMethods.join(", ")}.`);
+        }
+        return {
+            apiFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "apiFile"),
+            clientFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "clientFile"),
+            dataFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "dataFile"),
+            methods,
+            namespace: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "namespace"),
+            openApiFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "openApiFile"),
+            phpFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "phpFile"),
+            slug: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "slug"),
+            typesFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "typesFile"),
+            validatorsFile: getRequiredStringProperty("REST_RESOURCES", elementIndex, element, "validatorsFile"),
+        };
+    });
+}
+function parseEditorPluginEntries(arrayLiteral) {
+    return arrayLiteral.elements.map((element, elementIndex) => {
+        if (!ts.isObjectLiteralExpression(element)) {
+            throw new Error(`EDITOR_PLUGINS[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+        }
+        return {
+            file: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "file"),
+            slug: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slug"),
+            slot: getRequiredStringProperty("EDITOR_PLUGINS", elementIndex, element, "slot"),
+        };
+    });
+}
 /**
  * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
  *
@@ -170,6 +271,8 @@ export function parseWorkspaceInventorySource(source) {
     const variationArray = findExportedArrayLiteral(sourceFile, "VARIATIONS");
     const patternArray = findExportedArrayLiteral(sourceFile, "PATTERNS");
     const bindingSourceArray = findExportedArrayLiteral(sourceFile, "BINDING_SOURCES");
+    const restResourceArray = findExportedArrayLiteral(sourceFile, "REST_RESOURCES");
+    const editorPluginArray = findExportedArrayLiteral(sourceFile, "EDITOR_PLUGINS");
     if (variationArray.found && !variationArray.array) {
         throw new Error("scripts/block-config.ts must export VARIATIONS as an array literal.");
     }
@@ -179,15 +282,29 @@ export function parseWorkspaceInventorySource(source) {
     if (bindingSourceArray.found && !bindingSourceArray.array) {
         throw new Error("scripts/block-config.ts must export BINDING_SOURCES as an array literal.");
     }
+    if (restResourceArray.found && !restResourceArray.array) {
+        throw new Error("scripts/block-config.ts must export REST_RESOURCES as an array literal.");
+    }
+    if (editorPluginArray.found && !editorPluginArray.array) {
+        throw new Error("scripts/block-config.ts must export EDITOR_PLUGINS as an array literal.");
+    }
     return {
         bindingSources: bindingSourceArray.array
             ? parseBindingSourceEntries(bindingSourceArray.array)
             : [],
         blocks: parseBlockEntries(blockArray.array),
         hasBindingSourcesSection: bindingSourceArray.found,
+        hasEditorPluginsSection: editorPluginArray.found,
         hasPatternsSection: patternArray.found,
+        hasRestResourcesSection: restResourceArray.found,
         hasVariationsSection: variationArray.found,
+        editorPlugins: editorPluginArray.array
+            ? parseEditorPluginEntries(editorPluginArray.array)
+            : [],
         patterns: patternArray.array ? parsePatternEntries(patternArray.array) : [],
+        restResources: restResourceArray.array
+            ? parseRestResourceEntries(restResourceArray.array)
+            : [],
         source,
         variations: variationArray.array ? parseVariationEntries(variationArray.array) : [],
     };
@@ -255,6 +372,18 @@ function ensureWorkspaceInventorySections(source) {
     if (!/export\s+const\s+BINDING_SOURCES\b/u.test(nextSource)) {
         nextSource += BINDING_SOURCES_CONST_SECTION;
     }
+    if (!/export\s+interface\s+WorkspaceRestResourceConfig\b/u.test(nextSource)) {
+        nextSource += REST_RESOURCES_INTERFACE_SECTION;
+    }
+    if (!/export\s+const\s+REST_RESOURCES\b/u.test(nextSource)) {
+        nextSource += REST_RESOURCES_CONST_SECTION;
+    }
+    if (!/export\s+interface\s+WorkspaceEditorPluginConfig\b/u.test(nextSource)) {
+        nextSource += EDITOR_PLUGINS_INTERFACE_SECTION;
+    }
+    if (!/export\s+const\s+EDITOR_PLUGINS\b/u.test(nextSource)) {
+        nextSource += EDITOR_PLUGINS_CONST_SECTION;
+    }
     return `${nextSource}\n`;
 }
 function appendEntriesAtMarker(source, marker, entries) {
@@ -277,7 +406,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 = [], bindingSourceEntries = [], patternEntries = [], variationEntries = [], transformSource, } = {}) {
+export function updateWorkspaceInventorySource(source, { blockEntries = [], bindingSourceEntries = [], editorPluginEntries = [], patternEntries = [], restResourceEntries = [], variationEntries = [], transformSource, } = {}) {
     let nextSource = ensureWorkspaceInventorySections(source);
     if (transformSource) {
         nextSource = transformSource(nextSource);
@@ -286,6 +415,8 @@ export function updateWorkspaceInventorySource(source, { blockEntries = [], bind
     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);
+    nextSource = appendEntriesAtMarker(nextSource, REST_RESOURCE_CONFIG_ENTRY_MARKER, restResourceEntries);
+    nextSource = appendEntriesAtMarker(nextSource, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, editorPluginEntries);
     return nextSource;
 }
 /**

package/dist/runtime/workspace-project.d.ts

@@ -43,7 +43,7 @@ export declare function getInvalidWorkspaceProjectReason(startDir: string): stri
  * Parse a package-manager identifier from a `packageManager` field.
  *
  * @param packageManagerField Raw package-manager field such as `bun@1.3.11`.
- * @returns A normalized `PackageManagerId`, defaulting to `"bun"` when the
+ * @returns A normalized `PackageManagerId`, defaulting to `"npm"` when the
  * field is missing or unsupported.
  */
 export declare function parseWorkspacePackageManagerId(packageManagerField: string | undefined): PackageManagerId;

package/dist/runtime/workspace-project.js

@@ -77,7 +77,7 @@ export function getInvalidWorkspaceProjectReason(startDir) {
  * Parse a package-manager identifier from a `packageManager` field.
  *
  * @param packageManagerField Raw package-manager field such as `bun@1.3.11`.
- * @returns A normalized `PackageManagerId`, defaulting to `"bun"` when the
+ * @returns A normalized `PackageManagerId`, defaulting to `"npm"` when the
  * field is missing or unsupported.
  */
 export function parseWorkspacePackageManagerId(packageManagerField) {
@@ -89,7 +89,7 @@ export function parseWorkspacePackageManagerId(packageManagerField) {
         case "yarn":
             return packageManagerId;
         default:
-            return "bun";
+            return "npm";
     }
 }
 /**