@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/version-floor.js

@@ -1,62 +1 @@
-/**
- * Parse a dotted version floor into numeric parts for stable comparisons.
- *
- * @param value Human-authored version floor such as `7.0` or `8.1.2`.
- * @returns Numeric version segments suitable for ordered comparison.
- * @throws When any segment contains non-digit characters.
- */
-export function parseVersionFloorParts(value) {
-    return value.split('.').map((part, index) => {
-        if (!/^\d+$/u.test(part)) {
-            throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
-        }
-        return Number.parseInt(part, 10);
-    });
-}
-/**
- * Compare two dotted version floors.
- *
- * Missing trailing segments are treated as zero so `7.0` equals `7.0.0`.
- *
- * @param left Left-hand version floor.
- * @param right Right-hand version floor.
- * @returns `1` when left is higher, `-1` when right is higher, or `0` when equal.
- */
-export function compareVersionFloors(left, right) {
-    const leftParts = parseVersionFloorParts(left);
-    const rightParts = parseVersionFloorParts(right);
-    const length = Math.max(leftParts.length, rightParts.length);
-    for (let index = 0; index < length; index += 1) {
-        const leftValue = leftParts[index] ?? 0;
-        const rightValue = rightParts[index] ?? 0;
-        if (leftValue > rightValue) {
-            return 1;
-        }
-        if (leftValue < rightValue) {
-            return -1;
-        }
-    }
-    return 0;
-}
-/**
- * Pick the higher version floor while tolerating undefined values.
- *
- * @param current Current resolved floor, when present.
- * @param candidate Candidate floor to compare against the current floor.
- * @returns The higher defined floor, or undefined when neither value exists.
- */
-export function pickHigherVersionFloor(current, candidate) {
-    if (current !== undefined) {
-        parseVersionFloorParts(current);
-    }
-    if (candidate !== undefined) {
-        parseVersionFloorParts(candidate);
-    }
-    if (candidate === undefined) {
-        return current;
-    }
-    if (current === undefined) {
-        return candidate;
-    }
-    return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
-}
+export * from "./shared/version-floor.js";

package/dist/runtime/wordpress-ai.d.ts

@@ -1,122 +1 @@
-import type { EndpointManifestDefinition, EndpointManifestEndpointDefinition } from '@wp-typia/block-runtime/metadata-core';
-import { type EndpointAuthIntent, type EndpointWordPressAuthDefinition, type JsonSchemaDocument } from './schema-core.js';
-import { type AbilitySpecCatalog } from './ability-spec.js';
-export type { AbilityAnnotationSpec, AbilityCategorySpec, AbilityMcpProjectionSpec, AbilityMetaSpec, AbilitySpec, AbilitySpecCatalog, } from './ability-spec.js';
-/**
- * Represents one projected WordPress-native ability derived from an endpoint
- * manifest plus an AbilitySpec definition.
- */
-export interface ProjectedWordPressAbilityDefinition {
-    /** Normalized auth intent derived from the endpoint manifest. */
-    authIntent: EndpointAuthIntent;
-    /** Optional auth mode propagated from the manifest when present. */
-    authMode?: EndpointManifestEndpointDefinition['authMode'];
-    /** Shared category identifier resolved from the AbilitySpec catalog. */
-    category: string;
-    /** Human-readable summary shown to ability discovery consumers. */
-    description: string;
-    /** PHP callback that executes the ability. */
-    executeCallback: string;
-    /** Stable generated ability identifier. */
-    id: string;
-    /** Optional projected input schema, or null when no input exists. */
-    inputSchema: Record<string, unknown> | null;
-    /** Display label propagated from the AbilitySpec layer. */
-    label: string;
-    /** WordPress-owned metadata preserved in the projected document. */
-    meta: Record<string, unknown>;
-    /** HTTP method from the source endpoint manifest. */
-    method: EndpointManifestEndpointDefinition['method'];
-    /** Source operation identifier from the endpoint manifest. */
-    operationId: string;
-    /** Projected AI response schema shared by the document. */
-    outputSchema: Record<string, unknown>;
-    /** HTTP path from the source endpoint manifest. */
-    path: string;
-    /** PHP permission callback that gates the ability. */
-    permissionCallback: string;
-    /** Optional WordPress auth metadata preserved for downstream adapters. */
-    wordpressAuth?: EndpointWordPressAuthDefinition;
-}
-/**
- * Bundles a single-category WordPress AI abilities document together with the
- * metadata that describes how it was generated.
- */
-export interface ProjectedWordPressAbilitiesDocument {
-    /** Ability definitions generated from the current manifest and AbilitySpec map. */
-    abilities: ProjectedWordPressAbilityDefinition[];
-    /** Shared category metadata for the generated document. */
-    category: {
-        id: string;
-        label: string;
-    };
-    /** Source metadata that points downstream consumers at the generated schema. */
-    generatedFrom: {
-        blockSlug: string;
-        responseSchemaPath: string;
-        schemaProfile: 'ai-structured-output';
-    };
-}
-/**
- * Carries the projected input schema plus endpoint metadata into an optional
- * transform hook.
- */
-export interface WordPressAiInputSchemaTransformContext {
-    /** Name of the input contract being transformed. */
-    contractName: string;
-    /** Source endpoint that requested the input schema. */
-    endpoint: EndpointManifestEndpointDefinition;
-    /** Already-projected AI-friendly input schema. */
-    schema: JsonSchemaDocument & Record<string, unknown>;
-}
-interface BuildWordPressAbilitiesDocumentOptions {
-    abilityCatalog: AbilitySpecCatalog;
-    buildAbilityId?: (operationId: string) => string;
-    generatedFrom: ProjectedWordPressAbilitiesDocument['generatedFrom'];
-    loadInputSchema?: (endpoint: EndpointManifestEndpointDefinition, contractName: string) => Promise<JsonSchemaDocument & Record<string, unknown>>;
-    manifest: EndpointManifestDefinition;
-    outputSchema: Record<string, unknown>;
-    transformInputSchema?: (context: WordPressAiInputSchemaTransformContext) => JsonSchemaDocument & Record<string, unknown>;
-}
-interface BuildWordPressAiArtifactsOptions extends Omit<BuildWordPressAbilitiesDocumentOptions, 'outputSchema'> {
-    responseSchema: JsonSchemaDocument & Record<string, unknown>;
-}
-/**
- * Projects a canonical schema into the AI structured-output profile used by
- * WordPress AI artifact generation.
- *
- * @param schema Canonical JSON Schema document from the manifest-owned source.
- * @returns The projected AI-friendly schema document.
- */
-export declare function projectWordPressAiSchema(schema: JsonSchemaDocument & Record<string, unknown>): JsonSchemaDocument & Record<string, unknown>;
-/**
- * Builds a WordPress abilities document from a manifest-first REST surface and
- * a matching AbilitySpec catalog.
- *
- * Input schemas are loaded lazily per endpoint only when an input contract
- * exists, and `transformInputSchema` runs after the schema has already been
- * projected into the AI structured-output profile.
- *
- * @param options Manifest, ability catalog, and projected output schema inputs.
- * @returns The generated WordPress abilities document.
- * @throws When an endpoint is missing an AbilitySpec.
- * @throws When categories are missing, inconsistent, or span multiple documents.
- * @throws When an endpoint references a missing input contract or no loader was supplied.
- */
-export declare function buildWordPressAbilitiesDocument({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, outputSchema, transformInputSchema, }: BuildWordPressAbilitiesDocumentOptions): Promise<ProjectedWordPressAbilitiesDocument>;
-/**
- * Builds the projected AI response schema together with its companion
- * WordPress abilities document.
- *
- * All endpoints must share the same response contract and category so the
- * generated artifacts stay aligned with one manifest-owned response surface.
- *
- * @param options Manifest, ability catalog, and response schema inputs.
- * @returns The projected AI response schema and generated abilities document.
- * @throws When the manifest has no endpoints.
- * @throws When the shared response contract is missing or inconsistent.
- */
-export declare function buildWordPressAiArtifacts({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, responseSchema, transformInputSchema, }: BuildWordPressAiArtifactsOptions): Promise<{
-    abilitiesDocument: ProjectedWordPressAbilitiesDocument;
-    aiResponseSchema: Record<string, unknown>;
-}>;
+export * from "./schema/wordpress-ai.js";

package/dist/runtime/wordpress-ai.js

@@ -1,177 +1 @@
-import { normalizeEndpointAuthDefinition, projectJsonSchemaDocument, } from './schema-core.js';
-import { resolveAbilityCategorySpec, } from './ability-spec.js';
-function getEndpointInputContractName(endpoint) {
-    if (endpoint.method !== 'GET' &&
-        endpoint.bodyContract &&
-        endpoint.queryContract) {
-        throw new Error(`Endpoint "${endpoint.operationId}" defines both bodyContract and queryContract; WordPress AI input projection is ambiguous.`);
-    }
-    if (endpoint.method === 'GET') {
-        return endpoint.queryContract ?? null;
-    }
-    return endpoint.bodyContract ?? endpoint.queryContract ?? null;
-}
-function toAbilityId(categoryId, operationId) {
-    return `${categoryId}/${operationId
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .toLowerCase()}`;
-}
-/**
- * Projects a canonical schema into the AI structured-output profile used by
- * WordPress AI artifact generation.
- *
- * @param schema Canonical JSON Schema document from the manifest-owned source.
- * @returns The projected AI-friendly schema document.
- */
-export function projectWordPressAiSchema(schema) {
-    return projectJsonSchemaDocument(schema, {
-        profile: 'ai-structured-output',
-    });
-}
-function assertAbilityMetaKeys(abilitySpec, operationId) {
-    if (!abilitySpec.meta) {
-        return;
-    }
-    if ('annotations' in abilitySpec.meta) {
-        throw new Error(`Operation "${operationId}" cannot set AbilitySpec.meta.annotations directly; use AbilitySpec.annotations instead.`);
-    }
-    if ('show_in_rest' in abilitySpec.meta) {
-        throw new Error(`Operation "${operationId}" cannot set AbilitySpec.meta.show_in_rest directly; use AbilitySpec.showInRest instead.`);
-    }
-}
-/**
- * Builds a WordPress abilities document from a manifest-first REST surface and
- * a matching AbilitySpec catalog.
- *
- * Input schemas are loaded lazily per endpoint only when an input contract
- * exists, and `transformInputSchema` runs after the schema has already been
- * projected into the AI structured-output profile.
- *
- * @param options Manifest, ability catalog, and projected output schema inputs.
- * @returns The generated WordPress abilities document.
- * @throws When an endpoint is missing an AbilitySpec.
- * @throws When categories are missing, inconsistent, or span multiple documents.
- * @throws When an endpoint references a missing input contract or no loader was supplied.
- */
-export async function buildWordPressAbilitiesDocument({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, outputSchema, transformInputSchema, }) {
-    const resolvedEndpoints = manifest.endpoints.map((endpoint) => {
-        const abilitySpec = abilityCatalog.abilities[endpoint.operationId];
-        if (!abilitySpec) {
-            throw new Error(`Missing AbilitySpec for operationId "${endpoint.operationId}".`);
-        }
-        assertAbilityMetaKeys(abilitySpec, endpoint.operationId);
-        return {
-            abilitySpec,
-            category: resolveAbilityCategorySpec(abilitySpec, abilityCatalog.categories, endpoint.operationId),
-            endpoint,
-        };
-    });
-    const documentCategory = resolvedEndpoints[0]?.category ?? null;
-    if (!documentCategory) {
-        throw new Error('WordPress AI projection requires at least one endpoint before it can resolve an AbilitySpec category.');
-    }
-    for (const resolvedEndpoint of resolvedEndpoints) {
-        if (resolvedEndpoint.category.id !== documentCategory.id) {
-            throw new Error(`Operation "${resolvedEndpoint.endpoint.operationId}" uses AbilitySpec category "${resolvedEndpoint.category.id}" but WordPress AI projections currently support one shared category per document.`);
-        }
-    }
-    const abilities = await Promise.all(resolvedEndpoints.map(async ({ abilitySpec, category, endpoint }) => {
-        const inputContractName = getEndpointInputContractName(endpoint);
-        let inputSchema = null;
-        if (inputContractName) {
-            if (!manifest.contracts[inputContractName]) {
-                throw new Error(`Endpoint "${endpoint.operationId}" references missing input contract "${inputContractName}".`);
-            }
-            if (!loadInputSchema) {
-                throw new Error(`Missing input schema loader for operationId "${endpoint.operationId}".`);
-            }
-            const projectedInputSchema = projectWordPressAiSchema(await loadInputSchema(endpoint, inputContractName));
-            inputSchema = transformInputSchema
-                ? transformInputSchema({
-                    contractName: inputContractName,
-                    endpoint,
-                    schema: projectedInputSchema,
-                })
-                : projectedInputSchema;
-        }
-        const normalizedAuth = normalizeEndpointAuthDefinition(endpoint);
-        return {
-            authIntent: normalizedAuth.auth,
-            ...(normalizedAuth.authMode
-                ? { authMode: normalizedAuth.authMode }
-                : {}),
-            category: category.id,
-            description: endpoint.summary ?? abilitySpec.label,
-            executeCallback: abilitySpec.executeCallback,
-            id: (buildAbilityId ??
-                ((operationId) => toAbilityId(category.id, operationId)))(endpoint.operationId),
-            inputSchema,
-            label: abilitySpec.label,
-            meta: {
-                ...(abilitySpec.meta ?? {}),
-                ...(abilitySpec.annotations
-                    ? {
-                        annotations: abilitySpec.annotations,
-                    }
-                    : {}),
-                show_in_rest: abilitySpec.showInRest ?? true,
-            },
-            method: endpoint.method,
-            operationId: endpoint.operationId,
-            outputSchema,
-            path: endpoint.path,
-            permissionCallback: abilitySpec.permissionCallback,
-            ...(normalizedAuth.wordpressAuth
-                ? { wordpressAuth: normalizedAuth.wordpressAuth }
-                : {}),
-        };
-    }));
-    return {
-        abilities,
-        category: documentCategory,
-        generatedFrom,
-    };
-}
-/**
- * Builds the projected AI response schema together with its companion
- * WordPress abilities document.
- *
- * All endpoints must share the same response contract and category so the
- * generated artifacts stay aligned with one manifest-owned response surface.
- *
- * @param options Manifest, ability catalog, and response schema inputs.
- * @returns The projected AI response schema and generated abilities document.
- * @throws When the manifest has no endpoints.
- * @throws When the shared response contract is missing or inconsistent.
- */
-export async function buildWordPressAiArtifacts({ abilityCatalog, buildAbilityId, generatedFrom, loadInputSchema, manifest, responseSchema, transformInputSchema, }) {
-    if (manifest.endpoints.length === 0) {
-        throw new Error('WordPress AI projection requires at least one endpoint in the manifest.');
-    }
-    const responseContractName = manifest.endpoints[0].responseContract;
-    if (!responseContractName) {
-        throw new Error('The manifest is missing its shared response contract.');
-    }
-    for (const endpoint of manifest.endpoints) {
-        if (endpoint.responseContract !== responseContractName) {
-            throw new Error(`Endpoint "${endpoint.operationId}" uses response contract "${endpoint.responseContract}" but expected shared response contract "${responseContractName}".`);
-        }
-    }
-    if (!manifest.contracts[responseContractName]) {
-        throw new Error(`The manifest references missing response contract "${responseContractName}".`);
-    }
-    const aiResponseSchema = projectWordPressAiSchema(responseSchema);
-    const abilitiesDocument = await buildWordPressAbilitiesDocument({
-        abilityCatalog,
-        buildAbilityId,
-        generatedFrom,
-        loadInputSchema,
-        manifest,
-        outputSchema: aiResponseSchema,
-        transformInputSchema,
-    });
-    return {
-        abilitiesDocument,
-        aiResponseSchema,
-    };
-}
+export * from "./schema/wordpress-ai.js";

package/dist/runtime/workspace/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/workspace-inventory-mutations.js

@@ -0,0 +1,195 @@
+import path from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { escapeRegex } from "../shared/php-utils.js";
+import { BLOCK_INVENTORY_SECTION, INVENTORY_SECTIONS, } from "./workspace-inventory-section-descriptors.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 &&
+            !hasExportedTypeDeclaration(nextSource, section.interface.name)) {
+            nextSource += section.interface.section;
+        }
+        if (section.value && !hasExportedConst(nextSource, section.value.name)) {
+            nextSource += section.value.section;
+        }
+    }
+    return `${nextSource}\n`;
+}
+function hasExportedTypeDeclaration(source, interfaceName) {
+    return new RegExp(`export\\s+(?:interface|type)\\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 upsertInterfaceField(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) => {
+        const lineEnding = start.endsWith("\r\n") ? "\r\n" : "\n";
+        const formattedFieldSource = `${fieldSource
+            .replace(/\r?\n$/u, "")
+            .split("\n")
+            .join(lineEnding)}${lineEnding}`;
+        const existingFieldPattern = new RegExp(`(^[ \\t]*${escapeRegex(fieldName)}\\??:\\s*[^;\\r\\n]+;?\\r?\\n?)`, "mu");
+        const existingFieldMatch = existingFieldPattern.exec(body);
+        if (existingFieldMatch?.[0]) {
+            if (existingFieldMatch[0].trim() === fieldSource.trim()) {
+                return match;
+            }
+            return `${start}${body.slice(0, existingFieldMatch.index)}${formattedFieldSource}${body.slice(existingFieldMatch.index + existingFieldMatch[0].length)}${end}`;
+        }
+        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);
+    for (const [fieldName, fieldSource] of [
+        ["contentFile", "\tcontentFile?: string;"],
+        ["file", "\tfile?: string;"],
+        ["scope", "\tscope?: 'full' | 'section';"],
+        ["sectionRole", "\tsectionRole?: string;"],
+        ["tags", "\ttags?: string[];"],
+        ["thumbnailUrl", "\tthumbnailUrl?: string;"],
+        ["title", "\ttitle?: string;"],
+    ]) {
+        nextSource = upsertInterfaceField(nextSource, "WorkspacePatternConfig", fieldName, fieldSource);
+    }
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "attribute", "\tattribute?: string;");
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "block", "\tblock?: string;");
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "metaPath", "\tmetaPath?: string;");
+    nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "postMeta", "\tpostMeta?: 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[];"]);
+    for (const [fieldName, fieldSource] of [
+        ["auth", "\tauth?: 'authenticated' | 'public' | 'public-write-protected';"],
+        ["bodyTypeName", "\tbodyTypeName?: string;"],
+        ["controllerClass", "\tcontrollerClass?: string;"],
+        ["controllerExtends", "\tcontrollerExtends?: string;"],
+        ["dataFile", "\tdataFile?: string;"],
+        ["method", "\tmethod?: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';"],
+        ["mode", "\tmode?: 'generated' | 'manual';"],
+        ["pathPattern", "\tpathPattern?: string;"],
+        ["permissionCallback", "\tpermissionCallback?: string;"],
+        ["phpFile", "\tphpFile?: string;"],
+        ["queryTypeName", "\tqueryTypeName?: string;"],
+        ["responseTypeName", "\tresponseTypeName?: string;"],
+        ["routePattern", "\troutePattern?: string;"],
+        ["secretFieldName", "\tsecretFieldName?: string;"],
+        ["secretPreserveOnEmpty", "\tsecretPreserveOnEmpty?: boolean;"],
+        ["secretStateFieldName", "\tsecretStateFieldName?: string;"],
+    ]) {
+        nextSource = upsertInterfaceField(nextSource, "WorkspaceRestResourceConfig", fieldName, fieldSource);
+    }
+    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/workspace-inventory-parser-entries.d.ts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+import { type InventorySectionDescriptor } from "./workspace-inventory-parser-validation.js";
+/**
+ * Parse one descriptor-backed inventory section from a TypeScript source file.
+ *
+ * The generic `T` is the typed entry shape returned in `entries`. The
+ * `descriptor` supplies the exported array name, parser field metadata, and
+ * whether the section is required; this helper uses `findExportedArrayLiteral`
+ * and `parseInventoryEntries` to guarantee object-literal entries and literal
+ * field values. It returns parsed entries plus a `found` flag, and throws when
+ * required exports are missing, descriptors cannot resolve an export name, or
+ * exported values are not array literals.
+ */
+export declare function parseInventorySection<T extends object>(sourceFile: ts.SourceFile, descriptor: InventorySectionDescriptor): {
+    entries: T[];
+    found: boolean;
+};