wp-typia 0.24.4 → 0.24.6

package/dist-bunli/cli-init-7avk42dh.js

@@ -1,880 +0,0 @@
-// @bun
-import {
-  getPackageVersions
-} from "./cli-84c7wff4.js";
-import"./cli-8hxf9qw6.js";
-import {
-  discoverMigrationInitLayout
-} from "./cli-e4bwd81c.js";
-import {
-  quoteTsString,
-  require_typescript,
-  rollbackWorkspaceMutation,
-  snapshotWorkspaceFiles,
-  toPascalCase,
-  updateWorkspaceInventorySource
-} from "./cli-fv4h3ydt.js";
-import"./cli-cvxvcw7c.js";
-import"./cli-bajwv85z.js";
-import {
-  CLI_DIAGNOSTIC_CODES,
-  createCliDiagnosticCodeError
-} from "./cli-tq730sqt.js";
-import {
-  parseWorkspacePackageManagerId,
-  tryResolveWorkspaceProject
-} from "./cli-1170yyve.js";
-import {
-  formatAddDevDependenciesCommand,
-  formatPackageExecCommand,
-  formatRunScript,
-  getPackageManager,
-  transformPackageManagerText
-} from "./cli-am5x7tb4.js";
-import {
-  readJsonFileSync
-} from "./cli-ccax7s0s.js";
-import {
-  __toESM
-} from "./cli-xnn9xjcy.js";
-
-// ../wp-typia-project-tools/src/runtime/cli-init-apply.ts
-import fs3 from "fs";
-import { promises as fsp } from "fs";
-import path4 from "path";
-
-// ../wp-typia-project-tools/src/runtime/cli-init-package-json.ts
-import fs from "fs";
-import path from "path";
-var BASE_RETROFIT_SCRIPTS = {
-  sync: "tsx scripts/sync-project.ts",
-  "sync-types": "tsx scripts/sync-types-to-block-json.ts",
-  typecheck: "bun run sync --check && tsc --noEmit"
-};
-var BASE_RETROFIT_DEV_DEPENDENCIES = [
-  "@typia/unplugin",
-  "@wp-typia/block-runtime",
-  "@wp-typia/block-types",
-  "tsx",
-  "typescript",
-  "typia"
-];
-function readProjectPackageJson(projectDir) {
-  const packageJsonPath = path.join(projectDir, "package.json");
-  if (!fs.existsSync(packageJsonPath)) {
-    return null;
-  }
-  try {
-    return readJsonFileSync(packageJsonPath, {
-      context: "project package manifest"
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to parse ${packageJsonPath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
-  }
-}
-function inferInitPackageManager(projectDir, packageJson) {
-  if (packageJson?.packageManager) {
-    return parseWorkspacePackageManagerId(packageJson.packageManager);
-  }
-  if (fs.existsSync(path.join(projectDir, "bun.lock")) || fs.existsSync(path.join(projectDir, "bun.lockb"))) {
-    return "bun";
-  }
-  if (fs.existsSync(path.join(projectDir, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (fs.existsSync(path.join(projectDir, "yarn.lock")) || fs.existsSync(path.join(projectDir, ".yarnrc.yml"))) {
-    return "yarn";
-  }
-  return "npm";
-}
-function resolveInitPackageManager(projectDir, packageJson, override) {
-  if (!override) {
-    return inferInitPackageManager(projectDir, packageJson);
-  }
-  if (override !== "bun" && override !== "npm" && override !== "pnpm" && override !== "yarn") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unknown package manager "${override}". Expected one of: bun, npm, pnpm, yarn.`);
-  }
-  return override;
-}
-function getWpTypiaCliSpecifier() {
-  const versions = getPackageVersions();
-  return versions.wpTypiaPackageExactVersion === "0.0.0" ? "wp-typia" : `wp-typia@${versions.wpTypiaPackageExactVersion}`;
-}
-function buildRequiredDevDependencyMap() {
-  const versions = getPackageVersions();
-  return {
-    "@typia/unplugin": versions.typiaUnpluginPackageVersion,
-    "@wp-typia/block-runtime": versions.blockRuntimePackageVersion,
-    "@wp-typia/block-types": versions.blockTypesPackageVersion,
-    tsx: versions.tsxPackageVersion,
-    typescript: versions.typescriptPackageVersion,
-    typia: versions.typiaPackageVersion
-  };
-}
-function getExistingDependencyVersion(packageJson, name) {
-  return packageJson?.devDependencies?.[name] ?? packageJson?.dependencies?.[name];
-}
-function buildDependencyChanges(packageJson) {
-  const requiredDependencies = buildRequiredDevDependencyMap();
-  return BASE_RETROFIT_DEV_DEPENDENCIES.flatMap((name) => {
-    const requiredValue = requiredDependencies[name];
-    const currentValue = getExistingDependencyVersion(packageJson, name);
-    if (currentValue === requiredValue) {
-      return [];
-    }
-    return [
-      {
-        action: currentValue ? "update" : "add",
-        ...currentValue ? { currentValue } : {},
-        name,
-        requiredValue
-      }
-    ];
-  });
-}
-function buildScriptChanges(packageJson, packageManager) {
-  const scripts = packageJson?.scripts ?? {};
-  return Object.entries(BASE_RETROFIT_SCRIPTS).flatMap(([name, commandSource]) => {
-    const requiredValue = transformPackageManagerText(commandSource, packageManager);
-    const currentValue = scripts[name];
-    if (currentValue === requiredValue) {
-      return [];
-    }
-    return [
-      {
-        action: typeof currentValue === "string" ? "update" : "add",
-        ...typeof currentValue === "string" ? { currentValue } : {},
-        name,
-        requiredValue
-      }
-    ];
-  });
-}
-function buildPackageManagerFieldChange(packageJson, packageManager, options = {}) {
-  if (!options.persistExplicitOverride && packageManager === "npm") {
-    return;
-  }
-  const requiredValue = getPackageManager(packageManager).packageManagerField;
-  const currentValue = packageJson?.packageManager;
-  if (currentValue === requiredValue) {
-    return;
-  }
-  return {
-    action: typeof currentValue === "string" ? "update" : "add",
-    ...typeof currentValue === "string" ? { currentValue } : {},
-    requiredValue
-  };
-}
-function hasExistingWpTypiaProjectSurface(projectDir, packageJson) {
-  const scripts = packageJson?.scripts ?? {};
-  const hasSyncSurface = typeof scripts.sync === "string" || typeof scripts["sync-types"] === "string";
-  const hasHelperFiles = [
-    path.join("scripts", "block-config.ts"),
-    path.join("scripts", "sync-project.ts"),
-    path.join("scripts", "sync-types-to-block-json.ts")
-  ].every((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
-  const hasRuntimeDeps = typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-runtime") === "string" && typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-types") === "string";
-  return hasSyncSurface && hasHelperFiles && hasRuntimeDeps;
-}
-function buildRequiredDevDependencyMapEntries() {
-  return Object.entries(buildRequiredDevDependencyMap()).map(([name, version]) => `${name}@${version.replace(/^workspace:/u, "")}`);
-}
-function setDependencyVersion(packageJson, name, requiredValue) {
-  if (packageJson.devDependencies?.[name] !== undefined) {
-    packageJson.devDependencies[name] = requiredValue;
-    return;
-  }
-  if (packageJson.dependencies?.[name] !== undefined) {
-    packageJson.dependencies[name] = requiredValue;
-    return;
-  }
-  packageJson.devDependencies ??= {};
-  packageJson.devDependencies[name] = requiredValue;
-}
-function buildNextProjectPackageJson(options) {
-  const nextPackageJson = options.packageJson ? JSON.parse(JSON.stringify(options.packageJson)) : {
-    name: options.projectName,
-    private: true
-  };
-  nextPackageJson.devDependencies ??= {};
-  nextPackageJson.scripts ??= {};
-  for (const dependencyChange of options.packageChanges.addDevDependencies) {
-    setDependencyVersion(nextPackageJson, dependencyChange.name, dependencyChange.requiredValue);
-  }
-  if (options.packageChanges.packageManagerField) {
-    nextPackageJson.packageManager = options.packageChanges.packageManagerField.requiredValue;
-  } else if (!nextPackageJson.packageManager && options.packageManager !== "npm") {
-    nextPackageJson.packageManager = getPackageManager(options.packageManager).packageManagerField;
-  }
-  for (const scriptChange of options.packageChanges.scripts) {
-    nextPackageJson.scripts[scriptChange.name] = scriptChange.requiredValue;
-  }
-  return nextPackageJson;
-}
-function buildProjectPackageJsonSource(packageJson) {
-  return `${JSON.stringify(packageJson, null, 2)}
-`;
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-init-plan.ts
-var import_typescript = __toESM(require_typescript(), 1);
-import fs2 from "fs";
-import path2 from "path";
-import { analyzeSourceTypes } from "@wp-typia/block-runtime/metadata-parser";
-
-// ../wp-typia-project-tools/src/runtime/cli-init-plan-presentation.ts
-function buildInitPlanChangeSummary(changes, options) {
-  const lines = [];
-  for (const dependencyChange of changes.packageChanges.addDevDependencies) {
-    lines.push(`devDependency ${dependencyChange.action} ${dependencyChange.name} -> ${dependencyChange.requiredValue}`);
-  }
-  if (changes.packageChanges.packageManagerField) {
-    lines.push(`packageManager ${changes.packageChanges.packageManagerField.action} -> ${changes.packageChanges.packageManagerField.requiredValue}`);
-  }
-  for (const scriptChange of changes.packageChanges.scripts) {
-    lines.push(`script ${scriptChange.action} ${scriptChange.name} -> ${scriptChange.requiredValue}`);
-  }
-  for (const filePlan of changes.plannedFiles) {
-    lines.push(`file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`);
-  }
-  if (options.includeGeneratedArtifacts) {
-    for (const artifactPath of changes.generatedArtifacts) {
-      lines.push(`generated artifact ${artifactPath}`);
-    }
-  }
-  return lines;
-}
-function buildInitPlanNextSteps(options) {
-  const cliSpecifier = getWpTypiaCliSpecifier();
-  const syncTypesRun = formatRunScript(options.packageManager, "sync-types");
-  const syncRun = formatRunScript(options.packageManager, "sync");
-  const doctorRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "doctor");
-  const migrationInitRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "migrate init --current-migration-version v1");
-  const dependencyInstallCommand = formatAddDevDependenciesCommand(options.packageManager, buildRequiredDevDependencyMapEntries());
-  if (options.layoutKind === "unsupported") {
-    return [
-      "Align the project to one of the supported retrofit layouts listed below, then rerun `wp-typia init`.",
-      dependencyInstallCommand,
-      syncTypesRun,
-      doctorRun
-    ];
-  }
-  if (options.commandMode === "apply") {
-    return [
-      ...options.dependencyChangeCount > 0 ? [
-        "Install or reinstall project dependencies so the retrofit sync scripts and metadata generators are available locally.",
-        dependencyInstallCommand
-      ] : [],
-      syncRun,
-      doctorRun,
-      `Optional migration bootstrap: ${migrationInitRun}`
-    ];
-  }
-  return [
-    ...options.hasPlannedChanges ? [
-      "Re-run `wp-typia init --apply` to write the planned package.json changes and helper files automatically.",
-      ...options.dependencyChangeCount > 0 ? [dependencyInstallCommand] : []
-    ] : [],
-    syncRun,
-    doctorRun,
-    `Optional migration bootstrap: ${migrationInitRun}`
-  ];
-}
-function buildRetrofitPlanSummary(options) {
-  if (options.status === "already-initialized") {
-    return options.commandMode === "apply" ? "This project already exposes the minimum wp-typia retrofit surface. No files were changed." : "This project already exposes the minimum wp-typia retrofit surface.";
-  }
-  if (options.commandMode === "apply") {
-    return "Applied the minimum wp-typia retrofit surface so package.json and helper scripts are ready for the next install and sync run.";
-  }
-  return "This command previews the minimum wp-typia adoption layer for the current project without rewriting it into a full scaffold.";
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-init-types.ts
-var SUPPORTED_RETROFIT_LAYOUT_NOTE = "Supported retrofit layouts currently mirror the migration bootstrap detector: `src/block.json` + `src/types.ts` + `src/save.tsx`, legacy root `block.json` + `src/types.ts` + `src/save.tsx`, or multi-block `src/blocks/*/block.json` workspaces.";
-var RETROFIT_APPLY_PREVIEW_NOTE = "If you rerun with `wp-typia init --apply`, package.json and generated helper files are snapshotted and rolled back automatically if a write fails.";
-var RETROFIT_ROLLBACK_NOTE = "Apply mode writes package.json and generated helper files with rollback-on-failure protection.";
-
-// ../wp-typia-project-tools/src/runtime/cli-init-plan.ts
-function normalizeRelativePath(value) {
-  return value.replace(/\\/gu, "/");
-}
-function buildGeneratedArtifactPaths(blockJsonFile, manifestFile) {
-  const manifestDir = path2.dirname(manifestFile);
-  const artifactPaths = [
-    blockJsonFile,
-    manifestFile,
-    path2.join(manifestDir, "typia.schema.json"),
-    path2.join(manifestDir, "typia-validator.php"),
-    path2.join(manifestDir, "typia.openapi.json")
-  ];
-  return Array.from(new Set(artifactPaths.map((filePath) => normalizeRelativePath(filePath))));
-}
-function collectNamedSourceTypeCandidates(typesSource) {
-  const sourceFile = import_typescript.default.createSourceFile("types.ts", typesSource, import_typescript.default.ScriptTarget.Latest, true, import_typescript.default.ScriptKind.TS);
-  return sourceFile.statements.flatMap((statement) => {
-    if (import_typescript.default.isInterfaceDeclaration(statement) || import_typescript.default.isTypeAliasDeclaration(statement)) {
-      return [statement.name.text];
-    }
-    return [];
-  });
-}
-function isObjectLikeSourceType(projectDir, typesFile, sourceTypeName) {
-  const analyzedTypes = analyzeSourceTypes({
-    projectRoot: projectDir,
-    typesFile
-  }, [sourceTypeName]);
-  return analyzedTypes[sourceTypeName]?.kind === "object";
-}
-function inferRetrofitAttributeTypeName(projectDir, block) {
-  const typesPath = path2.join(projectDir, block.typesFile);
-  const typesSource = fs2.readFileSync(typesPath, "utf8");
-  const blockNameSegments = block.blockName.split("/");
-  const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
-  const candidateNames = collectNamedSourceTypeCandidates(typesSource);
-  const validCandidates = candidateNames.filter((candidateName) => isObjectLikeSourceType(projectDir, block.typesFile, candidateName));
-  const preferredName = `${toPascalCase(slug)}Attributes`;
-  if (validCandidates.includes(preferredName)) {
-    return preferredName;
-  }
-  const attributeCandidates = validCandidates.filter((candidateName) => candidateName.endsWith("Attributes"));
-  if (attributeCandidates.length === 1) {
-    return attributeCandidates[0];
-  }
-  if (validCandidates.length === 1) {
-    return validCandidates[0];
-  }
-  if (validCandidates.length === 0) {
-    throw new Error(`Unable to infer an object-like source type from ${block.typesFile}. Add one interface or type alias such as ${preferredName} before rerunning \`wp-typia init\`.`);
-  }
-  throw new Error(`Unable to infer a unique source type from ${block.typesFile}. Candidate object-like exports: ${validCandidates.join(", ")}. Rename one to ${preferredName} or leave a single object-like attributes type before rerunning \`wp-typia init\`.`);
-}
-function buildRetrofitBlockTarget(projectDir, block) {
-  const blockNameSegments = block.blockName.split("/");
-  const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
-  return {
-    attributeTypeName: inferRetrofitAttributeTypeName(projectDir, block),
-    blockJsonFile: block.blockJsonFile,
-    blockName: block.blockName,
-    manifestFile: block.manifestFile,
-    saveFile: block.saveFile,
-    slug,
-    typesFile: block.typesFile
-  };
-}
-function buildInitLayoutDetails(projectDir) {
-  try {
-    const discoveredLayout = discoverMigrationInitLayout(projectDir);
-    const discoveredBlocks = discoveredLayout.mode === "multi" ? discoveredLayout.blocks : [discoveredLayout.block];
-    let blockTargets;
-    try {
-      blockTargets = discoveredBlocks.map((block) => buildRetrofitBlockTarget(projectDir, block));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        blockNames: discoveredBlocks.map((block) => block.blockName),
-        blockTargets: [],
-        description: "Detected supported block files, but could not infer retrofit block-config metadata automatically yet.",
-        generatedArtifacts: [],
-        kind: "unsupported",
-        notes: [message, SUPPORTED_RETROFIT_LAYOUT_NOTE]
-      };
-    }
-    if (discoveredLayout.mode === "multi") {
-      return {
-        blockNames: discoveredBlocks.map((block) => block.blockName),
-        blockTargets,
-        description: `Detected a supported multi-block retrofit candidate (${discoveredBlocks.length} targets).`,
-        generatedArtifacts: discoveredBlocks.flatMap((block) => buildGeneratedArtifactPaths(block.blockJsonFile, block.manifestFile)),
-        kind: "multi-block",
-        notes: [
-          "Migration bootstrap can stay optional. Add it later with `wp-typia migrate init --current-migration-version v1` once the typed sync surface is in place."
-        ]
-      };
-    }
-    return {
-      blockNames: [discoveredLayout.block.blockName],
-      blockTargets,
-      description: "Detected a supported single-block retrofit candidate.",
-      generatedArtifacts: buildGeneratedArtifactPaths(discoveredLayout.block.blockJsonFile, discoveredLayout.block.manifestFile),
-      kind: "single-block",
-      notes: discoveredLayout.block.blockJsonFile === "block.json" ? [
-        "Legacy root `block.json` layouts are still supported for retrofit planning, but newer scaffolds keep generated block metadata under `src/`."
-      ] : []
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      blockNames: [],
-      blockTargets: [],
-      description: "No supported retrofit layout was auto-detected yet.",
-      generatedArtifacts: [],
-      kind: "unsupported",
-      notes: [message, SUPPORTED_RETROFIT_LAYOUT_NOTE]
-    };
-  }
-}
-function buildPlannedFiles(projectDir, layoutKind) {
-  if (layoutKind === "unsupported") {
-    return [];
-  }
-  return [
-    {
-      action: fs2.existsSync(path2.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
-      path: "scripts/block-config.ts",
-      purpose: "Declare the current retrofit block targets so sync-types can regenerate metadata from the existing TypeScript source of truth."
-    },
-    {
-      action: fs2.existsSync(path2.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
-      path: "scripts/sync-types-to-block-json.ts",
-      purpose: "Generate block.json and Typia metadata artifacts from the current TypeScript source of truth."
-    },
-    {
-      action: fs2.existsSync(path2.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
-      path: "scripts/sync-project.ts",
-      purpose: "Provide one shared sync entrypoint that can grow into sync-rest or workspace-aware refresh steps later."
-    }
-  ];
-}
-function createRetrofitPlan(options) {
-  const includeGeneratedArtifacts = options.commandMode === "preview-only";
-  const plannedChanges = buildInitPlanChangeSummary({
-    generatedArtifacts: options.generatedArtifacts,
-    packageChanges: options.packageChanges,
-    plannedFiles: options.plannedFiles
-  }, {
-    includeGeneratedArtifacts
-  });
-  return {
-    blockTargets: options.blockTargets,
-    commandMode: options.commandMode,
-    detectedLayout: options.detectedLayout,
-    generatedArtifacts: options.generatedArtifacts,
-    nextSteps: options.nextSteps ?? buildInitPlanNextSteps({
-      commandMode: options.commandMode,
-      dependencyChangeCount: options.packageChanges.addDevDependencies.length,
-      hasPlannedChanges: plannedChanges.length > 0,
-      layoutKind: options.detectedLayout.kind,
-      packageManager: options.packageManager
-    }),
-    notes: options.notes,
-    packageChanges: options.packageChanges,
-    plannedFiles: options.plannedFiles,
-    packageManager: options.packageManager,
-    projectDir: options.projectDir,
-    projectName: options.projectName,
-    status: options.status,
-    summary: buildRetrofitPlanSummary({
-      commandMode: options.commandMode,
-      status: options.status
-    })
-  };
-}
-function getInitPlan(projectDir, options = {}) {
-  const resolvedProjectDir = path2.resolve(projectDir);
-  const packageJson = readProjectPackageJson(resolvedProjectDir);
-  const packageManager = resolveInitPackageManager(resolvedProjectDir, packageJson, options.packageManager);
-  const workspace = tryResolveWorkspaceProject(resolvedProjectDir);
-  if (workspace) {
-    const workspacePackageJson = readProjectPackageJson(workspace.projectDir);
-    const workspacePackageManager = resolveInitPackageManager(workspace.projectDir, workspacePackageJson, options.packageManager);
-    const cliSpecifier = getWpTypiaCliSpecifier();
-    return createRetrofitPlan({
-      blockTargets: [],
-      commandMode: "preview-only",
-      detectedLayout: {
-        blockNames: [],
-        description: "Already an official wp-typia workspace.",
-        kind: "official-workspace"
-      },
-      generatedArtifacts: [],
-      nextSteps: [
-        "Use `wp-typia add <kind> <name>` to extend the official workspace instead of rerunning init.",
-        formatRunScript(workspacePackageManager, "sync"),
-        formatPackageExecCommand(workspacePackageManager, cliSpecifier, "doctor")
-      ],
-      notes: [
-        "The official workspace template already owns inventory, doctor, and add-command workflows."
-      ],
-      packageChanges: {
-        addDevDependencies: [],
-        scripts: []
-      },
-      packageManager: workspacePackageManager,
-      plannedFiles: [],
-      projectDir: workspace.projectDir,
-      projectName: workspace.packageName,
-      status: "already-initialized"
-    });
-  }
-  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path2.basename(resolvedProjectDir);
-  const layout = buildInitLayoutDetails(resolvedProjectDir);
-  const dependencyChanges = buildDependencyChanges(packageJson);
-  const scriptChanges = buildScriptChanges(packageJson, packageManager);
-  const packageManagerFieldChange = buildPackageManagerFieldChange(packageJson, packageManager, {
-    persistExplicitOverride: typeof options.packageManager === "string"
-  });
-  const rawPlannedFiles = layout.kind === "generated-project" || layout.kind === "official-workspace" ? [] : buildPlannedFiles(resolvedProjectDir, layout.kind);
-  const hasExistingSurface = hasExistingWpTypiaProjectSurface(resolvedProjectDir, packageJson);
-  const status = hasExistingSurface && dependencyChanges.length === 0 && scriptChanges.length === 0 && packageManagerFieldChange === undefined ? "already-initialized" : "preview";
-  const plannedFiles = status === "already-initialized" ? [] : rawPlannedFiles;
-  const detectedLayout = status === "already-initialized" && hasExistingSurface ? {
-    blockNames: layout.blockNames,
-    description: layout.kind === "unsupported" ? "Already exposes the minimum wp-typia sync surface." : `Already exposes the minimum wp-typia sync surface for ${layout.kind === "multi-block" ? "a multi-block project" : "a single-block project"}.`,
-    kind: "generated-project"
-  } : {
-    blockNames: layout.blockNames,
-    description: layout.description,
-    kind: layout.kind
-  };
-  return createRetrofitPlan({
-    blockTargets: layout.blockTargets,
-    commandMode: "preview-only",
-    detectedLayout,
-    generatedArtifacts: status === "already-initialized" && detectedLayout.kind === "generated-project" ? [] : layout.generatedArtifacts,
-    notes: Array.from(new Set([
-      "Preview only: `wp-typia init` does not write files yet.",
-      RETROFIT_APPLY_PREVIEW_NOTE,
-      ...layout.notes
-    ])),
-    packageChanges: {
-      addDevDependencies: dependencyChanges,
-      ...packageManagerFieldChange ? { packageManagerField: packageManagerFieldChange } : {},
-      scripts: scriptChanges
-    },
-    packageManager,
-    plannedFiles,
-    projectDir: resolvedProjectDir,
-    projectName,
-    status
-  });
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-init-templates.ts
-import path3 from "path";
-function buildRetrofitBlockConfigEntry(target) {
-  return [
-    "\t{",
-    `		slug: ${quoteTsString(target.slug)},`,
-    `		attributeTypeName: ${quoteTsString(target.attributeTypeName)},`,
-    `		blockJsonFile: ${quoteTsString(target.blockJsonFile)},`,
-    `		manifestFile: ${quoteTsString(target.manifestFile)},`,
-    `		typesFile: ${quoteTsString(target.typesFile)},`,
-    "\t},"
-  ].join(`
-`);
-}
-function buildRetrofitBlockConfigSource(targets) {
-  const blockEntries = targets.map(buildRetrofitBlockConfigEntry).join(`
-`);
-  const baseSource = `export interface WorkspaceBlockConfig {
-	attributeTypeName: string;
-	apiTypesFile?: string;
-	blockJsonFile?: string;
-	manifestFile?: string;
-	openApiFile?: string;
-	restManifest?: ReturnType<
-		typeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
-	>;
-	slug: string;
-	typesFile: string;
-}
-
-export const BLOCKS: WorkspaceBlockConfig[] = [
-${blockEntries}
-];
-`;
-  return `${updateWorkspaceInventorySource(baseSource)}
-`;
-}
-function buildRetrofitSyncTypesScriptSource() {
-  return `/* eslint-disable no-console */
-import path from 'node:path';
-
-import { syncBlockMetadata } from '@wp-typia/block-runtime/metadata-core';
-
-import { BLOCKS } from './block-config';
-
-function parseCliOptions( argv: string[] ) {
-	const options = {
-		check: false,
-	};
-
-	for ( const argument of argv ) {
-		if ( argument === '--check' ) {
-			options.check = true;
-			continue;
-		}
-
-		throw new Error( \`Unknown sync-types flag: \${ argument }\` );
-	}
-
-	return options;
-}
-
-async function main() {
-	const options = parseCliOptions( process.argv.slice( 2 ) );
-
-	if ( BLOCKS.length === 0 ) {
-		console.log(
-			options.check
-				? '\u2139\uFE0F No retrofit blocks are registered yet. \`sync-types --check\` is already clean.'
-				: '\u2139\uFE0F No retrofit blocks are registered yet. Add one block target to scripts/block-config.ts before rerunning sync-types.'
-		);
-		return;
-	}
-
-	for ( const block of BLOCKS ) {
-		const blockDir = path.dirname( block.typesFile );
-		const blockJsonFile =
-			block.blockJsonFile ?? path.join( blockDir, 'block.json' );
-		const manifestFile =
-			block.manifestFile ?? path.join( blockDir, 'typia.manifest.json' );
-		const manifestDir = path.dirname( manifestFile );
-		const result = await syncBlockMetadata(
-			{
-				blockJsonFile,
-				jsonSchemaFile: path.join( manifestDir, 'typia.schema.json' ),
-				manifestFile,
-				openApiFile: path.join( manifestDir, 'typia.openapi.json' ),
-				sourceTypeName: block.attributeTypeName,
-				typesFile: block.typesFile,
-			},
-			{
-				check: options.check,
-			}
-		);
-		for ( const warning of result.lossyProjectionWarnings ) {
-			console.warn( \`\u26A0\uFE0F \${ block.slug }: \${ warning }\` );
-		}
-		for ( const warning of result.phpGenerationWarnings ) {
-			console.warn( \`\u26A0\uFE0F \${ block.slug }: \${ warning }\` );
-		}
-
-		console.log(
-			options.check
-				? \`\u2705 \${ block.slug }: block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json are already up to date with the TypeScript types!\`
-				: \`\u2705 \${ block.slug }: block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json were generated from TypeScript types!\`
-		);
-		console.log( '\uD83D\uDCDD Generated attributes:', result.attributeNames );
-	}
-}
-
-main().catch( ( error ) => {
-	console.error( '\u274C Type sync failed:', error );
-	process.exit( 1 );
-} );
-`;
-}
-function buildRetrofitSyncProjectScriptSource() {
-  return `/* eslint-disable no-console */
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-
-interface SyncCliOptions {
-	check: boolean;
-}
-
-function parseCliOptions( argv: string[] ): SyncCliOptions {
-	const options: SyncCliOptions = {
-		check: false,
-	};
-
-	for ( const argument of argv ) {
-		if ( argument === '--check' ) {
-			options.check = true;
-			continue;
-		}
-
-		throw new Error( \`Unknown sync flag: \${ argument }\` );
-	}
-
-	return options;
-}
-
-function getSyncScriptEnv() {
-	const binaryDirectory = path.join( process.cwd(), 'node_modules', '.bin' );
-	const inheritedPath =
-		process.env.PATH ??
-		process.env.Path ??
-		Object.entries( process.env ).find(
-			( [ key ] ) => key.toLowerCase() === 'path'
-		)?.[ 1 ] ??
-		'';
-	const nextPath = fs.existsSync( binaryDirectory )
-		? \`\${ binaryDirectory }\${ path.delimiter }\${ inheritedPath }\`
-		: inheritedPath;
-	const env: NodeJS.ProcessEnv = {
-		...process.env,
-	};
-
-	for ( const key of Object.keys( env ) ) {
-		if ( key.toLowerCase() === 'path' ) {
-			delete env[ key ];
-		}
-	}
-
-	env.PATH = nextPath;
-
-	return env;
-}
-
-function getOptionalNodeErrorCode( error: unknown ): string | undefined {
-	return typeof error === 'object' && error !== null && 'code' in error
-		? String( ( error as { code: unknown } ).code )
-		: undefined;
-}
-
-function isFileNotFoundError( error: unknown ): boolean {
-	return getOptionalNodeErrorCode( error ) === 'ENOENT';
-}
-
-function runSyncScript( scriptPath: string, options: SyncCliOptions ) {
-	const args = [ scriptPath ];
-	if ( options.check ) {
-		args.push( '--check' );
-	}
-
-	const result = spawnSync( 'tsx', args, {
-		cwd: process.cwd(),
-		env: getSyncScriptEnv(),
-		shell: process.platform === 'win32',
-		stdio: 'inherit',
-	} );
-
-	if ( result.error ) {
-		if ( isFileNotFoundError( result.error ) ) {
-			throw new Error(
-				'Unable to resolve \`tsx\` for project sync. Install project dependencies or rerun the command through your package manager.'
-			);
-		}
-
-		throw result.error;
-	}
-
-	if ( result.status !== 0 ) {
-		throw new Error( \`Sync script failed: \${ scriptPath }\` );
-	}
-}
-
-async function main() {
-	const options = parseCliOptions( process.argv.slice( 2 ) );
-	const syncTypesScriptPath = path.join( 'scripts', 'sync-types-to-block-json.ts' );
-
-	runSyncScript( syncTypesScriptPath, options );
-
-	console.log(
-		options.check
-			? '\u2705 Generated project metadata is already synchronized.'
-			: '\u2705 Generated project metadata was synchronized.'
-	);
-}
-
-main().catch( ( error ) => {
-	console.error( '\u274C Project sync failed:', error );
-	process.exit( 1 );
-} );
-`;
-}
-function buildRetrofitHelperFiles(blockTargets) {
-  return {
-    [path3.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
-    [path3.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
-    [path3.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
-  };
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-init-apply.ts
-async function createRetrofitMutationSnapshot(projectDir, filePaths) {
-  const scriptsDir = path4.join(projectDir, "scripts");
-  const scriptsDirExisted = fs3.existsSync(scriptsDir);
-  const fileSources = await snapshotWorkspaceFiles(filePaths);
-  const targetPaths = fileSources.filter((entry) => entry.source === null).map((entry) => entry.filePath);
-  if (!scriptsDirExisted) {
-    targetPaths.push(scriptsDir);
-  }
-  return {
-    fileSources,
-    snapshotDirs: [],
-    targetPaths
-  };
-}
-async function writeRetrofitFiles(options) {
-  const helperFiles = buildRetrofitHelperFiles(options.blockTargets);
-  const scriptsDir = path4.join(options.projectDir, "scripts");
-  await fsp.mkdir(scriptsDir, { recursive: true });
-  await fsp.writeFile(path4.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
-  for (const [relativePath, source] of Object.entries(helperFiles)) {
-    await fsp.writeFile(path4.join(options.projectDir, relativePath), source, "utf8");
-  }
-}
-function buildApplyFailureError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to apply the retrofit init plan safely. The command restored the previous package.json/helper-file snapshot. ${message}`, error instanceof Error ? { cause: error } : undefined);
-}
-function toApplyNotes(previewNotes) {
-  return Array.from(new Set([
-    ...previewNotes.filter((note) => note !== "Preview only: `wp-typia init` does not write files yet." && note !== RETROFIT_APPLY_PREVIEW_NOTE),
-    RETROFIT_ROLLBACK_NOTE
-  ]));
-}
-async function applyInitPlan(projectDir, options = {}) {
-  const previewPlan = getInitPlan(projectDir, options);
-  if (previewPlan.detectedLayout.kind === "unsupported") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia init --apply` requires a supported retrofit layout. Run `wp-typia init` first to inspect the preview plan and any blocking notes.");
-  }
-  if (previewPlan.status === "already-initialized") {
-    return createRetrofitPlan({
-      ...previewPlan,
-      commandMode: "apply",
-      notes: toApplyNotes(previewPlan.notes),
-      status: "already-initialized"
-    });
-  }
-  const nextPackageJson = buildNextProjectPackageJson({
-    packageChanges: previewPlan.packageChanges,
-    packageJson: readProjectPackageJson(previewPlan.projectDir),
-    packageManager: previewPlan.packageManager,
-    projectName: previewPlan.projectName
-  });
-  const helperFiles = buildRetrofitHelperFiles(previewPlan.blockTargets);
-  const filePaths = [
-    path4.join(previewPlan.projectDir, "package.json"),
-    ...Object.keys(helperFiles).map((relativePath) => path4.join(previewPlan.projectDir, relativePath))
-  ];
-  const mutationSnapshot = await createRetrofitMutationSnapshot(previewPlan.projectDir, filePaths);
-  try {
-    await writeRetrofitFiles({
-      blockTargets: previewPlan.blockTargets,
-      packageJson: nextPackageJson,
-      projectDir: previewPlan.projectDir
-    });
-  } catch (error) {
-    await rollbackWorkspaceMutation(mutationSnapshot);
-    throw buildApplyFailureError(error);
-  }
-  return createRetrofitPlan({
-    ...previewPlan,
-    commandMode: "apply",
-    notes: toApplyNotes(previewPlan.notes),
-    status: "applied"
-  });
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-init.ts
-async function runInitCommand(options) {
-  return options.apply ? applyInitPlan(options.projectDir, {
-    packageManager: options.packageManager
-  }) : getInitPlan(options.projectDir, {
-    packageManager: options.packageManager
-  });
-}
-export {
-  runInitCommand,
-  getInitPlan,
-  applyInitPlan
-};
-
-//# debugId=DC4EACE5C620361164756E2164756E21