@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/doctor/cli-doctor-workspace-shared.js

@@ -0,0 +1,102 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Glob pattern for generated binding-source PHP entrypoints. */
+export const WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
+/** Relative path to the generated binding editor bundle. */
+export const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
+/** Relative path to the generated binding asset manifest. */
+export const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
+/** Glob pattern for generated REST resource PHP entrypoints. */
+export const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+/** Glob pattern for generated post-meta PHP entrypoints. */
+export const WORKSPACE_POST_META_GLOB = "/inc/post-meta/*.php";
+/** Glob pattern for generated ability PHP entrypoints. */
+export const WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
+/** Relative path to the generated ability editor bundle. */
+export const WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
+/** Relative path to the generated ability asset manifest. */
+export const WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
+/** Glob pattern for generated AI feature PHP entrypoints. */
+export const WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php";
+/** Glob pattern for generated admin view PHP entrypoints. */
+export const WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php";
+/** Relative path to the generated admin view editor bundle. */
+export const WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js";
+/** Relative path to the generated admin view asset manifest. */
+export const WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php";
+/** Relative path to the generated admin view stylesheet. */
+export const WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css";
+/** Relative path to the generated editor plugin bundle. */
+export const WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
+/** Relative path to the generated editor plugin asset manifest. */
+export const WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
+/** Relative path to the generated editor plugin stylesheet. */
+export const WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
+/** Canonical generated artifact filenames expected in each workspace block directory. */
+export const WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
+    "block.json",
+    "typia.manifest.json",
+    "typia.schema.json",
+    "typia-validator.php",
+    "typia.openapi.json",
+];
+/** Pattern for full block names in `namespace/slug` format. */
+export const WORKSPACE_FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+/**
+ * Create a doctor result row with an optional stable diagnostic code.
+ *
+ * @param label Human-readable doctor row label.
+ * @param status Pass, warn, or fail status for the row.
+ * @param detail Detailed remediation or success text for CLI output.
+ * @param code Optional stable machine-readable diagnostic code.
+ * @returns A normalized `DoctorCheck` object for CLI rendering.
+ */
+export function createDoctorCheck(label, status, detail, code) {
+    return code ? { code, detail, label, status } : { detail, label, status };
+}
+/**
+ * Create the standard workspace-doctor scope row.
+ *
+ * @param status Pass or fail scope status for the doctor run.
+ * @param detail Scope summary describing what diagnostics ran.
+ * @returns A `DoctorCheck` row labelled `Doctor scope`.
+ */
+export function createDoctorScopeCheck(status, detail) {
+    return createDoctorCheck("Doctor scope", status, detail);
+}
+/**
+ * Resolve the expected workspace bootstrap file from a package name.
+ *
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Relative PHP bootstrap filename for the workspace root.
+ */
+export function getWorkspaceBootstrapRelativePath(packageName) {
+    return `${packageName.split("/").pop() ?? packageName}.php`;
+}
+/**
+ * Resolve the expected workspace bootstrap file inside a project root.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Absolute PHP bootstrap file path for the workspace root.
+ */
+export function resolveWorkspaceBootstrapPath(projectDir, packageName) {
+    return path.join(projectDir, getWorkspaceBootstrapRelativePath(packageName));
+}
+/**
+ * Verify that every referenced relative file exists inside a workspace.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param label Doctor row label for the file set being checked.
+ * @param filePaths Relative file paths to validate.
+ * @returns A passing or failing `DoctorCheck` describing any missing files.
+ */
+export function checkExistingFiles(projectDir, label, filePaths) {
+    // Workspace category collectors remain synchronous pure mappers after the
+    // async inventory snapshot is loaded, so these small existence probes stay
+    // sync to preserve their current non-Promise APIs and output ordering.
+    const missing = filePaths
+        .filter((filePath) => typeof filePath === "string")
+        .filter((filePath) => !fs.existsSync(path.join(projectDir, filePath)));
+    return createDoctorCheck(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
+}

package/dist/runtime/doctor/cli-doctor-workspace.d.ts

@@ -0,0 +1,18 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+/**
+ * Collect workspace-scoped doctor checks for the given working directory.
+ *
+ * When the directory is not an official workspace, the function returns a
+ * "Doctor scope" row explaining that only environment checks ran, plus a
+ * failing workspace metadata row when a nearby candidate workspace is invalid.
+ * When workspace resolution or metadata parsing throws, the corresponding
+ * failing rows are returned early and the remaining checks are skipped.
+ * When an official workspace is detected, a passing "Doctor scope" row is
+ * emitted first so the remaining package metadata, inventory, source-tree
+ * drift, and optional migration hint rows are clearly framed as workspace
+ * diagnostics for that run.
+ *
+ * @param cwd Working directory expected to host an official workspace.
+ * @returns Ordered workspace check rows ready for CLI rendering.
+ */
+export declare function getWorkspaceDoctorChecks(cwd: string): Promise<DoctorCheck[]>;

package/dist/runtime/doctor/cli-doctor-workspace.js

@@ -0,0 +1,97 @@
+import { getWorkspaceBindingDoctorChecks, } from "./cli-doctor-workspace-bindings.js";
+import { getWorkspaceBlockDoctorChecks, } from "./cli-doctor-workspace-blocks.js";
+import { getWorkspaceFeatureDoctorChecks, } from "./cli-doctor-workspace-features.js";
+import { getMigrationWorkspaceHintCheck, getWorkspacePackageMetadataCheck, prepareWorkspacePackageDoctorSnapshot, } from "./cli-doctor-workspace-package.js";
+import { createDoctorCheck, createDoctorScopeCheck, } from "./cli-doctor-workspace-shared.js";
+import { readWorkspaceInventoryAsync, } from "../workspace/workspace-inventory.js";
+import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, tryResolveWorkspaceProject, } from "../workspace/workspace-project.js";
+function formatWorkspaceInventorySummary(inventory) {
+    return [
+        `${inventory.blocks.length} block(s)`,
+        `${inventory.variations.length} variation(s)`,
+        `${inventory.blockStyles.length} block style(s)`,
+        `${inventory.blockTransforms.length} block transform(s)`,
+        `${inventory.patterns.length} pattern(s)`,
+        `${inventory.bindingSources.length} binding source(s)`,
+        `${inventory.restResources.length} REST resource(s)`,
+        `${inventory.postMeta.length} post meta contract(s)`,
+        `${inventory.abilities.length} ability scaffold(s)`,
+        `${inventory.aiFeatures.length} AI feature(s)`,
+        `${inventory.editorPlugins.length} editor plugin(s)`,
+        `${inventory.adminViews.length} admin view(s)`,
+    ].join(", ");
+}
+/**
+ * Collect workspace-scoped doctor checks for the given working directory.
+ *
+ * When the directory is not an official workspace, the function returns a
+ * "Doctor scope" row explaining that only environment checks ran, plus a
+ * failing workspace metadata row when a nearby candidate workspace is invalid.
+ * When workspace resolution or metadata parsing throws, the corresponding
+ * failing rows are returned early and the remaining checks are skipped.
+ * When an official workspace is detected, a passing "Doctor scope" row is
+ * emitted first so the remaining package metadata, inventory, source-tree
+ * drift, and optional migration hint rows are clearly framed as workspace
+ * diagnostics for that run.
+ *
+ * @param cwd Working directory expected to host an official workspace.
+ * @returns Ordered workspace check rows ready for CLI rendering.
+ */
+export async function getWorkspaceDoctorChecks(cwd) {
+    const checks = [];
+    let workspace = null;
+    let invalidWorkspaceReason = null;
+    try {
+        // Workspace discovery and package parsing intentionally stay synchronous
+        // because they share compatibility helpers with sync add/migration callers.
+        invalidWorkspaceReason = getInvalidWorkspaceProjectReason(cwd);
+        workspace = tryResolveWorkspaceProject(cwd);
+    }
+    catch (error) {
+        checks.push(createDoctorScopeCheck("fail", "Scope: blocked before workspace checks. Environment checks ran, but workspace discovery could not continue. Fix the nearby workspace package metadata and rerun `wp-typia doctor`."));
+        checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+        return checks;
+    }
+    if (!workspace) {
+        if (invalidWorkspaceReason) {
+            checks.push(createDoctorScopeCheck("fail", "Scope: blocked before workspace checks. Environment checks ran, but workspace diagnostics could not continue because a nearby wp-typia workspace candidate is invalid. Fix the workspace package metadata and rerun `wp-typia doctor`."));
+            checks.push(createDoctorCheck("Workspace package metadata", "fail", invalidWorkspaceReason));
+        }
+        else {
+            checks.push(createDoctorScopeCheck("pass", "Scope: environment-only. No official wp-typia workspace root was detected, so this run only covered environment readiness. Re-run `wp-typia doctor` from a workspace root if you expected package metadata, inventory, or generated artifact checks."));
+        }
+        return checks;
+    }
+    checks.push(createDoctorScopeCheck("pass", `Scope: full workspace diagnostics for ${workspace.workspace.namespace}. Environment readiness checks ran and workspace-scoped diagnostics are enabled for the package metadata, inventory, source-tree drift, and any configured migration hint rows below.`));
+    let workspacePackageJson;
+    try {
+        // Keep package metadata parsing sync until workspace-project exposes an
+        // async companion; the surrounding doctor orchestration already awaits
+        // async inventory reads below.
+        workspacePackageJson = parseWorkspacePackageJson(workspace.projectDir);
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+        return checks;
+    }
+    const packageDoctorSnapshot = await prepareWorkspacePackageDoctorSnapshot(workspace, workspacePackageJson);
+    checks.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson, packageDoctorSnapshot));
+    try {
+        const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+        checks.push(createDoctorCheck("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
+        // The highest-impact remaining probes live in block, binding, and feature
+        // categories; keep them synchronous until broader path/content snapshots
+        // can preserve their current row ordering and diagnostics.
+        checks.push(...getWorkspaceBlockDoctorChecks(workspace, inventory));
+        checks.push(...getWorkspaceBindingDoctorChecks(workspace, inventory));
+        checks.push(...getWorkspaceFeatureDoctorChecks(workspace, inventory));
+        const migrationWorkspaceCheck = getMigrationWorkspaceHintCheck(workspacePackageJson, packageDoctorSnapshot);
+        if (migrationWorkspaceCheck) {
+            checks.push(migrationWorkspaceCheck);
+        }
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace inventory", "fail", error instanceof Error ? error.message : String(error)));
+    }
+    return checks;
+}

package/dist/runtime/doctor/cli-doctor.d.ts

@@ -0,0 +1,90 @@
+/** Scope bucket used by doctor exit policies and JSON summaries. */
+export type DoctorCheckScope = "environment" | "workspace";
+/** Policy used to decide which failed checks should fail the process. */
+export type DoctorExitPolicy = "strict" | "workspace-only";
+/**
+ * One doctor check rendered by the CLI diagnostics flow.
+ */
+export interface DoctorCheck {
+    /** Stable machine-readable diagnostic id for structured integrations. */
+    code?: string;
+    /** Human-readable status detail rendered next to the label. */
+    detail: string;
+    /** Short label for the dependency, directory, or template check. */
+    label: string;
+    /** Scope bucket used by machine-readable summaries and exit-code policies. */
+    scope?: DoctorCheckScope;
+    /** Final pass/fail/warn status for this diagnostic row. */
+    status: "pass" | "fail" | "warn";
+}
+/** One failed row classified against the active doctor exit policy. */
+export interface DoctorFailureSummary {
+    code?: string;
+    label: string;
+    scope: DoctorCheckScope | "unknown";
+    severity: "advisory" | "error";
+}
+/** Stable JSON summary for `wp-typia doctor --format json`. */
+export interface DoctorRunSummary {
+    advisoryFailureCount: number;
+    advisoryFailures: DoctorFailureSummary[];
+    exitCode: 0 | 1;
+    exitFailureCount: number;
+    exitFailures: DoctorFailureSummary[];
+    exitPolicy: DoctorExitPolicy;
+    failed: number;
+    passed: number;
+    total: number;
+    warnings: number;
+}
+interface RunDoctorOptions {
+    exitPolicy?: DoctorExitPolicy;
+    renderLine?: (check: DoctorCheck) => void;
+    renderSummaryLine?: (summaryLine: string) => void;
+}
+interface DoctorSummaryOptions {
+    exitPolicy?: DoctorExitPolicy;
+}
+/**
+ * Collect all runtime doctor checks for the current environment.
+ *
+ * The returned array concatenates environment checks (command availability,
+ * directory writability, and built-in template assets) followed by
+ * workspace checks (package metadata, inventory, blocks, variations,
+ * patterns, bindings, and optional migration hints) in display order.
+ *
+ * @param cwd Working directory to validate for writability.
+ * @returns Ordered doctor check rows ready for CLI rendering.
+ */
+export declare function getDoctorChecks(cwd: string): Promise<DoctorCheck[]>;
+/**
+ * Return failed rows that contribute to the process exit code for one policy.
+ */
+export declare function getDoctorExitFailureChecks(checks: readonly DoctorCheck[], options?: DoctorSummaryOptions): DoctorCheck[];
+/**
+ * Format only exit-contributing doctor failures for structured diagnostics.
+ */
+export declare function getDoctorExitFailureDetailLines(checks: readonly DoctorCheck[], options?: DoctorSummaryOptions): string[];
+/**
+ * Build the stable JSON summary for one doctor run.
+ */
+export declare function createDoctorRunSummary(checks: readonly DoctorCheck[], options?: DoctorSummaryOptions): DoctorRunSummary;
+/**
+ * Run doctor checks, render each line, and fail when one or more failed checks
+ * contribute to the exit code under the active exit policy.
+ *
+ * The default `strict` policy treats every failed row as exit-contributing.
+ * The `workspace-only` policy only fails on workspace-scoped rows so
+ * environment/runtime failures remain advisory for CI gates that only care
+ * about generated workspace artifacts.
+ *
+ * @param cwd Working directory to validate.
+ * @param options Optional renderer overrides and exit-policy selection.
+ * @param options.exitPolicy Policy deciding which failed checks contribute to the process exit code.
+ * @param options.renderLine Optional renderer for each check row. Defaults to the stdout line printer.
+ * @param options.renderSummaryLine Optional renderer for the summary row. Defaults to the stdout line printer unless a custom `renderLine` suppresses implicit summary output.
+ * @returns The completed list of doctor checks.
+ * @throws {Error} When one or more failed checks contribute to the exit code under the active policy.
+ */
+export declare function runDoctor(cwd: string, options?: RunDoctorOptions): Promise<DoctorCheck[]>;
+export {};

package/dist/runtime/doctor/cli-doctor.js

@@ -0,0 +1,130 @@
+import { CLI_DIAGNOSTIC_CODES, createCliCommandError, formatDoctorCheckLine, formatDoctorSummaryLine, } from "../cli/cli-diagnostics.js";
+import { getEnvironmentDoctorChecks } from "./cli-doctor-environment.js";
+import { getWorkspaceDoctorChecks } from "./cli-doctor-workspace.js";
+const DEFAULT_DOCTOR_EXIT_POLICY = "strict";
+const defaultDoctorLinePrinter = (line) => {
+    process.stdout.write(`${line}\n`);
+};
+function renderDefaultDoctorCheckLine(check) {
+    defaultDoctorLinePrinter(formatDoctorCheckLine(check));
+}
+function renderDefaultDoctorSummaryLine(summaryLine) {
+    defaultDoctorLinePrinter(summaryLine);
+}
+function annotateDoctorChecks(checks, scope) {
+    return checks.map((check) => ({
+        ...check,
+        scope: check.scope ?? scope,
+    }));
+}
+function resolveDoctorExitPolicy(options) {
+    return options.exitPolicy ?? DEFAULT_DOCTOR_EXIT_POLICY;
+}
+function doesCheckContributeToExit(check, exitPolicy) {
+    if (check.status !== "fail") {
+        return false;
+    }
+    if (exitPolicy === "strict") {
+        return true;
+    }
+    return check.scope === "workspace";
+}
+function toFailureSummary(check, severity) {
+    return {
+        ...(check.code ? { code: check.code } : {}),
+        label: check.label,
+        scope: check.scope ?? "unknown",
+        severity,
+    };
+}
+/**
+ * Collect all runtime doctor checks for the current environment.
+ *
+ * The returned array concatenates environment checks (command availability,
+ * directory writability, and built-in template assets) followed by
+ * workspace checks (package metadata, inventory, blocks, variations,
+ * patterns, bindings, and optional migration hints) in display order.
+ *
+ * @param cwd Working directory to validate for writability.
+ * @returns Ordered doctor check rows ready for CLI rendering.
+ */
+export async function getDoctorChecks(cwd) {
+    return [
+        ...annotateDoctorChecks(await getEnvironmentDoctorChecks(cwd), "environment"),
+        ...annotateDoctorChecks(await getWorkspaceDoctorChecks(cwd), "workspace"),
+    ];
+}
+/**
+ * Return failed rows that contribute to the process exit code for one policy.
+ */
+export function getDoctorExitFailureChecks(checks, options = {}) {
+    const exitPolicy = resolveDoctorExitPolicy(options);
+    return checks.filter((check) => doesCheckContributeToExit(check, exitPolicy));
+}
+/**
+ * Format only exit-contributing doctor failures for structured diagnostics.
+ */
+export function getDoctorExitFailureDetailLines(checks, options = {}) {
+    return getDoctorExitFailureChecks(checks, options).map((check) => `${check.label}: ${check.detail}`);
+}
+/**
+ * Build the stable JSON summary for one doctor run.
+ */
+export function createDoctorRunSummary(checks, options = {}) {
+    const exitPolicy = resolveDoctorExitPolicy(options);
+    const failedChecks = checks.filter((check) => check.status === "fail");
+    const exitFailureChecks = failedChecks.filter((check) => doesCheckContributeToExit(check, exitPolicy));
+    const advisoryFailureChecks = failedChecks.filter((check) => !doesCheckContributeToExit(check, exitPolicy));
+    const warnings = checks.filter((check) => check.status === "warn").length;
+    return {
+        advisoryFailureCount: advisoryFailureChecks.length,
+        advisoryFailures: advisoryFailureChecks.map((check) => toFailureSummary(check, "advisory")),
+        exitCode: exitFailureChecks.length > 0 ? 1 : 0,
+        exitFailureCount: exitFailureChecks.length,
+        exitFailures: exitFailureChecks.map((check) => toFailureSummary(check, "error")),
+        exitPolicy,
+        failed: failedChecks.length,
+        passed: checks.length - failedChecks.length - warnings,
+        total: checks.length,
+        warnings,
+    };
+}
+/**
+ * Run doctor checks, render each line, and fail when one or more failed checks
+ * contribute to the exit code under the active exit policy.
+ *
+ * The default `strict` policy treats every failed row as exit-contributing.
+ * The `workspace-only` policy only fails on workspace-scoped rows so
+ * environment/runtime failures remain advisory for CI gates that only care
+ * about generated workspace artifacts.
+ *
+ * @param cwd Working directory to validate.
+ * @param options Optional renderer overrides and exit-policy selection.
+ * @param options.exitPolicy Policy deciding which failed checks contribute to the process exit code.
+ * @param options.renderLine Optional renderer for each check row. Defaults to the stdout line printer.
+ * @param options.renderSummaryLine Optional renderer for the summary row. Defaults to the stdout line printer unless a custom `renderLine` suppresses implicit summary output.
+ * @returns The completed list of doctor checks.
+ * @throws {Error} When one or more failed checks contribute to the exit code under the active policy.
+ */
+export async function runDoctor(cwd, options = {}) {
+    const exitPolicy = resolveDoctorExitPolicy(options);
+    const renderLine = options.renderLine ?? renderDefaultDoctorCheckLine;
+    const renderSummaryLine = options.renderSummaryLine ??
+        (options.renderLine ? () => undefined : renderDefaultDoctorSummaryLine);
+    const checks = await getDoctorChecks(cwd);
+    for (const check of checks) {
+        renderLine(check);
+    }
+    const exitFailureChecks = getDoctorExitFailureChecks(checks, { exitPolicy });
+    renderSummaryLine(formatDoctorSummaryLine(checks, { exitFailureChecks }));
+    const failureDetailLines = getDoctorExitFailureDetailLines(checks, { exitPolicy });
+    if (failureDetailLines.length > 0) {
+        throw createCliCommandError({
+            code: CLI_DIAGNOSTIC_CODES.DOCTOR_CHECK_FAILED,
+            command: "doctor",
+            detailLines: failureDetailLines,
+            summary: "One or more doctor checks failed.",
+        });
+    }
+    return checks;
+}

package/dist/runtime/external-layer-selection.d.ts

@@ -1,20 +1 @@
-import { resolveTemplateSeed } from "./template-source.js";
-import { listSelectableExternalTemplateLayers, type SelectableExternalTemplateLayer } from "./template-layers.js";
-export interface ExternalLayerSelectionOption extends SelectableExternalTemplateLayer {
-}
-export interface ResolvedExternalLayerSelection {
-    cleanup?: () => Promise<void>;
-    externalLayerId?: string;
-    externalLayerSource?: string;
-}
-type ResolveExternalTemplateSeed = typeof resolveTemplateSeed;
-type ListExternalTemplateLayers = typeof listSelectableExternalTemplateLayers;
-export declare function resolveOptionalInteractiveExternalLayerId({ callerCwd, externalLayerId, externalLayerSource, listExternalTemplateLayers, resolveExternalTemplateSeed, selectExternalLayerId, }: {
-    callerCwd: string;
-    externalLayerId?: string;
-    externalLayerSource?: string;
-    listExternalTemplateLayers?: ListExternalTemplateLayers;
-    resolveExternalTemplateSeed?: ResolveExternalTemplateSeed;
-    selectExternalLayerId?: (options: ExternalLayerSelectionOption[]) => Promise<string>;
-}): Promise<ResolvedExternalLayerSelection>;
-export {};
+export * from "./templates/external-layer-selection.js";

package/dist/runtime/external-layer-selection.js

@@ -1,34 +1 @@
-import { parseTemplateLocator, resolveTemplateSeed, } from "./template-source.js";
-import { listSelectableExternalTemplateLayers, } from "./template-layers.js";
-export async function resolveOptionalInteractiveExternalLayerId({ callerCwd, externalLayerId, externalLayerSource, listExternalTemplateLayers = listSelectableExternalTemplateLayers, resolveExternalTemplateSeed = resolveTemplateSeed, selectExternalLayerId, }) {
-    if (!externalLayerSource || externalLayerId || !selectExternalLayerId) {
-        return {
-            externalLayerId,
-            externalLayerSource,
-        };
-    }
-    const layerSeed = await resolveExternalTemplateSeed(parseTemplateLocator(externalLayerSource), callerCwd);
-    try {
-        const selectableLayers = await listExternalTemplateLayers(layerSeed.rootDir);
-        if (selectableLayers.length <= 1) {
-            await layerSeed.cleanup?.();
-            return {
-                externalLayerId,
-                externalLayerSource,
-            };
-        }
-        const selectedLayerId = await selectExternalLayerId(selectableLayers);
-        if (selectableLayers.some((layer) => layer.id === selectedLayerId)) {
-            return {
-                cleanup: layerSeed.cleanup,
-                externalLayerId: selectedLayerId,
-                externalLayerSource: layerSeed.rootDir,
-            };
-        }
-        throw new Error(`Unknown external layer "${selectedLayerId}". Expected one of: ${selectableLayers.map((layer) => layer.id).join(", ")}`);
-    }
-    catch (error) {
-        await layerSeed.cleanup?.();
-        throw error;
-    }
-}
+export * from "./templates/external-layer-selection.js";

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

@@ -1,31 +1 @@
-export declare const TEMPLATE_SOURCE_TIMEOUT_CODE: "template-source-timeout";
-export declare const TEMPLATE_SOURCE_TOO_LARGE_CODE: "template-source-too-large";
-export declare function getExternalTemplateTimeoutMs(): number;
-export declare function getExternalTemplateConfigMaxBytes(): number;
-export declare function getExternalTemplatePackageJsonMaxBytes(): number;
-export declare function getExternalTemplateMetadataMaxBytes(): number;
-export declare function getExternalTemplateTarballMaxBytes(): number;
-export declare function createExternalTemplateTimeoutError(label: string, timeoutMs: number): Error & {
-    code: typeof TEMPLATE_SOURCE_TIMEOUT_CODE;
-};
-export declare function createExternalTemplateTooLargeError(label: string, maxBytes: number): Error & {
-    code: typeof TEMPLATE_SOURCE_TOO_LARGE_CODE;
-};
-export declare function assertExternalTemplateFileSize(filePath: string, options: {
-    label: string;
-    maxBytes: number;
-}): void;
-export declare function withExternalTemplateTimeout<T>(label: string, task: Promise<T> | (() => Promise<T>), timeoutMs?: number): Promise<T>;
-export declare function fetchWithExternalTemplateTimeout(input: string, options: {
-    init?: RequestInit;
-    label: string;
-    timeoutMs?: number;
-}): Promise<Response>;
-export declare function readJsonResponseWithLimit(response: Response, options: {
-    label: string;
-    maxBytes: number;
-}): Promise<Record<string, unknown>>;
-export declare function readBufferResponseWithLimit(response: Response, options: {
-    label: string;
-    maxBytes: number;
-}): Promise<Buffer>;
+export * from "./templates/external-template-guards.js";

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

@@ -1,130 +1 @@
-import fs from "node:fs";
-import { safeJsonParse } from "./json-utils.js";
-export const TEMPLATE_SOURCE_TIMEOUT_CODE = "template-source-timeout";
-export const TEMPLATE_SOURCE_TOO_LARGE_CODE = "template-source-too-large";
-const DEFAULT_EXTERNAL_TEMPLATE_TIMEOUT_MS = 20000;
-const DEFAULT_EXTERNAL_TEMPLATE_CONFIG_MAX_BYTES = 256 * 1024;
-const DEFAULT_EXTERNAL_TEMPLATE_PACKAGE_JSON_MAX_BYTES = 1 * 1024 * 1024;
-const DEFAULT_EXTERNAL_TEMPLATE_METADATA_MAX_BYTES = 1 * 1024 * 1024;
-const DEFAULT_EXTERNAL_TEMPLATE_TARBALL_MAX_BYTES = 32 * 1024 * 1024;
-function parsePositiveIntegerEnv(value, fallback) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        return fallback;
-    }
-    const parsed = Number.parseInt(value, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function createTemplateGuardError(code, message) {
-    const error = new Error(message);
-    error.code = code;
-    return error;
-}
-export function getExternalTemplateTimeoutMs() {
-    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_TIMEOUT_MS, DEFAULT_EXTERNAL_TEMPLATE_TIMEOUT_MS);
-}
-export function getExternalTemplateConfigMaxBytes() {
-    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_CONFIG_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_CONFIG_MAX_BYTES);
-}
-export function getExternalTemplatePackageJsonMaxBytes() {
-    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_PACKAGE_JSON_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_PACKAGE_JSON_MAX_BYTES);
-}
-export function getExternalTemplateMetadataMaxBytes() {
-    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_METADATA_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_METADATA_MAX_BYTES);
-}
-export function getExternalTemplateTarballMaxBytes() {
-    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_TARBALL_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_TARBALL_MAX_BYTES);
-}
-export function createExternalTemplateTimeoutError(label, timeoutMs) {
-    return createTemplateGuardError(TEMPLATE_SOURCE_TIMEOUT_CODE, `Timed out while ${label} after ${timeoutMs}ms.`);
-}
-export function createExternalTemplateTooLargeError(label, maxBytes) {
-    return createTemplateGuardError(TEMPLATE_SOURCE_TOO_LARGE_CODE, `${label} exceeded the external template size limit (${maxBytes} bytes).`);
-}
-export function assertExternalTemplateFileSize(filePath, options) {
-    const stats = fs.statSync(filePath);
-    if (stats.size > options.maxBytes) {
-        throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
-    }
-}
-export async function withExternalTemplateTimeout(label, task, timeoutMs = getExternalTemplateTimeoutMs()) {
-    let timeoutHandle;
-    const timeoutPromise = new Promise((_, reject) => {
-        timeoutHandle = setTimeout(() => {
-            reject(createExternalTemplateTimeoutError(label, timeoutMs));
-        }, timeoutMs);
-    });
-    try {
-        const pendingTask = typeof task === "function" ? task() : task;
-        return await Promise.race([pendingTask, timeoutPromise]);
-    }
-    finally {
-        if (timeoutHandle) {
-            clearTimeout(timeoutHandle);
-        }
-    }
-}
-export async function fetchWithExternalTemplateTimeout(input, options) {
-    const controller = new AbortController();
-    const timeoutMs = options.timeoutMs ?? getExternalTemplateTimeoutMs();
-    const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await fetch(input, {
-            ...(options.init ?? {}),
-            signal: controller.signal,
-        });
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            (error.name === "AbortError" || error.name === "TimeoutError")) {
-            throw createExternalTemplateTimeoutError(options.label, timeoutMs);
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeoutHandle);
-    }
-}
-async function readResponseBodyWithLimit(response, options) {
-    const contentLengthHeader = response.headers.get("content-length");
-    if (typeof contentLengthHeader === "string") {
-        const declaredLength = Number.parseInt(contentLengthHeader, 10);
-        if (Number.isFinite(declaredLength) && declaredLength > options.maxBytes) {
-            throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
-        }
-    }
-    if (!response.body) {
-        const buffer = Buffer.from(await response.arrayBuffer());
-        if (buffer.length > options.maxBytes) {
-            throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
-        }
-        return buffer;
-    }
-    const reader = response.body.getReader();
-    const chunks = [];
-    let totalBytes = 0;
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        }
-        if (!value) {
-            continue;
-        }
-        totalBytes += value.byteLength;
-        if (totalBytes > options.maxBytes) {
-            await reader.cancel();
-            throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
-        }
-        chunks.push(Buffer.from(value));
-    }
-    return Buffer.concat(chunks);
-}
-export async function readJsonResponseWithLimit(response, options) {
-    const buffer = await readResponseBodyWithLimit(response, options);
-    return safeJsonParse(buffer.toString("utf8"), {
-        context: options.label,
-    });
-}
-export async function readBufferResponseWithLimit(response, options) {
-    return readResponseBodyWithLimit(response, options);
-}
+export * from "./templates/external-template-guards.js";