@wp-typia/project-tools 0.24.3 → 0.24.5

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

@@ -0,0 +1,46 @@
+/**
+ * Normalize arbitrary text into a kebab-case identifier.
+ * Common acronym runs stay grouped, with a boundary before the next
+ * capitalized word or before a narrow allow-list of lowercase WordPress slug
+ * terms. Naturalized words such as `RESTful` intentionally stay as one word.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase kebab-case string with collapsed separators.
+ */
+export declare function toKebabCase(input: string): string;
+/**
+ * Normalize arbitrary text into a snake_case identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase snake_case string derived from the kebab-case form.
+ */
+export declare function toSnakeCase(input: string): string;
+/**
+ * Normalize arbitrary text into a PascalCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A PascalCase string derived from the normalized kebab-case form.
+ */
+export declare function toPascalCase(input: string): string;
+/**
+ * Normalize arbitrary text into a camelCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A camelCase string derived from the normalized PascalCase form.
+ */
+export declare function toCamelCase(input: string): string;
+/**
+ * Convert delimited text to PascalCase while preserving each segment's
+ * existing internal casing.
+ *
+ * @param input Raw text split on non-alphanumeric boundaries.
+ * @returns A PascalCase string that preserves acronyms inside segments.
+ */
+export declare function toSegmentPascalCase(input: string): string;
+/**
+ * Normalize arbitrary text into a human-readable title.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A title-cased string derived from the normalized kebab-case form.
+ */
+export declare function toTitleCase(input: string): string;

package/dist/runtime/shared/string-case.js

@@ -0,0 +1,140 @@
+// Keep this list fixed so generated slugs and file paths do not drift when
+// project config changes. Domain-specific acronyms should use separators.
+const COMMON_ACRONYM_PREFIXES = [
+    'HTML',
+    'HTTP',
+    'JSON',
+    'REST',
+    'UUID',
+    'AJAX',
+    'API',
+    'CPT',
+    'CSS',
+    'CTA',
+    'DOM',
+    'PHP',
+    'SQL',
+    'SVG',
+    'URL',
+    'XML',
+    'ID',
+    'JS',
+    'UI',
+    'WP',
+];
+// Keep lowercase suffix splitting narrow so naturalized words such as
+// `RESTful` remain stable while WordPress slug terms like `URLslug` read well.
+const COMMON_ACRONYM_LOWERCASE_SUFFIXES = ['slug'];
+function capitalizeSegment(segment) {
+    return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+function findCommonAcronymPrefix(segment) {
+    return COMMON_ACRONYM_PREFIXES.find((prefix) => segment.startsWith(prefix));
+}
+function isCommonAcronymLowercaseSuffix(suffix) {
+    return COMMON_ACRONYM_LOWERCASE_SUFFIXES.includes(suffix);
+}
+function splitKnownAcronymSegment(segment) {
+    const prefixes = [];
+    let remaining = segment;
+    while (remaining.length > 0) {
+        const prefix = findCommonAcronymPrefix(remaining);
+        if (!prefix) {
+            break;
+        }
+        const suffix = remaining.slice(prefix.length);
+        if (/^[A-Z][a-z]/.test(suffix)) {
+            return [...prefixes, prefix, suffix].join('-');
+        }
+        if (/^[a-z]+$/.test(suffix) && isCommonAcronymLowercaseSuffix(suffix)) {
+            return [...prefixes, prefix, suffix].join('-');
+        }
+        if (!findCommonAcronymPrefix(suffix)) {
+            break;
+        }
+        prefixes.push(prefix);
+        remaining = suffix;
+    }
+    return segment;
+}
+function splitAcronymBoundary(value) {
+    return value.replace(/[A-Z]{2,}[a-z]+/g, splitKnownAcronymSegment);
+}
+/**
+ * Normalize arbitrary text into a kebab-case identifier.
+ * Common acronym runs stay grouped, with a boundary before the next
+ * capitalized word or before a narrow allow-list of lowercase WordPress slug
+ * terms. Naturalized words such as `RESTful` intentionally stay as one word.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase kebab-case string with collapsed separators.
+ */
+export function toKebabCase(input) {
+    return splitAcronymBoundary(input.trim())
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-')
+        .toLowerCase();
+}
+/**
+ * Normalize arbitrary text into a snake_case identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase snake_case string derived from the kebab-case form.
+ */
+export function toSnakeCase(input) {
+    return toKebabCase(input).replace(/-/g, '_');
+}
+/**
+ * Normalize arbitrary text into a PascalCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A PascalCase string derived from the normalized kebab-case form.
+ */
+export function toPascalCase(input) {
+    return toKebabCase(input)
+        .split('-')
+        .filter(Boolean)
+        .map(capitalizeSegment)
+        .join('');
+}
+/**
+ * Normalize arbitrary text into a camelCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A camelCase string derived from the normalized PascalCase form.
+ */
+export function toCamelCase(input) {
+    const pascalCase = toPascalCase(input);
+    return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
+}
+/**
+ * Convert delimited text to PascalCase while preserving each segment's
+ * existing internal casing.
+ *
+ * @param input Raw text split on non-alphanumeric boundaries.
+ * @returns A PascalCase string that preserves acronyms inside segments.
+ */
+export function toSegmentPascalCase(input) {
+    return input
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(capitalizeSegment)
+        .join('');
+}
+/**
+ * Normalize arbitrary text into a human-readable title.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A title-cased string derived from the normalized kebab-case form.
+ */
+export function toTitleCase(input) {
+    return toKebabCase(input)
+        .split('-')
+        .filter(Boolean)
+        .map(capitalizeSegment)
+        .join(' ');
+}

package/dist/runtime/shared/temp-roots.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Required prefix for managed wp-typia temporary directories.
+ */
+export declare const WP_TYPIA_TEMP_ROOT_PREFIX = "wp-typia-";
+/**
+ * Default age threshold for pruning stale wp-typia temp roots.
+ */
+export declare const STALE_TEMP_ROOT_MAX_AGE_MS: number;
+type TempRootOptions = {
+    maxAgeMs?: number;
+    now?: number;
+    tmpDir?: string;
+};
+/**
+ * Remove a managed temp root and stop tracking it for process-level cleanup.
+ *
+ * @param tempRoot Absolute temporary directory path to remove.
+ */
+export declare function cleanupManagedTempRoot(tempRoot: string): Promise<void>;
+/**
+ * Remove stale `wp-typia-*` temp directories from the target temp root.
+ *
+ * @param options Optional temp directory, age threshold, and clock override.
+ * @returns Absolute temp-root paths removed during the cleanup pass.
+ */
+export declare function cleanupStaleTempRoots({ maxAgeMs, now, tmpDir, }?: TempRootOptions): Promise<string[]>;
+/**
+ * Create a managed wp-typia temp root and install process cleanup handlers.
+ *
+ * @param prefix Temp directory prefix. Must start with `wp-typia-`.
+ * @param options Optional temp directory override.
+ * @returns The created temp-root path plus an async cleanup helper.
+ */
+export declare function createManagedTempRoot(prefix: string, options?: Pick<TempRootOptions, "tmpDir">): Promise<{
+    cleanup: () => Promise<void>;
+    path: string;
+}>;
+/**
+ * Snapshot the currently tracked temp roots for diagnostics and tests.
+ *
+ * @returns Absolute paths for temp roots currently registered for cleanup.
+ */
+export declare function getTrackedTempRoots(): string[];
+export {};

package/dist/runtime/shared/temp-roots.js

@@ -0,0 +1,132 @@
+import fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Required prefix for managed wp-typia temporary directories.
+ */
+export const WP_TYPIA_TEMP_ROOT_PREFIX = "wp-typia-";
+/**
+ * Default age threshold for pruning stale wp-typia temp roots.
+ */
+export const STALE_TEMP_ROOT_MAX_AGE_MS = 1000 * 60 * 60 * 24;
+const trackedTempRoots = new Set();
+let cleanupHandlersInstalled = false;
+let staleCleanupRan = false;
+let signalCleanupInProgress = false;
+function getTempDir(tmpDir) {
+    return tmpDir ?? os.tmpdir();
+}
+function cleanupTrackedTempRootsSync() {
+    for (const tempRoot of [...trackedTempRoots]) {
+        trackedTempRoots.delete(tempRoot);
+        try {
+            fs.rmSync(tempRoot, { force: true, recursive: true });
+        }
+        catch {
+            // Process-exit cleanup is best-effort: shutdown-time rm failures
+            // such as EPERM are intentionally ignored rather than made fatal.
+        }
+    }
+}
+function installCleanupHandlers() {
+    if (cleanupHandlersInstalled) {
+        return;
+    }
+    cleanupHandlersInstalled = true;
+    process.on("exit", cleanupTrackedTempRootsSync);
+    for (const [signal, exitCode] of [
+        ["SIGHUP", 129],
+        ["SIGINT", 130],
+        ["SIGTERM", 143],
+    ]) {
+        process.once(signal, () => {
+            if (signalCleanupInProgress) {
+                return;
+            }
+            signalCleanupInProgress = true;
+            cleanupTrackedTempRootsSync();
+            process.exitCode = exitCode;
+            process.exit();
+        });
+    }
+}
+/**
+ * Remove a managed temp root and stop tracking it for process-level cleanup.
+ *
+ * @param tempRoot Absolute temporary directory path to remove.
+ */
+export async function cleanupManagedTempRoot(tempRoot) {
+    trackedTempRoots.delete(tempRoot);
+    await fsp.rm(tempRoot, { force: true, recursive: true });
+}
+/**
+ * Remove stale `wp-typia-*` temp directories from the target temp root.
+ *
+ * @param options Optional temp directory, age threshold, and clock override.
+ * @returns Absolute temp-root paths removed during the cleanup pass.
+ */
+export async function cleanupStaleTempRoots({ maxAgeMs = STALE_TEMP_ROOT_MAX_AGE_MS, now = Date.now(), tmpDir, } = {}) {
+    const resolvedTmpDir = getTempDir(tmpDir);
+    const removedRoots = [];
+    const entries = await fsp.readdir(resolvedTmpDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() ||
+            !entry.name.startsWith(WP_TYPIA_TEMP_ROOT_PREFIX)) {
+            continue;
+        }
+        const tempRoot = path.join(resolvedTmpDir, entry.name);
+        if (trackedTempRoots.has(tempRoot)) {
+            continue;
+        }
+        let stats;
+        try {
+            stats = await fsp.stat(tempRoot);
+        }
+        catch {
+            continue;
+        }
+        if (now - stats.mtimeMs < maxAgeMs) {
+            continue;
+        }
+        try {
+            await fsp.rm(tempRoot, { force: true, recursive: true });
+            removedRoots.push(tempRoot);
+        }
+        catch {
+            continue;
+        }
+    }
+    return removedRoots;
+}
+/**
+ * Create a managed wp-typia temp root and install process cleanup handlers.
+ *
+ * @param prefix Temp directory prefix. Must start with `wp-typia-`.
+ * @param options Optional temp directory override.
+ * @returns The created temp-root path plus an async cleanup helper.
+ */
+export async function createManagedTempRoot(prefix, options = {}) {
+    if (!prefix.startsWith(WP_TYPIA_TEMP_ROOT_PREFIX)) {
+        throw new Error(`Managed wp-typia temp roots must use the "${WP_TYPIA_TEMP_ROOT_PREFIX}" prefix.`);
+    }
+    installCleanupHandlers();
+    if (!staleCleanupRan) {
+        staleCleanupRan = true;
+        await cleanupStaleTempRoots({ tmpDir: options.tmpDir });
+    }
+    const tempRoot = await fsp.mkdtemp(path.join(getTempDir(options.tmpDir), prefix));
+    trackedTempRoots.add(tempRoot);
+    return {
+        cleanup: async () => cleanupManagedTempRoot(tempRoot),
+        path: tempRoot,
+    };
+}
+/**
+ * Snapshot the currently tracked temp roots for diagnostics and tests.
+ *
+ * @returns Absolute paths for temp roots currently registered for cleanup.
+ */
+export function getTrackedTempRoots() {
+    return [...trackedTempRoots];
+}

package/dist/runtime/shared/ts-property-names.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+/**
+ * Extract the literal text for TypeScript property names this runtime supports.
+ *
+ * Computed property names are intentionally not resolved because their runtime
+ * values are not statically knowable from the syntax node alone.
+ *
+ * @param name TypeScript property name node.
+ * @returns Identifier, string-literal, or numeric-literal text; otherwise `null`.
+ */
+export declare function getPropertyNameText(name: ts.PropertyName): string | null;

package/dist/runtime/shared/ts-property-names.js

@@ -0,0 +1,16 @@
+import ts from "typescript";
+/**
+ * Extract the literal text for TypeScript property names this runtime supports.
+ *
+ * Computed property names are intentionally not resolved because their runtime
+ * values are not statically knowable from the syntax node alone.
+ *
+ * @param name TypeScript property name node.
+ * @returns Identifier, string-literal, or numeric-literal text; otherwise `null`.
+ */
+export function getPropertyNameText(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}

package/dist/runtime/shared/ts-source-masking.d.ts

@@ -0,0 +1,28 @@
+/** Original-source range returned from a masked-source pattern match. */
+export interface SourceRange {
+    end: number;
+    start: number;
+}
+/**
+ * Masks TypeScript comments with spaces while preserving newlines and offsets.
+ */
+export declare function maskTypeScriptComments(source: string): string;
+/**
+ * Masks TypeScript comments and quoted/template literals with spaces while
+ * preserving source offsets. This is a lightweight lexer for runtime checks,
+ * not a full TypeScript parser, so template interpolation and regex/division
+ * ambiguity are intentionally left to callers that need deeper syntax analysis.
+ */
+export declare function maskTypeScriptCommentsAndLiterals(source: string): string;
+/**
+ * Tests for a pattern after hiding comments and quoted/template literals.
+ */
+export declare function hasExecutablePattern(source: string, pattern: RegExp): boolean;
+/**
+ * Tests for a pattern after hiding comments while leaving literals intact.
+ */
+export declare function hasUncommentedPattern(source: string, pattern: RegExp): boolean;
+/**
+ * Finds the first masked-source match that maps back to the original source.
+ */
+export declare function findExecutablePatternMatch(source: string, patterns: readonly RegExp[]): SourceRange | undefined;

package/dist/runtime/shared/ts-source-masking.js

@@ -0,0 +1,104 @@
+function maskSourceSegment(segment) {
+    return segment.replace(/[^\n\r]/gu, " ");
+}
+function testPattern(source, pattern) {
+    pattern.lastIndex = 0;
+    const matched = pattern.test(source);
+    pattern.lastIndex = 0;
+    return matched;
+}
+/**
+ * Masks TypeScript comments with spaces while preserving newlines and offsets.
+ */
+export function maskTypeScriptComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment)
+        .replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
+}
+/**
+ * Masks TypeScript comments and quoted/template literals with spaces while
+ * preserving source offsets. This is a lightweight lexer for runtime checks,
+ * not a full TypeScript parser, so template interpolation and regex/division
+ * ambiguity are intentionally left to callers that need deeper syntax analysis.
+ */
+export function maskTypeScriptCommentsAndLiterals(source) {
+    let maskedSource = "";
+    let index = 0;
+    while (index < source.length) {
+        const current = source[index];
+        const next = source[index + 1];
+        if (current === "/" && next === "/") {
+            const start = index;
+            index += 2;
+            while (index < source.length &&
+                source[index] !== "\n" &&
+                source[index] !== "\r") {
+                index += 1;
+            }
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        if (current === "/" && next === "*") {
+            const start = index;
+            index += 2;
+            while (index < source.length &&
+                !(source[index] === "*" && source[index + 1] === "/")) {
+                index += 1;
+            }
+            index = Math.min(index + 2, source.length);
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        if (current === "'" || current === '"' || current === "`") {
+            const start = index;
+            const quote = current;
+            index += 1;
+            while (index < source.length) {
+                const char = source[index];
+                if (char === "\\") {
+                    index += 2;
+                    continue;
+                }
+                index += 1;
+                if (char === quote) {
+                    break;
+                }
+            }
+            maskedSource += maskSourceSegment(source.slice(start, index));
+            continue;
+        }
+        maskedSource += current;
+        index += 1;
+    }
+    return maskedSource;
+}
+/**
+ * Tests for a pattern after hiding comments and quoted/template literals.
+ */
+export function hasExecutablePattern(source, pattern) {
+    return testPattern(maskTypeScriptCommentsAndLiterals(source), pattern);
+}
+/**
+ * Tests for a pattern after hiding comments while leaving literals intact.
+ */
+export function hasUncommentedPattern(source, pattern) {
+    return testPattern(maskTypeScriptComments(source), pattern);
+}
+/**
+ * Finds the first masked-source match that maps back to the original source.
+ */
+export function findExecutablePatternMatch(source, patterns) {
+    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+    for (const pattern of patterns) {
+        pattern.lastIndex = 0;
+        const match = pattern.exec(maskedSource);
+        pattern.lastIndex = 0;
+        if (match && match.index !== undefined) {
+            return {
+                end: match.index + match[0].length,
+                start: match.index,
+            };
+        }
+    }
+    return undefined;
+}

package/dist/runtime/shared/version-floor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parse a dotted version floor into numeric parts for stable comparisons.
+ *
+ * @param value Human-authored version floor such as `7.0` or `8.1.2`.
+ * @returns Numeric version segments suitable for ordered comparison.
+ * @throws When any segment contains non-digit characters.
+ */
+export declare function parseVersionFloorParts(value: string): number[];
+/**
+ * Compare two dotted version floors.
+ *
+ * Missing trailing segments are treated as zero so `7.0` equals `7.0.0`.
+ *
+ * @param left Left-hand version floor.
+ * @param right Right-hand version floor.
+ * @returns `1` when left is higher, `-1` when right is higher, or `0` when equal.
+ */
+export declare function compareVersionFloors(left: string, right: string): number;
+/**
+ * Pick the higher version floor while tolerating undefined values.
+ *
+ * @param current Current resolved floor, when present.
+ * @param candidate Candidate floor to compare against the current floor.
+ * @returns The higher defined floor, or undefined when neither value exists.
+ */
+export declare function pickHigherVersionFloor(current: string | undefined, candidate: string | undefined): string | undefined;

package/dist/runtime/shared/version-floor.js

@@ -0,0 +1,62 @@
+/**
+ * Parse a dotted version floor into numeric parts for stable comparisons.
+ *
+ * @param value Human-authored version floor such as `7.0` or `8.1.2`.
+ * @returns Numeric version segments suitable for ordered comparison.
+ * @throws When any segment contains non-digit characters.
+ */
+export function parseVersionFloorParts(value) {
+    return value.split('.').map((part, index) => {
+        if (!/^\d+$/u.test(part)) {
+            throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
+        }
+        return Number.parseInt(part, 10);
+    });
+}
+/**
+ * Compare two dotted version floors.
+ *
+ * Missing trailing segments are treated as zero so `7.0` equals `7.0.0`.
+ *
+ * @param left Left-hand version floor.
+ * @param right Right-hand version floor.
+ * @returns `1` when left is higher, `-1` when right is higher, or `0` when equal.
+ */
+export function compareVersionFloors(left, right) {
+    const leftParts = parseVersionFloorParts(left);
+    const rightParts = parseVersionFloorParts(right);
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = leftParts[index] ?? 0;
+        const rightValue = rightParts[index] ?? 0;
+        if (leftValue > rightValue) {
+            return 1;
+        }
+        if (leftValue < rightValue) {
+            return -1;
+        }
+    }
+    return 0;
+}
+/**
+ * Pick the higher version floor while tolerating undefined values.
+ *
+ * @param current Current resolved floor, when present.
+ * @param candidate Candidate floor to compare against the current floor.
+ * @returns The higher defined floor, or undefined when neither value exists.
+ */
+export function pickHigherVersionFloor(current, candidate) {
+    if (current !== undefined) {
+        parseVersionFloorParts(current);
+    }
+    if (candidate !== undefined) {
+        parseVersionFloorParts(candidate);
+    }
+    if (candidate === undefined) {
+        return current;
+    }
+    if (current === undefined) {
+        return candidate;
+    }
+    return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
+}

package/dist/runtime/starter-manifests.d.ts

@@ -1,26 +1 @@
-/**
- * Scaffold-time starter manifest builders for generated projects.
- *
- * These helpers now reuse the Phase 2 built-in artifact model so generated
- * `types.ts`, `block.json`, and starter `typia.manifest.json` all share the
- * same attribute metadata source of truth.
- */
-import type { ManifestDocument } from "./migration-types.js";
-import type { ScaffoldTemplateVariables } from "./scaffold.js";
-/**
- * Builds the starter manifest used by generated compound child blocks.
- */
-export declare function buildCompoundChildStarterManifestDocument(childTypeName: string, childTitle: string, bodyPlaceholder?: string): ManifestDocument;
-/**
- * Returns the starter manifest files that should be seeded for a built-in
- * template before the first sync.
- */
-export declare function getStarterManifestFiles(templateId: string, variables: ScaffoldTemplateVariables): Array<{
-    document: ManifestDocument;
-    relativePath: string;
-}>;
-/**
- * Serializes a starter manifest using the generated-project JSON formatting
- * convention.
- */
-export declare function stringifyStarterManifest(document: ManifestDocument): string;
+export * from "./templates/starter-manifests.js";

package/dist/runtime/starter-manifests.js

@@ -1,33 +1 @@
-import { buildBuiltInBlockArtifacts, buildCompoundChildStarterManifestDocument as buildCompoundChildStarterManifestFromArtifacts, } from "./built-in-block-artifacts.js";
-/**
- * Builds the starter manifest used by generated compound child blocks.
- */
-export function buildCompoundChildStarterManifestDocument(childTypeName, childTitle, bodyPlaceholder) {
-    return buildCompoundChildStarterManifestFromArtifacts(childTypeName, childTitle, bodyPlaceholder);
-}
-/**
- * Returns the starter manifest files that should be seeded for a built-in
- * template before the first sync.
- */
-export function getStarterManifestFiles(templateId, variables) {
-    if (templateId !== "basic" &&
-        templateId !== "interactivity" &&
-        templateId !== "persistence" &&
-        templateId !== "compound") {
-        return [];
-    }
-    return buildBuiltInBlockArtifacts({
-        templateId,
-        variables,
-    }).map((artifact) => ({
-        document: artifact.manifestDocument,
-        relativePath: `${artifact.relativeDir}/typia.manifest.json`,
-    }));
-}
-/**
- * Serializes a starter manifest using the generated-project JSON formatting
- * convention.
- */
-export function stringifyStarterManifest(document) {
-    return `${JSON.stringify(document, null, "\t")}\n`;
-}
+export * from "./templates/starter-manifests.js";