@primeuicom/mcp 1.1.1 → 1.2.1

package/dist/service.js

@@ -577,6 +577,30 @@ var primeUiExportPageSchema = z3.object({
   componentsPath: z3.string(),
   manifest: primeUiExportPageManifestSchema
 });
+var primeUiPostExportPayloadExportSchema = z3.object({
+  id: z3.string(),
+  status: primeUiExportStatusSchema,
+  createdAt: z3.string().datetime({ offset: true }),
+  expiresAt: z3.string().datetime({ offset: true }).nullable(),
+  summary: primeUiExportSummarySchema,
+  exportables: z3.array(primeUiExportedExportableSchema)
+});
+var primeUiComponentExportComponentSchema = z3.object({
+  componentId: z3.string(),
+  name: z3.string(),
+  pageType: z3.string(),
+  family: z3.string(),
+  defaultPropsAvailable: z3.boolean(),
+  isReadyToExport: z3.boolean()
+});
+var primeUiComponentExportPageSchema = z3.object({
+  id: z3.string(),
+  title: z3.string().optional(),
+  slug: z3.string(),
+  pageType: z3.string(),
+  isReadyToExport: z3.boolean(),
+  manifest: primeUiExportPageManifestSchema
+});
 var primeUiProjectInfoSchema = z3.object(
   {
     projectId: z3.string(),
@@ -654,6 +678,178 @@ var primeUiIssueReportSubmitResponseSchema = z3.object({
   accepted: z3.literal(true),
   ticketId: z3.string()
 });
+var nullableDateStringSchema = z3.string().nullable();
+var primeUiManagedSearchLastErrorSchema = z3.object({
+  at: nullableDateStringSchema,
+  code: z3.string().nullable(),
+  message: z3.string(),
+  scope: z3.enum(["project", "index", "job", "sync-run"])
+});
+var primeUiManagedSearchRuntimeModelSchema = z3.object({
+  additionalRuntimesSupported: z3.literal(true),
+  defaultRuntimeAutoWired: z3.literal(true),
+  defaultRuntimeSlug: z3.literal("prod"),
+  mode: z3.literal("runtime-first"),
+  panelCompatibility: z3.literal("disabled"),
+  stagingRuntimeAutoWired: z3.literal(false),
+  stagingRuntimeSlug: z3.literal("staging")
+});
+var primeUiManagedSearchRuntimeSchema = z3.object({
+  createdAt: z3.string(),
+  currentMeilisearchIndexUid: z3.string().nullable(),
+  currentQueryId: z3.string().nullable(),
+  id: z3.string(),
+  lastErrorSummary: z3.string().nullable(),
+  lastFailedSyncAt: nullableDateStringSchema,
+  lastSuccessfulSyncAt: nullableDateStringSchema,
+  name: z3.string(),
+  slug: z3.string(),
+  status: z3.enum([
+    "bootstrapping",
+    "active",
+    "indexing",
+    "failed",
+    "inactive"
+  ]),
+  updatedAt: z3.string()
+});
+var primeUiManagedSearchRootSchema = z3.object({
+  bootstrapCompletedAt: nullableDateStringSchema,
+  createdAt: nullableDateStringSchema,
+  defaultIndexId: z3.string().nullable(),
+  defaultSearchId: z3.string().nullable(),
+  enabled: z3.boolean(),
+  id: z3.string().nullable(),
+  lastErrorSummary: z3.string().nullable(),
+  lastFailedSyncAt: nullableDateStringSchema,
+  lastSuccessfulSyncAt: nullableDateStringSchema,
+  status: z3.enum(["inactive", "active", "degraded"]),
+  updatedAt: nullableDateStringSchema
+});
+var primeUiManagedSearchSourceSchema = z3.object({
+  activationMode: z3.enum(["auto-export", "manual"]),
+  configJson: z3.record(z3.unknown()),
+  createdAt: z3.string(),
+  id: z3.string(),
+  sourceKey: z3.string(),
+  sourceSnapshotJson: z3.record(z3.unknown()),
+  sourceType: z3.enum(["docs", "blog", "landing-pages"]),
+  status: z3.enum(["inactive", "active", "blocked"]),
+  updatedAt: z3.string()
+});
+var primeUiManagedSearchIndexSchema = z3.object({
+  createdAt: z3.string(),
+  documentCount: z3.number().int().nonnegative(),
+  id: z3.string(),
+  kind: z3.enum(["default-runtime", "custom"]),
+  lastErrorSummary: z3.string().nullable(),
+  lastFailedSyncAt: nullableDateStringSchema,
+  lastSuccessfulSyncAt: nullableDateStringSchema,
+  meilisearchIndexUid: z3.string().nullable(),
+  name: z3.string(),
+  publicSearchId: z3.string().nullable(),
+  queryRole: z3.enum(["default-runtime", "manual"]),
+  retiredAt: nullableDateStringSchema,
+  slug: z3.string(),
+  sourceSelectionJson: z3.record(z3.unknown()),
+  status: z3.enum(["inactive", "syncing", "ready", "failed", "degraded"]),
+  updatedAt: z3.string()
+});
+var primeUiManagedSearchJobSchema = z3.object({
+  attemptCount: z3.number().int().nonnegative(),
+  createdAt: z3.string(),
+  errorCode: z3.string().nullable(),
+  errorMessage: z3.string().nullable(),
+  finishedAt: nullableDateStringSchema,
+  id: z3.string(),
+  jobType: z3.enum(["sync", "reindex", "recover"]),
+  maxAttempts: z3.number().int().nonnegative(),
+  projectSearchIndexId: z3.string(),
+  requestedById: z3.string().nullable(),
+  requestedByType: z3.enum(["export", "studio-user", "cli", "system"]),
+  startedAt: nullableDateStringSchema,
+  state: z3.enum(["queued", "running", "succeeded", "failed", "cancelled"])
+});
+var primeUiManagedSearchSyncRunSchema = z3.object({
+  deletedDocumentCount: z3.number().int().nonnegative(),
+  durationMs: z3.number().int().nonnegative().nullable(),
+  errorSummary: z3.string().nullable(),
+  extractedDocumentCount: z3.number().int().nonnegative(),
+  finishedAt: nullableDateStringSchema,
+  id: z3.string(),
+  projectSearchIndexId: z3.string(),
+  projectSearchJobId: z3.string(),
+  startedAt: z3.string(),
+  status: z3.enum(["running", "succeeded", "failed", "cancelled"]),
+  writtenDocumentCount: z3.number().int().nonnegative()
+});
+var primeUiManagedSearchQueryProtectionSchema = z3.object({
+  enabled: z3.literal(true),
+  rateLimit: z3.object({
+    enabled: z3.literal(true),
+    windowMs: z3.number().int().positive(),
+    maxRequests: z3.number().int().positive(),
+    activeBucketCount: z3.number().int().nonnegative(),
+    limitedRequestCount: z3.number().int().nonnegative(),
+    recentLimitedAt: nullableDateStringSchema
+  }),
+  logging: z3.object({
+    enabled: z3.literal(true),
+    lastDayEventCount: z3.number().int().nonnegative(),
+    recentEventCount: z3.number().int().nonnegative(),
+    lastHourEventCount: z3.number().int().nonnegative(),
+    lastEventAt: nullableDateStringSchema
+  }),
+  cache: z3.object({
+    enabled: z3.literal(false),
+    ttlMs: z3.null(),
+    reason: z3.string()
+  })
+});
+var primeUiManagedSearchRelevanceSettingsSchema = z3.object({
+  displayedAttributes: z3.array(z3.string()),
+  facetSearch: z3.boolean(),
+  filterableAttributes: z3.array(z3.string()),
+  pagination: z3.object({
+    maxTotalHits: z3.number().int().positive()
+  }),
+  prefixSearch: z3.enum(["indexingTime", "disabled"]),
+  primaryKey: z3.string(),
+  proximityPrecision: z3.enum(["byWord", "byAttribute"]),
+  rankingRules: z3.array(z3.string()),
+  searchableAttributes: z3.array(z3.string()),
+  sortableAttributes: z3.array(z3.string()),
+  typoTolerance: z3.object({
+    disableOnAttributes: z3.array(z3.string()),
+    enabled: z3.boolean(),
+    minWordSizeForTypos: z3.object({
+      oneTypo: z3.number().int().positive(),
+      twoTypos: z3.number().int().positive()
+    })
+  })
+});
+var primeUiManagedSearchOverviewResponseSchema = z3.object({
+  customIndexes: z3.array(primeUiManagedSearchIndexSchema),
+  defaultIndex: primeUiManagedSearchIndexSchema.nullable(),
+  lastError: primeUiManagedSearchLastErrorSchema.nullable(),
+  projectId: z3.string(),
+  queryProtection: primeUiManagedSearchQueryProtectionSchema,
+  recentJobs: z3.array(primeUiManagedSearchJobSchema),
+  recentSyncRuns: z3.array(primeUiManagedSearchSyncRunSchema),
+  relevanceSettings: primeUiManagedSearchRelevanceSettingsSchema,
+  runtimeModel: primeUiManagedSearchRuntimeModelSchema,
+  runtimes: z3.array(primeUiManagedSearchRuntimeSchema),
+  search: primeUiManagedSearchRootSchema,
+  sources: z3.array(primeUiManagedSearchSourceSchema),
+  success: z3.literal(true)
+});
+var primeUiManagedSearchRuntimeMutationResponseSchema = z3.object({
+  success: z3.literal(true),
+  runtime: primeUiManagedSearchRuntimeSchema
+});
+var primeUiManagedSearchRuntimeDeleteResponseSchema = z3.object({
+  success: z3.literal(true)
+});
 var primeUiExportsResponseSchema = z3.object({
   exports: z3.array(
     z3.object({
@@ -664,17 +860,18 @@ var primeUiExportsResponseSchema = z3.object({
   )
 });
 var primeUiCreateExportResponseSchema = z3.object({
-  export: z3.object({
-    id: z3.string(),
-    status: primeUiExportStatusSchema,
-    createdAt: z3.string().datetime({ offset: true }),
-    expiresAt: z3.string().datetime({ offset: true }).nullable(),
-    summary: primeUiExportSummarySchema,
-    exportables: z3.array(primeUiExportedExportableSchema)
-  }),
+  export: primeUiPostExportPayloadExportSchema,
   pages: z3.array(primeUiExportPageSchema)
 });
 var primeUiExportManifestSchema = primeUiCreateExportResponseSchema;
+var primeUiComponentExportResponseSchema = z3.object({
+  exportId: z3.string(),
+  export: primeUiPostExportPayloadExportSchema,
+  component: primeUiComponentExportComponentSchema,
+  page: primeUiComponentExportPageSchema,
+  pages: z3.array(primeUiComponentExportPageSchema)
+});
+var primeUiComponentExportManifestSchema = primeUiComponentExportResponseSchema;
 function parsePrimeUiExportManifest(value) {
   if (!value || typeof value !== "object") {
     throw new Error("Export manifest is invalid.");
@@ -694,6 +891,22 @@ function parsePrimeUiExportManifest(value) {
   }
   return parsed.data;
 }
+function parsePrimeUiComponentExportManifest(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Component export manifest is invalid.");
+  }
+  const maybe = value;
+  if (!maybe.component || typeof maybe.component !== "object") {
+    throw new Error("Component export manifest component payload is invalid.");
+  }
+  const parsed = primeUiComponentExportManifestSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new Error(
+      `Component export manifest is invalid: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`
+    );
+  }
+  return parsed.data;
+}
 
 // src/lib/fs.ts
 import { mkdir, rm, writeFile } from "fs/promises";
@@ -882,6 +1095,49 @@ var ApiProjectDataProvider = class {
       this.buildJsonRequestInit(input)
     );
   }
+  async getSearchOverview() {
+    return this.requestJson(
+      "project/search",
+      primeUiManagedSearchOverviewResponseSchema
+    );
+  }
+  async createSearchEnvironment(params) {
+    return this.requestJson(
+      "project/search/runtimes",
+      primeUiManagedSearchRuntimeMutationResponseSchema,
+      this.buildJsonRequestInit(params)
+    );
+  }
+  async updateSearchEnvironment(params) {
+    return this.requestJson(
+      `project/search/runtimes/${encodeURIComponent(params.runtimeSlug)}`,
+      primeUiManagedSearchRuntimeMutationResponseSchema,
+      this.buildJsonRequestInit(
+        {
+          projectId: params.projectId,
+          ...params.name === void 0 ? {} : { name: params.name },
+          ...params.status === void 0 ? {} : { status: params.status }
+        },
+        {
+          method: "PATCH"
+        }
+      )
+    );
+  }
+  async deleteSearchEnvironment(params) {
+    return this.requestJson(
+      `project/search/runtimes/${encodeURIComponent(params.runtimeSlug)}`,
+      primeUiManagedSearchRuntimeDeleteResponseSchema,
+      this.buildJsonRequestInit(
+        {
+          projectId: params.projectId
+        },
+        {
+          method: "DELETE"
+        }
+      )
+    );
+  }
   async getProjectPageBySlug(slug) {
     const encodedSlug = encodeURIComponent(slug);
     return this.requestJson(
@@ -905,9 +1161,19 @@ var ApiProjectDataProvider = class {
       }
     );
   }
+  async createComponentExport(componentId) {
+    return this.requestJson(
+      `component-registry/components/${encodeURIComponent(componentId)}/exports`,
+      primeUiComponentExportResponseSchema,
+      {
+        method: "POST"
+      }
+    );
+  }
   /**
    * Consumer-side runtime contract for GET /api/v1/project/exports/:exportId/download.
-   * Producer source of truth: apps/studio/src/app/api/v1/project/exports/[exportId]/download/route.ts
+   * Primary Studio runtime entrypoint: apps/studio/src/tanstack/routes/api.v1.project.exports.$exportId.download.ts
+   * Legacy migration reference: apps/studio/src/app/api/v1/project/exports/[exportId]/download/route.ts
    * Keep content-type and archive format checks synchronized with the producer response.
    */
   async downloadExportArchive(exportId, destinationPath) {
@@ -951,10 +1217,12 @@ var ApiProjectDataProvider = class {
   buildUrl(endpoint) {
     return buildPrimeUiApiUrl(this.apiRoot, endpoint);
   }
-  buildJsonRequestInit(payload) {
+  buildJsonRequestInit(payload, overrides = {}) {
     return {
-      method: "POST",
+      ...overrides,
+      method: overrides.method ?? "POST",
       headers: {
+        ...overrides.headers ?? {},
         "Content-Type": "application/json"
       },
       body: JSON.stringify(payload)
@@ -1725,11 +1993,11 @@ async function runHealthCheck(options) {
 }
 
 // src/services/project-sync-service.ts
-import path13 from "path";
-import { readFile as readFile7 } from "fs/promises";
+import path14 from "path";
+import { readFile as readFile8 } from "fs/promises";
 
 // src/services/page-copy-service.ts
-import { readFile as readFile4, stat as stat6, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile4, stat as stat6, writeFile as writeFile3 } from "fs/promises";
 import path10 from "path";
 
 // src/lib/import-graph.ts
@@ -2011,7 +2279,7 @@ function buildUnifiedDiff(input) {
 }
 
 // src/services/copy-service-shared.ts
-import { readFile as readFile3, readdir as readdir2, stat as stat5 } from "fs/promises";
+import { readFile as readFile3, readdir as readdir2, stat as stat5, writeFile as writeFile2 } from "fs/promises";
 import path9 from "path";
 var DEPENDENCY_SECTIONS = [
   "dependencies",
@@ -2198,6 +2466,64 @@ async function resolveDependencyRequirements(input) {
     )
   };
 }
+async function applyDependencyRequirementsToPackageJson(input) {
+  const exportPackageJson = await readJsonFile(
+    input.exportPackageJsonPath
+  );
+  const userPackageJson = await readJsonFile(
+    input.userPackageJsonPath
+  );
+  const addedDependencies = [];
+  const dependenciesVersionConflicts = [];
+  for (const packageName of new Set(input.requiredPackageNames)) {
+    const exportDependency = getDependencyVersion(
+      exportPackageJson,
+      packageName
+    );
+    if (!exportDependency) {
+      continue;
+    }
+    const userDependency = getDependencyVersion(userPackageJson, packageName);
+    if (!userDependency) {
+      const sectionData = getOrCreateDependencySection(
+        userPackageJson,
+        exportDependency.section
+      );
+      sectionData[packageName] = exportDependency.version;
+      addedDependencies.push({
+        packageName,
+        version: exportDependency.version,
+        section: exportDependency.section
+      });
+      continue;
+    }
+    if (userDependency.version !== exportDependency.version) {
+      dependenciesVersionConflicts.push({
+        packageName,
+        section: exportDependency.section,
+        exportVersion: exportDependency.version,
+        userVersion: userDependency.version
+      });
+    }
+  }
+  if (addedDependencies.length > 0) {
+    sortDependencySections(userPackageJson);
+    await writeFile2(
+      input.userPackageJsonPath,
+      `${JSON.stringify(userPackageJson, null, 2)}
+`,
+      "utf-8"
+    );
+  }
+  return {
+    addedDependencies: addedDependencies.sort(
+      (a, b) => a.packageName.localeCompare(b.packageName)
+    ),
+    dependenciesVersionConflicts: dependenciesVersionConflicts.sort(
+      (a, b) => a.packageName.localeCompare(b.packageName)
+    )
+  };
+}
 
 // src/services/runtime-guidance.ts
 var EXPORT_MANIFEST_DESCRIPTION = "Local sidecar export manifest. This is the authoritative file-level contract for the selected transfer item. Files listed per page or exportable are functionality-critical dependencies for that item.";
@@ -2367,7 +2693,7 @@ async function copyPageFromExport(input) {
     const targetRelative = toProjectRelative(input.projectRoot, targetFilePath);
     if (!targetBuffer) {
       await ensureDir(path10.dirname(targetFilePath));
-      await writeFile2(targetFilePath, plannedSourceBuffer);
+      await writeFile3(targetFilePath, plannedSourceBuffer);
       newFiles.push(targetRelative);
       continue;
     }
@@ -2436,7 +2762,7 @@ async function copyPageFromExport(input) {
   }
   if (addedDependencies.length > 0) {
     sortDependencySections(userPackageJson);
-    await writeFile2(
+    await writeFile3(
       userPackageJsonPath,
       `${JSON.stringify(userPackageJson, null, 2)}
 `,
@@ -2472,7 +2798,7 @@ async function copyPageFromExport(input) {
     sourceComponentsPath: page.componentsPath,
     conflicts: sortedConflictReportEntries
   };
-  await writeFile2(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile3(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   const hasFileConflicts = conflictFiles.length > 0;
   const hasDependencyVersionConflicts = sortedDependenciesVersionConflicts.length > 0;
@@ -2622,7 +2948,7 @@ function buildInspectPageReport(input) {
 }
 
 // src/services/exportable-copy-service.ts
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import path11 from "path";
 var PACKAGE_JSON_RELATIVE_PATH = "package.json";
 var SUPPLEMENTARY_DEPENDENCY_PACKAGES = {
@@ -2768,7 +3094,7 @@ async function copyExportableFromExport(input) {
     const targetRelative = toProjectRelative(input.projectRoot, targetFilePath);
     if (!targetBuffer) {
       await ensureDir(path11.dirname(targetFilePath));
-      await writeFile3(targetFilePath, sourceBuffer);
+      await writeFile4(targetFilePath, sourceBuffer);
       newFiles.push(targetRelative);
       continue;
     }
@@ -2834,7 +3160,7 @@ async function copyExportableFromExport(input) {
     exportableKey: normalizedExportableKey,
     conflicts: sortedConflictReportEntries
   };
-  await writeFile3(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile4(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   const hasFileConflicts = conflictFiles.length > 0;
   const hasDependencyVersionConflicts = dependenciesVersionConflicts.length > 0;
@@ -2895,7 +3221,7 @@ async function copyExportableFromExport(input) {
 }
 
 // src/services/component-copy-service.ts
-import { readFile as readFile6, stat as stat7, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile6, stat as stat7, writeFile as writeFile5 } from "fs/promises";
 import path12 from "path";
 function normalizeSlug2(slug) {
   const trimmed = slug.trim();
@@ -3051,7 +3377,7 @@ async function applyDependencyRequirements(input) {
   }
   if (addedDependencies.length > 0) {
     sortDependencySections(userPackageJson);
-    await writeFile4(
+    await writeFile5(
       userPackageJsonPath,
       `${JSON.stringify(userPackageJson, null, 2)}
 `,
@@ -3215,7 +3541,7 @@ async function copyComponentFromExport(input) {
     }
     if (!targetBuffer) {
       await ensureDir(path12.dirname(targetPrimaryPath));
-      await writeFile4(targetPrimaryPath, sourceBuffer);
+      await writeFile5(targetPrimaryPath, sourceBuffer);
       newFiles.push(primaryComponentFile);
     } else if (sourceBuffer.equals(targetBuffer)) {
       identicalFiles.push(primaryComponentFile);
@@ -3319,7 +3645,7 @@ async function copyComponentFromExport(input) {
     potentialConflicts: sortedPotentialConflictEntries,
     selectedBlock
   };
-  await writeFile4(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile5(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   const needsReview = !primaryComponentFile || conflictFiles.length > 0 || dependenciesVersionConflicts.length > 0 || missingManifestFiles.size > 0;
   const missingManifestFileList = [...missingManifestFiles].sort(
@@ -3408,71 +3734,568 @@ async function copyComponentFromExport(input) {
   };
 }
 
-// src/services/project-sync-service.ts
-function buildManifestPath(exportsRoot, exportId) {
-  return path13.join(exportsRoot, `${exportId}.manifest.json`);
+// src/services/registry-component-copy-service.ts
+import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import path13 from "path";
+var PACKAGE_JSON_RELATIVE_PATH2 = "package.json";
+var VIRTUAL_ROUTE_SEGMENT = "__primeui-component-export";
+var COMPONENT_PAGES_PREFIX = "src/components/pages/";
+var COMPONENT_UI_PREFIX = "src/components/ui/";
+function normalizeComponentId(componentId) {
+  const trimmed = componentId.trim();
+  if (!trimmed) {
+    throw new Error("componentId must not be empty.");
+  }
+  return trimmed;
 }
-function normalizeSlug3(slug) {
-  const trimmed = slug.trim();
-  if (!trimmed || trimmed === "/") {
-    return "/";
+function normalizeManifestFilePath(filePath) {
+  const trimmed = filePath.trim();
+  if (!trimmed) {
+    throw new Error("Component export manifest contains an empty file path.");
   }
-  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-  return withLeadingSlash.replace(/\/+$/, "") || "/";
+  return toPosixPath(trimmed).replace(/^\.\/+/, "");
 }
-var ProjectSyncService = class {
-  provider;
-  projectRoot;
-  targetProjectRoot;
-  primeUiRoot;
-  tempRoot;
-  exportsRoot;
-  pageDetailsBySlug;
-  constructor(options) {
-    this.projectRoot = options.projectRoot;
-    this.targetProjectRoot = options.targetProjectRoot;
-    this.provider = options.provider;
-    this.pageDetailsBySlug = options.pageDetailsBySlug ?? /* @__PURE__ */ new Map();
-    this.primeUiRoot = path13.join(this.projectRoot, ".primeui");
-    this.tempRoot = path13.join(this.primeUiRoot, "temp");
-    this.exportsRoot = path13.join(this.tempRoot, "exports");
+function uniqueNormalizedManifestFiles(files) {
+  return [...new Set(files.map(normalizeManifestFilePath))];
+}
+function getSuccessfulExportableFiles(manifest) {
+  return manifest.export.exportables.flatMap(
+    (exportable) => exportable.isReadyToExport && exportable.manifest.success ? exportable.manifest.files : []
+  );
+}
+function getComponentCopyManifestFiles(manifest) {
+  return uniqueNormalizedManifestFiles([
+    ...manifest.page.manifest.files,
+    ...getSuccessfulExportableFiles(manifest)
+  ]);
+}
+function isVirtualRouteFile(relativePath) {
+  const segments = relativePath.split("/");
+  return segments[0] === "src" && segments[1] === "app" && segments.includes(VIRTUAL_ROUTE_SEGMENT);
+}
+function isComponentEntryFile(relativePath, componentId) {
+  if (!relativePath.startsWith(COMPONENT_PAGES_PREFIX)) {
+    return false;
   }
-  async getProjectInfo(_context) {
-    await this.ensureTempLayout();
-    return this.provider.getProjectInfo();
+  const extension = path13.extname(relativePath);
+  if (!extension) {
+    return false;
   }
-  async getProjectDescription(_context) {
-    return this.provider.getProjectDescription();
+  const basename = path13.basename(relativePath, extension);
+  if (basename === componentId) {
+    return true;
   }
-  async upsertProjectDescription(projectDescription, _context) {
-    return this.provider.upsertProjectDescription(projectDescription);
+  return basename === "index" && path13.basename(path13.dirname(relativePath)) === componentId;
+}
+function isManifestSupportFile(relativePath) {
+  return relativePath.startsWith(COMPONENT_UI_PREFIX);
+}
+function toSkippedFile(targetPath, reason) {
+  return {
+    targetPath,
+    reason
+  };
+}
+function splitManifestFiles(input) {
+  const manifestFiles = input.files.map(normalizeManifestFilePath);
+  const copyableFileSet = new Set(input.copyableFiles);
+  const componentEntryFiles = [];
+  const skippedFiles = [];
+  for (const relativePath of manifestFiles) {
+    if (relativePath === PACKAGE_JSON_RELATIVE_PATH2) {
+      skippedFiles.push(
+        toSkippedFile(relativePath, "package_json_managed_as_dependencies")
+      );
+      continue;
+    }
+    if (isVirtualRouteFile(relativePath)) {
+      skippedFiles.push(toSkippedFile(relativePath, "virtual_component_route"));
+      continue;
+    }
+    if (isComponentEntryFile(relativePath, input.componentId)) {
+      componentEntryFiles.push(relativePath);
+    }
+    if (!copyableFileSet.has(relativePath)) {
+      skippedFiles.push(
+        toSkippedFile(relativePath, "not_component_dependency")
+      );
+    }
   }
-  async listProjectPages(_context) {
-    return this.provider.listProjectPages();
+  return {
+    manifestFiles,
+    componentEntryFiles,
+    skippedFiles
+  };
+}
+async function createConflictReportEntry2(input) {
+  const sourceBuffer = await readFile7(input.sourceFilePath);
+  let targetBuffer = null;
+  try {
+    targetBuffer = await readFile7(input.targetFilePath);
+  } catch {
+    targetBuffer = null;
   }
-  async getProjectPage(pageId, _context) {
-    return this.provider.getProjectPage(pageId);
+  if (!targetBuffer || sourceBuffer.equals(targetBuffer)) {
+    return null;
   }
-  async createProjectPage(input, _context) {
-    return this.provider.createProjectPage(input);
+  const sourceRelative = toProjectRelative(
+    input.exportPath,
+    input.sourceFilePath
+  );
+  const targetRelative = toProjectRelative(
+    input.projectRoot,
+    input.targetFilePath
+  );
+  const isBinary = isBinaryBuffer(sourceBuffer) || isBinaryBuffer(targetBuffer);
+  return {
+    sourcePath: sourceRelative,
+    targetPath: targetRelative,
+    diff: isBinary ? "Binary files differ." : buildUnifiedDiff({
+      oldText: targetBuffer.toString("utf-8"),
+      newText: sourceBuffer.toString("utf-8"),
+      oldLabel: `user/${targetRelative}`,
+      newLabel: `export/${sourceRelative}`
+    }),
+    isBinary
+  };
+}
+function buildMessage(input) {
+  const parts = [
+    input.status === "completed" ? `Registry component "${input.componentId}" copied from the component manifest.` : `Registry component "${input.componentId}" needs review before transfer is complete.`,
+    `Report: ${input.reportPath}.`
+  ];
+  if (input.newFiles.length > 0) {
+    parts.push(`${input.newFiles.length} new file(s) copied.`);
   }
-  async listProjectPageVariants(pageId, _context) {
-    return this.provider.listProjectPageVariants(pageId);
+  if (input.identicalFiles.length > 0) {
+    parts.push(`${input.identicalFiles.length} file(s) already identical.`);
   }
-  async getProjectPageVariant(pageId, variantId, _context) {
-    return this.provider.getProjectPageVariant(pageId, variantId);
+  if (input.conflictFiles.length > 0) {
+    parts.push(
+      `${input.conflictFiles.length} conflicting file(s) were not overwritten.`
+    );
   }
-  async createProjectPageVariant(pageId, input, _context) {
-    return this.provider.createProjectPageVariant(pageId, input);
+  if (input.skippedFiles.length > 0) {
+    parts.push(
+      `${input.skippedFiles.length} manifest file(s) skipped, including virtual route, package metadata, or non-component context entries.`
+    );
   }
-  async setProjectPageActiveVariant(pageId, variantId, _context) {
-    return this.provider.setProjectPageActiveVariant(pageId, variantId);
+  if (input.missingManifestFiles.length > 0) {
+    parts.push(
+      `Missing manifest file(s): ${input.missingManifestFiles.join(", ")}.`
+    );
   }
-  async submitIssueReport(input, _context) {
-    return this.provider.submitIssueReport(input);
+  if (input.addedDependenciesCount > 0) {
+    parts.push(
+      "Missing dependencies were added to package.json but are NOT installed."
+    );
   }
-  async listExports(_context) {
-    await this.ensureTempLayout();
+  if (input.dependencyConflictCount > 0) {
+    parts.push(
+      "Dependency version conflicts require manual resolution before completion."
+    );
+  }
+  parts.push(
+    "The virtual component export page was skipped; manually insert the copied component into a real target page."
+  );
+  return parts.join(" ");
+}
+async function copyRegistryComponentFromExport(input) {
+  const normalizedComponentId = normalizeComponentId(input.componentId);
+  const { exportId, exportPath } = await resolveSingleExportDirectory(
+    input.exportsRoot
+  );
+  const manifestPath = path13.join(
+    input.exportsRoot,
+    `${exportId}.manifest.json`
+  );
+  if (!await fileExists2(manifestPath)) {
+    throw new Error(
+      `Component export manifest is missing at ${manifestPath}. Run create_component_export and download_component_export to regenerate it.`
+    );
+  }
+  const manifest = parsePrimeUiComponentExportManifest(
+    await readJsonFile(manifestPath)
+  );
+  if (manifest.export.id !== exportId || manifest.exportId !== exportId) {
+    throw new Error(
+      `Component export manifest mismatch for id "${exportId}". Run create_component_export and download_component_export again.`
+    );
+  }
+  if (manifest.component.componentId !== normalizedComponentId) {
+    throw new Error(
+      `Component export manifest mismatch: expected componentId "${normalizedComponentId}", got "${manifest.component.componentId}".`
+    );
+  }
+  const initialSelection = splitManifestFiles({
+    files: getComponentCopyManifestFiles(manifest),
+    componentId: normalizedComponentId,
+    copyableFiles: []
+  });
+  const manifestFileSet = new Set(initialSelection.manifestFiles);
+  const componentEntryCandidates = await resolveManifestCandidateFiles({
+    exportPath,
+    manifestOwnerLabel: `registry component "${normalizedComponentId}"`,
+    files: initialSelection.componentEntryFiles,
+    requireExisting: false
+  });
+  const newFiles = [];
+  const identicalFiles = [];
+  const conflictFiles = [];
+  const conflictReportEntries = [];
+  const missingManifestFiles = /* @__PURE__ */ new Set();
+  const existingComponentEntryFiles = [];
+  for (const sourceFilePath of componentEntryCandidates) {
+    const relativeToExport = toProjectRelative(exportPath, sourceFilePath);
+    if (await fileExists2(sourceFilePath)) {
+      existingComponentEntryFiles.push(sourceFilePath);
+      continue;
+    }
+    missingManifestFiles.add(relativeToExport);
+  }
+  const dependencyGraph = existingComponentEntryFiles.length > 0 ? await buildImportGraph({
+    projectRoot: exportPath,
+    entryFiles: existingComponentEntryFiles,
+    followInternalImports: true
+  }) : { internalFiles: [], externalPackages: [] };
+  const graphInternalFiles = new Set(
+    dependencyGraph.internalFiles.map(
+      (filePath) => toProjectRelative(exportPath, filePath)
+    )
+  );
+  const exportableFileSet = new Set(
+    uniqueNormalizedManifestFiles(getSuccessfulExportableFiles(manifest))
+  );
+  const copyableFiles = initialSelection.manifestFiles.filter(
+    (relativePath) => graphInternalFiles.has(relativePath) || isManifestSupportFile(relativePath) || exportableFileSet.has(relativePath)
+  ).filter(
+    (relativePath) => relativePath !== PACKAGE_JSON_RELATIVE_PATH2 && !isVirtualRouteFile(relativePath)
+  ).sort((a, b) => a.localeCompare(b));
+  const { manifestFiles, skippedFiles } = splitManifestFiles({
+    files: initialSelection.manifestFiles,
+    componentId: normalizedComponentId,
+    copyableFiles
+  });
+  const candidateFiles = await resolveManifestCandidateFiles({
+    exportPath,
+    manifestOwnerLabel: `registry component "${normalizedComponentId}"`,
+    files: copyableFiles,
+    requireExisting: false
+  });
+  for (const sourceFilePath of candidateFiles) {
+    const relativeToExport = toProjectRelative(exportPath, sourceFilePath);
+    const sourceExists = await fileExists2(sourceFilePath);
+    if (!sourceExists) {
+      missingManifestFiles.add(relativeToExport);
+      continue;
+    }
+    const targetFilePath = path13.join(input.projectRoot, relativeToExport);
+    ensureSafeTargetPath(input.projectRoot, targetFilePath);
+    const sourceBuffer = await readFile7(sourceFilePath);
+    let targetBuffer = null;
+    try {
+      targetBuffer = await readFile7(targetFilePath);
+    } catch {
+      targetBuffer = null;
+    }
+    if (!targetBuffer) {
+      await ensureDir(path13.dirname(targetFilePath));
+      await writeFile6(targetFilePath, sourceBuffer);
+      newFiles.push(relativeToExport);
+      continue;
+    }
+    if (sourceBuffer.equals(targetBuffer)) {
+      identicalFiles.push(relativeToExport);
+      continue;
+    }
+    const entry = await createConflictReportEntry2({
+      sourceFilePath,
+      targetFilePath,
+      exportPath,
+      projectRoot: input.projectRoot
+    });
+    if (entry) {
+      conflictReportEntries.push(entry);
+      conflictFiles.push({
+        targetPath: entry.targetPath,
+        isBinary: entry.isBinary
+      });
+    }
+  }
+  const { addedDependencies, dependenciesVersionConflicts } = await applyDependencyRequirementsToPackageJson({
+    exportPackageJsonPath: path13.join(exportPath, PACKAGE_JSON_RELATIVE_PATH2),
+    userPackageJsonPath: path13.join(
+      input.projectRoot,
+      PACKAGE_JSON_RELATIVE_PATH2
+    ),
+    requiredPackageNames: dependencyGraph.externalPackages
+  });
+  const missingManifestFileList = [...missingManifestFiles].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  const sortedConflictEntries = conflictReportEntries.sort(
+    (a, b) => a.targetPath.localeCompare(b.targetPath)
+  );
+  const sortedConflictFiles = conflictFiles.sort(
+    (a, b) => a.targetPath.localeCompare(b.targetPath)
+  );
+  const sortedNewFiles = newFiles.sort((a, b) => a.localeCompare(b));
+  const sortedIdenticalFiles = identicalFiles.sort(
+    (a, b) => a.localeCompare(b)
+  );
+  const copyId = createCopyId();
+  const reportPath = path13.join(
+    input.exportsRoot,
+    `${exportId}.copy-registry-component-report-${copyId}.json`
+  );
+  const report = {
+    reportPath,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    exportId,
+    componentId: normalizedComponentId,
+    manifestFiles,
+    copyableFiles,
+    skippedFiles,
+    conflicts: sortedConflictEntries,
+    missingManifestFiles: missingManifestFileList
+  };
+  await writeFile6(reportPath, `${JSON.stringify(report, null, 2)}
+`, "utf-8");
+  const needsReview = copyableFiles.length === 0 || sortedConflictFiles.length > 0 || dependenciesVersionConflicts.length > 0 || missingManifestFileList.length > 0;
+  const status = needsReview ? "needs_review" : "completed";
+  const guidanceArtifacts = [
+    buildExportManifestArtifact(manifestPath),
+    buildReferenceExportArtifact(exportPath)
+  ];
+  if (needsReview) {
+    guidanceArtifacts.push(buildConflictReportArtifact(reportPath));
+  }
+  return {
+    status,
+    message: buildMessage({
+      componentId: normalizedComponentId,
+      status,
+      reportPath,
+      newFiles: sortedNewFiles,
+      identicalFiles: sortedIdenticalFiles,
+      conflictFiles: sortedConflictFiles,
+      skippedFiles,
+      addedDependenciesCount: addedDependencies.length,
+      dependencyConflictCount: dependenciesVersionConflicts.length,
+      missingManifestFiles: missingManifestFileList
+    }),
+    reportPath,
+    exportId,
+    exportPath,
+    manifestPath,
+    component: manifest.component,
+    manifestFiles,
+    copyableFiles,
+    newFiles: sortedNewFiles,
+    identicalFiles: sortedIdenticalFiles,
+    conflictFiles: sortedConflictFiles,
+    skippedFiles,
+    addedDependencies,
+    dependenciesVersionConflicts,
+    missingManifestFiles: missingManifestFileList,
+    summary: {
+      totalManifestFiles: manifestFiles.length,
+      totalCopyableFiles: copyableFiles.length,
+      copiedFiles: sortedNewFiles.length,
+      identicalFiles: sortedIdenticalFiles.length,
+      conflictFiles: sortedConflictFiles.length,
+      skippedFiles: skippedFiles.length,
+      addedDependencies: addedDependencies.length,
+      dependenciesVersionConflicts: dependenciesVersionConflicts.length,
+      missingManifestFiles: missingManifestFileList.length
+    },
+    guidance: {
+      artifacts: guidanceArtifacts,
+      requiredActions: "Do not install the skipped virtual component export page as a route. Manually import the copied component/support files into a real target page, install newly added dependencies, and resolve any reported conflicts or dependency version mismatches before treating the registry component transfer as complete."
+    }
+  };
+}
+
+// src/services/project-sync-service.ts
+function buildManifestPath(exportsRoot, exportId) {
+  return path14.join(exportsRoot, `${exportId}.manifest.json`);
+}
+function normalizeSlug3(slug) {
+  const trimmed = slug.trim();
+  if (!trimmed || trimmed === "/") {
+    return "/";
+  }
+  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withLeadingSlash.replace(/\/+$/, "") || "/";
+}
+function normalizeEnvironmentSlug(slug) {
+  return slug.trim();
+}
+var ProjectSyncService = class {
+  provider;
+  projectRoot;
+  targetProjectRoot;
+  primeUiRoot;
+  tempRoot;
+  exportsRoot;
+  pageDetailsBySlug;
+  constructor(options) {
+    this.projectRoot = options.projectRoot;
+    this.targetProjectRoot = options.targetProjectRoot;
+    this.provider = options.provider;
+    this.pageDetailsBySlug = options.pageDetailsBySlug ?? /* @__PURE__ */ new Map();
+    this.primeUiRoot = path14.join(this.projectRoot, ".primeui");
+    this.tempRoot = path14.join(this.primeUiRoot, "temp");
+    this.exportsRoot = path14.join(this.tempRoot, "exports");
+  }
+  async getProjectInfo(_context) {
+    await this.ensureTempLayout();
+    return this.provider.getProjectInfo();
+  }
+  async getProjectDescription(_context) {
+    return this.provider.getProjectDescription();
+  }
+  async upsertProjectDescription(projectDescription, _context) {
+    return this.provider.upsertProjectDescription(projectDescription);
+  }
+  async listProjectPages(_context) {
+    return this.provider.listProjectPages();
+  }
+  async getProjectPage(pageId, _context) {
+    return this.provider.getProjectPage(pageId);
+  }
+  async createProjectPage(input, _context) {
+    return this.provider.createProjectPage(input);
+  }
+  async listProjectPageVariants(pageId, _context) {
+    return this.provider.listProjectPageVariants(pageId);
+  }
+  async getProjectPageVariant(pageId, variantId, _context) {
+    return this.provider.getProjectPageVariant(pageId, variantId);
+  }
+  async createProjectPageVariant(pageId, input, _context) {
+    return this.provider.createProjectPageVariant(pageId, input);
+  }
+  async setProjectPageActiveVariant(pageId, variantId, _context) {
+    return this.provider.setProjectPageActiveVariant(pageId, variantId);
+  }
+  async submitIssueReport(input, _context) {
+    return this.provider.submitIssueReport(input);
+  }
+  async getSearchOverview(_context) {
+    return this.provider.getSearchOverview();
+  }
+  async getSearchEnvironment(environmentSlug, _context) {
+    const normalizedSlug = normalizeEnvironmentSlug(environmentSlug);
+    if (!normalizedSlug) {
+      throw new Error("Search environment slug is required.");
+    }
+    const overview = await this.provider.getSearchOverview();
+    const runtime = overview.runtimes.find(
+      (candidate) => candidate.slug === normalizedSlug
+    );
+    if (!runtime) {
+      throw new Error(
+        `Search environment "${normalizedSlug}" was not found in the current project overview.`
+      );
+    }
+    const relatedIndexes = this.getRelatedIndexesForRuntime(overview, runtime);
+    const relatedIndexIds = new Set(relatedIndexes.map((index) => index.id));
+    const primaryIndex = relatedIndexes[0] ?? null;
+    return {
+      success: true,
+      environmentSlug: normalizedSlug,
+      environment: runtime,
+      primaryIndex,
+      relatedIndexes,
+      recentJobs: overview.recentJobs.filter(
+        (job) => relatedIndexIds.has(job.projectSearchIndexId)
+      ),
+      recentSyncRuns: overview.recentSyncRuns.filter(
+        (syncRun) => relatedIndexIds.has(syncRun.projectSearchIndexId)
+      ),
+      search: overview.search,
+      runtimeModel: overview.runtimeModel,
+      sources: overview.sources,
+      lastError: overview.lastError
+    };
+  }
+  async createSearchEnvironment(input, _context) {
+    const projectInfo = await this.provider.getProjectInfo();
+    const result = await this.provider.createSearchEnvironment({
+      name: input.name,
+      projectId: projectInfo.projectId,
+      slug: input.slug
+    });
+    return {
+      success: result.success,
+      environment: result.runtime
+    };
+  }
+  async updateSearchEnvironment(input, _context) {
+    const projectInfo = await this.provider.getProjectInfo();
+    const result = await this.provider.updateSearchEnvironment({
+      projectId: projectInfo.projectId,
+      runtimeSlug: input.environmentSlug,
+      ...input.name === void 0 ? {} : { name: input.name },
+      ...input.status === void 0 ? {} : { status: input.status }
+    });
+    return {
+      success: result.success,
+      environment: result.runtime
+    };
+  }
+  async deleteSearchEnvironment(environmentSlug, _context) {
+    const projectInfo = await this.provider.getProjectInfo();
+    return this.provider.deleteSearchEnvironment({
+      projectId: projectInfo.projectId,
+      runtimeSlug: environmentSlug
+    });
+  }
+  async syncSearchEnvironment(environmentSlug, _context) {
+    const normalizedSlug = normalizeEnvironmentSlug(environmentSlug);
+    if (!normalizedSlug) {
+      throw new Error("Search environment slug is required.");
+    }
+    const packageJsonPath = path14.join(this.targetProjectRoot, "package.json");
+    const guidanceNotes = [
+      `Run the command from ${this.targetProjectRoot}.`,
+      "This tool returns guidance mode because Phase 13 keeps sync truthful to the real exported-project flow instead of pretending MCP generated a fresh payload itself."
+    ];
+    try {
+      const packageJson = JSON.parse(
+        await readFile8(packageJsonPath, "utf-8")
+      );
+      if (packageJson.scripts?.["search:sync"]) {
+        return {
+          success: true,
+          mode: "guidance",
+          environmentSlug: normalizedSlug,
+          command: `pnpm search:sync --env ${normalizedSlug}`,
+          workingDirectory: this.targetProjectRoot,
+          jobId: null,
+          status: null,
+          notes: guidanceNotes
+        };
+      }
+    } catch {
+      guidanceNotes.push(
+        `Package script lookup at ${packageJsonPath} was unavailable, so MCP is falling back to the package CLI command.`
+      );
+    }
+    return {
+      success: true,
+      mode: "guidance",
+      environmentSlug: normalizedSlug,
+      command: `npx @primeuicom/cli search sync --env ${normalizedSlug}`,
+      workingDirectory: this.targetProjectRoot,
+      jobId: null,
+      status: null,
+      notes: guidanceNotes
+    };
+  }
+  async listExports(_context) {
+    await this.ensureTempLayout();
     return this.provider.listExports();
   }
   async createExport(_context) {
@@ -3489,6 +4312,20 @@ var ProjectSyncService = class {
       }
     };
   }
+  async createComponentExport(componentId, _context) {
+    await this.ensureTempLayout();
+    const result = await this.provider.createComponentExport(componentId);
+    const manifestPath = buildManifestPath(this.exportsRoot, result.export.id);
+    await writeUtf8(manifestPath, `${JSON.stringify(result, null, 2)}
+`);
+    return {
+      ...result,
+      guidance: {
+        artifacts: [buildExportManifestArtifact(manifestPath)],
+        requiredActions: `Call download_component_export with id "${result.export.id}" next. This is a component-track manifest; do not use page copy tools until a component registry copy tool is available.`
+      }
+    };
+  }
   async downloadExportById(id, _context) {
     await this.ensureTempLayout();
     const exportsList = await this.provider.listExports();
@@ -3496,13 +4333,13 @@ var ProjectSyncService = class {
     if (!selected) {
       throw new Error(`Export not found: ${id}`);
     }
-    const targetZipPath = path13.join(this.exportsRoot, `${id}.zip`);
-    const targetProjectPath = path13.join(this.exportsRoot, id);
+    const targetZipPath = path14.join(this.exportsRoot, `${id}.zip`);
+    const targetProjectPath = path14.join(this.exportsRoot, id);
     const manifestPath = buildManifestPath(this.exportsRoot, id);
     let manifest;
     try {
       manifest = parsePrimeUiExportManifest(
-        JSON.parse(await readFile7(manifestPath, "utf-8"))
+        JSON.parse(await readFile8(manifestPath, "utf-8"))
       );
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
@@ -3532,6 +4369,29 @@ var ProjectSyncService = class {
       }
     };
   }
+  async downloadComponentExportById(id, _context) {
+    await this.ensureTempLayout();
+    const manifestPath = buildManifestPath(this.exportsRoot, id);
+    const manifest = await this.readComponentExportManifest(id, manifestPath);
+    const targetZipPath = path14.join(this.exportsRoot, `${id}.zip`);
+    const targetProjectPath = path14.join(this.exportsRoot, id);
+    await ensureDir(this.exportsRoot);
+    await this.provider.downloadExportArchive(id, targetZipPath);
+    await resetDir(targetProjectPath);
+    await extractZip(targetZipPath, targetProjectPath);
+    return {
+      exportId: id,
+      projectPath: targetProjectPath,
+      manifestPath,
+      guidance: {
+        artifacts: [
+          buildReferenceExportArtifact(targetProjectPath),
+          buildExportManifestArtifact(manifestPath)
+        ],
+        requiredActions: `Use the component export_manifest artifact as the source of truth for component "${manifest.component.componentId}" and the reference_export artifact for inspection only. The next component-track step is a registry component copy tool; do not install the virtual page as a normal page.`
+      }
+    };
+  }
   async inspectPage(slug, _context) {
     await this.ensureTempLayout();
     const pageDetails = await this.provider.getProjectPageBySlug(slug);
@@ -3543,6 +4403,25 @@ var ProjectSyncService = class {
       reportRows: reportPayload.reportRows
     };
   }
+  async readComponentExportManifest(id, manifestPath) {
+    let manifest;
+    try {
+      manifest = parsePrimeUiComponentExportManifest(
+        JSON.parse(await readFile8(manifestPath, "utf-8"))
+      );
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Component export manifest is required for download id "${id}". Run create_component_export for this export before downloading. Details: ${reason}`
+      );
+    }
+    if (manifest.export.id !== id || manifest.exportId !== id) {
+      throw new Error(
+        `Component export manifest mismatch for id "${id}". Run create_component_export and retry download.`
+      );
+    }
+    return manifest;
+  }
   async copyPage(originPageSlug, _context) {
     await this.ensureTempLayout();
     return copyPageFromExport({
@@ -3568,6 +4447,14 @@ var ProjectSyncService = class {
       pageDetails
     });
   }
+  async copyRegistryComponent(componentId, _context) {
+    await this.ensureTempLayout();
+    return copyRegistryComponentFromExport({
+      projectRoot: this.targetProjectRoot,
+      exportsRoot: this.exportsRoot,
+      componentId
+    });
+  }
   async copyExportable(exportableKey, _context) {
     await this.ensureTempLayout();
     return copyExportableFromExport({
@@ -3586,6 +4473,30 @@ var ProjectSyncService = class {
     await ensureDir(this.tempRoot);
     await ensureDir(this.exportsRoot);
   }
+  getRelatedIndexesForRuntime(overview, runtime) {
+    const indexes = [];
+    const seen = /* @__PURE__ */ new Set();
+    const pushIndex = (index) => {
+      if (!index || seen.has(index.id)) {
+        return;
+      }
+      seen.add(index.id);
+      indexes.push(index);
+    };
+    if (overview.defaultIndex) {
+      const matchesByUid = runtime.currentMeilisearchIndexUid && overview.defaultIndex.meilisearchIndexUid === runtime.currentMeilisearchIndexUid;
+      const matchesDefaultSlug = runtime.slug === overview.runtimeModel.defaultRuntimeSlug && overview.defaultIndex.kind === "default-runtime";
+      if (matchesByUid || matchesDefaultSlug) {
+        pushIndex(overview.defaultIndex);
+      }
+    }
+    for (const index of overview.customIndexes) {
+      if (runtime.currentMeilisearchIndexUid && index.meilisearchIndexUid === runtime.currentMeilisearchIndexUid) {
+        pushIndex(index);
+      }
+    }
+    return indexes;
+  }
 };
 
 // src/runtime.ts
@@ -3776,6 +4687,57 @@ var LazyProjectSyncSource = class {
       }
     );
   }
+  async getSearchOverview(context) {
+    return this.withService(
+      context,
+      (service) => service.getSearchOverview(context),
+      {
+        requireTargetProjectRoot: false
+      }
+    );
+  }
+  async getSearchEnvironment(environmentSlug, context) {
+    return this.withService(
+      context,
+      (service) => service.getSearchEnvironment(environmentSlug, context),
+      {
+        requireTargetProjectRoot: false
+      }
+    );
+  }
+  async createSearchEnvironment(input, context) {
+    return this.withMutationService(
+      context,
+      (service) => service.createSearchEnvironment(input, context),
+      {
+        requireTargetProjectRoot: false
+      }
+    );
+  }
+  async updateSearchEnvironment(input, context) {
+    return this.withMutationService(
+      context,
+      (service) => service.updateSearchEnvironment(input, context),
+      {
+        requireTargetProjectRoot: false
+      }
+    );
+  }
+  async deleteSearchEnvironment(environmentSlug, context) {
+    return this.withMutationService(
+      context,
+      (service) => service.deleteSearchEnvironment(environmentSlug, context),
+      {
+        requireTargetProjectRoot: false
+      }
+    );
+  }
+  async syncSearchEnvironment(environmentSlug, context) {
+    return this.withService(
+      context,
+      (service) => service.syncSearchEnvironment(environmentSlug, context)
+    );
+  }
   async listExports(context) {
     return this.withService(context, (service) => service.listExports(context));
   }
@@ -3785,12 +4747,24 @@ var LazyProjectSyncSource = class {
       (service) => service.createExport(context)
     );
   }
+  async createComponentExport(componentId, context) {
+    return this.withService(
+      context,
+      (service) => service.createComponentExport(componentId, context)
+    );
+  }
   async downloadExportById(id, context) {
     return this.withService(
       context,
       (service) => service.downloadExportById(id, context)
     );
   }
+  async downloadComponentExportById(id, context) {
+    return this.withService(
+      context,
+      (service) => service.downloadComponentExportById(id, context)
+    );
+  }
   async inspectPage(slug, context) {
     const result = await this.withService(
       context,
@@ -3811,6 +4785,12 @@ var LazyProjectSyncSource = class {
       (service) => service.copyComponent(originPageSlug, blockId, componentId, context)
     );
   }
+  async copyRegistryComponent(componentId, context) {
+    return this.withMutationService(
+      context,
+      (service) => service.copyRegistryComponent(componentId, context)
+    );
+  }
   async copyExportable(exportableKey, context) {
     return this.withMutationService(
       context,
@@ -3911,6 +4891,18 @@ var exportPageSchema = z4.object({
   componentsPath: z4.string().describe("Page components directory path relative to export root."),
   manifest: exportPageManifestSchema
 });
+var componentExportComponentSchema = z4.object({
+  componentId: z4.string().describe("PrimeUI component registry identifier used to create export."),
+  name: z4.string().describe("Human-readable PrimeUI component name from registry metadata."),
+  pageType: z4.string().describe("Page type used by the virtual component export snapshot."),
+  family: z4.string().describe("Component family/group metadata from the PrimeUI registry."),
+  defaultPropsAvailable: z4.boolean().describe("True when registry default props were available for export."),
+  isReadyToExport: z4.boolean().describe("True when this component export payload is ready to download.")
+});
+var componentExportPageSchema = exportPageSchema.omit({
+  pagePath: true,
+  componentsPath: true
+});
 var dependencySectionSchema = z4.enum([
   "dependencies",
   "devDependencies",
@@ -3939,8 +4931,12 @@ var skippedCopyFileSchema = z4.object({
   targetPath: z4.string().describe(
     "Relative target path intentionally not copied into user project root."
   ),
-  reason: z4.enum(["package_json_managed_as_dependencies"]).describe(
-    "Machine-readable reason for skipping this file. package_json_managed_as_dependencies means package.json was handled as dependency guidance instead of direct file copy."
+  reason: z4.enum([
+    "package_json_managed_as_dependencies",
+    "virtual_component_route",
+    "not_component_dependency"
+  ]).describe(
+    "Machine-readable reason for skipping this file. package_json_managed_as_dependencies means package.json was handled as dependency guidance instead of direct file copy. virtual_component_route means the internal component-export route was intentionally not installed into the target app. not_component_dependency means the manifest file belongs to page/template context outside the selected registry component dependency set."
   )
 });
 var runtimeGuidanceArtifactSchema = z4.object({
@@ -4024,7 +5020,7 @@ WORKFLOW ORDER (always follow this sequence):
 4. inspect_page -> inspect selected page components and produce a structured comparison table
 5. create_export -> generate export snapshot and local manifest with page file lists + shared exportables
 6. download_export -> download to temp directory
-7. copy_page, copy_component, or copy_exportable -> transfer one selected page, one selected block-level component, or one selected shared exportable safely
+7. copy_page, copy_component, copy_exportable, or copy_registry_component -> transfer one selected page, one selected block-level page component, one selected shared exportable, or one registry component safely
 8. Reconcile integration points, dependency follow-up, and reported conflicts
 `.trim();
 var initialInstructions = `
@@ -4064,7 +5060,7 @@ CRITICAL RULES FOR PAGE IMPORT:
   - copy_page for page manifests,
   - copy_component for one selected block-level component instance,
   - copy_exportable for shared exportables.
-- Always call copy_page, copy_component, or copy_exportable instead of manual file copy.
+- Always call copy_page, copy_component, copy_exportable, or copy_registry_component instead of manual file copy.
 - copy_page performs safe copy only:
   - new files are copied,
   - identical files are reported,
@@ -4252,6 +5248,59 @@ ${WORKFLOW_SUMMARY}`,
     openWorldHint: true
   }
 };
+var toolCreateComponentExport = {
+  title: "PrimeUI Create Component Export",
+  description: `Create a component-track export for one known PrimeUI componentId and wait for completion. This uses the component registry export API and returns a component-aware sidecar manifest plus the virtual page manifest created by Studio.
+
+WHEN TO USE: Use this only for the component-registry import track when the user wants to export a single known componentId. This is separate from create_export, which exports selected project pages.
+
+AFTER CALLING:
+- Verify component.componentId matches the requested componentId.
+- Verify component.isReadyToExport is true and page.manifest.files is present.
+- Local component sidecar manifest is saved to .primeui/temp/exports/[exportId].manifest.json.
+- Use the returned export ID to call download_component_export.
+- Use copy_registry_component after download_component_export for this component-track manifest. Do not use page copy tools for component-track manifests.
+- If guidance is present in the result, read guidance.artifacts and follow guidance.requiredActions before continuing.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    componentId: z4.string().min(1).describe("PrimeUI component registry identifier to export.")
+  },
+  outputSchema: z4.object({
+    exportId: z4.string().describe(
+      "Freshly created component export identifier. Use this as download_component_export input.id."
+    ),
+    export: z4.object({
+      id: z4.string().describe("Created export identifier."),
+      status: exportStatusSchema,
+      createdAt: z4.string().describe("Export creation timestamp in ISO-8601 UTC format."),
+      expiresAt: z4.string().nullable().describe(
+        "Export expiration timestamp in ISO-8601 UTC format, or null when export has no explicit expiration."
+      ),
+      summary: exportSummarySchema.describe(
+        "Export run summary with total/successful/failed counters."
+      ),
+      exportables: z4.array(exportableSchema).describe("Shared exportables included in this export payload.")
+    }).describe("Created component export summary."),
+    component: componentExportComponentSchema,
+    page: componentExportPageSchema.describe(
+      "Virtual page manifest for this component export."
+    ),
+    pages: z4.array(componentExportPageSchema).describe(
+      "Page-compatible virtual page payload associated with this component export."
+    ),
+    guidance: runtimeGuidanceSchema.optional().describe(
+      "Mandatory runtime guidance for local artifacts created during component export."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  }
+};
 var toolDownloadExport = {
   title: "PrimeUI Download Export",
   description: `Download a completed export into .primeui/temp/exports/[exportId]. Downloads and extracts the full export as a standalone Next.js project into the temp directory. This does NOT modify the user's project - files land only in .primeui/temp/.
@@ -4280,25 +5329,67 @@ AFTER DOWNLOAD:
 - Do not force cleanup at flow end; keep downloaded export files available for validation and follow-up checks.
 - If guidance is present in the result, read guidance.artifacts and follow guidance.requiredActions before choosing the next copy tool.
 
-  ${WORKFLOW_SUMMARY}`,
+  ${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    id: z4.string().describe(
+      "Export identifier to download. Prefer export.id from create_export; use list_exports only on explicit user request."
+    )
+  },
+  outputSchema: z4.object({
+    exportId: z4.string().describe(
+      "Downloaded export identifier. Should match the requested input.id for traceability."
+    ),
+    projectPath: z4.string().describe(
+      "Absolute local path to extracted export root in .primeui/temp/exports/[exportId]. Read files from here only."
+    ),
+    manifestPath: z4.string().describe(
+      "Absolute path to sidecar export manifest file (.primeui/temp/exports/[exportId].manifest.json) saved by create_export and required by copy_page and copy_component."
+    ),
+    guidance: runtimeGuidanceSchema.optional().describe(
+      "Mandatory runtime guidance for the downloaded export and manifest artifacts. Present only on successful tool results."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+var toolDownloadComponentExport = {
+  title: "PrimeUI Download Component Export",
+  description: `Download a completed component-track export into .primeui/temp/exports/[exportId]. Downloads and extracts the full export archive through the existing PrimeUI export download endpoint, but requires a local component sidecar manifest created by create_component_export.
+
+Do NOT call this as the first step. Requires export ID from create_component_export.
+
+WHEN TO USE: Call this AFTER create_component_export has returned a completed component export. This does NOT modify the user's project - files land only in .primeui/temp/.
+
+NOTE:
+- Download of an export ID without a local component sidecar manifest will fail.
+- A normal page export manifest from create_export is not accepted here.
+- The next component-track step is copy_registry_component. Do not use page copy tools for component-track manifests.
+- If guidance is present in the result, read guidance.artifacts and follow guidance.requiredActions before continuing.
+
+${WORKFLOW_SUMMARY}`,
   inputSchema: {
     projectRoot: projectRootInputSchema,
     id: z4.string().describe(
-      "Export identifier to download. Prefer export.id from create_export; use list_exports only on explicit user request."
+      "Component export identifier to download. Use export.id from create_component_export."
     )
   },
   outputSchema: z4.object({
     exportId: z4.string().describe(
-      "Downloaded export identifier. Should match the requested input.id for traceability."
+      "Downloaded component export identifier. Should match the requested input.id."
     ),
     projectPath: z4.string().describe(
       "Absolute local path to extracted export root in .primeui/temp/exports/[exportId]. Read files from here only."
     ),
     manifestPath: z4.string().describe(
-      "Absolute path to sidecar export manifest file (.primeui/temp/exports/[exportId].manifest.json) saved by create_export and required by copy_page and copy_component."
+      "Absolute path to component sidecar export manifest saved by create_component_export."
     ),
     guidance: runtimeGuidanceSchema.optional().describe(
-      "Mandatory runtime guidance for the downloaded export and manifest artifacts. Present only on successful tool results."
+      "Mandatory runtime guidance for the downloaded component export and manifest artifacts."
     )
   }),
   annotations: {
@@ -4491,6 +5582,97 @@ ${WORKFLOW_SUMMARY}`,
     openWorldHint: false
   }
 };
+var toolCopyRegistryComponent = {
+  title: "PrimeUI Copy Registry Component",
+  description: `Safely copy one registry component from a downloaded component export into the user's local project. Works only with component-track files in .primeui/temp/exports and does NOT call PrimeUI API.
+
+WHEN TO USE:
+- Call this AFTER create_component_export and download_component_export.
+- Use this for component-registry exports, not page exports.
+- Pass componentId from the create_component_export result so the local component sidecar manifest can be validated before copying.
+
+BEHAVIOR:
+- Reads the component sidecar manifest saved by create_component_export.
+- Validates that manifest.component.componentId matches input.componentId.
+- Copies files strictly from page.manifest.files in the component sidecar manifest.
+- Skips virtual route files that include __primeui-component-export, because those are reference/insertion hints and must not be installed as normal app routes.
+- Never copies package.json directly. package.json is used only to add missing dependency entries and report dependency version conflicts.
+- Preserves export-relative paths for copied files in this first version.
+- Never overwrites existing conflicting files.
+- Writes full conflict details to .primeui/temp/exports/[exportId].copy-registry-component-report-[copyId].json.
+- Reports copied files, identical files, conflicts, skipped files, dependency additions, dependency version conflicts, missing manifest files, and manual insertion guidance.
+- If status is needs_review, resolve conflicts, missing manifest files, or dependency version conflicts before treating transfer as complete.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    componentId: z4.string().describe(
+      "PrimeUI component registry identifier from create_component_export output. Must match the local component sidecar manifest."
+    )
+  },
+  outputSchema: z4.object({
+    status: z4.enum(["completed", "needs_review"]).describe(
+      "Decision state for next step. needs_review means conflicts, dependency version conflicts, missing manifest files, or no copyable files require manual review."
+    ),
+    message: z4.string().describe(
+      "Decision-oriented summary with reportPath and manual insertion guidance."
+    ),
+    reportPath: z4.string().describe(
+      "Absolute path to saved local report with conflicts, skipped files, and component manifest metadata."
+    ),
+    exportId: z4.string().describe("Resolved local component export identifier used for copy."),
+    exportPath: z4.string().describe("Absolute path to local extracted component export root."),
+    manifestPath: z4.string().describe(
+      "Absolute path to the local component sidecar manifest used during copy."
+    ),
+    component: componentExportComponentSchema.describe(
+      "Component metadata from the validated component sidecar manifest."
+    ),
+    manifestFiles: z4.array(z4.string()).describe(
+      "Normalized page.manifest.files from the component sidecar manifest."
+    ),
+    copyableFiles: z4.array(z4.string()).describe(
+      "Manifest files considered for copying after filtering virtual route files and package.json."
+    ),
+    newFiles: z4.array(z4.string()).describe("Relative target paths for new files copied."),
+    identicalFiles: z4.array(z4.string()).describe("Relative target paths for existing byte-identical files."),
+    conflictFiles: z4.array(conflictFileSchema).describe(
+      "Files that already exist and differ from export version. Never overwritten."
+    ),
+    skippedFiles: z4.array(skippedCopyFileSchema).describe(
+      "Manifest files intentionally not copied, such as package.json or virtual component-export routes."
+    ),
+    addedDependencies: z4.array(dependencyToAddSchema).describe(
+      "Dependencies that were missing and have been added to user's package.json."
+    ),
+    dependenciesVersionConflicts: z4.array(dependencyVersionConflictSchema).describe(
+      "Dependencies with version mismatch between export and user project. Report only."
+    ),
+    missingManifestFiles: z4.array(z4.string()).describe(
+      "Manifest file paths that were expected but missing from the downloaded export."
+    ),
+    summary: z4.object({
+      totalManifestFiles: z4.number(),
+      totalCopyableFiles: z4.number(),
+      copiedFiles: z4.number(),
+      identicalFiles: z4.number(),
+      conflictFiles: z4.number(),
+      skippedFiles: z4.number(),
+      addedDependencies: z4.number(),
+      dependenciesVersionConflicts: z4.number(),
+      missingManifestFiles: z4.number()
+    }),
+    guidance: runtimeGuidanceSchema.describe(
+      "Structured follow-up guidance. It always instructs manual insertion into a real target page and warns that the virtual route was skipped."
+    )
+  }),
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+};
 var toolCopyExportable = {
   title: "PrimeUI Copy Exportable",
   description: `Safely copy one shared exportable from downloaded export into the user's local project. Works only with local files in .primeui/temp/exports and does NOT call PrimeUI API.
@@ -4767,6 +5949,124 @@ var projectIssueReportSubmitInputSchema = z4.object({
     "Optional issue report tags. Empty values are trimmed and dropped by the API."
   )
 });
+var searchEnvironmentSlugSchema = z4.string().describe(
+  "Search environment slug, for example 'prod', 'staging', or a custom environment slug."
+);
+var searchRuntimeStatusSchema = z4.enum([
+  "bootstrapping",
+  "active",
+  "indexing",
+  "failed",
+  "inactive"
+]);
+var searchRuntimeSchema = z4.object({
+  createdAt: z4.string().describe("ISO timestamp when the environment was created."),
+  currentMeilisearchIndexUid: z4.string().nullable().describe(
+    "Current Meilisearch index UID bound to this environment, when available."
+  ),
+  currentQueryId: z4.string().nullable().describe(
+    "Current query credential or query binding identifier, when available."
+  ),
+  id: z4.string().describe("Stable internal environment record identifier."),
+  lastErrorSummary: z4.string().nullable().describe("Most recent error summary for this environment, if any."),
+  lastFailedSyncAt: z4.string().nullable().describe("ISO timestamp of the last failed sync for this environment."),
+  lastSuccessfulSyncAt: z4.string().nullable().describe(
+    "ISO timestamp of the last successful sync for this environment."
+  ),
+  name: z4.string().describe("Human-readable environment name."),
+  slug: z4.string().describe("Canonical search environment slug."),
+  status: searchRuntimeStatusSchema.describe(
+    "Current environment lifecycle status."
+  ),
+  updatedAt: z4.string().describe("ISO timestamp of the latest environment update.")
+});
+var searchOverviewOutputSchema = z4.object({
+  success: z4.literal(true),
+  projectId: z4.string().describe("PrimeUI project identifier for this overview."),
+  runtimeModel: z4.object({
+    additionalRuntimesSupported: z4.literal(true),
+    defaultRuntimeAutoWired: z4.literal(true),
+    defaultRuntimeSlug: z4.literal("prod"),
+    mode: z4.literal("runtime-first"),
+    panelCompatibility: z4.literal("disabled"),
+    stagingRuntimeAutoWired: z4.literal(false),
+    stagingRuntimeSlug: z4.literal("staging")
+  }).describe("Managed-search runtime model summary from the PrimeUI API."),
+  search: z4.object({
+    bootstrapCompletedAt: z4.string().nullable(),
+    createdAt: z4.string().nullable(),
+    id: z4.string().nullable(),
+    enabled: z4.boolean(),
+    status: z4.enum(["inactive", "active", "degraded"]),
+    defaultIndexId: z4.string().nullable(),
+    defaultSearchId: z4.string().nullable(),
+    lastErrorSummary: z4.string().nullable(),
+    lastFailedSyncAt: z4.string().nullable(),
+    lastSuccessfulSyncAt: z4.string().nullable(),
+    updatedAt: z4.string().nullable()
+  }).describe("Top-level managed-search root status."),
+  runtimes: z4.array(searchRuntimeSchema).describe("All configured search environments for this project."),
+  defaultIndex: z4.record(z4.unknown()).nullable().describe(
+    "Default index payload from the API overview, or null when absent."
+  ),
+  customIndexes: z4.array(z4.record(z4.unknown())).describe("Additional search index payloads from the API overview."),
+  recentJobs: z4.array(z4.record(z4.unknown())).describe("Recent search jobs from the overview API."),
+  recentSyncRuns: z4.array(z4.record(z4.unknown())).describe("Recent sync-run payloads from the overview API."),
+  sources: z4.array(z4.record(z4.unknown())).describe("Configured managed-search sources from the overview API."),
+  lastError: z4.record(z4.unknown()).nullable().describe("Latest overview-level managed-search error payload, if any."),
+  queryProtection: z4.record(z4.unknown()).describe("Query protection summary from the overview API."),
+  relevanceSettings: z4.record(z4.unknown()).describe("Relevance settings summary from the overview API.")
+});
+var searchEnvironmentOutputSchema = z4.object({
+  success: z4.literal(true),
+  environmentSlug: z4.string().describe("Resolved search environment slug for this focused MCP view."),
+  environment: searchRuntimeSchema.describe("Selected environment record."),
+  primaryIndex: z4.record(z4.unknown()).nullable().describe(
+    "Primary related index for this environment when one can be identified."
+  ),
+  relatedIndexes: z4.array(z4.record(z4.unknown())).describe("Related search indexes inferred for this environment."),
+  recentJobs: z4.array(z4.record(z4.unknown())).describe(
+    "Recent jobs filtered to the related indexes for this environment."
+  ),
+  recentSyncRuns: z4.array(z4.record(z4.unknown())).describe(
+    "Recent sync runs filtered to the related indexes for this environment."
+  ),
+  search: z4.record(z4.unknown()).describe(
+    "Top-level managed-search root status carried through from the overview API."
+  ),
+  runtimeModel: z4.record(z4.unknown()).describe(
+    "Managed-search runtime model carried through from the overview API."
+  ),
+  sources: z4.array(z4.record(z4.unknown())).describe("Managed-search sources carried through from the overview API."),
+  lastError: z4.record(z4.unknown()).nullable().describe("Latest overview-level managed-search error payload, if any.")
+});
+var searchEnvironmentMutationOutputSchema = z4.object({
+  success: z4.literal(true),
+  environment: searchRuntimeSchema.describe(
+    "Environment payload returned by the PrimeUI API."
+  )
+});
+var searchEnvironmentDeleteOutputSchema = z4.object({
+  success: z4.literal(true)
+});
+var searchEnvironmentSyncOutputSchema = z4.object({
+  success: z4.literal(true),
+  mode: z4.enum(["executed", "guidance"]).describe(
+    "Whether MCP executed the real sync command or returned next-step guidance."
+  ),
+  environmentSlug: z4.string().describe("Resolved search environment slug."),
+  command: z4.string().describe(
+    "Exact command the agent should run or that MCP already executed."
+  ),
+  workingDirectory: z4.string().describe("Absolute project directory where the command applies."),
+  jobId: z4.string().nullable().describe(
+    "Search job identifier when the command was actually executed and returned one."
+  ),
+  status: z4.string().nullable().describe("Execution status when available; null for guidance-only mode."),
+  notes: z4.array(z4.string()).describe(
+    "Actionable notes that explain why guidance or execution was chosen."
+  )
+});
 var toolProjectDescriptionGet = {
   title: "PrimeUI Project Description Get",
   description: `Atomic external API helper. Returns the current shared project description for the scoped PrimeUI project.
@@ -4974,6 +6274,139 @@ AFTER CALLING:
     openWorldHint: true
   }
 };
+var toolSearchOverviewGet = {
+  title: "PrimeUI Search Overview Get",
+  description: `Standalone managed-search helper. Returns the current search overview for the scoped PrimeUI project using the existing environment-first API contract.
+
+WHEN TO USE:
+- Use this as the starting point for MCP search work.
+- This tool is intentionally separate from the page/export workflow chain.
+- Call this before focused environment inspection or environment mutations when the current search state is not already known.
+
+AFTER CALLING:
+- Use runtimes as the authoritative inventory of search environments.
+- Use search_environment_get when the caller wants one environment-focused view instead of the full overview payload.`,
+  inputSchema: optionalProjectRootInputObjectSchema,
+  outputSchema: searchOverviewOutputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+var toolSearchEnvironmentGet = {
+  title: "PrimeUI Search Environment Get",
+  description: `Standalone managed-search helper. Returns one environment-focused view derived from the existing search overview contract.
+
+WHEN TO USE:
+- Use this when the caller already knows the target environment slug.
+- This tool does not rely on a separate runtime-details endpoint; it is an MCP convenience projection over the overview API.
+
+AFTER CALLING:
+- Treat environment as the source of truth for the selected search environment.
+- Treat relatedIndexes, recentJobs, and recentSyncRuns as MCP-filtered convenience data for this one environment.`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    environmentSlug: searchEnvironmentSlugSchema
+  },
+  outputSchema: searchEnvironmentOutputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  }
+};
+var toolSearchEnvironmentCreate = {
+  title: "PrimeUI Search Environment Create",
+  description: `Standalone managed-search helper. Creates one new search environment through the existing PrimeUI search-environment management API.
+
+WHEN TO USE:
+- Use this only when the caller explicitly wants to create a new search environment.
+- This is a power-user environment management tool, not part of the primary page/export workflow.
+
+AFTER CALLING:
+- Treat the returned environment payload as the immediate API result for the new environment.`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    slug: searchEnvironmentSlugSchema,
+    name: z4.string().describe("Human-readable environment name to create.")
+  },
+  outputSchema: searchEnvironmentMutationOutputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  }
+};
+var toolSearchEnvironmentUpdate = {
+  title: "PrimeUI Search Environment Update",
+  description: `Standalone managed-search helper. Updates one existing search environment through the PrimeUI search-environment management API.
+
+WHEN TO USE:
+- Use this only when the caller explicitly wants to update an existing search environment.
+- Keep this narrow: name and status updates only.
+
+AFTER CALLING:
+- Treat the returned environment payload as the immediate API result for the updated environment.`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    environmentSlug: searchEnvironmentSlugSchema,
+    name: z4.string().optional().describe("Optional new human-readable environment name."),
+    status: searchRuntimeStatusSchema.optional().describe("Optional new environment lifecycle status.")
+  },
+  outputSchema: searchEnvironmentMutationOutputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  }
+};
+var toolSearchEnvironmentDelete = {
+  title: "PrimeUI Search Environment Delete",
+  description: `Standalone managed-search helper. Deletes one search environment through the PrimeUI search-environment management API when the backend allows it.
+
+WHEN TO USE:
+- Use this only when the caller explicitly wants to delete an existing environment.
+- This tool relies on normal API allow/deny behavior instead of inventing separate MCP policy summaries.`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    environmentSlug: searchEnvironmentSlugSchema
+  },
+  outputSchema: searchEnvironmentDeleteOutputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+  }
+};
+var toolSearchEnvironmentSync = {
+  title: "PrimeUI Search Environment Sync",
+  description: `Standalone managed-search helper. Returns the real search sync command context for one environment and may execute it only when MCP can do so truthfully.
+
+WHEN TO USE:
+- Use this when the caller wants to sync one search environment against the actual local exported-project flow.
+- This tool intentionally avoids pretending that a runtime-action API wrapper would always represent fresh local project state.
+
+AFTER CALLING:
+- If mode is guidance, run the returned command from workingDirectory next.
+- If mode is executed, treat jobId and status as the immediate sync invocation result.`,
+  inputSchema: {
+    projectRoot: projectRootInputSchema,
+    environmentSlug: searchEnvironmentSlugSchema
+  },
+  outputSchema: searchEnvironmentSyncOutputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  }
+};
 
 // src/server.ts
 var ZERO_ARG_PROJECT_ROOT_TOOLS = /* @__PURE__ */ new Set([
@@ -4982,7 +6415,8 @@ var ZERO_ARG_PROJECT_ROOT_TOOLS = /* @__PURE__ */ new Set([
   "project_pages_list",
   "list_exports",
   "create_export",
-  "clear_temp"
+  "clear_temp",
+  "search_overview_get"
 ]);
 function serializeToolData(data) {
   try {
@@ -5260,6 +6694,20 @@ function createPrimeUiMcpServer(source) {
       }
     }
   );
+  server.registerTool(
+    "create_component_export",
+    toolCreateComponentExport,
+    async ({ componentId, projectRoot }) => {
+      try {
+        const result = await source.createComponentExport(componentId, {
+          projectRoot
+        });
+        return okResult("create_component_export", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
   server.registerTool(
     "download_export",
     toolDownloadExport,
@@ -5275,6 +6723,20 @@ function createPrimeUiMcpServer(source) {
       }
     }
   );
+  server.registerTool(
+    "download_component_export",
+    toolDownloadComponentExport,
+    async ({ id, projectRoot }) => {
+      try {
+        const result = await source.downloadComponentExportById(id, {
+          projectRoot
+        });
+        return okResult("download_component_export", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
   server.registerTool(
     "clear_temp",
     toolClearTemp,
@@ -5327,6 +6789,20 @@ function createPrimeUiMcpServer(source) {
       }
     }
   );
+  server.registerTool(
+    "copy_registry_component",
+    toolCopyRegistryComponent,
+    async ({ componentId, projectRoot }) => {
+      try {
+        const result = await source.copyRegistryComponent(componentId, {
+          projectRoot
+        });
+        return okResult("copy_registry_component", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
   server.registerTool(
     "copy_exportable",
     toolCopyExportable,
@@ -5344,6 +6820,99 @@ function createPrimeUiMcpServer(source) {
       }
     }
   );
+  server.registerTool(
+    "search_overview_get",
+    toolSearchOverviewGet,
+    async (args) => {
+      const { projectRoot } = args ?? {};
+      try {
+        const result = await source.getSearchOverview({ projectRoot });
+        return okResult("search_overview_get", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "search_environment_get",
+    toolSearchEnvironmentGet,
+    async ({ environmentSlug, projectRoot }) => {
+      try {
+        const result = await source.getSearchEnvironment(environmentSlug, { projectRoot });
+        return okResult("search_environment_get", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "search_environment_create",
+    toolSearchEnvironmentCreate,
+    async ({ name, projectRoot, slug }) => {
+      try {
+        const result = await source.createSearchEnvironment(
+          {
+            name,
+            slug
+          },
+          { projectRoot }
+        );
+        return okResult("search_environment_create", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "search_environment_update",
+    toolSearchEnvironmentUpdate,
+    async ({
+      environmentSlug,
+      name,
+      projectRoot,
+      status
+    }) => {
+      try {
+        const result = await source.updateSearchEnvironment(
+          {
+            environmentSlug,
+            ...name === void 0 ? {} : { name },
+            ...status === void 0 ? {} : { status }
+          },
+          { projectRoot }
+        );
+        return okResult("search_environment_update", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "search_environment_delete",
+    toolSearchEnvironmentDelete,
+    async ({ environmentSlug, projectRoot }) => {
+      try {
+        const result = await source.deleteSearchEnvironment(environmentSlug, {
+          projectRoot
+        });
+        return okResult("search_environment_delete", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.registerTool(
+    "search_environment_sync",
+    toolSearchEnvironmentSync,
+    async ({ environmentSlug, projectRoot }) => {
+      try {
+        const result = await source.syncSearchEnvironment(environmentSlug, { projectRoot });
+        return okResult("search_environment_sync", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
   return server;
 }