@wp-typia/project-tools 0.23.0 → 0.24.0

package/dist/runtime/typia-llm-openapi-constraints.js

@@ -0,0 +1,254 @@
+import { cloneJsonValue } from './json-utils.js';
+import { assertJsonSchemaObject, cloneJsonValueIfDefined, isJsonSchemaObject, } from './typia-llm-json-schema.js';
+const JSON_SCHEMA_CONSTRAINT_KEYS = [
+    'additionalProperties',
+    'const',
+    'default',
+    'enum',
+    'exclusiveMaximum',
+    'exclusiveMinimum',
+    'format',
+    'maxItems',
+    'maxLength',
+    'maximum',
+    'minItems',
+    'minLength',
+    'minimum',
+    'multipleOf',
+    'pattern',
+    'type',
+];
+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];
+        }
+    }
+}
+/**
+ * Clone a projected function artifact before mutation-oriented constraint work.
+ *
+ * @param functionArtifact Projected artifact to clone.
+ * @returns A cloned artifact with parameters and optional output deep-cloned,
+ * and tags shallow-copied when present.
+ */
+export 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;
+}

package/dist/runtime/typia-llm-projection.d.ts

@@ -0,0 +1,25 @@
+import type { ProjectedTypiaLlmApplicationArtifact, ProjectedTypiaLlmFunctionArtifact, ProjectedTypiaLlmStructuredOutputArtifact, ProjectTypiaLlmApplicationArtifactOptions, ProjectTypiaLlmStructuredOutputArtifactOptions, TypiaLlmFunctionLike } from './typia-llm-types.js';
+/**
+ * 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 declare function projectTypiaLlmApplicationFunction(functionSchema: TypiaLlmFunctionLike): ProjectedTypiaLlmFunctionArtifact;
+/**
+ * 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 declare function projectTypiaLlmApplicationArtifact({ application, generatedFrom, openApiProjection, transformFunction, }: ProjectTypiaLlmApplicationArtifactOptions): ProjectedTypiaLlmApplicationArtifact;
+/**
+ * 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 declare function projectTypiaLlmStructuredOutputArtifact({ generatedFrom, structuredOutput, }: ProjectTypiaLlmStructuredOutputArtifactOptions): ProjectedTypiaLlmStructuredOutputArtifact;

package/dist/runtime/typia-llm-projection.js

@@ -0,0 +1,58 @@
+import { cloneJsonValue } from './json-utils.js';
+import { cloneJsonValueIfDefined } from './typia-llm-json-schema.js';
+import { applyOpenApiConstraintsToTypiaLlmFunctionArtifact, cloneProjectedTypiaLlmFunctionArtifact, } from './typia-llm-openapi-constraints.js';
+/**
+ * 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] } : {}),
+    };
+}
+/**
+ * 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),
+    };
+}

package/dist/runtime/typia-llm-render.d.ts

@@ -0,0 +1,21 @@
+import type { EndpointManifestDefinition } from '@wp-typia/block-runtime/metadata-core';
+import type { RenderTypiaLlmModuleOptions, TypiaLlmEndpointMethodDescriptor } from './typia-llm-types.js';
+export declare function renderTypiaLlmModuleFromMethodDescriptors({ applicationExportName, interfaceName, structuredOutputExportName, structuredOutputTypeName, typesImportPath, }: Omit<RenderTypiaLlmModuleOptions, 'manifest'>, methods: readonly TypiaLlmEndpointMethodDescriptor[]): string;
+/**
+ * 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 declare function buildTypiaLlmEndpointMethodDescriptors(manifest: EndpointManifestDefinition): TypiaLlmEndpointMethodDescriptor[];
+/**
+ * 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 declare function renderTypiaLlmModule({ applicationExportName, interfaceName, manifest, structuredOutputExportName, structuredOutputTypeName, typesImportPath, }: RenderTypiaLlmModuleOptions): string;

package/dist/runtime/typia-llm-render.js

@@ -0,0 +1,252 @@
+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',
+]);
+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 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};`;
+}
+export 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}>();
+`;
+}
+/**
+ * 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));
+}

package/dist/runtime/typia-llm-sync.d.ts

@@ -0,0 +1,10 @@
+import type { SyncTypiaLlmAdapterModuleOptions, SyncTypiaLlmAdapterModuleResult } from './typia-llm-types.js';
+/**
+ * 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 declare function syncTypiaLlmAdapterModule({ check, generatedSourceFile, ...renderOptions }: SyncTypiaLlmAdapterModuleOptions): Promise<SyncTypiaLlmAdapterModuleResult>;

package/dist/runtime/typia-llm-sync.js

@@ -0,0 +1,63 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getOptionalNodeErrorCode, isFileNotFoundError, } from './fs-async.js';
+import { buildTypiaLlmEndpointMethodDescriptors, renderTypiaLlmModuleFromMethodDescriptors, } from './typia-llm-render.js';
+function normalizeGeneratedArtifactContent(content) {
+    return content.replace(/\r\n?/g, '\n');
+}
+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')}`);
+    }
+}
+/**
+ * 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,
+    };
+}