@wp-typia/project-tools 0.22.8 → 0.22.10

package/dist/runtime/scaffold-repository-reference.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
+import { getOptionalNodeErrorCode } from "./fs-async.js";
 import { PROJECT_TOOLS_PACKAGE_ROOT } from "./template-registry.js";
 const require = createRequire(import.meta.url);
 /**
@@ -8,17 +9,12 @@ const require = createRequire(import.meta.url);
  * can be resolved from the current runtime package manifests.
  */
 export const DEFAULT_SCAFFOLD_REPOSITORY_REFERENCE = "imjlk/wp-typia";
-function getErrorCode(error) {
-    return typeof error === "object" && error !== null && "code" in error
-        ? String(error.code)
-        : undefined;
-}
 function readRepositoryPackageManifest(packageJsonPath) {
     try {
         return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
     }
     catch (error) {
-        if (getErrorCode(error) === "ENOENT") {
+        if (getOptionalNodeErrorCode(error) === "ENOENT") {
             return null;
         }
         throw error;
@@ -29,7 +25,7 @@ function resolveInstalledPackageManifestPath(packageName) {
         return require.resolve(`${packageName}/package.json`);
     }
     catch (error) {
-        if (getErrorCode(error) === "MODULE_NOT_FOUND") {
+        if (getOptionalNodeErrorCode(error) === "MODULE_NOT_FOUND") {
             return null;
         }
         throw error;

package/dist/runtime/scaffold.js

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { getPackageManager } from "./package-managers.js";
@@ -14,6 +13,7 @@ import { BlockGeneratorService, } from "./block-generator-service.js";
 import { getTemplateVariables } from "./scaffold-template-variables.js";
 import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 import { assertExternalLayerCompositionOptions, } from "./cli-validation.js";
+import { pathExists } from "./fs-async.js";
 export const DATA_STORAGE_MODES = ["post-meta", "custom-table"];
 export const PERSISTENCE_POLICIES = ["authenticated", "public"];
 export { buildBlockCssClassName } from "./scaffold-identifiers.js";
@@ -149,7 +149,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, alterna
         title: "Finalizing scaffold output",
     });
     const readmePath = path.join(projectDir, "README.md");
-    if (!fs.existsSync(readmePath)) {
+    if (!(await pathExists(readmePath))) {
         await fsp.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
             withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
             withTestPreset: isBuiltInTemplate ? withTestPreset : false,
@@ -157,7 +157,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, alterna
         }), "utf8");
     }
     const gitignorePath = path.join(projectDir, ".gitignore");
-    const existingGitignore = fs.existsSync(gitignorePath)
+    const existingGitignore = (await pathExists(gitignorePath))
         ? await fsp.readFile(gitignorePath, "utf8")
         : "";
     await fsp.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");

package/dist/runtime/template-builtins.js

@@ -1,6 +1,6 @@
-import fs from "node:fs";
 import path from "node:path";
 import { promises as fsp } from "node:fs";
+import { pathExists } from "./fs-async.js";
 import { createManagedTempRoot } from "./temp-roots.js";
 import { getTemplateById, SHARED_BASE_TEMPLATE_ROOT, SHARED_COMPOUND_TEMPLATE_ROOT, SHARED_MIGRATION_UI_TEMPLATE_ROOT, SHARED_PERSISTENCE_TEMPLATE_ROOT, SHARED_PRESET_TEMPLATE_ROOT, SHARED_REST_HELPER_TEMPLATE_ROOT, SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
 const BUILT_IN_SHARED_TEMPLATE_LAYERS = Object.freeze([
@@ -138,20 +138,23 @@ export function isOmittableBuiltInTemplateLayerDir(templateId, layerDir) {
     return (OMITTABLE_BUILT_IN_OVERLAY_TEMPLATE_IDS.has(templateId) &&
         layerDir === getTemplateById(templateId).templateDir);
 }
-function resolveMaterializedTemplateLayerDirs(templateId, layerDirs) {
-    return layerDirs.flatMap((layerDir) => {
-        if (fs.existsSync(layerDir)) {
-            return [layerDir];
+async function resolveMaterializedTemplateLayerDirs(templateId, layerDirs) {
+    const materializedLayerDirs = [];
+    for (const layerDir of layerDirs) {
+        if (await pathExists(layerDir)) {
+            materializedLayerDirs.push(layerDir);
+            continue;
         }
         if (isOmittableBuiltInTemplateLayerDir(templateId, layerDir)) {
-            return [];
+            continue;
         }
         throw new Error(`Built-in template layer is missing: ${layerDir}`);
-    });
+    }
+    return materializedLayerDirs;
 }
 async function materializeBuiltInTemplateSource(templateId, layerDirs) {
     const template = getTemplateById(templateId);
-    const materializedLayerDirs = resolveMaterializedTemplateLayerDirs(templateId, layerDirs);
+    const materializedLayerDirs = await resolveMaterializedTemplateLayerDirs(templateId, layerDirs);
     const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-");
     const templateDir = path.join(tempRoot, templateId);
     try {

package/dist/runtime/template-layers.js

@@ -1,6 +1,6 @@
-import fs from "node:fs";
 import path from "node:path";
 import { promises as fsp } from "node:fs";
+import { pathExists } from "./fs-async.js";
 import { isPlainObject } from "./object-utils.js";
 import { getBuiltInSharedTemplateLayerDir, isBuiltInSharedTemplateLayerId, } from "./template-builtins.js";
 import { listInterpolatedDirectoryOutputs } from "./template-render.js";
@@ -56,7 +56,7 @@ function parseLayerDefinition(layerId, value) {
 }
 export async function loadExternalTemplateLayerManifest(sourceRoot) {
     const manifestPath = path.join(sourceRoot, TEMPLATE_LAYER_MANIFEST_FILENAME);
-    if (!fs.existsSync(manifestPath)) {
+    if (!(await pathExists(manifestPath))) {
         return null;
     }
     const raw = JSON.parse(await fsp.readFile(manifestPath, "utf8"));

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

@@ -7,6 +7,9 @@ export declare const EXTERNAL_TEMPLATE_TRUST_WARNING = "External template config
 /**
  * Search a source directory for the first supported external template entry.
  *
+ * @deprecated Use `findExternalTemplateEntry()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Directory that may contain an external template config entry.
  * @returns The first matching entry path, or null when no supported entry exists.
  */

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

@@ -33,6 +33,9 @@ function resolveSourceSubpath(sourceDir, relativePath) {
 /**
  * Search a source directory for the first supported external template entry.
  *
+ * @deprecated Use `findExternalTemplateEntry()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Directory that may contain an external template config entry.
  * @returns The first matching entry path, or null when no supported entry exists.
  */
@@ -205,11 +208,11 @@ export async function renderCreateBlockExternalTemplate(sourceDir, context, requ
         const view = await buildExternalTemplateView(context, config, selectedVariant, variantConfig);
         const blockTemplateDir = resolveSourceSubpath(sourceDir, templatePath);
         await copyRenderedDirectory(blockTemplateDir, blockDir, view, {
-            filter: (sourcePath, _destinationPath, entry) => {
+            filter: async (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));
+                    (await pathExists(mustacheVariantPath)));
             },
         });
         const assetsPath = typeof variantConfig.assetsPath === 'string'

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

@@ -2,6 +2,9 @@ import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from
 /**
  * Read a remote block source and return its default block category.
  *
+ * @deprecated Use `getDefaultCategoryAsync()` from async template-source paths.
+ * This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Block source directory that may contain a block.json file.
  * @returns The declared block category, or "widgets" when detection fails.
  */
@@ -16,6 +19,9 @@ export declare function getDefaultCategoryAsync(sourceDir: string): Promise<stri
 /**
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
+ *
+ * @deprecated Use `getTemplateProjectTypeAsync()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
  */
 export declare function getTemplateProjectType(sourceDir: string): string | null;
 /**

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

@@ -59,6 +59,9 @@ async function readRemoteBlockJsonAsync(blockDir) {
 /**
  * Read a remote block source and return its default block category.
  *
+ * @deprecated Use `getDefaultCategoryAsync()` from async template-source paths.
+ * This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Block source directory that may contain a block.json file.
  * @returns The declared block category, or "widgets" when detection fails.
  */
@@ -139,6 +142,9 @@ async function readTemplatePackageJsonAsync(sourceDir) {
 /**
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
+ *
+ * @deprecated Use `getTemplateProjectTypeAsync()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
  */
 export function getTemplateProjectType(sourceDir) {
     const packageJsonEntry = readTemplatePackageJson(sourceDir);
@@ -185,11 +191,11 @@ export async function normalizeWpTypiaTemplateSeed(seed) {
     const normalizedDir = path.join(tempRoot, 'template');
     try {
         await copyRawDirectory(seed.blockDir, normalizedDir, {
-            filter: (sourcePath, _targetPath, entry) => {
+            filter: async (sourcePath, _targetPath, 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));
+                    (await pathExists(mustacheVariantPath)));
             },
         });
         if (seed.assetsDir && (await pathExists(seed.assetsDir))) {

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

@@ -1,5 +1,18 @@
 import type { RemoteTemplateLocator, SeedSource } from './template-source-contracts.js';
+/**
+ * Synchronously identify the bundled workspace template seed.
+ *
+ * This remains sync-only for compatibility callers. Async template resolution
+ * paths should use `isOfficialWorkspaceTemplateSeedAsync()`.
+ */
 export declare function isOfficialWorkspaceTemplateSeed(seed: SeedSource): boolean;
+/**
+ * Asynchronously identify the bundled workspace template seed.
+ *
+ * @param seed Seed source to inspect.
+ * @returns Whether the seed resolves to the official workspace template package.
+ */
+export declare function isOfficialWorkspaceTemplateSeedAsync(seed: SeedSource): Promise<boolean>;
 export declare function assertNoSymlinks(sourceDir: string): Promise<void>;
 /**
  * Resolves a template locator into a local seed source directory.

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

@@ -8,6 +8,7 @@ import { x as extractTarball } from 'tar';
 import { createExternalTemplateTimeoutError, fetchWithExternalTemplateTimeout, getExternalTemplateMetadataMaxBytes, getExternalTemplateTarballMaxBytes, getExternalTemplateTimeoutMs, readBufferResponseWithLimit, readJsonResponseWithLimit, } from './external-template-guards.js';
 import { findReusableExternalTemplateSourceCache, isExternalTemplateCacheEnabled, resolveExternalTemplateSourceCache, } from './template-source-cache.js';
 import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from './cli-diagnostics.js';
+import { pathExists } from './fs-async.js';
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, OFFICIAL_WORKSPACE_TEMPLATE_ALIAS, PROJECT_TOOLS_PACKAGE_ROOT, TEMPLATE_IDS, } from './template-registry.js';
 import { isPlainObject } from './object-utils.js';
 import { createManagedTempRoot } from './temp-roots.js';
@@ -184,7 +185,9 @@ async function fetchNpmTemplateSource(locator) {
  * Resolve a locally installed npm template package from the caller workspace.
  *
  * Bare package ids are preferred here so monorepo and offline workflows can
- * use an already-installed template without forcing a registry fetch.
+ * use an already-installed template without forcing a registry fetch. This
+ * path intentionally keeps Node's synchronous `require.resolve` semantics
+ * because the module resolver itself has no async equivalent.
  */
 function resolveInstalledNpmTemplateSource(locator, cwd) {
     if (locator.rawSpec !== '' && locator.rawSpec !== '*') {
@@ -244,6 +247,12 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
         throw error;
     }
 }
+/**
+ * Synchronously identify the bundled workspace template seed.
+ *
+ * This remains sync-only for compatibility callers. Async template resolution
+ * paths should use `isOfficialWorkspaceTemplateSeedAsync()`.
+ */
 export function isOfficialWorkspaceTemplateSeed(seed) {
     const packageJsonPath = path.join(seed.rootDir, 'package.json');
     if (!fs.existsSync(packageJsonPath)) {
@@ -257,6 +266,25 @@ export function isOfficialWorkspaceTemplateSeed(seed) {
         return false;
     }
 }
+/**
+ * Asynchronously identify the bundled workspace template seed.
+ *
+ * @param seed Seed source to inspect.
+ * @returns Whether the seed resolves to the official workspace template package.
+ */
+export async function isOfficialWorkspaceTemplateSeedAsync(seed) {
+    const packageJsonPath = path.join(seed.rootDir, 'package.json');
+    if (!(await pathExists(packageJsonPath))) {
+        return false;
+    }
+    try {
+        const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, 'utf8'));
+        return packageJson.name === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE;
+    }
+    catch {
+        return false;
+    }
+}
 export async function assertNoSymlinks(sourceDir) {
     const stats = await fsp.lstat(sourceDir);
     if (stats.isSymbolicLink()) {
@@ -300,13 +328,13 @@ function runGitTemplateCommand(args, label, options = {}) {
 function getGitHubTemplateRepositoryUrl(locator) {
     return `https://github.com/${locator.owner}/${locator.repo}.git`;
 }
-function resolveGitHubTemplateDirectory(checkoutDir, locator) {
+async function resolveGitHubTemplateDirectory(checkoutDir, locator) {
     const sourceDir = path.resolve(checkoutDir, locator.sourcePath);
     const relativeSourceDir = path.relative(checkoutDir, sourceDir);
     if (relativeSourceDir.startsWith('..') || path.isAbsolute(relativeSourceDir)) {
         throw new Error('GitHub template path must stay within the cloned repository.');
     }
-    if (!fs.existsSync(sourceDir)) {
+    if (!(await pathExists(sourceDir))) {
         throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
     }
     return sourceDir;
@@ -438,7 +466,7 @@ async function reuseGitHubTemplateCacheByMetadata(locator) {
     if (!cachedSource) {
         return null;
     }
-    const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+    const sourceDir = await resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
     await assertNoSymlinks(sourceDir);
     return {
         blockDir: sourceDir,
@@ -482,12 +510,12 @@ async function resolveGitHubTemplateSource(locator) {
                 namespace: 'github',
             }, async (checkoutDir) => {
                 cloneGitHubTemplateSource(locator, checkoutDir);
-                const sourceDir = resolveGitHubTemplateDirectory(checkoutDir, locator);
+                const sourceDir = await resolveGitHubTemplateDirectory(checkoutDir, locator);
                 await assertNoSymlinks(sourceDir);
                 pinGitHubTemplateCacheRevision(locator, checkoutDir, resolvedCacheRevision);
             });
             if (cachedSource) {
-                const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+                const sourceDir = await resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
                 await assertNoSymlinks(sourceDir);
                 return {
                     blockDir: sourceDir,
@@ -506,7 +534,7 @@ async function resolveGitHubTemplateSource(locator) {
     const checkoutDir = path.join(remoteRoot, 'source');
     try {
         cloneGitHubTemplateSource(locator, checkoutDir);
-        const sourceDir = resolveGitHubTemplateDirectory(checkoutDir, locator);
+        const sourceDir = await resolveGitHubTemplateDirectory(checkoutDir, locator);
         await assertNoSymlinks(sourceDir);
         return {
             blockDir: sourceDir,
@@ -530,7 +558,7 @@ async function resolveGitHubTemplateSource(locator) {
 export async function resolveTemplateSeed(locator, cwd) {
     if (locator.kind === 'path') {
         const sourceDir = path.resolve(cwd, locator.templatePath);
-        if (!fs.existsSync(sourceDir)) {
+        if (!(await pathExists(sourceDir))) {
             throw new Error(`Template path does not exist: ${sourceDir}`);
         }
         await assertNoSymlinks(sourceDir);

package/dist/runtime/template-source.js

@@ -2,7 +2,7 @@ import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from './tem
 import { resolveBuiltInTemplateSource } from './template-builtins.js';
 import { parseTemplateLocator, } from './template-source-locators.js';
 import { detectTemplateSourceFormat, getTemplateProjectTypeAsync, getDefaultCategoryAsync, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
-import { isOfficialWorkspaceTemplateSeed, resolveTemplateSeed, } from './template-source-seeds.js';
+import { isOfficialWorkspaceTemplateSeedAsync, resolveTemplateSeed, } from './template-source-seeds.js';
 import { assertBuiltInTemplateVariantAllowed, } from './cli-validation.js';
 import { getScaffoldTemplateVariableGroups } from './scaffold-template-variable-groups.js';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
@@ -27,7 +27,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
     const context = getTemplateVariableContext(variables);
     const seed = await resolveTemplateSeed(locator, cwd);
     const isOfficialWorkspaceTemplate = templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE ||
-        isOfficialWorkspaceTemplateSeed(seed);
+        (await isOfficialWorkspaceTemplateSeedAsync(seed));
     let normalizedSeed = null;
     try {
         const format = await detectTemplateSourceFormat(seed.blockDir);

package/dist/runtime/typia-llm.js

@@ -1,5 +1,6 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { getOptionalNodeErrorCode, isFileNotFoundError, } from './fs-async.js';
 import { cloneJsonValue } from './json-utils.js';
 import { normalizeEndpointAuthDefinition, } from './schema-core.js';
 const TYPESCRIPT_RESERVED_WORDS = new Set([
@@ -433,13 +434,11 @@ async function reconcileGeneratedTypiaLlmArtifacts(artifacts, check) {
             }
         }
         catch (error) {
-            const code = error && typeof error === 'object' && 'code' in error
-                ? error.code
-                : undefined;
-            if (code === 'ENOENT') {
+            if (isFileNotFoundError(error)) {
                 issues.push(`- ${artifact.filePath} (missing)`);
                 continue;
             }
+            const code = getOptionalNodeErrorCode(error);
             issues.push(`- ${artifact.filePath} (unreadable: ${error instanceof Error ? error.message : code ?? 'unknown'})`);
         }
     }

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

@@ -0,0 +1,24 @@
+import type { WorkspaceInventoryUpdateOptions } from "./workspace-inventory-types.js";
+/**
+ * Update `scripts/block-config.ts` source text with additional inventory entries.
+ *
+ * Missing inventory sections for variations, patterns, binding sources, REST
+ * resources, workflow abilities, AI features, editor plugins, block styles, and
+ * block transforms are created
+ * automatically before new entries are appended at their marker comments.
+ * When provided, `transformSource` runs before any entries are inserted.
+ *
+ * @param source Existing `scripts/block-config.ts` source.
+ * @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, options?: WorkspaceInventoryUpdateOptions): string;
+/**
+ * Append new entries to the canonical workspace inventory file on disk.
+ *
+ * @param projectDir Workspace root directory.
+ * @param options Entry lists and optional source transform passed through to
+ * `updateWorkspaceInventorySource`.
+ * @returns Resolves once `scripts/block-config.ts` has been updated if needed.
+ */
+export declare function appendWorkspaceInventoryEntries(projectDir: string, options: Parameters<typeof updateWorkspaceInventorySource>[1]): Promise<void>;

package/dist/runtime/workspace-inventory-mutations.js

@@ -0,0 +1,132 @@
+import path from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { escapeRegex } from "./php-utils.js";
+import { BLOCK_INVENTORY_SECTION, INVENTORY_SECTIONS, } from "./workspace-inventory-parser.js";
+import { WORKSPACE_COMPATIBILITY_CONFIG_FIELD } from "./workspace-inventory-templates.js";
+function ensureWorkspaceInventorySections(source) {
+    let nextSource = source.trimEnd();
+    for (const section of INVENTORY_SECTIONS) {
+        if (section.interface &&
+            !hasExportedInterface(nextSource, section.interface.name)) {
+            nextSource += section.interface.section;
+        }
+        if (section.value && !hasExportedConst(nextSource, section.value.name)) {
+            nextSource += section.value.section;
+        }
+    }
+    return `${nextSource}\n`;
+}
+function hasExportedInterface(source, interfaceName) {
+    return new RegExp(`export\\s+interface\\s+${escapeRegex(interfaceName)}\\b`, "u").test(source);
+}
+function hasExportedConst(source, constName) {
+    return new RegExp(`export\\s+const\\s+${escapeRegex(constName)}\\b`, "u").test(source);
+}
+function appendEntriesAtMarker(source, marker, entries) {
+    if (entries.length === 0) {
+        return source;
+    }
+    if (!source.includes(marker)) {
+        throw new Error(`Workspace inventory marker "${marker}" is missing in scripts/block-config.ts.`);
+    }
+    const replacement = `${entries.join("\n")}\n${marker}`;
+    return source.replace(marker, () => replacement);
+}
+function appendInventorySectionEntries(source, options) {
+    let nextSource = source;
+    for (const section of [BLOCK_INVENTORY_SECTION, ...INVENTORY_SECTIONS]) {
+        if (!section.append) {
+            continue;
+        }
+        nextSource = appendEntriesAtMarker(nextSource, section.append.marker, options[section.append.optionKey] ?? []);
+    }
+    return nextSource;
+}
+function ensureInterfaceField(source, interfaceName, fieldName, fieldSource) {
+    const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
+    return source.replace(interfacePattern, (match, start, body, end) => {
+        if (new RegExp(`^[ \t]*${escapeRegex(fieldName)}\\??:`, "mu").test(body)) {
+            return match;
+        }
+        const lineEnding = start.endsWith("\r\n") ? "\r\n" : "\n";
+        const formattedFieldSource = `${fieldSource
+            .replace(/\r?\n$/u, "")
+            .split("\n")
+            .join(lineEnding)}${lineEnding}`;
+        const memberPattern = /^[ \t]*([A-Za-z_$][\w$]*)\??:/gmu;
+        for (const member of body.matchAll(memberPattern)) {
+            const memberIndex = member.index;
+            const memberName = member[1];
+            if (memberIndex === undefined || !memberName) {
+                continue;
+            }
+            if (memberName.localeCompare(fieldName) > 0) {
+                return `${start}${body.slice(0, memberIndex)}${formattedFieldSource}${body.slice(memberIndex)}${end}`;
+            }
+        }
+        return `${start}${body}${body.length > 0 && !body.endsWith(lineEnding) ? lineEnding : ""}${formattedFieldSource}${end}`;
+    });
+}
+function normalizeInterfaceFieldBlock(source, interfaceName, fieldName, fieldSource, requiredFragments) {
+    const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
+    return source.replace(interfacePattern, (match, start, body, end) => {
+        const fieldPattern = new RegExp(`(^([ \\t]*)${escapeRegex(fieldName)}\\??:\\s*\\{[ \\t]*\\r?\\n)([\\s\\S]*?)(^\\2\\};\\r?\\n?)`, "mu");
+        const fieldMatch = fieldPattern.exec(body);
+        if (!fieldMatch) {
+            return match;
+        }
+        const existingFieldSource = fieldMatch[0];
+        if (requiredFragments.every((fragment) => existingFieldSource.includes(fragment))) {
+            return match;
+        }
+        const lineEnding = start.endsWith("\r\n") ? "\r\n" : "\n";
+        const formattedFieldSource = `${fieldSource
+            .replace(/\r?\n$/u, "")
+            .split("\n")
+            .join(lineEnding)}${lineEnding}`;
+        return `${start}${body.slice(0, fieldMatch.index)}${formattedFieldSource}${body.slice(fieldMatch.index + existingFieldSource.length)}${end}`;
+    });
+}
+/**
+ * Update `scripts/block-config.ts` source text with additional inventory entries.
+ *
+ * Missing inventory sections for variations, patterns, binding sources, REST
+ * resources, workflow abilities, AI features, editor plugins, block styles, and
+ * block transforms are created
+ * automatically before new entries are appended at their marker comments.
+ * When provided, `transformSource` runs before any entries are inserted.
+ *
+ * @param source Existing `scripts/block-config.ts` source.
+ * @param options Entry lists plus an optional source transformer.
+ * @returns Updated source text with all requested inventory entries appended.
+ */
+export function updateWorkspaceInventorySource(source, options = {}) {
+    let nextSource = ensureWorkspaceInventorySections(source);
+    if (options.transformSource) {
+        nextSource = options.transformSource(nextSource);
+    }
+    nextSource = appendInventorySectionEntries(nextSource, options);
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "attribute", "\tattribute?: string;");
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "block", "\tblock?: string;");
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+    nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+    nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
+    return nextSource;
+}
+/**
+ * Append new entries to the canonical workspace inventory file on disk.
+ *
+ * @param projectDir Workspace root directory.
+ * @param options Entry lists and optional source transform passed through to
+ * `updateWorkspaceInventorySource`.
+ * @returns Resolves once `scripts/block-config.ts` has been updated if needed.
+ */
+export async function appendWorkspaceInventoryEntries(projectDir, options) {
+    const blockConfigPath = path.join(projectDir, "scripts", "block-config.ts");
+    const source = await readFile(blockConfigPath, "utf8");
+    const nextSource = updateWorkspaceInventorySource(source, options);
+    if (nextSource !== source) {
+        await writeFile(blockConfigPath, nextSource, "utf8");
+    }
+}

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

@@ -0,0 +1,52 @@
+import type { WorkspaceInventory, WorkspaceInventoryAppendOptionKey, WorkspaceInventoryEntriesKey, WorkspaceInventorySectionFlagKey } from "./workspace-inventory-types.js";
+type InventoryEntryFieldValidationContext = {
+    elementIndex: number;
+    entryName: string;
+    key: string;
+};
+type InventoryEntryFieldDescriptor = {
+    key: string;
+    kind?: "string" | "stringArray";
+    required?: boolean;
+    validate?: (value: string | string[] | undefined, context: InventoryEntryFieldValidationContext) => void;
+};
+type InventoryEntryParserDescriptor = {
+    entryName: string;
+    fields: readonly InventoryEntryFieldDescriptor[];
+};
+export type InventorySectionDescriptor = {
+    /** Optional marker metadata used when appending generated entries. */
+    append?: {
+        marker: string;
+        optionKey: WorkspaceInventoryAppendOptionKey;
+    };
+    /** Optional exported interface that backs the inventory section entries. */
+    interface?: {
+        name: string;
+        section: string;
+    };
+    /** Optional parser metadata for descriptor-driven inventory reads. */
+    parse?: {
+        entriesKey: WorkspaceInventoryEntriesKey;
+        entry: InventoryEntryParserDescriptor;
+        exportName?: string;
+        hasSectionKey?: WorkspaceInventorySectionFlagKey;
+        required?: boolean;
+    };
+    /** Optional exported const array that stores the inventory section entries. */
+    value?: {
+        name: string;
+        section: string;
+    };
+};
+export declare const BLOCK_INVENTORY_SECTION: InventorySectionDescriptor;
+export declare const INVENTORY_SECTIONS: readonly InventorySectionDescriptor[];
+/**
+ * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
+ *
+ * @param source Raw TypeScript source from `scripts/block-config.ts`.
+ * @returns Parsed inventory sections without the resolved `blockConfigPath`.
+ * @throws {Error} When `BLOCKS` is missing or any inventory entry is malformed.
+ */
+export declare function parseWorkspaceInventorySource(source: string): Omit<WorkspaceInventory, "blockConfigPath">;
+export {};