@wordrhyme/plugin 0.1.0-alpha.10

package/dist/chunk-3IM3FPTJ.js

@@ -0,0 +1,1470 @@
+import {
+  canonicalizeLocale
+} from "./chunk-BI7E5CVM.js";
+
+// src/presentation.ts
+import { z } from "zod";
+var presentationIdPattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var pluginIdPattern = /^[a-z0-9-]+(\.[a-z0-9-]+)+$/;
+var contractVersionPattern = /^\d+(?:\.\d+){0,2}(?:-[0-9A-Za-z.-]+)?$/;
+var contractRangePattern = /^(?:\^|~|>=|<=|>|<)?\d+(?:\.\d+){0,2}(?:-[0-9A-Za-z.-]+)?$|^\d+(?:\.\d+)?\.(?:x|\*)$|^\d+\.(?:x|\*)$/;
+var presentationIdSchema = z.string().min(1).max(160).regex(presentationIdPattern, "presentation id must be URL-safe");
+var presentationPluginIdSchema = z.string().regex(pluginIdPattern, "pluginId must be reverse-domain format");
+var presentationContractVersionSchema = z.string().regex(contractVersionPattern, "contract version must contain one to three numeric semver components");
+var presentationContractRangeSchema = z.string().regex(contractRangePattern, "contract range must be an exact, comparator, caret, tilde, or wildcard range");
+var presentationSchemaRefSchema = z.union([z.string().min(1), z.record(z.string(), z.json())]);
+var presentationModelSchema = z.json();
+var presentationRenderModeSchema = z.enum(["ssr", "react", "island"]);
+var presentationRegionSchema = z.object({
+  id: presentationIdSchema,
+  label: z.string().min(1).optional(),
+  required: z.boolean().optional(),
+  accepts: z.array(presentationIdSchema).optional(),
+  contextSchema: presentationSchemaRefSchema.optional(),
+  min: z.number().int().nonnegative().optional(),
+  max: z.number().int().positive().optional(),
+  order: z.number().optional()
+}).superRefine((region, ctx) => {
+  if (region.min !== void 0 && region.max !== void 0 && region.min > region.max) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["min"],
+      message: "presentation region min must not exceed max"
+    });
+  }
+});
+var presentationActionSchema = z.object({
+  id: presentationIdSchema,
+  inputSchema: presentationSchemaRefSchema.optional(),
+  outputSchema: presentationSchemaRefSchema.optional(),
+  permission: z.string().min(1).optional()
+}).passthrough();
+var presentationSurfaceSchema = z.object({
+  id: presentationIdSchema,
+  contractVersion: presentationContractVersionSchema,
+  modelSchema: presentationSchemaRefSchema,
+  defaultRenderer: z.string().min(1),
+  clientComponent: z.string().min(1).optional(),
+  renderModes: z.array(presentationRenderModeSchema).min(1),
+  actions: z.array(presentationActionSchema).optional(),
+  regions: z.array(presentationRegionSchema).optional()
+}).superRefine((surface, ctx) => {
+  addDuplicateIdIssues(surface.actions, ["actions"], ctx);
+  addDuplicateIdIssues(surface.regions, ["regions"], ctx);
+});
+var presentationAdapterSchema = z.object({
+  id: presentationIdSchema.optional(),
+  label: z.string().min(1).optional(),
+  labelKey: z.string().min(1).optional(),
+  ownerPluginId: presentationPluginIdSchema,
+  surfaceId: presentationIdSchema,
+  accepts: presentationContractRangeSchema,
+  serverRenderer: z.string().min(1).optional(),
+  clientComponent: z.string().min(1).optional(),
+  expose: z.string().min(1).optional(),
+  required: z.boolean().optional(),
+  regions: z.array(presentationIdSchema).optional()
+}).superRefine((adapter, ctx) => {
+  if (!adapter.serverRenderer && !adapter.clientComponent) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["serverRenderer"],
+      message: "presentation adapter requires serverRenderer or clientComponent"
+    });
+  }
+});
+var themeAssetPathSchema = z.string().min(1).max(512).refine((value) => !value.startsWith("/") && !value.includes("\\"), {
+  message: "theme asset paths must be relative POSIX paths"
+}).refine((value) => value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".."), {
+  message: "theme asset paths must not contain empty, dot, or parent segments"
+});
+var themeAssetSchema = z.object({
+  path: themeAssetPathSchema,
+  kind: z.enum(["stylesheet", "script", "font", "image", "other"]),
+  integrity: z.string().min(1).optional(),
+  media: z.string().min(1).optional(),
+  preload: z.boolean().optional(),
+  order: z.number().optional()
+}).passthrough();
+var themeHeadSchema = z.object({
+  title: z.string().min(1).max(300).optional(),
+  description: z.string().max(1e3).optional(),
+  meta: z.record(z.string().min(1).max(120), z.string().max(2048)).optional(),
+  links: z.array(z.object({
+    rel: z.string().min(1).max(80),
+    href: z.string().min(1).max(2048),
+    as: z.string().min(1).max(80).optional(),
+    type: z.string().min(1).max(160).optional()
+  })).optional()
+});
+var themeTokenTypeSchema = z.enum(["color", "length", "font-family", "number", "shadow", "enum", "image"]);
+var themeTokenSchema = z.object({
+  id: presentationIdSchema,
+  cssVariable: z.string().regex(/^--[a-z0-9][a-z0-9-]*$/, "theme token cssVariable must be a CSS custom property"),
+  type: themeTokenTypeSchema,
+  default: z.json(),
+  enumValues: z.array(z.string().min(1)).optional(),
+  label: z.string().min(1).optional(),
+  labelKey: z.string().min(1).optional(),
+  description: z.string().optional(),
+  descriptionKey: z.string().min(1).optional()
+}).superRefine((token, ctx) => {
+  if (token.type === "enum" && !token.enumValues?.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["enumValues"],
+      message: "enum theme tokens require enumValues"
+    });
+  }
+});
+var themeTokenPresetSchema = z.object({
+  id: presentationIdSchema,
+  label: z.string().min(1).optional(),
+  labelKey: z.string().min(1).optional(),
+  description: z.string().optional(),
+  descriptionKey: z.string().min(1).optional(),
+  extends: presentationIdSchema.optional(),
+  values: z.record(presentationIdSchema, z.json())
+});
+var themeSiteShellSchema = z.union([
+  z.string().min(1),
+  z.object({
+    serverRenderer: z.string().min(1),
+    clientComponent: z.string().min(1).optional(),
+    expose: z.string().min(1).optional()
+  })
+]);
+var themeHomeTargetSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("theme-route"),
+    routeId: presentationIdSchema
+  }),
+  z.object({
+    type: z.literal("plugin-route"),
+    pluginId: presentationPluginIdSchema,
+    routeId: presentationIdSchema
+  }),
+  z.object({
+    type: z.literal("designer-page"),
+    pageId: z.string().min(1).max(160)
+  }),
+  z.object({
+    type: z.literal("default")
+  })
+]);
+var themeIntegrationSchema = z.object({
+  pluginId: presentationPluginIdSchema,
+  required: z.boolean().optional(),
+  surfaces: z.array(
+    z.object({
+      id: presentationIdSchema,
+      accepts: presentationContractRangeSchema,
+      required: z.boolean().optional()
+    })
+  ).optional(),
+  storefrontApis: z.array(
+    z.object({
+      id: presentationIdSchema,
+      accepts: presentationContractRangeSchema,
+      required: z.boolean().optional()
+    })
+  ).optional()
+});
+var webPresentationSchema = z.object({
+  contractVersion: z.literal(1),
+  shell: themeSiteShellSchema.optional(),
+  defaultHomeRouteId: presentationIdSchema.optional(),
+  head: themeHeadSchema.optional(),
+  assets: z.array(themeAssetSchema).optional(),
+  tokens: z.array(themeTokenSchema).optional(),
+  presets: z.array(themeTokenPresetSchema).optional(),
+  settingsSchema: themeAssetPathSchema.optional(),
+  settingsVersion: z.number().int().positive().optional(),
+  adapters: z.array(presentationAdapterSchema).optional(),
+  integrations: z.array(themeIntegrationSchema).optional()
+}).superRefine((presentation, ctx) => {
+  const hasDeclaration = Boolean(
+    presentation.shell || presentation.defaultHomeRouteId || presentation.head || presentation.assets?.length || presentation.tokens?.length || presentation.presets?.length || presentation.settingsSchema || presentation.adapters?.length || presentation.integrations?.length
+  );
+  if (!hasDeclaration) {
+    ctx.addIssue({
+      code: "custom",
+      path: [],
+      message: "web.presentation must declare at least one presentation resource"
+    });
+  }
+  addDuplicateIdIssues(presentation.tokens, ["tokens"], ctx);
+  addDuplicateIdIssues(presentation.presets, ["presets"], ctx);
+  const adapterKeys = /* @__PURE__ */ new Set();
+  for (const [index, adapter] of (presentation.adapters ?? []).entries()) {
+    const key = `${adapter.ownerPluginId}:${adapter.surfaceId}`;
+    if (adapterKeys.has(key)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["adapters", index, "surfaceId"],
+        message: `duplicate presentation adapter target: ${key}`
+      });
+    }
+    adapterKeys.add(key);
+  }
+  validatePresetGraph(presentation.presets ?? [], ctx);
+});
+var presentationDiagnosticSeveritySchema = z.enum(["info", "warning", "error"]);
+var presentationCompatibilityStatusSchema = z.enum(["compatible", "incompatible", "missing"]);
+var presentationDiagnosticSchema = z.object({
+  code: z.string().min(1),
+  severity: presentationDiagnosticSeveritySchema,
+  ownerPluginId: presentationPluginIdSchema,
+  contractId: presentationIdSchema,
+  expectedRange: presentationContractRangeSchema.optional(),
+  actualVersion: presentationContractVersionSchema.optional(),
+  required: z.boolean(),
+  remediation: z.enum(["install", "enable", "upgrade-owner", "upgrade-theme", "disable-integration", "fallback"]),
+  message: z.string().min(1)
+});
+var presentationCompatibilityResultSchema = z.object({
+  status: presentationCompatibilityStatusSchema,
+  diagnostic: presentationDiagnosticSchema.optional()
+});
+var PRESENTATION_OBSERVABILITY = {
+  spans: {
+    resolve: "site.presentation.resolve",
+    shell: "site.presentation.shell.render",
+    adapter: "site.presentation.adapter.render",
+    storefront: "site.presentation.storefront.call",
+    designNode: "site.presentation.design-node.render",
+    embed: "site.presentation.embed.load"
+  },
+  metrics: {
+    resolution: "site_presentation_resolution_total",
+    fallback: "site_presentation_fallback_total",
+    renderDuration: "site_presentation_render_duration_ms",
+    compatibility: "site_presentation_compatibility_total"
+  },
+  auditEvents: {
+    previewIssued: "site.theme.preview.issued",
+    published: "site.theme.published",
+    rolledBack: "site.theme.rolled_back",
+    safeModeEntered: "site.theme.safe_mode.entered",
+    safeModeRecovered: "site.theme.safe_mode.recovered"
+  },
+  fields: [
+    "organizationId",
+    "themePluginId",
+    "themeVersion",
+    "revisionId",
+    "presentationMode",
+    "routeId",
+    "surfaceId",
+    "contractVersion",
+    "fallbackReason",
+    "pluginLoadGeneration"
+  ]
+};
+function defineWebPresentation(presentation) {
+  return presentation;
+}
+function defineThemeHomeTarget(target) {
+  return target;
+}
+function definePresentationSurface(surface) {
+  return surface;
+}
+function definePresentationAdapter(adapter) {
+  return adapter;
+}
+function parsePresentationModel(value) {
+  return presentationModelSchema.parse(value);
+}
+function evaluatePresentationCompatibility(check) {
+  if (!check.actualVersion) {
+    return {
+      status: "missing",
+      diagnostic: {
+        code: `presentation.${check.kind ?? "surface"}.missing`,
+        severity: check.required ? "error" : "warning",
+        ownerPluginId: check.ownerPluginId,
+        contractId: check.contractId,
+        expectedRange: check.expectedRange,
+        required: check.required,
+        remediation: "install",
+        message: `Missing ${check.ownerPluginId}:${check.contractId} ${check.expectedRange}`
+      }
+    };
+  }
+  if (satisfiesPresentationRange(check.actualVersion, check.expectedRange)) {
+    return { status: "compatible" };
+  }
+  return {
+    status: "incompatible",
+    diagnostic: {
+      code: `presentation.${check.kind ?? "surface"}.version_mismatch`,
+      severity: check.required ? "error" : "warning",
+      ownerPluginId: check.ownerPluginId,
+      contractId: check.contractId,
+      expectedRange: check.expectedRange,
+      actualVersion: check.actualVersion,
+      required: check.required,
+      remediation: check.required ? "upgrade-theme" : "fallback",
+      message: `Expected ${check.expectedRange}, received ${check.actualVersion}`
+    }
+  };
+}
+function satisfiesPresentationRange(version, range) {
+  const parsedVersion = parseVersion(version);
+  if (!parsedVersion) return false;
+  if (range.endsWith(".x") || range.endsWith(".*")) {
+    const prefix = range.slice(0, -2).split(".").map(Number);
+    if (prefix.some(Number.isNaN)) return false;
+    return prefix.every((part, index) => parsedVersion[index] === part);
+  }
+  const comparator = range.match(/^(\^|~|>=|<=|>|<)?(.+)$/);
+  if (!comparator) return false;
+  const operator = comparator[1] ?? "=";
+  const base = parseVersion(comparator[2] ?? "");
+  if (!base) return false;
+  const comparison = compareVersion(parsedVersion, base);
+  if (operator === "=") return comparison === 0;
+  if (operator === ">=") return comparison >= 0;
+  if (operator === "<=") return comparison <= 0;
+  if (operator === ">") return comparison > 0;
+  if (operator === "<") return comparison < 0;
+  if (comparison < 0) return false;
+  if (operator === "~") {
+    return parsedVersion[0] === base[0] && parsedVersion[1] === base[1];
+  }
+  if (base[0] > 0) return parsedVersion[0] === base[0];
+  if (base[1] > 0) return parsedVersion[0] === 0 && parsedVersion[1] === base[1];
+  return parsedVersion[0] === 0 && parsedVersion[1] === 0 && parsedVersion[2] === base[2];
+}
+function addDuplicateIdIssues(values, path, ctx) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, value] of (values ?? []).entries()) {
+    if (ids.has(value.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, index, "id"],
+        message: `duplicate presentation id: ${value.id}`
+      });
+    }
+    ids.add(value.id);
+  }
+}
+function validatePresetGraph(presets, ctx) {
+  const byId = new Map(presets.map((preset) => [preset.id, preset]));
+  for (const [index, preset] of presets.entries()) {
+    if (preset.extends && !byId.has(preset.extends)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["presets", index, "extends"],
+        message: `unknown theme token preset: ${preset.extends}`
+      });
+      continue;
+    }
+    const visited = /* @__PURE__ */ new Set();
+    let current = preset;
+    while (current?.extends) {
+      if (visited.has(current.id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["presets", index, "extends"],
+          message: `cyclic theme token preset inheritance: ${preset.id}`
+        });
+        break;
+      }
+      visited.add(current.id);
+      current = byId.get(current.extends);
+    }
+  }
+}
+function parseVersion(value) {
+  const core = value.split("-")[0];
+  if (!core) return null;
+  const parts = core.split(".");
+  if (parts.length < 1 || parts.length > 3) return null;
+  const numbers = parts.map(Number);
+  if (numbers.some((part) => !Number.isInteger(part) || part < 0)) return null;
+  return [numbers[0] ?? 0, numbers[1] ?? 0, numbers[2] ?? 0];
+}
+function compareVersion(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+
+// src/storefront.ts
+import { z as z2 } from "zod";
+var storefrontOperationKindSchema = z2.enum(["query", "command"]);
+var storefrontOperationSchema = z2.object({
+  id: presentationIdSchema,
+  kind: storefrontOperationKindSchema,
+  inputSchema: presentationSchemaRefSchema,
+  outputSchema: presentationSchemaRefSchema,
+  anonymous: z2.boolean().optional(),
+  permission: z2.string().min(1).optional()
+}).passthrough();
+var storefrontApiSchema = z2.object({
+  id: presentationIdSchema,
+  version: presentationContractVersionSchema,
+  serverExport: z2.string().min(1),
+  browserExport: z2.string().min(1).optional(),
+  operations: z2.array(storefrontOperationSchema).min(1),
+  openapi: z2.object({
+    basePath: z2.string().regex(/^\/v\d+(?:\/[a-z0-9-]+)*$/),
+    cors: z2.enum(["site-origin", "allowlist", "disabled"]).optional()
+  }).optional()
+}).superRefine((api, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, operation] of api.operations.entries()) {
+    if (ids.has(operation.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["operations", index, "id"],
+        message: `duplicate Storefront operation: ${operation.id}`
+      });
+    }
+    ids.add(operation.id);
+  }
+});
+function defineStorefrontApi(api) {
+  return api;
+}
+
+// src/web-design.ts
+import { z as z3 } from "zod";
+var webDesignNodeKindSchema = z3.enum(["content", "container", "app-block"]);
+var webDesignRegionSchema = z3.object({
+  id: presentationIdSchema,
+  label: z3.string().min(1).optional(),
+  accepts: z3.array(presentationIdSchema).optional(),
+  min: z3.number().int().nonnegative().optional(),
+  max: z3.number().int().positive().optional(),
+  required: z3.boolean().optional()
+}).superRefine((region, ctx) => {
+  if (region.min !== void 0 && region.max !== void 0 && region.min > region.max) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["min"],
+      message: "Web Designer region min must not exceed max"
+    });
+  }
+});
+var webDesignBindingSchema = z3.object({
+  id: presentationIdSchema,
+  source: presentationIdSchema,
+  inputSchema: presentationSchemaRefSchema.optional(),
+  outputSchema: presentationSchemaRefSchema.optional()
+});
+var webDesignMigrationSchema = z3.object({
+  from: presentationContractVersionSchema,
+  to: presentationContractVersionSchema,
+  handler: z3.string().min(1)
+});
+var webDesignNodeDefinitionSchema = z3.object({
+  id: presentationIdSchema,
+  version: presentationContractVersionSchema,
+  kind: webDesignNodeKindSchema,
+  title: z3.string().min(1),
+  category: z3.string().min(1).optional(),
+  icon: z3.string().min(1).optional(),
+  settingsSchema: presentationSchemaRefSchema.optional(),
+  contextSchema: presentationSchemaRefSchema.optional(),
+  editorComponent: z3.string().min(1),
+  serverRenderer: z3.string().min(1),
+  clientComponent: z3.string().min(1).optional(),
+  regions: z3.array(webDesignRegionSchema).optional(),
+  bindings: z3.array(webDesignBindingSchema).optional(),
+  actions: z3.array(presentationIdSchema).optional(),
+  migrations: z3.array(webDesignMigrationSchema).optional()
+}).superRefine((node, ctx) => {
+  if (node.kind === "container" && !node.regions?.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["regions"],
+      message: "container Web Designer nodes require at least one region"
+    });
+  }
+});
+var webAppEmbedTargetSchema = z3.enum(["head", "body-start", "body-end", "floating-layer"]);
+var webAppEmbedConsentSchema = z3.enum(["necessary", "functional", "analytics", "marketing"]);
+var webAppEmbedSchema = z3.object({
+  id: presentationIdSchema,
+  version: presentationContractVersionSchema,
+  title: z3.string().min(1),
+  target: webAppEmbedTargetSchema,
+  clientComponent: z3.string().min(1),
+  settingsSchema: presentationSchemaRefSchema.optional(),
+  consent: webAppEmbedConsentSchema.optional(),
+  csp: z3.object({
+    scriptSrc: z3.array(z3.string().min(1)).optional(),
+    connectSrc: z3.array(z3.string().min(1)).optional(),
+    frameSrc: z3.array(z3.string().min(1)).optional(),
+    imgSrc: z3.array(z3.string().min(1)).optional()
+  }).optional(),
+  order: z3.number().optional()
+});
+function defineWebDesignNode(node) {
+  return node;
+}
+function defineAppEmbed(embed) {
+  return embed;
+}
+
+// src/manifest.ts
+import { z as z4 } from "zod";
+var aggregationStrategySchema = z4.enum(["none", "by_target", "by_actor", "by_type"]);
+var notificationCategorySchema = z4.enum(["system", "collaboration", "social"]);
+var notificationTypeSchema = z4.object({
+  id: z4.string().min(1).regex(/^[a-z0-9_]+$/, "type id must be lowercase alphanumeric with underscores"),
+  category: notificationCategorySchema,
+  aggregation: aggregationStrategySchema.default("none"),
+  i18n: z4.record(
+    z4.string(),
+    // locale key (e.g., 'en-US', 'zh-CN')
+    z4.object({
+      title: z4.string().min(1),
+      description: z4.string().optional()
+    })
+  )
+});
+var notificationWebhooksSchema = z4.object({
+  onClicked: z4.string().url().optional(),
+  onArchived: z4.string().url().optional()
+}).optional();
+var notificationRateLimitSchema = z4.object({
+  maxPerMinute: z4.number().int().positive().max(1e4).default(100),
+  maxPerHour: z4.number().int().positive().max(2e4).default(1e3),
+  maxPerDay: z4.number().int().positive().max(1e5).default(1e4)
+}).partial();
+var notificationPermissionSchema = z4.enum([
+  "notification:send",
+  "notification:send:batch",
+  "notification:read:own"
+]);
+var notificationsConfigSchema = z4.object({
+  types: z4.array(notificationTypeSchema).min(1),
+  permissions: z4.array(notificationPermissionSchema).optional(),
+  rateLimit: notificationRateLimitSchema.optional(),
+  webhooks: notificationWebhooksSchema
+}).optional();
+var permissionDeclarationSchema = z4.union([
+  z4.string().min(1),
+  z4.object({
+    action: z4.string().min(1),
+    subject: z4.string().min(1),
+    anonymous: z4.boolean().optional()
+  })
+]);
+var navTargetSchema = z4.object({
+  slot: z4.literal("nav.sidebar"),
+  path: z4.string(),
+  icon: z4.string().optional(),
+  order: z4.number().optional(),
+  permission: permissionDeclarationSchema.optional(),
+  /** @deprecated Use permission instead. */
+  requiredPermission: z4.string().optional(),
+  parent: z4.string().optional()
+});
+var navGroupTargetSchema = z4.object({
+  slot: z4.literal("nav.sidebar.group"),
+  path: z4.string().optional(),
+  icon: z4.string().optional(),
+  order: z4.number().optional()
+});
+var routeTargetSchema = z4.object({
+  slot: z4.literal("plugin.route"),
+  path: z4.string(),
+  order: z4.number().optional(),
+  params: z4.record(z4.string(), z4.string()).optional()
+});
+var marketplaceTabTargetSchema = z4.object({
+  slot: z4.literal("marketplace.tabs"),
+  value: z4.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/, "marketplace tab value must be URL-safe"),
+  order: z4.number().optional(),
+  visibility: z4.enum(["platform", "all"]).optional()
+});
+var settingsTargetSchema = z4.object({
+  slot: z4.literal("settings.plugin"),
+  category: z4.string().optional(),
+  order: z4.number().optional(),
+  visibility: z4.enum(["platform", "all"]).optional()
+});
+var dashboardTargetSchema = z4.object({
+  slot: z4.enum(["dashboard.widgets", "dashboard.overview"]),
+  order: z4.number().optional(),
+  colSpan: z4.union([z4.literal(1), z4.literal(2), z4.literal(3), z4.literal(4)]).optional()
+});
+var genericTargetSchema = z4.object({
+  slot: z4.string(),
+  order: z4.number().optional()
+});
+var targetSchema = z4.union([
+  navTargetSchema,
+  navGroupTargetSchema,
+  routeTargetSchema,
+  marketplaceTabTargetSchema,
+  settingsTargetSchema,
+  dashboardTargetSchema,
+  genericTargetSchema
+]);
+var adminExtensionSchema = z4.object({
+  id: z4.string().min(1),
+  label: z4.string().min(1),
+  icon: z4.string().optional(),
+  hidden: z4.boolean().optional(),
+  targets: z4.array(targetSchema).min(1)
+});
+var adminSlotPropSchema = z4.union([
+  z4.string().min(1),
+  z4.object({
+    name: z4.string().min(1),
+    type: z4.string().optional(),
+    required: z4.boolean().optional(),
+    description: z4.string().optional()
+  }).passthrough()
+]);
+var adminSlotSchema = z4.object({
+  slot: z4.string().min(1),
+  description: z4.string().optional(),
+  props: z4.array(adminSlotPropSchema).optional()
+}).passthrough();
+var adminTourPlacementSchema = z4.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 = z4.object({
+  target: z4.string().min(1),
+  title: z4.string().min(1).optional(),
+  titleKey: z4.string().min(1).optional(),
+  content: z4.string().min(1).optional(),
+  contentKey: z4.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 = z4.object({
+  id: z4.string().min(1),
+  label: z4.string().min(1).optional(),
+  labelKey: z4.string().min(1).optional(),
+  routePatterns: z4.array(z4.string().min(1)).optional(),
+  order: z4.number().optional(),
+  steps: z4.array(adminTourStepSchema).min(1)
+});
+var pluginTranslationRecordSchema = z4.record(z4.string().min(1), z4.string());
+function normalizeLocaleRecord(value, ctx) {
+  const normalized = {};
+  for (const [rawLocale, message] of Object.entries(value)) {
+    const locale = canonicalizeLocale(rawLocale);
+    if (!locale) {
+      ctx.addIssue({
+        code: "custom",
+        path: [rawLocale],
+        message: `Invalid BCP 47 locale: ${rawLocale}`
+      });
+      continue;
+    }
+    if (locale in normalized && normalized[locale] !== message) {
+      ctx.addIssue({
+        code: "custom",
+        path: [rawLocale],
+        message: `Duplicate canonical locale: ${locale}`
+      });
+      continue;
+    }
+    normalized[locale] = message;
+  }
+  return normalized;
+}
+var pluginKeyFirstMessagesSchema = z4.record(
+  z4.string().min(1),
+  pluginTranslationRecordSchema.transform(normalizeLocaleRecord)
+);
+var pluginLocaleFirstMessagesSchema = z4.record(
+  z4.string(),
+  pluginTranslationRecordSchema
+).transform((value, ctx) => {
+  const normalized = {};
+  for (const [rawLocale, messages] of Object.entries(value)) {
+    const locale = canonicalizeLocale(rawLocale);
+    if (!locale) {
+      ctx.addIssue({
+        code: "custom",
+        path: [rawLocale],
+        message: `Invalid BCP 47 locale: ${rawLocale}`
+      });
+      continue;
+    }
+    if (locale in normalized) {
+      ctx.addIssue({
+        code: "custom",
+        path: [rawLocale],
+        message: `Duplicate canonical locale: ${locale}`
+      });
+      continue;
+    }
+    normalized[locale] = messages;
+  }
+  return normalized;
+});
+var pluginI18nConfigSchema = z4.object({
+  namespace: z4.string().min(1).optional(),
+  messages: pluginKeyFirstMessagesSchema.optional(),
+  localesFile: z4.string().min(1).optional(),
+  onUninstall: z4.enum(["delete", "archive", "retain"]).optional()
+}).strict();
+var pluginI18nSchema = z4.union([
+  pluginLocaleFirstMessagesSchema,
+  pluginI18nConfigSchema
+]);
+var extensionTargetPluginIdSchema = z4.string().min(1).max(160).regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "target pluginId must be reverse-domain format");
+var crudIdSchema = z4.string().min(1).max(80).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/, "crud id must be an identifier");
+var entityNameSchema = z4.string().min(1).max(160).regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, 'entity must be dot-separated (e.g., "shop.store")');
+var extensionFieldNameSchema = z4.string().min(1).max(80).regex(/^[a-zA-Z][a-zA-Z0-9_]*$/, "field must be an identifier");
+var entityExtensionFieldTypeSchema = z4.enum([
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "select",
+  "ref",
+  "json"
+]);
+var entityExtensionRefSchema = z4.object({
+  entity: entityNameSchema,
+  display: z4.string().min(1).optional(),
+  changed: z4.string().min(1).optional()
+}).passthrough();
+var autoCrudFieldOptionSchema = z4.object({
+  label: z4.string().min(1),
+  value: z4.string().min(1),
+  searchText: z4.union([
+    z4.string().min(1),
+    z4.array(z4.string().min(1))
+  ]).optional(),
+  count: z4.number().optional(),
+  disabled: z4.boolean().optional()
+}).passthrough();
+var autoCrudDataSourceSchema = z4.string().min(1);
+var autoCrudFieldConfigSchema = z4.object({
+  label: z4.string().min(1).optional(),
+  enum: z4.array(autoCrudFieldOptionSchema).optional(),
+  dataSource: autoCrudDataSourceSchema.optional(),
+  hidden: z4.boolean().optional(),
+  table: z4.union([z4.literal(false), z4.record(z4.string(), z4.unknown())]).optional(),
+  filter: z4.union([z4.literal(false), z4.record(z4.string(), z4.unknown())]).optional(),
+  form: z4.union([z4.literal(false), z4.record(z4.string(), z4.unknown())]).optional(),
+  search: z4.boolean().optional()
+}).passthrough();
+var entityExtensionOwnedFieldSchema = autoCrudFieldConfigSchema.extend({
+  label: z4.string().min(1),
+  type: entityExtensionFieldTypeSchema,
+  ref: entityExtensionRefSchema.optional()
+});
+var entityExtensionFieldSchema = z4.union([
+  entityExtensionOwnedFieldSchema,
+  autoCrudFieldConfigSchema
+]);
+var autoCrudActionZoneSchema = z4.enum(["toolbar", "row", "batch"]);
+var autoCrudActionSchema = z4.object({
+  type: z4.enum([
+    "create",
+    "import",
+    "export",
+    "view",
+    "edit",
+    "copy",
+    "delete",
+    "batchUpdate",
+    "custom"
+  ]),
+  id: z4.string().min(1).optional(),
+  label: z4.string().min(1).optional(),
+  component: z4.string().min(1).optional(),
+  onClick: z4.string().min(1).optional(),
+  order: z4.number().optional(),
+  hidden: z4.boolean().optional(),
+  position: z4.enum(["start", "end"]).optional(),
+  variant: z4.enum(["default", "destructive"]).optional()
+}).passthrough();
+var autoCrudActionsSchema = z4.object({
+  toolbar: z4.array(autoCrudActionSchema).optional(),
+  row: z4.array(autoCrudActionSchema).optional(),
+  batch: z4.array(autoCrudActionSchema).optional()
+}).passthrough();
+var entityExtensionCrudConfigSchema = z4.object({
+  fields: z4.record(extensionFieldNameSchema, entityExtensionFieldSchema).optional(),
+  actions: autoCrudActionsSchema.optional()
+}).passthrough();
+var entityExtensionSlotSchema = z4.object({
+  slot: z4.string().min(1),
+  component: z4.string().min(1),
+  order: z4.number().optional(),
+  label: z4.string().optional()
+}).passthrough();
+var entityExtensionBaseSchema = z4.object({
+  fields: z4.record(
+    crudIdSchema,
+    z4.record(extensionFieldNameSchema, entityExtensionFieldSchema)
+  ).optional(),
+  slots: z4.array(entityExtensionSlotSchema).optional(),
+  hide: z4.record(crudIdSchema, z4.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 = z4.object({
+  pluginId: z4.string().regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "pluginId must be reverse-domain format"),
+  targetId: z4.string().min(1).max(240),
+  field: extensionFieldNameSchema,
+  required: z4.boolean().optional()
+}).passthrough();
+var pluginUsesSchema = z4.object({
+  extensions: z4.array(entityExtensionUseSchema).optional()
+}).passthrough();
+var webSsrContractVersionSchema = z4.union([z4.literal(1), z4.literal("1")]);
+var webPluginRouteSchema = z4.object({
+  id: z4.string().min(1).optional(),
+  path: z4.string().min(1).regex(/^\//, "web route path must start with /"),
+  handler: z4.string().min(1).optional(),
+  component: z4.string().min(1),
+  permission: permissionDeclarationSchema.optional(),
+  order: z4.number().optional()
+}).passthrough();
+var webExtensionTargetSchema = z4.object({
+  pluginId: extensionTargetPluginIdSchema,
+  slot: z4.string().min(1),
+  permission: permissionDeclarationSchema.optional(),
+  order: z4.number().optional()
+}).passthrough();
+var webExtensionQuerySchema = z4.object({
+  id: z4.string().min(1),
+  procedure: z4.string().min(1),
+  inputFrom: z4.enum(["slotProps", "static"]).optional(),
+  staticInput: z4.record(z4.string(), z4.unknown()).optional()
+}).passthrough();
+var webExtensionSchema = z4.object({
+  id: z4.string().min(1),
+  label: z4.string().min(1).optional(),
+  component: z4.string().min(1),
+  expose: z4.string().min(1).optional(),
+  permission: permissionDeclarationSchema.optional(),
+  targets: z4.array(webExtensionTargetSchema).min(1),
+  queries: z4.array(webExtensionQuerySchema).optional()
+}).passthrough();
+var webDesignBlockSchema = z4.object({
+  id: z4.string().min(1),
+  component: z4.string().min(1),
+  title: z4.string().min(1).optional(),
+  /** @deprecated Use title instead. */
+  label: z4.string().min(1).optional(),
+  category: z4.string().min(1).optional(),
+  icon: z4.string().min(1).optional(),
+  defaultProps: z4.record(z4.string(), z4.unknown()).optional(),
+  previewProps: z4.record(z4.string(), z4.unknown()).optional(),
+  propsSchema: z4.record(z4.string(), z4.unknown()).optional(),
+  settingsSchema: z4.record(z4.string(), z4.unknown()).optional(),
+  designable: z4.object({
+    resource: z4.record(z4.string(), z4.unknown()).optional(),
+    behavior: z4.record(z4.string(), z4.unknown()).optional()
+  }).optional(),
+  previewImage: z4.string().min(1).optional(),
+  order: z4.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 = z4.object({
+  id: z4.string().min(1),
+  label: z4.string().min(1).optional(),
+  renderMode: z4.enum(["island", "react"]).optional(),
+  scope: z4.enum(["site", "route", "template", "entity"]).optional(),
+  routeId: z4.string().min(1).optional(),
+  templateId: z4.string().min(1).optional(),
+  acceptedBlocks: z4.array(z4.string().min(1)).optional(),
+  order: z4.number().optional()
+}).passthrough();
+var webDesignTemplateSchema = z4.object({
+  id: z4.string().min(1),
+  label: z4.string().min(1).optional(),
+  routeId: z4.string().min(1).optional(),
+  entityType: z4.string().min(1).optional(),
+  component: z4.string().min(1),
+  slots: z4.array(z4.string().min(1)).optional(),
+  order: z4.number().optional()
+}).passthrough();
+var webDesignDataSourceSchema = z4.object({
+  id: z4.string().min(1),
+  title: z4.string().min(1).optional(),
+  /** @deprecated Use title instead. */
+  label: z4.string().min(1).optional(),
+  permission: permissionDeclarationSchema.optional(),
+  inputSchema: z4.record(z4.string(), z4.unknown()).optional(),
+  outputSchema: z4.record(z4.string(), z4.unknown()).optional(),
+  order: z4.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 = z4.object({
+  id: z4.string().min(1),
+  title: z4.string().min(1).optional(),
+  /** @deprecated Use title instead. */
+  label: z4.string().min(1).optional(),
+  permission: permissionDeclarationSchema.optional(),
+  inputSchema: z4.record(z4.string(), z4.unknown()).optional(),
+  order: z4.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 = z4.object({
+  editorEntry: z4.string().min(1).optional(),
+  previewEntry: z4.string().min(1).optional(),
+  blocks: z4.array(webDesignBlockSchema).optional(),
+  nodes: z4.array(webDesignNodeDefinitionSchema).optional(),
+  slots: z4.array(webDesignSlotSchema).optional(),
+  templates: z4.array(webDesignTemplateSchema).optional(),
+  dataSources: z4.array(webDesignDataSourceSchema).optional(),
+  actions: z4.array(webDesignActionSchema).optional(),
+  embeds: z4.array(webAppEmbedSchema).optional()
+}).superRefine((design, ctx) => {
+  const hasDesignSurface = Boolean(
+    design.blocks?.length || design.nodes?.length || design.slots?.length || design.templates?.length || design.dataSources?.length || design.actions?.length || design.embeds?.length
+  );
+  if (!hasDesignSurface) {
+    ctx.addIssue({
+      code: "custom",
+      path: [],
+      message: "web.design must declare at least one block, slot, template, dataSource, or action"
+    });
+  }
+  for (const [field, values] of [
+    ["blocks", design.blocks],
+    ["nodes", design.nodes],
+    ["slots", design.slots],
+    ["templates", design.templates],
+    ["dataSources", design.dataSources],
+    ["actions", design.actions],
+    ["embeds", design.embeds]
+  ]) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const [index, value] of (values ?? []).entries()) {
+      if (ids.has(value.id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [field, index, "id"],
+          message: `duplicate web.design.${field} id: ${value.id}`
+        });
+      }
+      ids.add(value.id);
+    }
+  }
+});
+var webSurfaceSchema = z4.object({
+  ssrContractVersion: webSsrContractVersionSchema.optional(),
+  serverEntry: z4.string().min(1).optional(),
+  clientEntry: z4.string().min(1).optional(),
+  remoteEntry: z4.string().min(1).optional(),
+  devRemoteEntry: z4.string().min(1).optional(),
+  moduleName: z4.string().min(1).optional(),
+  exposes: z4.record(z4.string(), z4.string()).optional(),
+  routes: z4.array(webPluginRouteSchema).optional(),
+  fills: z4.never().optional(),
+  extensions: z4.array(webExtensionSchema).optional(),
+  design: webDesignSurfaceSchema.optional(),
+  /** Standalone feature presentation adapters supplied by a Presentation Pack. */
+  adapters: z4.array(presentationAdapterSchema).optional(),
+  surfaces: z4.array(presentationSurfaceSchema).optional(),
+  storefrontApis: z4.array(storefrontApiSchema).optional(),
+  presentation: webPresentationSchema.optional(),
+  /** @deprecated Use serverEntry/clientEntry plus routes[].handler/component. */
+  entry: z4.string().optional(),
+  /** @deprecated Use routes[].component. */
+  components: z4.array(z4.string()).optional()
+}).superRefine((web, ctx) => {
+  const hasRoutes = Boolean(web.routes?.length);
+  const hasExtensions = Boolean(web.extensions?.length);
+  const hasSurfaceServerRenderers = Boolean(web.surfaces?.some((surface) => surface.defaultRenderer));
+  const hasStorefrontServerExports = Boolean(web.storefrontApis?.some((api) => api.serverExport));
+  const hasPresentationServerRenderers = Boolean(
+    typeof web.presentation?.shell === "string" || web.presentation?.shell?.serverRenderer || web.presentation?.adapters?.some((adapter) => adapter.serverRenderer) || web.adapters?.some((adapter) => adapter.serverRenderer)
+  );
+  const hasPresentationClientComponents = Boolean(
+    typeof web.presentation?.shell === "object" && web.presentation.shell.clientComponent || web.presentation?.adapters?.some((adapter) => adapter.clientComponent) || web.adapters?.some((adapter) => adapter.clientComponent)
+  );
+  const usesSsrSurface = Boolean(
+    web.ssrContractVersion || web.serverEntry || web.clientEntry || hasRoutes || hasSurfaceServerRenderers || hasStorefrontServerExports || hasPresentationServerRenderers
+  );
+  const usesRemoteSurface = Boolean(
+    web.remoteEntry || web.devRemoteEntry || web.moduleName || web.exposes || hasExtensions || hasPresentationClientComponents || web.storefrontApis?.some((api) => api.browserExport)
+  );
+  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 || hasSurfaceServerRenderers || hasStorefrontServerExports || hasPresentationServerRenderers) && !web.serverEntry) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["serverEntry"],
+      message: "web.serverEntry is required for server-rendered web declarations"
+    });
+  }
+  if ((hasExtensions || hasPresentationClientComponents || web.storefrontApis?.some((api) => api.browserExport)) && !web.remoteEntry) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["remoteEntry"],
+      message: "web.remoteEntry is required for public Web remote components or clients"
+    });
+  }
+  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"
+      });
+    }
+  }
+  for (const [field, values] of [
+    ["adapters", web.adapters],
+    ["surfaces", web.surfaces],
+    ["storefrontApis", web.storefrontApis]
+  ]) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const [index, value] of (values ?? []).entries()) {
+      const id = value.id;
+      if (!id) continue;
+      if (ids.has(id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [field, index, "id"],
+          message: `duplicate web.${field} id: ${id}`
+        });
+      }
+      ids.add(id);
+    }
+  }
+  const adapterTargets = /* @__PURE__ */ new Set();
+  for (const [field, adapters] of [
+    ["presentation.adapters", web.presentation?.adapters],
+    ["adapters", web.adapters]
+  ]) {
+    for (const [index, adapter] of (adapters ?? []).entries()) {
+      const key = `${adapter.ownerPluginId}:${adapter.surfaceId}`;
+      if (adapterTargets.has(key)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [field, index, "surfaceId"],
+          message: `duplicate presentation adapter target across theme and pack declarations: ${key}`
+        });
+      }
+      adapterTargets.add(key);
+    }
+  }
+});
+var pluginManifestSchema = z4.object({
+  // === Identity ===
+  pluginId: z4.string().regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "pluginId must be reverse-domain format (e.g., com.vendor.plugin-name)"),
+  version: z4.string().regex(/^\d+\.\d+\.\d+/, "version must be semver format"),
+  name: z4.string().min(1).max(100),
+  description: z4.string().max(500).optional(),
+  vendor: z4.string().min(1).max(100),
+  private: z4.boolean().optional(),
+  type: z4.enum(["backend", "frontend", "full", "extension", "integration", "feature"]).optional(),
+  // === UI Translations ===
+  // Locale -> { key: translated text }. Stored under namespace `plugin.{pluginId}`.
+  i18n: pluginI18nSchema.optional(),
+  // === Runtime ===
+  runtime: z4.enum(["node"]).default("node"),
+  // Note: surfaces is auto-generated from server/admin/web presence
+  // Used by plugin marketplace for filtering
+  // === Compatibility ===
+  engines: z4.object({
+    wordrhyme: z4.string(),
+    // semver range, e.g., "^0.1.0"
+    node: z4.string().optional()
+    // e.g., ">=20.0.0"
+  }),
+  // === Capabilities Declared ===
+  capabilities: z4.object({
+    ui: z4.object({
+      adminPage: z4.boolean().optional(),
+      webPage: z4.boolean().optional(),
+      webTheme: z4.boolean().optional(),
+      webPresentationPack: z4.boolean().optional(),
+      webDesigner: z4.boolean().optional(),
+      settingsTab: z4.boolean().optional()
+    }).optional(),
+    storage: z4.object({
+      provider: z4.boolean().optional()
+    }).optional(),
+    artifacts: z4.object({
+      write: z4.boolean().optional()
+    }).optional(),
+    /**
+     * Agent capability (AI Action Gateway, Phase 0 spike).
+     * Static whitelist declarations reconciled by the Host at load time:
+     * - `runtime: true` — this plugin hosts the agent runtime and may read
+     *   the Core agent tool registry (gated capability injection).
+     * - `tools` — tools this plugin contributes to the AI Tool Catalog.
+     *   Declaration only; undeclared tools never become visible.
+     */
+    agent: z4.object({
+      runtime: z4.boolean().optional(),
+      /** Governed action invoker access (ActionInvokerCapability, ctx.actions). */
+      invoker: z4.boolean().optional(),
+      tools: z4.array(z4.object({
+        id: z4.string().min(1).regex(
+          /^[a-z0-9-]+(\.[a-z0-9-]+)*$/,
+          'tool id must be lowercase dot-separated (e.g., "canvas.add-node")'
+        ),
+        title: z4.string().min(1),
+        summary: z4.string().optional()
+      })).optional()
+    }).optional(),
+    /** Governed AI generation metadata and the reserved official Runtime boundary. */
+    ai: z4.object({
+      aliases: z4.array(z4.object({
+        id: z4.string().min(1).max(80).regex(
+          /^[a-z0-9][a-z0-9._-]{0,79}$/,
+          "AI alias must be lowercase and may contain dots, underscores, or hyphens"
+        ),
+        name: z4.string().min(1).max(80),
+        description: z4.string().max(240).optional()
+      })).superRefine((aliases, ctx) => {
+        const seen = /* @__PURE__ */ new Set();
+        for (const [index, alias] of aliases.entries()) {
+          if (seen.has(alias.id)) {
+            ctx.addIssue({
+              code: "custom",
+              message: `duplicate AI alias: ${alias.id}`,
+              path: [index, "id"]
+            });
+          }
+          seen.add(alias.id);
+        }
+      }).optional(),
+      provider: z4.boolean().optional()
+    }).optional(),
+    provides: z4.array(z4.string()).optional(),
+    // e.g., ["logger-adapter", "cache-adapter"]
+    billing: z4.object({
+      subjects: z4.array(z4.object({
+        subject: z4.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: z4.enum(["boolean", "metered"]),
+        unit: z4.string().optional(),
+        description: z4.string().optional()
+      })).optional(),
+      procedures: z4.record(z4.string(), z4.string()).optional()
+    }).optional()
+  }).optional(),
+  // === Exports ===
+  exports: z4.object({
+    loggerAdapter: z4.string().optional(),
+    // e.g., "./dist/logger-adapter.js"
+    cacheAdapter: z4.string().optional()
+  }).optional(),
+  // === Permissions Defined ===
+  permissions: z4.object({
+    definitions: z4.array(z4.object({
+      key: z4.string().regex(/^[a-z0-9_.]+$/, "Permission key must be lowercase with dots/underscores"),
+      description: z4.string().optional()
+    })).optional(),
+    required: z4.array(z4.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: z4.record(
+      z4.string(),
+      // subject name
+      z4.array(z4.object({
+        key: z4.string().min(1),
+        label: z4.string().min(1),
+        actions: z4.array(z4.string().min(1)).min(1)
+      }))
+    ).optional()
+  }).optional(),
+  // === Server Entry ===
+  server: z4.object({
+    entry: z4.string(),
+    // e.g., "./dist/server/index.js"
+    router: z4.boolean().optional(),
+    // Exports tRPC router
+    nestModule: z4.string().optional(),
+    // NestJS module for advanced plugins, e.g., "./dist/server/hello.module.js"
+    fastifyRoutes: z4.string().optional(),
+    // Fastify route registrar, e.g., "./dist/server/http/routes.js"
+    publicServices: z4.array(z4.object({
+      name: z4.string().min(1).max(80).regex(/^[a-z0-9-]+$/),
+      mountPath: z4.string().regex(/^\/api\/[a-z0-9/-]+$/),
+      methods: z4.array(z4.enum(["GET", "POST", "PUT", "PATCH", "DELETE"])).min(1),
+      auth: z4.enum(["public", "bearer", "session", "user"]).default("public"),
+      maxBodyBytes: z4.number().int().positive().max(100 * 1024 * 1024).default(1024 * 1024)
+    })).optional(),
+    trustedApiTokenProxy: z4.object({
+      invoker: z4.string().min(1),
+      paths: z4.array(z4.string().min(1)).min(1)
+    }).optional(),
+    hooks: z4.array(z4.enum(["onInstall", "onEnable", "onDisable", "onUninstall"])).optional()
+  }).optional(),
+  // === Admin UI Entry ===
+  admin: z4.object({
+    remoteEntry: z4.string(),
+    // e.g., "./dist/admin/remoteEntry.js"
+    devRemoteEntry: z4.string().optional(),
+    // Dev mode: e.g., "http://localhost:3010/remoteEntry.js"
+    moduleName: z4.string().optional(),
+    // MF2.0 module name
+    exposes: z4.record(z4.string(), z4.string()).optional(),
+    extensions: z4.array(adminExtensionSchema).optional(),
+    slots: z4.array(adminSlotSchema).optional(),
+    tours: z4.array(adminTourSchema).optional(),
+    /** @deprecated Use slots instead. */
+    extensionSlots: z4.array(adminSlotSchema).optional(),
+    /** @deprecated Use extensions[] instead */
+    menus: z4.array(z4.object({
+      label: z4.string(),
+      icon: z4.string().optional(),
+      path: z4.string(),
+      order: z4.number().optional(),
+      parentId: z4.string().optional(),
+      permission: permissionDeclarationSchema.optional(),
+      /** @deprecated Use permission instead. */
+      requiredPermission: z4.string().optional(),
+      metadata: z4.record(z4.string(), z4.unknown()).optional()
+    })).optional()
+  }).optional(),
+  // === Web UI Entry ===
+  web: webSurfaceSchema.optional(),
+  // === Dependencies ===
+  dependencies: z4.array(z4.string()).optional(),
+  // Other plugin IDs
+  conflicts: z4.array(z4.string()).optional(),
+  // Conflicting plugin IDs
+  peerDependencies: z4.record(z4.string(), z4.string()).optional(),
+  // e.g., { react: "^18.0.0" }
+  compatibilityMode: z4.enum(["strict", "lenient", "fallback"]).optional(),
+  // === Entity Extensions ===
+  extends: z4.record(extensionTargetPluginIdSchema, entityExtensionSchema).optional(),
+  uses: pluginUsesSchema.optional(),
+  // === Data Retention ===
+  dataRetention: z4.object({
+    onDisable: z4.enum(["retain"]).optional(),
+    onUninstall: z4.enum(["delete", "archive", "retain"]).optional(),
+    tables: z4.array(z4.string()).optional()
+  }).optional(),
+  // === Infrastructure (Tenant Config Delegation) ===
+  infrastructure: z4.object({
+    tenantOverride: z4.boolean(),
+    riskLevel: z4.enum(["high", "medium", "low"]),
+    sensitiveFields: z4.array(z4.string()).default([])
+  }).optional(),
+  // === Notifications ===
+  notifications: notificationsConfigSchema
+}).superRefine((manifest, ctx) => {
+  const declaresThemeCapability = manifest.capabilities?.ui?.webTheme === true;
+  const hasPresentation = manifest.web?.presentation !== void 0;
+  if (declaresThemeCapability && !hasPresentation) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["web", "presentation"],
+      message: "capabilities.ui.webTheme requires web.presentation"
+    });
+  }
+  if (hasPresentation && !declaresThemeCapability) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["capabilities", "ui", "webTheme"],
+      message: "web.presentation requires capabilities.ui.webTheme = true"
+    });
+  }
+  const declaresPresentationPack = manifest.capabilities?.ui?.webPresentationPack === true;
+  const hasStandaloneAdapters = (manifest.web?.adapters?.length ?? 0) > 0;
+  if (declaresPresentationPack && !hasStandaloneAdapters) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["web", "adapters"],
+      message: "capabilities.ui.webPresentationPack requires web.adapters"
+    });
+  }
+  if (hasStandaloneAdapters && !declaresPresentationPack) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["capabilities", "ui", "webPresentationPack"],
+      message: "web.adapters requires capabilities.ui.webPresentationPack = true"
+    });
+  }
+});
+
+export {
+  presentationIdSchema,
+  presentationPluginIdSchema,
+  presentationContractVersionSchema,
+  presentationContractRangeSchema,
+  presentationSchemaRefSchema,
+  presentationModelSchema,
+  presentationRenderModeSchema,
+  presentationRegionSchema,
+  presentationActionSchema,
+  presentationSurfaceSchema,
+  presentationAdapterSchema,
+  themeAssetPathSchema,
+  themeAssetSchema,
+  themeHeadSchema,
+  themeTokenTypeSchema,
+  themeTokenSchema,
+  themeTokenPresetSchema,
+  themeSiteShellSchema,
+  themeHomeTargetSchema,
+  themeIntegrationSchema,
+  webPresentationSchema,
+  presentationDiagnosticSeveritySchema,
+  presentationCompatibilityStatusSchema,
+  presentationDiagnosticSchema,
+  presentationCompatibilityResultSchema,
+  PRESENTATION_OBSERVABILITY,
+  defineWebPresentation,
+  defineThemeHomeTarget,
+  definePresentationSurface,
+  definePresentationAdapter,
+  parsePresentationModel,
+  evaluatePresentationCompatibility,
+  satisfiesPresentationRange,
+  storefrontOperationKindSchema,
+  storefrontOperationSchema,
+  storefrontApiSchema,
+  defineStorefrontApi,
+  webDesignNodeKindSchema,
+  webDesignRegionSchema,
+  webDesignBindingSchema,
+  webDesignMigrationSchema,
+  webDesignNodeDefinitionSchema,
+  webAppEmbedTargetSchema,
+  webAppEmbedConsentSchema,
+  webAppEmbedSchema,
+  defineWebDesignNode,
+  defineAppEmbed,
+  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-3IM3FPTJ.js.map