@wordrhyme/plugin 0.1.0-alpha.5

package/dist/chunk-QNCOGISF.js

@@ -0,0 +1,694 @@
+// src/manifest.ts
+import { z } from "zod";
+var aggregationStrategySchema = z.enum(["none", "by_target", "by_actor", "by_type"]);
+var notificationCategorySchema = z.enum(["system", "collaboration", "social"]);
+var notificationTypeSchema = z.object({
+  id: z.string().min(1).regex(/^[a-z0-9_]+$/, "type id must be lowercase alphanumeric with underscores"),
+  category: notificationCategorySchema,
+  aggregation: aggregationStrategySchema.default("none"),
+  i18n: z.record(
+    z.string(),
+    // locale key (e.g., 'en-US', 'zh-CN')
+    z.object({
+      title: z.string().min(1),
+      description: z.string().optional()
+    })
+  )
+});
+var notificationWebhooksSchema = z.object({
+  onClicked: z.string().url().optional(),
+  onArchived: z.string().url().optional()
+}).optional();
+var notificationRateLimitSchema = z.object({
+  maxPerMinute: z.number().int().positive().max(1e4).default(100),
+  maxPerHour: z.number().int().positive().max(2e4).default(1e3),
+  maxPerDay: z.number().int().positive().max(1e5).default(1e4)
+}).partial();
+var notificationPermissionSchema = z.enum([
+  "notification:send",
+  "notification:send:batch",
+  "notification:read:own"
+]);
+var notificationsConfigSchema = z.object({
+  types: z.array(notificationTypeSchema).min(1),
+  permissions: z.array(notificationPermissionSchema).optional(),
+  rateLimit: notificationRateLimitSchema.optional(),
+  webhooks: notificationWebhooksSchema
+}).optional();
+var permissionDeclarationSchema = z.union([
+  z.string().min(1),
+  z.object({
+    action: z.string().min(1),
+    subject: z.string().min(1),
+    anonymous: z.boolean().optional()
+  })
+]);
+var navTargetSchema = z.object({
+  slot: z.literal("nav.sidebar"),
+  path: z.string(),
+  icon: z.string().optional(),
+  order: z.number().optional(),
+  permission: permissionDeclarationSchema.optional(),
+  /** @deprecated Use permission instead. */
+  requiredPermission: z.string().optional(),
+  parent: z.string().optional()
+});
+var navGroupTargetSchema = z.object({
+  slot: z.literal("nav.sidebar.group"),
+  path: z.string().optional(),
+  icon: z.string().optional(),
+  order: z.number().optional()
+});
+var routeTargetSchema = z.object({
+  slot: z.literal("plugin.route"),
+  path: z.string(),
+  order: z.number().optional(),
+  params: z.record(z.string(), z.string()).optional()
+});
+var settingsTargetSchema = z.object({
+  slot: z.literal("settings.plugin"),
+  category: z.string().optional(),
+  order: z.number().optional(),
+  visibility: z.enum(["platform", "all"]).optional()
+});
+var dashboardTargetSchema = z.object({
+  slot: z.enum(["dashboard.widgets", "dashboard.overview"]),
+  order: z.number().optional(),
+  colSpan: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]).optional()
+});
+var genericTargetSchema = z.object({
+  slot: z.string(),
+  order: z.number().optional()
+});
+var targetSchema = z.union([
+  navTargetSchema,
+  navGroupTargetSchema,
+  routeTargetSchema,
+  settingsTargetSchema,
+  dashboardTargetSchema,
+  genericTargetSchema
+]);
+var adminExtensionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  icon: z.string().optional(),
+  targets: z.array(targetSchema).min(1)
+});
+var adminSlotPropSchema = z.union([
+  z.string().min(1),
+  z.object({
+    name: z.string().min(1),
+    type: z.string().optional(),
+    required: z.boolean().optional(),
+    description: z.string().optional()
+  }).passthrough()
+]);
+var adminSlotSchema = z.object({
+  slot: z.string().min(1),
+  description: z.string().optional(),
+  props: z.array(adminSlotPropSchema).optional()
+}).passthrough();
+var adminTourPlacementSchema = z.enum([
+  "top",
+  "top-start",
+  "top-end",
+  "bottom",
+  "bottom-start",
+  "bottom-end",
+  "left",
+  "left-start",
+  "left-end",
+  "right",
+  "right-start",
+  "right-end",
+  "auto",
+  "center"
+]);
+var adminTourStepSchema = z.object({
+  target: z.string().min(1),
+  title: z.string().min(1).optional(),
+  titleKey: z.string().min(1).optional(),
+  content: z.string().min(1).optional(),
+  contentKey: z.string().min(1).optional(),
+  placement: adminTourPlacementSchema.optional()
+}).refine((step) => Boolean(step.content || step.contentKey), {
+  message: "admin tour step must define content or contentKey",
+  path: ["content"]
+});
+var adminTourSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1).optional(),
+  labelKey: z.string().min(1).optional(),
+  routePatterns: z.array(z.string().min(1)).optional(),
+  order: z.number().optional(),
+  steps: z.array(adminTourStepSchema).min(1)
+});
+var pluginI18nSchema = z.record(
+  z.string().min(1),
+  z.record(z.string().min(1), z.string())
+);
+var extensionTargetPluginIdSchema = z.string().min(1).max(160).regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "target pluginId must be reverse-domain format");
+var crudIdSchema = z.string().min(1).max(80).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/, "crud id must be an identifier");
+var entityNameSchema = z.string().min(1).max(160).regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, 'entity must be dot-separated (e.g., "shop.store")');
+var extensionFieldNameSchema = z.string().min(1).max(80).regex(/^[a-zA-Z][a-zA-Z0-9_]*$/, "field must be an identifier");
+var entityExtensionFieldTypeSchema = z.enum([
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "select",
+  "ref",
+  "json"
+]);
+var entityExtensionRefSchema = z.object({
+  entity: entityNameSchema,
+  display: z.string().min(1).optional(),
+  changed: z.string().min(1).optional()
+}).passthrough();
+var autoCrudFieldOptionSchema = z.object({
+  label: z.string().min(1),
+  value: z.string().min(1),
+  searchText: z.union([
+    z.string().min(1),
+    z.array(z.string().min(1))
+  ]).optional(),
+  count: z.number().optional(),
+  disabled: z.boolean().optional()
+}).passthrough();
+var autoCrudDataSourceSchema = z.string().min(1);
+var autoCrudFieldConfigSchema = z.object({
+  label: z.string().min(1).optional(),
+  enum: z.array(autoCrudFieldOptionSchema).optional(),
+  dataSource: autoCrudDataSourceSchema.optional(),
+  hidden: z.boolean().optional(),
+  table: z.union([z.literal(false), z.record(z.string(), z.unknown())]).optional(),
+  filter: z.union([z.literal(false), z.record(z.string(), z.unknown())]).optional(),
+  form: z.union([z.literal(false), z.record(z.string(), z.unknown())]).optional(),
+  search: z.boolean().optional()
+}).passthrough();
+var entityExtensionOwnedFieldSchema = autoCrudFieldConfigSchema.extend({
+  label: z.string().min(1),
+  type: entityExtensionFieldTypeSchema,
+  ref: entityExtensionRefSchema.optional()
+});
+var entityExtensionFieldSchema = z.union([
+  entityExtensionOwnedFieldSchema,
+  autoCrudFieldConfigSchema
+]);
+var autoCrudActionZoneSchema = z.enum(["toolbar", "row", "batch"]);
+var autoCrudActionSchema = z.object({
+  type: z.enum([
+    "create",
+    "import",
+    "export",
+    "view",
+    "edit",
+    "copy",
+    "delete",
+    "batchUpdate",
+    "custom"
+  ]),
+  id: z.string().min(1).optional(),
+  label: z.string().min(1).optional(),
+  component: z.string().min(1).optional(),
+  onClick: z.string().min(1).optional(),
+  order: z.number().optional(),
+  hidden: z.boolean().optional(),
+  position: z.enum(["start", "end"]).optional(),
+  variant: z.enum(["default", "destructive"]).optional()
+}).passthrough();
+var autoCrudActionsSchema = z.object({
+  toolbar: z.array(autoCrudActionSchema).optional(),
+  row: z.array(autoCrudActionSchema).optional(),
+  batch: z.array(autoCrudActionSchema).optional()
+}).passthrough();
+var entityExtensionCrudConfigSchema = z.object({
+  fields: z.record(extensionFieldNameSchema, entityExtensionFieldSchema).optional(),
+  actions: autoCrudActionsSchema.optional()
+}).passthrough();
+var entityExtensionSlotSchema = z.object({
+  slot: z.string().min(1),
+  component: z.string().min(1),
+  order: z.number().optional(),
+  label: z.string().optional()
+}).passthrough();
+var entityExtensionBaseSchema = z.object({
+  fields: z.record(
+    crudIdSchema,
+    z.record(extensionFieldNameSchema, entityExtensionFieldSchema)
+  ).optional(),
+  slots: z.array(entityExtensionSlotSchema).optional(),
+  hide: z.record(crudIdSchema, z.array(extensionFieldNameSchema)).optional()
+}).passthrough();
+var entityExtensionSchema = entityExtensionBaseSchema.superRefine((extension, ctx) => {
+  const reservedKeys = /* @__PURE__ */ new Set(["fields", "slots", "hide"]);
+  for (const [key, value] of Object.entries(extension)) {
+    if (reservedKeys.has(key)) continue;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+    const record = value;
+    if (!("fields" in record) && !("actions" in record)) continue;
+    const parsed = entityExtensionCrudConfigSchema.safeParse(value);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        ctx.addIssue({
+          ...issue,
+          path: [key, ...issue.path]
+        });
+      }
+    }
+  }
+});
+var entityExtensionUseSchema = z.object({
+  pluginId: z.string().regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "pluginId must be reverse-domain format"),
+  targetId: z.string().min(1).max(240),
+  field: extensionFieldNameSchema,
+  required: z.boolean().optional()
+}).passthrough();
+var pluginUsesSchema = z.object({
+  extensions: z.array(entityExtensionUseSchema).optional()
+}).passthrough();
+var webSsrContractVersionSchema = z.union([z.literal(1), z.literal("1")]);
+var webPluginRouteSchema = z.object({
+  id: z.string().min(1).optional(),
+  path: z.string().min(1).regex(/^\//, "web route path must start with /"),
+  handler: z.string().min(1).optional(),
+  component: z.string().min(1),
+  permission: permissionDeclarationSchema.optional(),
+  order: z.number().optional()
+}).passthrough();
+var webExtensionTargetSchema = z.object({
+  pluginId: extensionTargetPluginIdSchema,
+  slot: z.string().min(1),
+  permission: permissionDeclarationSchema.optional(),
+  order: z.number().optional()
+}).passthrough();
+var webExtensionQuerySchema = z.object({
+  id: z.string().min(1),
+  procedure: z.string().min(1),
+  inputFrom: z.enum(["slotProps", "static"]).optional(),
+  staticInput: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+var webExtensionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1).optional(),
+  component: z.string().min(1),
+  expose: z.string().min(1).optional(),
+  permission: permissionDeclarationSchema.optional(),
+  targets: z.array(webExtensionTargetSchema).min(1),
+  queries: z.array(webExtensionQuerySchema).optional()
+}).passthrough();
+var webDesignBlockSchema = z.object({
+  id: z.string().min(1),
+  component: z.string().min(1),
+  title: z.string().min(1).optional(),
+  /** @deprecated Use title instead. */
+  label: z.string().min(1).optional(),
+  category: z.string().min(1).optional(),
+  icon: z.string().min(1).optional(),
+  defaultProps: z.record(z.string(), z.unknown()).optional(),
+  previewProps: z.record(z.string(), z.unknown()).optional(),
+  propsSchema: z.record(z.string(), z.unknown()).optional(),
+  settingsSchema: z.record(z.string(), z.unknown()).optional(),
+  designable: z.object({
+    resource: z.record(z.string(), z.unknown()).optional(),
+    behavior: z.record(z.string(), z.unknown()).optional()
+  }).optional(),
+  previewImage: z.string().min(1).optional(),
+  order: z.number().optional()
+}).passthrough().superRefine((block, ctx) => {
+  if ("schema" in block) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["schema"],
+      message: "web.design.blocks[] must not declare platform schema; use propsSchema/settingsSchema for configuration metadata"
+    });
+  }
+  if (!block.title && !block.label) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["title"],
+      message: "web.design.blocks[] must define title or label"
+    });
+  }
+});
+var webDesignSlotSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1).optional(),
+  scope: z.enum(["site", "route", "template", "entity"]).optional(),
+  routeId: z.string().min(1).optional(),
+  templateId: z.string().min(1).optional(),
+  acceptedBlocks: z.array(z.string().min(1)).optional(),
+  order: z.number().optional()
+}).passthrough();
+var webDesignTemplateSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1).optional(),
+  routeId: z.string().min(1).optional(),
+  entityType: z.string().min(1).optional(),
+  component: z.string().min(1),
+  slots: z.array(z.string().min(1)).optional(),
+  order: z.number().optional()
+}).passthrough();
+var webDesignDataSourceSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1).optional(),
+  /** @deprecated Use title instead. */
+  label: z.string().min(1).optional(),
+  permission: permissionDeclarationSchema.optional(),
+  inputSchema: z.record(z.string(), z.unknown()).optional(),
+  outputSchema: z.record(z.string(), z.unknown()).optional(),
+  order: z.number().optional()
+}).passthrough().superRefine((dataSource, ctx) => {
+  if (!dataSource.title && !dataSource.label) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["title"],
+      message: "web.design.dataSources[] must define title or label"
+    });
+  }
+});
+var webDesignActionSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1).optional(),
+  /** @deprecated Use title instead. */
+  label: z.string().min(1).optional(),
+  permission: permissionDeclarationSchema.optional(),
+  inputSchema: z.record(z.string(), z.unknown()).optional(),
+  order: z.number().optional()
+}).passthrough().superRefine((action, ctx) => {
+  if (!action.title && !action.label) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["title"],
+      message: "web.design.actions[] must define title or label"
+    });
+  }
+});
+var webDesignSurfaceSchema = z.object({
+  editorEntry: z.string().min(1).optional(),
+  previewEntry: z.string().min(1).optional(),
+  blocks: z.array(webDesignBlockSchema).optional(),
+  slots: z.array(webDesignSlotSchema).optional(),
+  templates: z.array(webDesignTemplateSchema).optional(),
+  dataSources: z.array(webDesignDataSourceSchema).optional(),
+  actions: z.array(webDesignActionSchema).optional()
+}).superRefine((design, ctx) => {
+  const hasDesignSurface = Boolean(
+    design.blocks?.length || design.slots?.length || design.templates?.length || design.dataSources?.length || design.actions?.length
+  );
+  if (!hasDesignSurface) {
+    ctx.addIssue({
+      code: "custom",
+      path: [],
+      message: "web.design must declare at least one block, slot, template, dataSource, or action"
+    });
+  }
+});
+var webSurfaceSchema = z.object({
+  ssrContractVersion: webSsrContractVersionSchema.optional(),
+  serverEntry: z.string().min(1).optional(),
+  clientEntry: z.string().min(1).optional(),
+  remoteEntry: z.string().min(1).optional(),
+  devRemoteEntry: z.string().min(1).optional(),
+  moduleName: z.string().min(1).optional(),
+  exposes: z.record(z.string(), z.string()).optional(),
+  routes: z.array(webPluginRouteSchema).optional(),
+  fills: z.never().optional(),
+  extensions: z.array(webExtensionSchema).optional(),
+  design: webDesignSurfaceSchema.optional(),
+  /** @deprecated Use serverEntry/clientEntry plus routes[].handler/component. */
+  entry: z.string().optional(),
+  /** @deprecated Use routes[].component. */
+  components: z.array(z.string()).optional()
+}).superRefine((web, ctx) => {
+  const hasRoutes = Boolean(web.routes?.length);
+  const hasExtensions = Boolean(web.extensions?.length);
+  const usesSsrSurface = Boolean(
+    web.ssrContractVersion || web.serverEntry || web.clientEntry || hasRoutes
+  );
+  const usesRemoteSurface = Boolean(
+    web.remoteEntry || web.devRemoteEntry || web.moduleName || web.exposes || hasExtensions
+  );
+  if (!usesSsrSurface && !usesRemoteSurface) return;
+  if (hasRoutes && !web.ssrContractVersion) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["ssrContractVersion"],
+      message: "web.ssrContractVersion is required for SSR web surface"
+    });
+  }
+  if (hasRoutes && !web.serverEntry) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["serverEntry"],
+      message: "web.serverEntry is required for SSR web surface"
+    });
+  }
+  if (hasRoutes && !web.clientEntry) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["clientEntry"],
+      message: "web.clientEntry is required for SSR web surface"
+    });
+  }
+  if (hasExtensions && !web.remoteEntry) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["remoteEntry"],
+      message: "web.remoteEntry is required when web.extensions are declared"
+    });
+  }
+  for (const [index, route] of (web.routes ?? []).entries()) {
+    if (!route.id) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["routes", index, "id"],
+        message: "web.routes[].id is required for SSR web surface"
+      });
+    }
+    if (!route.handler) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["routes", index, "handler"],
+        message: "web.routes[].handler is required for SSR web surface"
+      });
+    }
+    if (!route.permission) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["routes", index, "permission"],
+        message: "web.routes[].permission is required for SSR web surface"
+      });
+    }
+  }
+});
+var pluginManifestSchema = z.object({
+  // === Identity ===
+  pluginId: z.string().regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "pluginId must be reverse-domain format (e.g., com.vendor.plugin-name)"),
+  version: z.string().regex(/^\d+\.\d+\.\d+/, "version must be semver format"),
+  name: z.string().min(1).max(100),
+  description: z.string().max(500).optional(),
+  vendor: z.string().min(1).max(100),
+  private: z.boolean().optional(),
+  type: z.enum(["backend", "frontend", "full", "extension", "integration", "feature"]).optional(),
+  // === UI Translations ===
+  // Locale -> { key: translated text }. Stored under namespace `plugin.{pluginId}`.
+  i18n: pluginI18nSchema.optional(),
+  // === Runtime ===
+  runtime: z.enum(["node"]).default("node"),
+  // Note: surfaces is auto-generated from server/admin/web presence
+  // Used by plugin marketplace for filtering
+  // === Compatibility ===
+  engines: z.object({
+    wordrhyme: z.string(),
+    // semver range, e.g., "^0.1.0"
+    node: z.string().optional()
+    // e.g., ">=20.0.0"
+  }),
+  // === Capabilities Declared ===
+  capabilities: z.object({
+    ui: z.object({
+      adminPage: z.boolean().optional(),
+      webPage: z.boolean().optional(),
+      webTheme: z.boolean().optional(),
+      webDesigner: z.boolean().optional(),
+      settingsTab: z.boolean().optional()
+    }).optional(),
+    storage: z.object({
+      provider: z.boolean().optional()
+    }).optional(),
+    artifacts: z.object({
+      write: z.boolean().optional()
+    }).optional(),
+    provides: z.array(z.string()).optional(),
+    // e.g., ["logger-adapter", "cache-adapter"]
+    billing: z.object({
+      subjects: z.array(z.object({
+        subject: z.string().min(1).regex(
+          /^[a-z0-9-]+(\.[a-z0-9-]+)+\.[a-zA-Z0-9_]+$/,
+          'subject must be dot-separated (e.g., "com.vendor.plugin.apiCalls")'
+        ),
+        type: z.enum(["boolean", "metered"]),
+        unit: z.string().optional(),
+        description: z.string().optional()
+      })).optional(),
+      procedures: z.record(z.string(), z.string()).optional()
+    }).optional()
+  }).optional(),
+  // === Exports ===
+  exports: z.object({
+    loggerAdapter: z.string().optional(),
+    // e.g., "./dist/logger-adapter.js"
+    cacheAdapter: z.string().optional()
+  }).optional(),
+  // === Permissions Defined ===
+  permissions: z.object({
+    definitions: z.array(z.object({
+      key: z.string().regex(/^[a-z0-9_.]+$/, "Permission key must be lowercase with dots/underscores"),
+      description: z.string().optional()
+    })).optional(),
+    required: z.array(z.string()).optional(),
+    /**
+     * Quick-select action groups for the permission configuration UI.
+     * Keyed by CASL subject name. Each subject can have multiple groups,
+     * and groups may overlap (same action in multiple groups).
+     *
+     * @example
+     * ```json
+     * {
+     *   "Article": [
+     *     { "key": "editor", "label": "Editor", "actions": ["create", "update"] },
+     *     { "key": "full", "label": "Full Access", "actions": ["create", "update", "delete", "publish"] }
+     *   ]
+     * }
+     * ```
+     */
+    actionGroups: z.record(
+      z.string(),
+      // subject name
+      z.array(z.object({
+        key: z.string().min(1),
+        label: z.string().min(1),
+        actions: z.array(z.string().min(1)).min(1)
+      }))
+    ).optional()
+  }).optional(),
+  // === Server Entry ===
+  server: z.object({
+    entry: z.string(),
+    // e.g., "./dist/server/index.js"
+    router: z.boolean().optional(),
+    // Exports tRPC router
+    nestModule: z.string().optional(),
+    // NestJS module for advanced plugins, e.g., "./dist/server/hello.module.js"
+    fastifyRoutes: z.string().optional(),
+    // Fastify route registrar, e.g., "./dist/server/http/routes.js"
+    publicServices: z.array(z.object({
+      name: z.string().min(1).max(80).regex(/^[a-z0-9-]+$/),
+      mountPath: z.string().regex(/^\/api\/[a-z0-9/-]+$/),
+      methods: z.array(z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"])).min(1),
+      auth: z.enum(["public", "bearer", "session", "user"]).default("public"),
+      maxBodyBytes: z.number().int().positive().max(100 * 1024 * 1024).default(1024 * 1024)
+    })).optional(),
+    trustedApiTokenProxy: z.object({
+      invoker: z.string().min(1),
+      paths: z.array(z.string().min(1)).min(1)
+    }).optional(),
+    hooks: z.array(z.enum(["onInstall", "onEnable", "onDisable", "onUninstall"])).optional()
+  }).optional(),
+  // === Admin UI Entry ===
+  admin: z.object({
+    remoteEntry: z.string(),
+    // e.g., "./dist/admin/remoteEntry.js"
+    devRemoteEntry: z.string().optional(),
+    // Dev mode: e.g., "http://localhost:3010/remoteEntry.js"
+    moduleName: z.string().optional(),
+    // MF2.0 module name
+    exposes: z.record(z.string(), z.string()).optional(),
+    extensions: z.array(adminExtensionSchema).optional(),
+    slots: z.array(adminSlotSchema).optional(),
+    tours: z.array(adminTourSchema).optional(),
+    /** @deprecated Use slots instead. */
+    extensionSlots: z.array(adminSlotSchema).optional(),
+    /** @deprecated Use extensions[] instead */
+    menus: z.array(z.object({
+      label: z.string(),
+      icon: z.string().optional(),
+      path: z.string(),
+      order: z.number().optional(),
+      parentId: z.string().optional(),
+      permission: permissionDeclarationSchema.optional(),
+      /** @deprecated Use permission instead. */
+      requiredPermission: z.string().optional(),
+      metadata: z.record(z.string(), z.unknown()).optional()
+    })).optional()
+  }).optional(),
+  // === Web UI Entry ===
+  web: webSurfaceSchema.optional(),
+  // === Dependencies ===
+  dependencies: z.array(z.string()).optional(),
+  // Other plugin IDs
+  conflicts: z.array(z.string()).optional(),
+  // Conflicting plugin IDs
+  peerDependencies: z.record(z.string(), z.string()).optional(),
+  // e.g., { react: "^18.0.0" }
+  compatibilityMode: z.enum(["strict", "lenient", "fallback"]).optional(),
+  // === Entity Extensions ===
+  extends: z.record(extensionTargetPluginIdSchema, entityExtensionSchema).optional(),
+  uses: pluginUsesSchema.optional(),
+  // === Data Retention ===
+  dataRetention: z.object({
+    onDisable: z.enum(["retain"]).optional(),
+    onUninstall: z.enum(["delete", "archive", "retain"]).optional(),
+    tables: z.array(z.string()).optional()
+  }).optional(),
+  // === Infrastructure (Tenant Config Delegation) ===
+  infrastructure: z.object({
+    tenantOverride: z.boolean(),
+    riskLevel: z.enum(["high", "medium", "low"]),
+    sensitiveFields: z.array(z.string()).default([])
+  }).optional(),
+  // === Notifications ===
+  notifications: notificationsConfigSchema
+});
+
+export {
+  navTargetSchema,
+  navGroupTargetSchema,
+  routeTargetSchema,
+  settingsTargetSchema,
+  dashboardTargetSchema,
+  targetSchema,
+  adminExtensionSchema,
+  adminTourPlacementSchema,
+  adminTourStepSchema,
+  adminTourSchema,
+  pluginI18nSchema,
+  autoCrudFieldOptionSchema,
+  autoCrudDataSourceSchema,
+  autoCrudFieldConfigSchema,
+  entityExtensionFieldSchema,
+  autoCrudActionZoneSchema,
+  autoCrudActionSchema,
+  autoCrudActionsSchema,
+  entityExtensionCrudConfigSchema,
+  entityExtensionSlotSchema,
+  entityExtensionSchema,
+  entityExtensionUseSchema,
+  pluginUsesSchema,
+  webSsrContractVersionSchema,
+  webPluginRouteSchema,
+  webExtensionTargetSchema,
+  webExtensionQuerySchema,
+  webExtensionSchema,
+  webDesignBlockSchema,
+  webDesignSlotSchema,
+  webDesignTemplateSchema,
+  webDesignDataSourceSchema,
+  webDesignActionSchema,
+  webDesignSurfaceSchema,
+  webSurfaceSchema,
+  pluginManifestSchema
+};
+//# sourceMappingURL=chunk-QNCOGISF.js.map