@wp-typia/project-tools 0.22.0 → 0.22.2

package/dist/runtime/package-versions.js

@@ -1,12 +1,12 @@
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { PROJECT_TOOLS_PACKAGE_ROOT } from "./template-registry.js";
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { PROJECT_TOOLS_PACKAGE_ROOT } from './template-registry.js';
 const require = createRequire(import.meta.url);
-const DEFAULT_VERSION_RANGE = "^0.0.0";
-const DEFAULT_EXACT_VERSION = "0.0.0";
-const DEFAULT_TSX_PACKAGE_VERSION = "^4.20.5";
-const DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = "^12.0.1";
+const DEFAULT_VERSION_RANGE = '^0.0.0';
+const DEFAULT_EXACT_VERSION = '0.0.0';
+const DEFAULT_TSX_PACKAGE_VERSION = '^4.20.5';
+const DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = '^12.0.1';
 /**
  * Explicit fallback ranges for managed WordPress-facing workspace dependencies.
  *
@@ -14,15 +14,15 @@ const DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = "^12.0.1";
  * fresher local or installed manifest version first, so add-command defaults do
  * not drift across runtime modules.
  */
-export const DEFAULT_WORDPRESS_ABILITIES_VERSION = "^0.10.0";
-export const DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = "^0.9.0";
-export const DEFAULT_WORDPRESS_CORE_DATA_VERSION = "^7.44.0";
-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.0";
+export const DEFAULT_WORDPRESS_ABILITIES_VERSION = '^0.10.0';
+export const DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = '^0.9.0';
+export const DEFAULT_WORDPRESS_CORE_DATA_VERSION = '^7.44.0';
+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.0';
 let cachedPackageVersions = null;
 function getErrorCode(error) {
-    return typeof error === "object" && error !== null && "code" in error
+    return typeof error === 'object' && error !== null && 'code' in error
         ? String(error.code)
         : undefined;
 }
@@ -31,7 +31,7 @@ function normalizeVersionRange(value) {
     if (!trimmed) {
         return DEFAULT_VERSION_RANGE;
     }
-    if (trimmed.startsWith("workspace:")) {
+    if (trimmed.startsWith('workspace:')) {
         return DEFAULT_VERSION_RANGE;
     }
     return /^[~^<>=]/.test(trimmed) ? trimmed : `^${trimmed}`;
@@ -41,10 +41,10 @@ function normalizeExactVersion(value) {
     if (!trimmed) {
         return DEFAULT_EXACT_VERSION;
     }
-    if (trimmed.startsWith("workspace:")) {
+    if (trimmed.startsWith('workspace:')) {
         return DEFAULT_EXACT_VERSION;
     }
-    return trimmed.replace(/^[~^<>=]+/, "");
+    return trimmed.replace(/^[~^<>=]+/, '');
 }
 function normalizeVersionRangeWithFallback(value, fallback) {
     const normalized = normalizeVersionRange(value);
@@ -61,7 +61,7 @@ function createContentFingerprint(source) {
 function resolvePackageManifestLocation(packageJsonPath) {
     try {
         const stats = fs.statSync(packageJsonPath);
-        const source = fs.readFileSync(packageJsonPath, "utf8");
+        const source = fs.readFileSync(packageJsonPath, 'utf8');
         return {
             cacheKey: `file:${packageJsonPath}:${stats.ino}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.size}:${createContentFingerprint(source)}`,
             packageJsonPath,
@@ -69,7 +69,7 @@ function resolvePackageManifestLocation(packageJsonPath) {
         };
     }
     catch (error) {
-        if (getErrorCode(error) === "ENOENT") {
+        if (getErrorCode(error) === 'ENOENT') {
             return {
                 cacheKey: `missing-file:${packageJsonPath}`,
                 packageJsonPath: null,
@@ -85,12 +85,23 @@ function readPackageManifest(location) {
     }
     return JSON.parse(location.source);
 }
+function tryReadPackageManifest(location) {
+    if (!location) {
+        return null;
+    }
+    try {
+        return readPackageManifest(location);
+    }
+    catch {
+        return null;
+    }
+}
 function resolveInstalledPackageManifestLocation(packageName) {
     try {
         return resolvePackageManifestLocation(require.resolve(`${packageName}/package.json`));
     }
     catch (error) {
-        if (getErrorCode(error) === "MODULE_NOT_FOUND") {
+        if (getErrorCode(error) === 'MODULE_NOT_FOUND') {
             return {
                 cacheKey: `missing-module:${packageName}`,
                 packageJsonPath: null,
@@ -101,7 +112,26 @@ function resolveInstalledPackageManifestLocation(packageName) {
     }
 }
 function composePackageVersionsCacheKey(locations) {
-    return locations.map((location) => location.cacheKey).join("|");
+    return locations.map((location) => location.cacheKey).join('|');
+}
+/**
+ * Resolve a managed package version range from linked workspace packages first,
+ * then installed package manifests, while preserving the shared normalization
+ * and manifest fingerprinting rules used by `getPackageVersions()`.
+ *
+ * @param packageName npm package whose manifest version should be consulted.
+ * @param fallback Canonical range to use when no usable manifest version exists.
+ * @param workspacePackageDirName Optional sibling monorepo package directory name.
+ * @returns A normalized semver range suitable for generated dependency entries.
+ */
+export function resolveManagedPackageVersionRange(options) {
+    const workspaceManifestLocation = options.workspacePackageDirName
+        ? resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', options.workspacePackageDirName, 'package.json'))
+        : null;
+    const installedManifestLocation = resolveInstalledPackageManifestLocation(options.packageName);
+    const workspaceManifest = tryReadPackageManifest(workspaceManifestLocation);
+    const installedManifest = tryReadPackageManifest(installedManifestLocation);
+    return normalizeVersionRangeWithFallback(workspaceManifest?.version ?? installedManifest?.version, options.fallback);
 }
 /**
  * Clears the in-memory cache used by `getPackageVersions()`.
@@ -128,20 +158,20 @@ export function invalidatePackageVersionsCache() {
  * disk, the cache key changes and the returned version object is refreshed.
  */
 export function getPackageVersions() {
-    const createManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, "package.json"));
-    const monorepoManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", "..", "package.json"));
-    const blockRuntimeManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", "wp-typia-block-runtime", "package.json"));
-    const wpTypiaManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", "wp-typia", "package.json"));
-    const installedProjectToolsManifestLocation = resolveInstalledPackageManifestLocation("@wp-typia/project-tools");
-    const installedApiClientManifestLocation = resolveInstalledPackageManifestLocation("@wp-typia/api-client");
-    const installedBlockRuntimeManifestLocation = resolveInstalledPackageManifestLocation("@wp-typia/block-runtime");
-    const installedBlockTypesManifestLocation = resolveInstalledPackageManifestLocation("@wp-typia/block-types");
-    const installedRestManifestLocation = resolveInstalledPackageManifestLocation("@wp-typia/rest");
-    const installedTsxManifestLocation = resolveInstalledPackageManifestLocation("tsx");
-    const installedTypiaManifestLocation = resolveInstalledPackageManifestLocation("typia");
-    const installedTypiaUnpluginManifestLocation = resolveInstalledPackageManifestLocation("@typia/unplugin");
-    const installedTypescriptManifestLocation = resolveInstalledPackageManifestLocation("typescript");
-    const installedWpTypiaManifestLocation = resolveInstalledPackageManifestLocation("wp-typia");
+    const createManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, 'package.json'));
+    const monorepoManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', '..', 'package.json'));
+    const blockRuntimeManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', 'wp-typia-block-runtime', 'package.json'));
+    const wpTypiaManifestLocation = resolvePackageManifestLocation(path.join(PROJECT_TOOLS_PACKAGE_ROOT, '..', 'wp-typia', 'package.json'));
+    const installedProjectToolsManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/project-tools');
+    const installedApiClientManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/api-client');
+    const installedBlockRuntimeManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/block-runtime');
+    const installedBlockTypesManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/block-types');
+    const installedRestManifestLocation = resolveInstalledPackageManifestLocation('@wp-typia/rest');
+    const installedTsxManifestLocation = resolveInstalledPackageManifestLocation('tsx');
+    const installedTypiaManifestLocation = resolveInstalledPackageManifestLocation('typia');
+    const installedTypiaUnpluginManifestLocation = resolveInstalledPackageManifestLocation('@typia/unplugin');
+    const installedTypescriptManifestLocation = resolveInstalledPackageManifestLocation('typescript');
+    const installedWpTypiaManifestLocation = resolveInstalledPackageManifestLocation('wp-typia');
     const cacheKey = composePackageVersionsCacheKey([
         createManifestLocation,
         monorepoManifestLocation,
@@ -171,17 +201,17 @@ export function getPackageVersions() {
     const wpTypiaManifest = readPackageManifest(wpTypiaManifestLocation) ??
         readPackageManifest(installedWpTypiaManifestLocation) ??
         {};
-    const blockRuntimeDependencyVersion = normalizeVersionRange(createManifest.dependencies?.["@wp-typia/block-runtime"]);
+    const blockRuntimeDependencyVersion = normalizeVersionRange(createManifest.dependencies?.['@wp-typia/block-runtime']);
     const versions = {
-        apiClientPackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/api-client"] ??
+        apiClientPackageVersion: normalizeVersionRange(createManifest.dependencies?.['@wp-typia/api-client'] ??
             readPackageManifest(installedApiClientManifestLocation)?.version),
         blockRuntimePackageVersion: blockRuntimeDependencyVersion !== DEFAULT_VERSION_RANGE
             ? blockRuntimeDependencyVersion
             : normalizeVersionRange(blockRuntimeManifest.version),
-        blockTypesPackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/block-types"] ??
+        blockTypesPackageVersion: normalizeVersionRange(createManifest.dependencies?.['@wp-typia/block-types'] ??
             readPackageManifest(installedBlockTypesManifestLocation)?.version),
         projectToolsPackageVersion: normalizeVersionRange(createManifest.version),
-        restPackageVersion: normalizeVersionRange(createManifest.dependencies?.["@wp-typia/rest"] ??
+        restPackageVersion: normalizeVersionRange(createManifest.dependencies?.['@wp-typia/rest'] ??
             readPackageManifest(installedRestManifestLocation)?.version),
         tsxPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.tsx ??
             monorepoManifest.devDependencies?.tsx ??
@@ -190,8 +220,8 @@ export function getPackageVersions() {
             monorepoManifest.devDependencies?.typia ??
             createManifest.dependencies?.typia ??
             readPackageManifest(installedTypiaManifestLocation)?.version, DEFAULT_VERSION_RANGE),
-        typiaUnpluginPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.["@typia/unplugin"] ??
-            monorepoManifest.devDependencies?.["@typia/unplugin"] ??
+        typiaUnpluginPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.['@typia/unplugin'] ??
+            monorepoManifest.devDependencies?.['@typia/unplugin'] ??
             readPackageManifest(installedTypiaUnpluginManifestLocation)?.version, DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION),
         typescriptPackageVersion: normalizeVersionRangeWithFallback(monorepoManifest.dependencies?.typescript ??
             monorepoManifest.devDependencies?.typescript ??

package/dist/runtime/scaffold-compatibility.d.ts

@@ -26,7 +26,9 @@ export interface ScaffoldCompatibilityPolicy {
 export interface ScaffoldCompatibilityConfig {
     hardMinimums: AiFeatureCompatibilityFloor;
     mode: 'baseline' | 'optional' | 'required';
+    optionalFeatureIds: string[];
     optionalFeatures: string[];
+    requiredFeatureIds: string[];
     requiredFeatures: string[];
     runtimeGates: string[];
 }

package/dist/runtime/scaffold-compatibility.js

@@ -88,7 +88,9 @@ export function createScaffoldCompatibilityConfig(policy) {
     return {
         hardMinimums: capabilityPlan.hardMinimums,
         mode: getPolicyMode(capabilityPlan),
+        optionalFeatureIds: capabilityPlan.optionalFeatures.map((feature) => feature.id),
         optionalFeatures: capabilityPlan.optionalFeatures.map((feature) => feature.label),
+        requiredFeatureIds: capabilityPlan.requiredFeatures.map((feature) => feature.id),
         requiredFeatures: capabilityPlan.requiredFeatures.map((feature) => feature.label),
         runtimeGates: [
             ...capabilityPlan.requiredFeatures.flatMap(formatRuntimeGate),

package/dist/runtime/string-case.d.ts

@@ -19,6 +19,13 @@ export declare function toSnakeCase(input: string): string;
  * @returns A PascalCase string derived from the normalized kebab-case form.
  */
 export declare function toPascalCase(input: string): string;
+/**
+ * Normalize arbitrary text into a camelCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A camelCase string derived from the normalized PascalCase form.
+ */
+export declare function toCamelCase(input: string): string;
 /**
  * Convert delimited text to PascalCase while preserving each segment's
  * existing internal casing.

package/dist/runtime/string-case.js

@@ -10,10 +10,10 @@ function capitalizeSegment(segment) {
 export function toKebabCase(input) {
     return input
         .trim()
-        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-        .replace(/[^A-Za-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .replace(/-{2,}/g, "-")
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-')
         .toLowerCase();
 }
 /**
@@ -23,7 +23,7 @@ export function toKebabCase(input) {
  * @returns A lowercase snake_case string derived from the kebab-case form.
  */
 export function toSnakeCase(input) {
-    return toKebabCase(input).replace(/-/g, "_");
+    return toKebabCase(input).replace(/-/g, '_');
 }
 /**
  * Normalize arbitrary text into a PascalCase identifier.
@@ -33,10 +33,20 @@ export function toSnakeCase(input) {
  */
 export function toPascalCase(input) {
     return toKebabCase(input)
-        .split("-")
+        .split('-')
         .filter(Boolean)
         .map(capitalizeSegment)
-        .join("");
+        .join('');
+}
+/**
+ * Normalize arbitrary text into a camelCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A camelCase string derived from the normalized PascalCase form.
+ */
+export function toCamelCase(input) {
+    const pascalCase = toPascalCase(input);
+    return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
 }
 /**
  * Convert delimited text to PascalCase while preserving each segment's
@@ -47,12 +57,12 @@ export function toPascalCase(input) {
  */
 export function toSegmentPascalCase(input) {
     return input
-        .replace(/[^A-Za-z0-9]+/g, " ")
+        .replace(/[^A-Za-z0-9]+/g, ' ')
         .trim()
         .split(/\s+/)
         .filter(Boolean)
         .map(capitalizeSegment)
-        .join("");
+        .join('');
 }
 /**
  * Normalize arbitrary text into a human-readable title.
@@ -62,8 +72,8 @@ export function toSegmentPascalCase(input) {
  */
 export function toTitleCase(input) {
     return toKebabCase(input)
-        .split("-")
+        .split('-')
         .filter(Boolean)
         .map(capitalizeSegment)
-        .join(" ");
+        .join(' ');
 }

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

@@ -1,6 +1,6 @@
 import type { ArtifactSyncExecutionOptions, EndpointManifestDefinition, EndpointManifestEndpointDefinition } from '@wp-typia/block-runtime/metadata-core';
 import type { ILlmFunction, ILlmSchema, ILlmStructuredOutput } from 'typia';
-import { type EndpointAuthIntent, type EndpointWordPressAuthDefinition } from './schema-core.js';
+import { type EndpointAuthIntent, type EndpointWordPressAuthDefinition, type OpenApiDocument } from './schema-core.js';
 /**
  * Method-level descriptor projected from an endpoint manifest for a generated
  * `typia.llm` controller interface.
@@ -140,6 +140,16 @@ export interface ProjectedTypiaLlmStructuredOutputArtifact {
     /** Structured output parameters generated by `typia.llm`. */
     parameters: ILlmStructuredOutput['parameters'];
 }
+/**
+ * Configures optional OpenAPI-backed constraint restoration for projected
+ * `typia.llm` function artifacts.
+ */
+export interface ProjectTypiaLlmOpenApiProjectionOptions {
+    /** Canonical endpoint-aware OpenAPI document for the projected contracts. */
+    openApiDocument: OpenApiDocument;
+    /** Optional override for resolving one function schema to an operation id. */
+    resolveOperationId?: (functionSchema: TypiaLlmFunctionLike, functionArtifact: ProjectedTypiaLlmFunctionArtifact) => string;
+}
 /**
  * Configures projection of a compiled `typia.llm.application(...)` result into
  * the JSON-friendly adapter artifact.
@@ -149,9 +159,23 @@ export interface ProjectTypiaLlmApplicationArtifactOptions {
     application: TypiaLlmApplicationLike;
     /** Source metadata for the generated JSON artifact. */
     generatedFrom: ProjectedTypiaLlmApplicationArtifact['generatedFrom'];
+    /** Optional OpenAPI projection that restores canonical schema constraints. */
+    openApiProjection?: ProjectTypiaLlmOpenApiProjectionOptions;
     /** Optional hook for adapter-specific function schema normalization. */
     transformFunction?: (functionArtifact: ProjectedTypiaLlmFunctionArtifact, functionSchema: TypiaLlmFunctionLike) => ProjectedTypiaLlmFunctionArtifact;
 }
+/**
+ * Configures direct OpenAPI-backed constraint restoration for one projected
+ * function artifact.
+ */
+export interface ApplyOpenApiConstraintsToTypiaLlmFunctionArtifactOptions {
+    /** Projected function artifact to enrich with canonical constraints. */
+    functionArtifact: ProjectedTypiaLlmFunctionArtifact;
+    /** Canonical endpoint-aware OpenAPI document. */
+    openApiDocument: OpenApiDocument;
+    /** Operation id that owns the request/response contract for this function. */
+    operationId: string;
+}
 /**
  * Configures projection of a compiled `typia.llm.structuredOutput(...)` result
  * into the JSON-friendly adapter artifact.
@@ -197,6 +221,17 @@ export declare function syncTypiaLlmAdapterModule({ check, generatedSourceFile,
  * @returns JSON-friendly function artifact.
  */
 export declare function projectTypiaLlmApplicationFunction(functionSchema: TypiaLlmFunctionLike): ProjectedTypiaLlmFunctionArtifact;
+/**
+ * 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 declare function applyOpenApiConstraintsToTypiaLlmFunctionArtifact({ functionArtifact, openApiDocument, operationId, }: ApplyOpenApiConstraintsToTypiaLlmFunctionArtifactOptions): ProjectedTypiaLlmFunctionArtifact;
 /**
  * Projects a compiled `typia.llm.application(...)` result into a JSON-friendly
  * downstream adapter artifact.
@@ -204,7 +239,7 @@ export declare function projectTypiaLlmApplicationFunction(functionSchema: Typia
  * @param options Compiled application value and source metadata.
  * @returns JSON-friendly application artifact.
  */
-export declare function projectTypiaLlmApplicationArtifact({ application, generatedFrom, transformFunction, }: ProjectTypiaLlmApplicationArtifactOptions): ProjectedTypiaLlmApplicationArtifact;
+export declare function projectTypiaLlmApplicationArtifact({ application, generatedFrom, openApiProjection, transformFunction, }: ProjectTypiaLlmApplicationArtifactOptions): ProjectedTypiaLlmApplicationArtifact;
 /**
  * Projects a compiled `typia.llm.structuredOutput(...)` result into a
  * JSON-friendly downstream adapter artifact.

package/dist/runtime/typia-llm.js

@@ -81,9 +81,195 @@ const TYPESCRIPT_RESERVED_WORDS = new Set([
     '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);
+}
+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]);
+}
+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) {
@@ -342,6 +528,50 @@ function cloneProjectedTypiaLlmFunctionArtifact(functionArtifact) {
         ...(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);
+    if (requestBodySchema) {
+        if (hasQueryParameters) {
+            mergeJsonSchemaConstraintProperties(openApiDocument, getOrCreateObjectProperty(constrainedArtifact.parameters, 'body'), requestBodySchema);
+        }
+        else {
+            mergeJsonSchemaConstraintProperties(openApiDocument, constrainedArtifact.parameters, requestBodySchema);
+        }
+    }
+    if (hasQueryParameters) {
+        applyOpenApiQueryParameterConstraints(requestBodySchema
+            ? getOrCreateObjectProperty(constrainedArtifact.parameters, 'query')
+            : constrainedArtifact.parameters, operation, openApiDocument);
+    }
+    if (constrainedArtifact.output) {
+        const responseSchema = resolveOpenApiSuccessResponseSchema(operation, openApiDocument);
+        if (responseSchema) {
+            mergeJsonSchemaConstraintProperties(openApiDocument, constrainedArtifact.output, responseSchema);
+        }
+    }
+    return constrainedArtifact;
+}
 /**
  * Projects a compiled `typia.llm.application(...)` result into a JSON-friendly
  * downstream adapter artifact.
@@ -349,13 +579,20 @@ function cloneProjectedTypiaLlmFunctionArtifact(functionArtifact) {
  * @param options Compiled application value and source metadata.
  * @returns JSON-friendly application artifact.
  */
-export function projectTypiaLlmApplicationArtifact({ application, generatedFrom, transformFunction, }) {
+export function projectTypiaLlmApplicationArtifact({ application, generatedFrom, openApiProjection, transformFunction, }) {
     return {
         functions: application.functions.map((functionSchema) => {
             const functionArtifact = projectTypiaLlmApplicationFunction(functionSchema);
-            const transformedArtifact = transformFunction
-                ? transformFunction(functionArtifact, 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),