@wp-typia/project-tools 0.23.0 → 0.24.0

package/dist/runtime/typia-llm.js

@@ -1,634 +1,5 @@
-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([
-    'abstract',
-    'any',
-    'as',
-    'asserts',
-    'async',
-    'await',
-    'bigint',
-    'boolean',
-    'break',
-    'case',
-    'catch',
-    'class',
-    'const',
-    'constructor',
-    'continue',
-    'debugger',
-    'declare',
-    'default',
-    'delete',
-    'do',
-    'else',
-    'enum',
-    'export',
-    'extends',
-    'false',
-    'finally',
-    'for',
-    'from',
-    'function',
-    'get',
-    'global',
-    'if',
-    'implements',
-    'import',
-    'in',
-    'infer',
-    'instanceof',
-    'interface',
-    'is',
-    'keyof',
-    'let',
-    'module',
-    'namespace',
-    'never',
-    'new',
-    'null',
-    'number',
-    'object',
-    'of',
-    'package',
-    'private',
-    'protected',
-    'public',
-    'readonly',
-    'require',
-    'return',
-    'satisfies',
-    'set',
-    'static',
-    'string',
-    'super',
-    'switch',
-    'symbol',
-    'this',
-    'throw',
-    'true',
-    'try',
-    'type',
-    'typeof',
-    'undefined',
-    'unique',
-    'unknown',
-    'var',
-    'void',
-    'while',
-    'with',
-    'yield',
-]);
-const JSON_SCHEMA_CONSTRAINT_KEYS = [
-    'additionalProperties',
-    'const',
-    'default',
-    'enum',
-    'exclusiveMaximum',
-    'exclusiveMinimum',
-    'format',
-    'maxItems',
-    'maxLength',
-    'maximum',
-    'minItems',
-    'minLength',
-    'minimum',
-    'multipleOf',
-    'pattern',
-    'type',
-];
-function cloneJsonValueIfDefined(value) {
-    return value === undefined ? undefined : cloneJsonValue(value);
-}
-function isJsonSchemaObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/**
- * Narrow a `typia.llm` artifact field before applying JSON Schema mutations.
- *
- * @param value Candidate schema value emitted by `typia.llm`.
- * @param context Human-readable artifact path for diagnostics.
- * @returns The value narrowed to the shared JSON Schema object shape.
- */
-export function assertJsonSchemaObject(value, context) {
-    if (isJsonSchemaObject(value)) {
-        return value;
-    }
-    throw new Error(`${context} must be a JSON Schema object.`);
-}
-function decodeJsonPointerSegment(segment) {
-    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-function resolveOpenApiReferenceTarget(document, reference) {
-    if (!reference.startsWith('#/')) {
-        throw new Error(`Unsupported OpenAPI schema reference "${reference}".`);
-    }
-    let current = document;
-    for (const rawSegment of reference.slice(2).split('/')) {
-        const segment = decodeJsonPointerSegment(rawSegment);
-        if (Array.isArray(current)) {
-            const index = Number.parseInt(segment, 10);
-            current = Number.isInteger(index) ? current[index] : undefined;
-            continue;
-        }
-        if (!isJsonSchemaObject(current)) {
-            current = undefined;
-            break;
-        }
-        current = current[segment];
-    }
-    if (!isJsonSchemaObject(current)) {
-        throw new Error(`Unable to resolve OpenAPI schema reference "${reference}".`);
-    }
-    return current;
-}
-function resolveOpenApiSchemaObject(document, schema, seenReferences = new Set()) {
-    if (!isJsonSchemaObject(schema)) {
-        return {};
-    }
-    const reference = schema.$ref;
-    if (typeof reference !== 'string') {
-        return schema;
-    }
-    if (seenReferences.has(reference)) {
-        return schema;
-    }
-    return resolveOpenApiSchemaObject(document, resolveOpenApiReferenceTarget(document, reference), new Set([...seenReferences, reference]));
-}
-function collectOpenApiSeenReferences(schema, seenReferences) {
-    const reference = schema.$ref;
-    if (typeof reference !== 'string' || seenReferences.has(reference)) {
-        return seenReferences;
-    }
-    return new Set([...seenReferences, reference]);
-}
-/**
- * Copy constraint-oriented JSON Schema keywords from `source` into `target`.
- *
- * This helper intentionally mutates and returns `target` so nested OpenAPI
- * constraint restoration can preserve the projected typia.llm schema shape.
- * Callers that need immutable behavior should clone the target before calling.
- */
-function mergeJsonSchemaConstraintProperties(document, target, source, seenReferences = new Set()) {
-    const nextSeenReferences = collectOpenApiSeenReferences(source, seenReferences);
-    const resolvedSource = resolveOpenApiSchemaObject(document, source, seenReferences);
-    const merged = target;
-    for (const key of JSON_SCHEMA_CONSTRAINT_KEYS) {
-        if (resolvedSource[key] !== undefined) {
-            merged[key] = cloneJsonValue(resolvedSource[key]);
-        }
-    }
-    if (Array.isArray(resolvedSource.required)) {
-        merged.required = resolvedSource.required.filter((value) => typeof value === 'string');
-    }
-    if (Array.isArray(resolvedSource.items)) {
-        merged.items = cloneJsonValue(resolvedSource.items);
-    }
-    else if (isJsonSchemaObject(resolvedSource.items)) {
-        const nextItems = isJsonSchemaObject(merged.items) ? merged.items : {};
-        merged.items = mergeJsonSchemaConstraintProperties(document, nextItems, resolvedSource.items, nextSeenReferences);
-    }
-    if (isJsonSchemaObject(resolvedSource.properties)) {
-        const targetProperties = isJsonSchemaObject(merged.properties)
-            ? merged.properties
-            : {};
-        for (const [propertyName, propertySchema] of Object.entries(resolvedSource.properties)) {
-            if (!isJsonSchemaObject(propertySchema)) {
-                continue;
-            }
-            const nextProperty = isJsonSchemaObject(targetProperties[propertyName])
-                ? targetProperties[propertyName]
-                : {};
-            targetProperties[propertyName] = mergeJsonSchemaConstraintProperties(document, nextProperty, propertySchema, nextSeenReferences);
-        }
-        merged.properties = targetProperties;
-    }
-    return merged;
-}
-function findOpenApiOperationById(document, operationId) {
-    for (const pathItem of Object.values(document.paths)) {
-        if (!isJsonSchemaObject(pathItem)) {
-            continue;
-        }
-        for (const method of ['delete', 'get', 'patch', 'post', 'put']) {
-            const operation = resolveOpenApiSchemaObject(document, pathItem[method]);
-            if (!isJsonSchemaObject(operation) ||
-                typeof operation.operationId !== 'string') {
-                continue;
-            }
-            if (operation.operationId === operationId) {
-                return operation;
-            }
-        }
-    }
-    return null;
-}
-function resolveOpenApiRequestBodySchema(operation, document) {
-    const requestBody = resolveOpenApiSchemaObject(document, operation.requestBody);
-    const content = isJsonSchemaObject(requestBody.content)
-        ? requestBody.content
-        : null;
-    const jsonMediaType = content && isJsonSchemaObject(content['application/json'])
-        ? content['application/json']
-        : null;
-    const schema = jsonMediaType?.schema;
-    if (!isJsonSchemaObject(schema)) {
-        return null;
-    }
-    return resolveOpenApiSchemaObject(document, schema);
-}
-function resolveOpenApiSuccessResponseSchema(operation, document) {
-    for (const [statusCode, response] of Object.entries(operation.responses)) {
-        const resolvedResponse = resolveOpenApiSchemaObject(document, response);
-        if (!/^2(?:\d\d|XX)$/u.test(statusCode) ||
-            !isJsonSchemaObject(resolvedResponse)) {
-            continue;
-        }
-        const content = isJsonSchemaObject(resolvedResponse.content)
-            ? resolvedResponse.content
-            : null;
-        const jsonMediaType = content && isJsonSchemaObject(content['application/json'])
-            ? content['application/json']
-            : null;
-        const schema = jsonMediaType?.schema;
-        if (!isJsonSchemaObject(schema)) {
-            continue;
-        }
-        return resolveOpenApiSchemaObject(document, schema);
-    }
-    return null;
-}
-function getOrCreateObjectProperty(target, propertyName) {
-    const targetProperties = isJsonSchemaObject(target.properties)
-        ? target.properties
-        : {};
-    const nextProperty = isJsonSchemaObject(targetProperties[propertyName])
-        ? targetProperties[propertyName]
-        : {};
-    targetProperties[propertyName] = nextProperty;
-    target.properties = targetProperties;
-    return nextProperty;
-}
-function applyOpenApiQueryParameterConstraints(target, operation, document) {
-    for (const parameter of operation.parameters ?? []) {
-        const resolvedParameter = resolveOpenApiSchemaObject(document, parameter);
-        if (!isJsonSchemaObject(resolvedParameter) ||
-            resolvedParameter.in !== 'query' ||
-            typeof resolvedParameter.name !== 'string') {
-            continue;
-        }
-        const propertyTarget = getOrCreateObjectProperty(target, resolvedParameter.name);
-        mergeJsonSchemaConstraintProperties(document, propertyTarget, resolveOpenApiSchemaObject(document, resolvedParameter.schema));
-        if (resolvedParameter.required === true) {
-            const required = new Set(Array.isArray(target.required)
-                ? target.required.filter((value) => typeof value === 'string')
-                : []);
-            required.add(resolvedParameter.name);
-            target.required = [...required];
-        }
-    }
-}
-function getContractSourceTypeName(manifest, endpoint, contractName) {
-    const contract = manifest.contracts[contractName];
-    if (!contract) {
-        throw new Error(`Endpoint "${endpoint.operationId}" references missing input contract "${contractName}".`);
-    }
-    return contract.sourceTypeName;
-}
-function getEndpointInputTypeDescriptor(manifest, endpoint) {
-    if (endpoint.bodyContract && endpoint.queryContract) {
-        const bodyTypeName = getContractSourceTypeName(manifest, endpoint, endpoint.bodyContract);
-        const queryTypeName = getContractSourceTypeName(manifest, endpoint, endpoint.queryContract);
-        return {
-            importTypeNames: [bodyTypeName, queryTypeName],
-            signatureTypeName: `{ body: ${bodyTypeName}; query: ${queryTypeName} }`,
-        };
-    }
-    const contractName = endpoint.method === 'GET'
-        ? endpoint.queryContract ?? null
-        : endpoint.bodyContract ?? endpoint.queryContract ?? null;
-    if (!contractName) {
-        return {
-            importTypeNames: [],
-            signatureTypeName: null,
-        };
-    }
-    const sourceTypeName = getContractSourceTypeName(manifest, endpoint, contractName);
-    return {
-        importTypeNames: [sourceTypeName],
-        signatureTypeName: sourceTypeName,
-    };
-}
-function getEndpointOutputTypeName(manifest, endpoint) {
-    const contract = manifest.contracts[endpoint.responseContract];
-    if (!contract) {
-        throw new Error(`Endpoint "${endpoint.operationId}" references missing response contract "${endpoint.responseContract}".`);
-    }
-    return contract.sourceTypeName;
-}
-function escapeJsDocLine(line) {
-    return line.replace(/\*\//g, '* /');
-}
-function normalizeGeneratedArtifactContent(content) {
-    return content.replace(/\r\n?/g, '\n');
-}
-function renderDescriptionJsDocLines(method) {
-    const description = method.description && method.description.trim().length > 0
-        ? method.description
-        : method.operationId;
-    const descriptionLines = description
-        .replace(/\r\n?/g, '\n')
-        .split('\n')
-        .map((line) => line.trim().replace(/\s+/g, ' '))
-        .filter(Boolean);
-    return (descriptionLines.length > 0
-        ? descriptionLines
-        : [method.operationId]).map((line) => ` * ${escapeJsDocLine(line)}`);
-}
-function renderMethodJsDoc(method) {
-    const lines = [
-        '/**',
-        ...renderDescriptionJsDocLines(method),
-        ' *',
-        ` * REST path: ${method.method} ${method.path}`,
-        ` * Auth intent: ${method.authIntent}`,
-        ...(method.wordpressAuth
-            ? [
-                ` * WordPress auth: ${method.wordpressAuth.mechanism}${method.wordpressAuth.publicTokenField
-                    ? ` (field: ${method.wordpressAuth.publicTokenField})`
-                    : ''}`,
-            ]
-            : []),
-        ...method.tags.map((tag) => ` * @tag ${escapeJsDocLine(tag)}`),
-        ' */',
-    ];
-    return lines.join('\n');
-}
-function renderMethodSignature(method) {
-    const inputSignature = method.inputTypeName === null ? '' : `input: ${method.inputTypeName}`;
-    const methodName = /^[$A-Z_][$0-9A-Z_]*$/i.test(method.operationId) &&
-        !TYPESCRIPT_RESERVED_WORDS.has(method.operationId)
-        ? method.operationId
-        : JSON.stringify(method.operationId);
-    return `${methodName}(${inputSignature}): ${method.outputTypeName};`;
-}
-function renderTypiaLlmModuleFromMethodDescriptors({ applicationExportName, interfaceName, structuredOutputExportName, structuredOutputTypeName, typesImportPath, }, methods) {
-    const importedTypeNames = new Set([structuredOutputTypeName]);
-    for (const method of methods) {
-        importedTypeNames.add(method.outputTypeName);
-        if (method.inputTypeImportNames) {
-            for (const inputTypeImportName of method.inputTypeImportNames) {
-                importedTypeNames.add(inputTypeImportName);
-            }
-        }
-        else if (method.inputTypeName) {
-            importedTypeNames.add(method.inputTypeName);
-        }
-    }
-    const imports = Array.from(importedTypeNames).sort().join(',\n\t');
-    const methodBlocks = methods
-        .map((method) => {
-        const jsDoc = renderMethodJsDoc(method)
-            .split('\n')
-            .map((line) => `\t${line}`)
-            .join('\n');
-        return `${jsDoc}\n\t${renderMethodSignature(method)}`;
-    })
-        .join('\n\n');
-    return `import typia from "typia";
-import type {
-\t${imports},
-} from "${typesImportPath}";
-
-export interface ${interfaceName} {
-${methodBlocks}
-}
-
-export const ${applicationExportName} =
-\ttypia.llm.application<${interfaceName}>();
-
-export const ${structuredOutputExportName} =
-\ttypia.llm.structuredOutput<${structuredOutputTypeName}>();
-`;
-}
-async function reconcileGeneratedTypiaLlmArtifacts(artifacts, check) {
-    if (!check) {
-        for (const artifact of artifacts) {
-            await mkdir(path.dirname(artifact.filePath), {
-                recursive: true,
-            });
-            await writeFile(artifact.filePath, artifact.content, 'utf8');
-        }
-        return;
-    }
-    const issues = [];
-    for (const artifact of artifacts) {
-        try {
-            const current = normalizeGeneratedArtifactContent(await readFile(artifact.filePath, 'utf8'));
-            const expected = normalizeGeneratedArtifactContent(artifact.content);
-            if (current !== expected) {
-                issues.push(`- ${artifact.filePath} (stale)`);
-            }
-        }
-        catch (error) {
-            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'})`);
-        }
-    }
-    if (issues.length > 0) {
-        throw new Error(`Generated typia.llm artifacts are missing or stale:\n${issues.join('\n')}`);
-    }
-}
-/**
- * Builds the generated controller method descriptors that bridge endpoint
- * manifests to `typia.llm` TypeScript interfaces.
- *
- * @param manifest Endpoint manifest that owns operation and source type names.
- * @returns Ordered method descriptors matching the manifest endpoints.
- * @throws When an endpoint has ambiguous query/body input mapping.
- * @throws When an endpoint references a missing input or output contract.
- */
-export function buildTypiaLlmEndpointMethodDescriptors(manifest) {
-    return manifest.endpoints.map((endpoint) => {
-        const normalizedAuth = normalizeEndpointAuthDefinition(endpoint);
-        const inputTypeDescriptor = getEndpointInputTypeDescriptor(manifest, endpoint);
-        const inputTypeName = inputTypeDescriptor.signatureTypeName;
-        const shouldUseInlineInputImports = inputTypeName !== null &&
-            inputTypeDescriptor.importTypeNames.length > 0 &&
-            inputTypeDescriptor.importTypeNames[0] !== inputTypeName;
-        return {
-            authIntent: normalizedAuth.auth,
-            ...(normalizedAuth.authMode ? { authMode: normalizedAuth.authMode } : {}),
-            description: endpoint.summary,
-            inputTypeName,
-            ...(shouldUseInlineInputImports
-                ? { inputTypeImportNames: inputTypeDescriptor.importTypeNames }
-                : {}),
-            method: endpoint.method,
-            operationId: endpoint.operationId,
-            outputTypeName: getEndpointOutputTypeName(manifest, endpoint),
-            path: endpoint.path,
-            tags: endpoint.tags ?? [],
-            ...(normalizedAuth.wordpressAuth
-                ? { wordpressAuth: normalizedAuth.wordpressAuth }
-                : {}),
-        };
-    });
-}
-/**
- * Renders a build-time-only TypeScript module that invokes `typia.llm` against
- * canonical manifest-owned contracts.
- *
- * @param options Render options for the generated adapter module.
- * @returns The generated TypeScript source.
- */
-export function renderTypiaLlmModule({ applicationExportName, interfaceName, manifest, structuredOutputExportName, structuredOutputTypeName, typesImportPath, }) {
-    return renderTypiaLlmModuleFromMethodDescriptors({
-        applicationExportName,
-        interfaceName,
-        structuredOutputExportName,
-        structuredOutputTypeName,
-        typesImportPath,
-    }, buildTypiaLlmEndpointMethodDescriptors(manifest));
-}
-/**
- * Writes or verifies the generated build-time `typia.llm` adapter module. The
- * returned TypeScript source still needs to be compiled by the consuming
- * project's Typia transformer before JSON artifacts can be read from it.
- *
- * @param options Generated module destination plus render options.
- * @returns Rendered source, method descriptors, and the checked/written file path.
- */
-export async function syncTypiaLlmAdapterModule({ check = false, generatedSourceFile, ...renderOptions }) {
-    const methodDescriptors = buildTypiaLlmEndpointMethodDescriptors(renderOptions.manifest);
-    const source = renderTypiaLlmModuleFromMethodDescriptors(renderOptions, methodDescriptors);
-    await reconcileGeneratedTypiaLlmArtifacts([
-        {
-            content: source,
-            filePath: generatedSourceFile,
-        },
-    ], check);
-    return {
-        check,
-        methodDescriptors,
-        source,
-        sourceFile: generatedSourceFile,
-    };
-}
-/**
- * Projects one compiled `typia.llm` function schema into a JSON-friendly
- * artifact record.
- *
- * @param functionSchema Function schema from a compiled `typia.llm.application(...)`.
- * @returns JSON-friendly function artifact.
- */
-export function projectTypiaLlmApplicationFunction(functionSchema) {
-    return {
-        description: functionSchema.description,
-        name: functionSchema.name,
-        output: cloneJsonValueIfDefined(functionSchema.output),
-        parameters: cloneJsonValue(functionSchema.parameters),
-        ...(functionSchema.tags ? { tags: [...functionSchema.tags] } : {}),
-    };
-}
-function cloneProjectedTypiaLlmFunctionArtifact(functionArtifact) {
-    return {
-        description: functionArtifact.description,
-        name: functionArtifact.name,
-        output: cloneJsonValueIfDefined(functionArtifact.output),
-        parameters: cloneJsonValue(functionArtifact.parameters),
-        ...(functionArtifact.tags ? { tags: [...functionArtifact.tags] } : {}),
-    };
-}
-/**
- * Restores canonical request and response constraints from an endpoint-aware
- * OpenAPI document onto one projected `typia.llm` function artifact.
- *
- * Query-only inputs merge into the root parameter object. Mixed body/query
- * inputs merge into the generated `body` and `query` properties.
- *
- * @param options Projected artifact plus the canonical OpenAPI document.
- * @returns A cloned artifact enriched with OpenAPI-backed constraints when available.
- */
-export function applyOpenApiConstraintsToTypiaLlmFunctionArtifact({ functionArtifact, openApiDocument, operationId, }) {
-    const constrainedArtifact = cloneProjectedTypiaLlmFunctionArtifact(functionArtifact);
-    const operation = findOpenApiOperationById(openApiDocument, operationId);
-    if (!operation) {
-        return constrainedArtifact;
-    }
-    const hasQueryParameters = (operation.parameters ?? []).some((parameter) => {
-        const resolvedParameter = resolveOpenApiSchemaObject(openApiDocument, parameter);
-        return (isJsonSchemaObject(resolvedParameter) &&
-            resolvedParameter.in === 'query' &&
-            typeof resolvedParameter.name === 'string');
-    });
-    const requestBodySchema = resolveOpenApiRequestBodySchema(operation, openApiDocument);
-    const parameterSchema = assertJsonSchemaObject(constrainedArtifact.parameters, `typia.llm parameters for "${constrainedArtifact.name}"`);
-    if (requestBodySchema) {
-        if (hasQueryParameters) {
-            mergeJsonSchemaConstraintProperties(openApiDocument, getOrCreateObjectProperty(parameterSchema, 'body'), requestBodySchema);
-        }
-        else {
-            mergeJsonSchemaConstraintProperties(openApiDocument, parameterSchema, requestBodySchema);
-        }
-    }
-    if (hasQueryParameters) {
-        applyOpenApiQueryParameterConstraints(requestBodySchema
-            ? getOrCreateObjectProperty(parameterSchema, 'query')
-            : parameterSchema, operation, openApiDocument);
-    }
-    if (constrainedArtifact.output) {
-        const outputSchema = assertJsonSchemaObject(constrainedArtifact.output, `typia.llm output for "${constrainedArtifact.name}"`);
-        const responseSchema = resolveOpenApiSuccessResponseSchema(operation, openApiDocument);
-        if (responseSchema) {
-            mergeJsonSchemaConstraintProperties(openApiDocument, outputSchema, responseSchema);
-        }
-    }
-    return constrainedArtifact;
-}
-/**
- * Projects a compiled `typia.llm.application(...)` result into a JSON-friendly
- * downstream adapter artifact.
- *
- * @param options Compiled application value and source metadata.
- * @returns JSON-friendly application artifact.
- */
-export function projectTypiaLlmApplicationArtifact({ application, generatedFrom, openApiProjection, transformFunction, }) {
-    return {
-        functions: application.functions.map((functionSchema) => {
-            const functionArtifact = projectTypiaLlmApplicationFunction(functionSchema);
-            const openApiAlignedArtifact = openApiProjection
-                ? applyOpenApiConstraintsToTypiaLlmFunctionArtifact({
-                    functionArtifact,
-                    openApiDocument: openApiProjection.openApiDocument,
-                    operationId: openApiProjection.resolveOperationId?.(functionSchema, functionArtifact) ?? functionSchema.name,
-                })
-                : functionArtifact;
-            const transformedArtifact = transformFunction
-                ? transformFunction(openApiAlignedArtifact, functionSchema)
-                : openApiAlignedArtifact;
-            return cloneProjectedTypiaLlmFunctionArtifact(transformedArtifact);
-        }),
-        generatedFrom: cloneJsonValue(generatedFrom),
-    };
-}
-/**
- * Projects a compiled `typia.llm.structuredOutput(...)` result into a
- * JSON-friendly downstream adapter artifact.
- *
- * @param options Compiled structured-output value and source metadata.
- * @returns JSON-friendly structured-output artifact.
- */
-export function projectTypiaLlmStructuredOutputArtifact({ generatedFrom, structuredOutput, }) {
-    return {
-        generatedFrom: cloneJsonValue(generatedFrom),
-        parameters: cloneJsonValue(structuredOutput.parameters),
-    };
-}
+export { assertJsonSchemaObject } from './typia-llm-json-schema.js';
+export { applyOpenApiConstraintsToTypiaLlmFunctionArtifact, } from './typia-llm-openapi-constraints.js';
+export { projectTypiaLlmApplicationArtifact, projectTypiaLlmApplicationFunction, projectTypiaLlmStructuredOutputArtifact, } from './typia-llm-projection.js';
+export { buildTypiaLlmEndpointMethodDescriptors, renderTypiaLlmModule, } from './typia-llm-render.js';
+export { syncTypiaLlmAdapterModule } from './typia-llm-sync.js';

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

@@ -1,7 +1,7 @@
 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 { 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();
@@ -136,8 +136,21 @@ export function updateWorkspaceInventorySource(source, options = {}) {
         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);
@@ -157,6 +170,7 @@ export function updateWorkspaceInventorySource(source, options = {}) {
         ["responseTypeName", "\tresponseTypeName?: string;"],
         ["routePattern", "\troutePattern?: string;"],
         ["secretFieldName", "\tsecretFieldName?: string;"],
+        ["secretPreserveOnEmpty", "\tsecretPreserveOnEmpty?: boolean;"],
         ["secretStateFieldName", "\tsecretStateFieldName?: string;"],
     ]) {
         nextSource = upsertInterfaceField(nextSource, "WorkspaceRestResourceConfig", fieldName, fieldSource);

package/dist/runtime/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;
+};