@wp-typia/project-tools 0.22.9 → 0.22.10

package/dist/runtime/ai-artifacts.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { buildWordPressAiArtifacts, } from './wordpress-ai.js';
+import { getOptionalNodeErrorCode, isFileNotFoundError, } from './fs-async.js';
 export { buildWordPressAiArtifacts, buildWordPressAbilitiesDocument, projectWordPressAiSchema, } from './wordpress-ai.js';
 function normalizeGeneratedArtifactContent(content) {
     return content.replace(/\r\n?/g, '\n');
@@ -25,13 +26,11 @@ async function reconcileGeneratedAiArtifacts(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/ai-feature-artifacts.js

@@ -2,6 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
 import { projectWordPressAiSchema } from "./ai-artifacts.js";
+import { isFileNotFoundError } from "./fs-async.js";
 function normalizeGeneratedArtifactContent(content) {
     return content.replace(/\r\n?/g, "\n");
 }
@@ -21,10 +22,7 @@ async function reconcileGeneratedArtifact(options) {
         }
     }
     catch (error) {
-        const code = error && typeof error === "object" && "code" in error
-            ? error.code
-            : undefined;
-        if (code === "ENOENT") {
+        if (isFileNotFoundError(error)) {
             throw new Error(`Generated AI feature artifact is missing: ${options.label} (${options.filePath}).`);
         }
         throw error;

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

@@ -1,5 +1,6 @@
 import { promises as fsp } from "node:fs";
 import path from "node:path";
+import { readOptionalUtf8File } from "./fs-async.js";
 /**
  * Resolve the primary PHP bootstrap file for an official workspace.
  *
@@ -24,15 +25,7 @@ export async function patchFile(filePath, transform) {
  * Read a file when it exists and otherwise return `null`.
  */
 export async function readOptionalFile(filePath) {
-    try {
-        return await fsp.readFile(filePath, "utf8");
-    }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            return null;
-        }
-        throw error;
-    }
+    return readOptionalUtf8File(filePath);
 }
 /**
  * Restore a file to its captured source, deleting it when the snapshot was `null`.
@@ -69,9 +62,3 @@ export async function rollbackWorkspaceMutation(snapshot) {
         await restoreOptionalFile(filePath, source);
     }
 }
-function isFileNotFoundError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === "ENOENT");
-}

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

@@ -55,5 +55,7 @@ export const ADD_BLOCK_TEMPLATE_IDS = [
  * close-id threshold, otherwise `null`.
  */
 export function suggestAddBlockTemplateId(templateId) {
-    return suggestCloseId(templateId, ADD_BLOCK_TEMPLATE_IDS);
+    return suggestCloseId(templateId, ADD_BLOCK_TEMPLATE_IDS, {
+        maxDistance: 3,
+    });
 }

package/dist/runtime/cli-doctor-workspace-shared.js

@@ -90,6 +90,9 @@ export function resolveWorkspaceBootstrapPath(projectDir, packageName) {
  * @returns A passing or failing `DoctorCheck` describing any missing files.
  */
 export function checkExistingFiles(projectDir, label, filePaths) {
+    // Workspace category collectors remain synchronous pure mappers after the
+    // async inventory snapshot is loaded, so these small existence probes stay
+    // sync to preserve their current non-Promise APIs and output ordering.
     const missing = filePaths
         .filter((filePath) => typeof filePath === "string")
         .filter((filePath) => !fs.existsSync(path.join(projectDir, filePath)));

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

@@ -15,4 +15,4 @@ import type { DoctorCheck } from "./cli-doctor.js";
  * @param cwd Working directory expected to host an official workspace.
  * @returns Ordered workspace check rows ready for CLI rendering.
  */
-export declare function getWorkspaceDoctorChecks(cwd: string): DoctorCheck[];
+export declare function getWorkspaceDoctorChecks(cwd: string): Promise<DoctorCheck[]>;

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

@@ -3,7 +3,7 @@ import { getWorkspaceBlockDoctorChecks, } from "./cli-doctor-workspace-blocks.js
 import { getWorkspaceFeatureDoctorChecks, } from "./cli-doctor-workspace-features.js";
 import { getMigrationWorkspaceHintCheck, getWorkspacePackageMetadataCheck, } from "./cli-doctor-workspace-package.js";
 import { createDoctorCheck, createDoctorScopeCheck, } from "./cli-doctor-workspace-shared.js";
-import { readWorkspaceInventory } from "./workspace-inventory.js";
+import { readWorkspaceInventoryAsync, } from "./workspace-inventory.js";
 import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, tryResolveWorkspaceProject, } from "./workspace-project.js";
 function formatWorkspaceInventorySummary(inventory) {
     return [
@@ -36,11 +36,13 @@ function formatWorkspaceInventorySummary(inventory) {
  * @param cwd Working directory expected to host an official workspace.
  * @returns Ordered workspace check rows ready for CLI rendering.
  */
-export function getWorkspaceDoctorChecks(cwd) {
+export async function getWorkspaceDoctorChecks(cwd) {
     const checks = [];
     let workspace = null;
     let invalidWorkspaceReason = null;
     try {
+        // Workspace discovery and package parsing intentionally stay synchronous
+        // because they share compatibility helpers with sync add/migration callers.
         invalidWorkspaceReason = getInvalidWorkspaceProjectReason(cwd);
         workspace = tryResolveWorkspaceProject(cwd);
     }
@@ -62,6 +64,9 @@ export function getWorkspaceDoctorChecks(cwd) {
     checks.push(createDoctorScopeCheck("pass", `Scope: full workspace diagnostics for ${workspace.workspace.namespace}. Environment readiness checks ran and workspace-scoped diagnostics are enabled for the package metadata, inventory, source-tree drift, and any configured migration hint rows below.`));
     let workspacePackageJson;
     try {
+        // Keep package metadata parsing sync until workspace-project exposes an
+        // async companion; the surrounding doctor orchestration already awaits
+        // async inventory reads below.
         workspacePackageJson = parseWorkspacePackageJson(workspace.projectDir);
     }
     catch (error) {
@@ -70,9 +75,7 @@ export function getWorkspaceDoctorChecks(cwd) {
     }
     checks.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson));
     try {
-        // Doctor checks expose a synchronous API so callers can collect a stable
-        // snapshot without mixing async inventory reads into check aggregation.
-        const inventory = readWorkspaceInventory(workspace.projectDir);
+        const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
         checks.push(createDoctorCheck("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
         checks.push(...getWorkspaceBlockDoctorChecks(workspace, inventory));
         checks.push(...getWorkspaceBindingDoctorChecks(workspace, inventory));

package/dist/runtime/cli-doctor.js

@@ -15,7 +15,7 @@ import { getWorkspaceDoctorChecks } from "./cli-doctor-workspace.js";
 export async function getDoctorChecks(cwd) {
     return [
         ...(await getEnvironmentDoctorChecks(cwd)),
-        ...getWorkspaceDoctorChecks(cwd),
+        ...(await getWorkspaceDoctorChecks(cwd)),
     ];
 }
 /**

package/dist/runtime/fs-async.d.ts

@@ -19,6 +19,13 @@ export declare function readOptionalUtf8File(filePath: string): Promise<string |
  * @returns The string error code, or an empty string when unavailable.
  */
 export declare function getNodeErrorCode(error: unknown): string;
+/**
+ * Extract a Node.js error code from an unknown thrown value when available.
+ *
+ * @param error Unknown error value.
+ * @returns The string error code, or `undefined` when unavailable.
+ */
+export declare function getOptionalNodeErrorCode(error: unknown): string | undefined;
 /**
  * Return whether an unknown error represents a missing filesystem path.
  *

package/dist/runtime/fs-async.js

@@ -38,9 +38,18 @@ export async function readOptionalUtf8File(filePath) {
  * @returns The string error code, or an empty string when unavailable.
  */
 export function getNodeErrorCode(error) {
+    return getOptionalNodeErrorCode(error) ?? "";
+}
+/**
+ * Extract a Node.js error code from an unknown thrown value when available.
+ *
+ * @param error Unknown error value.
+ * @returns The string error code, or `undefined` when unavailable.
+ */
+export function getOptionalNodeErrorCode(error) {
     return typeof error === "object" && error !== null && "code" in error
         ? String(error.code)
-        : "";
+        : undefined;
 }
 /**
  * Return whether an unknown error represents a missing filesystem path.
@@ -49,5 +58,5 @@ export function getNodeErrorCode(error) {
  * @returns `true` when the error has Node.js code `ENOENT`.
  */
 export function isFileNotFoundError(error) {
-    return getNodeErrorCode(error) === "ENOENT";
+    return getOptionalNodeErrorCode(error) === "ENOENT";
 }

package/dist/runtime/migration-maintenance-verify.js

@@ -59,6 +59,9 @@ export function verifyProjectMigrations(projectDir, { all = false, fromMigration
     return { verifiedVersions: targetVersions };
 }
 function recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck) {
+    // `migrate doctor` is still a synchronous maintenance command: it shares
+    // sync migration project loading, generated artifact comparisons, and
+    // execFileSync verification with the rest of migration maintenance.
     let invalidWorkspaceReason = null;
     let workspace;
     try {

package/dist/runtime/migration-render-generated.js

@@ -217,6 +217,10 @@ export function renderPhpMigrationRegistryFile(state, entries) {
     return `<?php
 declare(strict_types=1);
 
+if ( ! defined( 'ABSPATH' ) ) {
+\texit;
+}
+
 /**
  * Generated from advanced migration snapshots. Do not edit manually.
  */

package/dist/runtime/package-versions.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);
 const DEFAULT_VERSION_RANGE = '^0.0.0';
@@ -21,11 +22,6 @@ export const DEFAULT_WORDPRESS_DATA_VERSION = '^9.28.0';
 export const DEFAULT_WORDPRESS_DATAVIEWS_VERSION = '^14.1.0';
 export const DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = '^0.1.1';
 let cachedPackageVersions = null;
-function getErrorCode(error) {
-    return typeof error === 'object' && error !== null && 'code' in error
-        ? String(error.code)
-        : undefined;
-}
 function normalizeVersionRange(value) {
     const trimmed = value?.trim();
     if (!trimmed) {
@@ -82,7 +78,7 @@ function resolvePackageManifestLocation(packageJsonPath) {
         };
     }
     catch (error) {
-        if (getErrorCode(error) === 'ENOENT') {
+        if (getOptionalNodeErrorCode(error) === 'ENOENT') {
             return {
                 cacheKey: `missing-file:${packageJsonPath}`,
                 packageJsonPath: null,
@@ -114,7 +110,7 @@ function resolveInstalledPackageManifestLocation(packageName) {
         return resolvePackageManifestLocation(require.resolve(`${packageName}/package.json`));
     }
     catch (error) {
-        if (getErrorCode(error) === 'MODULE_NOT_FOUND') {
+        if (getOptionalNodeErrorCode(error) === 'MODULE_NOT_FOUND') {
             return {
                 cacheKey: `missing-module:${packageName}`,
                 packageJsonPath: null,

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/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 {};