@wp-typia/project-tools 0.15.0 → 0.15.2

package/dist/runtime/cli-add.js

@@ -2,8 +2,9 @@ import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { defineEndpointManifest, syncBlockMetadata, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
+import { syncBlockMetadata, } from "@wp-typia/block-runtime/metadata-core";
 import { ensureMigrationDirectories, parseMigrationConfig, writeInitialMigrationScaffold, writeMigrationConfig, } from "./migration-project.js";
+import { syncPersistenceRestArtifacts, } from "./persistence-rest-artifacts.js";
 import { snapshotProjectVersion } from "./migrations.js";
 import { getDefaultAnswers, scaffoldProject } from "./scaffold.js";
 import { SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
@@ -84,15 +85,21 @@ function buildPersistenceBlockConfigEntry(variables) {
         `\t\tattributeTypeName: ${quoteTsString(`${variables.pascalCase}Attributes`)},`,
         "\t\trestManifest: defineEndpointManifest( {",
         "\t\t\tcontracts: {",
+        "\t\t\t\t'bootstrap-query': {",
+        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}BootstrapQuery`)},`,
+        "\t\t\t\t},",
+        "\t\t\t\t'bootstrap-response': {",
+        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}BootstrapResponse`)},`,
+        "\t\t\t\t},",
         "\t\t\t\t'state-query': {",
         `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}StateQuery`)},`,
         "\t\t\t\t},",
-        "\t\t\t\t'write-state-request': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}WriteStateRequest`)},`,
-        "\t\t\t\t},",
         "\t\t\t\t'state-response': {",
         `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}StateResponse`)},`,
         "\t\t\t\t},",
+        "\t\t\t\t'write-state-request': {",
+        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}WriteStateRequest`)},`,
+        "\t\t\t\t},",
         "\t\t\t},",
         "\t\t\tendpoints: [",
         "\t\t\t\t{",
@@ -118,6 +125,16 @@ function buildPersistenceBlockConfigEntry(variables) {
         `\t\t\t\t\t\tmechanism: ${quoteTsString(variables.restWriteAuthMechanism)},`,
         "\t\t\t\t\t},",
         "\t\t\t\t},",
+        "\t\t\t\t{",
+        "\t\t\t\t\tauth: 'public',",
+        "\t\t\t\t\tmethod: 'GET',",
+        `\t\t\t\t\toperationId: ${quoteTsString(`get${variables.pascalCase}Bootstrap`)},`,
+        `\t\t\t\t\tpath: ${quoteTsString(`/${variables.namespace}/v1/${variables.slugKebabCase}/bootstrap`)},`,
+        "\t\t\t\t\tqueryContract: 'bootstrap-query',",
+        "\t\t\t\t\tresponseContract: 'bootstrap-response',",
+        `\t\t\t\t\tsummary: 'Read fresh session bootstrap state for the current viewer.',`,
+        `\t\t\t\t\ttags: [ ${quoteTsString(variables.title)} ],`,
+        "\t\t\t\t},",
         "\t\t\t],",
         "\t\t\tinfo: {",
         `\t\t\t\ttitle: ${quoteTsString(`${variables.title} REST API`)},`,
@@ -130,50 +147,6 @@ function buildPersistenceBlockConfigEntry(variables) {
         "\t},",
     ].join("\n");
 }
-function buildPersistenceEndpointManifest(variables) {
-    return defineEndpointManifest({
-        contracts: {
-            "state-query": {
-                sourceTypeName: `${variables.pascalCase}StateQuery`,
-            },
-            "write-state-request": {
-                sourceTypeName: `${variables.pascalCase}WriteStateRequest`,
-            },
-            "state-response": {
-                sourceTypeName: `${variables.pascalCase}StateResponse`,
-            },
-        },
-        endpoints: [
-            {
-                auth: "public",
-                method: "GET",
-                operationId: `get${variables.pascalCase}State`,
-                path: `/${variables.namespace}/v1/${variables.slugKebabCase}/state`,
-                queryContract: "state-query",
-                responseContract: "state-response",
-                summary: "Read the current persisted state.",
-                tags: [variables.title],
-            },
-            {
-                auth: variables.restWriteAuthIntent,
-                bodyContract: "write-state-request",
-                method: "POST",
-                operationId: `write${variables.pascalCase}State`,
-                path: `/${variables.namespace}/v1/${variables.slugKebabCase}/state`,
-                responseContract: "state-response",
-                summary: "Write the current persisted state.",
-                tags: [variables.title],
-                wordpressAuth: {
-                    mechanism: variables.restWriteAuthMechanism,
-                },
-            },
-        ],
-        info: {
-            title: `${variables.title} REST API`,
-            version: "1.0.0",
-        },
-    });
-}
 function buildCompoundChildConfigEntry(variables) {
     return [
         "\t{",
@@ -732,28 +705,11 @@ async function syncWorkspaceBlockMetadata(projectDir, slug, sourceTypeName, type
     });
 }
 async function syncWorkspacePersistenceArtifacts(projectDir, variables) {
-    const manifest = buildPersistenceEndpointManifest(variables);
-    const apiTypesFile = path.join("src", "blocks", variables.slugKebabCase, "api-types.ts");
-    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
-        await syncTypeSchemas({
-            jsonSchemaFile: path.join("src", "blocks", variables.slugKebabCase, "api-schemas", `${baseName}.schema.json`),
-            openApiFile: path.join("src", "blocks", variables.slugKebabCase, "api-schemas", `${baseName}.openapi.json`),
-            projectRoot: projectDir,
-            sourceTypeName: contract.sourceTypeName,
-            typesFile: apiTypesFile,
-        });
-    }
-    await syncRestOpenApi({
-        manifest,
-        openApiFile: path.join("src", "blocks", variables.slugKebabCase, "api.openapi.json"),
-        projectRoot: projectDir,
-        typesFile: apiTypesFile,
-    });
-    await syncEndpointClient({
-        clientFile: path.join("src", "blocks", variables.slugKebabCase, "api-client.ts"),
-        manifest,
-        projectRoot: projectDir,
-        typesFile: apiTypesFile,
+    await syncPersistenceRestArtifacts({
+        apiTypesFile: path.join("src", "blocks", variables.slugKebabCase, "api-types.ts"),
+        outputDir: path.join("src", "blocks", variables.slugKebabCase),
+        projectDir,
+        variables,
     });
 }
 async function syncWorkspaceAddedBlockArtifacts(projectDir, templateId, variables) {

package/dist/runtime/cli-doctor.js

@@ -5,7 +5,7 @@ import { execFileSync } from "node:child_process";
 import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
 import { getBuiltInTemplateLayerDirs } from "./template-builtins.js";
 import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_SET, } from "./hooked-blocks.js";
-import { listTemplates } from "./template-registry.js";
+import { isBuiltInTemplateId, listTemplates } from "./template-registry.js";
 import { readWorkspaceInventory } from "./workspace-inventory.js";
 import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, WORKSPACE_TEMPLATE_PACKAGE, tryResolveWorkspaceProject, } from "./workspace-project.js";
 const WORKSPACE_COLLECTION_IMPORT_LINE = "import '../../collection';";
@@ -285,24 +285,40 @@ export async function getDoctorChecks(cwd) {
         detail: tempWritable ? "Writable" : "Not writable",
     });
     for (const template of listTemplates()) {
-        const layerDirs = template.id === "persistence"
+        if (!isBuiltInTemplateId(template.id)) {
+            const templateDirExists = fs.existsSync(template.templateDir);
+            const hasAssets = templateDirExists &&
+                fs.existsSync(path.join(template.templateDir, "package.json.mustache"));
+            checks.push({
+                status: !templateDirExists || hasAssets ? "pass" : "fail",
+                label: `Template ${template.id}`,
+                detail: !templateDirExists
+                    ? "External template metadata only; local overlay package is not installed."
+                    : hasAssets
+                        ? template.templateDir
+                        : "Missing core template assets",
+            });
+            continue;
+        }
+        const builtInTemplateId = template.id;
+        const layerDirs = builtInTemplateId === "persistence"
             ? Array.from(new Set([
-                ...getBuiltInTemplateLayerDirs(template.id, { persistencePolicy: "authenticated" }),
-                ...getBuiltInTemplateLayerDirs(template.id, { persistencePolicy: "public" }),
+                ...getBuiltInTemplateLayerDirs(builtInTemplateId, { persistencePolicy: "authenticated" }),
+                ...getBuiltInTemplateLayerDirs(builtInTemplateId, { persistencePolicy: "public" }),
             ]))
-            : template.id === "compound"
+            : builtInTemplateId === "compound"
                 ? Array.from(new Set([
-                    ...getBuiltInTemplateLayerDirs(template.id),
-                    ...getBuiltInTemplateLayerDirs(template.id, {
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId),
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId, {
                         persistenceEnabled: true,
                         persistencePolicy: "authenticated",
                     }),
-                    ...getBuiltInTemplateLayerDirs(template.id, {
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId, {
                         persistenceEnabled: true,
                         persistencePolicy: "public",
                     }),
                 ]))
-                : getBuiltInTemplateLayerDirs(template.id);
+                : getBuiltInTemplateLayerDirs(builtInTemplateId);
         const hasAssets = layerDirs.every((layerDir) => fs.existsSync(layerDir)) &&
             layerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "package.json.mustache"))) &&
             layerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "src")));

package/dist/runtime/cli-help.js

@@ -34,6 +34,7 @@ Package managers: ${PACKAGE_MANAGER_IDS.join(", ")}
 Notes:
   \`wp-typia create\` is the canonical scaffold command.
   \`wp-typia <project-dir>\` remains a backward-compatible alias to \`create\`.
+  Use \`--template @wp-typia/create-workspace-template\` for the official empty workspace scaffold behind \`wp-typia add ...\`.
   \`add variation\` uses an existing workspace block from \`scripts/block-config.ts\`.
   \`add pattern\` scaffolds a namespaced PHP pattern shell under \`src/patterns/\`.
   \`add binding-source\` scaffolds shared PHP and editor registration under \`src/bindings/\`.

package/dist/runtime/cli-templates.js

@@ -30,6 +30,16 @@ export function formatTemplateFeatures(template) {
  * @returns Multi-line template details text for CLI output.
  */
 export function formatTemplateDetails(template) {
+    if (!isBuiltInTemplateId(template.id)) {
+        return [
+            template.id,
+            template.description,
+            `Category: ${template.defaultCategory}`,
+            `Overlay path: ${template.templateDir}`,
+            "Layers: workspace package scaffold",
+            `Features: ${template.features.join(", ")}`,
+        ].join("\n");
+    }
     const layers = template.id === "persistence"
         ? [
             `authenticated: ${getBuiltInTemplateLayerDirs(template.id, { persistencePolicy: "authenticated" }).join(" -> ")}`,

package/dist/runtime/json-utils.d.ts

@@ -1,10 +1,7 @@
 /**
- * Create a deep clone of a JSON-serializable value.
- *
- * @param value JSON-compatible data to clone.
- * @returns A deep-cloned copy created with `JSON.parse(JSON.stringify(...))`.
- *
- * Values that are not JSON-serializable, such as functions, `undefined`,
- * `BigInt`, class instances, and `Date` objects, are not preserved faithfully.
+ * Re-exports JSON cloning helpers from `@wp-typia/block-runtime`.
+ * This adapter keeps the existing project-tools module path stable while the
+ * runtime implementation now lives in block-runtime.
+ * @module
  */
-export declare function cloneJsonValue<T>(value: T): T;
+export * from "@wp-typia/block-runtime/json-utils";

package/dist/runtime/json-utils.js

@@ -1,12 +1,7 @@
 /**
- * Create a deep clone of a JSON-serializable value.
- *
- * @param value JSON-compatible data to clone.
- * @returns A deep-cloned copy created with `JSON.parse(JSON.stringify(...))`.
- *
- * Values that are not JSON-serializable, such as functions, `undefined`,
- * `BigInt`, class instances, and `Date` objects, are not preserved faithfully.
+ * Re-exports JSON cloning helpers from `@wp-typia/block-runtime`.
+ * This adapter keeps the existing project-tools module path stable while the
+ * runtime implementation now lives in block-runtime.
+ * @module
  */
-export function cloneJsonValue(value) {
-    return JSON.parse(JSON.stringify(value));
-}
+export * from "@wp-typia/block-runtime/json-utils";

package/dist/runtime/metadata-analysis.d.ts

@@ -1,11 +1,7 @@
-import ts from "typescript";
-export interface AnalysisContext {
-    allowedExternalPackages: Set<string>;
-    checker: ts.TypeChecker;
-    packageNameCache: Map<string, string | null>;
-    projectRoot: string;
-    program: ts.Program;
-    recursionGuard: Set<string>;
-}
-export declare function getTaggedSyncBlockMetadataFailureCode(error: Error): "typescript-diagnostic" | undefined;
-export declare function createAnalysisContext(projectRoot: string, typesFilePath: string): AnalysisContext;
+/**
+ * Re-exports metadata analysis helpers from `@wp-typia/block-runtime`.
+ * This adapter preserves the public project-tools module path while sharing
+ * the runtime implementation with block-runtime.
+ * @module
+ */
+export * from "@wp-typia/block-runtime/metadata-analysis";

package/dist/runtime/metadata-analysis.js

@@ -1,285 +1,7 @@
-import { createHash } from "node:crypto";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-class LruCache {
-    constructor(maxEntries) {
-        this.maxEntries = maxEntries;
-        this.entries = new Map();
-    }
-    get(key) {
-        const value = this.entries.get(key);
-        if (value === undefined) {
-            return undefined;
-        }
-        this.entries.delete(key);
-        this.entries.set(key, value);
-        return value;
-    }
-    set(key, value) {
-        if (this.entries.has(key)) {
-            this.entries.delete(key);
-        }
-        this.entries.set(key, value);
-        if (this.entries.size <= this.maxEntries) {
-            return;
-        }
-        const oldestKey = this.entries.keys().next().value;
-        if (oldestKey !== undefined) {
-            this.entries.delete(oldestKey);
-        }
-    }
-}
-const DEFAULT_ALLOWED_EXTERNAL_PACKAGES = ["@wp-typia/block-types"];
-const ANALYSIS_PROGRAM_CACHE_MAX_ENTRIES = 20;
-const TYPESCRIPT_LIB_DIRECTORY = path.dirname(ts.getDefaultLibFilePath({}));
-const RUNTIME_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
-const SYNC_BLOCK_METADATA_FAILURE_CODE = Symbol("sync-block-metadata-failure-code");
-const analysisProgramCache = new LruCache(ANALYSIS_PROGRAM_CACHE_MAX_ENTRIES);
-function tagMetadataDiagnosticError(error) {
-    error[SYNC_BLOCK_METADATA_FAILURE_CODE] = "typescript-diagnostic";
-    return error;
-}
-export function getTaggedSyncBlockMetadataFailureCode(error) {
-    return error[SYNC_BLOCK_METADATA_FAILURE_CODE];
-}
-function isProjectLocalSourceFile(filePath, projectRoot) {
-    if (filePath.startsWith(TYPESCRIPT_LIB_DIRECTORY)) {
-        return false;
-    }
-    if (filePath.includes(`${path.sep}node_modules${path.sep}`)) {
-        return false;
-    }
-    return !path.relative(projectRoot, filePath).startsWith("..");
-}
-function collectSourceFileModuleSpecifiers(sourceFile) {
-    const moduleSpecifiers = [];
-    for (const statement of sourceFile.statements) {
-        if ((ts.isImportDeclaration(statement) ||
-            ts.isExportDeclaration(statement)) &&
-            statement.moduleSpecifier &&
-            ts.isStringLiteralLike(statement.moduleSpecifier)) {
-            moduleSpecifiers.push(statement.moduleSpecifier.text);
-        }
-    }
-    ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportTypeNode(node) &&
-            ts.isLiteralTypeNode(node.argument) &&
-            ts.isStringLiteral(node.argument.literal)) {
-            moduleSpecifiers.push(node.argument.literal.text);
-        }
-    });
-    return moduleSpecifiers;
-}
-function collectReferencedLocalSourceFiles(program, entryFilePath, compilerOptions, projectRoot) {
-    const visited = new Set();
-    const queue = [entryFilePath];
-    while (queue.length > 0) {
-        const filePath = queue.pop();
-        if (filePath === undefined ||
-            visited.has(filePath) ||
-            !isProjectLocalSourceFile(filePath, projectRoot)) {
-            continue;
-        }
-        visited.add(filePath);
-        const sourceFile = program.getSourceFile(filePath);
-        if (sourceFile === undefined) {
-            continue;
-        }
-        for (const moduleSpecifier of collectSourceFileModuleSpecifiers(sourceFile)) {
-            const resolved = ts.resolveModuleName(moduleSpecifier, filePath, compilerOptions, ts.sys).resolvedModule;
-            const resolvedFileName = resolved?.resolvedFileName;
-            if (resolvedFileName &&
-                isProjectLocalSourceFile(resolvedFileName, projectRoot)) {
-                queue.push(resolvedFileName);
-            }
-        }
-    }
-    return visited;
-}
-function stableSerializeAnalysisValue(value) {
-    if (value === undefined) {
-        return '"__undefined__"';
-    }
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((entry) => stableSerializeAnalysisValue(entry)).join(",")}]`;
-    }
-    return `{${Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, entry]) => `${JSON.stringify(key)}:${stableSerializeAnalysisValue(entry)}`)
-        .join(",")}}`;
-}
-function buildAnalysisProgramStructureKey(projectRoot, typesFilePath, { compilerOptions, configPath, rootNames, typiaTagsAugmentationPath, }) {
-    return stableSerializeAnalysisValue({
-        compilerOptions,
-        configPath,
-        projectRoot,
-        rootNames: [...rootNames].sort(),
-        typiaTagsAugmentationPath,
-        typesFilePath,
-    });
-}
-function createAnalysisProgramContentFingerprint(filePaths, onMissingFile = "throw") {
-    const hash = createHash("sha1");
-    const fingerprintPaths = [...new Set(filePaths)].sort();
-    for (const filePath of fingerprintPaths) {
-        const fileContents = ts.sys.readFile(filePath);
-        if (fileContents === undefined) {
-            if (onMissingFile === "return-null") {
-                return null;
-            }
-            if (onMissingFile === "hash-missing") {
-                hash.update(filePath);
-                hash.update("\0");
-                hash.update("__missing__");
-                hash.update("\0");
-                continue;
-            }
-            throw new Error(`Unable to read metadata analysis dependency: ${filePath}`);
-        }
-        hash.update(filePath);
-        hash.update("\0");
-        hash.update(fileContents);
-        hash.update("\0");
-    }
-    return hash.digest("hex");
-}
-function getAnalysisProgramDependencyPaths(program, configPath) {
-    const sourceFilePaths = program
-        .getSourceFiles()
-        .map((sourceFile) => sourceFile.fileName)
-        .filter((filePath) => !filePath.startsWith(TYPESCRIPT_LIB_DIRECTORY));
-    const dependencyPaths = new Set(sourceFilePaths);
-    for (const filePath of sourceFilePaths) {
-        let currentDir = path.dirname(filePath);
-        while (true) {
-            dependencyPaths.add(path.join(currentDir, "package.json"));
-            const parentDir = path.dirname(currentDir);
-            if (parentDir === currentDir) {
-                break;
-            }
-            currentDir = parentDir;
-        }
-    }
-    if (configPath) {
-        dependencyPaths.add(configPath);
-    }
-    return [...dependencyPaths].sort();
-}
-function resolveAnalysisProgramInputs(projectRoot, typesFilePath) {
-    const configPath = ts.findConfigFile(projectRoot, ts.sys.fileExists, "tsconfig.json");
-    const compilerOptions = {
-        allowJs: false,
-        esModuleInterop: true,
-        module: ts.ModuleKind.NodeNext,
-        moduleResolution: ts.ModuleResolutionKind.NodeNext,
-        resolveJsonModule: true,
-        skipLibCheck: true,
-        target: ts.ScriptTarget.ES2022,
-    };
-    let rootNames = [typesFilePath];
-    const typiaTagsAugmentationPath = resolveTypiaTagsAugmentationPath();
-    if (configPath !== undefined) {
-        const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-        if (configFile.error) {
-            throw formatDiagnosticError(configFile.error);
-        }
-        const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath), compilerOptions, configPath);
-        if (parsed.errors.length > 0) {
-            throw formatDiagnosticError(parsed.errors[0]);
-        }
-        rootNames = parsed.fileNames.includes(typesFilePath)
-            ? parsed.fileNames
-            : [...parsed.fileNames, typesFilePath];
-        if (typiaTagsAugmentationPath &&
-            !rootNames.includes(typiaTagsAugmentationPath)) {
-            rootNames = [...rootNames, typiaTagsAugmentationPath];
-        }
-        Object.assign(compilerOptions, parsed.options);
-    }
-    else if (typiaTagsAugmentationPath) {
-        rootNames = [...rootNames, typiaTagsAugmentationPath];
-    }
-    const structureKey = buildAnalysisProgramStructureKey(projectRoot, typesFilePath, {
-        compilerOptions,
-        configPath: configPath ?? null,
-        rootNames,
-        typiaTagsAugmentationPath,
-    });
-    return {
-        compilerOptions,
-        configPath: configPath ?? null,
-        rootNames,
-        structureKey,
-        typiaTagsAugmentationPath,
-    };
-}
-export function createAnalysisContext(projectRoot, typesFilePath) {
-    const analysisInputs = resolveAnalysisProgramInputs(projectRoot, typesFilePath);
-    const cachedAnalysis = analysisProgramCache.get(analysisInputs.structureKey);
-    if (cachedAnalysis) {
-        const currentDependencyFingerprint = createAnalysisProgramContentFingerprint(cachedAnalysis.dependencyPaths, "hash-missing");
-        if (currentDependencyFingerprint !== null &&
-            currentDependencyFingerprint === cachedAnalysis.dependencyFingerprint) {
-            return {
-                allowedExternalPackages: new Set(DEFAULT_ALLOWED_EXTERNAL_PACKAGES),
-                checker: cachedAnalysis.checker,
-                packageNameCache: new Map(),
-                projectRoot,
-                program: cachedAnalysis.program,
-                recursionGuard: new Set(),
-            };
-        }
-    }
-    const program = ts.createProgram({
-        oldProgram: cachedAnalysis?.program,
-        options: analysisInputs.compilerOptions,
-        rootNames: analysisInputs.rootNames,
-    });
-    const diagnostics = ts.getPreEmitDiagnostics(program);
-    const localSourceFiles = collectReferencedLocalSourceFiles(program, typesFilePath, analysisInputs.compilerOptions, projectRoot);
-    const blockingDiagnostic = diagnostics.find((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error &&
-        diagnostic.file !== undefined &&
-        localSourceFiles.has(diagnostic.file.fileName));
-    if (blockingDiagnostic) {
-        throw formatDiagnosticError(blockingDiagnostic);
-    }
-    const checker = program.getTypeChecker();
-    const dependencyPaths = getAnalysisProgramDependencyPaths(program, analysisInputs.configPath);
-    const dependencyFingerprint = createAnalysisProgramContentFingerprint(dependencyPaths, "hash-missing");
-    if (dependencyFingerprint === null) {
-        throw new Error("Unable to fingerprint metadata analysis dependencies.");
-    }
-    analysisProgramCache.set(analysisInputs.structureKey, {
-        checker,
-        dependencyFingerprint,
-        dependencyPaths,
-        program,
-    });
-    return {
-        allowedExternalPackages: new Set(DEFAULT_ALLOWED_EXTERNAL_PACKAGES),
-        checker,
-        packageNameCache: new Map(),
-        projectRoot,
-        program,
-        recursionGuard: new Set(),
-    };
-}
-function resolveTypiaTagsAugmentationPath() {
-    const candidates = [
-        path.join(RUNTIME_DIRECTORY, "typia-tags.d.ts"),
-        path.join(RUNTIME_DIRECTORY, "typia-tags.ts"),
-    ];
-    for (const candidate of candidates) {
-        if (ts.sys.fileExists(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function formatDiagnosticError(diagnostic) {
-    return tagMetadataDiagnosticError(new Error(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")));
-}
+/**
+ * Re-exports metadata analysis helpers from `@wp-typia/block-runtime`.
+ * This adapter preserves the public project-tools module path while sharing
+ * the runtime implementation with block-runtime.
+ * @module
+ */
+export * from "@wp-typia/block-runtime/metadata-analysis";

package/dist/runtime/metadata-model.d.ts

@@ -1,84 +1,7 @@
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-export type AttributeKind = "string" | "number" | "boolean" | "array" | "object" | "union";
-export type WordPressAttributeKind = "string" | "number" | "boolean" | "array" | "object";
-export type WordPressAttributeSource = "html" | "text" | "rich-text";
-export interface AttributeConstraints {
-    exclusiveMaximum: number | null;
-    exclusiveMinimum: number | null;
-    format: string | null;
-    maxLength: number | null;
-    maxItems: number | null;
-    maximum: number | null;
-    minLength: number | null;
-    minItems: number | null;
-    minimum: number | null;
-    multipleOf: number | null;
-    pattern: string | null;
-    typeTag: string | null;
-}
-export interface AttributeNode {
-    constraints: AttributeConstraints;
-    defaultValue?: JsonValue;
-    enumValues: Array<string | number | boolean> | null;
-    items?: AttributeNode;
-    kind: AttributeKind;
-    path: string;
-    properties?: Record<string, AttributeNode>;
-    required: boolean;
-    union?: AttributeUnion | null;
-    wp: {
-        selector: string | null;
-        source: WordPressAttributeSource | null;
-    };
-}
-export interface AttributeUnion {
-    branches: Record<string, AttributeNode>;
-    discriminator: string;
-}
-export interface BlockJsonAttribute {
-    default?: JsonValue;
-    enum?: Array<string | number | boolean>;
-    selector?: string;
-    source?: WordPressAttributeSource;
-    type: WordPressAttributeKind;
-}
-export interface ManifestAttribute {
-    typia: {
-        constraints: AttributeConstraints;
-        defaultValue: JsonValue | null;
-        hasDefault: boolean;
-    };
-    ts: {
-        items: ManifestAttribute | null;
-        kind: AttributeKind;
-        properties: Record<string, ManifestAttribute> | null;
-        required: boolean;
-        union: ManifestUnion | null;
-    };
-    wp: {
-        defaultValue: JsonValue | null;
-        enum: Array<string | number | boolean> | null;
-        hasDefault: boolean;
-        selector?: string | null;
-        source?: WordPressAttributeSource | null;
-        type: WordPressAttributeKind;
-    };
-}
-export interface ManifestUnion {
-    branches: Record<string, ManifestAttribute>;
-    discriminator: string;
-}
-export interface ManifestDocument {
-    attributes: Record<string, ManifestAttribute>;
-    manifestVersion: 2;
-    sourceType: string;
-}
-export declare function defaultAttributeConstraints(): AttributeConstraints;
-export declare function getWordPressKind(node: AttributeNode): WordPressAttributeKind;
-export declare function baseNode(kind: AttributeKind, pathLabel: string): AttributeNode;
-export declare function withRequired(node: AttributeNode, required: boolean): AttributeNode;
-export declare function cloneUnion(union: AttributeUnion): AttributeUnion;
-export declare function cloneProperties(properties: Record<string, AttributeNode>): Record<string, AttributeNode>;
+/**
+ * Re-exports the metadata model types and helpers from `@wp-typia/block-runtime`.
+ * This adapter keeps the public project-tools runtime path stable while the
+ * implementation is consolidated in block-runtime.
+ * @module
+ */
+export * from "@wp-typia/block-runtime/metadata-model";