@inf-monkeys-tech/monkeys 1.0.65 → 1.0.68

package/lib/esm/schemas/index.mjs

@@ -7096,7 +7096,8 @@ var CapabilitySourceTypeSchema = z5.enum([
   "plugin-manifest",
   "openapi",
   "workflow",
-  "comfyui"
+  "comfyui",
+  "design-view-provider"
 ]);
 var CapabilityRegistrySourceSchema = z5.object({
   sourceType: CapabilitySourceTypeSchema,
@@ -8352,12 +8353,949 @@ var DomainEventSchema = z9.object({
   occurredAt: IsoDateTimeSchema
 }).strict();
 
+// src/contracts/declarative-control.ts
+import { z as z10 } from "zod";
+var DECLARATIVE_CONTROL_SCHEMA_VERSION = 1;
+var uniqueArray = (values, identity) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const key = identity(value);
+    if (seen.has(key)) return key;
+    seen.add(key);
+  }
+  return void 0;
+};
+var I18nTextSchema = z10.object({
+  defaultLocale: LocaleIdentifierSchema,
+  values: z10.record(LocaleIdentifierSchema, z10.string().trim().min(1))
+}).strict().superRefine((value, context) => {
+  if (!Object.prototype.hasOwnProperty.call(value.values, value.defaultLocale)) {
+    context.addIssue({
+      code: "custom",
+      path: ["values", value.defaultLocale],
+      message: "I18nText values must contain the default locale."
+    });
+  }
+});
+var ScopedIdentityRefSchema = z10.object({
+  kind: ContractIdentifierSchema,
+  id: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema
+}).strict();
+var TenantScopeSchema = z10.object({
+  tenantRef: ScopedIdentityRefSchema,
+  dataSpaceRef: ScopedIdentityRefSchema,
+  teamRef: ScopedIdentityRefSchema.optional()
+}).strict().superRefine((value, context) => {
+  const expectedKinds = [
+    ["tenantRef", value.tenantRef, "tenant"],
+    ["dataSpaceRef", value.dataSpaceRef, "data-space"],
+    ["teamRef", value.teamRef, "team"]
+  ];
+  expectedKinds.forEach(([field, reference, expectedKind]) => {
+    if (reference && reference.kind !== expectedKind) {
+      context.addIssue({ code: "custom", path: [field, "kind"], message: `${field} must reference ${expectedKind}.` });
+    }
+  });
+});
+var ReferenceVisibilitySchema = z10.enum(["tenant", "global", "public"]);
+var StableRefShape = {
+  kind: ContractIdentifierSchema,
+  id: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  visibility: ReferenceVisibilitySchema,
+  tenantScope: TenantScopeSchema.optional()
+};
+var validateReferenceScope = (value, context) => {
+  if (value.visibility === "tenant" && !value.tenantScope) {
+    context.addIssue({ code: "custom", path: ["tenantScope"], message: "Tenant references require an explicit tenant scope." });
+  }
+  if (value.visibility !== "tenant" && value.tenantScope) {
+    context.addIssue({ code: "custom", path: ["tenantScope"], message: "Global and public references cannot carry a tenant scope." });
+  }
+};
+var StableRefSchema = z10.object(StableRefShape).strict().superRefine(validateReferenceScope);
+var RevisionRefSchema = z10.object({
+  ...StableRefShape,
+  revision: z10.number().int().positive(),
+  schemaVersion: ContractVersionSchema,
+  contentHash: Sha256Schema
+}).strict().superRefine(validateReferenceScope);
+var scopedIdentityKey = (reference) => `${reference.kind}:${reference.id}:${reference.ownerRepo}`;
+var tenantScopeKey = (scope) => `${scopedIdentityKey(scope.tenantRef)}:${scopedIdentityKey(scope.dataSpaceRef)}:${scope.teamRef ? scopedIdentityKey(scope.teamRef) : ""}`;
+var stableRefIdentity = (reference) => `${reference.visibility}:${reference.tenantScope ? tenantScopeKey(reference.tenantScope) : ""}:${reference.kind}:${reference.id}:${reference.ownerRepo}`;
+var exactRevisionRef = (left, right) => stableRefIdentity(left) === stableRefIdentity(right) && left.revision === right.revision && left.schemaVersion === right.schemaVersion && left.contentHash === right.contentHash;
+var StableRefAliasSchema = z10.object({
+  aliasRef: StableRefSchema,
+  canonicalRef: StableRefSchema,
+  validFrom: IsoDateTimeSchema,
+  validUntil: IsoDateTimeSchema.nullable(),
+  evidenceRef: RevisionRefSchema
+}).strict().superRefine((value, context) => {
+  if (value.aliasRef.kind !== value.canonicalRef.kind) {
+    context.addIssue({ code: "custom", path: ["canonicalRef", "kind"], message: "Alias and canonical references must have the same kind." });
+  }
+  if (value.validUntil && value.validUntil <= value.validFrom) {
+    context.addIssue({ code: "custom", path: ["validUntil"], message: "Alias validUntil must be later than validFrom." });
+  }
+});
+var StableRefAliasMapSchema = z10.object({
+  contract: z10.literal("StableRefAliasMap"),
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  tenantScope: TenantScopeSchema,
+  aliases: z10.array(StableRefAliasSchema),
+  contentHash: Sha256Schema
+}).strict().superRefine((value, context) => {
+  const duplicate = uniqueArray(value.aliases, (entry) => stableRefIdentity(entry.aliasRef));
+  if (duplicate) context.addIssue({ code: "custom", path: ["aliases"], message: `Duplicate alias reference: ${duplicate}` });
+});
+var DeclarativeLifecycleSchema = z10.enum(["active", "deprecated", "retired"]);
+var ProductSurfaceSchema = z10.enum(["studio", "kernel"]);
+var GroupRefSchema = StableRefSchema.superRefine((value, context) => {
+  if (value.kind !== "group") context.addIssue({ code: "custom", path: ["kind"], message: "Access group references must use kind group." });
+});
+var AccessConditionRefSchema = RevisionRefSchema.superRefine((value, context) => {
+  if (value.kind !== "access-condition") {
+    context.addIssue({ code: "custom", path: ["kind"], message: "Access condition references must use kind access-condition." });
+  }
+});
+var AccessPolicySchema = z10.object({
+  authenticated: z10.boolean(),
+  groupAllOf: z10.array(GroupRefSchema),
+  groupAnyOf: z10.array(GroupRefSchema),
+  permissionAllOf: z10.array(ContractIdentifierSchema),
+  permissionAnyOf: z10.array(ContractIdentifierSchema),
+  conditionAllOf: z10.array(AccessConditionRefSchema)
+}).strict().superRefine((value, context) => {
+  const checks = [
+    ["groupAllOf", value.groupAllOf, (candidate) => stableRefIdentity(candidate)],
+    ["groupAnyOf", value.groupAnyOf, (candidate) => stableRefIdentity(candidate)],
+    ["permissionAllOf", value.permissionAllOf, String],
+    ["permissionAnyOf", value.permissionAnyOf, String],
+    ["conditionAllOf", value.conditionAllOf, (candidate) => `${stableRefIdentity(candidate)}@${candidate.revision}`]
+  ];
+  checks.forEach(([field, values, identity]) => {
+    if (uniqueArray(values, identity)) context.addIssue({ code: "custom", path: [field], message: `${field} entries must be unique.` });
+  });
+});
+var ManagementAccessSchema = z10.object({
+  edit: AccessPolicySchema,
+  preview: AccessPolicySchema,
+  publish: AccessPolicySchema,
+  deactivate: AccessPolicySchema,
+  rollback: AccessPolicySchema,
+  retire: AccessPolicySchema
+}).strict();
+var RoutePathTemplateSchema = z10.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").superRefine((value, context) => {
+  if (value.includes("?") || value.includes("#") || value.includes("\\")) {
+    context.addIssue({ code: "custom", message: "Route paths cannot contain query strings, fragments, or backslashes." });
+  }
+  if (value.split("/").some((segment) => segment === "." || segment === "..")) {
+    context.addIssue({ code: "custom", message: "Route paths cannot contain traversal segments." });
+  }
+  if (/^[a-z][a-z0-9+.-]*:/i.test(value) || value.includes("://")) {
+    context.addIssue({ code: "custom", message: "Route paths cannot contain a scheme or host." });
+  }
+});
+var RouteSpaceParameterSchema = z10.object({
+  name: ContractIdentifierSchema,
+  type: z10.enum(["identifier", "integer", "slug", "uuid"]),
+  required: z10.boolean()
+}).strict();
+var RouteSpaceSchema = z10.object({
+  contract: z10.literal("RouteSpace"),
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  routeSpaceId: ContractIdentifierSchema,
+  supportedSurface: ProductSurfaceSchema,
+  basePath: RoutePathTemplateSchema,
+  caseSensitive: z10.boolean(),
+  trailingSlash: z10.enum(["preserve", "remove", "require"]),
+  reservedPaths: z10.array(RoutePathTemplateSchema),
+  parameters: z10.array(RouteSpaceParameterSchema)
+}).strict().superRefine((value, context) => {
+  if (uniqueArray(value.parameters, (parameter) => parameter.name)) {
+    context.addIssue({ code: "custom", path: ["parameters"], message: "RouteSpace parameter names must be unique." });
+  }
+  if (uniqueArray(value.reservedPaths, (path) => path)) {
+    context.addIssue({ code: "custom", path: ["reservedPaths"], message: "RouteSpace reserved paths must be unique." });
+  }
+});
+var RouteClaimBaseSchema = z10.object({
+  kind: z10.enum(["canonical", "alias", "redirect"]),
+  routeSpaceRevisionRef: RevisionRefSchema,
+  pathTemplate: RoutePathTemplateSchema,
+  redirectTargetRef: StableRefSchema.optional()
+}).strict().superRefine((value, context) => {
+  if (value.routeSpaceRevisionRef.kind !== "route-space") {
+    context.addIssue({ code: "custom", path: ["routeSpaceRevisionRef", "kind"], message: "Route claims must reference a route-space revision." });
+  }
+  if (value.kind === "redirect" && !value.redirectTargetRef) {
+    context.addIssue({ code: "custom", path: ["redirectTargetRef"], message: "Redirect claims require a governed target reference." });
+  }
+  if (value.kind !== "redirect" && value.redirectTargetRef) {
+    context.addIssue({ code: "custom", path: ["redirectTargetRef"], message: "Only redirect claims may declare redirectTargetRef." });
+  }
+});
+var LegacyRouteClaimSchema = RouteClaimBaseSchema;
+var RouteClaimSchema = RouteClaimBaseSchema.safeExtend({
+  surface: ProductSurfaceSchema
+}).strict();
+var DeclarativeRouteClaimSchema = RouteClaimSchema;
+var LegacyDeclarativeRouteClaimSchema = LegacyRouteClaimSchema;
+var LegacyCompiledRouteMatcherSchema = z10.object({
+  caseSensitive: z10.boolean(),
+  trailingSlash: z10.enum(["preserve", "remove", "require"]),
+  parameters: z10.array(RouteSpaceParameterSchema)
+}).strict();
+var CompiledRouteMatcherSchema = LegacyCompiledRouteMatcherSchema.safeExtend({
+  surface: ProductSurfaceSchema
+}).strict();
+var CompiledRouteClaimSchema = RouteClaimSchema.safeExtend({
+  normalizedPath: RoutePathTemplateSchema,
+  matcher: CompiledRouteMatcherSchema
+}).strict();
+var LegacyCompiledRouteClaimSchema = LegacyRouteClaimSchema.safeExtend({
+  normalizedPath: RoutePathTemplateSchema,
+  matcher: LegacyCompiledRouteMatcherSchema
+}).strict();
+var validateDeclaredRouteSurfaces = (supportedSurfaces, routeClaims, context) => {
+  if (uniqueArray(supportedSurfaces, (surface) => surface)) {
+    context.addIssue({ code: "custom", path: ["supportedSurfaces"], message: "Supported surfaces must be unique." });
+  }
+  const explicitClaims = routeClaims.filter((claim) => "surface" in claim);
+  if (explicitClaims.length > 0 && explicitClaims.length < routeClaims.length) {
+    context.addIssue({ code: "custom", path: ["routeClaims"], message: "Route claims must either all declare surface or all omit it for legacy compatibility." });
+    return;
+  }
+  routeClaims.forEach((claim, index) => {
+    if ("surface" in claim && !supportedSurfaces.includes(claim.surface)) {
+      context.addIssue({ code: "custom", path: ["routeClaims", index, "surface"], message: "Route claim surface must be declared by supportedSurfaces." });
+    }
+  });
+  if (explicitClaims.length !== routeClaims.length) return;
+  supportedSurfaces.forEach((surface) => {
+    const canonicalCount = explicitClaims.filter((claim) => claim.surface === surface && claim.kind === "canonical").length;
+    if (canonicalCount !== 1) {
+      context.addIssue({ code: "custom", path: ["routeClaims"], message: `Surface ${surface} requires exactly one canonical route claim.` });
+    }
+  });
+};
+var ReleaseOperationSchema = z10.enum(["activate", "deactivate", "rollback"]);
+var ReleaseDependencyRoleSchema = z10.enum([
+  "route-space",
+  "shell",
+  "page",
+  "page-release",
+  "workbench",
+  "workbench-release",
+  "navigation",
+  "navigation-release",
+  "menu-action",
+  "application-menu-catalog",
+  "capability",
+  "provider",
+  "ontology-definition",
+  "view",
+  "projection",
+  "action",
+  "token",
+  "schema",
+  "compiler",
+  "workflow",
+  "agent",
+  "built-in-application",
+  "design",
+  "layout-policy",
+  "performance-budget",
+  "observation-policy"
+]);
+var DependencyKindByRole = {
+  "route-space": "route-space",
+  shell: "shell",
+  page: "page",
+  "page-release": "page-release",
+  workbench: "workbench",
+  "workbench-release": "workbench-release",
+  navigation: "navigation",
+  "navigation-release": "navigation-release",
+  "menu-action": "menu-action",
+  "application-menu-catalog": "application-menu-catalog",
+  capability: "capability",
+  provider: "view-provider",
+  "ontology-definition": "ontology-definition",
+  view: "view",
+  projection: "projection",
+  action: "domain-command",
+  token: "design-token",
+  schema: "schema",
+  compiler: "compiler",
+  workflow: "workflow",
+  agent: "agent",
+  "built-in-application": "built-in-application",
+  design: "design",
+  "layout-policy": "layout-policy",
+  "performance-budget": "performance-budget",
+  "observation-policy": "observation-policy"
+};
+var ReleaseDependencySchema = z10.object({
+  role: ReleaseDependencyRoleSchema,
+  revisionRef: RevisionRefSchema
+}).strict().superRefine((value, context) => {
+  const expectedKind = DependencyKindByRole[value.role];
+  if (value.revisionRef.kind !== expectedKind) {
+    context.addIssue({
+      code: "custom",
+      path: ["revisionRef", "kind"],
+      message: `Dependency role ${value.role} requires reference kind ${expectedKind}.`
+    });
+  }
+});
+var ReleaseValidationSchema = z10.object({
+  result: z10.enum(["pass", "fail"]),
+  inputHash: Sha256Schema,
+  diagnosticRefs: z10.array(RevisionRefSchema)
+}).strict();
+var ReleaseEvidenceSchema = z10.object({
+  publicationPlanRef: StableRefSchema,
+  expectedHeadRevisionRef: RevisionRefSchema.nullable(),
+  validation: ReleaseValidationSchema,
+  approvalPolicyRevisionRef: RevisionRefSchema,
+  approvalDecisionRevisionRef: RevisionRefSchema,
+  actorRef: StableRefSchema,
+  reason: z10.string().trim().min(1).max(4096),
+  idempotencyKey: ContractIdentifierSchema,
+  occurredAt: IsoDateTimeSchema,
+  evidenceRefs: z10.array(RevisionRefSchema).min(1)
+}).strict().superRefine((value, context) => {
+  const expectedKinds = [
+    ["publicationPlanRef", value.publicationPlanRef, "publication-plan"],
+    ["approvalPolicyRevisionRef", value.approvalPolicyRevisionRef, "approval-policy"],
+    ["approvalDecisionRevisionRef", value.approvalDecisionRevisionRef, "approval-decision"],
+    ["actorRef", value.actorRef, "actor"]
+  ];
+  expectedKinds.forEach(([field, reference, expectedKind]) => {
+    if (reference.kind !== expectedKind) {
+      context.addIssue({ code: "custom", path: [field, "kind"], message: `${field} must reference ${expectedKind}.` });
+    }
+  });
+  value.evidenceRefs.forEach((reference, index) => {
+    if (reference.kind !== "evidence") context.addIssue({ code: "custom", path: ["evidenceRefs", index, "kind"], message: "Release evidenceRefs must reference evidence revisions." });
+  });
+});
+var PublicationPlanOperationSchema = z10.object({
+  releaseKind: z10.enum(["page-release", "workbench-release", "navigation-release"]),
+  releaseSlotId: ContractIdentifierSchema,
+  releaseRevisionRef: RevisionRefSchema,
+  expectedHeadRevisionRef: RevisionRefSchema.nullable()
+}).strict().superRefine((value, context) => {
+  if (value.releaseRevisionRef.kind !== value.releaseKind || value.releaseRevisionRef.id !== value.releaseSlotId) {
+    context.addIssue({ code: "custom", path: ["releaseRevisionRef"], message: "Publication Plan operation must pin the exact release slot revision." });
+  }
+  if (value.expectedHeadRevisionRef && (value.expectedHeadRevisionRef.kind !== value.releaseKind || value.expectedHeadRevisionRef.id !== value.releaseSlotId)) {
+    context.addIssue({ code: "custom", path: ["expectedHeadRevisionRef"], message: "Expected head must identify the same release slot." });
+  }
+});
+var PublicationPlanSchema = z10.object({
+  contract: z10.literal("PublicationPlan"),
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  planId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  environmentRef: StableRefSchema,
+  operations: z10.array(PublicationPlanOperationSchema).min(1),
+  validation: ReleaseValidationSchema,
+  approvalPolicyRevisionRef: RevisionRefSchema,
+  approvalDecisionRevisionRef: RevisionRefSchema,
+  actorRef: StableRefSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  evidenceRefs: z10.array(RevisionRefSchema).min(1),
+  createdAt: IsoDateTimeSchema
+}).strict().superRefine((value, context) => {
+  if (value.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["environmentRef", "kind"], message: "Publication Plan requires an environment reference." });
+  const governedRefs = [
+    ["approvalPolicyRevisionRef", value.approvalPolicyRevisionRef, "approval-policy"],
+    ["approvalDecisionRevisionRef", value.approvalDecisionRevisionRef, "approval-decision"],
+    ["actorRef", value.actorRef, "actor"]
+  ];
+  governedRefs.forEach(([field, reference, expectedKind]) => {
+    if (reference.kind !== expectedKind) context.addIssue({ code: "custom", path: [field, "kind"], message: `${field} must reference ${expectedKind}.` });
+  });
+  value.operations.forEach((operation, index) => {
+    [operation.releaseRevisionRef, operation.expectedHeadRevisionRef].forEach((reference, referenceIndex) => {
+      if (reference?.tenantScope && tenantScopeKey(reference.tenantScope) !== tenantScopeKey(value.tenantScope)) {
+        const field = referenceIndex === 0 ? "releaseRevisionRef" : "expectedHeadRevisionRef";
+        context.addIssue({ code: "custom", path: ["operations", index, field, "tenantScope"], message: "Publication Plan operation belongs to another tenant scope." });
+      }
+    });
+  });
+  value.evidenceRefs.forEach((reference, index) => {
+    if (reference.kind !== "evidence") context.addIssue({ code: "custom", path: ["evidenceRefs", index, "kind"], message: "Publication Plan evidenceRefs must reference evidence revisions." });
+  });
+  if (uniqueArray(value.operations, (operation) => `${operation.releaseKind}:${operation.releaseSlotId}`)) {
+    context.addIssue({ code: "custom", path: ["operations"], message: "Publication Plan release slots must be unique." });
+  }
+});
+var IdentitySchema = z10.object({
+  name: I18nTextSchema,
+  description: I18nTextSchema.optional(),
+  tags: z10.array(ContractIdentifierSchema).default([])
+}).strict();
+var WorkbenchIdentitySchema = IdentitySchema.extend({ iconRef: StableRefSchema.optional() }).strict();
+var ReleaseBaseShape = {
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  releaseSlotId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  operation: ReleaseOperationSchema,
+  dependencySnapshot: z10.array(ReleaseDependencySchema),
+  evidence: ReleaseEvidenceSchema
+};
+var validateDependencySnapshot = (snapshot, context) => {
+  const duplicate = uniqueArray(snapshot, (dependency) => `${dependency.role}:${stableRefIdentity(dependency.revisionRef)}@${dependency.revisionRef.revision}`);
+  if (duplicate) context.addIssue({ code: "custom", path: ["dependencySnapshot"], message: `Duplicate dependency: ${duplicate}` });
+};
+var validateReleaseExpectedHead = (value, expectedKind, context) => {
+  const expectedHead = value.evidence.expectedHeadRevisionRef;
+  if (expectedHead && (expectedHead.kind !== expectedKind || expectedHead.id !== value.releaseSlotId)) {
+    context.addIssue({ code: "custom", path: ["evidence", "expectedHeadRevisionRef"], message: "Expected head must identify the same release slot." });
+  }
+  if (expectedHead?.tenantScope && tenantScopeKey(expectedHead.tenantScope) !== tenantScopeKey(value.tenantScope)) {
+    context.addIssue({ code: "custom", path: ["evidence", "expectedHeadRevisionRef", "tenantScope"], message: "Expected head belongs to another tenant scope." });
+  }
+};
+var BindingSourceSchema = z10.discriminatedUnion("kind", [
+  z10.object({ kind: z10.literal("constant"), value: z10.union([z10.string(), z10.number().finite(), z10.boolean(), z10.null()]) }).strict(),
+  z10.object({ kind: z10.literal("route-parameter"), name: ContractIdentifierSchema }).strict(),
+  z10.object({ kind: z10.literal("query-parameter"), name: ContractIdentifierSchema }).strict(),
+  z10.object({ kind: z10.literal("identity"), name: z10.enum(["tenantId", "teamId", "userId"]) }).strict(),
+  z10.object({ kind: z10.literal("intent-field"), path: z10.string().trim().regex(/^[A-Za-z0-9_.-]+$/) }).strict(),
+  z10.object({ kind: z10.literal("binding-field"), bindingId: ContractIdentifierSchema, path: z10.string().trim().regex(/^[A-Za-z0-9_.-]+$/) }).strict()
+]);
+var CapabilityInstanceSchema = z10.object({
+  instanceId: ContractIdentifierSchema,
+  nodeId: ContractIdentifierSchema,
+  capabilityRevisionRef: RevisionRefSchema,
+  providerRevisionRef: RevisionRefSchema,
+  propertySchemaRevisionRef: RevisionRefSchema,
+  properties: JsonObjectSchema,
+  allowedSideEffects: z10.array(z10.enum(["network", "storage", "navigation", "worker", "websocket"]))
+}).strict();
+var OntologyBindingSchema = z10.object({
+  bindingId: ContractIdentifierSchema,
+  ontologyDefinitionRevisionRef: RevisionRefSchema,
+  viewRevisionRef: RevisionRefSchema.optional(),
+  projectionRevisionRef: RevisionRefSchema.optional(),
+  parameters: z10.record(ContractIdentifierSchema, BindingSourceSchema),
+  target: z10.object({ capabilityInstanceId: ContractIdentifierSchema, port: ContractIdentifierSchema }).strict(),
+  renderModelSchemaRevisionRef: RevisionRefSchema,
+  pagination: z10.enum(["none", "cursor", "offset"]),
+  cache: z10.enum(["none", "identity-scoped", "tenant-scoped"]),
+  cancelOnChange: z10.boolean()
+}).strict().superRefine((value, context) => {
+  if ((value.viewRevisionRef ? 1 : 0) + (value.projectionRevisionRef ? 1 : 0) !== 1) {
+    context.addIssue({ code: "custom", path: ["viewRevisionRef"], message: "Ontology bindings require exactly one View or Projection revision." });
+  }
+  if (value.ontologyDefinitionRevisionRef.kind !== "ontology-definition") {
+    context.addIssue({ code: "custom", path: ["ontologyDefinitionRevisionRef", "kind"], message: "Expected an ontology-definition revision." });
+  }
+});
+var ActionBindingSchema = z10.object({
+  bindingId: ContractIdentifierSchema,
+  commandRevisionRef: RevisionRefSchema,
+  source: z10.object({ capabilityInstanceId: ContractIdentifierSchema, port: ContractIdentifierSchema }).strict(),
+  sourceIntentSchemaRevisionRef: RevisionRefSchema,
+  inputSchemaRevisionRef: RevisionRefSchema,
+  inputMapping: z10.record(ContractIdentifierSchema, BindingSourceSchema),
+  accessPolicy: AccessPolicySchema,
+  confirmation: I18nTextSchema.optional(),
+  idempotencyKeySource: z10.enum(["interaction", "record-and-interaction", "caller-provided"]),
+  compensationCommandRevisionRef: RevisionRefSchema.optional(),
+  resultSchemaRevisionRef: RevisionRefSchema,
+  success: z10.object({
+    refreshBindingIds: z10.array(ContractIdentifierSchema),
+    navigationTargetRef: StableRefSchema.optional()
+  }).strict(),
+  recovery: z10.enum(["retry-safe", "compensating-command", "manual-review"]),
+  lineageRequired: z10.literal(true)
+}).strict().superRefine((value, context) => {
+  if (value.commandRevisionRef.kind !== "domain-command") {
+    context.addIssue({ code: "custom", path: ["commandRevisionRef", "kind"], message: "Action bindings must reference a domain-command revision." });
+  }
+  if (value.sourceIntentSchemaRevisionRef.kind !== "schema") {
+    context.addIssue({ code: "custom", path: ["sourceIntentSchemaRevisionRef", "kind"], message: "Action source intents must pin a schema revision." });
+  }
+  if (value.inputSchemaRevisionRef.kind !== "schema") {
+    context.addIssue({ code: "custom", path: ["inputSchemaRevisionRef", "kind"], message: "Action command inputs must pin a schema revision." });
+  }
+  if (value.recovery === "compensating-command" && !value.compensationCommandRevisionRef) {
+    context.addIssue({ code: "custom", path: ["compensationCommandRevisionRef"], message: "Compensating recovery requires a compensation command." });
+  }
+});
+var PageSchema = z10.object({
+  contract: z10.literal("Page"),
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  pageId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  identity: IdentitySchema,
+  supportedSurfaces: z10.array(ProductSurfaceSchema).min(1),
+  lifecycle: DeclarativeLifecycleSchema,
+  routeClaims: z10.array(z10.union([DeclarativeRouteClaimSchema, LegacyDeclarativeRouteClaimSchema])).min(1),
+  shellRevisionRef: RevisionRefSchema,
+  renderTree: RenderTreeSchema,
+  capabilityInstances: z10.array(CapabilityInstanceSchema).min(1),
+  ontologyBindings: z10.array(OntologyBindingSchema),
+  actionBindings: z10.array(ActionBindingSchema),
+  pageAccessPolicy: AccessPolicySchema,
+  managementAccess: ManagementAccessSchema,
+  tokenRevisionRefs: z10.array(RevisionRefSchema).min(1),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z10.enum(["public", "internal", "confidential", "restricted"])
+}).strict().superRefine((value, context) => {
+  validateDeclaredRouteSurfaces(value.supportedSurfaces, value.routeClaims, context);
+  const uniqueness = [
+    ["capabilityInstances", value.capabilityInstances, (candidate) => String(candidate.instanceId)],
+    ["ontologyBindings", value.ontologyBindings, (candidate) => String(candidate.bindingId)],
+    ["actionBindings", value.actionBindings, (candidate) => String(candidate.bindingId)]
+  ];
+  uniqueness.forEach(([field, values, identity]) => {
+    if (uniqueArray(values, identity)) context.addIssue({ code: "custom", path: [field], message: `${field} identities must be unique.` });
+  });
+  const instanceIds = new Set(value.capabilityInstances.map((instance) => instance.instanceId));
+  value.ontologyBindings.forEach((binding, index) => {
+    if (!instanceIds.has(binding.target.capabilityInstanceId)) {
+      context.addIssue({ code: "custom", path: ["ontologyBindings", index, "target", "capabilityInstanceId"], message: "Ontology binding targets an unknown capability instance." });
+    }
+  });
+  value.actionBindings.forEach((binding, index) => {
+    if (!instanceIds.has(binding.source.capabilityInstanceId)) {
+      context.addIssue({ code: "custom", path: ["actionBindings", index, "source", "capabilityInstanceId"], message: "Action binding sources an unknown capability instance." });
+    }
+    binding.success.refreshBindingIds.forEach((bindingId) => {
+      if (!value.ontologyBindings.some((candidate) => candidate.bindingId === bindingId)) {
+        context.addIssue({ code: "custom", path: ["actionBindings", index, "success", "refreshBindingIds"], message: `Unknown refresh binding: ${bindingId}` });
+      }
+    });
+  });
+  if (value.shellRevisionRef.kind !== "shell") context.addIssue({ code: "custom", path: ["shellRevisionRef", "kind"], message: "Page shellRevisionRef must reference a shell." });
+  value.capabilityInstances.forEach((instance, index) => {
+    const refs = [
+      ["capabilityRevisionRef", instance.capabilityRevisionRef, "capability"],
+      ["providerRevisionRef", instance.providerRevisionRef, "view-provider"],
+      ["propertySchemaRevisionRef", instance.propertySchemaRevisionRef, "schema"]
+    ];
+    refs.forEach(([field, reference, expectedKind]) => {
+      if (reference.kind !== expectedKind) context.addIssue({ code: "custom", path: ["capabilityInstances", index, field, "kind"], message: `${field} must reference ${expectedKind}.` });
+    });
+  });
+  value.tokenRevisionRefs.forEach((reference, index) => {
+    if (reference.kind !== "design-token") context.addIssue({ code: "custom", path: ["tokenRevisionRefs", index, "kind"], message: "Page token references must use kind design-token." });
+  });
+  if (value.performanceBudgetRef.kind !== "performance-budget") context.addIssue({ code: "custom", path: ["performanceBudgetRef", "kind"], message: "Page requires a performance-budget revision." });
+  if (value.observationPolicyRevisionRef.kind !== "observation-policy") context.addIssue({ code: "custom", path: ["observationPolicyRevisionRef", "kind"], message: "Page requires an observation-policy revision." });
+});
+var PageReleaseSchema = z10.object({
+  contract: z10.literal("PageRelease"),
+  ...ReleaseBaseShape,
+  pageRevisionRef: RevisionRefSchema,
+  target: z10.object({
+    environmentRef: StableRefSchema,
+    surface: ProductSurfaceSchema,
+    routeSpaceRevisionRef: RevisionRefSchema,
+    normalizedPath: RoutePathTemplateSchema,
+    routeClaim: z10.union([CompiledRouteClaimSchema, LegacyCompiledRouteClaimSchema])
+  }).strict()
+}).strict().superRefine((value, context) => {
+  validateDependencySnapshot(value.dependencySnapshot, context);
+  validateReleaseExpectedHead(value, "page-release", context);
+  if (value.pageRevisionRef.kind !== "page") context.addIssue({ code: "custom", path: ["pageRevisionRef", "kind"], message: "Expected a page revision." });
+  if (value.target.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["target", "environmentRef", "kind"], message: "Page release target requires an environment reference." });
+  if (value.target.routeSpaceRevisionRef.kind !== "route-space") context.addIssue({ code: "custom", path: ["target", "routeSpaceRevisionRef", "kind"], message: "Page release target requires a route-space revision." });
+  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(value.target.routeSpaceRevisionRef, value.target.routeClaim.routeSpaceRevisionRef)) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim"], message: "Page Release route authority must pin the exact compiled claim and normalized path." });
+  }
+  if ("surface" in value.target.routeClaim && value.target.routeClaim.surface !== value.target.surface) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim", "surface"], message: "Page Release route claim must match the target surface." });
+  }
+});
+var WorkbenchGroupSchema = z10.object({
+  groupId: ContractIdentifierSchema,
+  label: I18nTextSchema,
+  iconRef: StableRefSchema.optional(),
+  order: z10.number().int(),
+  collapsedByDefault: z10.boolean(),
+  accessPolicy: AccessPolicySchema.optional()
+}).strict();
+var WorkbenchAppInstanceSchema = z10.object({
+  instanceId: ContractIdentifierSchema,
+  kind: z10.enum(["built-in-application", "workflow-form", "workflow", "agent", "design", "capability"]),
+  targetRevisionRef: RevisionRefSchema,
+  providerRevisionRef: RevisionRefSchema,
+  inputSchemaRevisionRef: RevisionRefSchema,
+  input: JsonObjectSchema,
+  groupId: ContractIdentifierSchema,
+  order: z10.number().int(),
+  display: z10.object({ name: I18nTextSchema.optional(), iconRef: StableRefSchema.optional() }).strict(),
+  accessPolicy: AccessPolicySchema
+}).strict();
+var WorkbenchSchema = z10.object({
+  contract: z10.literal("Workbench"),
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  workbenchId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  purpose: z10.enum(["instance", "template"]),
+  sourceTemplateRevisionRef: RevisionRefSchema.optional(),
+  identity: WorkbenchIdentitySchema,
+  supportedSurfaces: z10.array(ProductSurfaceSchema).min(1),
+  lifecycle: DeclarativeLifecycleSchema,
+  routeClaims: z10.array(z10.union([DeclarativeRouteClaimSchema, LegacyDeclarativeRouteClaimSchema])).min(1),
+  groups: z10.array(WorkbenchGroupSchema).min(1),
+  appInstances: z10.array(WorkbenchAppInstanceSchema).min(1),
+  defaultEntry: z10.object({ groupId: ContractIdentifierSchema, instanceId: ContractIdentifierSchema, showDefaultGroup: z10.boolean() }).strict(),
+  layout: z10.object({
+    hostCapabilityRevisionRef: RevisionRefSchema,
+    hostProviderRevisionRef: RevisionRefSchema,
+    layoutPolicyRevisionRef: RevisionRefSchema,
+    tokenRevisionRefs: z10.array(RevisionRefSchema).min(1)
+  }).strict(),
+  workbenchAccessPolicy: AccessPolicySchema,
+  managementAccess: ManagementAccessSchema,
+  personalPreferencesPolicy: z10.object({
+    allowed: z10.array(z10.enum(["collapsed-groups", "recent-entry", "layout-density"])),
+    authority: z10.literal("identity-overlay")
+  }).strict(),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z10.enum(["public", "internal", "confidential", "restricted"])
+}).strict().superRefine((value, context) => {
+  validateDeclaredRouteSurfaces(value.supportedSurfaces, value.routeClaims, context);
+  if (value.purpose === "template" && value.sourceTemplateRevisionRef) {
+    context.addIssue({ code: "custom", path: ["sourceTemplateRevisionRef"], message: "Templates cannot derive from another template at runtime." });
+  }
+  const duplicateGroup = uniqueArray(value.groups, (group) => group.groupId);
+  if (duplicateGroup) context.addIssue({ code: "custom", path: ["groups"], message: `Duplicate Workbench group: ${duplicateGroup}` });
+  const duplicateInstance = uniqueArray(value.appInstances, (instance) => instance.instanceId);
+  if (duplicateInstance) context.addIssue({ code: "custom", path: ["appInstances"], message: `Duplicate Workbench instance: ${duplicateInstance}` });
+  const groupIds = new Set(value.groups.map((group) => group.groupId));
+  value.appInstances.forEach((instance, index) => {
+    if (!groupIds.has(instance.groupId)) context.addIssue({ code: "custom", path: ["appInstances", index, "groupId"], message: "Workbench app references an unknown group." });
+  });
+  const defaultInstance = value.appInstances.find((instance) => instance.instanceId === value.defaultEntry.instanceId);
+  if (!defaultInstance || defaultInstance.groupId !== value.defaultEntry.groupId) {
+    context.addIssue({ code: "custom", path: ["defaultEntry"], message: "Workbench default entry must reference an app in the declared group." });
+  }
+  const targetKindByInstanceKind = {
+    "built-in-application": "built-in-application",
+    "workflow-form": "workflow",
+    workflow: "workflow",
+    agent: "agent",
+    design: "design",
+    capability: "capability"
+  };
+  value.appInstances.forEach((instance, index) => {
+    if (instance.targetRevisionRef.kind !== targetKindByInstanceKind[instance.kind]) context.addIssue({ code: "custom", path: ["appInstances", index, "targetRevisionRef", "kind"], message: `Workbench ${instance.kind} target has an incompatible reference kind.` });
+    if (instance.providerRevisionRef.kind !== "view-provider") context.addIssue({ code: "custom", path: ["appInstances", index, "providerRevisionRef", "kind"], message: "Workbench app provider must use kind view-provider." });
+    if (instance.inputSchemaRevisionRef.kind !== "schema") context.addIssue({ code: "custom", path: ["appInstances", index, "inputSchemaRevisionRef", "kind"], message: "Workbench app input must pin a schema revision." });
+  });
+  const layoutRefs = [
+    ["hostCapabilityRevisionRef", value.layout.hostCapabilityRevisionRef, "capability"],
+    ["hostProviderRevisionRef", value.layout.hostProviderRevisionRef, "view-provider"],
+    ["layoutPolicyRevisionRef", value.layout.layoutPolicyRevisionRef, "layout-policy"]
+  ];
+  layoutRefs.forEach(([field, reference, expectedKind]) => {
+    if (reference.kind !== expectedKind) context.addIssue({ code: "custom", path: ["layout", field, "kind"], message: `${field} must reference ${expectedKind}.` });
+  });
+  value.layout.tokenRevisionRefs.forEach((reference, index) => {
+    if (reference.kind !== "design-token") context.addIssue({ code: "custom", path: ["layout", "tokenRevisionRefs", index, "kind"], message: "Workbench token references must use kind design-token." });
+  });
+});
+var WorkbenchReleaseSchema = z10.object({
+  contract: z10.literal("WorkbenchRelease"),
+  ...ReleaseBaseShape,
+  workbenchRevisionRef: RevisionRefSchema,
+  target: z10.object({
+    environmentRef: StableRefSchema,
+    surface: ProductSurfaceSchema,
+    workbenchId: ContractIdentifierSchema,
+    routeSpaceRevisionRef: RevisionRefSchema,
+    normalizedPath: RoutePathTemplateSchema,
+    routeClaim: z10.union([CompiledRouteClaimSchema, LegacyCompiledRouteClaimSchema]),
+    order: z10.number().int(),
+    isDefaultCandidate: z10.boolean()
+  }).strict()
+}).strict().superRefine((value, context) => {
+  validateDependencySnapshot(value.dependencySnapshot, context);
+  validateReleaseExpectedHead(value, "workbench-release", context);
+  if (value.workbenchRevisionRef.kind !== "workbench") context.addIssue({ code: "custom", path: ["workbenchRevisionRef", "kind"], message: "Expected a workbench revision." });
+  if (value.target.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["target", "environmentRef", "kind"], message: "Workbench release target requires an environment reference." });
+  if (value.target.routeSpaceRevisionRef.kind !== "route-space") context.addIssue({ code: "custom", path: ["target", "routeSpaceRevisionRef", "kind"], message: "Workbench release target requires a route-space revision." });
+  if (value.target.normalizedPath !== value.target.routeClaim.normalizedPath || !exactRevisionRef(value.target.routeSpaceRevisionRef, value.target.routeClaim.routeSpaceRevisionRef)) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim"], message: "Workbench Release route authority must pin the exact compiled claim and normalized path." });
+  }
+  if ("surface" in value.target.routeClaim && value.target.routeClaim.surface !== value.target.surface) {
+    context.addIssue({ code: "custom", path: ["target", "routeClaim", "surface"], message: "Workbench Release route claim must match the target surface." });
+  }
+});
+var NavigationNodeBaseShape = {
+  nodeId: ContractIdentifierSchema,
+  parentNodeId: ContractIdentifierSchema.nullable(),
+  order: z10.number().int(),
+  disabled: z10.boolean().optional()
+};
+var NavigationGroupNodeSchema = z10.object({
+  ...NavigationNodeBaseShape,
+  kind: z10.literal("group"),
+  label: I18nTextSchema,
+  iconRef: StableRefSchema.optional(),
+  collapsedByDefault: z10.boolean(),
+  audience: AccessPolicySchema
+}).strict();
+var NavigationTargetNodeSchema = z10.object({
+  ...NavigationNodeBaseShape,
+  kind: z10.literal("target"),
+  label: I18nTextSchema,
+  iconRef: StableRefSchema.optional(),
+  tone: z10.enum(["default", "danger"]).optional(),
+  targetRef: StableRefSchema,
+  parameterMapping: z10.record(ContractIdentifierSchema, BindingSourceSchema),
+  audience: AccessPolicySchema
+}).strict();
+var NavigationSeparatorNodeSchema = z10.object({
+  ...NavigationNodeBaseShape,
+  kind: z10.literal("separator")
+}).strict();
+var NavigationNodeSchema = z10.discriminatedUnion("kind", [
+  NavigationGroupNodeSchema,
+  NavigationTargetNodeSchema,
+  NavigationSeparatorNodeSchema
+]);
+var validateNavigationTree = (nodes, context) => {
+  const byId = /* @__PURE__ */ new Map();
+  nodes.forEach((node, index) => {
+    if (byId.has(node.nodeId)) context.addIssue({ code: "custom", path: ["nodes", index, "nodeId"], message: `Duplicate Navigation node: ${node.nodeId}` });
+    else byId.set(node.nodeId, { node, index });
+  });
+  const siblingOrders = /* @__PURE__ */ new Set();
+  nodes.forEach((node, index) => {
+    const orderKey = `${node.parentNodeId ?? ""}:${node.order}`;
+    if (siblingOrders.has(orderKey)) context.addIssue({ code: "custom", path: ["nodes", index, "order"], message: "Sibling Navigation order values must be unique." });
+    siblingOrders.add(orderKey);
+    if (node.parentNodeId) {
+      const parent = byId.get(node.parentNodeId)?.node;
+      if (!parent) context.addIssue({ code: "custom", path: ["nodes", index, "parentNodeId"], message: "Navigation node has an unknown parent." });
+      else if (parent.kind !== "group") context.addIssue({ code: "custom", path: ["nodes", index, "parentNodeId"], message: "Navigation parents must be groups." });
+    }
+    const ancestors = /* @__PURE__ */ new Set([node.nodeId]);
+    let parentId = node.parentNodeId;
+    while (parentId) {
+      if (ancestors.has(parentId)) {
+        context.addIssue({ code: "custom", path: ["nodes", index, "parentNodeId"], message: `Navigation cycle contains ${node.nodeId}.` });
+        break;
+      }
+      ancestors.add(parentId);
+      parentId = byId.get(parentId)?.node.parentNodeId ?? null;
+    }
+  });
+};
+var NavigationSchema = z10.object({
+  contract: z10.literal("Navigation"),
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  navigationId: ContractIdentifierSchema,
+  tenantScope: TenantScopeSchema,
+  identity: IdentitySchema,
+  supportedSurfaces: z10.array(ProductSurfaceSchema).min(1),
+  placements: z10.array(ContractIdentifierSchema).min(1),
+  lifecycle: DeclarativeLifecycleSchema,
+  nodes: z10.array(NavigationNodeSchema),
+  managementAccess: ManagementAccessSchema,
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema
+}).strict().superRefine((value, context) => {
+  validateNavigationTree(value.nodes, context);
+  value.nodes.forEach((node, index) => {
+    if (node.kind === "target" && !["page", "workbench", "menu-action", "domain-command"].includes(node.targetRef.kind)) {
+      context.addIssue({ code: "custom", path: ["nodes", index, "targetRef", "kind"], message: "Navigation targets must reference Page, Workbench, registered Menu Action, or DomainCommand identities." });
+    }
+  });
+});
+var ResolvedNavigationTargetSchema = z10.object({
+  nodeId: ContractIdentifierSchema,
+  stableTargetRef: StableRefSchema,
+  targetRevisionRef: RevisionRefSchema,
+  releaseRevisionRef: RevisionRefSchema.optional()
+}).strict();
+var NavigationReleaseSchema = z10.object({
+  contract: z10.literal("NavigationRelease"),
+  ...ReleaseBaseShape,
+  navigationRevisionRef: RevisionRefSchema,
+  target: z10.object({
+    environmentRef: StableRefSchema,
+    surface: ProductSurfaceSchema,
+    placement: ContractIdentifierSchema
+  }).strict(),
+  resolvedTargets: z10.array(ResolvedNavigationTargetSchema)
+}).strict().superRefine((value, context) => {
+  validateDependencySnapshot(value.dependencySnapshot, context);
+  validateReleaseExpectedHead(value, "navigation-release", context);
+  if (value.navigationRevisionRef.kind !== "navigation") context.addIssue({ code: "custom", path: ["navigationRevisionRef", "kind"], message: "Expected a navigation revision." });
+  if (value.target.environmentRef.kind !== "environment") context.addIssue({ code: "custom", path: ["target", "environmentRef", "kind"], message: "Navigation release target requires an environment reference." });
+  if (uniqueArray(value.resolvedTargets, (target) => target.nodeId)) context.addIssue({ code: "custom", path: ["resolvedTargets"], message: "Resolved Navigation node IDs must be unique." });
+});
+var RuntimeDiagnosticSchema = z10.object({
+  code: ContractIdentifierSchema,
+  severity: z10.enum(["info", "warning", "error"]),
+  path: z10.string().trim().min(1),
+  message: z10.string().trim().min(1)
+}).strict();
+var RuntimeBundleBaseShape = {
+  schemaVersion: z10.literal(DECLARATIVE_CONTROL_SCHEMA_VERSION),
+  tenantScope: TenantScopeSchema,
+  releaseRevisionRef: RevisionRefSchema,
+  compilerRevisionRef: RevisionRefSchema,
+  generation: z10.number().int().nonnegative(),
+  dependencySnapshot: z10.array(ReleaseDependencySchema),
+  contentHash: Sha256Schema,
+  rebuildable: z10.literal(true),
+  diagnostics: z10.array(RuntimeDiagnosticSchema)
+};
+var PageRuntimeBundleSchema = z10.object({
+  contract: z10.literal("PageRuntimeBundle"),
+  ...RuntimeBundleBaseShape,
+  pageId: ContractIdentifierSchema,
+  pageRevisionRef: RevisionRefSchema,
+  surface: ProductSurfaceSchema,
+  routeClaims: z10.array(CompiledRouteClaimSchema),
+  shellRevisionRef: RevisionRefSchema,
+  renderTree: RenderTreeSchema,
+  capabilityInstances: z10.array(CapabilityInstanceSchema),
+  ontologyBindings: z10.array(OntologyBindingSchema),
+  actionBindings: z10.array(ActionBindingSchema),
+  pageAccessPolicy: AccessPolicySchema,
+  tokenRevisionRefs: z10.array(RevisionRefSchema),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z10.enum(["public", "internal", "confidential", "restricted"])
+}).strict();
+var ResolvedWorkbenchAppInstanceSchema = WorkbenchAppInstanceSchema.extend({
+  targetAccessPolicy: AccessPolicySchema
+}).strict();
+var WorkbenchRuntimeTargetSchema = WorkbenchReleaseSchema.shape.target.safeExtend({
+  routeClaim: CompiledRouteClaimSchema
+}).strict();
+var WorkbenchRuntimeBundleSchema = z10.object({
+  contract: z10.literal("WorkbenchRuntimeBundle"),
+  ...RuntimeBundleBaseShape,
+  workbenchId: ContractIdentifierSchema,
+  workbenchRevisionRef: RevisionRefSchema,
+  surface: ProductSurfaceSchema,
+  routeClaims: z10.array(CompiledRouteClaimSchema),
+  groups: z10.array(WorkbenchGroupSchema),
+  appInstances: z10.array(ResolvedWorkbenchAppInstanceSchema),
+  defaultEntry: WorkbenchSchema.shape.defaultEntry,
+  layout: WorkbenchSchema.shape.layout,
+  workbenchAccessPolicy: AccessPolicySchema,
+  personalPreferencesPolicy: WorkbenchSchema.shape.personalPreferencesPolicy,
+  target: WorkbenchRuntimeTargetSchema,
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema,
+  privacyClassification: z10.enum(["public", "internal", "confidential", "restricted"])
+}).strict();
+var CompiledNavigationTargetSchema = ResolvedNavigationTargetSchema.extend({
+  kind: z10.literal("route"),
+  accessPolicy: AccessPolicySchema,
+  routeClaim: CompiledRouteClaimSchema
+}).strict();
+var CompiledNavigationRegisteredMenuActionTargetSchema = ResolvedNavigationTargetSchema.extend({
+  kind: z10.literal("registered-menu-action"),
+  accessPolicy: AccessPolicySchema,
+  execution: z10.literal("client"),
+  applicationId: ContractIdentifierSchema,
+  actionRef: ContractIdentifierSchema,
+  inputSchemaRef: ContractIdentifierSchema.optional(),
+  input: JsonObjectSchema,
+  sourceCatalogRevisionRef: RevisionRefSchema
+}).strict();
+var CompiledNavigationDomainCommandTargetSchema = ResolvedNavigationTargetSchema.extend({
+  kind: z10.literal("governed-domain-command"),
+  accessPolicy: AccessPolicySchema,
+  execution: z10.literal("server"),
+  commandRevisionRef: RevisionRefSchema,
+  inputSchemaRevisionRef: RevisionRefSchema,
+  resultSchemaRevisionRef: RevisionRefSchema.optional(),
+  input: JsonObjectSchema
+}).strict();
+var CompiledNavigationResolvedTargetSchema = z10.discriminatedUnion("kind", [
+  CompiledNavigationTargetSchema,
+  CompiledNavigationRegisteredMenuActionTargetSchema,
+  CompiledNavigationDomainCommandTargetSchema
+]);
+var CompiledNavigationGroupNodeSchema = NavigationGroupNodeSchema.extend({
+  ancestorAccessPolicies: z10.array(AccessPolicySchema)
+}).strict();
+var CompiledNavigationTargetNodeSchema = NavigationTargetNodeSchema.extend({
+  ancestorAccessPolicies: z10.array(AccessPolicySchema),
+  resolvedTarget: CompiledNavigationResolvedTargetSchema
+}).strict();
+var CompiledNavigationSeparatorNodeSchema = NavigationSeparatorNodeSchema.extend({
+  ancestorAccessPolicies: z10.array(AccessPolicySchema)
+}).strict();
+var CompiledNavigationNodeSchema = z10.discriminatedUnion("kind", [
+  CompiledNavigationGroupNodeSchema,
+  CompiledNavigationTargetNodeSchema,
+  CompiledNavigationSeparatorNodeSchema
+]);
+var NavigationRuntimeBundleSchema = z10.object({
+  contract: z10.literal("NavigationRuntimeBundle"),
+  ...RuntimeBundleBaseShape,
+  navigationId: ContractIdentifierSchema,
+  navigationRevisionRef: RevisionRefSchema,
+  surface: ProductSurfaceSchema,
+  placement: ContractIdentifierSchema,
+  nodes: z10.array(CompiledNavigationNodeSchema),
+  performanceBudgetRef: RevisionRefSchema,
+  observationPolicyRevisionRef: RevisionRefSchema
+}).strict();
+var DeclarativeControlOntologyDefinitionSchema = OntologyDefinitionSchema.extend({
+  classification: z10.literal("control"),
+  discovery: z10.object({
+    ordinaryDataBrowser: z10.literal(false),
+    businessSearch: z10.literal(false),
+    businessStatistics: z10.literal(false),
+    ordinaryExport: z10.literal(false),
+    genericWrite: z10.literal(false)
+  }).strict()
+}).strict();
+var controlDefinition = (ontologyId, bodySchemaRef) => DeclarativeControlOntologyDefinitionSchema.parse({
+  contract: "OntologyDefinition",
+  ontologyId,
+  dataSpaceId: "monkeys.control",
+  ownerRepo: "monkeys-js-sdk",
+  bodySchemaRef,
+  authority: { service: "monkeys-data-server", storage: "domain-record", scope: "tenant" },
+  relationKinds: [],
+  metricKinds: [],
+  classification: "control",
+  discovery: {
+    ordinaryDataBrowser: false,
+    businessSearch: false,
+    businessStatistics: false,
+    ordinaryExport: false,
+    genericWrite: false
+  }
+});
+var DECLARATIVE_CONTROL_ONTOLOGY_DEFINITIONS = Object.freeze([
+  controlDefinition("monkeys.system.page", "monkeys.system.page/v1"),
+  controlDefinition("monkeys.system.page-release", "monkeys.system.page-release/v1"),
+  controlDefinition("monkeys.system.workbench", "monkeys.system.workbench/v1"),
+  controlDefinition("monkeys.system.workbench-release", "monkeys.system.workbench-release/v1"),
+  controlDefinition("monkeys.system.navigation", "monkeys.system.navigation/v1"),
+  controlDefinition("monkeys.system.navigation-release", "monkeys.system.navigation-release/v1")
+]);
+
 // src/contracts/menu.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/contracts/page.ts
-import { z as z10 } from "zod";
-var PageTypeSchema = z10.enum([
+import { z as z11 } from "zod";
+var PageTypeSchema = z11.enum([
   "page",
   "workspace",
   "view",
@@ -8378,14 +9316,14 @@ var PageTypeSchema = z10.enum([
   "global-design-board",
   "iframe"
 ]);
-var PageVisibilitySchema = z10.object({
-  authenticated: z10.boolean().default(true),
-  permissionAllOf: z10.array(ContractIdentifierSchema).default([]),
-  permissionAnyOf: z10.array(ContractIdentifierSchema).default([]),
-  featureFlags: z10.array(ContractIdentifierSchema).default([]),
-  productContexts: z10.array(z10.enum(["studio", "kernel"])).min(1)
-}).strict();
-var PageRoutePathSchema = z10.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
+var PageVisibilitySchema = z11.object({
+  authenticated: z11.boolean().default(true),
+  permissionAllOf: z11.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z11.array(ContractIdentifierSchema).default([]),
+  featureFlags: z11.array(ContractIdentifierSchema).default([]),
+  productContexts: z11.array(z11.enum(["studio", "kernel"])).min(1)
+}).strict();
+var PageRoutePathSchema = z11.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
 var requireCapabilityReference = (reference, path, context) => {
   if (reference.kind !== "capability") {
     context.addIssue({
@@ -8409,53 +9347,53 @@ var requireCapabilityReference = (reference, path, context) => {
     });
   }
 };
-var PageDefinitionSchema = z10.object({
-  contract: z10.literal("PageDefinition"),
+var PageDefinitionSchema = z11.object({
+  contract: z11.literal("PageDefinition"),
   pageId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
   title: LocalizedTextSchema,
   pageType: PageTypeSchema,
-  ownership: z10.object({
+  ownership: z11.object({
     teamId: ContractIdentifierSchema.optional(),
     creatorRef: EntityRefSchema.optional(),
     studioId: ContractIdentifierSchema.optional(),
-    builtIn: z10.boolean()
+    builtIn: z11.boolean()
   }).strict(),
-  record: z10.object({
-    createdTimestamp: z10.number().int().nonnegative().optional(),
-    updatedTimestamp: z10.number().int().nonnegative().optional(),
-    deleted: z10.boolean().default(false)
+  record: z11.object({
+    createdTimestamp: z11.number().int().nonnegative().optional(),
+    updatedTimestamp: z11.number().int().nonnegative().optional(),
+    deleted: z11.boolean().default(false)
   }).strict(),
-  surface: z10.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z11.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   routeId: ContractIdentifierSchema,
   routePath: PageRoutePathSchema,
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z10.array(EntityRefSchema).default([]),
+  capabilityRefs: z11.array(EntityRefSchema).default([]),
   workflowRef: EntityRefSchema.optional(),
-  binding: z10.object({
+  binding: z11.object({
     sourceRef: ContractIdentifierSchema.optional(),
     ontologyId: ContractIdentifierSchema.optional(),
     projectionRef: ContractIdentifierSchema.optional(),
     stateRef: ContractIdentifierSchema.optional()
   }).strict(),
-  access: z10.object({
-    actions: z10.array(z10.enum(["read", "write", "execute", "manage-permissions"])).default([])
+  access: z11.object({
+    actions: z11.array(z11.enum(["read", "write", "execute", "manage-permissions"])).default([])
   }).strict(),
-  input: z10.object({
+  input: z11.object({
     schemaRef: ContractIdentifierSchema
   }).strict().optional(),
-  rendererConfig: z10.object({
+  rendererConfig: z11.object({
     schemaRef: ContractIdentifierSchema,
     value: JsonObjectSchema
   }).strict(),
-  navigation: z10.object({
+  navigation: z11.object({
     label: LocalizedTextSchema,
     iconRef: ContractIdentifierSchema.optional(),
     parentPageId: ContractIdentifierSchema.optional(),
-    order: z10.number().int().optional(),
-    hidden: z10.boolean().default(false),
-    pinned: z10.boolean().default(false)
+    order: z11.number().int().optional(),
+    hidden: z11.boolean().default(false),
+    pinned: z11.boolean().default(false)
   }).strict(),
   visibility: PageVisibilitySchema
 }).strict().superRefine((page, context) => {
@@ -8476,8 +9414,8 @@ var PageDefinitionSchema = z10.object({
   });
   if (page.workflowRef && page.workflowRef.kind !== "workflow") context.addIssue({ code: "custom", path: ["workflowRef", "kind"], message: "workflowRef must reference a workflow." });
 });
-var PageRuntimeDescriptorSchema = z10.object({
-  contract: z10.literal("PageRuntimeDescriptor"),
+var PageRuntimeDescriptorSchema = z11.object({
+  contract: z11.literal("PageRuntimeDescriptor"),
   page: PageDefinitionSchema,
   nodeId: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
@@ -8485,54 +9423,54 @@ var PageRuntimeDescriptorSchema = z10.object({
   semanticRef: ContractIdentifierSchema.optional(),
   dataContextRef: ContractIdentifierSchema.optional(),
   providerRef: EntityRefSchema.optional(),
-  surface: z10.object({
+  surface: z11.object({
     frameOwner: ContractIdentifierSchema,
     tone: ContractIdentifierSchema.optional(),
-    density: z10.enum(["compact", "default", "comfortable"]).default("default")
+    density: z11.enum(["compact", "default", "comfortable"]).default("default")
   }).strict(),
-  scroll: z10.object({
-    owner: z10.enum(["page", "surface", "provider"]),
-    axis: z10.enum(["x", "y", "both", "none"]),
+  scroll: z11.object({
+    owner: z11.enum(["page", "surface", "provider"]),
+    axis: z11.enum(["x", "y", "both", "none"]),
     restoreKey: ContractIdentifierSchema.optional(),
-    virtualized: z10.boolean().default(false)
+    virtualized: z11.boolean().default(false)
   }).strict(),
-  activation: z10.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
-  lifecycle: z10.object({
-    mountPolicy: z10.enum(["always", "when-visible", "when-active"]),
-    queryPolicy: z10.enum(["always", "when-visible", "when-active", "manual"]),
-    deepLink: z10.boolean(),
-    focusReturn: z10.boolean()
+  activation: z11.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
+  lifecycle: z11.object({
+    mountPolicy: z11.enum(["always", "when-visible", "when-active"]),
+    queryPolicy: z11.enum(["always", "when-visible", "when-active", "manual"]),
+    deepLink: z11.boolean(),
+    focusReturn: z11.boolean()
   }).strict()
 }).strict();
-var PageRouteProjectionSchema = z10.object({
+var PageRouteProjectionSchema = z11.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema
 }).strict();
-var PageNavigationProjectionSchema = z10.object({
+var PageNavigationProjectionSchema = z11.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema,
   label: LocalizedTextSchema,
   iconRef: ContractIdentifierSchema.optional(),
   parentPageId: ContractIdentifierSchema.optional(),
-  order: z10.number().int().optional(),
-  pinned: z10.boolean()
+  order: z11.number().int().optional(),
+  pinned: z11.boolean()
 }).strict();
-var PageGuardProjectionSchema = z10.object({
+var PageGuardProjectionSchema = z11.object({
   pageId: ContractIdentifierSchema,
-  authenticated: z10.boolean(),
-  permissionAllOf: z10.array(ContractIdentifierSchema),
-  permissionAnyOf: z10.array(ContractIdentifierSchema),
-  featureFlags: z10.array(ContractIdentifierSchema),
-  actions: z10.array(z10.enum(["read", "write", "execute", "manage-permissions"]))
+  authenticated: z11.boolean(),
+  permissionAllOf: z11.array(ContractIdentifierSchema),
+  permissionAnyOf: z11.array(ContractIdentifierSchema),
+  featureFlags: z11.array(ContractIdentifierSchema),
+  actions: z11.array(z11.enum(["read", "write", "execute", "manage-permissions"]))
 }).strict();
-var PageRendererProjectionSchema = z10.object({
+var PageRendererProjectionSchema = z11.object({
   pageId: ContractIdentifierSchema,
-  surface: z10.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z11.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z10.array(EntityRefSchema),
+  capabilityRefs: z11.array(EntityRefSchema),
   providerRef: EntityRefSchema,
   binding: PageDefinitionSchema.shape.binding,
   rendererConfig: PageDefinitionSchema.shape.rendererConfig,
@@ -8573,13 +9511,13 @@ var duplicateProjectionIdentity = (values, identity) => {
   }
   return void 0;
 };
-var PageRuntimeProjectionSchema = z10.object({
-  contract: z10.literal("PageRuntimeProjection"),
-  product: z10.enum(["studio", "kernel"]),
-  routes: z10.array(PageRouteProjectionSchema),
-  navigation: z10.array(PageNavigationProjectionSchema),
-  guards: z10.array(PageGuardProjectionSchema),
-  renderers: z10.array(PageRendererProjectionSchema)
+var PageRuntimeProjectionSchema = z11.object({
+  contract: z11.literal("PageRuntimeProjection"),
+  product: z11.enum(["studio", "kernel"]),
+  routes: z11.array(PageRouteProjectionSchema),
+  navigation: z11.array(PageNavigationProjectionSchema),
+  guards: z11.array(PageGuardProjectionSchema),
+  renderers: z11.array(PageRendererProjectionSchema)
 }).strict().superRefine((projection, context) => {
   const tables = [
     ["routes", projection.routes.map((value) => value.pageId)],
@@ -8641,7 +9579,7 @@ var MENU_MAX_NODES = 1024;
 var MENU_MAX_TREE_DEPTH = 16;
 var MENU_MAX_INPUT_BYTES = 64 * 1024;
 var MENU_MAX_INPUT_VALUES = 2048;
-var MenuOrderSchema = z11.number().int().min(-1e6).max(1e6);
+var MenuOrderSchema = z12.number().int().min(-1e6).max(1e6);
 var inspectJsonValue = (value) => {
   let maxDepth = 0;
   let values = 0;
@@ -8684,30 +9622,30 @@ var MenuBoundedInputSchema = JsonObjectSchema.superRefine((value, context) => {
     });
   }
 });
-var MenuPageRefSchema = z11.object({
+var MenuPageRefSchema = z12.object({
   applicationId: ContractIdentifierSchema,
   pageId: ContractIdentifierSchema
 }).strict();
-var MenuSourceInputBindingSchema = z11.discriminatedUnion("exposure", [
-  z11.object({ exposure: z11.literal("client"), value: MenuBoundedInputSchema }).strict(),
-  z11.object({ exposure: z11.literal("server"), value: MenuBoundedInputSchema }).strict()
+var MenuSourceInputBindingSchema = z12.discriminatedUnion("exposure", [
+  z12.object({ exposure: z12.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z12.object({ exposure: z12.literal("server"), value: MenuBoundedInputSchema }).strict()
 ]);
-var MenuRuntimeInputBindingSchema = z11.discriminatedUnion("exposure", [
-  z11.object({ exposure: z11.literal("client"), value: MenuBoundedInputSchema }).strict(),
-  z11.object({ exposure: z11.literal("server") }).strict()
+var MenuRuntimeInputBindingSchema = z12.discriminatedUnion("exposure", [
+  z12.object({ exposure: z12.literal("client"), value: MenuBoundedInputSchema }).strict(),
+  z12.object({ exposure: z12.literal("server") }).strict()
 ]);
-var MenuNavigateBehaviorSchema = z11.object({
-  kind: z11.literal("navigate"),
+var MenuNavigateBehaviorSchema = z12.object({
+  kind: z12.literal("navigate"),
   page: MenuPageRefSchema,
   activationId: ContractIdentifierSchema.optional(),
   input: MenuSourceInputBindingSchema.optional()
 }).strict();
-var MenuActionBehaviorSchema = z11.object({
-  kind: z11.literal("action"),
+var MenuActionBehaviorSchema = z12.object({
+  kind: z12.literal("action"),
   actionRef: ContractIdentifierSchema,
   input: MenuBoundedInputSchema.optional()
 }).strict();
-var MenuBehaviorSchema = z11.discriminatedUnion("kind", [
+var MenuBehaviorSchema = z12.discriminatedUnion("kind", [
   MenuNavigateBehaviorSchema,
   MenuActionBehaviorSchema
 ]);
@@ -8716,33 +9654,33 @@ var MenuNodeBaseShape = {
   parentNodeId: ContractIdentifierSchema.optional(),
   order: MenuOrderSchema
 };
-var MenuGroupNodeSchema = z11.object({
+var MenuGroupNodeSchema = z12.object({
   ...MenuNodeBaseShape,
-  kind: z11.literal("group"),
+  kind: z12.literal("group"),
   label: LocalizedTextSchema.optional(),
   iconRef: ContractIdentifierSchema.optional(),
-  disabled: z11.boolean().optional()
+  disabled: z12.boolean().optional()
 }).strict();
-var MenuDividerNodeSchema = z11.object({
+var MenuDividerNodeSchema = z12.object({
   ...MenuNodeBaseShape,
-  kind: z11.literal("divider")
+  kind: z12.literal("divider")
 }).strict();
-var MenuItemNodeSchema = z11.object({
+var MenuItemNodeSchema = z12.object({
   ...MenuNodeBaseShape,
-  kind: z11.literal("item"),
+  kind: z12.literal("item"),
   label: LocalizedTextSchema,
   iconRef: ContractIdentifierSchema.optional(),
-  tone: z11.enum(["default", "danger"]).optional(),
-  disabled: z11.boolean().optional(),
+  tone: z12.enum(["default", "danger"]).optional(),
+  disabled: z12.boolean().optional(),
   requiredPermission: ContractIdentifierSchema.optional(),
   behavior: MenuBehaviorSchema
 }).strict();
-var MenuNodeSchema = z11.discriminatedUnion("kind", [
+var MenuNodeSchema = z12.discriminatedUnion("kind", [
   MenuGroupNodeSchema,
   MenuDividerNodeSchema,
   MenuItemNodeSchema
 ]);
-var MenuContributionSchema = z11.object({
+var MenuContributionSchema = z12.object({
   providerId: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
   order: MenuOrderSchema
@@ -8812,55 +9750,55 @@ var validateMenuStructure = (menu, context) => {
     contributionKeys.add(key);
   });
 };
-var MenuDefinitionSchema = z11.object({
-  contract: z11.literal("MenuDefinition"),
-  version: z11.literal(MENU_CONTRACT_VERSION),
+var MenuDefinitionSchema = z12.object({
+  contract: z12.literal("MenuDefinition"),
+  version: z12.literal(MENU_CONTRACT_VERSION),
   applicationId: ContractIdentifierSchema,
   surface: ContractIdentifierSchema,
   menuId: ContractIdentifierSchema,
-  nodes: z11.array(MenuNodeSchema).max(MENU_MAX_NODES),
-  contributions: z11.array(MenuContributionSchema).max(MENU_MAX_NODES).default([])
+  nodes: z12.array(MenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z12.array(MenuContributionSchema).max(MENU_MAX_NODES).default([])
 }).strict().superRefine(validateMenuStructure);
-var MenuDefinitionSetSchema = z11.union([
-  z11.literal("*"),
-  z11.object({
-    version: z11.literal(MENU_CONTRACT_VERSION),
-    definitions: z11.array(MenuDefinitionSchema).max(MENU_MAX_DEFINITIONS)
+var MenuDefinitionSetSchema = z12.union([
+  z12.literal("*"),
+  z12.object({
+    version: z12.literal(MENU_CONTRACT_VERSION),
+    definitions: z12.array(MenuDefinitionSchema).max(MENU_MAX_DEFINITIONS)
   }).strict()
 ]);
-var MenuAccessRequirementSchema = z11.object({
-  authenticated: z11.boolean().default(true),
-  permissionAllOf: z11.array(ContractIdentifierSchema).default([]),
-  permissionAnyOf: z11.array(ContractIdentifierSchema).default([]),
-  featureFlags: z11.array(ContractIdentifierSchema).default([])
+var MenuAccessRequirementSchema = z12.object({
+  authenticated: z12.boolean().default(true),
+  permissionAllOf: z12.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z12.array(ContractIdentifierSchema).default([]),
+  featureFlags: z12.array(ContractIdentifierSchema).default([])
 }).strict();
-var MenuPageRegistrationSchema = z11.object({
+var MenuPageRegistrationSchema = z12.object({
   applicationId: ContractIdentifierSchema,
   page: PageDefinitionSchema
 }).strict();
-var MenuActionRegistrationSchema = z11.object({
+var MenuActionRegistrationSchema = z12.object({
   applicationId: ContractIdentifierSchema,
   actionRef: ContractIdentifierSchema,
   inputSchemaRef: ContractIdentifierSchema.optional(),
   access: MenuAccessRequirementSchema
 }).strict();
-var MenuContributionProviderRegistrationSchema = z11.object({
+var MenuContributionProviderRegistrationSchema = z12.object({
   applicationId: ContractIdentifierSchema,
   providerId: ContractIdentifierSchema,
-  surfaces: z11.array(ContractIdentifierSchema).min(1).optional()
+  surfaces: z12.array(ContractIdentifierSchema).min(1).optional()
 }).strict();
-var CompiledMenuNavigateBehaviorSchema = z11.object({
-  kind: z11.literal("navigate"),
+var CompiledMenuNavigateBehaviorSchema = z12.object({
+  kind: z12.literal("navigate"),
   page: MenuPageRefSchema,
   activationId: ContractIdentifierSchema,
   input: MenuRuntimeInputBindingSchema.optional()
 }).strict();
-var CompiledMenuActionBehaviorSchema = z11.object({
-  kind: z11.literal("action"),
+var CompiledMenuActionBehaviorSchema = z12.object({
+  kind: z12.literal("action"),
   actionRef: ContractIdentifierSchema,
   input: MenuBoundedInputSchema.optional()
 }).strict();
-var CompiledMenuBehaviorSchema = z11.discriminatedUnion("kind", [
+var CompiledMenuBehaviorSchema = z12.discriminatedUnion("kind", [
   CompiledMenuNavigateBehaviorSchema,
   CompiledMenuActionBehaviorSchema
 ]);
@@ -8873,76 +9811,96 @@ var CompiledMenuItemNodeSchema = MenuItemNodeSchema.omit({ behavior: true, requi
   behavior: CompiledMenuBehaviorSchema,
   access: CompiledMenuItemAccessSchema
 }).strict();
-var CompiledMenuNodeSchema = z11.discriminatedUnion("kind", [
+var CompiledMenuNodeSchema = z12.discriminatedUnion("kind", [
   CompiledMenuGroupNodeSchema,
   CompiledMenuDividerNodeSchema,
   CompiledMenuItemNodeSchema
 ]);
-var CompiledMenuProjectionSchema = z11.object({
+var CompiledMenuProjectionSchema = z12.object({
   applicationId: ContractIdentifierSchema,
   surface: ContractIdentifierSchema,
   menuId: ContractIdentifierSchema,
-  nodes: z11.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES),
-  contributions: z11.array(MenuContributionSchema).max(MENU_MAX_NODES)
+  nodes: z12.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES),
+  contributions: z12.array(MenuContributionSchema).max(MENU_MAX_NODES)
 }).strict();
-var MenuNavigationTargetSchema = z11.object({
+var MenuNavigationTargetSchema = z12.object({
   page: MenuPageRefSchema,
   activationId: ContractIdentifierSchema,
   input: MenuRuntimeInputBindingSchema.optional()
 }).strict();
-var MenuRuntimeBundleSchema = z11.object({
-  contract: z11.literal("MenuRuntimeBundle"),
-  version: z11.literal(MENU_CONTRACT_VERSION),
+var MenuRuntimeBundleSchema = z12.object({
+  contract: z12.literal("MenuRuntimeBundle"),
+  version: z12.literal(MENU_CONTRACT_VERSION),
   applicationId: ContractIdentifierSchema,
   sourceVersion: ContractIdentifierSchema,
   contentHash: Sha256Schema,
-  menus: z11.array(CompiledMenuProjectionSchema).max(MENU_MAX_DEFINITIONS),
-  navigationTargets: z11.array(MenuNavigationTargetSchema),
-  sourceMap: z11.record(z11.string(), ContractIdentifierSchema).default({})
+  menus: z12.array(CompiledMenuProjectionSchema).max(MENU_MAX_DEFINITIONS),
+  navigationTargets: z12.array(MenuNavigationTargetSchema),
+  sourceMap: z12.record(z12.string(), ContractIdentifierSchema).default({})
 }).strict();
-var MenuContributionResultSchema = z11.object({
-  contract: z11.literal("MenuContributionResult"),
+var MenuContributionResultSchema = z12.object({
+  contract: z12.literal("MenuContributionResult"),
   applicationId: ContractIdentifierSchema,
   surface: ContractIdentifierSchema,
   menuId: ContractIdentifierSchema,
   providerId: ContractIdentifierSchema,
-  nodes: z11.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES)
+  nodes: z12.array(CompiledMenuNodeSchema).max(MENU_MAX_NODES)
 }).strict();
 
 // src/contracts/semantic.ts
-import { z as z12 } from "zod";
-var ConceptRelationshipSchema = z12.object({
+import { z as z13 } from "zod";
+var ExactRefKindSchema = (kind) => RevisionRefSchema.superRefine((value, context) => {
+  if (value.kind !== kind) context.addIssue({ code: "custom", path: ["kind"], message: `Reference must use kind ${kind}.` });
+});
+var SchemaDefinitionSchema = z13.object({
+  contract: z13.literal("Schema"),
+  schemaVersion: z13.literal(1),
+  schemaId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  dialect: z13.literal("https://json-schema.org/draft/2020-12/schema"),
+  document: JsonObjectSchema
+}).strict();
+var OntologyViewDefinitionSchema = z13.object({
+  contract: z13.literal("View"),
+  schemaVersion: z13.literal(1),
+  viewId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  ontologyDefinitionRevisionRef: ExactRefKindSchema("ontology-definition"),
+  renderModelSchemaRevisionRef: ExactRefKindSchema("schema"),
+  requiredPermissionCodes: z13.array(ContractIdentifierSchema).default([])
+}).strict();
+var ConceptRelationshipSchema = z13.object({
   kind: ContractIdentifierSchema,
   targetConceptId: ContractIdentifierSchema,
-  cardinality: z12.enum(["one", "optional", "many"])
+  cardinality: z13.enum(["one", "optional", "many"])
 }).strict();
-var ConceptDefinitionSchema = z12.object({
-  contract: z12.literal("ConceptDefinition"),
+var ConceptDefinitionSchema = z13.object({
+  contract: z13.literal("ConceptDefinition"),
   conceptId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z12.string().trim().min(1),
-  description: z12.string().optional(),
+  displayName: z13.string().trim().min(1),
+  description: z13.string().optional(),
   schemaRef: ContractIdentifierSchema,
   ontologyId: ContractIdentifierSchema.optional(),
-  capabilityIds: z12.array(ContractIdentifierSchema).default([]),
-  commandNames: z12.array(ContractIdentifierSchema).default([]),
-  relationships: z12.array(ConceptRelationshipSchema).default([])
+  capabilityIds: z13.array(ContractIdentifierSchema).default([]),
+  commandNames: z13.array(ContractIdentifierSchema).default([]),
+  relationships: z13.array(ConceptRelationshipSchema).default([])
 }).strict();
-var DomainCommandDefinitionSchema = z12.object({
-  contract: z12.literal("DomainCommandDefinition"),
+var DomainCommandDefinitionSchema = z13.object({
+  contract: z13.literal("DomainCommandDefinition"),
   commandName: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z12.string().trim().min(1),
-  description: z12.string().optional(),
-  targetKinds: z12.array(ContractIdentifierSchema).min(1),
+  displayName: z13.string().trim().min(1),
+  description: z13.string().optional(),
+  targetKinds: z13.array(ContractIdentifierSchema).min(1),
   inputSchemaRef: ContractIdentifierSchema,
   outputSchemaRef: ContractIdentifierSchema.optional(),
-  requiredPermissionCodes: z12.array(ContractIdentifierSchema).default([]),
+  requiredPermissionCodes: z13.array(ContractIdentifierSchema).default([]),
   handlerRef: EntityRefSchema,
-  sideEffects: z12.array(z12.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+  sideEffects: z13.array(z13.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
 }).strict();
-var DomainCommandSchema = z12.object({
-  contract: z12.literal("DomainCommand"),
+var DomainCommandSchema = z13.object({
+  contract: z13.literal("DomainCommand"),
   commandId: ContractIdentifierSchema,
   commandName: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
@@ -8950,30 +9908,30 @@ var DomainCommandSchema = z12.object({
   idempotencyKey: ContractIdentifierSchema,
   targetRef: EntityRefSchema,
   actorRef: EntityRefSchema,
-  source: z12.object({
-    product: z12.enum(["studio", "kernel", "agent", "mcp", "service"]),
+  source: z13.object({
+    product: z13.enum(["studio", "kernel", "agent", "mcp", "service"]),
     pageId: ContractIdentifierSchema.optional(),
     capabilityId: ContractIdentifierSchema.optional()
   }).strict(),
   payload: JsonObjectSchema,
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ProductDeclarationSchema = z12.object({
-  contract: z12.literal("ProductDeclaration"),
+var ProductDeclarationSchema = z13.object({
+  contract: z13.literal("ProductDeclaration"),
   declarationId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  concepts: z12.array(ConceptDefinitionSchema).default([]),
-  ontologies: z12.array(OntologyDefinitionSchema).default([]),
-  projections: z12.array(ProjectionSpecSchema).default([]),
-  commands: z12.array(DomainCommandDefinitionSchema).default([]),
-  capabilities: z12.array(CapabilityManifestSchema).default([]),
-  pages: z12.array(PageDefinitionSchema).default([]),
-  menus: z12.array(MenuDefinitionSchema).default([])
-}).strict();
-var DeclarationGraphEdgeSchema = z12.object({
+  concepts: z13.array(ConceptDefinitionSchema).default([]),
+  ontologies: z13.array(OntologyDefinitionSchema).default([]),
+  projections: z13.array(ProjectionSpecSchema).default([]),
+  commands: z13.array(DomainCommandDefinitionSchema).default([]),
+  capabilities: z13.array(CapabilityManifestSchema).default([]),
+  pages: z13.array(PageDefinitionSchema).default([]),
+  menus: z13.array(MenuDefinitionSchema).default([])
+}).strict();
+var DeclarationGraphEdgeSchema = z13.object({
   from: EntityRefSchema,
   to: EntityRefSchema,
-  relation: z12.enum([
+  relation: z13.enum([
     "uses-ontology",
     "uses-projection",
     "uses-capability",
@@ -8981,25 +9939,25 @@ var DeclarationGraphEdgeSchema = z12.object({
     "relates-to-concept"
   ])
 }).strict();
-var ChangeImpactSchema = z12.object({
+var ChangeImpactSchema = z13.object({
   changedRef: EntityRefSchema,
-  affectedRefs: z12.array(EntityRefSchema),
-  reasons: z12.array(ContractIdentifierSchema).min(1)
+  affectedRefs: z13.array(EntityRefSchema),
+  reasons: z13.array(ContractIdentifierSchema).min(1)
 }).strict();
-var ChangeImpactGraphSchema = z12.object({
-  contract: z12.literal("ChangeImpactGraph"),
+var ChangeImpactGraphSchema = z13.object({
+  contract: z13.literal("ChangeImpactGraph"),
   declarationId: ContractIdentifierSchema,
-  nodes: z12.array(EntityRefSchema),
-  edges: z12.array(DeclarationGraphEdgeSchema),
-  impacts: z12.array(ChangeImpactSchema),
+  nodes: z13.array(EntityRefSchema),
+  edges: z13.array(DeclarationGraphEdgeSchema),
+  impacts: z13.array(ChangeImpactSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/tenant.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -11193,20 +12151,20 @@ var MONKEYS_REQUIRED_THEME_TOKEN_PATHS = Object.freeze({
 });
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z13.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z13.record(z13.string(), z13.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z14.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z14.record(z14.string(), z14.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure({ token: input });
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokenGroupSchema = z13.record(z13.string(), z13.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z14.record(z14.string(), z14.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z13.record(z13.string(), z13.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z14.record(z14.string(), z14.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -11233,9 +12191,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z14.object({
-  type: z14.literal("file"),
-  path: z14.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z15.object({
+  type: z15.literal("file"),
+  path: z15.string().trim().min(1).superRefine((source, context) => {
     const isWindowsDrivePath = /^[a-z]:[\\/]/i.test(source);
     if (!isWindowsDrivePath && /^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
@@ -11245,9 +12203,9 @@ var DesignTokenFileSourceSchema = z14.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z14.object({
-  type: z14.literal("url"),
-  url: z14.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z15.object({
+  type: z15.literal("url"),
+  url: z15.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -11256,55 +12214,45 @@ var DesignTokenUrlSourceSchema = z14.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z14.object({
-  type: z14.literal("inline"),
+var DesignTokenInlineSourceSchema = z15.object({
+  type: z15.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z14.discriminatedUnion("type", [
-  DesignTokenFileSourceSchema,
-  DesignTokenUrlSourceSchema,
-  DesignTokenInlineSourceSchema
-]);
-var TenantDesignTokensConfigSchema = z14.object({
+var DesignTokenSourceSchema = z15.discriminatedUnion("type", [DesignTokenFileSourceSchema, DesignTokenUrlSourceSchema, DesignTokenInlineSourceSchema]);
+var TenantDesignTokensConfigSchema = z15.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z14.array(DesignTokenSourceSchema)
+  tokenSources: z15.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z14.object({
-  kind: z14.literal("auth-provider"),
+var TenantAuthBindingSchema = z15.object({
+  kind: z15.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z14.discriminatedUnion("kind", [
-  z14.object({
-    kind: z14.literal("data-provider"),
+var TenantDataBindingSchema = z15.discriminatedUnion("kind", [
+  z15.object({
+    kind: z15.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z14.object({
-    kind: z14.literal("projection"),
+  z15.object({
+    kind: z15.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z14.record(
-  ContractIdentifierSchema,
-  TenantAuthBindingSchema
-);
-var TenantDataBindingsSchema = z14.record(
-  ContractIdentifierSchema,
-  TenantDataBindingSchema
-);
-var TenantTrendRadarSourceSchema = z14.object({
+var TenantAuthBindingsSchema = z15.record(ContractIdentifierSchema, TenantAuthBindingSchema);
+var TenantDataBindingsSchema = z15.record(ContractIdentifierSchema, TenantDataBindingSchema);
+var TenantTrendRadarSourceSchema = z15.object({
   ontologyId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarCollectionTargetSchema = z14.object({
+var TenantTrendRadarCollectionTargetSchema = z15.object({
   ontologyId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarEvaluationSchema = z14.object({
+var TenantTrendRadarEvaluationSchema = z15.object({
   workflowId: ContractIdentifierSchema
 }).strict();
-var TenantTrendRadarDerivedMetricsSchema = z14.object({
+var TenantTrendRadarDerivedMetricsSchema = z15.object({
   productCountFieldKey: ContractIdentifierSchema,
   salesValueCountFieldKey: ContractIdentifierSchema,
   salesSumFieldKey: ContractIdentifierSchema
@@ -11312,7 +12260,7 @@ var TenantTrendRadarDerivedMetricsSchema = z14.object({
   ({ productCountFieldKey, salesValueCountFieldKey, salesSumFieldKey }) => (/* @__PURE__ */ new Set([productCountFieldKey, salesValueCountFieldKey, salesSumFieldKey])).size === 3,
   { message: "Trend Radar derived metric Field Keys must be distinct." }
 );
-var TenantTrendRadarSourcesSchema = z14.object({
+var TenantTrendRadarSourcesSchema = z15.object({
   products: TenantTrendRadarSourceSchema.optional(),
   hotwords: TenantTrendRadarSourceSchema.optional(),
   brands: TenantTrendRadarSourceSchema.optional(),
@@ -11320,58 +12268,54 @@ var TenantTrendRadarSourcesSchema = z14.object({
   derivedMetrics: TenantTrendRadarDerivedMetricsSchema.optional(),
   evaluation: TenantTrendRadarEvaluationSchema.optional()
 }).strict();
-var AssetVariantsSchema = z14.object({
-  light: z14.string().optional(),
-  dark: z14.string().optional()
+var AssetVariantsSchema = z15.object({
+  light: z15.string().optional(),
+  dark: z15.string().optional()
 }).strict();
-var TenantAgentThemeConfigSchema = z14.object({
+var TenantAgentThemeConfigSchema = z15.object({
   logo: AssetVariantsSchema.optional(),
-  brandDisplayMode: z14.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-  density: z14.enum(["compact", "default", "comfortable"]).optional(),
+  brandDisplayMode: z15.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+  density: z15.enum(["compact", "default", "comfortable"]).optional(),
   sidebar: AgentWorkbenchSidebarConfigSchema.optional(),
   /** @deprecated Use sidebar.navigationMode. */
-  navigationMode: z14.enum(["default", "session", "trend"]).optional(),
+  navigationMode: z15.enum(["default", "session", "trend"]).optional(),
   /** @deprecated Use sidebar.quickStartEnabled. */
-  quickStartEnabled: z14.boolean().optional()
+  quickStartEnabled: z15.boolean().optional()
 }).strict();
 var LEGACY_CURRENT_USER_MENU_ITEM_IDS = ["dark-mode", "language", "settings", "logout"];
 var CURRENT_USER_MENU_CONTROL_REFS = ["dark-mode", "language"];
 var CURRENT_USER_MENU_ACTION_REFS = ["logout"];
-var CurrentUserMenuIdentifierSchema = z14.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
-var CurrentUserMenuDisplayTextSchema = z14.union([
-  z14.string().trim().min(1),
-  z14.record(z14.string().trim().min(1), z14.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
+var CurrentUserMenuIdentifierSchema = z15.string().trim().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/, "Expected a stable current-user menu identifier.");
+var CurrentUserMenuDisplayTextSchema = z15.union([
+  z15.string().trim().min(1),
+  z15.record(z15.string().trim().min(1), z15.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized menu text must contain at least one locale.")
 ]);
-var CurrentUserMenuNavigationItemSchema = z14.object({
+var CurrentUserMenuNavigationItemSchema = z15.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z14.literal("navigation"),
+  kind: z15.literal("navigation"),
   ref: CurrentUserMenuIdentifierSchema
 }).strict();
-var CurrentUserMenuControlItemSchema = z14.object({
+var CurrentUserMenuControlItemSchema = z15.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z14.literal("control"),
-  ref: z14.enum(CURRENT_USER_MENU_CONTROL_REFS)
+  kind: z15.literal("control"),
+  ref: z15.enum(CURRENT_USER_MENU_CONTROL_REFS)
 }).strict();
-var CurrentUserMenuActionItemSchema = z14.object({
+var CurrentUserMenuActionItemSchema = z15.object({
   id: CurrentUserMenuIdentifierSchema,
-  kind: z14.literal("action"),
-  ref: z14.enum(CURRENT_USER_MENU_ACTION_REFS),
-  tone: z14.enum(["default", "danger"]).optional()
+  kind: z15.literal("action"),
+  ref: z15.enum(CURRENT_USER_MENU_ACTION_REFS),
+  tone: z15.enum(["default", "danger"]).optional()
 }).strict();
-var CurrentUserMenuItemSchema = z14.discriminatedUnion("kind", [
-  CurrentUserMenuNavigationItemSchema,
-  CurrentUserMenuControlItemSchema,
-  CurrentUserMenuActionItemSchema
-]);
-var CurrentUserMenuSectionSchema = z14.object({
+var CurrentUserMenuItemSchema = z15.discriminatedUnion("kind", [CurrentUserMenuNavigationItemSchema, CurrentUserMenuControlItemSchema, CurrentUserMenuActionItemSchema]);
+var CurrentUserMenuSectionSchema = z15.object({
   id: CurrentUserMenuIdentifierSchema,
   label: CurrentUserMenuDisplayTextSchema.optional(),
-  dividerBefore: z14.boolean().optional(),
-  items: z14.array(CurrentUserMenuItemSchema)
+  dividerBefore: z15.boolean().optional(),
+  items: z15.array(CurrentUserMenuItemSchema)
 }).strict();
-var CurrentUserMenuConfigSchema = z14.object({
-  version: z14.literal(1),
-  sections: z14.array(CurrentUserMenuSectionSchema).max(20)
+var CurrentUserMenuConfigSchema = z15.object({
+  version: z15.literal(1),
+  sections: z15.array(CurrentUserMenuSectionSchema).max(20)
 }).strict().superRefine((value, context) => {
   const sectionIds = /* @__PURE__ */ new Set();
   const itemIds = /* @__PURE__ */ new Set();
@@ -11405,7 +12349,7 @@ var CurrentUserMenuConfigSchema = z14.object({
     });
   }
 });
-var LegacyCurrentUserMenuProfileSchema = z14.array(z14.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
+var LegacyCurrentUserMenuProfileSchema = z15.array(z15.enum(LEGACY_CURRENT_USER_MENU_ITEM_IDS)).superRefine((value, context) => {
   const seen = /* @__PURE__ */ new Set();
   value.forEach((item, index) => {
     if (seen.has(item)) {
@@ -11418,73 +12362,69 @@ var LegacyCurrentUserMenuProfileSchema = z14.array(z14.enum(LEGACY_CURRENT_USER_
     seen.add(item);
   });
 });
-var CurrentUserMenuProfileSchema = z14.union([
-  z14.literal("*"),
-  LegacyCurrentUserMenuProfileSchema,
-  CurrentUserMenuConfigSchema
-]);
-var ThemeHeadbarSchema = z14.object({
-  theme: z14.enum(["card", "glassy", "ghost"]).optional(),
-  navPosition: z14.enum(["left", "center", "right"]).optional(),
-  actions: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]).optional(),
+var CurrentUserMenuProfileSchema = z15.union([z15.literal("*"), LegacyCurrentUserMenuProfileSchema, CurrentUserMenuConfigSchema]);
+var ThemeHeadbarSchema = z15.object({
+  theme: z15.enum(["card", "glassy", "ghost"]).optional(),
+  navPosition: z15.enum(["left", "center", "right"]).optional(),
+  actions: z15.union([z15.literal("*"), z15.array(ContractIdentifierSchema)]).optional(),
   profile: CurrentUserMenuProfileSchema.optional(),
-  showTeamQuota: z14.boolean().optional()
+  showTeamQuota: z15.boolean().optional()
 }).strict();
-var TenantHeadbarModuleLeafSchema = z14.object({
+var TenantHeadbarModuleLeafSchema = z15.object({
   id: ContractIdentifierSchema,
-  extraInfo: z14.boolean().optional(),
-  displayName: z14.union([z14.string(), z14.record(LocaleIdentifierSchema, z14.string())]).optional(),
-  visible: z14.boolean().optional(),
-  disabled: z14.boolean().optional(),
-  icon: z14.string().optional(),
-  showQuickSwitcher: z14.boolean().optional(),
-  showSidebar: z14.boolean().optional(),
-  showContentFrame: z14.boolean().optional()
+  extraInfo: z15.boolean().optional(),
+  displayName: z15.union([z15.string(), z15.record(LocaleIdentifierSchema, z15.string())]).optional(),
+  visible: z15.boolean().optional(),
+  disabled: z15.boolean().optional(),
+  icon: z15.string().optional(),
+  showQuickSwitcher: z15.boolean().optional(),
+  showSidebar: z15.boolean().optional(),
+  showContentFrame: z15.boolean().optional()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  children: z14.array(TenantHeadbarModuleLeafSchema).optional()
-}).strict();
-var KernelHeadbarSchema = z14.object({
-  theme: z14.literal("card").optional(),
-  layoutMode: z14.enum(["boxed", "full-bleed"]).optional(),
-  heightPx: z14.number().positive().optional(),
-  navPosition: z14.enum(["left", "center", "right"]).optional(),
-  brandTitle: z14.string().optional(),
-  menuRadius: z14.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
-}).strict();
-var CustomIconSchema = z14.object({
-  color: z14.string().optional(),
-  url: z14.string().optional(),
-  type: z14.enum(["svg", "image"]).optional(),
-  hintTextColor: z14.string().optional()
-}).strict();
-var WorkbenchCustomerToolSchema = z14.object({
+  children: z15.array(TenantHeadbarModuleLeafSchema).optional()
+}).strict();
+var KernelHeadbarSchema = z15.object({
+  theme: z15.literal("card").optional(),
+  layoutMode: z15.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z15.number().positive().optional(),
+  navPosition: z15.enum(["left", "center", "right"]).optional(),
+  brandTitle: z15.string().optional(),
+  menuRadius: z15.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+}).strict();
+var CustomIconSchema = z15.object({
+  color: z15.string().optional(),
+  url: z15.string().optional(),
+  type: z15.enum(["svg", "image"]).optional(),
+  hintTextColor: z15.string().optional()
+}).strict();
+var WorkbenchCustomerToolSchema = z15.object({
   id: ContractIdentifierSchema,
-  label: z14.union([z14.string(), z14.record(LocaleIdentifierSchema, z14.string())]).optional(),
-  fixed: z14.boolean().optional()
+  label: z15.union([z15.string(), z15.record(LocaleIdentifierSchema, z15.string())]).optional(),
+  fixed: z15.boolean().optional()
 }).strict();
-var WorkbenchStudioOverrideSchema = z14.object({
-  studioName: z14.string().trim().min(1),
-  dropdownToolsDefault: z14.array(ContractIdentifierSchema).optional(),
-  existingToolsDefault: z14.array(ContractIdentifierSchema).optional(),
-  historyColumnsDefault: z14.number().int().min(1).max(6).optional()
+var WorkbenchStudioOverrideSchema = z15.object({
+  studioName: z15.string().trim().min(1),
+  dropdownToolsDefault: z15.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z15.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z15.number().int().min(1).max(6).optional()
 }).strict();
-var TenantWorkbenchPageContextSchema = z14.object({
+var TenantWorkbenchPageContextSchema = z15.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z14.string().trim().min(1).optional(),
-  info: z14.object({
+  iframeUrl: z15.string().trim().min(1).optional(),
+  info: z15.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z14.string().trim().min(1).optional()
+    iconUrl: z15.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z14.boolean().optional(),
-  isBuiltinReadonly: z14.boolean().optional()
+  isBuiltinPinned: z15.boolean().optional(),
+  isBuiltinReadonly: z15.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z14.object({
+var TenantWorkbenchPageEnvelopeSchema = z15.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -11517,66 +12457,77 @@ var TenantWorkbenchPageEnvelopeSchema = z14.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z14.object({
+var TenantWorkbenchPageGroupSchema = z15.object({
   id: ContractIdentifierSchema,
-  pageIds: z14.array(ContractIdentifierSchema),
+  pageIds: z15.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z14.boolean(),
-  iconUrl: z14.string().optional(),
-  sortIndex: z14.number().int().nullable().optional(),
+  isBuiltIn: z15.boolean(),
+  iconUrl: z15.string().optional(),
+  sortIndex: z15.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-var TenantWorkbenchConfigSchema = z14.object({
-  pages: z14.array(TenantWorkbenchPageEnvelopeSchema),
-  pageGroups: z14.array(TenantWorkbenchPageGroupSchema),
-  catalog: z14.object({ enabled: z14.boolean().optional(), defaultEntry: z14.boolean().optional() }).strict().optional(),
-  quickSwitcherMaxItems: z14.number().int().nonnegative().optional(),
-  defaultOrder: z14.object({
-    groups: z14.array(ContractIdentifierSchema),
-    pages: z14.record(ContractIdentifierSchema, z14.array(ContractIdentifierSchema))
+var TenantWorkbenchConfigSchema = z15.object({
+  pages: z15.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z15.array(TenantWorkbenchPageGroupSchema),
+  catalog: z15.object({
+    enabled: z15.boolean().optional(),
+    defaultEntry: z15.boolean().optional()
+  }).strict().optional(),
+  quickSwitcherMaxItems: z15.number().int().nonnegative().optional(),
+  defaultOrder: z15.object({
+    groups: z15.array(ContractIdentifierSchema),
+    pages: z15.record(ContractIdentifierSchema, z15.array(ContractIdentifierSchema))
   }).strict().optional(),
-  customers: z14.object({
-    dropdownToolsDefault: z14.array(ContractIdentifierSchema).optional(),
-    layoutManagerTools: z14.array(WorkbenchCustomerToolSchema).optional(),
-    studioTabsMode: z14.enum(["dropdown", "tabs"]).optional(),
-    historyWatermark: z14.object({
-      svgUrl: z14.string().optional(),
-      coverage: z14.array(z14.enum(["list", "detail", "download"])).optional(),
-      maxLongEdgeRatio: z14.number().positive().optional(),
-      sizing: z14.object({
+  customers: z15.object({
+    dropdownToolsDefault: z15.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z15.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z15.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z15.object({
+      svgUrl: z15.string().optional(),
+      coverage: z15.array(z15.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z15.number().positive().optional(),
+      sizing: z15.object({
         mode: ContractIdentifierSchema,
-        heightRatio: z14.number().positive().optional(),
-        minHeightPx: z14.number().nonnegative().optional(),
-        maxHeightPx: z14.number().nonnegative().optional()
+        heightRatio: z15.number().positive().optional(),
+        minHeightPx: z15.number().nonnegative().optional(),
+        maxHeightPx: z15.number().nonnegative().optional()
       }).strict().optional(),
-      enhance: z14.object({
-        enabled: z14.boolean().optional(),
-        backgroundLumaThreshold: z14.number().min(0).max(1).optional(),
-        stroke: z14.object({
-          color: z14.string().optional(),
-          opacity: z14.number().min(0).max(1).optional(),
-          widthRatio: z14.number().nonnegative().optional(),
-          blurRatio: z14.number().nonnegative().optional(),
-          steps: z14.number().int().positive().optional()
+      enhance: z15.object({
+        enabled: z15.boolean().optional(),
+        backgroundLumaThreshold: z15.number().min(0).max(1).optional(),
+        stroke: z15.object({
+          color: z15.string().optional(),
+          opacity: z15.number().min(0).max(1).optional(),
+          widthRatio: z15.number().nonnegative().optional(),
+          blurRatio: z15.number().nonnegative().optional(),
+          steps: z15.number().int().positive().optional()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z14.boolean().optional(),
-    existingToolsDefault: z14.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z14.number().int().min(1).max(6).optional(),
-    studioOverrides: z14.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z15.boolean().optional(),
+    existingToolsDefault: z15.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z15.number().int().min(1).max(6).optional(),
+    studioOverrides: z15.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
   const pageIdSet = new Set(pageIds);
   if (pageIdSet.size !== pageIds.length) {
-    context.addIssue({ code: "custom", path: ["pages"], message: "Tenant workbench page ids must be unique." });
+    context.addIssue({
+      code: "custom",
+      path: ["pages"],
+      message: "Tenant workbench page ids must be unique."
+    });
   }
   const groupIds = pageGroups.map(({ id }) => id);
   if (new Set(groupIds).size !== groupIds.length) {
-    context.addIssue({ code: "custom", path: ["pageGroups"], message: "Tenant workbench page group ids must be unique." });
+    context.addIssue({
+      code: "custom",
+      path: ["pageGroups"],
+      message: "Tenant workbench page group ids must be unique."
+    });
   }
   pageGroups.forEach((group, groupIndex) => {
     group.pageIds.forEach((pageId, pageIndex) => {
@@ -11590,38 +12541,41 @@ var TenantWorkbenchConfigSchema = z14.object({
     });
   });
 });
-var LoginPageSchema = z14.object({
-  background: z14.object({ imageUrl: z14.string().optional(), gradient: z14.string().optional() }).strict().optional(),
-  logo: z14.object({
-    url: z14.string().optional(),
-    lightUrl: z14.string().optional(),
-    darkUrl: z14.string().optional(),
-    position: z14.enum(["top", "middle", "bottom"]).optional(),
-    scale: z14.number().positive().optional()
+var LoginPageSchema = z15.object({
+  background: z15.object({
+    imageUrl: z15.string().optional(),
+    gradient: z15.string().optional()
   }).strict().optional(),
-  customCss: z14.string().optional()
+  logo: z15.object({
+    url: z15.string().optional(),
+    lightUrl: z15.string().optional(),
+    darkUrl: z15.string().optional(),
+    position: z15.enum(["top", "middle", "bottom"]).optional(),
+    scale: z15.number().positive().optional()
+  }).strict().optional(),
+  customCss: z15.string().optional()
 }).strict();
 var LandingPageHeadbarConfigShape = {
-  headbarMode: z14.enum(["shared", "hidden"]).optional()
+  headbarMode: z15.enum(["shared", "hidden"]).optional()
 };
-var LandingPageDefaultConfigSchema = z14.object({
-  mode: z14.literal("default"),
+var LandingPageDefaultConfigSchema = z15.object({
+  mode: z15.literal("default"),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageMarkdownConfigSchema = z14.object({
-  mode: z14.literal("markdown"),
-  content: z14.string(),
+var LandingPageMarkdownConfigSchema = z15.object({
+  mode: z15.literal("markdown"),
+  content: z15.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageHtmlConfigSchema = z14.object({
-  mode: z14.literal("html"),
-  content: z14.string(),
+var LandingPageHtmlConfigSchema = z15.object({
+  mode: z15.literal("html"),
+  content: z15.string(),
   ...LandingPageHeadbarConfigShape
 }).strict();
-var LandingPageIframeConfigSchema = z14.object({
-  mode: z14.literal("iframe"),
+var LandingPageIframeConfigSchema = z15.object({
+  mode: z15.literal("iframe"),
   ...LandingPageHeadbarConfigShape,
-  url: z14.string().refine((value) => {
+  url: z15.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -11633,13 +12587,13 @@ var LandingPageIframeConfigSchema = z14.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z14.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z15.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var ListFooterPageSizeOptionsSchema = z14.array(z14.number().int().positive().max(1e3)).min(1).max(10).superRefine((options, context) => {
+var ListFooterPageSizeOptionsSchema = z15.array(z15.number().int().positive().max(1e3)).min(1).max(10).superRefine((options, context) => {
   const seen = /* @__PURE__ */ new Set();
   options.forEach((option, index) => {
     if (seen.has(option)) {
@@ -11652,489 +12606,565 @@ var ListFooterPageSizeOptionsSchema = z14.array(z14.number().int().positive().ma
     seen.add(option);
   });
 });
-var TenantListFooterConfigSchema = z14.object({
-  showTotal: z14.boolean().optional(),
-  showPageSize: z14.boolean().optional(),
+var TenantListFooterConfigSchema = z15.object({
+  showTotal: z15.boolean().optional(),
+  showPageSize: z15.boolean().optional(),
   pageSizeOptions: ListFooterPageSizeOptionsSchema.optional(),
-  paginationMode: z14.enum(["auto", "pages", "compact"]).optional(),
-  alignment: z14.enum(["start", "end", "space-between"]).optional(),
-  density: z14.enum(["compact", "default", "comfortable"]).optional()
-}).strict();
-var TenantApplicationConfigSchema = z14.object({
-  theme: z14.object({
-    id: z14.string().optional(),
-    name: z14.string().optional(),
-    title: z14.string().optional(),
+  paginationMode: z15.enum(["auto", "pages", "compact"]).optional(),
+  alignment: z15.enum(["start", "end", "space-between"]).optional(),
+  density: z15.enum(["compact", "default", "comfortable"]).optional()
+}).strict();
+var TenantApplicationConfigSchema = z15.object({
+  theme: z15.object({
+    id: z15.string().optional(),
+    name: z15.string().optional(),
+    title: z15.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    pwaIcon: z14.string().optional(),
-    form: z14.object({ variant: z14.enum(["bento", "ghost"]) }).strict().optional(),
-    toast: z14.object({
-      position: z14.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    pwaIcon: z15.string().optional(),
+    form: z15.object({ variant: z15.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z15.object({
+      position: z15.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    }).strict().optional(),
+    icons: z15.object({
+      error: CustomIconSchema.optional(),
+      empty: CustomIconSchema.optional()
     }).strict().optional(),
-    icons: z14.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
-    views: z14.object({
-      form: z14.object({
-        toast: z14.object({ afterCreate: z14.boolean(), afterDelete: z14.boolean() }).strict(),
-        progress: z14.enum(["estimate", "infinite"]),
-        onlyResult: z14.boolean(),
-        tabular: z14.object({ theme: z14.enum(["default", "tentiary", "primary"]) }).strict()
+    views: z15.object({
+      form: z15.object({
+        toast: z15.object({
+          afterCreate: z15.boolean(),
+          afterDelete: z15.boolean()
+        }).strict(),
+        progress: z15.enum(["estimate", "infinite"]),
+        onlyResult: z15.boolean(),
+        tabular: z15.object({ theme: z15.enum(["default", "tentiary", "primary"]) }).strict()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.optional(),
-    extraLanguageURL: z14.record(z14.string(), z14.string()).optional(),
-    hideSpaceHeader: z14.boolean().optional(),
-    showSidebarTeamSelector: z14.boolean().optional(),
-    showWorkbenchSidebar: z14.boolean().optional(),
-    workbenchViewTheme: z14.enum(["default", "bsd-blue"]).optional(),
-    defaults: z14.object({
-      showFormInImageDetail: z14.boolean().optional(),
-      darkMode: z14.enum(["light", "dark", "auto"]).optional(),
-      language: z14.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
-      showDarkModeToggle: z14.boolean().optional(),
-      showLanguageToggle: z14.boolean().optional()
+    extraLanguageURL: z15.record(z15.string(), z15.string()).optional(),
+    hideSpaceHeader: z15.boolean().optional(),
+    showSidebarTeamSelector: z15.boolean().optional(),
+    showWorkbenchSidebar: z15.boolean().optional(),
+    workbenchViewTheme: z15.enum(["default", "bsd-blue"]).optional(),
+    defaults: z15.object({
+      showFormInImageDetail: z15.boolean().optional(),
+      darkMode: z15.enum(["light", "dark", "auto"]).optional(),
+      language: z15.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z15.boolean().optional(),
+      showLanguageToggle: z15.boolean().optional()
     }).strict().optional(),
-    modules: z14.object({
-      monkeysSpaceSidebar: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z14.union([
-        z14.literal("*"),
-        z14.array(TenantHeadbarModuleItemSchema)
-      ]).optional(),
-      settingsSidebar: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]).optional()
+    modules: z15.object({
+      monkeysSpaceSidebar: z15.union([z15.literal("*"), z15.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z15.union([z15.literal("*"), z15.array(TenantHeadbarModuleItemSchema)]).optional(),
+      settingsSidebar: z15.union([z15.literal("*"), z15.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z14.object({
-      navigationMode: z14.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z14.boolean().optional(),
+    kernelLayout: z15.object({
+      navigationMode: z15.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z15.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().optional(),
-    paginationPosition: z14.enum(["left", "right"]).optional(),
+    paginationPosition: z15.enum(["left", "right"]).optional(),
     listFooter: TenantListFooterConfigSchema.optional(),
-    ugcViewIconOnlyMode: z14.boolean().optional(),
-    workflowPreviewExecutionGrid: z14.object({
-      selectionModeDisplayType: z14.enum(["operation-button", "dropdown-menu"]).optional(),
-      clickBehavior: z14.enum(["preview", "select", "fill-form", "none"]).optional(),
-      showErrorFilter: z14.boolean().optional(),
-      displayType: z14.enum(["grid", "masonry"]).optional(),
-      showDetailButton: z14.boolean().optional(),
-      aspectRatio: z14.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional()
+    ugcViewIconOnlyMode: z15.boolean().optional(),
+    workflowPreviewExecutionGrid: z15.object({
+      selectionModeDisplayType: z15.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z15.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z15.boolean().optional(),
+      displayType: z15.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z15.boolean().optional(),
+      aspectRatio: z15.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional()
     }).strict().optional(),
-    workbenchSidebarDefaultOpen: z14.boolean().optional(),
-    workbenchSidebarMoreAction: z14.boolean().optional(),
-    workbenchSidebarApart: z14.boolean().optional(),
-    workbenchSidebarToggleGroupDetail: z14.boolean().optional(),
-    workbenchSidebarViewType: z14.boolean().optional(),
-    workbenchSidebarFormViewEmbed: z14.boolean().optional(),
-    workbenchSidebarModernMode: z14.boolean().optional(),
-    ugc: z14.object({ onItemClick: z14.boolean(), subtitle: z14.boolean().optional() }).strict().optional(),
-    uniImagePreview: z14.boolean().optional(),
-    imagePreviewStyle: z14.union([z14.literal(false), z14.enum(["simple", "normal", "uni"])]).optional(),
-    teamAsUser: z14.boolean().optional(),
-    themeMode: z14.enum(["shadow", "border"]).optional(),
-    density: z14.enum(["compact", "default", "comfortable"]).optional(),
-    statusStates: z14.object({
-      loading: z14.object({ variant: z14.enum(["spinner", "skeleton"]).optional() }).strict().optional(),
-      empty: z14.object({ variant: z14.enum(["default", "compact"]).optional() }).strict().optional(),
-      error: z14.object({ showRetry: z14.boolean().optional() }).strict().optional(),
-      permission: z14.object({ showRequestAccess: z14.boolean().optional() }).strict().optional(),
-      density: z14.enum(["compact", "default", "comfortable"]).optional()
+    workbenchSidebarDefaultOpen: z15.boolean().optional(),
+    workbenchSidebarMoreAction: z15.boolean().optional(),
+    workbenchSidebarApart: z15.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z15.boolean().optional(),
+    workbenchSidebarViewType: z15.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z15.boolean().optional(),
+    workbenchSidebarModernMode: z15.boolean().optional(),
+    ugc: z15.object({
+      onItemClick: z15.boolean(),
+      subtitle: z15.boolean().optional()
     }).strict().optional(),
-    pageZoom: z14.number().positive().optional(),
-    miniMode: z14.object({ showPreviewViewExecutionResultGrid: z14.boolean() }).strict().optional(),
-    workflow: z14.object({ allowConcurrentRuns: z14.boolean() }).strict().optional(),
-    historyResult: z14.object({ display: z14.boolean() }).strict().optional(),
-    uploader: z14.object({
-      orientation: z14.enum(["vertical", "horizontal"]),
-      pasteButton: z14.boolean(),
-      statusText: z14.boolean()
+    uniImagePreview: z15.boolean().optional(),
+    imagePreviewStyle: z15.union([z15.literal(false), z15.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z15.boolean().optional(),
+    themeMode: z15.enum(["shadow", "border"]).optional(),
+    density: z15.enum(["compact", "default", "comfortable"]).optional(),
+    statusStates: z15.object({
+      loading: z15.object({ variant: z15.enum(["spinner", "skeleton"]).optional() }).strict().optional(),
+      empty: z15.object({ variant: z15.enum(["default", "compact"]).optional() }).strict().optional(),
+      error: z15.object({ showRetry: z15.boolean().optional() }).strict().optional(),
+      permission: z15.object({ showRequestAccess: z15.boolean().optional() }).strict().optional(),
+      density: z15.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional(),
-    designProjects: z14.object({
-      oneOnOne: z14.boolean(),
-      newTabOpenBoard: z14.boolean(),
-      defaultShowGrid: z14.boolean().optional(),
-      createDefaultFrame: z14.boolean(),
-      showPageMenu: z14.boolean(),
-      showMainMenu: z14.boolean(),
-      showStylePanel: z14.boolean(),
-      showToolbar: z14.boolean(),
-      toolbarPosition: z14.enum(["bottom", "left"]).optional(),
-      showContextMenu: z14.boolean(),
-      showActionsMenu: z14.boolean(),
-      showPageAndLayerSidebar: z14.boolean().optional(),
-      showBoardOperationSidebar: z14.boolean().optional(),
-      showMiniToolsToolbar: z14.boolean().optional(),
-      showRightSidebar: z14.boolean().optional(),
-      showRealtimeDrawing: z14.boolean().optional(),
-      showWorkflow: z14.boolean().optional(),
-      showVersionManager: z14.boolean().optional(),
-      showAgent: z14.boolean().optional(),
-      AgentTools: z14.array(ContractIdentifierSchema).optional()
+    pageZoom: z15.number().positive().optional(),
+    miniMode: z15.object({ showPreviewViewExecutionResultGrid: z15.boolean() }).strict().optional(),
+    workflow: z15.object({ allowConcurrentRuns: z15.boolean() }).strict().optional(),
+    historyResult: z15.object({ display: z15.boolean() }).strict().optional(),
+    uploader: z15.object({
+      orientation: z15.enum(["vertical", "horizontal"]),
+      pasteButton: z15.boolean(),
+      statusText: z15.boolean()
+    }).strict().optional(),
+    designProjects: z15.object({
+      oneOnOne: z15.boolean(),
+      newTabOpenBoard: z15.boolean(),
+      defaultShowGrid: z15.boolean().optional(),
+      createDefaultFrame: z15.boolean(),
+      showPageMenu: z15.boolean(),
+      showMainMenu: z15.boolean(),
+      showStylePanel: z15.boolean(),
+      showToolbar: z15.boolean(),
+      toolbarPosition: z15.enum(["bottom", "left"]).optional(),
+      showContextMenu: z15.boolean(),
+      showActionsMenu: z15.boolean(),
+      showPageAndLayerSidebar: z15.boolean().optional(),
+      showBoardOperationSidebar: z15.boolean().optional(),
+      showMiniToolsToolbar: z15.boolean().optional(),
+      showRightSidebar: z15.boolean().optional(),
+      showRealtimeDrawing: z15.boolean().optional(),
+      showWorkflow: z15.boolean().optional(),
+      showVersionManager: z15.boolean().optional(),
+      showAgent: z15.boolean().optional(),
+      AgentTools: z15.array(ContractIdentifierSchema).optional()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z14.array(ContractIdentifierSchema).optional(),
-    initTeam: z14.boolean().optional(),
-    imageThumbnail: z14.boolean().optional(),
-    pages: z14.object({
-      allowPageKeys: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z15.array(ContractIdentifierSchema).optional(),
+    initTeam: z15.boolean().optional(),
+    imageThumbnail: z15.boolean().optional(),
+    pages: z15.object({
+      allowPageKeys: z15.union([z15.literal("*"), z15.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional(),
-      homeEntryEnabled: z14.boolean().optional()
+      homeEntryEnabled: z15.boolean().optional()
     }).strict().optional(),
     agent: TenantAgentThemeConfigSchema.optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.optional(),
-  auth: z14.object({
-    enabled: z14.array(ContractIdentifierSchema).default([]),
-    oidc: z14.object({ buttonText: z14.string().optional(), autoSignin: z14.boolean().optional() }).strict().optional(),
-    password: z14.object({
-      registrationEnabled: z14.boolean().optional(),
-      disableAutoRegister: z14.boolean().optional()
+  auth: z15.object({
+    enabled: z15.array(ContractIdentifierSchema).default([]),
+    oidc: z15.object({
+      buttonText: z15.string().optional(),
+      autoSignin: z15.boolean().optional()
+    }).strict().optional(),
+    password: z15.object({
+      registrationEnabled: z15.boolean().optional(),
+      disableAutoRegister: z15.boolean().optional()
     }).strict().optional(),
-    registrationApproval: z14.object({
-      enabled: z14.boolean().optional()
+    registrationApproval: z15.object({
+      enabled: z15.boolean().optional()
     }).strict().optional(),
-    hideAuthToast: z14.boolean().optional(),
-    autoReload: z14.boolean().optional(),
-    defaultOtherTeam: z14.boolean().optional()
+    hideAuthToast: z15.boolean().optional(),
+    autoReload: z15.boolean().optional(),
+    defaultOtherTeam: z15.boolean().optional()
   }).strict(),
-  endpoints: z14.record(ContractIdentifierSchema, z14.string()),
-  module: z14.union([z14.literal("*"), z14.array(ContractIdentifierSchema)]),
-  behavior: z14.object({
-    clearWorkflowFormStorageAfterUpdate: z14.boolean().optional(),
-    autoApproveOAuth: z14.boolean().optional(),
-    rememberWorkflowModelSelection: z14.boolean().optional()
+  endpoints: z15.record(ContractIdentifierSchema, z15.string()),
+  module: z15.union([z15.literal("*"), z15.array(ContractIdentifierSchema)]),
+  behavior: z15.object({
+    clearWorkflowFormStorageAfterUpdate: z15.boolean().optional(),
+    autoApproveOAuth: z15.boolean().optional(),
+    rememberWorkflowModelSelection: z15.boolean().optional()
   }).strict(),
-  dataManagement: z14.object({
-    favoriteOntologyId: z14.string().optional(),
-    pairedOntologyId: z14.string().optional(),
-    galleryOntologyIds: z14.array(ContractIdentifierSchema).max(20).optional(),
-    galleryOntologyId: z14.string().optional(),
-    dataBrowserDefaultOntologyId: z14.string().optional(),
-    workflowResultOntologyId: z14.string().optional(),
-    homeAdvertisement: z14.object({
+  dataManagement: z15.object({
+    favoriteOntologyId: z15.string().optional(),
+    pairedOntologyId: z15.string().optional(),
+    galleryOntologyIds: z15.array(ContractIdentifierSchema).max(20).optional(),
+    galleryOntologyId: z15.string().optional(),
+    dataBrowserDefaultOntologyId: z15.string().optional(),
+    workflowResultOntologyId: z15.string().optional(),
+    homeAdvertisement: z15.object({
+      ontologyId: ContractIdentifierSchema,
+      viewId: ContractIdentifierSchema.optional(),
+      viewType: z15.enum(["filter", "container", "share_link"]).optional(),
+      teamId: ContractIdentifierSchema.optional(),
+      teamOnly: z15.boolean().optional(),
+      pageSize: z15.number().int().positive().optional(),
+      sortBy: z15.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z15.enum(["asc", "desc"]).optional(),
+      fieldMap: z15.record(z15.string(), z15.string()).optional(),
+      columnIds: z15.record(z15.string(), z15.string()).optional()
+    }).strict().optional(),
+    homeShortcutBackground: z15.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z14.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z15.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
-      teamOnly: z14.boolean().optional(),
-      pageSize: z14.number().int().positive().optional(),
-      sortBy: z14.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
-      sortOrder: z14.enum(["asc", "desc"]).optional(),
-      fieldMap: z14.record(z14.string(), z14.string()).optional(),
-      columnIds: z14.record(z14.string(), z14.string()).optional()
+      teamOnly: z15.boolean().optional(),
+      pageSize: z15.number().int().positive().optional(),
+      sortBy: z15.enum(["pin_order", "asset_id", "updated_timestamp"]).optional(),
+      sortOrder: z15.enum(["asc", "desc"]).optional(),
+      fieldMap: z15.record(z15.string(), z15.string()).optional(),
+      columnIds: z15.record(z15.string(), z15.string()).optional()
     }).strict().optional(),
-    homeTrendAssistant: z14.object({
+    homeTrendAssistant: z15.object({
       ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z14.string().optional(),
+      viewName: z15.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.optional(),
-      tep: z14.object({ baseUrl: z14.string().optional(), timeoutMs: z14.number().int().positive().optional() }).strict().optional(),
-      runtime: z14.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z14.boolean(), tepAuthorizationConfigured: z14.boolean(), tepCookieConfigured: z14.boolean() }).strict().optional()
+      tep: z15.object({
+        baseUrl: z15.string().optional(),
+        timeoutMs: z15.number().int().positive().optional()
+      }).strict().optional(),
+      runtime: z15.object({
+        appId: ContractIdentifierSchema,
+        tepBaseUrlConfigured: z15.boolean(),
+        tepAuthorizationConfigured: z15.boolean(),
+        tepCookieConfigured: z15.boolean()
+      }).strict().optional()
     }).strict().optional(),
-    staticTrendReport: z14.object({
+    staticTrendReport: z15.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
       teamId: ContractIdentifierSchema.optional()
     }).strict().optional(),
     trendRadar: TenantTrendRadarSourcesSchema.optional(),
-    sharing: z14.object({
-      silentViewLinks: z14.object({ enabled: z14.boolean().optional(), placement: z14.object({ mode: z14.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
-      shareAccess: z14.object({ publicLinksEnabled: z14.boolean().optional(), passwordGateEnabled: z14.boolean().optional(), passwordAccessTtlSeconds: z14.number().int().positive().optional(), defaultViewTreeDelivery: z14.enum(["manual", "auto"]).optional() }).strict().optional(),
-      shareDialog: z14.object({
-        audience: z14.object({ enabled: z14.boolean().optional(), allowed: z14.array(z14.enum(["user", "team", "public"])).optional(), default: z14.enum(["user", "team", "public"]).optional() }).strict().optional(),
-        accessLevel: z14.object({ enabled: z14.boolean().optional(), allowed: z14.array(z14.enum(["read", "write"])).optional(), default: z14.enum(["read", "write"]).optional() }).strict().optional(),
-        viewTreeDelivery: z14.object({ enabled: z14.boolean().optional(), allowed: z14.array(z14.enum(["manual", "auto"])).optional(), default: z14.enum(["manual", "auto"]).optional() }).strict().optional()
+    sharing: z15.object({
+      silentViewLinks: z15.object({
+        enabled: z15.boolean().optional(),
+        placement: z15.object({
+          mode: z15.enum(["sourceOntology", "ontology"]).optional(),
+          ontologyId: ContractIdentifierSchema.optional(),
+          parentId: ContractIdentifierSchema.optional(),
+          navId: ContractIdentifierSchema.optional()
+        }).strict().optional()
+      }).strict().optional(),
+      shareAccess: z15.object({
+        publicLinksEnabled: z15.boolean().optional(),
+        passwordGateEnabled: z15.boolean().optional(),
+        passwordAccessTtlSeconds: z15.number().int().positive().optional(),
+        defaultViewTreeDelivery: z15.enum(["manual", "auto"]).optional()
+      }).strict().optional(),
+      shareDialog: z15.object({
+        audience: z15.object({
+          enabled: z15.boolean().optional(),
+          allowed: z15.array(z15.enum(["user", "team", "public"])).optional(),
+          default: z15.enum(["user", "team", "public"]).optional()
+        }).strict().optional(),
+        accessLevel: z15.object({
+          enabled: z15.boolean().optional(),
+          allowed: z15.array(z15.enum(["read", "write"])).optional(),
+          default: z15.enum(["read", "write"]).optional()
+        }).strict().optional(),
+        viewTreeDelivery: z15.object({
+          enabled: z15.boolean().optional(),
+          allowed: z15.array(z15.enum(["manual", "auto"])).optional(),
+          default: z15.enum(["manual", "auto"]).optional()
+        }).strict().optional()
       }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  kernelRuntime: z14.object({
-    integrations: z14.object({
-      harbor: z14.object({ endpoint: z14.string().optional(), projectScopes: z14.array(z14.string()).optional(), authMode: z14.string().optional(), principal: z14.string().optional(), autoSync: z14.boolean().optional(), proxyUrl: z14.string().optional() }).strict().optional(),
-      gitlab: z14.object({ baseUrl: z14.string().optional(), groupScopes: z14.array(z14.string()).optional(), tokenMode: z14.string().optional(), deployProjectPath: z14.string().optional(), deploymentReportsEnabled: z14.boolean().optional(), proxyUrl: z14.string().optional() }).strict().optional(),
-      kubernetes: z14.object({ accessMode: z14.string().optional(), clusterAlias: z14.string().optional(), agentProjectPath: z14.string().optional(), agentName: z14.string().optional(), namespaceScopes: z14.array(z14.string()).optional(), rolloutObserverEnabled: z14.boolean().optional(), proxyUrl: z14.string().optional() }).strict().optional()
+  kernelRuntime: z15.object({
+    integrations: z15.object({
+      harbor: z15.object({
+        endpoint: z15.string().optional(),
+        projectScopes: z15.array(z15.string()).optional(),
+        authMode: z15.string().optional(),
+        principal: z15.string().optional(),
+        autoSync: z15.boolean().optional(),
+        proxyUrl: z15.string().optional()
+      }).strict().optional(),
+      gitlab: z15.object({
+        baseUrl: z15.string().optional(),
+        groupScopes: z15.array(z15.string()).optional(),
+        tokenMode: z15.string().optional(),
+        deployProjectPath: z15.string().optional(),
+        deploymentReportsEnabled: z15.boolean().optional(),
+        proxyUrl: z15.string().optional()
+      }).strict().optional(),
+      kubernetes: z15.object({
+        accessMode: z15.string().optional(),
+        clusterAlias: z15.string().optional(),
+        agentProjectPath: z15.string().optional(),
+        agentName: z15.string().optional(),
+        namespaceScopes: z15.array(z15.string()).optional(),
+        rolloutObserverEnabled: z15.boolean().optional(),
+        proxyUrl: z15.string().optional()
+      }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  data: z14.object({}).strict().optional(),
-  storage: z14.object({
-    presignMode: z14.enum(["frontend", "backend", "both"]).optional(),
-    presign: z14.object({
-      expiresInSeconds: z14.number().int().positive(),
-      buckets: z14.array(
-        z14.object({
+  data: z15.object({}).strict().optional(),
+  storage: z15.object({
+    presignMode: z15.enum(["frontend", "backend", "both"]).optional(),
+    presign: z15.object({
+      expiresInSeconds: z15.number().int().positive(),
+      buckets: z15.array(
+        z15.object({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z14.array(
-            z14.object({
+          urlPatterns: z15.array(
+            z15.object({
               id: ContractIdentifierSchema,
-              type: z14.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z14.string().trim().min(1),
-              preferred: z14.boolean().optional(),
-              bucketSegment: z14.string().optional()
+              type: z15.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z15.string().trim().min(1),
+              preferred: z15.boolean().optional(),
+              bucketSegment: z15.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z14.object({ baseUrl: z14.string().optional() }).strict().optional()
+  monkeyData: z15.object({ baseUrl: z15.string().optional() }).strict().optional()
 }).strict();
-var TenantProductConfigSchema = z14.object({
-  contract: z14.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z15.object({
+  contract: z15.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z14.array(ContractIdentifierSchema).default([]),
-  pageRefs: z14.array(ContractIdentifierSchema).default([]),
-  featureFlags: z14.record(z14.string(), z14.boolean()).default({}),
+  moduleRefs: z15.array(ContractIdentifierSchema).default([]),
+  pageRefs: z15.array(ContractIdentifierSchema).default([]),
+  featureFlags: z15.record(z15.string(), z15.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z14.record(z14.string(), ContractIdentifierSchema),
-  warnings: z14.array(z14.string()).default([]),
+  sourceMap: z15.record(z15.string(), ContractIdentifierSchema),
+  warnings: z15.array(z15.string()).default([]),
   menus: MenuDefinitionSetSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
-var TenantRuntimeConfigSchema = z14.object({
-  contract: z14.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z15.object({
+  contract: z15.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z14.array(ContractIdentifierSchema).default([]),
-  pageRefs: z14.array(ContractIdentifierSchema).default([]),
-  featureFlags: z14.record(z14.string(), z14.boolean()).default({}),
+  moduleRefs: z15.array(ContractIdentifierSchema).default([]),
+  pageRefs: z15.array(ContractIdentifierSchema).default([]),
+  featureFlags: z15.record(z15.string(), z15.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z14.record(z14.string(), ContractIdentifierSchema),
-  warnings: z14.array(z14.string()).default([]),
+  sourceMap: z15.record(z15.string(), ContractIdentifierSchema),
+  warnings: z15.array(z15.string()).default([]),
   menuBundle: MenuRuntimeBundleSchema.optional(),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
 
 // src/contracts/trend.ts
-import { z as z15 } from "zod";
-var RadarDecisionMetricsSchema = z15.object({
-  currentSales: z15.number().finite(),
-  forecastSales: z15.number().finite(),
-  searchHeat: z15.number().finite(),
-  socialHeat: z15.number().finite(),
-  confidence: z15.number().min(0).max(1)
-}).strict();
-var TrendSourceSchema = z15.object({
+import { z as z16 } from "zod";
+var RadarDecisionMetricsSchema = z16.object({
+  currentSales: z16.number().finite(),
+  forecastSales: z16.number().finite(),
+  searchHeat: z16.number().finite(),
+  socialHeat: z16.number().finite(),
+  confidence: z16.number().min(0).max(1)
+}).strict();
+var TrendSourceSchema = z16.object({
   sourceId: ContractIdentifierSchema,
   provider: ContractIdentifierSchema,
-  channel: z15.enum(["trend", "ecommerce", "social", "search", "internal"]),
+  channel: z16.enum(["trend", "ecommerce", "social", "search", "internal"]),
   collectedAt: IsoDateTimeSchema,
-  sourceUrl: z15.string().url().optional(),
-  evidenceRefs: z15.array(EntityRefSchema).default([])
+  sourceUrl: z16.string().url().optional(),
+  evidenceRefs: z16.array(EntityRefSchema).default([])
 }).strict();
-var TrendIngestRunSchema = z15.object({
-  contract: z15.literal("TrendIngestRun"),
+var TrendIngestRunSchema = z16.object({
+  contract: z16.literal("TrendIngestRun"),
   ingestRunId: ContractIdentifierSchema,
   sourceId: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z15.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
-  recordCount: z15.number().int().nonnegative(),
-  errorCount: z15.number().int().nonnegative(),
+  status: z16.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
+  recordCount: z16.number().int().nonnegative(),
+  errorCount: z16.number().int().nonnegative(),
   startedAt: IsoDateTimeSchema,
   completedAt: IsoDateTimeSchema.optional()
 }).strict();
-var TrendSourceRecordSchema = z15.object({
-  contract: z15.literal("TrendSourceRecord"),
+var TrendSourceRecordSchema = z16.object({
+  contract: z16.literal("TrendSourceRecord"),
   sourceRecordId: ContractIdentifierSchema,
   source: TrendSourceSchema,
   ingestRunRef: EntityRefSchema,
-  recordVersion: z15.number().int().positive(),
+  recordVersion: z16.number().int().positive(),
   contentHash: Sha256Schema,
   payload: JsonValueSchema,
   idempotencyKey: ContractIdentifierSchema,
   collectedAt: IsoDateTimeSchema
 }).strict();
-var HotwordBodySchema = z15.object({
-  contract: z15.literal("HotwordBody"),
+var HotwordBodySchema = z16.object({
+  contract: z16.literal("HotwordBody"),
   hotwordId: ContractIdentifierSchema,
-  label: z15.string().trim().min(1),
-  normalizedLabel: z15.string().trim().min(1),
-  categories: z15.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z15.array(TrendSourceSchema).min(1),
-  relationRefs: z15.array(EntityRefSchema).default([]),
+  label: z16.string().trim().min(1),
+  normalizedLabel: z16.string().trim().min(1),
+  categories: z16.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z16.array(TrendSourceSchema).min(1),
+  relationRefs: z16.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 }).strict();
 var CommerceBodyFieldsSchema = {
-  displayName: z15.string().trim().min(1),
-  normalizedName: z15.string().trim().min(1),
-  categories: z15.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z15.array(EntityRefSchema).min(1),
-  relationRefs: z15.array(EntityRefSchema).default([]),
+  displayName: z16.string().trim().min(1),
+  normalizedName: z16.string().trim().min(1),
+  categories: z16.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z16.array(EntityRefSchema).min(1),
+  relationRefs: z16.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 };
-var BrandBodySchema = z15.object({
-  contract: z15.literal("BrandBody"),
+var BrandBodySchema = z16.object({
+  contract: z16.literal("BrandBody"),
   brandId: ContractIdentifierSchema,
   ...CommerceBodyFieldsSchema
 }).strict();
-var ProductBodySchema = z15.object({
-  contract: z15.literal("ProductBody"),
+var ProductBodySchema = z16.object({
+  contract: z16.literal("ProductBody"),
   productId: ContractIdentifierSchema,
   brandRef: EntityRefSchema.optional(),
   ...CommerceBodyFieldsSchema
 }).strict();
-var TrendMetricSnapshotSchema = z15.object({
-  contract: z15.literal("TrendMetricSnapshot"),
+var TrendMetricSnapshotSchema = z16.object({
+  contract: z16.literal("TrendMetricSnapshot"),
   snapshotId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   observedAt: IsoDateTimeSchema,
-  metrics: z15.record(z15.string(), z15.number().finite()),
-  confidence: z15.number().min(0).max(1),
-  evidenceRefs: z15.array(EntityRefSchema).min(1)
+  metrics: z16.record(z16.string(), z16.number().finite()),
+  confidence: z16.number().min(0).max(1),
+  evidenceRefs: z16.array(EntityRefSchema).min(1)
 }).strict();
-var RadarScoreModelBodySchema = z15.object({
-  contract: z15.literal("RadarScoreModelBody"),
+var RadarScoreModelBodySchema = z16.object({
+  contract: z16.literal("RadarScoreModelBody"),
   modelId: ContractIdentifierSchema,
-  version: z15.number().int().positive(),
+  version: z16.number().int().positive(),
   weights: RadarDecisionMetricsSchema,
-  thresholds: z15.record(z15.string(), z15.number().finite()).default({}),
-  explanationRules: z15.record(z15.string(), z15.string().trim().min(1)).default({}),
+  thresholds: z16.record(z16.string(), z16.number().finite()).default({}),
+  explanationRules: z16.record(z16.string(), z16.string().trim().min(1)).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarScoreProjectionSchema = z15.object({
-  contract: z15.literal("RadarScoreProjection"),
+var RadarScoreProjectionSchema = z16.object({
+  contract: z16.literal("RadarScoreProjection"),
   projectionId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   modelRef: EntityRefSchema,
-  totalScore: z15.number().finite(),
+  totalScore: z16.number().finite(),
   dimensions: RadarDecisionMetricsSchema,
-  evidenceRefs: z15.array(EntityRefSchema).min(1),
+  evidenceRefs: z16.array(EntityRefSchema).min(1),
   freshnessAt: IsoDateTimeSchema
 }).strict();
-var RadarPanoramaNodeSchema = z15.object({
+var RadarPanoramaNodeSchema = z16.object({
   ref: EntityRefSchema,
-  label: z15.string().trim().min(1),
-  categories: z15.array(ContractIdentifierSchema).default([]),
-  score: z15.number().finite().optional(),
+  label: z16.string().trim().min(1),
+  categories: z16.array(ContractIdentifierSchema).default([]),
+  score: z16.number().finite().optional(),
   freshnessAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarPanoramaEdgeSchema = z15.object({
+var RadarPanoramaEdgeSchema = z16.object({
   sourceRef: EntityRefSchema,
   targetRef: EntityRefSchema,
   relation: ContractIdentifierSchema,
-  evidenceRefs: z15.array(EntityRefSchema).default([])
+  evidenceRefs: z16.array(EntityRefSchema).default([])
 }).strict();
-var RadarPanoramaSchema = z15.object({
-  contract: z15.literal("RadarPanorama"),
-  nodes: z15.array(RadarPanoramaNodeSchema),
-  edges: z15.array(RadarPanoramaEdgeSchema),
+var RadarPanoramaSchema = z16.object({
+  contract: z16.literal("RadarPanorama"),
+  nodes: z16.array(RadarPanoramaNodeSchema),
+  edges: z16.array(RadarPanoramaEdgeSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
-var BrandGeneticsProfileSchema = z15.object({
-  contract: z15.literal("BrandGeneticsProfile"),
+var BrandGeneticsProfileSchema = z16.object({
+  contract: z16.literal("BrandGeneticsProfile"),
   brandRef: EntityRefSchema,
-  categories: z15.array(ContractIdentifierSchema).default([]),
-  signature: z15.record(ContractIdentifierSchema, z15.number().finite()),
-  relatedRefs: z15.array(EntityRefSchema).default([]),
-  evidenceRefs: z15.array(EntityRefSchema).default([]),
+  categories: z16.array(ContractIdentifierSchema).default([]),
+  signature: z16.record(ContractIdentifierSchema, z16.number().finite()),
+  relatedRefs: z16.array(EntityRefSchema).default([]),
+  evidenceRefs: z16.array(EntityRefSchema).default([]),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarOpportunityMatrixPointSchema = z15.object({
+var RadarOpportunityMatrixPointSchema = z16.object({
   subjectRef: EntityRefSchema,
-  label: z15.string().trim().min(1),
-  x: z15.number().finite(),
-  y: z15.number().finite(),
-  score: z15.number().finite(),
-  evidenceRefs: z15.array(EntityRefSchema).default([])
-}).strict();
-var RadarOpportunityMatrixSchema = z15.object({
-  contract: z15.literal("RadarOpportunityMatrix"),
-  xMetric: z15.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  yMetric: z15.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  points: z15.array(RadarOpportunityMatrixPointSchema),
+  label: z16.string().trim().min(1),
+  x: z16.number().finite(),
+  y: z16.number().finite(),
+  score: z16.number().finite(),
+  evidenceRefs: z16.array(EntityRefSchema).default([])
+}).strict();
+var RadarOpportunityMatrixSchema = z16.object({
+  contract: z16.literal("RadarOpportunityMatrix"),
+  xMetric: z16.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  yMetric: z16.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  points: z16.array(RadarOpportunityMatrixPointSchema),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarQueryBodySchema = z15.object({
-  contract: z15.literal("RadarQueryBody"),
+var RadarQueryBodySchema = z16.object({
+  contract: z16.literal("RadarQueryBody"),
   queryId: ContractIdentifierSchema,
-  filters: z15.record(z15.string(), JsonValueSchema).default({}),
-  sort: z15.object({
+  filters: z16.record(z16.string(), JsonValueSchema).default({}),
+  sort: z16.object({
     field: ContractIdentifierSchema,
-    direction: z15.enum(["asc", "desc"])
+    direction: z16.enum(["asc", "desc"])
   }).strict(),
-  pageSize: z15.number().int().min(1).max(200),
+  pageSize: z16.number().int().min(1).max(200),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var SavedRadarQuerySchema = z15.object({
-  contract: z15.literal("SavedRadarQuery"),
+var SavedRadarQuerySchema = z16.object({
+  contract: z16.literal("SavedRadarQuery"),
   savedQueryId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  name: z15.string().trim().min(1),
+  name: z16.string().trim().min(1),
   queryRef: EntityRefSchema,
-  expectedVersion: z15.number().int().nonnegative(),
+  expectedVersion: z16.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var RadarSelectionSchema = z15.object({
-  contract: z15.literal("RadarSelection"),
+var RadarSelectionSchema = z16.object({
+  contract: z16.literal("RadarSelection"),
   selectionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  subjectRefs: z15.array(EntityRefSchema),
-  status: z15.enum(["stashed", "selected", "rejected", "archived"]),
-  note: z15.string().optional(),
-  expectedVersion: z15.number().int().nonnegative(),
+  subjectRefs: z16.array(EntityRefSchema),
+  status: z16.enum(["stashed", "selected", "rejected", "archived"]),
+  note: z16.string().optional(),
+  expectedVersion: z16.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
 var versionedRefFields = {
   id: ContractIdentifierSchema,
-  version: z15.union([z15.number().int().positive(), z15.string().trim().min(1)]).optional(),
+  version: z16.union([z16.number().int().positive(), z16.string().trim().min(1)]).optional(),
   ownerRepo: ContractIdentifierSchema.optional()
 };
-var TrendRadarCollectionAssetRefSchema = z15.object({
-  kind: z15.literal("asset"),
+var TrendRadarCollectionAssetRefSchema = z16.object({
+  kind: z16.literal("asset"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionSelectionRefSchema = z15.object({
-  kind: z15.literal("radar-selection"),
+var TrendRadarCollectionSelectionRefSchema = z16.object({
+  kind: z16.literal("radar-selection"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionRunRefSchema = z15.object({
-  kind: z15.literal("radar-analysis-run"),
+var TrendRadarCollectionRunRefSchema = z16.object({
+  kind: z16.literal("radar-analysis-run"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionSubjectRefSchema = z15.object({
-  kind: z15.literal("hotword"),
+var TrendRadarCollectionSubjectRefSchema = z16.object({
+  kind: z16.literal("hotword"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionArtifactRefSchema = z15.object({
-  kind: z15.literal("artifact"),
+var TrendRadarCollectionArtifactRefSchema = z16.object({
+  kind: z16.literal("artifact"),
   ...versionedRefFields
 }).strict();
-var TrendRadarCollectionRecipeEntrySchema = z15.object({
+var TrendRadarCollectionRecipeEntrySchema = z16.object({
   subjectRef: TrendRadarCollectionSubjectRefSchema,
-  label: z15.string().trim().min(1).max(200)
+  label: z16.string().trim().min(1).max(200)
 }).strict();
-var TrendRadarCollectionRecipeSchema = z15.object({
-  category: z15.array(TrendRadarCollectionRecipeEntrySchema),
-  design: z15.array(TrendRadarCollectionRecipeEntrySchema),
-  audience: z15.array(TrendRadarCollectionRecipeEntrySchema)
+var TrendRadarCollectionRecipeSchema = z16.object({
+  category: z16.array(TrendRadarCollectionRecipeEntrySchema),
+  design: z16.array(TrendRadarCollectionRecipeEntrySchema),
+  audience: z16.array(TrendRadarCollectionRecipeEntrySchema)
 }).strict().refine(
   (recipe) => recipe.category.length + recipe.design.length + recipe.audience.length > 0,
   "A Trend Radar collection recipe must contain at least one subject."
 );
-var TrendRadarCollectionDecisionAxisSchema = z15.object({
+var TrendRadarCollectionDecisionAxisSchema = z16.object({
   key: ContractIdentifierSchema,
-  label: z15.string().trim().min(1).max(200).optional(),
-  value: z15.number().finite()
-}).strict();
-var TrendRadarCollectionDecisionProjectionSchema = z15.object({
-  axes: z15.array(TrendRadarCollectionDecisionAxisSchema).max(32).optional(),
-  overallScore: z15.number().finite().optional(),
-  itemRank: z15.number().finite().optional(),
-  sourceRefs: z15.array(EntityRefSchema).optional(),
-  outputRefs: z15.array(EntityRefSchema).optional()
+  label: z16.string().trim().min(1).max(200).optional(),
+  value: z16.number().finite()
+}).strict();
+var TrendRadarCollectionDecisionProjectionSchema = z16.object({
+  axes: z16.array(TrendRadarCollectionDecisionAxisSchema).max(32).optional(),
+  overallScore: z16.number().finite().optional(),
+  itemRank: z16.number().finite().optional(),
+  sourceRefs: z16.array(EntityRefSchema).optional(),
+  outputRefs: z16.array(EntityRefSchema).optional()
 }).strict().superRefine((projection, context) => {
   const hasProjection = Boolean(
     projection.axes?.length || projection.overallScore !== void 0 || projection.itemRank !== void 0 || projection.sourceRefs?.length || projection.outputRefs?.length
@@ -12157,20 +13187,20 @@ var TrendRadarCollectionDecisionProjectionSchema = z15.object({
     seenAxisKeys.add(axis.key);
   });
 });
-var TrendRadarCollectionArtifactProjectionSchema = z15.object({
+var TrendRadarCollectionArtifactProjectionSchema = z16.object({
   artifactRef: TrendRadarCollectionArtifactRefSchema,
-  url: z15.string().url().optional(),
-  thumbnailUrl: z15.string().url().optional(),
-  mimeType: z15.string().trim().min(1).optional(),
+  url: z16.string().url().optional(),
+  thumbnailUrl: z16.string().url().optional(),
+  mimeType: z16.string().trim().min(1).optional(),
   metadata: JsonObjectSchema.optional()
 }).strict();
-var TrendRadarCollectionProjectionWritebackSchema = z15.object({
-  status: z15.enum(["PENDING", "APPLIED", "FAILED"]),
+var TrendRadarCollectionProjectionWritebackSchema = z16.object({
+  status: z16.enum(["PENDING", "APPLIED", "FAILED"]),
   updatedAt: IsoDateTimeSchema,
-  error: z15.object({
+  error: z16.object({
     code: ContractIdentifierSchema,
-    message: z15.string().trim().min(1),
-    retryable: z15.boolean()
+    message: z16.string().trim().min(1),
+    retryable: z16.boolean()
   }).strict().optional()
 }).strict().superRefine((writeback, context) => {
   if (writeback.status === "FAILED" && !writeback.error) {
@@ -12188,12 +13218,12 @@ var TrendRadarCollectionProjectionWritebackSchema = z15.object({
     });
   }
 });
-var TrendRadarCollectionItemSchema = z15.object({
-  contract: z15.literal("TrendRadarCollectionItem"),
-  schemaVersion: z15.literal(1),
+var TrendRadarCollectionItemSchema = z16.object({
+  contract: z16.literal("TrendRadarCollectionItem"),
+  schemaVersion: z16.literal(1),
   selectionRef: TrendRadarCollectionSelectionRefSchema,
   recipe: TrendRadarCollectionRecipeSchema,
-  status: z15.enum(["SAVED", "QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  status: z16.enum(["SAVED", "QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
   latestRunRef: TrendRadarCollectionRunRefSchema.optional(),
   decisionProjection: TrendRadarCollectionDecisionProjectionSchema.optional(),
   artifactProjection: TrendRadarCollectionArtifactProjectionSchema.optional(),
@@ -12201,8 +13231,8 @@ var TrendRadarCollectionItemSchema = z15.object({
   updatedAt: IsoDateTimeSchema,
   generatedAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarAnalysisRunSchema = z15.object({
-  contract: z15.literal("RadarAnalysisRun"),
+var RadarAnalysisRunSchema = z16.object({
+  contract: z16.literal("RadarAnalysisRun"),
   runId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   selectionRef: EntityRefSchema,
@@ -12213,66 +13243,66 @@ var RadarAnalysisRunSchema = z15.object({
   collectionAssetRef: TrendRadarCollectionAssetRefSchema.optional(),
   collectionProjectionWriteback: TrendRadarCollectionProjectionWritebackSchema.optional(),
   workflowDefinitionTeamId: ContractIdentifierSchema.optional(),
-  workflowInput: z15.record(z15.string(), JsonValueSchema).default({}),
-  createDesignProject: z15.boolean().default(true),
-  designProjectName: z15.string().trim().min(1).max(200).optional(),
+  workflowInput: z16.record(z16.string(), JsonValueSchema).default({}),
+  createDesignProject: z16.boolean().default(true),
+  designProjectName: z16.string().trim().min(1).max(200).optional(),
   modelRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z15.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
-  outputRefs: z15.array(EntityRefSchema).default([]),
-  error: z15.object({
+  status: z16.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  outputRefs: z16.array(EntityRefSchema).default([]),
+  error: z16.object({
     code: ContractIdentifierSchema,
-    message: z15.string().trim().min(1),
-    retryable: z15.boolean()
+    message: z16.string().trim().min(1),
+    retryable: z16.boolean()
   }).strict().optional(),
   startedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisAssetSchema = z15.object({
+var RadarAnalysisAssetSchema = z16.object({
   artifactRef: EntityRefSchema,
   kind: ContractIdentifierSchema,
-  mimeType: z15.string().trim().min(1).optional(),
-  url: z15.string().url(),
-  metadata: z15.record(z15.string(), JsonValueSchema).default({}),
+  mimeType: z16.string().trim().min(1).optional(),
+  url: z16.string().url(),
+  metadata: z16.record(z16.string(), JsonValueSchema).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisDetailSchema = z15.object({
-  contract: z15.literal("RadarAnalysisDetail"),
+var RadarAnalysisDetailSchema = z16.object({
+  contract: z16.literal("RadarAnalysisDetail"),
   run: RadarAnalysisRunSchema,
-  runVersion: z15.number().int().positive(),
+  runVersion: z16.number().int().positive(),
   selection: RadarSelectionSchema,
-  outputs: z15.array(OutputRecordSchema),
-  assets: z15.array(RadarAnalysisAssetSchema),
-  lineage: z15.array(LineageRecordSchema)
+  outputs: z16.array(OutputRecordSchema),
+  assets: z16.array(RadarAnalysisAssetSchema),
+  lineage: z16.array(LineageRecordSchema)
 }).strict();
-var RadarActionRecordSchema = z15.object({
-  contract: z15.literal("RadarActionRecord"),
+var RadarActionRecordSchema = z16.object({
+  contract: z16.literal("RadarActionRecord"),
   actionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
-  action: z15.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
+  action: z16.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
   targetRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  expectedVersion: z15.number().int().nonnegative(),
+  expectedVersion: z16.number().int().nonnegative(),
   occurredAt: IsoDateTimeSchema
 }).strict();
-var RadarWritebackRecordSchema = z15.object({
-  contract: z15.literal("RadarWritebackRecord"),
+var RadarWritebackRecordSchema = z16.object({
+  contract: z16.literal("RadarWritebackRecord"),
   writebackId: ContractIdentifierSchema,
   actionRef: EntityRefSchema,
   targetRef: EntityRefSchema,
-  status: z15.enum(["PENDING", "APPLIED", "FAILED"]),
-  resultingVersion: z15.number().int().nonnegative().optional(),
-  error: z15.string().trim().min(1).optional(),
+  status: z16.enum(["PENDING", "APPLIED", "FAILED"]),
+  resultingVersion: z16.number().int().nonnegative().optional(),
+  error: z16.string().trim().min(1).optional(),
   recordedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/workflow-definition.ts
-import { z as z16 } from "zod";
-var ConductorTaskTypeSchema = z16.enum([
+import { z as z17 } from "zod";
+var ConductorTaskTypeSchema = z17.enum([
   "SIMPLE",
   "DYNAMIC",
   "FORK_JOIN",
@@ -12321,46 +13351,46 @@ var requiredTaskFields = {
   WAIT: ["inputParameters"],
   TERMINATE: ["inputParameters"]
 };
-var ConductorTaskDefinitionSchema = z16.lazy(
-  () => z16.object({
+var ConductorTaskDefinitionSchema = z17.lazy(
+  () => z17.object({
     name: ContractIdentifierSchema,
     taskReferenceName: ContractIdentifierSchema,
     type: ConductorTaskTypeSchema,
-    inputParameters: z16.record(z16.string(), JsonValueSchema).optional(),
-    startDelay: z16.number().int().nonnegative().optional(),
-    optional: z16.boolean().optional(),
-    asyncComplete: z16.boolean().optional(),
-    rateLimited: z16.boolean().optional(),
-    retryCount: z16.number().int().nonnegative().optional(),
-    taskDefinition: z16.record(z16.string(), JsonValueSchema).optional(),
-    loopCondition: z16.string().optional(),
-    loopOver: z16.array(ConductorTaskDefinitionSchema).optional(),
-    sink: z16.string().optional(),
-    forkTasks: z16.array(z16.array(ConductorTaskDefinitionSchema)).optional(),
-    joinOn: z16.array(ContractIdentifierSchema).optional(),
-    defaultExclusiveJoinTask: z16.array(ContractIdentifierSchema).optional(),
-    dynamicForkTasksParam: z16.string().optional(),
-    dynamicForkTasksInputParamName: z16.string().optional(),
-    subWorkflowParam: z16.object({
-      $ref: z16.string().optional(),
+    inputParameters: z17.record(z17.string(), JsonValueSchema).optional(),
+    startDelay: z17.number().int().nonnegative().optional(),
+    optional: z17.boolean().optional(),
+    asyncComplete: z17.boolean().optional(),
+    rateLimited: z17.boolean().optional(),
+    retryCount: z17.number().int().nonnegative().optional(),
+    taskDefinition: z17.record(z17.string(), JsonValueSchema).optional(),
+    loopCondition: z17.string().optional(),
+    loopOver: z17.array(ConductorTaskDefinitionSchema).optional(),
+    sink: z17.string().optional(),
+    forkTasks: z17.array(z17.array(ConductorTaskDefinitionSchema)).optional(),
+    joinOn: z17.array(ContractIdentifierSchema).optional(),
+    defaultExclusiveJoinTask: z17.array(ContractIdentifierSchema).optional(),
+    dynamicForkTasksParam: z17.string().optional(),
+    dynamicForkTasksInputParamName: z17.string().optional(),
+    subWorkflowParam: z17.object({
+      $ref: z17.string().optional(),
       name: ContractIdentifierSchema,
-      version: z16.number().int().positive().optional(),
-      taskToDomain: z16.record(z16.string(), z16.string()).optional(),
-      workflowDefinition: z16.record(z16.string(), JsonValueSchema).optional()
+      version: z17.number().int().positive().optional(),
+      taskToDomain: z17.record(z17.string(), z17.string()).optional(),
+      workflowDefinition: z17.record(z17.string(), JsonValueSchema).optional()
     }).strict().optional(),
-    decisionCases: z16.record(z16.string(), z16.array(ConductorTaskDefinitionSchema)).optional(),
-    defaultCase: z16.array(ConductorTaskDefinitionSchema).optional(),
-    evaluatorType: z16.enum(["value-param", "javascript", "graaljs"]).optional(),
-    expression: z16.string().optional(),
+    decisionCases: z17.record(z17.string(), z17.array(ConductorTaskDefinitionSchema)).optional(),
+    defaultCase: z17.array(ConductorTaskDefinitionSchema).optional(),
+    evaluatorType: z17.enum(["value-param", "javascript", "graaljs"]).optional(),
+    expression: z17.string().optional(),
     __alias: JsonValueSchema.optional(),
-    callbackFromWorker: z16.boolean().optional(),
+    callbackFromWorker: z17.boolean().optional(),
     caseExpression: JsonValueSchema.optional(),
-    caseValueParam: z16.string().optional(),
-    dependencies: z16.array(JsonValueSchema).optional(),
-    description: z16.string().optional(),
-    dynamicTaskNameParam: z16.string().optional(),
-    joinMode: z16.string().optional(),
-    permissive: z16.boolean().optional(),
+    caseValueParam: z17.string().optional(),
+    dependencies: z17.array(JsonValueSchema).optional(),
+    description: z17.string().optional(),
+    dynamicTaskNameParam: z17.string().optional(),
+    joinMode: z17.string().optional(),
+    permissive: z17.boolean().optional(),
     joinTaskRef: ContractIdentifierSchema.optional(),
     forkTaskRef: ContractIdentifierSchema.optional()
   }).strict().superRefine((task, context) => {
@@ -12374,29 +13404,29 @@ var ConductorTaskDefinitionSchema = z16.lazy(
     }
   })
 );
-var ConductorWorkflowDefinitionSchema = z16.object({
-  ownerApp: z16.string().optional(),
-  createTime: z16.number().int().nonnegative().optional(),
-  updateTime: z16.number().int().nonnegative().optional(),
-  createdBy: z16.string().optional(),
-  updatedBy: z16.string().optional(),
+var ConductorWorkflowDefinitionSchema = z17.object({
+  ownerApp: z17.string().optional(),
+  createTime: z17.number().int().nonnegative().optional(),
+  updateTime: z17.number().int().nonnegative().optional(),
+  createdBy: z17.string().optional(),
+  updatedBy: z17.string().optional(),
   name: ContractIdentifierSchema,
-  description: z16.string().optional(),
-  version: z16.number().int().positive(),
-  tasks: z16.array(ConductorTaskDefinitionSchema),
-  inputParameters: z16.array(ContractIdentifierSchema),
-  outputParameters: z16.record(z16.string(), JsonValueSchema).optional(),
+  description: z17.string().optional(),
+  version: z17.number().int().positive(),
+  tasks: z17.array(ConductorTaskDefinitionSchema),
+  inputParameters: z17.array(ContractIdentifierSchema),
+  outputParameters: z17.record(z17.string(), JsonValueSchema).optional(),
   failureWorkflow: ContractIdentifierSchema.optional(),
-  schemaVersion: z16.number().int().positive().optional(),
-  restartable: z16.boolean().optional(),
-  workflowStatusListenerEnabled: z16.boolean().optional(),
-  ownerEmail: z16.string().email().optional(),
-  timeoutPolicy: z16.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-  timeoutSeconds: z16.number().int().nonnegative(),
-  variables: z16.record(z16.string(), JsonValueSchema).optional(),
-  inputTemplate: z16.record(z16.string(), JsonValueSchema).optional()
-}).strict();
-var WorkflowParameterTypeSchema = z16.enum([
+  schemaVersion: z17.number().int().positive().optional(),
+  restartable: z17.boolean().optional(),
+  workflowStatusListenerEnabled: z17.boolean().optional(),
+  ownerEmail: z17.string().email().optional(),
+  timeoutPolicy: z17.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+  timeoutSeconds: z17.number().int().nonnegative(),
+  variables: z17.record(z17.string(), JsonValueSchema).optional(),
+  inputTemplate: z17.record(z17.string(), JsonValueSchema).optional()
+}).strict();
+var WorkflowParameterTypeSchema = z17.enum([
   "string",
   "file",
   "number",
@@ -12406,213 +13436,213 @@ var WorkflowParameterTypeSchema = z16.enum([
   "notice",
   "canvas-assist"
 ]);
-var WorkflowConditionalStateSchema = z16.object({
-  conditions: z16.array(
-    z16.object({
-      field: z16.string(),
-      operator: z16.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
+var WorkflowConditionalStateSchema = z17.object({
+  conditions: z17.array(
+    z17.object({
+      field: z17.string(),
+      operator: z17.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
       value: JsonValueSchema
     }).strict()
   ),
-  logic: z16.enum(["AND", "OR"]).optional()
-}).strict();
-var ImageSelectMappingAppearanceSchema = z16.object({
-  columns: z16.number().int().min(1).max(4).optional(),
-  cardSize: z16.enum(["sm", "md", "lg"]).optional(),
-  imageAspectRatio: z16.enum(["square", "4:5", "3:4", "16:9"]).optional(),
-  gap: z16.enum(["sm", "md", "lg"]).optional(),
-  radius: z16.enum(["sm", "md", "lg", "xl"]).optional(),
-  borderStyle: z16.enum(["none", "soft", "strong"]).optional(),
-  borderWidth: z16.union([z16.literal(0), z16.literal(1), z16.literal(2)]).optional(),
-  enableScroll: z16.boolean().optional(),
-  maxHeight: z16.number().int().min(160).max(1200).optional(),
-  enableCollapse: z16.boolean().optional(),
-  visibleRows: z16.number().int().min(1).max(6).optional(),
-  hideLabel: z16.boolean().optional(),
-  hideDescription: z16.boolean().optional(),
-  hideValue: z16.boolean().optional()
-}).strict();
-var ComfyWorkflowPortBindingSchema = z16.object({
-  node: z16.union([z16.string(), z16.number()]),
-  key: z16.string().optional()
-}).strict();
-var WorkflowParameterTypeOptionsSchema = z16.object({
-  editor: z16.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
-  editorLanguage: z16.enum(["javaScript", "json", "python", "sql"]).optional(),
-  maxValue: z16.number().optional(),
-  minValue: z16.number().optional(),
-  max: z16.number().optional(),
-  min: z16.number().optional(),
-  multipleValues: z16.boolean().optional(),
-  numberPrecision: z16.number().nonnegative().optional(),
-  password: z16.boolean().optional(),
-  rows: z16.number().int().positive().optional(),
-  assetType: z16.string().optional(),
-  accept: z16.string().optional(),
-  maxSize: z16.number().positive().optional(),
-  fileType: z16.string().optional(),
-  aiMultiShotMainImageField: z16.string().optional(),
-  aiMultiShotWorkflowAppId: z16.string().optional(),
-  aiMultiShotWorkflowId: z16.string().optional(),
-  allowCustomInput: z16.boolean().optional(),
-  allowUploadVideo: z16.boolean().optional(),
-  aspectRatioField: z16.string().optional(),
-  assemblyValueType: z16.string().optional(),
-  autoAnalyzeDesignImage: z16.boolean().optional(),
-  autoDetectAspectRatio: z16.boolean().optional(),
-  autoIncrementId: z16.boolean().optional(),
+  logic: z17.enum(["AND", "OR"]).optional()
+}).strict();
+var ImageSelectMappingAppearanceSchema = z17.object({
+  columns: z17.number().int().min(1).max(4).optional(),
+  cardSize: z17.enum(["sm", "md", "lg"]).optional(),
+  imageAspectRatio: z17.enum(["square", "4:5", "3:4", "16:9"]).optional(),
+  gap: z17.enum(["sm", "md", "lg"]).optional(),
+  radius: z17.enum(["sm", "md", "lg", "xl"]).optional(),
+  borderStyle: z17.enum(["none", "soft", "strong"]).optional(),
+  borderWidth: z17.union([z17.literal(0), z17.literal(1), z17.literal(2)]).optional(),
+  enableScroll: z17.boolean().optional(),
+  maxHeight: z17.number().int().min(160).max(1200).optional(),
+  enableCollapse: z17.boolean().optional(),
+  visibleRows: z17.number().int().min(1).max(6).optional(),
+  hideLabel: z17.boolean().optional(),
+  hideDescription: z17.boolean().optional(),
+  hideValue: z17.boolean().optional()
+}).strict();
+var ComfyWorkflowPortBindingSchema = z17.object({
+  node: z17.union([z17.string(), z17.number()]),
+  key: z17.string().optional()
+}).strict();
+var WorkflowParameterTypeOptionsSchema = z17.object({
+  editor: z17.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
+  editorLanguage: z17.enum(["javaScript", "json", "python", "sql"]).optional(),
+  maxValue: z17.number().optional(),
+  minValue: z17.number().optional(),
+  max: z17.number().optional(),
+  min: z17.number().optional(),
+  multipleValues: z17.boolean().optional(),
+  numberPrecision: z17.number().nonnegative().optional(),
+  password: z17.boolean().optional(),
+  rows: z17.number().int().positive().optional(),
+  assetType: z17.string().optional(),
+  accept: z17.string().optional(),
+  maxSize: z17.number().positive().optional(),
+  fileType: z17.string().optional(),
+  aiMultiShotMainImageField: z17.string().optional(),
+  aiMultiShotWorkflowAppId: z17.string().optional(),
+  aiMultiShotWorkflowId: z17.string().optional(),
+  allowCustomInput: z17.boolean().optional(),
+  allowUploadVideo: z17.boolean().optional(),
+  aspectRatioField: z17.string().optional(),
+  assemblyValueType: z17.string().optional(),
+  autoAnalyzeDesignImage: z17.boolean().optional(),
+  autoDetectAspectRatio: z17.boolean().optional(),
+  autoIncrementId: z17.boolean().optional(),
   comfyOptions: ComfyWorkflowPortBindingSchema.optional(),
-  comfyuiModelServerId: z16.string().optional(),
-  comfyuiModelTypeName: z16.string().optional(),
+  comfyuiModelServerId: z17.string().optional(),
+  comfyuiModelTypeName: z17.string().optional(),
   defaultCustomInput: JsonValueSchema.optional(),
-  descriptionAlert: z16.boolean().optional(),
-  disabled: z16.union([z16.boolean(), WorkflowConditionalStateSchema]).optional(),
-  editable: z16.union([z16.boolean(), WorkflowConditionalStateSchema]).optional(),
-  enableAiMultiShot: z16.boolean().optional(),
-  enableBooleanSwitchMode: z16.boolean().optional(),
-  enableClear: z16.boolean().optional(),
-  enableExpand: z16.boolean().optional(),
-  enableImageMask: z16.boolean().optional(),
-  enableImageOverlay: z16.boolean().optional(),
-  enablePopupEditor: z16.boolean().optional(),
-  enablePromptFontSize: z16.boolean().optional(),
-  enableReset: z16.boolean().optional(),
-  enableSelectItemIcon: z16.boolean().optional(),
-  enableSelectList: z16.boolean().optional(),
-  enableSelectSearch: z16.boolean().optional(),
-  enableSliderEnterMode: z16.boolean().optional(),
-  enableVoice: z16.boolean().optional(),
-  expandButtonText: z16.string().optional(),
-  foldUp: z16.boolean().optional(),
-  hidden: z16.boolean().optional(),
-  hideRequiredDot: z16.boolean().optional(),
-  inlineTitleWithSelect: z16.boolean().optional(),
-  knowledgeGraphButtonText: z16.string().optional(),
-  identifyAttributeCount: z16.union([z16.number().nonnegative(), z16.string().min(1), z16.object({ min: z16.number().nonnegative().optional(), max: z16.number().nonnegative().optional() }).strict()]).optional(),
-  identifyAttributes: z16.array(JsonValueSchema).optional(),
-  identifyMaxVariants: z16.number().int().nonnegative().optional(),
-  identifySourceField: z16.string().optional(),
-  imageOverlayBaseField: z16.string().optional(),
-  imageOverlayOverlayField: z16.string().optional(),
+  descriptionAlert: z17.boolean().optional(),
+  disabled: z17.union([z17.boolean(), WorkflowConditionalStateSchema]).optional(),
+  editable: z17.union([z17.boolean(), WorkflowConditionalStateSchema]).optional(),
+  enableAiMultiShot: z17.boolean().optional(),
+  enableBooleanSwitchMode: z17.boolean().optional(),
+  enableClear: z17.boolean().optional(),
+  enableExpand: z17.boolean().optional(),
+  enableImageMask: z17.boolean().optional(),
+  enableImageOverlay: z17.boolean().optional(),
+  enablePopupEditor: z17.boolean().optional(),
+  enablePromptFontSize: z17.boolean().optional(),
+  enableReset: z17.boolean().optional(),
+  enableSelectItemIcon: z17.boolean().optional(),
+  enableSelectList: z17.boolean().optional(),
+  enableSelectSearch: z17.boolean().optional(),
+  enableSliderEnterMode: z17.boolean().optional(),
+  enableVoice: z17.boolean().optional(),
+  expandButtonText: z17.string().optional(),
+  foldUp: z17.boolean().optional(),
+  hidden: z17.boolean().optional(),
+  hideRequiredDot: z17.boolean().optional(),
+  inlineTitleWithSelect: z17.boolean().optional(),
+  knowledgeGraphButtonText: z17.string().optional(),
+  identifyAttributeCount: z17.union([z17.number().nonnegative(), z17.string().min(1), z17.object({ min: z17.number().nonnegative().optional(), max: z17.number().nonnegative().optional() }).strict()]).optional(),
+  identifyAttributes: z17.array(JsonValueSchema).optional(),
+  identifyMaxVariants: z17.number().int().nonnegative().optional(),
+  identifySourceField: z17.string().optional(),
+  imageOverlayBaseField: z17.string().optional(),
+  imageOverlayOverlayField: z17.string().optional(),
   imageSelectMappingAppearance: ImageSelectMappingAppearanceSchema.optional(),
-  imageSelectMappingColumns: z16.number().int().min(1).max(4).optional(),
-  imageSelectMappingEnableCustomUpload: z16.boolean().optional(),
-  imageSelectMappingHideLabel: z16.boolean().optional(),
-  imageSelectMappingHideLink: z16.boolean().optional(),
-  imageSelectMappingHideMeta: z16.boolean().optional(),
-  imageSelectMappingInlineUseLargeUploadBox: z16.boolean().optional(),
-  imageSelectMappingPromptField: z16.string().optional(),
-  imageSelectMappingTabOrder: z16.enum(["template-first", "upload-first"]).optional(),
-  imageSelectMappingTabWidthMode: z16.enum(["content", "fill"]).optional(),
+  imageSelectMappingColumns: z17.number().int().min(1).max(4).optional(),
+  imageSelectMappingEnableCustomUpload: z17.boolean().optional(),
+  imageSelectMappingHideLabel: z17.boolean().optional(),
+  imageSelectMappingHideLink: z17.boolean().optional(),
+  imageSelectMappingHideMeta: z17.boolean().optional(),
+  imageSelectMappingInlineUseLargeUploadBox: z17.boolean().optional(),
+  imageSelectMappingPromptField: z17.string().optional(),
+  imageSelectMappingTabOrder: z17.enum(["template-first", "upload-first"]).optional(),
+  imageSelectMappingTabWidthMode: z17.enum(["content", "fill"]).optional(),
   imageSelectMappingTemplatePrompt: LocalizedTextSchema.optional(),
   imageSelectMappingTemplateTabTitle: LocalizedTextSchema.optional(),
-  imageSelectMappingUploadMode: z16.enum(["tabs", "inline"]).optional(),
+  imageSelectMappingUploadMode: z17.enum(["tabs", "inline"]).optional(),
   imageSelectMappingUploadPrompt: LocalizedTextSchema.optional(),
   imageSelectMappingUploadTabTitle: LocalizedTextSchema.optional(),
-  endpoints: z16.array(JsonValueSchema).optional(),
-  examples: z16.array(JsonValueSchema).optional(),
+  endpoints: z17.array(JsonValueSchema).optional(),
+  examples: z17.array(JsonValueSchema).optional(),
   extraData: JsonValueSchema.optional(),
   layer: JsonValueSchema.optional(),
   map: JsonValueSchema.optional(),
-  multiline: z16.boolean().optional(),
-  options: z16.array(JsonValueSchema).optional(),
-  originalFiles: z16.array(JsonValueSchema).optional(),
+  multiline: z17.boolean().optional(),
+  options: z17.array(JsonValueSchema).optional(),
+  originalFiles: z17.array(JsonValueSchema).optional(),
   placeholder: LocalizedTextSchema.optional(),
-  preserveSelectListOrder: z16.boolean().optional(),
+  preserveSelectListOrder: z17.boolean().optional(),
   promptDictionary: JsonValueSchema.optional(),
-  promptFontSize: z16.number().optional(),
+  promptFontSize: z17.number().optional(),
   promptModeToggle: JsonValueSchema.optional(),
-  requireActiveSelectFilter: z16.boolean().optional(),
-  restoreDefaultOnEmptyEnter: z16.boolean().optional(),
-  search: z16.boolean().optional(),
-  selectButtonEnableCollapse: z16.boolean().optional(),
-  selectButtonVisibleRows: z16.number().int().positive().optional(),
-  selectList: z16.array(JsonValueSchema).optional(),
-  selectListDisplayMode: z16.string().optional(),
-  selectPromptField: z16.string().optional(),
-  showAddLocalFileButton: z16.boolean().optional(),
-  singleColumn: z16.boolean().optional(),
-  singleFrameForMultiple: z16.boolean().optional(),
-  textSingleLine: z16.boolean().optional(),
-  textareaMiniHeight: z16.number().nonnegative().optional(),
+  requireActiveSelectFilter: z17.boolean().optional(),
+  restoreDefaultOnEmptyEnter: z17.boolean().optional(),
+  search: z17.boolean().optional(),
+  selectButtonEnableCollapse: z17.boolean().optional(),
+  selectButtonVisibleRows: z17.number().int().positive().optional(),
+  selectList: z17.array(JsonValueSchema).optional(),
+  selectListDisplayMode: z17.string().optional(),
+  selectPromptField: z17.string().optional(),
+  showAddLocalFileButton: z17.boolean().optional(),
+  singleColumn: z17.boolean().optional(),
+  singleFrameForMultiple: z17.boolean().optional(),
+  textSingleLine: z17.boolean().optional(),
+  textareaMiniHeight: z17.number().nonnegative().optional(),
   tips: LocalizedTextSchema.optional(),
   visibility: JsonValueSchema.optional(),
-  voiceButtonText: z16.string().optional(),
-  designAnalysisFields: z16.array(JsonValueSchema).optional(),
-  designAnalysisFillStrategy: z16.string().optional(),
-  designAnalysisMaxFields: z16.number().int().nonnegative().optional(),
-  designAnalysisType: z16.string().optional(),
-  designAnalysisFieldPrefix: z16.string().optional()
-}).strict();
-var WorkflowParameterSchema = z16.lazy(
-  () => z16.object({
+  voiceButtonText: z17.string().optional(),
+  designAnalysisFields: z17.array(JsonValueSchema).optional(),
+  designAnalysisFillStrategy: z17.string().optional(),
+  designAnalysisMaxFields: z17.number().int().nonnegative().optional(),
+  designAnalysisType: z17.string().optional(),
+  designAnalysisFieldPrefix: z17.string().optional()
+}).strict();
+var WorkflowParameterSchema = z17.lazy(
+  () => z17.object({
     displayName: LocalizedTextSchema,
     name: ContractIdentifierSchema,
     type: WorkflowParameterTypeSchema,
     typeOptions: WorkflowParameterTypeOptionsSchema.optional(),
     default: JsonValueSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    hint: z16.string().optional(),
-    displayOptions: z16.object({
-      hide: z16.record(z16.string(), z16.array(JsonValueSchema)).optional(),
-      show: z16.record(z16.string(), z16.array(JsonValueSchema)).optional()
+    hint: z17.string().optional(),
+    displayOptions: z17.object({
+      hide: z17.record(z17.string(), z17.array(JsonValueSchema)).optional(),
+      show: z17.record(z17.string(), z17.array(JsonValueSchema)).optional()
     }).strict().optional(),
-    options: z16.array(z16.union([
-      z16.object({ name: LocalizedTextSchema, value: z16.union([z16.string(), z16.number(), z16.boolean()]), action: z16.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
+    options: z17.array(z17.union([
+      z17.object({ name: LocalizedTextSchema, value: z17.union([z17.string(), z17.number(), z17.boolean()]), action: z17.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
       WorkflowParameterSchema,
-      z16.object({ displayName: z16.string(), name: ContractIdentifierSchema, values: z16.array(WorkflowParameterSchema) }).strict()
+      z17.object({ displayName: z17.string(), name: ContractIdentifierSchema, values: z17.array(WorkflowParameterSchema) }).strict()
     ])).optional(),
     placeholder: LocalizedTextSchema.optional(),
-    isNodeSetting: z16.boolean().optional(),
-    noDataExpression: z16.boolean().optional(),
-    required: z16.boolean().optional(),
-    example: z16.string().optional(),
-    extractValue: z16.object({ type: z16.literal("regex"), regex: z16.string() }).strict().optional(),
-    properties: z16.array(WorkflowParameterSchema).optional(),
-    assetType: z16.string().optional(),
-    flag: z16.boolean().optional(),
-    enableExpand: z16.boolean().optional(),
-    enableVoice: z16.boolean().optional(),
-    expandButtonText: z16.string().optional(),
-    knowledgeGraphButtonText: z16.string().optional(),
-    selectListDisplayMode: z16.string().optional(),
-    voiceButtonText: z16.string().optional()
+    isNodeSetting: z17.boolean().optional(),
+    noDataExpression: z17.boolean().optional(),
+    required: z17.boolean().optional(),
+    example: z17.string().optional(),
+    extractValue: z17.object({ type: z17.literal("regex"), regex: z17.string() }).strict().optional(),
+    properties: z17.array(WorkflowParameterSchema).optional(),
+    assetType: z17.string().optional(),
+    flag: z17.boolean().optional(),
+    enableExpand: z17.boolean().optional(),
+    enableVoice: z17.boolean().optional(),
+    expandButtonText: z17.string().optional(),
+    knowledgeGraphButtonText: z17.string().optional(),
+    selectListDisplayMode: z17.string().optional(),
+    voiceButtonText: z17.string().optional()
   }).strict()
 );
-var WorkflowOutputBindingSchema = z16.object({ key: ContractIdentifierSchema, value: z16.string() }).strict();
-var WorkflowNodeSchema = z16.object({
+var WorkflowOutputBindingSchema = z17.object({ key: ContractIdentifierSchema, value: z17.string() }).strict();
+var WorkflowNodeSchema = z17.object({
   id: ContractIdentifierSchema,
   referenceName: ContractIdentifierSchema,
   capabilityRef: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema.optional(),
-  inputBindings: z16.record(z16.string(), JsonValueSchema).default({}),
-  configuration: z16.object({ executor: z16.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
+  inputBindings: z17.record(z17.string(), JsonValueSchema).default({}),
+  configuration: z17.object({ executor: z17.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
 }).strict().superRefine((node, context) => {
   if (node.configuration.task.taskReferenceName !== node.referenceName) context.addIssue({ code: "custom", path: ["configuration", "task", "taskReferenceName"], message: "Conductor task reference must match node referenceName." });
   if (node.configuration.task.name !== node.capabilityRef) context.addIssue({ code: "custom", path: ["configuration", "task", "name"], message: "Conductor task name must match node capabilityRef." });
   if (JSON.stringify(node.configuration.task.inputParameters ?? {}) !== JSON.stringify(node.inputBindings)) context.addIssue({ code: "custom", path: ["configuration", "task", "inputParameters"], message: "Conductor task inputs must match node inputBindings." });
 });
-var WorkflowEdgeSchema = z16.object({
+var WorkflowEdgeSchema = z17.object({
   from: ContractIdentifierSchema,
   to: ContractIdentifierSchema,
   outputPort: ContractIdentifierSchema.optional(),
   inputPort: ContractIdentifierSchema.optional(),
-  condition: z16.string().optional()
+  condition: z17.string().optional()
 }).strict();
-var WorkflowTriggerSchema = z16.object({
+var WorkflowTriggerSchema = z17.object({
   id: ContractIdentifierSchema,
-  type: z16.enum(["manual", "schedule", "webhook", "event", "api"]),
-  enabled: z16.boolean(),
-  schedule: z16.object({ cron: z16.string().trim().min(1) }).strict().optional(),
-  webhook: z16.object({
-    path: z16.string().trim().min(1).optional(),
-    method: z16.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
-    auth: z16.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
-    basicAuth: z16.object({ username: z16.string(), password: z16.string() }).strict().optional(),
-    headerAuth: z16.object({ name: z16.string().trim().min(1), value: z16.string() }).strict().optional(),
-    responseUntil: z16.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
+  type: z17.enum(["manual", "schedule", "webhook", "event", "api"]),
+  enabled: z17.boolean(),
+  schedule: z17.object({ cron: z17.string().trim().min(1) }).strict().optional(),
+  webhook: z17.object({
+    path: z17.string().trim().min(1).optional(),
+    method: z17.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
+    auth: z17.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
+    basicAuth: z17.object({ username: z17.string(), password: z17.string() }).strict().optional(),
+    headerAuth: z17.object({ name: z17.string().trim().min(1), value: z17.string() }).strict().optional(),
+    responseUntil: z17.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
   }).strict().optional(),
-  event: z16.object({
+  event: z17.object({
     eventType: ContractIdentifierSchema,
     configuration: JsonValueSchema.optional()
   }).strict().optional()
@@ -12621,63 +13651,63 @@ var WorkflowTriggerSchema = z16.object({
   if (trigger.type === "webhook" && !trigger.webhook) context.addIssue({ code: "custom", path: ["webhook"], message: "Webhook trigger requires webhook configuration." });
   if (trigger.type === "event" && !trigger.event) context.addIssue({ code: "custom", path: ["event"], message: "Event trigger requires event configuration." });
 });
-var WorkflowValidationIssueSchema = z16.object({
+var WorkflowValidationIssueSchema = z17.object({
   taskReferenceName: ContractIdentifierSchema,
-  issueType: z16.enum(["ERROR", "WARNING"]),
-  detailReason: z16.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
-  humanMessage: z16.object({ en: z16.string(), zh: z16.string() }).strict()
+  issueType: z17.enum(["ERROR", "WARNING"]),
+  detailReason: z17.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
+  humanMessage: z17.object({ en: z17.string(), zh: z17.string() }).strict()
 }).strict();
-var WorkflowDefinitionSchema = z16.object({
-  contract: z16.literal("WorkflowDefinition"),
+var WorkflowDefinitionSchema = z17.object({
+  contract: z17.literal("WorkflowDefinition"),
   metadata: ContractMetadataSchema.omit({ name: true, description: true, labels: true }).extend({
     name: LocalizedTextSchema,
     description: LocalizedTextSchema.optional(),
-    role: z16.enum(["workflow", "template"]),
+    role: z17.enum(["workflow", "template"]),
     teamId: ContractIdentifierSchema,
     creatorRef: EntityRefSchema,
-    tags: z16.array(ContractIdentifierSchema).default([])
+    tags: z17.array(ContractIdentifierSchema).default([])
   }).strict(),
-  revision: z16.object({
-    kind: z16.enum(["release", "backup"]),
-    recordVersion: z16.number().int().positive(),
-    sourceVersion: z16.number().int().positive().optional()
+  revision: z17.object({
+    kind: z17.enum(["release", "backup"]),
+    recordVersion: z17.number().int().positive(),
+    sourceVersion: z17.number().int().positive().optional()
   }).strict().superRefine((revision, context) => {
     if (revision.kind === "backup" && revision.sourceVersion === void 0) context.addIssue({ code: "custom", path: ["sourceVersion"], message: "Backup revisions require a sourceVersion." });
   }),
-  presentation: z16.object({ iconUrl: z16.string().optional(), thumbnail: z16.string().optional() }).strict(),
-  ports: z16.object({ inputs: z16.array(ContractPortSchema).default([]), outputs: z16.array(ContractPortSchema).default([]) }).strict(),
-  parameters: z16.object({ variables: z16.array(WorkflowParameterSchema).default([]), outputs: z16.array(WorkflowOutputBindingSchema).default([]) }).strict(),
-  graph: z16.object({ nodes: z16.array(WorkflowNodeSchema), edges: z16.array(WorkflowEdgeSchema).default([]) }).strict(),
-  execution: z16.object({
-    timeoutMs: z16.number().int().positive().optional(),
-    retries: z16.number().int().nonnegative().default(0),
-    concurrencyLimit: z16.number().int().positive().optional(),
-    idempotency: z16.enum(["required", "supported", "none"]),
-    rateLimit: z16.object({ enabled: z16.boolean(), max: z16.number().int().nonnegative(), windowMs: z16.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
+  presentation: z17.object({ iconUrl: z17.string().optional(), thumbnail: z17.string().optional() }).strict(),
+  ports: z17.object({ inputs: z17.array(ContractPortSchema).default([]), outputs: z17.array(ContractPortSchema).default([]) }).strict(),
+  parameters: z17.object({ variables: z17.array(WorkflowParameterSchema).default([]), outputs: z17.array(WorkflowOutputBindingSchema).default([]) }).strict(),
+  graph: z17.object({ nodes: z17.array(WorkflowNodeSchema), edges: z17.array(WorkflowEdgeSchema).default([]) }).strict(),
+  execution: z17.object({
+    timeoutMs: z17.number().int().positive().optional(),
+    retries: z17.number().int().nonnegative().default(0),
+    concurrencyLimit: z17.number().int().positive().optional(),
+    idempotency: z17.enum(["required", "supported", "none"]),
+    rateLimit: z17.object({ enabled: z17.boolean(), max: z17.number().int().nonnegative(), windowMs: z17.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
       if (rateLimit.enabled && (rateLimit.max === 0 || rateLimit.windowMs === 0)) context.addIssue({ code: "custom", message: "Enabled rate limit requires positive max and windowMs." });
     }).optional(),
-    conductor: z16.object({
-      ownerApp: z16.string().optional(),
-      createTime: z16.number().int().nonnegative().optional(),
-      updateTime: z16.number().int().nonnegative().optional(),
-      createdBy: z16.string().optional(),
-      updatedBy: z16.string().optional(),
+    conductor: z17.object({
+      ownerApp: z17.string().optional(),
+      createTime: z17.number().int().nonnegative().optional(),
+      updateTime: z17.number().int().nonnegative().optional(),
+      createdBy: z17.string().optional(),
+      updatedBy: z17.string().optional(),
       failureWorkflow: ContractIdentifierSchema.optional(),
-      schemaVersion: z16.number().int().positive().optional(),
-      restartable: z16.boolean().optional(),
-      workflowStatusListenerEnabled: z16.boolean().optional(),
-      ownerEmail: z16.string().email().optional(),
-      timeoutPolicy: z16.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-      variables: z16.record(z16.string(), JsonValueSchema).optional(),
-      inputTemplate: z16.record(z16.string(), JsonValueSchema).optional()
+      schemaVersion: z17.number().int().positive().optional(),
+      restartable: z17.boolean().optional(),
+      workflowStatusListenerEnabled: z17.boolean().optional(),
+      ownerEmail: z17.string().email().optional(),
+      timeoutPolicy: z17.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+      variables: z17.record(z17.string(), JsonValueSchema).optional(),
+      inputTemplate: z17.record(z17.string(), JsonValueSchema).optional()
     }).strict()
   }).strict(),
-  triggers: z16.array(WorkflowTriggerSchema).default([]),
-  views: z16.array(z16.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
-  dataContracts: z16.object({ reads: z16.array(ContractIdentifierSchema).default([]), writes: z16.array(ContractIdentifierSchema).default([]), emits: z16.array(ContractIdentifierSchema).default([]) }).strict(),
-  governance: z16.object({ activated: z16.boolean(), validated: z16.boolean(), validationIssues: z16.array(WorkflowValidationIssueSchema).default([]), hidden: z16.boolean().optional() }).strict(),
-  interfaces: z16.object({
-    openai: z16.object({ enabled: z16.boolean(), modelName: z16.string().trim().min(1).optional() }).strict(),
+  triggers: z17.array(WorkflowTriggerSchema).default([]),
+  views: z17.array(z17.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
+  dataContracts: z17.object({ reads: z17.array(ContractIdentifierSchema).default([]), writes: z17.array(ContractIdentifierSchema).default([]), emits: z17.array(ContractIdentifierSchema).default([]) }).strict(),
+  governance: z17.object({ activated: z17.boolean(), validated: z17.boolean(), validationIssues: z17.array(WorkflowValidationIssueSchema).default([]), hidden: z17.boolean().optional() }).strict(),
+  interfaces: z17.object({
+    openai: z17.object({ enabled: z17.boolean(), modelName: z17.string().trim().min(1).optional() }).strict(),
     shortcutRef: EntityRefSchema.optional(),
     preferredAppId: ContractIdentifierSchema.optional()
   }).strict().superRefine((interfaces, context) => {
@@ -12696,21 +13726,21 @@ var WorkflowDefinitionSchema = z16.object({
 });
 
 // src/contracts/workflow-runtime.ts
-import { z as z17 } from "zod";
-var WorkflowCatalogEntrySchema = z17.object({
-  contract: z17.literal("WorkflowCatalogEntry"),
+import { z as z18 } from "zod";
+var WorkflowCatalogEntrySchema = z18.object({
+  contract: z18.literal("WorkflowCatalogEntry"),
   workflowId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   creatorRef: EntityRefSchema,
   currentDefinitionRef: EntityRefSchema,
-  lifecycle: z17.enum(["ACTIVE", "DELETED"]),
-  asset: z17.object({
-    preset: z17.boolean(),
-    marketplacePublished: z17.boolean(),
+  lifecycle: z18.enum(["ACTIVE", "DELETED"]),
+  asset: z18.object({
+    preset: z18.boolean(),
+    marketplacePublished: z18.boolean(),
     publishConfig: JsonObjectSchema.optional(),
-    sort: z17.number().int(),
+    sort: z18.number().int(),
     forkFromRef: EntityRefSchema.optional(),
-    notAuthorized: z17.boolean()
+    notAuthorized: z18.boolean()
   }).strict(),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema,
@@ -12745,17 +13775,17 @@ var WorkflowCatalogEntrySchema = z17.object({
     });
   }
 });
-var WorkflowPublicationSchema = z17.object({
-  contract: z17.literal("WorkflowPublication"),
+var WorkflowPublicationSchema = z18.object({
+  contract: z18.literal("WorkflowPublication"),
   publicationId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
   runtimeDefinitionRef: EntityRefSchema,
   sourceHash: Sha256Schema,
   compiledHash: Sha256Schema,
-  status: z17.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
+  status: z18.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
   publisherRef: EntityRefSchema,
   publishedAt: IsoDateTimeSchema.optional(),
-  failureReason: z17.string().trim().min(1).optional()
+  failureReason: z18.string().trim().min(1).optional()
 }).strict().superRefine((publication, context) => {
   if (publication.definitionRef.kind !== "workflow-definition") {
     context.addIssue({
@@ -12786,12 +13816,12 @@ var WorkflowPublicationSchema = z17.object({
     });
   }
 });
-var WorkflowCompletionCommitSchema = z17.object({
-  contract: z17.literal("WorkflowCompletionCommit"),
+var WorkflowCompletionCommitSchema = z18.object({
+  contract: z18.literal("WorkflowCompletionCommit"),
   commitId: ContractIdentifierSchema,
   run: ApplicationRunSchema,
-  outputs: z17.array(OutputRecordSchema),
-  artifacts: z17.array(ArtifactManifestSchema),
+  outputs: z18.array(OutputRecordSchema),
+  artifacts: z18.array(ArtifactManifestSchema),
   lineage: LineageRecordSchema,
   completedAt: IsoDateTimeSchema
 }).strict().superRefine((commit, context) => {
@@ -12833,15 +13863,15 @@ var WorkflowCompletionCommitSchema = z17.object({
     }
   });
 });
-var WorkflowCompletionReceiptSchema = z17.object({
-  contract: z17.literal("WorkflowCompletionReceipt"),
+var WorkflowCompletionReceiptSchema = z18.object({
+  contract: z18.literal("WorkflowCompletionReceipt"),
   commitId: ContractIdentifierSchema,
   runRef: EntityRefSchema,
-  outputRefs: z17.array(EntityRefSchema),
-  artifactRefs: z17.array(EntityRefSchema),
+  outputRefs: z18.array(EntityRefSchema),
+  artifactRefs: z18.array(EntityRefSchema),
   contentHash: Sha256Schema,
   committedAt: IsoDateTimeSchema,
-  idempotentReplay: z17.boolean()
+  idempotentReplay: z18.boolean()
 }).strict().superRefine((receipt, context) => {
   if (receipt.runRef.kind !== "application-run") {
     context.addIssue({
@@ -12902,6 +13932,7 @@ var canonicalContractSchemas = {
   "domain-command": DomainCommandSchema,
   "domain-command-definition": DomainCommandDefinitionSchema,
   "data-continuity-envelope": DataContinuityEnvelopeSchema,
+  "declarative-control-ontology-definition": DeclarativeControlOntologyDefinitionSchema,
   "execution-link": ExecutionLinkSchema,
   "expiring-access-grant": ExpiringAccessGrantSchema,
   "hotword-body": HotwordBodySchema,
@@ -12909,13 +13940,20 @@ var canonicalContractSchemas = {
   "menu-definition": MenuDefinitionSchema,
   "menu-definition-set": MenuDefinitionSetSchema,
   "menu-runtime-bundle": MenuRuntimeBundleSchema,
+  "navigation": NavigationSchema,
+  "navigation-release": NavigationReleaseSchema,
+  "navigation-runtime-bundle": NavigationRuntimeBundleSchema,
   "ontology-definition": OntologyDefinitionSchema,
   "overlay-node": OverlayNodeSchema,
   "output-record": OutputRecordSchema,
   "page-definition": PageDefinitionSchema,
+  "page": PageSchema,
+  "page-release": PageReleaseSchema,
+  "page-runtime-bundle": PageRuntimeBundleSchema,
   "page-runtime-descriptor": PageRuntimeDescriptorSchema,
   "page-runtime-projection": PageRuntimeProjectionSchema,
   "projection-spec": ProjectionSpecSchema,
+  "publication-plan": PublicationPlanSchema,
   "product-declaration": ProductDeclarationSchema,
   "product-body": ProductBodySchema,
   "radar-action-record": RadarActionRecordSchema,
@@ -12929,9 +13967,11 @@ var canonicalContractSchemas = {
   "radar-selection": RadarSelectionSchema,
   "radar-writeback-record": RadarWritebackRecordSchema,
   "request-scope": RequestScopeSchema,
+  "route-space": RouteSpaceSchema,
   "render-node": RenderNodeSchema,
   "render-tree": RenderTreeSchema,
   "saved-radar-query": SavedRadarQuerySchema,
+  "stable-ref-alias-map": StableRefAliasMapSchema,
   "tenant-product-config": TenantProductConfigSchema,
   "tenant-runtime-config": TenantRuntimeConfigSchema,
   "theme-tokens": ThemeTokensSchema,
@@ -12940,6 +13980,9 @@ var canonicalContractSchemas = {
   "trend-metric-snapshot": TrendMetricSnapshotSchema,
   "trend-source-record": TrendSourceRecordSchema,
   "view-provider-descriptor": ViewProviderDescriptorSchema,
+  "workbench": WorkbenchSchema,
+  "workbench-release": WorkbenchReleaseSchema,
+  "workbench-runtime-bundle": WorkbenchRuntimeBundleSchema,
   "workflow-definition": WorkflowDefinitionSchema,
   "workflow-catalog-entry": WorkflowCatalogEntrySchema,
   "workflow-publication": WorkflowPublicationSchema,
@@ -12947,6 +13990,8 @@ var canonicalContractSchemas = {
   "workflow-completion-receipt": WorkflowCompletionReceiptSchema
 };
 export {
+  AccessPolicySchema,
+  ActionBindingSchema,
   AgentConfigurationCapabilitySchema,
   AgentExecutionModeSchema,
   AgentModeCapabilitiesSchema,
@@ -13002,9 +14047,11 @@ export {
   ApplicationHandoffSchema,
   ApplicationRunSchema,
   ArtifactManifestSchema,
+  BindingSourceSchema,
   BodyRelationRecordSchema,
   BrandBodySchema,
   BrandGeneticsProfileSchema,
+  CapabilityInstanceSchema,
   CapabilityManifestSchema,
   CapabilityRegistryDocumentSchema,
   CapabilityRegistryEntrySchema,
@@ -13020,6 +14067,15 @@ export {
   CompiledMenuNavigateBehaviorSchema,
   CompiledMenuNodeSchema,
   CompiledMenuProjectionSchema,
+  CompiledNavigationDomainCommandTargetSchema,
+  CompiledNavigationGroupNodeSchema,
+  CompiledNavigationNodeSchema,
+  CompiledNavigationRegisteredMenuActionTargetSchema,
+  CompiledNavigationResolvedTargetSchema,
+  CompiledNavigationSeparatorNodeSchema,
+  CompiledNavigationTargetNodeSchema,
+  CompiledRouteClaimSchema,
+  CompiledRouteMatcherSchema,
   CompletionEventSchema,
   CompletionHeaderSchema,
   ConceptDefinitionSchema,
@@ -13037,6 +14093,9 @@ export {
   CurrentUserMenuProfileSchema,
   CurrentUserMenuSectionSchema,
   DataContinuityEnvelopeSchema,
+  DeclarativeControlOntologyDefinitionSchema,
+  DeclarativeLifecycleSchema,
+  DeclarativeRouteClaimSchema,
   DomainCommandDefinitionSchema,
   DomainCommandSchema,
   DomainEventSchema,
@@ -13044,9 +14103,12 @@ export {
   ExecutionLinkSchema,
   ExpiringAccessGrantSchema,
   HotwordBodySchema,
+  I18nTextSchema,
   JsonObjectSchema,
   JsonValueSchema,
+  LegacyRouteClaimSchema,
   LineageRecordSchema,
+  ManagementAccessSchema,
   MenuAccessRequirementSchema,
   MenuActionBehaviorSchema,
   MenuActionRegistrationSchema,
@@ -13068,6 +14130,14 @@ export {
   MenuRuntimeBundleSchema,
   MenuRuntimeInputBindingSchema,
   MenuSourceInputBindingSchema,
+  NavigationGroupNodeSchema,
+  NavigationNodeSchema,
+  NavigationReleaseSchema,
+  NavigationRuntimeBundleSchema,
+  NavigationSchema,
+  NavigationSeparatorNodeSchema,
+  NavigationTargetNodeSchema,
+  OntologyBindingSchema,
   OntologyDefinitionSchema,
   OutputRecordSchema,
   OverlayNodeSchema,
@@ -13075,10 +14145,13 @@ export {
   PageDefinitionSchema,
   PageGuardProjectionSchema,
   PageNavigationProjectionSchema,
+  PageReleaseSchema,
   PageRendererProjectionSchema,
   PageRouteProjectionSchema,
+  PageRuntimeBundleSchema,
   PageRuntimeDescriptorSchema,
   PageRuntimeProjectionSchema,
+  PageSchema,
   PageTypeSchema,
   PageVisibilitySchema,
   PermissionBundleSchema,
@@ -13087,7 +14160,10 @@ export {
   ProductBodySchema,
   ProductContextSchema,
   ProductDeclarationSchema,
+  ProductSurfaceSchema,
   ProjectionSpecSchema,
+  PublicationPlanOperationSchema,
+  PublicationPlanSchema,
   RadarActionRecordSchema,
   RadarAnalysisAssetSchema,
   RadarAnalysisDetailSchema,
@@ -13103,6 +14179,12 @@ export {
   RadarScoreProjectionSchema,
   RadarSelectionSchema,
   RadarWritebackRecordSchema,
+  ReferenceVisibilitySchema,
+  ReleaseDependencyRoleSchema,
+  ReleaseDependencySchema,
+  ReleaseEvidenceSchema,
+  ReleaseOperationSchema,
+  ReleaseValidationSchema,
   RenderActivationSchema,
   RenderLayoutSchema,
   RenderLifecycleSchema,
@@ -13114,9 +14196,20 @@ export {
   RenderSurfaceSchema,
   RenderTreeSchema,
   RequestScopeSchema,
+  ResolvedNavigationTargetSchema,
   ResolvedThemeTokensSchema,
+  ResolvedWorkbenchAppInstanceSchema,
+  RevisionRefSchema,
+  RouteClaimSchema,
+  RoutePathTemplateSchema,
+  RouteSpaceParameterSchema,
+  RouteSpaceSchema,
   SavedRadarQuerySchema,
+  ScopedIdentityRefSchema,
   SourceRecordRefSchema,
+  StableRefAliasMapSchema,
+  StableRefAliasSchema,
+  StableRefSchema,
   StorageLocatorSchema,
   StudioAgentModeSchema,
   SystemGroupDefinitionSchema,
@@ -13126,6 +14219,7 @@ export {
   TenantListFooterConfigSchema,
   TenantProductConfigSchema,
   TenantRuntimeConfigSchema,
+  TenantScopeSchema,
   TenantTrendRadarCollectionTargetSchema,
   TenantTrendRadarDerivedMetricsSchema,
   TenantTrendRadarEvaluationSchema,
@@ -13156,6 +14250,11 @@ export {
   TrendSourceRecordSchema,
   TrendSourceSchema,
   ViewProviderDescriptorSchema,
+  WorkbenchAppInstanceSchema,
+  WorkbenchGroupSchema,
+  WorkbenchReleaseSchema,
+  WorkbenchRuntimeBundleSchema,
+  WorkbenchSchema,
   WorkflowCatalogEntrySchema,
   WorkflowCompletionCommitSchema,
   WorkflowCompletionReceiptSchema,