@wp-typia/project-tools 0.24.4 → 0.24.6

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

@@ -1,58 +1 @@
-import fs from "node:fs";
-export type TemplateRenderView = Record<string, unknown>;
-/**
- * Optional controls for raw directory copies.
- *
- * The filter runs for each discovered entry before copying. Returning `false`
- * skips only that entry; when the skipped entry is a directory, the subtree is
- * skipped as well.
- */
-export interface CopyRawDirectoryOptions {
-    /**
-     * Predicate that decides whether a discovered entry should be copied.
-     *
-     * Throwing or rejecting aborts the copy and bubbles to the caller.
-     */
-    filter?: CopyDirectoryFilter;
-}
-export type CopyDirectoryFilter = (sourcePath: string, destinationPath: string, entry: fs.Dirent) => boolean | Promise<boolean>;
-/**
- * Render a Mustache template with full Mustache semantics while leaving values
- * unescaped for scaffold source generation.
- */
-export declare function renderMustacheTemplateString(template: string, view: TemplateRenderView): string;
-/**
- * Recursively copies a directory tree without rendering template contents.
- */
-export declare function copyRawDirectory(sourceDir: string, targetDir: string, options?: CopyRawDirectoryOptions): Promise<void>;
-/**
- * Copy a template directory using full Mustache semantics for filenames and
- * text-file contents while leaving rendered values unescaped.
- */
-export declare function copyRenderedDirectory(sourceDir: string, targetDir: string, view: TemplateRenderView, options?: {
-    filter?: CopyDirectoryFilter;
-}): Promise<void>;
-/**
- * Copy a template directory using direct `{{key}}` replacement only.
- *
- * This intentionally preserves literal Mustache sections, partials, and other
- * advanced constructs so built-in scaffold copy paths keep their historical
- * interpolation behavior.
- */
-export declare function copyInterpolatedDirectory(sourceDir: string, targetDir: string, view: Record<string, string>): Promise<void>;
-/**
- * Lists the output file paths produced by an interpolated template directory
- * without writing any files to disk.
- *
- * This walks the source directory, applies the same filename interpolation and
- * `.mustache` stripping rules as `copyInterpolatedDirectory(...)`, and returns
- * normalized output-relative paths under a virtual root.
- *
- * @param sourceDir - The template directory to traverse.
- * @param view - The interpolation map used when resolving file and directory
- * names.
- * @returns A sorted array of normalized output paths relative to a virtual
- * preview root.
- */
-export declare function listInterpolatedDirectoryOutputs(sourceDir: string, view: Record<string, string>): Promise<string[]>;
-export declare function pathExistsSync(targetPath: string): boolean;
+export * from "./templates/template-render.js";

package/dist/runtime/template-render.js

@@ -1,196 +1 @@
-/// <reference path="./external-template-modules.d.ts" />
-import fs from "node:fs";
-import { promises as fsp } from "node:fs";
-import path from "node:path";
-import Mustache from "mustache";
-const BINARY_EXTENSIONS = new Set([
-    ".avif",
-    ".bmp",
-    ".gif",
-    ".ico",
-    ".jpeg",
-    ".jpg",
-    ".otf",
-    ".pdf",
-    ".png",
-    ".svg",
-    ".ttf",
-    ".webp",
-    ".woff",
-    ".woff2",
-]);
-const IDENTITY_MUSTACHE_ESCAPE = (value) => value;
-/**
- * Render a Mustache template with full Mustache semantics while leaving values
- * unescaped for scaffold source generation.
- */
-export function renderMustacheTemplateString(template, view) {
-    const mustacheModule = Mustache;
-    const writer = new mustacheModule.Writer();
-    return writer.render(template, view, undefined, {
-        escape: IDENTITY_MUSTACHE_ESCAPE,
-    });
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-/**
- * Render direct `{{key}}` placeholders without enabling sections, partials, or
- * any other Mustache features.
- */
-function renderInterpolatedString(template, view) {
-    const keys = Object.keys(view);
-    if (keys.length === 0) {
-        return template;
-    }
-    const placeholderPattern = new RegExp(keys.map((key) => `({{${escapeRegExp(key)}}})`).join("|"), "g");
-    return template.replace(placeholderPattern, (match) => view[match.slice(2, -2)] ?? match);
-}
-function isBinaryTemplateFile(filePath) {
-    return BINARY_EXTENSIONS.has(path.extname(filePath).toLowerCase());
-}
-function resolveRenderedPath(targetDir, destinationName) {
-    const resolvedTargetDir = path.resolve(targetDir);
-    const resolvedDestinationPath = path.resolve(resolvedTargetDir, destinationName);
-    const relativePath = path.relative(resolvedTargetDir, resolvedDestinationPath);
-    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-        throw new Error(`Rendered template path escapes target directory: ${destinationName}`);
-    }
-    return resolvedDestinationPath;
-}
-function stripTemplateExtension(entryName) {
-    return entryName.endsWith(".mustache")
-        ? entryName.slice(0, -".mustache".length)
-        : entryName;
-}
-function renderTemplateDestinationName(entryName, view, renderString) {
-    return renderString(stripTemplateExtension(entryName), view);
-}
-async function traverseTemplateDirectory({ filter, prepareDirectory, renderString, sourceDir, targetDir, view, visitFile, }) {
-    const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        const destinationName = renderTemplateDestinationName(entry.name, view, renderString);
-        const destinationPath = resolveRenderedPath(targetDir, destinationName);
-        if (filter && !(await filter(sourcePath, destinationPath, entry))) {
-            continue;
-        }
-        if (entry.isDirectory()) {
-            await prepareDirectory?.(destinationPath);
-            await traverseTemplateDirectory({
-                filter,
-                prepareDirectory,
-                renderString,
-                sourceDir: sourcePath,
-                targetDir: destinationPath,
-                view,
-                visitFile,
-            });
-            continue;
-        }
-        await visitFile({
-            destinationPath,
-            sourcePath,
-        });
-    }
-}
-async function copyTemplateDirectory({ filter, renderString, sourceDir, targetDir, view, }) {
-    await fsp.mkdir(targetDir, { recursive: true });
-    await traverseTemplateDirectory({
-        filter,
-        prepareDirectory: async (directoryPath) => {
-            await fsp.mkdir(directoryPath, { recursive: true });
-        },
-        renderString,
-        sourceDir,
-        targetDir,
-        view,
-        visitFile: async ({ destinationPath, sourcePath }) => {
-            await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
-            if (isBinaryTemplateFile(sourcePath)) {
-                await fsp.copyFile(sourcePath, destinationPath);
-                return;
-            }
-            const content = await fsp.readFile(sourcePath, "utf8");
-            await fsp.writeFile(destinationPath, renderString(content, view), "utf8");
-        },
-    });
-}
-/**
- * Recursively copies a directory tree without rendering template contents.
- */
-export async function copyRawDirectory(sourceDir, targetDir, options = {}) {
-    await fsp.mkdir(targetDir, { recursive: true });
-    for (const entry of await fsp.readdir(sourceDir, { withFileTypes: true })) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        const targetPath = path.join(targetDir, entry.name);
-        if (options.filter && !(await options.filter(sourcePath, targetPath, entry))) {
-            continue;
-        }
-        if (entry.isDirectory()) {
-            await copyRawDirectory(sourcePath, targetPath, options);
-            continue;
-        }
-        await fsp.mkdir(path.dirname(targetPath), { recursive: true });
-        await fsp.copyFile(sourcePath, targetPath);
-    }
-}
-/**
- * Copy a template directory using full Mustache semantics for filenames and
- * text-file contents while leaving rendered values unescaped.
- */
-export async function copyRenderedDirectory(sourceDir, targetDir, view, options = {}) {
-    await copyTemplateDirectory({
-        filter: options.filter,
-        renderString: renderMustacheTemplateString,
-        sourceDir,
-        targetDir,
-        view,
-    });
-}
-/**
- * Copy a template directory using direct `{{key}}` replacement only.
- *
- * This intentionally preserves literal Mustache sections, partials, and other
- * advanced constructs so built-in scaffold copy paths keep their historical
- * interpolation behavior.
- */
-export async function copyInterpolatedDirectory(sourceDir, targetDir, view) {
-    await copyTemplateDirectory({
-        renderString: renderInterpolatedString,
-        sourceDir,
-        targetDir,
-        view,
-    });
-}
-/**
- * Lists the output file paths produced by an interpolated template directory
- * without writing any files to disk.
- *
- * This walks the source directory, applies the same filename interpolation and
- * `.mustache` stripping rules as `copyInterpolatedDirectory(...)`, and returns
- * normalized output-relative paths under a virtual root.
- *
- * @param sourceDir - The template directory to traverse.
- * @param view - The interpolation map used when resolving file and directory
- * names.
- * @returns A sorted array of normalized output paths relative to a virtual
- * preview root.
- */
-export async function listInterpolatedDirectoryOutputs(sourceDir, view) {
-    const virtualRoot = path.resolve("/wp-typia-template-preview");
-    const outputs = [];
-    await traverseTemplateDirectory({
-        renderString: renderInterpolatedString,
-        sourceDir,
-        targetDir: virtualRoot,
-        view,
-        visitFile: async ({ destinationPath }) => {
-            outputs.push(path.relative(virtualRoot, destinationPath).replace(/\\/g, "/"));
-        },
-    });
-    return outputs.sort((left, right) => left.localeCompare(right));
-}
-export function pathExistsSync(targetPath) {
-    return fs.existsSync(targetPath);
-}
+export * from "./templates/template-render.js";

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

@@ -1,37 +1 @@
-/**
- * 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;
+export * from "./templates/template-source-cache-markers.js";

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

@@ -1,130 +1 @@
-import { safeJsonParse } from './json-utils.js';
-/**
- * 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 = safeJsonParse(markerText, {
-            context: 'external template cache entry marker',
-        });
-    }
-    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 = safeJsonParse(markerText, {
-            context: 'external template cache prune marker',
-        });
-    }
-    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`;
-}
+export * from "./templates/template-source-cache-markers.js";

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

@@ -1,53 +1 @@
-/**
- * Environment variable that disables external template cache reads and writes.
- *
- * Set to `0`, `false`, `no`, or `off` to bypass the cache.
- */
-export declare const EXTERNAL_TEMPLATE_CACHE_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE";
-/**
- * Environment variable that overrides the external template cache root.
- */
-export declare const EXTERNAL_TEMPLATE_CACHE_DIR_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR";
-/**
- * Environment variable that enables TTL-based external template cache pruning.
- *
- * Unset, empty, zero, negative, and non-numeric values keep pruning disabled.
- */
-export declare const EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_TTL_DAYS";
-/**
- * Environment variable that overrides how often TTL pruning may scan the cache.
- *
- * Unset values use the default interval. Zero, negative, and non-numeric values
- * disable scan throttling.
- */
-export declare const EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS";
-/**
- * Checks whether remote external template source caching is enabled.
- *
- * Caching is enabled by default. Set `WP_TYPIA_EXTERNAL_TEMPLATE_CACHE` to
- * `0`, `false`, `no`, or `off` to force uncached resolution.
- *
- * @param env Environment object to inspect, defaulting to `process.env`.
- * @returns Whether external template source cache reads and writes are enabled.
- */
-export declare function isExternalTemplateCacheEnabled(env?: NodeJS.ProcessEnv): boolean;
-/**
- * Resolves the external template source cache root directory.
- *
- * `WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR` overrides the location. Without an
- * override, wp-typia uses a per-user `wp-typia-template-source-cache-*`
- * directory inside the operating system temp directory.
- *
- * @param env Environment object to inspect, defaulting to `process.env`.
- * @returns Absolute cache root directory path.
- */
-export declare function getExternalTemplateCacheRoot(env?: NodeJS.ProcessEnv): string;
-export declare function resolveExternalTemplateCacheTtlMs(options?: {
-    env?: NodeJS.ProcessEnv;
-    ttlDays?: number;
-}): number | null;
-export declare function resolveExternalTemplateCachePruneIntervalMs(options?: {
-    env?: NodeJS.ProcessEnv;
-    pruneIntervalMs?: number;
-}): number | null;
-export declare function getExternalTemplateCacheNowMs(now: Date | number | undefined): number;
+export * from "./templates/template-source-cache-policy.js";

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

@@ -1,135 +1 @@
-import os from 'node:os';
-import path from 'node:path';
-/**
- * Environment variable that disables external template cache reads and writes.
- *
- * Set to `0`, `false`, `no`, or `off` to bypass the cache.
- */
-export const EXTERNAL_TEMPLATE_CACHE_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE';
-/**
- * Environment variable that overrides the external template cache root.
- */
-export const EXTERNAL_TEMPLATE_CACHE_DIR_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR';
-/**
- * Environment variable that enables TTL-based external template cache pruning.
- *
- * Unset, empty, zero, negative, and non-numeric values keep pruning disabled.
- */
-export const EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_TTL_DAYS';
-/**
- * Environment variable that overrides how often TTL pruning may scan the cache.
- *
- * Unset values use the default interval. Zero, negative, and non-numeric values
- * disable scan throttling.
- */
-export const EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV = 'WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS';
-/**
- * Milliseconds in one TTL day.
- */
-const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
-/**
- * Default minimum interval between full external template cache prune scans.
- */
-const DEFAULT_CACHE_PRUNE_INTERVAL_MS = 60 * 60 * 1000;
-/**
- * Normalized environment values that disable the cache.
- */
-const DISABLED_CACHE_VALUES = new Set(['0', 'false', 'no', 'off']);
-/**
- * Checks whether remote external template source caching is enabled.
- *
- * Caching is enabled by default. Set `WP_TYPIA_EXTERNAL_TEMPLATE_CACHE` to
- * `0`, `false`, `no`, or `off` to force uncached resolution.
- *
- * @param env Environment object to inspect, defaulting to `process.env`.
- * @returns Whether external template source cache reads and writes are enabled.
- */
-export function isExternalTemplateCacheEnabled(env = process.env) {
-    const rawValue = env[EXTERNAL_TEMPLATE_CACHE_ENV];
-    if (rawValue === undefined) {
-        return true;
-    }
-    return !DISABLED_CACHE_VALUES.has(rawValue.trim().toLowerCase());
-}
-/**
- * Resolves the external template source cache root directory.
- *
- * `WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR` overrides the location. Without an
- * override, wp-typia uses a per-user `wp-typia-template-source-cache-*`
- * directory inside the operating system temp directory.
- *
- * @param env Environment object to inspect, defaulting to `process.env`.
- * @returns Absolute cache root directory path.
- */
-export function getExternalTemplateCacheRoot(env = process.env) {
-    const configuredCacheDir = env[EXTERNAL_TEMPLATE_CACHE_DIR_ENV]?.trim();
-    if (configuredCacheDir) {
-        return path.resolve(configuredCacheDir);
-    }
-    return path.join(os.tmpdir(), `wp-typia-template-source-cache-${getCurrentUserCacheSegment()}`);
-}
-function parseExternalTemplateCacheTtlDays(value) {
-    if (typeof value !== 'string' && typeof value !== 'number') {
-        return null;
-    }
-    const ttlDays = typeof value === 'number' ? value : Number(value.trim());
-    if (!Number.isFinite(ttlDays) || ttlDays <= 0) {
-        return null;
-    }
-    return ttlDays;
-}
-export function resolveExternalTemplateCacheTtlMs(options = {}) {
-    const env = options.env ?? process.env;
-    const ttlDays = options.ttlDays === undefined
-        ? parseExternalTemplateCacheTtlDays(env[EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV])
-        : parseExternalTemplateCacheTtlDays(options.ttlDays);
-    if (ttlDays === null) {
-        return null;
-    }
-    const ttlMs = ttlDays * MILLISECONDS_PER_DAY;
-    return Number.isFinite(ttlMs) ? ttlMs : null;
-}
-function parseExternalTemplateCachePruneIntervalMs(value) {
-    if (typeof value !== 'string' && typeof value !== 'number') {
-        return null;
-    }
-    const intervalMs = typeof value === 'number' ? value : Number(value.trim());
-    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
-        return null;
-    }
-    return intervalMs;
-}
-export function resolveExternalTemplateCachePruneIntervalMs(options = {}) {
-    if (options.pruneIntervalMs !== undefined) {
-        return parseExternalTemplateCachePruneIntervalMs(options.pruneIntervalMs);
-    }
-    const env = options.env ?? process.env;
-    const envValue = env[EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV];
-    if (envValue === undefined) {
-        return DEFAULT_CACHE_PRUNE_INTERVAL_MS;
-    }
-    return parseExternalTemplateCachePruneIntervalMs(envValue);
-}
-export function getExternalTemplateCacheNowMs(now) {
-    const nowMs = now instanceof Date
-        ? now.getTime()
-        : typeof now === 'number'
-            ? now
-            : Date.now();
-    return Number.isFinite(nowMs) ? nowMs : Date.now();
-}
-function getCurrentUserCacheSegment() {
-    if (typeof process.getuid === 'function') {
-        return String(process.getuid());
-    }
-    try {
-        const safeUsername = os
-            .userInfo()
-            .username.trim()
-            .replace(/[^A-Za-z0-9._-]+/gu, '-');
-        return safeUsername.length > 0 ? safeUsername : 'user';
-    }
-    catch {
-        return 'user';
-    }
-}
+export * from "./templates/template-source-cache-policy.js";