@wp-typia/block-runtime 0.4.0 → 0.4.3

package/dist/blocks.d.ts

@@ -34,6 +34,19 @@ export interface TypiaWebpackConfigOptions {
     path: {
         join(...paths: string[]): string;
     };
+    projectRoot?: string;
+}
+export interface TypiaWebpackPluginLoaderOptions {
+    importTypiaWebpackPlugin: () => Promise<{
+        default: () => unknown;
+    }>;
+    projectRoot?: string;
+}
+interface TypiaWebpackVersionMatrix {
+    "@typia/unplugin": string | null;
+    "@wordpress/scripts": string | null;
+    typia: string | null;
+    webpack: string | null;
 }
 type OverrideProperties<TBase, TOverride> = Omit<TBase, keyof TOverride> & TOverride;
 type ScaffoldSupportDefaultControls<TFeature extends string> = Readonly<Partial<Record<TFeature, boolean>> & Record<string, boolean | undefined>>;
@@ -169,8 +182,12 @@ export interface BuildScaffoldBlockRegistrationResult<TSettings extends object>
     name: string;
     settings: TSettings;
 }
+export declare function assertTypiaWebpackCompatibility({ projectRoot, }?: {
+    projectRoot?: string;
+}): Promise<TypiaWebpackVersionMatrix>;
+export declare function loadCompatibleTypiaWebpackPlugin({ importTypiaWebpackPlugin, projectRoot, }: TypiaWebpackPluginLoaderOptions): Promise<() => unknown>;
 export declare function buildScaffoldBlockRegistration<TSettings extends object>(metadata: ScaffoldBlockMetadata, overrides: Partial<TSettings> & Record<string, unknown>): BuildScaffoldBlockRegistrationResult<TSettings>;
-export declare function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset, moduleEntriesMode, nonModuleEntriesMode, path, }: TypiaWebpackConfigOptions): Promise<{
+export declare function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset, moduleEntriesMode, nonModuleEntriesMode, path, projectRoot, }: TypiaWebpackConfigOptions): Promise<{
     entry: () => Promise<Record<string, unknown>>;
     plugins: unknown[];
 } | {

package/dist/blocks.js

@@ -15,6 +15,96 @@ function isModuleConfig(config) {
         config !== null &&
         config.output?.module === true);
 }
+function parseMajorVersion(version) {
+    if (!version) {
+        return null;
+    }
+    const match = /^(\d+)/u.exec(version);
+    return match ? Number.parseInt(match[1], 10) : null;
+}
+function readPackageVersion(readFileSync, packageJsonPath) {
+    try {
+        return JSON.parse(readFileSync(packageJsonPath, "utf8")).version;
+    }
+    catch {
+        return null;
+    }
+}
+async function loadNodeRuntimeHelpers() {
+    const importNodeModule = Function("specifier", "return import(specifier);");
+    const [fsModule, moduleBuiltin, pathBuiltin] = (await Promise.all([
+        importNodeModule("node:fs"),
+        importNodeModule("node:module"),
+        importNodeModule("node:path"),
+    ]));
+    return {
+        createRequire: moduleBuiltin.createRequire,
+        pathModule: pathBuiltin,
+        readFileSync: fsModule.readFileSync,
+    };
+}
+function resolveInstalledPackageVersion(readFileSync, requireFromProject, packageName) {
+    try {
+        return readPackageVersion(readFileSync, requireFromProject.resolve(`${packageName}/package.json`));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveWebpackVersion(readFileSync, requireFromProject, createRequire) {
+    try {
+        const wordpressScriptsPackageJsonPath = requireFromProject.resolve("@wordpress/scripts/package.json");
+        const requireFromWordPressScripts = createRequire(wordpressScriptsPackageJsonPath);
+        const bundledWebpackVersion = resolveInstalledPackageVersion(readFileSync, requireFromWordPressScripts, "webpack");
+        if (bundledWebpackVersion) {
+            return bundledWebpackVersion;
+        }
+    }
+    catch {
+        // fall through to the project-level webpack resolution below
+    }
+    return resolveInstalledPackageVersion(readFileSync, requireFromProject, "webpack");
+}
+async function getTypiaWebpackVersionMatrix(projectRoot = process.cwd()) {
+    const { createRequire, pathModule, readFileSync } = await loadNodeRuntimeHelpers();
+    const packageJsonPath = pathModule.resolve(projectRoot, "package.json");
+    const requireFromProject = createRequire(packageJsonPath);
+    return {
+        "@typia/unplugin": resolveInstalledPackageVersion(readFileSync, requireFromProject, "@typia/unplugin"),
+        "@wordpress/scripts": resolveInstalledPackageVersion(readFileSync, requireFromProject, "@wordpress/scripts"),
+        typia: resolveInstalledPackageVersion(readFileSync, requireFromProject, "typia"),
+        webpack: resolveWebpackVersion(readFileSync, requireFromProject, createRequire),
+    };
+}
+function formatInstalledMatrix(versionMatrix) {
+    return [
+        `typia=${versionMatrix.typia ?? "missing"}`,
+        `@typia/unplugin=${versionMatrix["@typia/unplugin"] ?? "missing"}`,
+        `@wordpress/scripts=${versionMatrix["@wordpress/scripts"] ?? "missing"}`,
+        `webpack=${versionMatrix.webpack ?? "missing"}`,
+    ].join(", ");
+}
+export async function assertTypiaWebpackCompatibility({ projectRoot = process.cwd(), } = {}) {
+    const versionMatrix = await getTypiaWebpackVersionMatrix(projectRoot);
+    const isSupported = parseMajorVersion(versionMatrix.typia) === 12 &&
+        parseMajorVersion(versionMatrix["@typia/unplugin"]) === 12 &&
+        parseMajorVersion(versionMatrix["@wordpress/scripts"]) === 30 &&
+        parseMajorVersion(versionMatrix.webpack) === 5;
+    if (isSupported) {
+        return versionMatrix;
+    }
+    throw new Error([
+        "Unsupported Typia/Webpack toolchain for generated wp-typia projects.",
+        `Installed versions: ${formatInstalledMatrix(versionMatrix)}.`,
+        "Supported matrix: typia 12.x, @typia/unplugin 12.x, @wordpress/scripts 30.x with webpack 5.x.",
+        "Generated project defaults were tested against this matrix.",
+    ].join(" "));
+}
+export async function loadCompatibleTypiaWebpackPlugin({ importTypiaWebpackPlugin, projectRoot = process.cwd(), }) {
+    await assertTypiaWebpackCompatibility({ projectRoot });
+    const { default: UnpluginTypia } = await importTypiaWebpackPlugin();
+    return UnpluginTypia;
+}
 function mergeEntries(existingEntries, nextEntries, mode) {
     if (!nextEntries) {
         return existingEntries;
@@ -40,8 +130,11 @@ export function buildScaffoldBlockRegistration(metadata, overrides) {
         },
     };
 }
-export async function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset = (assetName) => /(^|\/)(interactivity|view)\.asset\.php$/.test(assetName), moduleEntriesMode = "merge", nonModuleEntriesMode = "merge", path, }) {
-    const { default: UnpluginTypia } = await importTypiaWebpackPlugin();
+export async function createTypiaWebpackConfig({ defaultConfig, fs, getArtifactEntries, getEditorEntries, getOptionalModuleEntries, importTypiaWebpackPlugin, isScriptModuleAsset = (assetName) => /(^|\/)(interactivity|view)\.asset\.php$/.test(assetName), moduleEntriesMode = "merge", nonModuleEntriesMode = "merge", path, projectRoot = process.cwd(), }) {
+    const UnpluginTypia = await loadCompatibleTypiaWebpackPlugin({
+        importTypiaWebpackPlugin,
+        projectRoot,
+    });
     const resolvedDefaultConfig = typeof defaultConfig === "function"
         ? await defaultConfig()
         : defaultConfig;

package/dist/metadata-core.js

@@ -4,7 +4,7 @@ import { getTaggedSyncBlockMetadataFailureCode } from './metadata-analysis.js';
 import { renderPhpValidator } from './metadata-php-render.js';
 import { analyzeSourceType, analyzeSourceTypes } from './metadata-parser.js';
 import { createBlockJsonAttribute, createExampleValue, createManifestDocument, validateWordPressExtractionAttributes, } from './metadata-projection.js';
-import { buildEndpointOpenApiDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, } from './schema-core.js';
+import { buildEndpointOpenApiDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, projectJsonSchemaDocument, } from './schema-core.js';
 /**
  * Preserve literal TypeScript inference for backend-neutral endpoint manifests.
  *
@@ -251,7 +251,9 @@ export async function syncTypeSchemas(options, executionOptions = {}) {
         : undefined;
     reconcileGeneratedArtifacts([
         {
-            content: JSON.stringify(manifestToJsonSchema(manifest), null, '\t'),
+            content: JSON.stringify(projectJsonSchemaDocument(manifestToJsonSchema(manifest), {
+                profile: 'rest',
+            }), null, '\t'),
             path: jsonSchemaPath,
         },
         ...(openApiPath

package/dist/object-utils.js

@@ -1,7 +1,4 @@
+import { isPlainObject as isSharedPlainObject } from "@wp-typia/api-client/runtime-primitives";
 export function isPlainObject(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
+    return isSharedPlainObject(value);
 }

package/dist/schema-core.d.ts

@@ -59,6 +59,7 @@ export interface OpenApiResponse extends JsonSchemaObject {
         "application/json": OpenApiMediaType;
     };
     description: string;
+    headers?: Record<string, JsonSchemaObject>;
 }
 /**
  * Header-based security scheme used by authenticated WordPress REST routes.

package/dist/schema-core.js

@@ -149,15 +149,35 @@ function applyProjectedTypeTag(schema, typeTag, path) {
             throw new Error(`Unsupported wp-typia schema type tag "${typeTag}" at "${path}".`);
     }
 }
+function canProjectTypeTag(typeTag) {
+    switch (typeTag) {
+        case "uint32":
+        case "int32":
+        case "float":
+        case "double":
+            return true;
+        default:
+            return false;
+    }
+}
 function projectSchemaArrayItemsForAiStructuredOutput(items, path) {
     return items.map((item, index) => projectSchemaObjectForAiStructuredOutput(item, `${path}/${index}`));
 }
+function projectSchemaArrayItemsForRest(items, path) {
+    return items.map((item, index) => projectSchemaObjectForRest(item, `${path}/${index}`));
+}
 function projectSchemaPropertyMapForAiStructuredOutput(properties, path) {
     return Object.fromEntries(Object.entries(properties).map(([key, value]) => [
         key,
         projectSchemaObjectForAiStructuredOutput(value, `${path}/${key}`),
     ]));
 }
+function projectSchemaPropertyMapForRest(properties, path) {
+    return Object.fromEntries(Object.entries(properties).map(([key, value]) => [
+        key,
+        projectSchemaObjectForRest(value, `${path}/${key}`),
+    ]));
+}
 function projectSchemaObjectForAiStructuredOutput(node, path) {
     const projectedNode = cloneJsonSchemaNode(node);
     const rawTypeTag = projectedNode[WP_TYPIA_OPENAPI_EXTENSION_KEYS.TYPE_TAG];
@@ -188,6 +208,126 @@ function projectSchemaObjectForAiStructuredOutput(node, path) {
     }
     return projectedNode;
 }
+function projectSchemaObjectForRest(node, path) {
+    const projectedNode = cloneJsonSchemaNode(node);
+    const rawTypeTag = projectedNode[WP_TYPIA_OPENAPI_EXTENSION_KEYS.TYPE_TAG];
+    if (typeof rawTypeTag === "string" && canProjectTypeTag(rawTypeTag)) {
+        applyProjectedTypeTag(projectedNode, rawTypeTag, path);
+    }
+    for (const key of Object.keys(projectedNode)) {
+        const child = projectedNode[key];
+        if (Array.isArray(child)) {
+            projectedNode[key] = child.every(isJsonSchemaObject)
+                ? projectSchemaArrayItemsForRest(child, `${path}/${key}`)
+                : child;
+            continue;
+        }
+        if (!isJsonSchemaObject(child)) {
+            continue;
+        }
+        if (key === "properties") {
+            projectedNode[key] = projectSchemaPropertyMapForRest(child, `${path}/${key}`);
+            continue;
+        }
+        projectedNode[key] = projectSchemaObjectForRest(child, `${path}/${key}`);
+    }
+    applyProjectedBootstrapContract(projectedNode);
+    return projectedNode;
+}
+function applyProjectedBootstrapContract(schema) {
+    if (schema.type !== "object" || !isJsonSchemaObject(schema.properties)) {
+        return;
+    }
+    const properties = schema.properties;
+    if (properties.canWrite?.type !== "boolean") {
+        return;
+    }
+    const allOf = Array.isArray(schema.allOf)
+        ? [...schema.allOf]
+        : [];
+    const canWriteIsTrue = {
+        properties: {
+            canWrite: {
+                const: true,
+            },
+        },
+        required: ["canWrite"],
+    };
+    const buildRequiredPropertyObject = (requiredKeys) => Object.fromEntries(requiredKeys.map((requiredKey) => [requiredKey, properties[requiredKey] ?? {}]));
+    const hasRestNonce = properties.restNonce?.type === "string";
+    const hasPublicWriteCredential = properties.publicWriteToken?.type === "string" &&
+        isJsonSchemaObject(properties.publicWriteExpiresAt);
+    if (hasRestNonce && hasPublicWriteCredential) {
+        allOf.push({
+            if: canWriteIsTrue,
+            then: {
+                anyOf: [
+                    {
+                        properties: buildRequiredPropertyObject(["restNonce"]),
+                        required: ["restNonce"],
+                    },
+                    {
+                        properties: buildRequiredPropertyObject([
+                            "publicWriteExpiresAt",
+                            "publicWriteToken",
+                        ]),
+                        required: ["publicWriteExpiresAt", "publicWriteToken"],
+                    },
+                ],
+            },
+            else: {
+                not: {
+                    anyOf: [
+                        {
+                            properties: buildRequiredPropertyObject(["restNonce"]),
+                            required: ["restNonce"],
+                        },
+                        {
+                            properties: buildRequiredPropertyObject(["publicWriteToken"]),
+                            required: ["publicWriteToken"],
+                        },
+                    ],
+                },
+            },
+        });
+    }
+    if (hasRestNonce && !hasPublicWriteCredential) {
+        allOf.push({
+            if: canWriteIsTrue,
+            then: {
+                properties: buildRequiredPropertyObject(["restNonce"]),
+                required: ["restNonce"],
+            },
+            else: {
+                not: {
+                    properties: buildRequiredPropertyObject(["restNonce"]),
+                    required: ["restNonce"],
+                },
+            },
+        });
+    }
+    if (hasPublicWriteCredential && !hasRestNonce) {
+        allOf.push({
+            if: canWriteIsTrue,
+            then: {
+                properties: buildRequiredPropertyObject([
+                    "publicWriteExpiresAt",
+                    "publicWriteToken",
+                ]),
+                required: ["publicWriteExpiresAt", "publicWriteToken"],
+            },
+            else: {
+                not: {
+                    properties: buildRequiredPropertyObject(["publicWriteToken"]),
+                    required: ["publicWriteToken"],
+                },
+            },
+        });
+    }
+    if (allOf.length > 0) {
+        schema.allOf = allOf;
+    }
+}
 function manifestUnionToJsonSchema(union) {
     const oneOf = Object.entries(union.branches).map(([branchKey, branch]) => {
         if (branch.ts.kind !== "object") {
@@ -305,7 +445,7 @@ export function manifestToJsonSchema(doc) {
  */
 export function projectJsonSchemaDocument(schema, options) {
     if (options.profile === "rest") {
-        return cloneJsonSchemaNode(schema);
+        return projectSchemaObjectForRest(schema, "#");
     }
     if (options.profile === "ai-structured-output") {
         return projectSchemaObjectForAiStructuredOutput(schema, "#");
@@ -321,10 +461,14 @@ export function projectJsonSchemaDocument(schema, options) {
  */
 export function manifestToOpenApi(doc, info = {}) {
     const schemaName = doc.sourceType ?? "TypiaDocument";
+    const projectedSchema = projectJsonSchemaDocument(manifestToJsonSchema(doc), {
+        profile: "rest",
+    });
+    delete projectedSchema.$schema;
     return {
         components: {
             schemas: {
-                [schemaName]: manifestToJsonSchema(doc),
+                [schemaName]: projectedSchema,
             },
         },
         info: {
@@ -486,7 +630,36 @@ function buildQueryParameters(contract) {
         schema: manifestAttributeToJsonSchema(attribute),
     }));
 }
-function createSuccessResponse(schemaName) {
+function createBootstrapResponseHeaders(normalizedAuth) {
+    const headers = {
+        "Cache-Control": {
+            description: "Must be non-cacheable for fresh bootstrap write/session state.",
+            schema: {
+                type: "string",
+                example: "private, no-store, no-cache, must-revalidate",
+            },
+        },
+        Pragma: {
+            description: "Legacy non-cacheable bootstrap response directive.",
+            schema: {
+                type: "string",
+                example: "no-cache",
+            },
+        },
+    };
+    if (normalizedAuth.wordpressAuth?.mechanism ===
+        WP_TYPIA_OPENAPI_LITERALS.WORDPRESS_REST_NONCE_MECHANISM) {
+        headers.Vary = {
+            description: "Viewer-aware bootstrap responses should vary on cookie-backed auth state.",
+            schema: {
+                type: "string",
+                example: "Cookie",
+            },
+        };
+    }
+    return headers;
+}
+function createSuccessResponse(schemaName, headers) {
     return {
         content: {
             [WP_TYPIA_OPENAPI_LITERALS.JSON_CONTENT_TYPE]: {
@@ -494,14 +667,18 @@ function createSuccessResponse(schemaName) {
             },
         },
         description: WP_TYPIA_OPENAPI_LITERALS.SUCCESS_RESPONSE_DESCRIPTION,
+        ...(headers ? { headers } : {}),
     };
 }
 function buildEndpointOpenApiOperation(endpoint, contracts) {
     const normalizedAuth = normalizeEndpointAuthDefinition(endpoint);
+    const isBootstrapEndpoint = endpoint.path.endsWith("/bootstrap");
     const operation = {
         operationId: endpoint.operationId,
         responses: {
-            "200": createSuccessResponse(getContractSchemaName(endpoint.responseContract, contracts[endpoint.responseContract], endpoint, "response")),
+            "200": createSuccessResponse(getContractSchemaName(endpoint.responseContract, contracts[endpoint.responseContract], endpoint, "response"), isBootstrapEndpoint
+                ? createBootstrapResponseHeaders(normalizedAuth)
+                : undefined),
         },
         tags: [...endpoint.tags],
         [WP_TYPIA_OPENAPI_EXTENSION_KEYS.AUTH_INTENT]: normalizedAuth.auth,
@@ -554,10 +731,13 @@ function buildEndpointOpenApiOperation(endpoint, contracts) {
  */
 export function buildEndpointOpenApiDocument(options) {
     const contractEntries = Object.entries(options.contracts);
-    const schemas = Object.fromEntries(contractEntries.map(([contractKey, contract]) => [
-        getContractSchemaName(contractKey, contract),
-        manifestToJsonSchema(contract.document),
-    ]));
+    const schemas = Object.fromEntries(contractEntries.map(([contractKey, contract]) => {
+        const projectedSchema = projectJsonSchemaDocument(manifestToJsonSchema(contract.document), {
+            profile: "rest",
+        });
+        delete projectedSchema.$schema;
+        return [getContractSchemaName(contractKey, contract), projectedSchema];
+    }));
     const paths = {};
     const topLevelTags = [...new Set(options.endpoints.flatMap((endpoint) => endpoint.tags))]
         .filter((tag) => typeof tag === "string" && tag.length > 0)

package/dist/validation.d.ts

@@ -1,15 +1,7 @@
 import type { ManifestDefaultsDocument } from "./defaults.js";
-export interface TypiaValidationError {
-    description?: string;
-    expected: string;
-    path: string;
-    value: unknown;
-}
-export interface ValidationResult<T> {
-    data?: T;
-    errors: TypiaValidationError[];
-    isValid: boolean;
-}
+import { type ValidationError as SharedValidationError, type ValidationResult as SharedValidationResult } from "@wp-typia/api-client/runtime-primitives";
+export type TypiaValidationError = SharedValidationError;
+export type ValidationResult<T> = SharedValidationResult<T>;
 export interface ValidationState<T> extends ValidationResult<T> {
     errorMessages: string[];
 }

package/dist/validation.js

@@ -1,5 +1,5 @@
 import { applyTemplateDefaultsFromManifest } from "./defaults.js";
-import { isPlainObject as isRecord } from "./object-utils.js";
+import { isPlainObject as isRecord, normalizeValidationError as normalizeSharedValidationError, toValidationResult as toSharedValidationResult, } from "@wp-typia/api-client/runtime-primitives";
 const UNSAFE_PATH_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);
 function getValueType(value) {
     if (value === null) {
@@ -18,33 +18,10 @@ function redactValidationErrors(errors) {
     }));
 }
 export function normalizeValidationError(error) {
-    const raw = error !== null && typeof error === "object"
-        ? error
-        : {};
-    return {
-        description: typeof raw.description === "string" ? raw.description : undefined,
-        expected: typeof raw.expected === "string" ? raw.expected : "unknown",
-        path: typeof raw.path === "string" && raw.path.length > 0 ? raw.path : "(root)",
-        value: Object.prototype.hasOwnProperty.call(raw, "value") ? raw.value : undefined,
-    };
+    return normalizeSharedValidationError(error);
 }
 export function toValidationResult(result) {
-    const raw = result !== null && typeof result === "object"
-        ? result
-        : undefined;
-    if (raw?.success === true) {
-        return {
-            data: raw.data,
-            errors: [],
-            isValid: true,
-        };
-    }
-    const rawErrors = Array.isArray(raw?.errors) ? raw.errors : [];
-    return {
-        data: undefined,
-        errors: rawErrors.map(normalizeValidationError),
-        isValid: false,
-    };
+    return toSharedValidationResult(result);
 }
 export function formatValidationError(error) {
     return `${error.path}: ${error.expected} expected, got ${getValueType(error.value)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/block-runtime",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "description": "Generated-project runtime and metadata sync helpers for wp-typia",
   "type": "module",
   "main": "dist/index.js",
@@ -21,6 +21,31 @@
       "import": "./dist/metadata-core.js",
       "default": "./dist/metadata-core.js"
     },
+    "./metadata-analysis": {
+      "types": "./dist/metadata-analysis.d.ts",
+      "import": "./dist/metadata-analysis.js",
+      "default": "./dist/metadata-analysis.js"
+    },
+    "./metadata-model": {
+      "types": "./dist/metadata-model.d.ts",
+      "import": "./dist/metadata-model.js",
+      "default": "./dist/metadata-model.js"
+    },
+    "./metadata-parser": {
+      "types": "./dist/metadata-parser.d.ts",
+      "import": "./dist/metadata-parser.js",
+      "default": "./dist/metadata-parser.js"
+    },
+    "./metadata-php-render": {
+      "types": "./dist/metadata-php-render.d.ts",
+      "import": "./dist/metadata-php-render.js",
+      "default": "./dist/metadata-php-render.js"
+    },
+    "./metadata-projection": {
+      "types": "./dist/metadata-projection.d.ts",
+      "import": "./dist/metadata-projection.js",
+      "default": "./dist/metadata-projection.js"
+    },
     "./defaults": {
       "types": "./dist/defaults.d.ts",
       "import": "./dist/defaults.js",
@@ -46,6 +71,11 @@
       "import": "./dist/validation.js",
       "default": "./dist/validation.js"
     },
+    "./json-utils": {
+      "types": "./dist/json-utils.d.ts",
+      "import": "./dist/json-utils.js",
+      "default": "./dist/json-utils.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -54,7 +84,7 @@
     "package.json"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build": "bun run --filter @wp-typia/api-client build && rm -rf dist && tsc -p tsconfig.build.json",
     "clean": "rm -rf dist",
     "test:prepare": "bun run build",
     "test": "bun run test:prepare && bun test tests",
@@ -78,7 +108,7 @@
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=10.0.0",
-    "bun": ">=1.3.10"
+    "bun": ">=1.3.11"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"
@@ -89,6 +119,7 @@
     }
   },
   "dependencies": {
+    "@wp-typia/api-client": "^0.4.2",
     "typescript": "^5.9.2"
   },
   "devDependencies": {