@wp-typia/project-tools 0.22.10 → 0.23.0

package/dist/runtime/rest-resource-artifacts.js

@@ -1,5 +1,18 @@
 import path from "node:path";
 import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
+function resolveManualRestContractWordPressAuth(auth) {
+    if (auth === "authenticated") {
+        return {
+            mechanism: "rest-nonce",
+        };
+    }
+    if (auth === "public-write-protected") {
+        return {
+            mechanism: "public-signed-token",
+        };
+    }
+    return undefined;
+}
 /**
  * Build the endpoint manifest for a workspace-level REST resource scaffold.
  *
@@ -9,7 +22,12 @@ import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSc
  */
 export function buildRestResourceEndpointManifest(variables, methods) {
     const basePath = `/${variables.namespace}/${variables.slugKebabCase}`;
-    const itemPath = `${basePath}/item`;
+    const routePattern = variables.routePattern == null
+        ? `/${variables.slugKebabCase}/item`
+        : variables.routePattern.startsWith("/")
+            ? variables.routePattern
+            : `/${variables.routePattern}`;
+    const itemPath = `/${variables.namespace}${routePattern}`;
     const contracts = {};
     const endpoints = [];
     if (methods.includes("list")) {
@@ -124,6 +142,52 @@ export function buildRestResourceEndpointManifest(variables, methods) {
         },
     });
 }
+/**
+ * Build the endpoint manifest for a type-only manual REST contract. Manual
+ * contracts describe routes owned by another integration without generating PHP
+ * route glue in the workspace.
+ *
+ * @param variables Template naming data used for contract names, route path,
+ * and OpenAPI info.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export function buildManualRestContractEndpointManifest(variables) {
+    const contracts = {
+        query: {
+            sourceTypeName: variables.queryTypeName,
+        },
+        response: {
+            sourceTypeName: variables.responseTypeName,
+        },
+    };
+    if (variables.bodyTypeName) {
+        contracts.request = {
+            sourceTypeName: variables.bodyTypeName,
+        };
+    }
+    const wordpressAuth = resolveManualRestContractWordPressAuth(variables.auth);
+    return defineEndpointManifest({
+        contracts,
+        endpoints: [
+            {
+                auth: variables.auth,
+                ...(variables.bodyTypeName ? { bodyContract: "request" } : {}),
+                method: variables.method,
+                operationId: `call${variables.pascalCase}ManualRestContract`,
+                path: `/${variables.namespace}${variables.pathPattern}`,
+                queryContract: "query",
+                responseContract: "response",
+                summary: `Call external ${variables.title} REST route.`,
+                tags: [variables.title],
+                ...(wordpressAuth ? { wordpressAuth } : {}),
+            },
+        ],
+        info: {
+            title: `${variables.title} Manual REST Contract`,
+            version: "1.0.0",
+        },
+    });
+}
 /**
  * Synchronize generated schemas, OpenAPI output, and endpoint client code for
  * a workspace-level REST resource scaffold.
@@ -156,3 +220,35 @@ export async function syncRestResourceArtifacts({ clientFile, methods, outputDir
         validatorsFile,
     });
 }
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for a
+ * type-only manual REST contract.
+ *
+ * @param options Contract file paths and naming variables.
+ * @returns A promise that resolves after every generated artifact has refreshed.
+ */
+export async function syncManualRestContractArtifacts({ clientFile, outputDir, projectDir, typesFile, validatorsFile, variables, }) {
+    const manifest = buildManualRestContractEndpointManifest(variables);
+    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
+        await syncTypeSchemas({
+            jsonSchemaFile: path.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+            openApiFile: path.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+            projectRoot: projectDir,
+            sourceTypeName: contract.sourceTypeName,
+            typesFile,
+        });
+    }
+    await syncRestOpenApi({
+        manifest,
+        openApiFile: path.join(outputDir, "api.openapi.json"),
+        projectRoot: projectDir,
+        typesFile,
+    });
+    await syncEndpointClient({
+        clientFile,
+        manifest,
+        projectRoot: projectDir,
+        typesFile,
+        validatorsFile,
+    });
+}

package/dist/runtime/template-render.d.ts

@@ -55,4 +55,4 @@ export declare function copyInterpolatedDirectory(sourceDir: string, targetDir:
  * preview root.
  */
 export declare function listInterpolatedDirectoryOutputs(sourceDir: string, view: Record<string, string>): Promise<string[]>;
-export declare function pathExists(targetPath: string): boolean;
+export declare function pathExistsSync(targetPath: string): boolean;

package/dist/runtime/template-render.js

@@ -191,6 +191,6 @@ export async function listInterpolatedDirectoryOutputs(sourceDir, view) {
     });
     return outputs.sort((left, right) => left.localeCompare(right));
 }
-export function pathExists(targetPath) {
+export function pathExistsSync(targetPath) {
     return fs.existsSync(targetPath);
 }

package/dist/runtime/template-source-cache-markers.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Marker file written after a cache entry is fully populated.
+ */
+export declare const CACHE_MARKER_FILE = "wp-typia-template-cache.json";
+/**
+ * Marker file written after a full TTL prune scan completes.
+ */
+export declare const CACHE_PRUNE_MARKER_FILE = "wp-typia-template-cache-prune.json";
+/**
+ * Serializable metadata recorded in cache markers for diagnostics.
+ */
+export type ExternalTemplateCacheMetadata = Record<string, string | null>;
+export interface ExternalTemplateCacheEntryMarker {
+    createdAtMs: number;
+    metadata: ExternalTemplateCacheMetadata;
+}
+export interface ExternalTemplateCachePruneMarker {
+    prunedAtMs: number;
+    pruneIntervalMs: number | null;
+    ttlMs: number;
+}
+export declare function sanitizeExternalTemplateCacheMetadata(metadata: ExternalTemplateCacheMetadata): ExternalTemplateCacheMetadata;
+export declare function parseExternalTemplateCacheEntryMarker(markerText: string): ExternalTemplateCacheEntryMarker | null;
+export declare function externalTemplateCacheMetadataMatches(actual: ExternalTemplateCacheMetadata, expected: ExternalTemplateCacheMetadata): boolean;
+export declare function isExternalTemplateCacheEntryFreshForTtl(createdAtMs: number, nowMs: number, ttlMs: number | null): boolean;
+export declare function parseExternalTemplateCachePruneMarker(markerText: string): ExternalTemplateCachePruneMarker | null;
+export declare function formatExternalTemplateCacheEntryMarker({ cacheKey, createdAt, metadata, namespace, }: {
+    cacheKey: string;
+    createdAt: Date;
+    metadata: ExternalTemplateCacheMetadata;
+    namespace: string;
+}): string;
+export declare function formatExternalTemplateCachePruneMarker({ nowMs, pruneIntervalMs, ttlMs, }: {
+    nowMs: number;
+    pruneIntervalMs: number | null;
+    ttlMs: number;
+}): string;

package/dist/runtime/template-source-cache-markers.js

@@ -0,0 +1,125 @@
+/**
+ * Marker file written after a cache entry is fully populated.
+ */
+export const CACHE_MARKER_FILE = 'wp-typia-template-cache.json';
+/**
+ * Marker file written after a full TTL prune scan completes.
+ */
+export const CACHE_PRUNE_MARKER_FILE = 'wp-typia-template-cache-prune.json';
+/**
+ * Marker value used when URL-like metadata cannot be safely normalized.
+ */
+const REDACTED_CACHE_METADATA_VALUE = '[redacted]';
+/**
+ * Metadata fields that may contain credentialed or signed URLs.
+ */
+const URL_LIKE_METADATA_KEY = /(url|uri|registry|tarball)/iu;
+function sanitizeExternalTemplateCacheMetadataValue(key, value) {
+    if (!URL_LIKE_METADATA_KEY.test(key)) {
+        return value;
+    }
+    try {
+        const url = new URL(value);
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString();
+    }
+    catch {
+        return REDACTED_CACHE_METADATA_VALUE;
+    }
+}
+export function sanitizeExternalTemplateCacheMetadata(metadata) {
+    return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [
+        key,
+        value === null
+            ? null
+            : sanitizeExternalTemplateCacheMetadataValue(key, value),
+    ]));
+}
+export function parseExternalTemplateCacheEntryMarker(markerText) {
+    let marker;
+    try {
+        marker = JSON.parse(markerText);
+    }
+    catch {
+        return null;
+    }
+    if (typeof marker !== 'object' || marker === null || Array.isArray(marker)) {
+        return null;
+    }
+    const rawMetadata = marker.metadata;
+    if (typeof rawMetadata !== 'object' ||
+        rawMetadata === null ||
+        Array.isArray(rawMetadata)) {
+        return null;
+    }
+    const metadata = {};
+    for (const [key, value] of Object.entries(rawMetadata)) {
+        if (typeof value !== 'string' && value !== null) {
+            return null;
+        }
+        metadata[key] = value;
+    }
+    const rawCreatedAt = marker.createdAt;
+    const createdAtMs = typeof rawCreatedAt === 'string' ? Date.parse(rawCreatedAt) : 0;
+    return {
+        createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : 0,
+        metadata,
+    };
+}
+export function externalTemplateCacheMetadataMatches(actual, expected) {
+    return Object.entries(expected).every(([key, value]) => actual[key] === value);
+}
+export function isExternalTemplateCacheEntryFreshForTtl(createdAtMs, nowMs, ttlMs) {
+    return ttlMs === null || createdAtMs >= nowMs - ttlMs;
+}
+export function parseExternalTemplateCachePruneMarker(markerText) {
+    let marker;
+    try {
+        marker = JSON.parse(markerText);
+    }
+    catch {
+        return null;
+    }
+    if (typeof marker !== 'object' || marker === null || Array.isArray(marker)) {
+        return null;
+    }
+    const rawPrunedAt = marker.prunedAt;
+    const prunedAtMs = typeof rawPrunedAt === 'string' ? Date.parse(rawPrunedAt) : Number.NaN;
+    const rawPruneIntervalMs = marker
+        .pruneIntervalMs;
+    const rawTtlMs = marker.ttlMs;
+    if (typeof rawTtlMs !== 'number' || !Number.isFinite(rawTtlMs)) {
+        return null;
+    }
+    if (!Number.isFinite(prunedAtMs)) {
+        return null;
+    }
+    if (rawPruneIntervalMs !== null &&
+        (typeof rawPruneIntervalMs !== 'number' ||
+            !Number.isFinite(rawPruneIntervalMs))) {
+        return null;
+    }
+    return {
+        prunedAtMs,
+        pruneIntervalMs: rawPruneIntervalMs ?? null,
+        ttlMs: rawTtlMs,
+    };
+}
+export function formatExternalTemplateCacheEntryMarker({ cacheKey, createdAt, metadata, namespace, }) {
+    return `${JSON.stringify({
+        createdAt: createdAt.toISOString(),
+        key: cacheKey,
+        metadata: sanitizeExternalTemplateCacheMetadata(metadata),
+        namespace,
+    }, null, 2)}\n`;
+}
+export function formatExternalTemplateCachePruneMarker({ nowMs, pruneIntervalMs, ttlMs, }) {
+    return `${JSON.stringify({
+        prunedAt: new Date(nowMs).toISOString(),
+        pruneIntervalMs,
+        ttlMs,
+    }, null, 2)}\n`;
+}

package/dist/runtime/template-source-cache.d.ts

@@ -1,8 +1,5 @@
+import { type ExternalTemplateCacheMetadata } from './template-source-cache-markers.js';
 export { EXTERNAL_TEMPLATE_CACHE_DIR_ENV, EXTERNAL_TEMPLATE_CACHE_ENV, EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV, EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, getExternalTemplateCacheRoot, isExternalTemplateCacheEnabled, } from './template-source-cache-policy.js';
-/**
- * Serializable metadata recorded in the cache marker for diagnostics.
- */
-type ExternalTemplateCacheMetadata = Record<string, string | null>;
 /**
  * Describes a deterministic external template cache entry.
  *

package/dist/runtime/template-source-cache.js

@@ -2,24 +2,13 @@ import { createHash, randomUUID } from 'node:crypto';
 import { promises as fsp } from 'node:fs';
 import path from 'node:path';
 import { getNodeErrorCode, pathExists } from './fs-async.js';
+import { CACHE_MARKER_FILE, CACHE_PRUNE_MARKER_FILE, externalTemplateCacheMetadataMatches, formatExternalTemplateCacheEntryMarker, formatExternalTemplateCachePruneMarker, isExternalTemplateCacheEntryFreshForTtl, parseExternalTemplateCacheEntryMarker, parseExternalTemplateCachePruneMarker, } from './template-source-cache-markers.js';
 import { getExternalTemplateCacheNowMs, getExternalTemplateCacheRoot, isExternalTemplateCacheEnabled, resolveExternalTemplateCachePruneIntervalMs, resolveExternalTemplateCacheTtlMs, } from './template-source-cache-policy.js';
 export { EXTERNAL_TEMPLATE_CACHE_DIR_ENV, EXTERNAL_TEMPLATE_CACHE_ENV, EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV, EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, getExternalTemplateCacheRoot, isExternalTemplateCacheEnabled, } from './template-source-cache-policy.js';
-/**
- * Marker file written after a cache entry is fully populated.
- */
-const CACHE_MARKER_FILE = 'wp-typia-template-cache.json';
-/**
- * Marker file written after a full TTL prune scan completes.
- */
-const CACHE_PRUNE_MARKER_FILE = 'wp-typia-template-cache-prune.json';
 /**
  * Private directory mode used for cache roots and entries on POSIX platforms.
  */
 const PRIVATE_CACHE_DIRECTORY_MODE = 0o700;
-/**
- * Marker value used when URL-like metadata cannot be safely normalized.
- */
-const REDACTED_CACHE_METADATA_VALUE = '[redacted]';
 /**
  * Filesystem errors that mean another writer published the same cache entry.
  */
@@ -34,10 +23,6 @@ const CACHE_UNAVAILABLE_ERROR_CODES = new Set([
     'EPERM',
     'EROFS',
 ]);
-/**
- * Metadata fields that may contain credentialed or signed URLs.
- */
-const URL_LIKE_METADATA_KEY = /(url|uri|registry|tarball)/iu;
 /**
  * Cache namespaces must stay within one path segment under the cache root.
  */
@@ -126,28 +111,6 @@ async function ensurePrivateCacheDirectory(directory) {
         return false;
     }
 }
-function sanitizeCacheMetadataValue(key, value) {
-    if (!URL_LIKE_METADATA_KEY.test(key)) {
-        return value;
-    }
-    try {
-        const url = new URL(value);
-        url.username = '';
-        url.password = '';
-        url.search = '';
-        url.hash = '';
-        return url.toString();
-    }
-    catch {
-        return REDACTED_CACHE_METADATA_VALUE;
-    }
-}
-function sanitizeCacheMetadata(metadata) {
-    return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [
-        key,
-        value === null ? null : sanitizeCacheMetadataValue(key, value),
-    ]));
-}
 function resolveCacheNamespaceDir(cacheRoot, namespace) {
     if (namespace === '.' ||
         namespace === '..' ||
@@ -185,51 +148,14 @@ async function isReusableCacheEntry(entryDir, markerPath, sourceDir) {
         (await pathExists(markerPath)) &&
         (await isDirectoryPath(sourceDir)));
 }
-function parseCacheMarkerMetadata(markerText) {
-    let marker;
-    try {
-        marker = JSON.parse(markerText);
-    }
-    catch {
-        return null;
-    }
-    if (typeof marker !== 'object' || marker === null || Array.isArray(marker)) {
-        return null;
-    }
-    const rawMetadata = marker.metadata;
-    if (typeof rawMetadata !== 'object' ||
-        rawMetadata === null ||
-        Array.isArray(rawMetadata)) {
-        return null;
-    }
-    const metadata = {};
-    for (const [key, value] of Object.entries(rawMetadata)) {
-        if (typeof value !== 'string' && value !== null) {
-            return null;
-        }
-        metadata[key] = value;
-    }
-    const rawCreatedAt = marker.createdAt;
-    const createdAtMs = typeof rawCreatedAt === 'string' ? Date.parse(rawCreatedAt) : 0;
-    return {
-        createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : 0,
-        metadata,
-    };
-}
 async function readCacheEntryMarker(markerPath) {
     try {
-        return parseCacheMarkerMetadata(await fsp.readFile(markerPath, 'utf8'));
+        return parseExternalTemplateCacheEntryMarker(await fsp.readFile(markerPath, 'utf8'));
     }
     catch {
         return null;
     }
 }
-function cacheMetadataMatches(actual, expected) {
-    return Object.entries(expected).every(([key, value]) => actual[key] === value);
-}
-function isCacheEntryFreshForTtl(createdAtMs, nowMs, ttlMs) {
-    return ttlMs === null || createdAtMs >= nowMs - ttlMs;
-}
 async function getReusableCacheEntryMarker(entryDir, markerPath, sourceDir) {
     if (!(await isReusableCacheEntry(entryDir, markerPath, sourceDir))) {
         return null;
@@ -238,7 +164,8 @@ async function getReusableCacheEntryMarker(entryDir, markerPath, sourceDir) {
 }
 async function isReusableFreshCacheEntry(entryDir, markerPath, sourceDir, nowMs, ttlMs) {
     const marker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
-    return (marker !== null && isCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs));
+    return (marker !== null &&
+        isExternalTemplateCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs));
 }
 function isPathInsideDirectory(directory, candidatePath) {
     const relativePath = path.relative(directory, candidatePath);
@@ -261,39 +188,6 @@ async function removeCacheEntryWithinRoot(cacheRoot, entryDir) {
 function getCachePruneMarkerPath(cacheRoot) {
     return path.join(cacheRoot, CACHE_PRUNE_MARKER_FILE);
 }
-function parseCachePruneMarker(markerText) {
-    let marker;
-    try {
-        marker = JSON.parse(markerText);
-    }
-    catch {
-        return null;
-    }
-    if (typeof marker !== 'object' || marker === null || Array.isArray(marker)) {
-        return null;
-    }
-    const rawPrunedAt = marker.prunedAt;
-    const prunedAtMs = typeof rawPrunedAt === 'string' ? Date.parse(rawPrunedAt) : Number.NaN;
-    const rawPruneIntervalMs = marker
-        .pruneIntervalMs;
-    const rawTtlMs = marker.ttlMs;
-    if (typeof rawTtlMs !== 'number' || !Number.isFinite(rawTtlMs)) {
-        return null;
-    }
-    if (!Number.isFinite(prunedAtMs)) {
-        return null;
-    }
-    if (rawPruneIntervalMs !== null &&
-        (typeof rawPruneIntervalMs !== 'number' ||
-            !Number.isFinite(rawPruneIntervalMs))) {
-        return null;
-    }
-    return {
-        prunedAtMs,
-        pruneIntervalMs: rawPruneIntervalMs ?? null,
-        ttlMs: rawTtlMs,
-    };
-}
 async function shouldSkipExternalTemplateCachePrune({ cacheRoot, force, nowMs, pruneIntervalMs, ttlMs, }) {
     if (force || pruneIntervalMs === null) {
         return false;
@@ -305,7 +199,7 @@ async function shouldSkipExternalTemplateCachePrune({ cacheRoot, force, nowMs, p
     catch {
         return false;
     }
-    const marker = parseCachePruneMarker(markerText);
+    const marker = parseExternalTemplateCachePruneMarker(markerText);
     if (!marker ||
         marker.ttlMs !== ttlMs ||
         marker.pruneIntervalMs !== pruneIntervalMs) {
@@ -316,11 +210,11 @@ async function shouldSkipExternalTemplateCachePrune({ cacheRoot, force, nowMs, p
 }
 async function writeExternalTemplateCachePruneMarker({ cacheRoot, nowMs, pruneIntervalMs, ttlMs, }) {
     try {
-        await fsp.writeFile(getCachePruneMarkerPath(cacheRoot), `${JSON.stringify({
-            prunedAt: new Date(nowMs).toISOString(),
+        await fsp.writeFile(getCachePruneMarkerPath(cacheRoot), formatExternalTemplateCachePruneMarker({
+            nowMs,
             pruneIntervalMs,
             ttlMs,
-        }, null, 2)}\n`, 'utf8');
+        }), 'utf8');
     }
     catch {
         // Prune markers are an optimization; failing to write one keeps TTL safe.
@@ -476,8 +370,8 @@ export async function findReusableExternalTemplateSourceCache(descriptor) {
         const sourceDir = path.join(entryDir, 'source');
         const marker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
         if (!marker ||
-            !isCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs) ||
-            !cacheMetadataMatches(marker.metadata, descriptor.metadata)) {
+            !isExternalTemplateCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs) ||
+            !externalTemplateCacheMetadataMatches(marker.metadata, descriptor.metadata)) {
             continue;
         }
         if (!bestEntry || marker.createdAtMs > bestEntry.createdAtMs) {
@@ -523,7 +417,7 @@ export async function resolveExternalTemplateSourceCache(descriptor, populateSou
     await pruneExternalTemplateCache();
     const existingMarker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
     if (existingMarker &&
-        isCacheEntryFreshForTtl(existingMarker.createdAtMs, nowMs, ttlMs)) {
+        isExternalTemplateCacheEntryFreshForTtl(existingMarker.createdAtMs, nowMs, ttlMs)) {
         return {
             cacheHit: true,
             sourceDir,
@@ -550,12 +444,12 @@ export async function resolveExternalTemplateSourceCache(descriptor, populateSou
             populateFailed = true;
             throw error;
         }
-        await fsp.writeFile(path.join(temporaryEntryDir, CACHE_MARKER_FILE), `${JSON.stringify({
-            createdAt: new Date().toISOString(),
-            key: cacheKey,
-            metadata: sanitizeCacheMetadata(descriptor.metadata),
+        await fsp.writeFile(path.join(temporaryEntryDir, CACHE_MARKER_FILE), formatExternalTemplateCacheEntryMarker({
+            cacheKey,
+            createdAt: new Date(),
+            metadata: descriptor.metadata,
             namespace: descriptor.namespace,
-        }, null, 2)}\n`, 'utf8');
+        }), 'utf8');
         await fsp.rename(temporaryEntryDir, entryDir);
         return {
             cacheHit: false,

package/dist/runtime/template-source-external.d.ts

@@ -7,8 +7,10 @@ export declare const EXTERNAL_TEMPLATE_TRUST_WARNING = "External template config
 /**
  * Search a source directory for the first supported external template entry.
  *
- * @deprecated Use `findExternalTemplateEntry()` from async template-source
- * paths. This synchronous helper remains only for compatibility callers.
+ * @deprecated Since 0.22.10. Use `findExternalTemplateEntry()` from async
+ * template-source paths. Removal target: not currently scheduled; this sync
+ * compatibility helper remains available until release notes announce a
+ * versioned target.
  *
  * @param sourceDir Directory that may contain an external template config entry.
  * @returns The first matching entry path, or null when no supported entry exists.

package/dist/runtime/template-source-external.js

@@ -33,8 +33,10 @@ function resolveSourceSubpath(sourceDir, relativePath) {
 /**
  * Search a source directory for the first supported external template entry.
  *
- * @deprecated Use `findExternalTemplateEntry()` from async template-source
- * paths. This synchronous helper remains only for compatibility callers.
+ * @deprecated Since 0.22.10. Use `findExternalTemplateEntry()` from async
+ * template-source paths. Removal target: not currently scheduled; this sync
+ * compatibility helper remains available until release notes announce a
+ * versioned target.
  *
  * @param sourceDir Directory that may contain an external template config entry.
  * @returns The first matching entry path, or null when no supported entry exists.

package/dist/runtime/template-source-remote.d.ts

@@ -2,8 +2,10 @@ import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from
 /**
  * Read a remote block source and return its default block category.
  *
- * @deprecated Use `getDefaultCategoryAsync()` from async template-source paths.
- * This synchronous helper remains only for compatibility callers.
+ * @deprecated Since 0.22.10. Use `getDefaultCategoryAsync()` from async
+ * template-source paths. Removal target: not currently scheduled; this sync
+ * compatibility helper remains available until release notes announce a
+ * versioned target.
  *
  * @param sourceDir Block source directory that may contain a block.json file.
  * @returns The declared block category, or "widgets" when detection fails.
@@ -20,8 +22,10 @@ export declare function getDefaultCategoryAsync(sourceDir: string): Promise<stri
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
  *
- * @deprecated Use `getTemplateProjectTypeAsync()` from async template-source
- * paths. This synchronous helper remains only for compatibility callers.
+ * @deprecated Since 0.22.10. Use `getTemplateProjectTypeAsync()` from async
+ * template-source paths. Removal target: not currently scheduled; this sync
+ * compatibility helper remains available until release notes announce a
+ * versioned target.
  */
 export declare function getTemplateProjectType(sourceDir: string): string | null;
 /**

package/dist/runtime/template-source-remote.js

@@ -59,8 +59,10 @@ async function readRemoteBlockJsonAsync(blockDir) {
 /**
  * Read a remote block source and return its default block category.
  *
- * @deprecated Use `getDefaultCategoryAsync()` from async template-source paths.
- * This synchronous helper remains only for compatibility callers.
+ * @deprecated Since 0.22.10. Use `getDefaultCategoryAsync()` from async
+ * template-source paths. Removal target: not currently scheduled; this sync
+ * compatibility helper remains available until release notes announce a
+ * versioned target.
  *
  * @param sourceDir Block source directory that may contain a block.json file.
  * @returns The declared block category, or "widgets" when detection fails.
@@ -143,8 +145,10 @@ async function readTemplatePackageJsonAsync(sourceDir) {
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
  *
- * @deprecated Use `getTemplateProjectTypeAsync()` from async template-source
- * paths. This synchronous helper remains only for compatibility callers.
+ * @deprecated Since 0.22.10. Use `getTemplateProjectTypeAsync()` from async
+ * template-source paths. Removal target: not currently scheduled; this sync
+ * compatibility helper remains available until release notes announce a
+ * versioned target.
  */
 export function getTemplateProjectType(sourceDir) {
     const packageJsonEntry = readTemplatePackageJson(sourceDir);