@inf-monkeys-tech/monkeys 1.0.2 → 1.0.3

package/lib/esm/contracts/index.mjs

@@ -0,0 +1,4564 @@
+// src/contracts/artifact.ts
+import { z as z2 } from "zod";
+
+// src/contracts/common.ts
+import { z } from "zod";
+var JsonValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number().finite(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema)
+  ])
+);
+var JsonObjectSchema = z.record(z.string(), JsonValueSchema);
+var ContractIdentifierSchema = z.string().trim().min(1).max(256);
+var ContractVersionSchema = z.number().int().positive();
+var IsoDateTimeSchema = z.string().datetime({ offset: true });
+var Sha256Schema = z.string().regex(/^[a-f0-9]{64}$/i, "Expected a SHA-256 hex digest.");
+var LocaleIdentifierSchema = z.string().regex(/^[a-z]{2,3}(?:-[A-Z][a-z]{3})?(?:-[A-Z]{2}|-\d{3})?$/, "Expected a BCP 47 locale identifier.");
+var LocalizedTextSchema = z.union([
+  z.string().trim().min(1),
+  z.record(LocaleIdentifierSchema, z.string().trim().min(1)).refine((value) => Object.keys(value).length > 0, "Localized text must contain at least one locale.")
+]);
+var ContractMetadataSchema = z.object({
+  id: ContractIdentifierSchema,
+  version: ContractVersionSchema,
+  name: z.string().trim().min(1).optional(),
+  description: z.string().optional(),
+  labels: z.record(z.string(), z.string()).optional(),
+  createdAt: IsoDateTimeSchema.optional(),
+  updatedAt: IsoDateTimeSchema.optional()
+}).strict();
+var EntityRefSchema = z.object({
+  kind: ContractIdentifierSchema,
+  id: ContractIdentifierSchema,
+  version: z.union([ContractVersionSchema, z.string().trim().min(1)]).optional(),
+  ownerRepo: ContractIdentifierSchema.optional()
+}).strict();
+
+// src/contracts/artifact.ts
+var StorageLocatorSchema = z2.object({
+  provider: ContractIdentifierSchema,
+  bucket: ContractIdentifierSchema.optional(),
+  key: ContractIdentifierSchema,
+  region: ContractIdentifierSchema.optional(),
+  url: z2.string().url().optional(),
+  expiresAt: IsoDateTimeSchema.optional()
+}).strict();
+var ArtifactAccessSchema = z2.object({
+  tenantId: ContractIdentifierSchema.optional(),
+  teamId: ContractIdentifierSchema.optional(),
+  ownerRef: EntityRefSchema.optional(),
+  visibility: z2.enum(["private", "team", "tenant", "public"])
+}).strict();
+var ArtifactManifestSchema = z2.object({
+  contract: z2.literal("ArtifactManifest"),
+  artifactId: ContractIdentifierSchema,
+  kind: ContractIdentifierSchema,
+  mimeType: z2.string().trim().min(1),
+  byteSize: z2.number().int().nonnegative().optional(),
+  sha256: Sha256Schema,
+  storage: StorageLocatorSchema,
+  sourceRef: EntityRefSchema.optional(),
+  runRef: EntityRefSchema,
+  outputRef: EntityRefSchema,
+  producer: z2.object({
+    service: ContractIdentifierSchema,
+    version: ContractIdentifierSchema,
+    capabilityRef: EntityRefSchema.optional()
+  }).strict(),
+  access: ArtifactAccessSchema,
+  metadata: z2.record(z2.string(), JsonValueSchema).default({}),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var OutputRecordSchema = z2.object({
+  contract: z2.literal("OutputRecord"),
+  outputId: ContractIdentifierSchema,
+  runRef: EntityRefSchema,
+  outputPort: ContractIdentifierSchema,
+  value: JsonValueSchema.optional(),
+  artifactRefs: z2.array(EntityRefSchema).default([]),
+  schemaRef: ContractIdentifierSchema.optional(),
+  createdAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/capability.ts
+import { z as z4 } from "zod";
+
+// src/contracts/render.ts
+import { z as z3 } from "zod";
+var ProductContextSchema = z3.enum(["studio", "kernel", "compute"]);
+var RenderNodeStateSchema = z3.enum([
+  "idle",
+  "loading",
+  "empty",
+  "error",
+  "success",
+  "disabled",
+  "selected"
+]);
+var RenderNodeKindSchema = z3.enum([
+  "shell",
+  "page",
+  "navigation",
+  "view",
+  "record",
+  "control",
+  "detail",
+  "action",
+  "overlay",
+  "professional-provider"
+]);
+var RenderSurfaceSchema = z3.object({
+  frameOwner: z3.enum(["host", "provider", "none"]),
+  tone: ContractIdentifierSchema.optional(),
+  density: z3.enum(["compact", "default", "comfortable"])
+}).strict();
+var RenderScrollSchema = z3.object({
+  owner: z3.enum(["page", "surface", "provider"]),
+  axis: z3.enum(["x", "y", "both", "none"]),
+  restoreKey: ContractIdentifierSchema.optional(),
+  virtualizationBoundary: z3.boolean()
+}).strict().superRefine((scroll, context) => {
+  if (scroll.owner === "provider" && scroll.restoreKey) {
+    context.addIssue({
+      code: "custom",
+      path: ["restoreKey"],
+      message: "Provider-owned scroll state cannot declare a host restoreKey."
+    });
+  }
+  if (scroll.virtualizationBoundary && scroll.owner !== "provider") {
+    context.addIssue({
+      code: "custom",
+      path: ["owner"],
+      message: "A virtualization boundary must keep scroll ownership in the provider."
+    });
+  }
+});
+var RenderActivationSchema = z3.object({
+  activationId: ContractIdentifierSchema,
+  mode: z3.enum(["navigate", "select", "drawer", "modal", "fullscreen", "inline"]),
+  targetPath: z3.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").optional(),
+  history: z3.enum(["push", "replace"]).optional()
+}).strict().superRefine((activation, context) => {
+  if (activation.mode === "navigate" && !activation.targetPath) {
+    context.addIssue({ code: "custom", path: ["targetPath"], message: "Navigate activation requires an application-relative targetPath." });
+  }
+  if (activation.mode !== "navigate" && activation.targetPath) {
+    context.addIssue({ code: "custom", path: ["targetPath"], message: "Only navigate activation may declare targetPath." });
+  }
+});
+var RenderLifecycleSchema = z3.object({
+  mountPolicy: z3.enum(["always", "when-visible", "when-active"]),
+  queryPolicy: z3.enum(["always", "when-visible", "when-active", "manual"]),
+  retainOnDeactivate: z3.boolean(),
+  deepLink: z3.boolean(),
+  focusReturn: z3.boolean()
+}).strict();
+var RenderLayoutSchema = z3.object({
+  mode: z3.enum(["contents", "block", "flex", "grid", "absolute"]),
+  direction: z3.enum(["row", "column"]).optional(),
+  columns: z3.number().int().positive().optional(),
+  align: z3.enum(["start", "center", "end", "stretch"]).optional(),
+  justify: z3.enum(["start", "center", "end", "between", "around"]).optional(),
+  gapTokenRef: EntityRefSchema.optional()
+}).strict().superRefine((layout, context) => {
+  if (layout.direction && layout.mode !== "flex") {
+    context.addIssue({ code: "custom", path: ["direction"], message: "direction is only valid for flex layout." });
+  }
+  if (layout.columns && layout.mode !== "grid") {
+    context.addIssue({ code: "custom", path: ["columns"], message: "columns is only valid for grid layout." });
+  }
+  if (layout.gapTokenRef && layout.gapTokenRef.kind !== "design-token") {
+    context.addIssue({ code: "custom", path: ["gapTokenRef", "kind"], message: "gapTokenRef must reference design-token." });
+  }
+});
+var RenderResponsiveRuleSchema = z3.object({
+  minWidthPx: z3.number().nonnegative().optional(),
+  maxWidthPx: z3.number().positive().optional(),
+  layout: RenderLayoutSchema
+}).strict().superRefine((rule, context) => {
+  if (rule.minWidthPx === void 0 && rule.maxWidthPx === void 0) {
+    context.addIssue({ code: "custom", path: [], message: "Responsive rule must declare minWidthPx or maxWidthPx." });
+  }
+  if (rule.minWidthPx !== void 0 && rule.maxWidthPx !== void 0 && rule.minWidthPx > rule.maxWidthPx) {
+    context.addIssue({ code: "custom", path: ["maxWidthPx"], message: "maxWidthPx must be greater than or equal to minWidthPx." });
+  }
+});
+var requireRef = (reference, expectedKind, path, context) => {
+  if (!reference) return;
+  if (reference.kind !== expectedKind) {
+    context.addIssue({
+      code: "custom",
+      path: [...path, "kind"],
+      message: `${path.join(".")} must reference ${expectedKind}.`
+    });
+  }
+};
+var requirePinnedOwnedRef = (reference, expectedKind, path, context) => {
+  requireRef(reference, expectedKind, path, context);
+  if (!reference) return;
+  if (reference.version === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: [...path, "version"],
+      message: `${path.join(".")} must pin a version.`
+    });
+  }
+  if (reference.ownerRepo === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: [...path, "ownerRepo"],
+      message: `${path.join(".")} must declare its owner repository.`
+    });
+  }
+};
+var RenderNodeSchema = z3.object({
+  contract: z3.literal("RenderNode"),
+  nodeId: ContractIdentifierSchema,
+  kind: RenderNodeKindSchema,
+  version: ContractVersionSchema,
+  ownerRepo: ContractIdentifierSchema,
+  parentNodeId: ContractIdentifierSchema.optional(),
+  children: z3.array(ContractIdentifierSchema),
+  slot: ContractIdentifierSchema.optional(),
+  pageRef: EntityRefSchema,
+  semanticRef: EntityRefSchema.optional(),
+  dataContextRef: EntityRefSchema.optional(),
+  capabilityRef: EntityRefSchema,
+  providerRef: EntityRefSchema.optional(),
+  stateRef: EntityRefSchema.optional(),
+  surface: RenderSurfaceSchema,
+  scroll: RenderScrollSchema,
+  activation: RenderActivationSchema,
+  lifecycle: RenderLifecycleSchema,
+  layout: RenderLayoutSchema,
+  responsive: z3.array(RenderResponsiveRuleSchema),
+  accessRef: EntityRefSchema.optional(),
+  evidenceRef: EntityRefSchema.optional(),
+  state: RenderNodeStateSchema,
+  renderModel: JsonObjectSchema
+}).strict().superRefine((node, context) => {
+  requireRef(node.pageRef, "page", ["pageRef"], context);
+  requirePinnedOwnedRef(node.capabilityRef, "capability", ["capabilityRef"], context);
+  requirePinnedOwnedRef(node.providerRef, "view-provider", ["providerRef"], context);
+  requireRef(node.accessRef, "access-policy", ["accessRef"], context);
+  requireRef(node.evidenceRef, "evidence", ["evidenceRef"], context);
+  if (node.parentNodeId === node.nodeId) {
+    context.addIssue({
+      code: "custom",
+      path: ["parentNodeId"],
+      message: "RenderNode cannot be its own parent."
+    });
+  }
+  if (new Set(node.children).size !== node.children.length) {
+    context.addIssue({ code: "custom", path: ["children"], message: "RenderNode children must be unique." });
+  }
+  if (node.children.includes(node.nodeId)) {
+    context.addIssue({ code: "custom", path: ["children"], message: "RenderNode cannot be its own child." });
+  }
+  if (node.surface.frameOwner === "provider" && !node.providerRef) {
+    context.addIssue({
+      code: "custom",
+      path: ["providerRef"],
+      message: "Provider-owned surfaces require providerRef."
+    });
+  }
+});
+var RenderTreeSchema = z3.object({
+  contract: z3.literal("RenderTree"),
+  treeId: ContractIdentifierSchema,
+  product: ProductContextSchema,
+  rootNodeId: ContractIdentifierSchema,
+  nodes: z3.array(RenderNodeSchema).min(1)
+}).strict();
+var OverlayZIndexLaneSchema = z3.enum([
+  "popover",
+  "drawer",
+  "modal",
+  "fullscreen",
+  "system"
+]);
+var OverlayNodeSchema = z3.object({
+  contract: z3.literal("OverlayNode"),
+  overlayId: ContractIdentifierSchema,
+  renderNode: RenderNodeSchema,
+  presentation: z3.enum(["drawer", "modal", "fullscreen"]),
+  zIndexLane: OverlayZIndexLaneSchema,
+  url: z3.object({
+    parameter: ContractIdentifierSchema,
+    value: ContractIdentifierSchema,
+    openMode: z3.enum(["push", "replace"]),
+    closeMode: z3.enum(["back", "replace"])
+  }).strict(),
+  focus: z3.object({
+    initial: z3.enum(["first-interactive", "container", "explicit"]),
+    trap: z3.boolean()
+  }).strict(),
+  close: z3.object({
+    escape: z3.boolean(),
+    backdrop: z3.boolean()
+  }).strict()
+}).strict().superRefine((value, context) => {
+  if (value.renderNode.kind !== "overlay") {
+    context.addIssue({
+      code: "custom",
+      path: ["renderNode", "kind"],
+      message: "OverlayNode renderNode.kind must be overlay."
+    });
+  }
+  if (value.renderNode.activation.mode !== value.presentation) {
+    context.addIssue({
+      code: "custom",
+      path: ["renderNode", "activation", "mode"],
+      message: "OverlayNode presentation must match the RenderNode activation mode."
+    });
+  }
+  if (value.presentation === "drawer" && value.zIndexLane !== "drawer") {
+    context.addIssue({
+      code: "custom",
+      path: ["zIndexLane"],
+      message: "Drawer overlays must use the drawer z-index lane."
+    });
+  }
+  if (value.presentation === "modal" && value.zIndexLane !== "modal") {
+    context.addIssue({
+      code: "custom",
+      path: ["zIndexLane"],
+      message: "Modal overlays must use the modal z-index lane."
+    });
+  }
+  if (value.presentation === "fullscreen" && value.zIndexLane !== "fullscreen" && value.zIndexLane !== "system") {
+    context.addIssue({
+      code: "custom",
+      path: ["zIndexLane"],
+      message: "Fullscreen overlays must use the fullscreen or system z-index lane."
+    });
+  }
+});
+var ProductPathSchema = z3.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.");
+var ApplicationHandoffEndpointSchema = z3.object({
+  product: ProductContextSchema,
+  pageId: ContractIdentifierSchema,
+  viewId: ContractIdentifierSchema.optional(),
+  objectRef: EntityRefSchema.optional(),
+  runtimeRef: EntityRefSchema.optional(),
+  activationId: ContractIdentifierSchema.optional(),
+  path: ProductPathSchema
+}).strict();
+var ApplicationHandoffSchema = z3.object({
+  contract: z3.literal("ApplicationHandoff"),
+  handoffId: ContractIdentifierSchema,
+  source: ApplicationHandoffEndpointSchema,
+  target: ApplicationHandoffEndpointSchema,
+  returnTarget: ApplicationHandoffEndpointSchema.optional(),
+  traceId: ContractIdentifierSchema.optional(),
+  createdAt: IsoDateTimeSchema
+}).strict().superRefine((value, context) => {
+  if (value.source.product === value.target.product && value.source.pageId === value.target.pageId) {
+    context.addIssue({
+      code: "custom",
+      path: ["target"],
+      message: "ApplicationHandoff target must identify a different product page."
+    });
+  }
+});
+var ViewProviderDescriptorSchema = z3.object({
+  contract: z3.literal("ViewProviderDescriptor"),
+  providerId: ContractIdentifierSchema,
+  providerVersion: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  capabilityRef: EntityRefSchema,
+  rendererKey: ContractIdentifierSchema,
+  renderModelSchemaRef: ContractIdentifierSchema,
+  intentSchemaRef: ContractIdentifierSchema.optional(),
+  loading: z3.enum(["eager", "lazy", "viewport", "on-activation"]),
+  stateOwner: z3.enum(["host", "provider", "external"]),
+  supportedPageTypes: z3.array(ContractIdentifierSchema).min(1),
+  supportedSurfaces: z3.array(z3.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"])).min(1),
+  frameOwner: z3.enum(["host", "provider", "none"]),
+  sideEffects: z3.array(z3.enum(["network", "storage", "navigation", "worker", "websocket"])),
+  sideEffectAdapterRef: EntityRefSchema.optional(),
+  lifecycle: z3.object({
+    preserveMount: z3.boolean(),
+    preserveScroll: z3.boolean(),
+    focusModel: ContractIdentifierSchema
+  }).strict(),
+  performance: z3.object({
+    lazy: z3.boolean(),
+    virtualized: z3.boolean(),
+    budgetMs: z3.number().positive().optional()
+  }).strict(),
+  accessRef: EntityRefSchema.optional(),
+  evidenceRef: EntityRefSchema.optional()
+}).strict().superRefine((provider, context) => {
+  requirePinnedOwnedRef(provider.capabilityRef, "capability", ["capabilityRef"], context);
+  requirePinnedOwnedRef(provider.sideEffectAdapterRef, "side-effect-adapter", ["sideEffectAdapterRef"], context);
+  requireRef(provider.accessRef, "access-policy", ["accessRef"], context);
+  requireRef(provider.evidenceRef, "evidence", ["evidenceRef"], context);
+  if (provider.capabilityRef.version === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["capabilityRef", "version"],
+      message: "Provider capabilityRef must pin an active capability version."
+    });
+  }
+  if (provider.frameOwner === "provider" && provider.stateOwner === "host" && !provider.lifecycle.preserveMount) {
+    context.addIssue({
+      code: "custom",
+      path: ["lifecycle", "preserveMount"],
+      message: "Host-owned state on a provider-owned frame must preserve the provider mount."
+    });
+  }
+  if (provider.sideEffects.length > 0 && !provider.sideEffectAdapterRef) {
+    context.addIssue({ code: "custom", path: ["sideEffectAdapterRef"], message: "Providers with side effects require a pinned side-effect adapter." });
+  }
+  if (provider.sideEffects.length === 0 && provider.sideEffectAdapterRef) {
+    context.addIssue({ code: "custom", path: ["sideEffectAdapterRef"], message: "Pure providers cannot declare a side-effect adapter." });
+  }
+});
+
+// src/contracts/capability.ts
+var ContractPortSchema = z4.object({
+  name: ContractIdentifierSchema,
+  schemaRef: ContractIdentifierSchema,
+  required: z4.boolean().default(false),
+  multiple: z4.boolean().default(false),
+  description: z4.string().optional()
+}).strict();
+var CapabilityProviderBindingSchema = z4.object({
+  providerRef: EntityRefSchema,
+  productContexts: z4.array(ProductContextSchema).default([]),
+  priority: z4.number().int().default(0)
+}).strict();
+var CapabilityManifestSchema = z4.object({
+  contract: z4.literal("CapabilityManifest"),
+  id: ContractIdentifierSchema,
+  capabilityVersion: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  kind: z4.enum(["primitive", "composite", "view", "professional-provider", "tool", "workflow"]),
+  displayName: z4.string().trim().min(1),
+  description: z4.string().optional(),
+  ports: z4.object({
+    inputs: z4.array(ContractPortSchema).default([]),
+    outputs: z4.array(ContractPortSchema).default([])
+  }).strict(),
+  runtime: z4.object({
+    providerBindings: z4.array(CapabilityProviderBindingSchema).min(1),
+    loading: z4.enum(["eager", "lazy", "viewport", "on-activation"]),
+    fallbackCapabilityRef: EntityRefSchema.optional(),
+    stateOwner: z4.enum(["host", "provider", "external"]),
+    stateSchemaRef: ContractIdentifierSchema.optional(),
+    sideEffects: z4.array(z4.enum(["network", "storage", "navigation", "worker", "websocket"])).default([])
+  }).strict(),
+  placement: z4.object({
+    surfaces: z4.array(ContractIdentifierSchema).min(1),
+    slots: z4.array(ContractIdentifierSchema).default([]),
+    variants: z4.array(ContractIdentifierSchema).default([]),
+    tokenRefs: z4.array(ContractIdentifierSchema).default([])
+  }).strict(),
+  accessibility: z4.object({
+    keyboardModel: ContractIdentifierSchema,
+    focusModel: ContractIdentifierSchema,
+    labelContract: ContractIdentifierSchema
+  }).strict(),
+  observability: z4.object({
+    eventNamespace: ContractIdentifierSchema,
+    metrics: z4.array(ContractIdentifierSchema).default([]),
+    evidenceRefs: z4.array(ContractIdentifierSchema).default([]),
+    performanceBudgetMs: z4.number().positive().optional()
+  }).strict()
+}).strict().superRefine((manifest, context) => {
+  const providerIds = /* @__PURE__ */ new Set();
+  manifest.runtime.providerBindings.forEach((binding, index) => {
+    const providerIdentity = `${binding.providerRef.kind}:${binding.providerRef.id}@${String(binding.providerRef.version)}:${binding.providerRef.ownerRepo ?? ""}`;
+    if (providerIds.has(providerIdentity)) {
+      context.addIssue({ code: "custom", path: ["runtime", "providerBindings", index], message: `Duplicate capability provider binding: ${providerIdentity}` });
+    }
+    providerIds.add(providerIdentity);
+    if (!["view", "professional-provider"].includes(manifest.kind)) return;
+    if (binding.providerRef.kind !== "view-provider") {
+      context.addIssue({ code: "custom", path: ["runtime", "providerBindings", index, "providerRef", "kind"], message: "View capabilities must resolve to view providers." });
+    }
+    if (binding.providerRef.version === void 0) {
+      context.addIssue({ code: "custom", path: ["runtime", "providerBindings", index, "providerRef", "version"], message: "View capability providers must pin a provider version." });
+    }
+    if (binding.providerRef.ownerRepo === void 0) {
+      context.addIssue({ code: "custom", path: ["runtime", "providerBindings", index, "providerRef", "ownerRepo"], message: "View capability providers must declare their owner repository." });
+    }
+  });
+});
+var CapabilitySourceTypeSchema = z4.enum([
+  "tool-manifest",
+  "plugin-manifest",
+  "openapi",
+  "workflow",
+  "comfyui"
+]);
+var CapabilityRegistrySourceSchema = z4.object({
+  sourceType: CapabilitySourceTypeSchema,
+  sourceId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema
+}).strict();
+var CapabilityRegistryEntrySchema = z4.object({
+  manifest: CapabilityManifestSchema,
+  sources: z4.array(CapabilityRegistrySourceSchema).min(1)
+}).strict();
+var CapabilityRegistryDocumentSchema = z4.object({
+  contract: z4.literal("CapabilityRegistry"),
+  entries: z4.array(CapabilityRegistryEntrySchema)
+}).strict().superRefine((registry, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  registry.entries.forEach((entry, index) => {
+    if (ids.has(entry.manifest.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["entries", index, "manifest", "id"],
+        message: `Duplicate capability id: ${entry.manifest.id}`
+      });
+    }
+    ids.add(entry.manifest.id);
+  });
+});
+
+// src/contracts/context.ts
+import { z as z5 } from "zod";
+var ActorRefSchema = z5.object({
+  kind: z5.enum(["human", "agent", "service", "tenant", "public"]),
+  id: ContractIdentifierSchema.optional(),
+  userId: ContractIdentifierSchema.optional(),
+  agentId: ContractIdentifierSchema.optional(),
+  serviceId: ContractIdentifierSchema.optional()
+}).strict();
+var AuthorityScopeSchema = z5.object({
+  resource: ContractIdentifierSchema,
+  actions: z5.array(ContractIdentifierSchema).min(1),
+  constraints: z5.record(z5.string(), JsonValueSchema).optional()
+}).strict();
+var RequestScopeSchema = z5.object({
+  contract: z5.literal("RequestScope"),
+  requestId: ContractIdentifierSchema,
+  traceId: ContractIdentifierSchema.optional(),
+  appId: ContractIdentifierSchema,
+  tenantId: ContractIdentifierSchema.optional(),
+  teamId: ContractIdentifierSchema.optional(),
+  actor: ActorRefSchema,
+  session: z5.object({
+    authType: ContractIdentifierSchema,
+    authenticated: z5.boolean(),
+    membershipVerified: z5.boolean()
+  }).strict(),
+  permissionCodes: z5.array(ContractIdentifierSchema).default([]),
+  authority: z5.array(AuthorityScopeSchema).default([]),
+  issuedAt: IsoDateTimeSchema
+}).strict();
+var ExecutionLinkSchema = z5.object({
+  contract: z5.literal("ExecutionLink"),
+  requestId: ContractIdentifierSchema,
+  traceId: ContractIdentifierSchema.optional(),
+  correlationId: ContractIdentifierSchema.optional(),
+  causationId: ContractIdentifierSchema.optional(),
+  workflowRef: EntityRefSchema.optional(),
+  runRef: EntityRefSchema,
+  taskRef: EntityRefSchema.optional(),
+  parentRunRef: EntityRefSchema.optional()
+}).strict();
+var CompletionHeaderSchema = z5.object({
+  contract: z5.literal("CompletionHeader"),
+  eventId: ContractIdentifierSchema,
+  runtimeEventId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  sequence: z5.number().int().nonnegative(),
+  execution: ExecutionLinkSchema,
+  producer: z5.object({
+    service: ContractIdentifierSchema,
+    runtime: ContractIdentifierSchema,
+    version: ContractIdentifierSchema
+  }).strict(),
+  status: z5.enum(["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"]),
+  occurredAt: IsoDateTimeSchema,
+  payloadSchemaRef: ContractIdentifierSchema.optional()
+}).strict();
+var CompletionEventSchema = z5.object({
+  header: CompletionHeaderSchema,
+  payload: JsonValueSchema.optional()
+}).strict();
+var AgentRuntimeEventSchema = z5.object({
+  contract: z5.literal("AgentRuntimeEvent"),
+  runtimeEventId: ContractIdentifierSchema,
+  streamId: ContractIdentifierSchema,
+  sequence: z5.number().int().nonnegative(),
+  requestId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  threadId: ContractIdentifierSchema.optional(),
+  eventType: z5.enum(["messages:append", "messages:update", "thread:update", "tool-call:upsert"]),
+  payload: JsonValueSchema,
+  occurredAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/continuity.ts
+import { z as z6 } from "zod";
+var DataContinuityEnvelopeSchema = z6.object({
+  contract: z6.literal("DataContinuityEnvelope"),
+  tenantId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  sourceRef: EntityRefSchema.optional(),
+  bodyRef: EntityRefSchema.optional(),
+  runRef: EntityRefSchema.optional(),
+  outputRef: EntityRefSchema.optional(),
+  artifactRef: EntityRefSchema.optional(),
+  requestId: ContractIdentifierSchema,
+  actorRef: EntityRefSchema,
+  schemaVersion: ContractVersionSchema
+}).strict().refine(
+  (value) => Boolean(value.sourceRef || value.bodyRef || value.runRef || value.outputRef || value.artifactRef),
+  "At least one continuity ref is required."
+);
+var BodyRelationRecordSchema = z6.object({
+  contract: z6.literal("BodyRelationRecord"),
+  relationId: ContractIdentifierSchema,
+  relationKind: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  objectRef: EntityRefSchema,
+  ownerRepo: ContractIdentifierSchema,
+  authorityScope: z6.enum(["tenant", "team", "global"]),
+  properties: JsonObjectSchema.default({}),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var ApplicationRunSchema = z6.object({
+  contract: z6.literal("ApplicationRun"),
+  runId: ContractIdentifierSchema,
+  definitionRef: EntityRefSchema,
+  runtimeLedgerRef: EntityRefSchema,
+  requestId: ContractIdentifierSchema,
+  actorRef: EntityRefSchema,
+  status: z6.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]),
+  inputRefs: z6.array(EntityRefSchema).default([]),
+  outputRefs: z6.array(EntityRefSchema).default([]),
+  startedAt: IsoDateTimeSchema.optional(),
+  completedAt: IsoDateTimeSchema.optional(),
+  expiresAt: IsoDateTimeSchema.optional(),
+  metadata: JsonObjectSchema.default({})
+}).strict();
+var ExpiringAccessGrantSchema = z6.object({
+  contract: z6.literal("ExpiringAccessGrant"),
+  grantId: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  resourceRef: EntityRefSchema,
+  permissions: z6.array(ContractIdentifierSchema).min(1),
+  issuedAt: IsoDateTimeSchema,
+  expiresAt: IsoDateTimeSchema,
+  revokedAt: IsoDateTimeSchema.optional()
+}).strict().refine((value) => Date.parse(value.expiresAt) > Date.parse(value.issuedAt), "expiresAt must be after issuedAt");
+
+// src/contracts/data.ts
+import { z as z7 } from "zod";
+var SourceRecordRefSchema = z7.object({
+  sourceId: ContractIdentifierSchema,
+  recordId: ContractIdentifierSchema,
+  recordVersion: z7.union([z7.number().int().nonnegative(), ContractIdentifierSchema]),
+  hash: Sha256Schema
+}).strict();
+var OntologyDefinitionSchema = z7.object({
+  contract: z7.literal("OntologyDefinition"),
+  ontologyId: ContractIdentifierSchema,
+  dataSpaceId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  bodySchemaRef: ContractIdentifierSchema,
+  authority: z7.object({
+    service: ContractIdentifierSchema,
+    storage: ContractIdentifierSchema,
+    scope: z7.enum(["tenant", "team", "user", "global"])
+  }).strict(),
+  relationKinds: z7.array(ContractIdentifierSchema).default([]),
+  metricKinds: z7.array(ContractIdentifierSchema).default([])
+}).strict();
+var ProjectionSpecSchema = z7.object({
+  contract: z7.literal("ProjectionSpec"),
+  projectionId: ContractIdentifierSchema,
+  ontologyIds: z7.array(ContractIdentifierSchema).min(1),
+  outputSchemaRef: ContractIdentifierSchema,
+  operator: z7.object({
+    kind: z7.enum(["query", "aggregate", "relationship", "search", "custom"]),
+    configuration: z7.record(z7.string(), JsonValueSchema).default({})
+  }).strict(),
+  materialization: z7.enum(["on-demand", "event-driven", "scheduled"]),
+  invalidationEvents: z7.array(ContractIdentifierSchema).default([]),
+  rebuildable: z7.literal(true),
+  lineagePolicy: z7.object({
+    sourceRecords: z7.boolean(),
+    bodyVersions: z7.boolean(),
+    runRefs: z7.boolean(),
+    actorRefs: z7.boolean()
+  }).strict()
+}).strict();
+var LineageRecordSchema = z7.object({
+  contract: z7.literal("LineageRecord"),
+  lineageId: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  sourceRecords: z7.array(SourceRecordRefSchema).default([]),
+  bodyRefs: z7.array(EntityRefSchema).default([]),
+  runRefs: z7.array(EntityRefSchema).default([]),
+  outputRefs: z7.array(EntityRefSchema).default([]),
+  artifactRefs: z7.array(EntityRefSchema).default([]),
+  actorRefs: z7.array(EntityRefSchema).default([]),
+  evidenceRefs: z7.array(EntityRefSchema).default([]),
+  recordedAt: IsoDateTimeSchema
+}).strict();
+var DomainEventSchema = z7.object({
+  contract: z7.literal("DomainEvent"),
+  eventId: ContractIdentifierSchema,
+  eventType: ContractIdentifierSchema,
+  aggregateRef: EntityRefSchema,
+  aggregateVersion: z7.number().int().nonnegative(),
+  requestId: ContractIdentifierSchema,
+  actorRef: EntityRefSchema,
+  payload: JsonValueSchema,
+  occurredAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/page.ts
+import { z as z8 } from "zod";
+var PageTypeSchema = z8.enum([
+  "page",
+  "workspace",
+  "view",
+  "record",
+  "action",
+  "overlay",
+  "agent",
+  "process",
+  "log",
+  "chat",
+  "preview",
+  "api",
+  "enhanced",
+  "agent-chat",
+  "agent-config",
+  "agent-log",
+  "design-board",
+  "global-design-board",
+  "iframe"
+]);
+var PageVisibilitySchema = z8.object({
+  authenticated: z8.boolean().default(true),
+  permissionAllOf: z8.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z8.array(ContractIdentifierSchema).default([]),
+  featureFlags: z8.array(ContractIdentifierSchema).default([]),
+  productContexts: z8.array(z8.enum(["studio", "kernel", "compute"])).min(1)
+}).strict();
+var PageRoutePathSchema = z8.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
+var requireCapabilityReference = (reference, path, context) => {
+  if (reference.kind !== "capability") {
+    context.addIssue({
+      code: "custom",
+      path: [...path, "kind"],
+      message: "Page capability references must use kind capability."
+    });
+  }
+  if (reference.version === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: [...path, "version"],
+      message: "Page capability references must pin an active capability version."
+    });
+  }
+  if (reference.ownerRepo === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: [...path, "ownerRepo"],
+      message: "Page capability references must declare their owner repository."
+    });
+  }
+};
+var PageDefinitionSchema = z8.object({
+  contract: z8.literal("PageDefinition"),
+  pageId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  title: LocalizedTextSchema,
+  pageType: PageTypeSchema,
+  ownership: z8.object({
+    teamId: ContractIdentifierSchema.optional(),
+    creatorRef: EntityRefSchema.optional(),
+    studioId: ContractIdentifierSchema.optional(),
+    builtIn: z8.boolean()
+  }).strict(),
+  record: z8.object({
+    createdTimestamp: z8.number().int().nonnegative().optional(),
+    updatedTimestamp: z8.number().int().nonnegative().optional(),
+    deleted: z8.boolean().default(false)
+  }).strict(),
+  surface: z8.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  routeId: ContractIdentifierSchema,
+  routePath: PageRoutePathSchema,
+  rendererKey: ContractIdentifierSchema,
+  capabilityRef: EntityRefSchema,
+  capabilityRefs: z8.array(EntityRefSchema).default([]),
+  workflowRef: EntityRefSchema.optional(),
+  binding: z8.object({
+    sourceRef: ContractIdentifierSchema.optional(),
+    ontologyId: ContractIdentifierSchema.optional(),
+    projectionRef: ContractIdentifierSchema.optional(),
+    stateRef: ContractIdentifierSchema.optional()
+  }).strict(),
+  access: z8.object({
+    actions: z8.array(z8.enum(["read", "write", "execute", "manage-permissions"])).default([])
+  }).strict(),
+  rendererConfig: z8.object({
+    schemaRef: ContractIdentifierSchema,
+    value: JsonObjectSchema
+  }).strict(),
+  navigation: z8.object({
+    label: LocalizedTextSchema,
+    iconRef: ContractIdentifierSchema.optional(),
+    parentPageId: ContractIdentifierSchema.optional(),
+    order: z8.number().int().optional(),
+    hidden: z8.boolean().default(false),
+    pinned: z8.boolean().default(false)
+  }).strict(),
+  visibility: PageVisibilitySchema
+}).strict().superRefine((page, context) => {
+  const capabilities = [page.capabilityRef, ...page.capabilityRefs];
+  const capabilityIdentities = /* @__PURE__ */ new Set();
+  capabilities.forEach((reference, index) => {
+    const path = index === 0 ? ["capabilityRef"] : ["capabilityRefs", index - 1];
+    requireCapabilityReference(reference, path, context);
+    const identity = `${reference.id}@${String(reference.version)}:${reference.ownerRepo ?? ""}`;
+    if (capabilityIdentities.has(identity)) {
+      context.addIssue({
+        code: "custom",
+        path,
+        message: `Duplicate page capability reference: ${identity}`
+      });
+    }
+    capabilityIdentities.add(identity);
+  });
+  if (page.workflowRef && page.workflowRef.kind !== "workflow") context.addIssue({ code: "custom", path: ["workflowRef", "kind"], message: "workflowRef must reference a workflow." });
+});
+var PageRuntimeDescriptorSchema = z8.object({
+  contract: z8.literal("PageRuntimeDescriptor"),
+  page: PageDefinitionSchema,
+  nodeId: ContractIdentifierSchema,
+  parentNodeId: ContractIdentifierSchema.optional(),
+  slot: ContractIdentifierSchema.optional(),
+  semanticRef: ContractIdentifierSchema.optional(),
+  dataContextRef: ContractIdentifierSchema.optional(),
+  providerRef: EntityRefSchema.optional(),
+  surface: z8.object({
+    frameOwner: ContractIdentifierSchema,
+    tone: ContractIdentifierSchema.optional(),
+    density: z8.enum(["compact", "default", "comfortable"]).default("default")
+  }).strict(),
+  scroll: z8.object({
+    owner: z8.enum(["page", "surface", "provider"]),
+    axis: z8.enum(["x", "y", "both", "none"]),
+    restoreKey: ContractIdentifierSchema.optional(),
+    virtualized: z8.boolean().default(false)
+  }).strict(),
+  activation: z8.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
+  lifecycle: z8.object({
+    mountPolicy: z8.enum(["always", "when-visible", "when-active"]),
+    queryPolicy: z8.enum(["always", "when-visible", "when-active", "manual"]),
+    deepLink: z8.boolean(),
+    focusReturn: z8.boolean()
+  }).strict()
+}).strict();
+var PageRouteProjectionSchema = z8.object({
+  pageId: ContractIdentifierSchema,
+  routeId: ContractIdentifierSchema,
+  path: PageRoutePathSchema
+}).strict();
+var PageNavigationProjectionSchema = z8.object({
+  pageId: ContractIdentifierSchema,
+  routeId: ContractIdentifierSchema,
+  path: PageRoutePathSchema,
+  label: LocalizedTextSchema,
+  iconRef: ContractIdentifierSchema.optional(),
+  parentPageId: ContractIdentifierSchema.optional(),
+  order: z8.number().int().optional(),
+  pinned: z8.boolean()
+}).strict();
+var PageGuardProjectionSchema = z8.object({
+  pageId: ContractIdentifierSchema,
+  authenticated: z8.boolean(),
+  permissionAllOf: z8.array(ContractIdentifierSchema),
+  permissionAnyOf: z8.array(ContractIdentifierSchema),
+  featureFlags: z8.array(ContractIdentifierSchema),
+  actions: z8.array(z8.enum(["read", "write", "execute", "manage-permissions"]))
+}).strict();
+var PageRendererProjectionSchema = z8.object({
+  pageId: ContractIdentifierSchema,
+  surface: z8.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  rendererKey: ContractIdentifierSchema,
+  capabilityRef: EntityRefSchema,
+  capabilityRefs: z8.array(EntityRefSchema),
+  providerRef: EntityRefSchema,
+  binding: PageDefinitionSchema.shape.binding,
+  rendererConfig: PageDefinitionSchema.shape.rendererConfig,
+  workflowRef: EntityRefSchema.optional()
+}).strict().superRefine((renderer, context) => {
+  requireCapabilityReference(renderer.capabilityRef, ["capabilityRef"], context);
+  renderer.capabilityRefs.forEach((reference, index) => {
+    requireCapabilityReference(reference, ["capabilityRefs", index], context);
+  });
+  if (renderer.providerRef.kind !== "view-provider") {
+    context.addIssue({
+      code: "custom",
+      path: ["providerRef", "kind"],
+      message: "Renderer providerRef must use kind view-provider."
+    });
+  }
+  if (renderer.providerRef.version === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["providerRef", "version"],
+      message: "Renderer providerRef must pin a provider version."
+    });
+  }
+  if (renderer.providerRef.ownerRepo === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["providerRef", "ownerRepo"],
+      message: "Renderer providerRef must declare its owner repository."
+    });
+  }
+});
+var duplicateProjectionIdentity = (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 PageRuntimeProjectionSchema = z8.object({
+  contract: z8.literal("PageRuntimeProjection"),
+  product: z8.enum(["studio", "kernel", "compute"]),
+  routes: z8.array(PageRouteProjectionSchema),
+  navigation: z8.array(PageNavigationProjectionSchema),
+  guards: z8.array(PageGuardProjectionSchema),
+  renderers: z8.array(PageRendererProjectionSchema)
+}).strict().superRefine((projection, context) => {
+  const tables = [
+    ["routes", projection.routes.map((value) => value.pageId)],
+    ["navigation", projection.navigation.map((value) => value.pageId)],
+    ["guards", projection.guards.map((value) => value.pageId)],
+    ["renderers", projection.renderers.map((value) => value.pageId)]
+  ];
+  for (const [table, values] of tables) {
+    const duplicate = duplicateProjectionIdentity(values, (value) => value);
+    if (duplicate) {
+      context.addIssue({ code: "custom", path: [table], message: `Duplicate ${table} pageId: ${duplicate}` });
+    }
+  }
+  for (const identity of [
+    ["routeId", duplicateProjectionIdentity(projection.routes, (route) => route.routeId)],
+    ["path", duplicateProjectionIdentity(projection.routes, (route) => route.path)]
+  ]) {
+    if (identity[1]) {
+      context.addIssue({ code: "custom", path: ["routes"], message: `Duplicate route ${identity[0]}: ${identity[1]}` });
+    }
+  }
+  const routesByPageId = new Map(projection.routes.map((route) => [route.pageId, route]));
+  const guardPageIds = new Set(projection.guards.map((guard) => guard.pageId));
+  const rendererPageIds = new Set(projection.renderers.map((renderer) => renderer.pageId));
+  for (const route of projection.routes) {
+    if (!guardPageIds.has(route.pageId)) {
+      context.addIssue({ code: "custom", path: ["guards"], message: `Missing guard projection for ${route.pageId}.` });
+    }
+    if (!rendererPageIds.has(route.pageId)) {
+      context.addIssue({ code: "custom", path: ["renderers"], message: `Missing renderer projection for ${route.pageId}.` });
+    }
+  }
+  for (const guard of projection.guards) {
+    if (!routesByPageId.has(guard.pageId)) {
+      context.addIssue({ code: "custom", path: ["guards"], message: `Guard references unknown page ${guard.pageId}.` });
+    }
+  }
+  for (const renderer of projection.renderers) {
+    if (!routesByPageId.has(renderer.pageId)) {
+      context.addIssue({ code: "custom", path: ["renderers"], message: `Renderer references unknown page ${renderer.pageId}.` });
+    }
+  }
+  for (const navigation of projection.navigation) {
+    const route = routesByPageId.get(navigation.pageId);
+    if (!route || route.routeId !== navigation.routeId || route.path !== navigation.path) {
+      context.addIssue({
+        code: "custom",
+        path: ["navigation"],
+        message: `Navigation route projection for ${navigation.pageId} does not match its route table entry.`
+      });
+    }
+  }
+});
+
+// src/contracts/semantic.ts
+import { z as z9 } from "zod";
+var ConceptRelationshipSchema = z9.object({
+  kind: ContractIdentifierSchema,
+  targetConceptId: ContractIdentifierSchema,
+  cardinality: z9.enum(["one", "optional", "many"])
+}).strict();
+var ConceptDefinitionSchema = z9.object({
+  contract: z9.literal("ConceptDefinition"),
+  conceptId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  displayName: z9.string().trim().min(1),
+  description: z9.string().optional(),
+  schemaRef: ContractIdentifierSchema,
+  ontologyId: ContractIdentifierSchema.optional(),
+  capabilityIds: z9.array(ContractIdentifierSchema).default([]),
+  commandNames: z9.array(ContractIdentifierSchema).default([]),
+  relationships: z9.array(ConceptRelationshipSchema).default([])
+}).strict();
+var DomainCommandDefinitionSchema = z9.object({
+  contract: z9.literal("DomainCommandDefinition"),
+  commandName: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  displayName: z9.string().trim().min(1),
+  description: z9.string().optional(),
+  targetKinds: z9.array(ContractIdentifierSchema).min(1),
+  inputSchemaRef: ContractIdentifierSchema,
+  outputSchemaRef: ContractIdentifierSchema.optional(),
+  requiredPermissionCodes: z9.array(ContractIdentifierSchema).default([]),
+  handlerRef: EntityRefSchema,
+  sideEffects: z9.array(z9.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+}).strict();
+var DomainCommandSchema = z9.object({
+  contract: z9.literal("DomainCommand"),
+  commandId: ContractIdentifierSchema,
+  commandName: ContractIdentifierSchema,
+  requestId: ContractIdentifierSchema,
+  traceId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  targetRef: EntityRefSchema,
+  actorRef: EntityRefSchema,
+  source: z9.object({
+    product: z9.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
+    pageId: ContractIdentifierSchema.optional(),
+    capabilityId: ContractIdentifierSchema.optional()
+  }).strict(),
+  payload: JsonObjectSchema,
+  issuedAt: IsoDateTimeSchema
+}).strict();
+var ProductDeclarationSchema = z9.object({
+  contract: z9.literal("ProductDeclaration"),
+  declarationId: ContractIdentifierSchema,
+  ownerRepo: ContractIdentifierSchema,
+  concepts: z9.array(ConceptDefinitionSchema).default([]),
+  ontologies: z9.array(OntologyDefinitionSchema).default([]),
+  projections: z9.array(ProjectionSpecSchema).default([]),
+  commands: z9.array(DomainCommandDefinitionSchema).default([]),
+  capabilities: z9.array(CapabilityManifestSchema).default([]),
+  pages: z9.array(PageDefinitionSchema).default([])
+}).strict();
+var DeclarationGraphEdgeSchema = z9.object({
+  from: EntityRefSchema,
+  to: EntityRefSchema,
+  relation: z9.enum([
+    "uses-ontology",
+    "uses-projection",
+    "uses-capability",
+    "uses-command",
+    "relates-to-concept"
+  ])
+}).strict();
+var ChangeImpactSchema = z9.object({
+  changedRef: EntityRefSchema,
+  affectedRefs: z9.array(EntityRefSchema),
+  reasons: z9.array(ContractIdentifierSchema).min(1)
+}).strict();
+var ChangeImpactGraphSchema = z9.object({
+  contract: z9.literal("ChangeImpactGraph"),
+  declarationId: ContractIdentifierSchema,
+  nodes: z9.array(EntityRefSchema),
+  edges: z9.array(DeclarationGraphEdgeSchema),
+  impacts: z9.array(ChangeImpactSchema),
+  generatedAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/tenant.ts
+import { z as z11 } from "zod";
+
+// src/contracts/theme.ts
+import { z as z10 } from "zod";
+
+// src/theme-tokens/core.ts
+import Ajv from "ajv";
+
+// src/contracts/dtcg-format.schema.json
+var dtcg_format_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://www.designtokens.org/schemas/2025.10/format.json",
+  title: "DTCG Format Schema",
+  description: "JSON Schema for the Design Tokens Community Group (DTCG) Format specification.",
+  type: "object",
+  properties: {
+    $schema: {
+      type: "string",
+      format: "uri-reference",
+      description: "URI reference to this JSON schema.",
+      $comment: "$schema is not part of the official DTCG specification."
+    },
+    $type: {
+      $ref: "https://www.designtokens.org/schemas/2025.10/format/tokenType.json"
+    },
+    $description: {
+      type: "string",
+      description: "A plain text description of the group"
+    },
+    $extensions: {
+      type: "object",
+      description: "Vendor-specific extensions"
+    },
+    $extends: {
+      oneOf: [
+        {
+          $ref: "#/definitions/curlyBraceReference"
+        },
+        {
+          $ref: "#/definitions/jsonPointerReference"
+        }
+      ],
+      description: "Reference to another group to inherit tokens and properties from"
+    },
+    $deprecated: {
+      oneOf: [
+        {
+          type: "boolean"
+        },
+        {
+          type: "string"
+        }
+      ],
+      description: "Whether this group is deprecated"
+    },
+    $root: {
+      $ref: "https://www.designtokens.org/schemas/2025.10/format/token.json"
+    }
+  },
+  patternProperties: {
+    "^[^${}.][^{}.]*$": {
+      $ref: "https://www.designtokens.org/schemas/2025.10/format/groupOrToken.json"
+    }
+  },
+  additionalProperties: false,
+  definitions: {
+    tokenOrGroupName: {
+      title: "Token or Group Name",
+      type: "string",
+      pattern: "^[^${}.][^{}.]*$",
+      description: "Valid token/group names: must not start with $ and must not contain {, }, or ."
+    },
+    curlyBraceReference: {
+      title: "Curly Brace Reference",
+      type: "string",
+      pattern: "^\\{[^${}.][^{}.]*(\\.[^${}.][^{}.]*)*\\}$",
+      description: "Curly brace reference (e.g., '{tokenName}' or '{group.nested.token}')"
+    },
+    jsonPointerReference: {
+      title: "JSON Pointer Reference",
+      type: "string",
+      pattern: "^#/",
+      format: "json-pointer-uri-fragment",
+      description: "JSON Pointer reference (RFC 6901) to a location in the document (e.g., '#/path/to/target')"
+    },
+    jsonPointerReferenceObject: {
+      title: "JSON Pointer Reference Object",
+      type: "object",
+      properties: {
+        $ref: {
+          $ref: "#/definitions/jsonPointerReference"
+        }
+      },
+      required: ["$ref"],
+      additionalProperties: false,
+      description: "Object containing a JSON Pointer reference for property-level references"
+    },
+    tokenValueReference: {
+      title: "Token Value Reference",
+      oneOf: [
+        {
+          $ref: "#/definitions/curlyBraceReference"
+        },
+        {
+          $ref: "#/definitions/jsonPointerReferenceObject"
+        }
+      ],
+      description: "A reference to a token value using either curly brace syntax or JSON Pointer syntax"
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/tokenType.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/tokenType.json",
+      title: "TokenType",
+      description: "A token type in the DTCG specification",
+      type: "string",
+      enum: [
+        "color",
+        "dimension",
+        "fontFamily",
+        "fontWeight",
+        "duration",
+        "cubicBezier",
+        "number",
+        "strokeStyle",
+        "border",
+        "transition",
+        "shadow",
+        "gradient",
+        "typography"
+      ]
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/token.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/token.json",
+      title: "Token",
+      description: "A token in the DTCG specification",
+      type: "object",
+      properties: {
+        $value: {
+          description: "The token's value - can be a direct value or a reference to another token using curly brace syntax (e.g., '{token.name}'). Mutually exclusive with $ref."
+        },
+        $type: {
+          $ref: "https://www.designtokens.org/schemas/2025.10/format/tokenType.json"
+        },
+        $ref: {
+          $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReference"
+        },
+        $description: {
+          type: "string",
+          description: "A plain text description of the token"
+        },
+        $extensions: {
+          type: "object",
+          description: "Vendor-specific extensions"
+        },
+        $deprecated: {
+          oneOf: [
+            {
+              type: "boolean"
+            },
+            {
+              type: "string"
+            }
+          ],
+          description: "Whether this token is deprecated"
+        }
+      },
+      additionalProperties: false,
+      allOf: [
+        {
+          description: "Tokens cannot define both $value and $ref; they must choose exactly one form of reference or direct value.",
+          if: {
+            required: ["$value"],
+            properties: {
+              $value: true
+            }
+          },
+          then: {
+            not: {
+              required: ["$ref"],
+              properties: {
+                $ref: true
+              }
+            }
+          },
+          else: {
+            required: ["$ref"],
+            properties: {
+              $ref: true
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "color"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/color.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "dimension"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "fontFamily"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/fontFamily.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "fontWeight"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/fontWeight.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "duration"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/duration.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "cubicBezier"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/cubicBezier.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "number"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/number.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "strokeStyle"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/strokeStyle.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "border"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/border.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "transition"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/transition.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "shadow"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/shadow.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "gradient"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/gradient.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["$type"],
+            properties: {
+              $type: {
+                const: "typography"
+              }
+            }
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/typography.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            allOf: [
+              {
+                not: {
+                  required: ["$type"]
+                }
+              },
+              {
+                required: ["$value"]
+              },
+              {
+                properties: {
+                  $value: {
+                    not: {
+                      $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                    }
+                  }
+                }
+              }
+            ]
+          },
+          then: {
+            properties: {
+              $value: {
+                oneOf: [
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/color.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/fontFamily.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/duration.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/cubicBezier.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/strokeStyle.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/border.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/transition.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/shadow.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/gradient.json"
+                  },
+                  {
+                    $ref: "https://www.designtokens.org/schemas/2025.10/format/values/typography.json"
+                  },
+                  {
+                    anyOf: [
+                      {
+                        $ref: "https://www.designtokens.org/schemas/2025.10/format/values/number.json"
+                      },
+                      {
+                        $ref: "https://www.designtokens.org/schemas/2025.10/format/values/fontWeight.json"
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          }
+        }
+      ]
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/color.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/color.json",
+      title: "Color Value",
+      description: "Value schema for color type tokens. Represents a color in a specific color space.",
+      type: "object",
+      properties: {
+        colorSpace: {
+          description: "The color space or color model used to represent the color",
+          oneOf: [
+            {
+              type: "string",
+              enum: [
+                "srgb",
+                "srgb-linear",
+                "hsl",
+                "hwb",
+                "lab",
+                "lch",
+                "oklab",
+                "oklch",
+                "display-p3",
+                "a98-rgb",
+                "prophoto-rgb",
+                "rec2020",
+                "xyz-d65",
+                "xyz-d50"
+              ]
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        components: {
+          description: "Array of color components. The number and meaning of components depend on the color space. Each component can be a number or the 'none' keyword.",
+          oneOf: [
+            {
+              type: "array"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        alpha: {
+          description: "The alpha (transparency) value of the color. 0 is fully transparent, 1 is fully opaque. If omitted, defaults to 1.",
+          oneOf: [
+            {
+              type: "number",
+              minimum: 0,
+              maximum: 1
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        hex: {
+          description: "Optional fallback value in 6-digit CSS hex color notation (e.g., '#ff00ff'). Must be 6 digits to avoid conflicts with the alpha value.",
+          $comment: "Only JSON Pointer references (not curly brace references) are allowed for hex because no string token type exists in the specification that could be referenced with curly braces.",
+          oneOf: [
+            {
+              type: "string",
+              pattern: "^#[0-9a-fA-F]{6}$"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        }
+      },
+      required: ["colorSpace", "components"],
+      additionalProperties: false,
+      definitions: {
+        zeroToOneComponent: {
+          title: "Zero to One Component",
+          description: "A color component normalized to the range [0-1] (e.g., RGB values, XYZ values)",
+          oneOf: [
+            {
+              type: "number",
+              minimum: 0,
+              maximum: 1
+            },
+            {
+              type: "string",
+              const: "none"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        hueComponent: {
+          title: "Hue Component",
+          description: "Hue angle from 0 up to (but not including) 360 degrees",
+          oneOf: [
+            {
+              type: "number",
+              minimum: 0,
+              exclusiveMaximum: 360
+            },
+            {
+              type: "string",
+              const: "none"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        percentageComponent: {
+          title: "Percentage Component",
+          description: "Percentage value from 0 to 100",
+          oneOf: [
+            {
+              type: "number",
+              minimum: 0,
+              maximum: 100
+            },
+            {
+              type: "string",
+              const: "none"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        chromaComponent: {
+          title: "Chroma Component",
+          description: "Chroma value from 0 to infinity",
+          oneOf: [
+            {
+              type: "number",
+              minimum: 0
+            },
+            {
+              type: "string",
+              const: "none"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        unboundedComponent: {
+          title: "Unbounded Component",
+          description: "A color component with no numeric bounds (e.g., A and B in LAB/OKLAB color spaces)",
+          oneOf: [
+            {
+              type: "number"
+            },
+            {
+              type: "string",
+              const: "none"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        rgbComponents: {
+          title: "RGB Components",
+          description: "Array of RGB color components [Red, Green, Blue], each normalized to the range [0-1]",
+          type: "array",
+          minItems: 3,
+          maxItems: 3,
+          items: [
+            {
+              $ref: "#/definitions/zeroToOneComponent"
+            },
+            {
+              $ref: "#/definitions/zeroToOneComponent"
+            },
+            {
+              $ref: "#/definitions/zeroToOneComponent"
+            }
+          ]
+        },
+        xyzComponents: {
+          title: "XYZ Components",
+          description: "Array of XYZ color components [X, Y, Z], each normalized to the range [0-1]",
+          type: "array",
+          minItems: 3,
+          maxItems: 3,
+          items: [
+            {
+              $ref: "#/definitions/zeroToOneComponent"
+            },
+            {
+              $ref: "#/definitions/zeroToOneComponent"
+            },
+            {
+              $ref: "#/definitions/zeroToOneComponent"
+            }
+          ]
+        }
+      },
+      allOf: [
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "srgb"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/rgbComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "srgb-linear"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/rgbComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "display-p3"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/rgbComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "a98-rgb"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/rgbComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "prophoto-rgb"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/rgbComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "rec2020"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/rgbComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "xyz-d65"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/xyzComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "xyz-d50"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                $ref: "#/definitions/xyzComponents"
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "hsl"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                type: "array",
+                minItems: 3,
+                maxItems: 3,
+                items: [
+                  {
+                    $ref: "#/definitions/hueComponent"
+                  },
+                  {
+                    $ref: "#/definitions/percentageComponent"
+                  },
+                  {
+                    $ref: "#/definitions/percentageComponent"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "hwb"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                type: "array",
+                minItems: 3,
+                maxItems: 3,
+                items: [
+                  {
+                    $ref: "#/definitions/hueComponent"
+                  },
+                  {
+                    $ref: "#/definitions/percentageComponent"
+                  },
+                  {
+                    $ref: "#/definitions/percentageComponent"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "lab"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                type: "array",
+                minItems: 3,
+                maxItems: 3,
+                items: [
+                  {
+                    $ref: "#/definitions/percentageComponent"
+                  },
+                  {
+                    $ref: "#/definitions/unboundedComponent"
+                  },
+                  {
+                    $ref: "#/definitions/unboundedComponent"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "lch"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                type: "array",
+                minItems: 3,
+                maxItems: 3,
+                items: [
+                  {
+                    $ref: "#/definitions/percentageComponent"
+                  },
+                  {
+                    $ref: "#/definitions/chromaComponent"
+                  },
+                  {
+                    $ref: "#/definitions/hueComponent"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "oklab"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                type: "array",
+                minItems: 3,
+                maxItems: 3,
+                items: [
+                  {
+                    $ref: "#/definitions/zeroToOneComponent"
+                  },
+                  {
+                    $ref: "#/definitions/unboundedComponent"
+                  },
+                  {
+                    $ref: "#/definitions/unboundedComponent"
+                  }
+                ]
+              }
+            }
+          }
+        },
+        {
+          if: {
+            properties: {
+              colorSpace: {
+                const: "oklch"
+              },
+              components: {
+                type: "array"
+              }
+            }
+          },
+          then: {
+            properties: {
+              components: {
+                type: "array",
+                minItems: 3,
+                maxItems: 3,
+                items: [
+                  {
+                    $ref: "#/definitions/zeroToOneComponent"
+                  },
+                  {
+                    $ref: "#/definitions/chromaComponent"
+                  },
+                  {
+                    $ref: "#/definitions/hueComponent"
+                  }
+                ]
+              }
+            }
+          }
+        }
+      ]
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json",
+      title: "Dimension Value",
+      description: "Value schema for dimension type tokens. Represents an amount of distance in a single dimension in the UI, such as a position, width, height, radius, or thickness.",
+      type: "object",
+      properties: {
+        value: {
+          description: "An integer or floating-point value representing the numeric value.",
+          oneOf: [
+            {
+              type: "number"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        unit: {
+          description: "Unit of distance. Supported values: 'px' (idealized pixel, equivalent to dp on Android and pt on iOS), 'rem' (multiple of system's default font size).",
+          oneOf: [
+            {
+              type: "string",
+              enum: ["px", "rem"]
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        }
+      },
+      required: ["value", "unit"],
+      additionalProperties: false
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/fontFamily.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/fontFamily.json",
+      title: "Font Family Value",
+      description: "Value schema for fontFamily type tokens. Represents a font name or an array of font names (ordered from most to least preferred).",
+      oneOf: [
+        {
+          type: "string",
+          description: "A single font name",
+          not: {
+            $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/curlyBraceReference"
+          }
+        },
+        {
+          type: "array",
+          description: "An array of font names, ordered from most to least preferred",
+          items: {
+            oneOf: [
+              {
+                type: "string",
+                not: {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/curlyBraceReference"
+                }
+              },
+              {
+                $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+              }
+            ]
+          },
+          minItems: 1
+        }
+      ]
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/fontWeight.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/fontWeight.json",
+      title: "Font Weight Value",
+      description: "Value schema for fontWeight type tokens. Represents a font weight as per the OpenType wght tag specification. Lower numbers represent lighter weights, higher numbers represent thicker weights.",
+      oneOf: [
+        {
+          type: "number",
+          description: "Numeric font weight value",
+          minimum: 1,
+          maximum: 1e3
+        },
+        {
+          type: "string",
+          description: "Pre-defined font weight string value",
+          enum: [
+            "thin",
+            "hairline",
+            "extra-light",
+            "ultra-light",
+            "light",
+            "normal",
+            "regular",
+            "book",
+            "medium",
+            "semi-bold",
+            "demi-bold",
+            "bold",
+            "extra-bold",
+            "ultra-bold",
+            "black",
+            "heavy",
+            "extra-black",
+            "ultra-black"
+          ]
+        }
+      ]
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/duration.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/duration.json",
+      title: "Duration Value",
+      description: "Value schema for duration type tokens. Represents the length of time in milliseconds an animation or animation cycle takes to complete.",
+      type: "object",
+      properties: {
+        value: {
+          description: "An integer or floating-point value representing the numeric value.",
+          oneOf: [
+            {
+              type: "number"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        unit: {
+          description: "Unit of time. Supported values: 'ms' (millisecond), 's' (second).",
+          oneOf: [
+            {
+              type: "string",
+              enum: ["ms", "s"]
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        }
+      },
+      required: ["value", "unit"],
+      additionalProperties: false
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/cubicBezier.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/cubicBezier.json",
+      title: "Cubic Bezier Value",
+      description: "Value schema for cubicBezier type tokens. Represents how the value of an animated property progresses towards completion over the duration of an animation, effectively creating visual effects such as acceleration, deceleration, and bounce.",
+      type: "array",
+      items: [
+        {
+          $ref: "#/definitions/xCoordinate"
+        },
+        {
+          $ref: "#/definitions/yCoordinate"
+        },
+        {
+          $ref: "#/definitions/xCoordinate"
+        },
+        {
+          $ref: "#/definitions/yCoordinate"
+        }
+      ],
+      additionalItems: false,
+      minItems: 4,
+      maxItems: 4,
+      definitions: {
+        xCoordinate: {
+          title: "X Coordinate",
+          description: "X coordinate of control point (must be between 0 and 1)",
+          oneOf: [
+            {
+              type: "number",
+              minimum: 0,
+              maximum: 1
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        },
+        yCoordinate: {
+          title: "Y Coordinate",
+          description: "Y coordinate of control point (can be any real number)",
+          oneOf: [
+            {
+              type: "number"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+            }
+          ]
+        }
+      }
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/number.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/number.json",
+      title: "Number Value",
+      description: "Value schema for number type tokens. Numbers can be positive, negative and have fractions. Example uses are gradient stop positions or unitless line heights.",
+      type: "number"
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/strokeStyle.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/strokeStyle.json",
+      title: "Stroke Style Value",
+      description: "Value schema for strokeStyle type tokens. Represents the style applied to lines or borders.",
+      oneOf: [
+        {
+          type: "string",
+          enum: [
+            "solid",
+            "dashed",
+            "dotted",
+            "double",
+            "groove",
+            "ridge",
+            "outset",
+            "inset"
+          ],
+          description: "Pre-defined stroke style values with the same meaning as CSS line style values"
+        },
+        {
+          type: "object",
+          properties: {
+            dashArray: {
+              description: "Array of dimension values specifying lengths of alternating dashes and gaps",
+              oneOf: [
+                {
+                  type: "array",
+                  items: {
+                    oneOf: [
+                      {
+                        $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+                      },
+                      {
+                        $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                      }
+                    ]
+                  },
+                  minItems: 1
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+                }
+              ]
+            },
+            lineCap: {
+              description: "Line cap style, same meaning as SVG stroke-linecap attribute",
+              oneOf: [
+                {
+                  type: "string",
+                  enum: ["round", "butt", "square"]
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+                }
+              ]
+            }
+          },
+          required: ["dashArray", "lineCap"],
+          additionalProperties: false
+        }
+      ]
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/border.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/border.json",
+      title: "Border Value",
+      description: "Value schema for border type tokens. Represents a border style.",
+      type: "object",
+      properties: {
+        color: {
+          description: "The color of the border",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/color.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        width: {
+          description: "The width or thickness of the border",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        style: {
+          description: "The border's style",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/strokeStyle.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        }
+      },
+      required: ["color", "width", "style"],
+      additionalProperties: false
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/transition.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/transition.json",
+      title: "Transition Value",
+      description: "Value schema for transition type tokens. Represents an animated transition between two states.",
+      type: "object",
+      properties: {
+        duration: {
+          description: "The duration of the transition",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/duration.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        delay: {
+          description: "The time to wait before the transition begins",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/duration.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        timingFunction: {
+          description: "The timing function of the transition",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/cubicBezier.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        }
+      },
+      required: ["duration", "delay", "timingFunction"],
+      additionalProperties: false
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/shadow.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/shadow.json",
+      title: "Shadow Value",
+      description: "Value schema for shadow type tokens. Represents a shadow style.",
+      oneOf: [
+        {
+          $ref: "#/definitions/shadowObject"
+        },
+        {
+          type: "array",
+          description: "Array of shadow objects and/or references to shadow tokens",
+          items: {
+            oneOf: [
+              {
+                $ref: "#/definitions/shadowObject"
+              },
+              {
+                $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+              }
+            ]
+          },
+          minItems: 1
+        }
+      ],
+      definitions: {
+        shadowObject: {
+          title: "Shadow Object",
+          type: "object",
+          properties: {
+            color: {
+              description: "The color of the shadow",
+              oneOf: [
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format/values/color.json"
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                }
+              ]
+            },
+            offsetX: {
+              description: "The horizontal offset that shadow has from the element it is applied to",
+              oneOf: [
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                }
+              ]
+            },
+            offsetY: {
+              description: "The vertical offset that shadow has from the element it is applied to",
+              oneOf: [
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                }
+              ]
+            },
+            blur: {
+              description: "The blur radius that is applied to the shadow",
+              oneOf: [
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                }
+              ]
+            },
+            spread: {
+              description: "The amount by which to expand or contract the shadow",
+              oneOf: [
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                }
+              ]
+            },
+            inset: {
+              description: "Whether this shadow is inside the containing shape (inner shadow) rather than a drop shadow (default: false)",
+              oneOf: [
+                {
+                  type: "boolean"
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReferenceObject"
+                }
+              ]
+            }
+          },
+          required: ["color", "offsetX", "offsetY", "blur", "spread"],
+          additionalProperties: false
+        }
+      }
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/gradient.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/gradient.json",
+      title: "Gradient Value",
+      description: "Value schema for gradient type tokens. Represents a color gradient.",
+      type: "array",
+      items: {
+        oneOf: [
+          {
+            $ref: "#/definitions/gradientStop"
+          },
+          {
+            $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+          }
+        ]
+      },
+      minItems: 1,
+      definitions: {
+        gradientStop: {
+          title: "Gradient Stop",
+          type: "object",
+          properties: {
+            color: {
+              description: "The color value at the stop's position on the gradient",
+              oneOf: [
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format/values/color.json"
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                }
+              ]
+            },
+            position: {
+              description: "The position of the stop along the gradient's axis (range [0, 1]). Values outside this range are clamped.",
+              oneOf: [
+                {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 1
+                },
+                {
+                  $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+                }
+              ]
+            }
+          },
+          required: ["color", "position"],
+          additionalProperties: false
+        }
+      }
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/values/typography.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/values/typography.json",
+      title: "Typography Value",
+      description: "Value schema for typography type tokens. Represents a typographic style.",
+      type: "object",
+      properties: {
+        fontFamily: {
+          description: "The typography's font",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/fontFamily.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        fontSize: {
+          description: "The size of the typography",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        fontWeight: {
+          description: "The weight of the typography",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/fontWeight.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        letterSpacing: {
+          description: "The horizontal spacing between characters",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/dimension.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        },
+        lineHeight: {
+          description: "The vertical spacing between lines of typography (interpreted as a multiplier of fontSize)",
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format/values/number.json"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/tokenValueReference"
+            }
+          ]
+        }
+      },
+      required: [
+        "fontFamily",
+        "fontSize",
+        "fontWeight",
+        "letterSpacing",
+        "lineHeight"
+      ],
+      additionalProperties: false
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/groupOrToken.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/groupOrToken.json",
+      title: "Group or Token",
+      description: "A group or a token in the DTCG specification. A token is identified by the presence of a $value property, while a group is any object without a $value property.",
+      oneOf: [
+        {
+          $ref: "https://www.designtokens.org/schemas/2025.10/format/group.json"
+        },
+        {
+          $ref: "https://www.designtokens.org/schemas/2025.10/format/token.json"
+        }
+      ]
+    },
+    "https://www.designtokens.org/schemas/2025.10/format/group.json": {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: "https://www.designtokens.org/schemas/2025.10/format/group.json",
+      title: "Group",
+      description: "A group in the DTCG specification",
+      type: "object",
+      properties: {
+        $type: {
+          $ref: "https://www.designtokens.org/schemas/2025.10/format/tokenType.json"
+        },
+        $description: {
+          type: "string",
+          description: "A plain text description of the group"
+        },
+        $extensions: {
+          type: "object",
+          description: "Vendor-specific extensions"
+        },
+        $extends: {
+          oneOf: [
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/curlyBraceReference"
+            },
+            {
+              $ref: "https://www.designtokens.org/schemas/2025.10/format.json#/definitions/jsonPointerReference"
+            }
+          ],
+          description: "Reference to another group to inherit tokens and properties from"
+        },
+        $deprecated: {
+          oneOf: [
+            {
+              type: "boolean"
+            },
+            {
+              type: "string"
+            }
+          ],
+          description: "Whether this group is deprecated"
+        },
+        $root: {
+          $ref: "https://www.designtokens.org/schemas/2025.10/format/token.json"
+        }
+      },
+      patternProperties: {
+        "^[^${}.][^{}.]*$": {
+          $ref: "https://www.designtokens.org/schemas/2025.10/format/groupOrToken.json"
+        }
+      },
+      additionalProperties: false
+    }
+  }
+};
+
+// src/theme-tokens/core.ts
+var THEME_TOKEN_TYPES = [
+  "color",
+  "dimension",
+  "fontFamily",
+  "fontWeight",
+  "duration",
+  "cubicBezier",
+  "number",
+  "strokeStyle",
+  "border",
+  "transition",
+  "shadow",
+  "gradient",
+  "typography"
+];
+var ThemeTokenValidationError = class extends TypeError {
+  constructor(message, issues = []) {
+    super(message);
+    this.name = "ThemeTokenValidationError";
+    this.issues = issues;
+  }
+};
+var schema = dtcg_format_schema_default;
+var ajv = new Ajv({
+  allErrors: true,
+  strict: false,
+  strictNumbers: true,
+  validateFormats: false
+});
+var validateDtcgDocument = ajv.compile(schema);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isToken(value) {
+  return isRecord(value) && (hasOwn(value, "$value") || hasOwn(value, "$ref"));
+}
+function isGroup(value) {
+  return isRecord(value) && !isToken(value);
+}
+function cloneJson(value) {
+  if (Array.isArray(value)) return value.map((item) => cloneJson(item));
+  if (!isRecord(value)) return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneJson(item)]));
+}
+function formatAjvIssues(errors) {
+  return (errors ?? []).map((error) => ({
+    path: error.instancePath || "/",
+    message: `${error.message ?? "is invalid"}${error.params && Object.keys(error.params).length > 0 ? ` (${JSON.stringify(error.params)})` : ""}`
+  }));
+}
+function validateThemeTokensDocumentStructure(input) {
+  if (validateDtcgDocument(input)) return [];
+  return formatAjvIssues(validateDtcgDocument.errors);
+}
+function assertThemeTokensDocumentStructure(input) {
+  const issues = validateThemeTokensDocumentStructure(input);
+  if (issues.length === 0) return;
+  const summary = issues.slice(0, 5).map((issue) => `${issue.path} ${issue.message}`).join("; ");
+  throw new ThemeTokenValidationError(`Invalid DTCG 2025.10 token document: ${summary}`, issues);
+}
+var GROUP_META_KEYS = /* @__PURE__ */ new Set(["$schema", "$type", "$description", "$deprecated", "$extensions"]);
+function mergeGroups(base, override, path, sourceMerge) {
+  const output = cloneJson(base);
+  for (const [key, value] of Object.entries(override)) {
+    if (key === "$extends") continue;
+    if (key.startsWith("$") && key !== "$root") {
+      output[key] = cloneJson(value);
+      continue;
+    }
+    if (!hasOwn(output, key)) {
+      output[key] = cloneJson(value);
+      continue;
+    }
+    const existing = output[key];
+    const existingKind = isToken(existing) ? "token" : isGroup(existing) ? "group" : "metadata";
+    const nextKind = isToken(value) ? "token" : isGroup(value) ? "group" : "metadata";
+    if (existingKind === "group" && nextKind === "group") {
+      output[key] = mergeGroups(existing, value, [...path, key], sourceMerge);
+      continue;
+    }
+    if (existingKind !== nextKind) {
+      const reason = sourceMerge ? "Token sources" : "Extended groups";
+      throw new ThemeTokenValidationError(
+        `${reason} cannot change ${[...path, key].join(".")} from ${existingKind} to ${nextKind}.`
+      );
+    }
+    output[key] = cloneJson(value);
+  }
+  return output;
+}
+function decodeJsonPointer(reference) {
+  if (!reference.startsWith("#/")) {
+    throw new ThemeTokenValidationError(`JSON Pointer reference must start with "#/": ${reference}`);
+  }
+  let decoded;
+  try {
+    decoded = decodeURIComponent(reference.slice(1));
+  } catch {
+    throw new ThemeTokenValidationError(`JSON Pointer contains invalid URI encoding: ${reference}`);
+  }
+  return decoded.slice(1).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function getAtSegments(document, segments, reference) {
+  let current = document;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      if (!/^(0|[1-9]\d*)$/.test(segment) || Number(segment) >= current.length) {
+        throw new ThemeTokenValidationError(`Unresolved JSON Pointer reference: ${reference}`);
+      }
+      current = current[Number(segment)];
+      continue;
+    }
+    if (!isRecord(current) || !hasOwn(current, segment)) {
+      throw new ThemeTokenValidationError(`Unresolved JSON Pointer reference: ${reference}`);
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function parseCurlyReference(reference) {
+  const match = reference.match(/^\{([^{}]+)\}$/);
+  return match ? match[1].split(".") : null;
+}
+function getGroupReference(document, reference) {
+  const curlyPath = parseCurlyReference(reference);
+  const path = curlyPath ?? decodeJsonPointer(reference);
+  const target = getAtSegments(document, path, reference);
+  if (!isGroup(target)) {
+    throw new ThemeTokenValidationError(`Group $extends must reference a group: ${reference}`);
+  }
+  return { group: target, key: path.join("."), path };
+}
+function materializeGroups(document) {
+  const resolveGroup = (group, path, extendsStack) => {
+    let merged = {};
+    const extension = group.$extends;
+    if (typeof extension === "string") {
+      const target = getGroupReference(document, extension);
+      if (extendsStack.includes(target.key)) {
+        throw new ThemeTokenValidationError(
+          `Circular group $extends reference: ${[...extendsStack, target.key].join(" -> ")}`
+        );
+      }
+      const base = resolveGroup(target.group, target.path, [...extendsStack, target.key]);
+      merged = mergeGroups(base, group, path, false);
+    } else {
+      merged = cloneJson(group);
+      delete merged.$extends;
+    }
+    for (const [key, value] of Object.entries(merged)) {
+      if (key.startsWith("$")) continue;
+      if (isGroup(value)) {
+        merged[key] = resolveGroup(value, [...path, key], extendsStack);
+      }
+    }
+    return merged;
+  };
+  return resolveGroup(document, [], ["$root-document"]);
+}
+function collectTokens(document) {
+  const tokens = /* @__PURE__ */ new Map();
+  const visitGroup = (group, path, inheritedType, inheritedDeprecated) => {
+    const groupType = group.$type ?? inheritedType;
+    const groupDeprecated = group.$deprecated ?? inheritedDeprecated;
+    for (const [key, value] of Object.entries(group)) {
+      if (GROUP_META_KEYS.has(key) || key === "$extends") continue;
+      const tokenPath = [...path, key].join(".");
+      if (isToken(value)) {
+        tokens.set(tokenPath, {
+          token: value,
+          inheritedType: groupType,
+          inheritedDeprecated: groupDeprecated
+        });
+      } else if (isGroup(value)) {
+        visitGroup(value, [...path, key], groupType, groupDeprecated);
+      }
+    }
+  };
+  visitGroup(document, []);
+  return tokens;
+}
+function expectedChildType(parentType, key) {
+  switch (parentType) {
+    case "border":
+      return { color: "color", width: "dimension", style: "strokeStyle" }[key];
+    case "transition":
+      return { duration: "duration", delay: "duration", timingFunction: "cubicBezier" }[key];
+    case "shadow":
+      return { color: "color", offsetX: "dimension", offsetY: "dimension", blur: "dimension", spread: "dimension" }[key];
+    case "gradient":
+      return { color: "color", position: "number" }[key];
+    case "typography":
+      return {
+        fontFamily: "fontFamily",
+        fontSize: "dimension",
+        fontWeight: "fontWeight",
+        letterSpacing: "dimension",
+        lineHeight: "number"
+      }[key];
+    case "strokeStyle":
+      return key === "dashArray" ? "dimension" : void 0;
+    case "dimension":
+    case "duration":
+      return key === "value" ? "number" : void 0;
+    case "color":
+      return key === "alpha" || key === "components" ? "number" : void 0;
+    default:
+      return void 0;
+  }
+}
+function assertResolvedValueMatchesType(type, value, path) {
+  const syntheticDocument = {
+    token: {
+      $type: type,
+      $value: value
+    }
+  };
+  const issues = validateThemeTokensDocumentStructure(syntheticDocument);
+  if (issues.length === 0) return;
+  const mapped = issues.map((issue) => ({
+    path: `${path}${issue.path.replace(/^\/token(?:\/\$value)?/, "")}`,
+    message: issue.message
+  }));
+  const summary = mapped.slice(0, 5).map((issue) => `${issue.path} ${issue.message}`).join("; ");
+  throw new ThemeTokenValidationError(`Token ${path} has an invalid ${type} value: ${summary}`, mapped);
+}
+function resolveThemeTokens(input) {
+  assertThemeTokensDocumentStructure(input);
+  const document = cloneJson(input);
+  const materializedDocument = materializeGroups(document);
+  const collected = collectTokens(materializedDocument);
+  const resolved = /* @__PURE__ */ new Map();
+  const resolvingTokens = [];
+  const resolveToken = (path) => {
+    const cached = resolved.get(path);
+    if (cached) return cached;
+    const entry = collected.get(path);
+    if (!entry) throw new ThemeTokenValidationError(`Unknown token reference: ${path}`);
+    if (resolvingTokens.includes(path)) {
+      throw new ThemeTokenValidationError(`Circular token reference: ${[...resolvingTokens, path].join(" -> ")}`);
+    }
+    resolvingTokens.push(path);
+    const token = entry.token;
+    let tokenType = token.$type ?? entry.inheritedType;
+    const inferReferenceType = (reference) => {
+      const segments = decodeJsonPointer(reference);
+      for (let length = segments.length; length > 0; length -= 1) {
+        const candidate = segments.slice(0, length).join(".");
+        if (!collected.has(candidate)) continue;
+        const owner = resolveToken(candidate);
+        if (length === segments.length || segments[length] === "$value") return owner.type;
+        return void 0;
+      }
+      return void 0;
+    };
+    if (!tokenType && typeof token.$value === "string") {
+      const aliasPath = parseCurlyReference(token.$value)?.join(".");
+      if (aliasPath) tokenType = resolveToken(aliasPath).type;
+    }
+    if (!tokenType && typeof token.$ref === "string") tokenType = inferReferenceType(token.$ref);
+    if (!tokenType) {
+      resolvingTokens.pop();
+      throw new ThemeTokenValidationError(
+        `Token ${path} has no $type, does not inherit one, and cannot infer one from its reference.`
+      );
+    }
+    const resolvingPointers = [];
+    const resolvePointer = (reference, expectedType, location) => {
+      const marker = `${path}:${reference}`;
+      if (resolvingPointers.includes(marker)) {
+        throw new ThemeTokenValidationError(
+          `Circular JSON Pointer reference at ${location}: ${[...resolvingPointers, marker].join(" -> ")}`
+        );
+      }
+      resolvingPointers.push(marker);
+      const segments = decodeJsonPointer(reference);
+      const target = getAtSegments(materializedDocument, segments, reference);
+      let result2;
+      if (isToken(target)) {
+        const targetPath = segments.join(".");
+        const targetToken = resolveToken(targetPath);
+        if (expectedType && targetToken.type !== expectedType) {
+          throw new ThemeTokenValidationError(
+            `Reference at ${location} expects ${expectedType} but ${targetPath} is ${targetToken.type}.`
+          );
+        }
+        result2 = targetToken.value;
+      } else if (isGroup(target)) {
+        throw new ThemeTokenValidationError(`JSON Pointer at ${location} references a group: ${reference}`);
+      } else {
+        result2 = resolveValue(target, expectedType, location);
+      }
+      resolvingPointers.pop();
+      return result2;
+    };
+    const resolveValue = (value2, expectedType, location, contextType = expectedType) => {
+      if (typeof value2 === "string") {
+        const alias = parseCurlyReference(value2);
+        if (!alias) return value2;
+        const aliasPath = alias.join(".");
+        const target = resolveToken(aliasPath);
+        if (expectedType && target.type !== expectedType) {
+          throw new ThemeTokenValidationError(
+            `Reference at ${location} expects ${expectedType} but ${aliasPath} is ${target.type}.`
+          );
+        }
+        return cloneJson(target.value);
+      }
+      if (Array.isArray(value2)) {
+        return value2.map((item, index) => {
+          const childType = contextType === "cubicBezier" ? "number" : contextType === "strokeStyle" ? "dimension" : void 0;
+          return resolveValue(item, childType, `${location}/${index}`, contextType);
+        });
+      }
+      if (!isRecord(value2)) return value2;
+      if (Object.keys(value2).length === 1 && typeof value2.$ref === "string") {
+        return resolvePointer(value2.$ref, expectedType, location);
+      }
+      return Object.fromEntries(Object.entries(value2).map(([key, child]) => {
+        const childType = expectedChildType(contextType, key);
+        return [key, resolveValue(child, childType, `${location}/${key}`, contextType)];
+      }));
+    };
+    let value;
+    if (typeof token.$ref === "string") {
+      value = resolvePointer(token.$ref, tokenType, path);
+    } else {
+      value = resolveValue(token.$value, tokenType, path);
+    }
+    assertResolvedValueMatchesType(tokenType, value, path);
+    const result = {
+      path,
+      type: tokenType,
+      value,
+      description: token.$description,
+      deprecated: token.$deprecated ?? entry.inheritedDeprecated,
+      extensions: token.$extensions
+    };
+    resolvingTokens.pop();
+    resolved.set(path, result);
+    return result;
+  };
+  for (const path of collected.keys()) resolveToken(path);
+  const resolvedDocument = {};
+  for (const token of resolved.values()) {
+    const segments = token.path.split(".");
+    let parent = resolvedDocument;
+    segments.forEach((segment, index) => {
+      if (index === segments.length - 1) {
+        parent[segment] = {
+          $type: token.type,
+          $value: cloneJson(token.value),
+          ...token.description !== void 0 ? { $description: token.description } : {},
+          ...token.deprecated !== void 0 ? { $deprecated: cloneJson(token.deprecated) } : {},
+          ...token.extensions !== void 0 ? { $extensions: cloneJson(token.extensions) } : {}
+        };
+        return;
+      }
+      const existing = parent[segment];
+      if (!isRecord(existing)) parent[segment] = {};
+      parent = parent[segment];
+    });
+  }
+  return {
+    document,
+    materializedDocument,
+    resolvedDocument,
+    tokens: resolved
+  };
+}
+function validateThemeTokensDocument(input) {
+  const structuralIssues = validateThemeTokensDocumentStructure(input);
+  if (structuralIssues.length > 0) return structuralIssues;
+  try {
+    resolveThemeTokens(input);
+    return [];
+  } catch (error) {
+    if (error instanceof ThemeTokenValidationError) {
+      return error.issues.length > 0 ? [...error.issues] : [{ path: "/", message: error.message }];
+    }
+    return [{ path: "/", message: error instanceof Error ? error.message : String(error) }];
+  }
+}
+var REQUIRED_SEMANTIC_COLOR_PATHS = [
+  "background",
+  "foreground",
+  "card",
+  "card-foreground",
+  "popover",
+  "popover-foreground",
+  "primary",
+  "primary-foreground",
+  "secondary",
+  "secondary-foreground",
+  "muted",
+  "muted-foreground",
+  "accent",
+  "accent-foreground",
+  "destructive",
+  "destructive-foreground",
+  "success",
+  "success-foreground",
+  "warning",
+  "warning-foreground",
+  "border",
+  "input",
+  "ring",
+  "neocard"
+];
+var MONKEYS_REQUIRED_THEME_TOKEN_PATHS = Object.freeze({
+  ...Object.fromEntries(
+    REQUIRED_SEMANTIC_COLOR_PATHS.flatMap((name) => [
+      [`semantic.color.${name}.light`, "color"],
+      [`semantic.color.${name}.dark`, "color"]
+    ])
+  ),
+  "semantic.radius.base": "dimension",
+  "semantic.spacing.global.compact": "dimension",
+  "semantic.spacing.global.default": "dimension",
+  "semantic.spacing.global.comfortable": "dimension",
+  "semantic.font.body": "fontFamily"
+});
+
+// src/contracts/theme.ts
+var ThemeTokenTypeSchema = z10.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z10.record(z10.string(), z10.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 = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+  const issues = validateThemeTokensDocumentStructure(input);
+  for (const issue of issues) {
+    context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
+  }
+});
+var ThemeTokensSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+  const issues = validateThemeTokensDocument(input);
+  for (const issue of issues) {
+    context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
+  }
+});
+var unresolvedReference = /^\{[^{}]+\}$/;
+var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) => {
+  const visit = (value, path) => {
+    if (typeof value === "string" && unresolvedReference.test(value)) {
+      context.addIssue({ code: "custom", path, message: "Resolved theme tokens cannot contain token aliases." });
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => visit(item, [...path, index]));
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    for (const [key, child] of Object.entries(value)) {
+      if (key === "$ref") context.addIssue({ code: "custom", path: [...path, key], message: "Resolved theme tokens cannot contain $ref." });
+      visit(child, [...path, key]);
+    }
+  };
+  visit(input, []);
+});
+
+// src/contracts/tenant.ts
+var DesignTokenFileSourceSchema = z11.object({
+  type: z11.literal("file"),
+  path: z11.string().trim().min(1).superRefine((source, context) => {
+    if (/^[a-z][a-z\d+.-]*:/i.test(source)) {
+      context.addIssue({
+        code: "custom",
+        message: "Design token file sources must use local file paths."
+      });
+    }
+  })
+}).strict();
+var DesignTokenUrlSourceSchema = z11.object({
+  type: z11.literal("url"),
+  url: z11.string().trim().min(1).superRefine((source, context) => {
+    if (!/^https?:\/\//i.test(source)) {
+      context.addIssue({
+        code: "custom",
+        message: "Design token URL sources must use HTTP(S)."
+      });
+    }
+  })
+}).strict();
+var DesignTokenInlineSourceSchema = z11.object({
+  type: z11.literal("inline"),
+  document: ThemeTokensSchema
+}).strict();
+var DesignTokenSourceSchema = z11.discriminatedUnion("type", [
+  DesignTokenFileSourceSchema,
+  DesignTokenUrlSourceSchema,
+  DesignTokenInlineSourceSchema
+]);
+var TenantDesignTokensConfigSchema = z11.object({
+  /** Ordered tenant overrides. The backend always applies the product default first. */
+  tokenSources: z11.array(DesignTokenSourceSchema)
+}).strict();
+var TenantAuthBindingSchema = z11.object({
+  kind: z11.literal("auth-provider"),
+  providerId: ContractIdentifierSchema,
+  policyRef: ContractIdentifierSchema.optional()
+}).strict();
+var TenantDataBindingSchema = z11.discriminatedUnion("kind", [
+  z11.object({
+    kind: z11.literal("data-provider"),
+    providerId: ContractIdentifierSchema,
+    domainRef: ContractIdentifierSchema.optional()
+  }).strict(),
+  z11.object({
+    kind: z11.literal("projection"),
+    projectionRef: ContractIdentifierSchema,
+    domainRef: ContractIdentifierSchema.optional()
+  }).strict()
+]);
+var TenantAuthBindingsSchema = z11.record(
+  ContractIdentifierSchema,
+  TenantAuthBindingSchema
+);
+var TenantDataBindingsSchema = z11.record(
+  ContractIdentifierSchema,
+  TenantDataBindingSchema
+);
+var AssetVariantsSchema = z11.object({
+  light: z11.string().optional(),
+  dark: z11.string().optional()
+}).strict();
+var ThemeHeadbarSchema = z11.object({
+  theme: z11.enum(["fixed", "card", "glassy", "ghost", "bsd-blue"]).optional(),
+  navPosition: z11.enum(["left", "center", "right"]).optional(),
+  actions: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
+  profile: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
+  showTeamQuota: z11.boolean().optional()
+}).strict();
+var KernelHeadbarSchema = z11.object({
+  theme: z11.literal("card").optional(),
+  layoutMode: z11.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z11.number().positive().optional(),
+  navPosition: z11.enum(["left", "center", "right"]).optional(),
+  brandTitle: z11.string().optional(),
+  menuRadius: z11.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+}).strict();
+var CustomIconSchema = z11.object({
+  color: z11.string().optional(),
+  url: z11.string().optional(),
+  type: z11.enum(["svg", "image"]).optional(),
+  hintTextColor: z11.string().optional()
+}).strict();
+var WorkbenchCustomerToolSchema = z11.object({
+  id: ContractIdentifierSchema,
+  label: z11.union([z11.string(), z11.record(LocaleIdentifierSchema, z11.string())]).optional(),
+  fixed: z11.boolean().optional()
+}).strict();
+var WorkbenchStudioOverrideSchema = z11.object({
+  studioName: z11.string().trim().min(1),
+  dropdownToolsDefault: z11.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z11.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z11.number().int().min(1).max(6).optional()
+}).strict();
+var TenantWorkbenchPageContextSchema = z11.object({
+  workflow: JsonObjectSchema.optional(),
+  agent: JsonObjectSchema.optional(),
+  agentId: ContractIdentifierSchema.optional(),
+  designProject: JsonObjectSchema.optional(),
+  designMetadataId: ContractIdentifierSchema.optional(),
+  iframeUrl: z11.string().trim().min(1).optional(),
+  info: z11.object({
+    displayName: LocalizedTextSchema.optional(),
+    description: LocalizedTextSchema.optional(),
+    iconUrl: z11.string().trim().min(1).optional()
+  }).strict().optional(),
+  isBuiltinPinned: z11.boolean().optional(),
+  isBuiltinReadonly: z11.boolean().optional()
+}).strict();
+var TenantWorkbenchPageEnvelopeSchema = z11.object({
+  definition: PageDefinitionSchema,
+  context: TenantWorkbenchPageContextSchema
+}).strict().superRefine(({ definition }, context) => {
+  if (definition.surface !== "view") {
+    context.addIssue({
+      code: "custom",
+      path: ["definition", "surface"],
+      message: "Tenant workbench pages must render on the view surface."
+    });
+  }
+  if (!definition.ownership.builtIn) {
+    context.addIssue({
+      code: "custom",
+      path: ["definition", "ownership", "builtIn"],
+      message: "Tenant workbench pages must be declared as built-in pages."
+    });
+  }
+  if (!definition.navigation.pinned) {
+    context.addIssue({
+      code: "custom",
+      path: ["definition", "navigation", "pinned"],
+      message: "Tenant workbench pages must be pinned in workbench navigation."
+    });
+  }
+  if (!definition.visibility.productContexts.includes("studio")) {
+    context.addIssue({
+      code: "custom",
+      path: ["definition", "visibility", "productContexts"],
+      message: "Tenant workbench pages must include the studio product context."
+    });
+  }
+});
+var TenantWorkbenchPageGroupSchema = z11.object({
+  id: ContractIdentifierSchema,
+  pageIds: z11.array(ContractIdentifierSchema),
+  displayName: LocalizedTextSchema,
+  isBuiltIn: z11.boolean(),
+  iconUrl: z11.string().optional(),
+  sortIndex: z11.number().int().nullable().optional(),
+  presetRelationId: ContractIdentifierSchema.optional(),
+  relationKey: ContractIdentifierSchema.nullable().optional(),
+  studioId: ContractIdentifierSchema.optional()
+}).strict();
+var TenantWorkbenchConfigSchema = z11.object({
+  pages: z11.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z11.array(TenantWorkbenchPageGroupSchema),
+  catalog: z11.object({ enabled: z11.boolean().optional(), defaultEntry: z11.boolean().optional() }).strict().optional(),
+  quickSwitcherMaxItems: z11.number().int().nonnegative().optional(),
+  defaultOrder: z11.object({
+    groups: z11.array(ContractIdentifierSchema),
+    pages: z11.record(ContractIdentifierSchema, z11.array(ContractIdentifierSchema))
+  }).strict().optional(),
+  customers: z11.object({
+    dropdownToolsDefault: z11.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z11.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z11.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z11.object({
+      svgUrl: z11.string().optional(),
+      coverage: z11.array(z11.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z11.number().positive().optional(),
+      sizing: z11.object({
+        mode: ContractIdentifierSchema,
+        heightRatio: z11.number().positive().optional(),
+        minHeightPx: z11.number().nonnegative().optional(),
+        maxHeightPx: z11.number().nonnegative().optional()
+      }).strict().optional(),
+      enhance: z11.object({
+        enabled: z11.boolean().optional(),
+        backgroundLumaThreshold: z11.number().min(0).max(1).optional(),
+        stroke: z11.object({
+          color: z11.string().optional(),
+          opacity: z11.number().min(0).max(1).optional(),
+          widthRatio: z11.number().nonnegative().optional(),
+          blurRatio: z11.number().nonnegative().optional(),
+          steps: z11.number().int().positive().optional()
+        }).strict().optional()
+      }).strict().optional()
+    }).strict().optional(),
+    layoutManagerEnabled: z11.boolean().optional(),
+    existingToolsDefault: z11.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z11.number().int().min(1).max(6).optional(),
+    studioOverrides: z11.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." });
+  }
+  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." });
+  }
+  pageGroups.forEach((group, groupIndex) => {
+    group.pageIds.forEach((pageId, pageIndex) => {
+      if (!pageIdSet.has(pageId)) {
+        context.addIssue({
+          code: "custom",
+          path: ["pageGroups", groupIndex, "pageIds", pageIndex],
+          message: `Tenant workbench page group references undeclared page ${pageId}.`
+        });
+      }
+    });
+  });
+});
+var LoginPageSchema = z11.object({
+  background: z11.object({ imageUrl: z11.string().optional(), gradient: z11.string().optional() }).strict().optional(),
+  logo: z11.object({
+    url: z11.string().optional(),
+    lightUrl: z11.string().optional(),
+    darkUrl: z11.string().optional(),
+    position: z11.enum(["top", "middle", "bottom"]).optional(),
+    scale: z11.number().positive().optional()
+  }).strict().optional(),
+  customCss: z11.string().optional()
+}).strict();
+var TenantApplicationConfigSchema = z11.object({
+  theme: z11.object({
+    id: z11.string().optional(),
+    name: z11.string().optional(),
+    title: z11.string().optional(),
+    favicon: AssetVariantsSchema.optional(),
+    logo: AssetVariantsSchema.optional(),
+    pwaIcon: z11.string().optional(),
+    form: z11.object({ variant: z11.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z11.object({
+      position: z11.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    }).strict().optional(),
+    icons: z11.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
+    views: z11.object({
+      form: z11.object({
+        toast: z11.object({ afterCreate: z11.boolean(), afterDelete: z11.boolean() }).strict(),
+        progress: z11.enum(["estimate", "infinite"]),
+        onlyResult: z11.boolean(),
+        tabular: z11.object({ theme: z11.enum(["default", "tentiary", "primary"]) }).strict()
+      }).strict()
+    }).strict().optional(),
+    loginPage: LoginPageSchema.optional(),
+    extraLanguageURL: z11.record(z11.string(), z11.string()).optional(),
+    hideSpaceHeader: z11.boolean().optional(),
+    showSidebarTeamSelector: z11.boolean().optional(),
+    showWorkbenchSidebar: z11.boolean().optional(),
+    workbenchViewTheme: z11.enum(["default", "bsd-blue"]).optional(),
+    defaults: z11.object({
+      showFormInImageDetail: z11.boolean().optional(),
+      darkMode: z11.enum(["light", "dark", "auto"]).optional(),
+      language: z11.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z11.boolean().optional(),
+      showLanguageToggle: z11.boolean().optional()
+    }).strict().optional(),
+    modules: z11.object({
+      monkeysSpaceSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z11.union([
+        z11.literal("*"),
+        z11.array(
+          z11.object({
+            id: ContractIdentifierSchema,
+            extraInfo: z11.boolean().optional(),
+            displayName: z11.union([z11.string(), z11.record(LocaleIdentifierSchema, z11.string())]).optional(),
+            visible: z11.boolean().optional(),
+            disabled: z11.boolean().optional(),
+            icon: z11.string().optional(),
+            showQuickSwitcher: z11.boolean().optional(),
+            showSidebar: z11.boolean().optional()
+          }).strict()
+        )
+      ]).optional(),
+      settingsSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional()
+    }).strict().optional(),
+    headbar: ThemeHeadbarSchema.optional(),
+    kernelLayout: z11.object({
+      navigationMode: z11.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z11.boolean().optional(),
+      headbar: KernelHeadbarSchema.optional()
+    }).strict().optional(),
+    paginationPosition: z11.enum(["left", "right"]).optional(),
+    ugcViewIconOnlyMode: z11.boolean().optional(),
+    workflowPreviewExecutionGrid: z11.object({
+      selectionModeDisplayType: z11.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z11.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z11.boolean().optional(),
+      displayType: z11.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z11.boolean().optional()
+    }).strict().optional(),
+    workbenchSidebarDefaultOpen: z11.boolean().optional(),
+    workbenchSidebarMoreAction: z11.boolean().optional(),
+    workbenchSidebarApart: z11.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z11.boolean().optional(),
+    workbenchSidebarViewType: z11.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z11.boolean().optional(),
+    workbenchSidebarModernMode: z11.boolean().optional(),
+    ugc: z11.object({ onItemClick: z11.boolean(), subtitle: z11.boolean().optional() }).strict().optional(),
+    uniImagePreview: z11.boolean().optional(),
+    imagePreviewStyle: z11.union([z11.literal(false), z11.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z11.boolean().optional(),
+    themeMode: z11.enum(["shadow", "border"]).optional(),
+    density: z11.enum(["compact", "default", "comfortable"]).optional(),
+    pageZoom: z11.number().positive().optional(),
+    miniMode: z11.object({ showPreviewViewExecutionResultGrid: z11.boolean() }).strict().optional(),
+    workflow: z11.object({ allowConcurrentRuns: z11.boolean() }).strict().optional(),
+    historyResult: z11.object({ display: z11.boolean() }).strict().optional(),
+    uploader: z11.object({
+      orientation: z11.enum(["vertical", "horizontal"]),
+      pasteButton: z11.boolean(),
+      statusText: z11.boolean()
+    }).strict().optional(),
+    designProjects: z11.object({
+      oneOnOne: z11.boolean(),
+      newTabOpenBoard: z11.boolean(),
+      defaultShowGrid: z11.boolean().optional(),
+      createDefaultFrame: z11.boolean(),
+      showPageMenu: z11.boolean(),
+      showMainMenu: z11.boolean(),
+      showStylePanel: z11.boolean(),
+      showToolbar: z11.boolean(),
+      toolbarPosition: z11.enum(["bottom", "left"]).optional(),
+      showContextMenu: z11.boolean(),
+      showActionsMenu: z11.boolean(),
+      showPageAndLayerSidebar: z11.boolean().optional(),
+      showBoardOperationSidebar: z11.boolean().optional(),
+      showMiniToolsToolbar: z11.boolean().optional(),
+      showRightSidebar: z11.boolean().optional(),
+      showRealtimeDrawing: z11.boolean().optional(),
+      showWorkflow: z11.boolean().optional(),
+      showVersionManager: z11.boolean().optional(),
+      showAgent: z11.boolean().optional(),
+      AgentTools: z11.array(ContractIdentifierSchema).optional()
+    }).strict().optional(),
+    workbench: TenantWorkbenchConfigSchema.optional(),
+    visionProWorkflows: z11.array(ContractIdentifierSchema).optional(),
+    initTeam: z11.boolean().optional(),
+    imageThumbnail: z11.boolean().optional(),
+    pages: z11.object({
+      allowPageKeys: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]),
+      defaultPageKey: ContractIdentifierSchema.optional()
+    }).strict().optional(),
+    agent: z11.object({
+      brandDisplayMode: z11.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+      density: z11.enum(["compact", "default", "comfortable"]).optional()
+    }).strict().optional()
+  }).strict(),
+  auth: z11.object({
+    enabled: z11.array(ContractIdentifierSchema).default([]),
+    oidc: z11.object({ buttonText: z11.string().optional(), autoSignin: z11.boolean().optional() }).strict().optional(),
+    password: z11.object({ disableAutoRegister: z11.boolean().optional() }).strict().optional(),
+    hideAuthToast: z11.boolean().optional(),
+    autoReload: z11.boolean().optional(),
+    defaultOtherTeam: z11.boolean().optional()
+  }).strict(),
+  endpoints: z11.record(ContractIdentifierSchema, z11.string()),
+  module: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]),
+  behavior: z11.object({
+    clearWorkflowFormStorageAfterUpdate: z11.boolean().optional(),
+    autoApproveOAuth: z11.boolean().optional(),
+    rememberWorkflowModelSelection: z11.boolean().optional()
+  }).strict(),
+  dataManagement: z11.object({
+    favoriteBucketId: z11.string().optional(),
+    pairedBucketId: z11.string().optional(),
+    galleryBucketId: z11.string().optional(),
+    dataBrowserDefaultBucketId: z11.string().optional(),
+    workflowResultBucketId: z11.string().optional(),
+    homeAdvertisement: z11.object({
+      bucketId: ContractIdentifierSchema,
+      viewId: ContractIdentifierSchema.optional(),
+      viewType: z11.enum(["filter", "container", "share_link"]).optional(),
+      teamId: ContractIdentifierSchema.optional(),
+      teamOnly: z11.boolean().optional(),
+      pageSize: z11.number().int().positive().optional(),
+      sortBy: z11.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z11.enum(["asc", "desc"]).optional(),
+      fieldMap: z11.record(z11.string(), z11.string()).optional(),
+      columnIds: z11.record(z11.string(), z11.string()).optional()
+    }).strict().optional(),
+    homeTrendAssistant: z11.object({
+      bucketId: ContractIdentifierSchema.optional(),
+      viewId: ContractIdentifierSchema.optional(),
+      viewInstanceId: ContractIdentifierSchema.optional(),
+      viewName: z11.string().optional(),
+      teamId: ContractIdentifierSchema.optional(),
+      designOptionsWorkflowId: ContractIdentifierSchema.optional(),
+      tep: z11.object({ baseUrl: z11.string().optional(), timeoutMs: z11.number().int().positive().optional() }).strict().optional(),
+      runtime: z11.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z11.boolean(), tepAuthorizationConfigured: z11.boolean(), tepCookieConfigured: z11.boolean() }).strict().optional()
+    }).strict().optional(),
+    sharing: z11.object({
+      silentViewLinks: z11.object({ enabled: z11.boolean().optional(), placement: z11.object({ mode: z11.enum(["sourceBucket", "bucket"]).optional(), bucketId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
+      shareAccess: z11.object({ publicLinksEnabled: z11.boolean().optional(), passwordGateEnabled: z11.boolean().optional(), passwordAccessTtlSeconds: z11.number().int().positive().optional(), defaultViewTreeDelivery: z11.enum(["manual", "auto"]).optional() }).strict().optional(),
+      shareDialog: z11.object({
+        audience: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["user", "team", "public"])).optional(), default: z11.enum(["user", "team", "public"]).optional() }).strict().optional(),
+        accessLevel: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["read", "write"])).optional(), default: z11.enum(["read", "write"]).optional() }).strict().optional(),
+        viewTreeDelivery: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["manual", "auto"])).optional(), default: z11.enum(["manual", "auto"]).optional() }).strict().optional()
+      }).strict().optional()
+    }).strict().optional()
+  }).strict().optional(),
+  compute: z11.object({
+    integrations: z11.object({
+      harbor: z11.object({ endpoint: z11.string().optional(), projectScopes: z11.array(z11.string()).optional(), authMode: z11.string().optional(), principal: z11.string().optional(), autoSync: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional(),
+      gitlab: z11.object({ baseUrl: z11.string().optional(), groupScopes: z11.array(z11.string()).optional(), tokenMode: z11.string().optional(), deployProjectPath: z11.string().optional(), deploymentReportsEnabled: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional(),
+      kubernetes: z11.object({ accessMode: z11.string().optional(), clusterAlias: z11.string().optional(), agentProjectPath: z11.string().optional(), agentName: z11.string().optional(), namespaceScopes: z11.array(z11.string()).optional(), rolloutObserverEnabled: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional()
+    }).strict().optional()
+  }).strict().optional(),
+  data: z11.object({}).strict().optional(),
+  storage: z11.object({
+    presignMode: z11.enum(["frontend", "backend", "both"]).optional(),
+    presign: z11.object({
+      expiresInSeconds: z11.number().int().positive(),
+      buckets: z11.array(
+        z11.object({
+          id: ContractIdentifierSchema,
+          provider: ContractIdentifierSchema,
+          preferredUrlPatternId: ContractIdentifierSchema,
+          urlPatterns: z11.array(
+            z11.object({
+              id: ContractIdentifierSchema,
+              type: z11.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z11.string().trim().min(1),
+              preferred: z11.boolean().optional(),
+              bucketSegment: z11.string().optional()
+            }).strict()
+          )
+        }).strict()
+      )
+    }).strict().optional()
+  }).strict().optional(),
+  monkeyData: z11.object({ baseUrl: z11.string().optional() }).strict().optional()
+}).strict();
+var TenantProductConfigSchema = z11.object({
+  contract: z11.literal("TenantProductConfig"),
+  tenantId: ContractIdentifierSchema,
+  appId: ContractIdentifierSchema,
+  environment: ContractIdentifierSchema,
+  designTokens: TenantDesignTokensConfigSchema,
+  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
+  pageRefs: z11.array(ContractIdentifierSchema).default([]),
+  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
+  authBinding: TenantAuthBindingsSchema,
+  dataBinding: TenantDataBindingsSchema,
+  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
+  warnings: z11.array(z11.string()).default([]),
+  applicationConfig: TenantApplicationConfigSchema
+}).strict();
+var TenantRuntimeConfigSchema = z11.object({
+  contract: z11.literal("TenantRuntimeConfig"),
+  tenantId: ContractIdentifierSchema,
+  appId: ContractIdentifierSchema,
+  environment: ContractIdentifierSchema,
+  designTokens: ResolvedThemeTokensSchema,
+  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
+  pageRefs: z11.array(ContractIdentifierSchema).default([]),
+  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
+  authBinding: TenantAuthBindingsSchema,
+  dataBinding: TenantDataBindingsSchema,
+  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
+  warnings: z11.array(z11.string()).default([]),
+  applicationConfig: TenantApplicationConfigSchema
+}).strict();
+
+// src/contracts/trend.ts
+import { z as z12 } from "zod";
+var RadarDecisionMetricsSchema = z12.object({
+  currentSales: z12.number().finite(),
+  forecastSales: z12.number().finite(),
+  searchHeat: z12.number().finite(),
+  socialHeat: z12.number().finite(),
+  confidence: z12.number().min(0).max(1)
+}).strict();
+var TrendSourceSchema = z12.object({
+  sourceId: ContractIdentifierSchema,
+  provider: ContractIdentifierSchema,
+  channel: z12.enum(["trend", "ecommerce", "social", "search", "internal"]),
+  collectedAt: IsoDateTimeSchema,
+  sourceUrl: z12.string().url().optional(),
+  evidenceRefs: z12.array(EntityRefSchema).default([])
+}).strict();
+var TrendIngestRunSchema = z12.object({
+  contract: z12.literal("TrendIngestRun"),
+  ingestRunId: ContractIdentifierSchema,
+  sourceId: ContractIdentifierSchema,
+  requestId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  status: z12.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
+  recordCount: z12.number().int().nonnegative(),
+  errorCount: z12.number().int().nonnegative(),
+  startedAt: IsoDateTimeSchema,
+  completedAt: IsoDateTimeSchema.optional()
+}).strict();
+var TrendSourceRecordSchema = z12.object({
+  contract: z12.literal("TrendSourceRecord"),
+  sourceRecordId: ContractIdentifierSchema,
+  source: TrendSourceSchema,
+  ingestRunRef: EntityRefSchema,
+  recordVersion: z12.number().int().positive(),
+  contentHash: Sha256Schema,
+  payload: JsonValueSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  collectedAt: IsoDateTimeSchema
+}).strict();
+var HotwordBodySchema = z12.object({
+  contract: z12.literal("HotwordBody"),
+  hotwordId: ContractIdentifierSchema,
+  label: z12.string().trim().min(1),
+  normalizedLabel: z12.string().trim().min(1),
+  categories: z12.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z12.array(TrendSourceSchema).min(1),
+  relationRefs: z12.array(EntityRefSchema).default([]),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var CommerceBodyFieldsSchema = {
+  displayName: z12.string().trim().min(1),
+  normalizedName: z12.string().trim().min(1),
+  categories: z12.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z12.array(EntityRefSchema).min(1),
+  relationRefs: z12.array(EntityRefSchema).default([]),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema
+};
+var BrandBodySchema = z12.object({
+  contract: z12.literal("BrandBody"),
+  brandId: ContractIdentifierSchema,
+  ...CommerceBodyFieldsSchema
+}).strict();
+var ProductBodySchema = z12.object({
+  contract: z12.literal("ProductBody"),
+  productId: ContractIdentifierSchema,
+  brandRef: EntityRefSchema.optional(),
+  ...CommerceBodyFieldsSchema
+}).strict();
+var TrendMetricSnapshotSchema = z12.object({
+  contract: z12.literal("TrendMetricSnapshot"),
+  snapshotId: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  observedAt: IsoDateTimeSchema,
+  metrics: z12.record(z12.string(), z12.number().finite()),
+  confidence: z12.number().min(0).max(1),
+  evidenceRefs: z12.array(EntityRefSchema).min(1)
+}).strict();
+var RadarScoreModelBodySchema = z12.object({
+  contract: z12.literal("RadarScoreModelBody"),
+  modelId: ContractIdentifierSchema,
+  version: z12.number().int().positive(),
+  weights: RadarDecisionMetricsSchema,
+  thresholds: z12.record(z12.string(), z12.number().finite()).default({}),
+  explanationRules: z12.record(z12.string(), z12.string().trim().min(1)).default({}),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var RadarScoreProjectionSchema = z12.object({
+  contract: z12.literal("RadarScoreProjection"),
+  projectionId: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  modelRef: EntityRefSchema,
+  totalScore: z12.number().finite(),
+  dimensions: RadarDecisionMetricsSchema,
+  evidenceRefs: z12.array(EntityRefSchema).min(1),
+  freshnessAt: IsoDateTimeSchema
+}).strict();
+var RadarPanoramaNodeSchema = z12.object({
+  ref: EntityRefSchema,
+  label: z12.string().trim().min(1),
+  categories: z12.array(ContractIdentifierSchema).default([]),
+  score: z12.number().finite().optional(),
+  freshnessAt: IsoDateTimeSchema.optional()
+}).strict();
+var RadarPanoramaEdgeSchema = z12.object({
+  sourceRef: EntityRefSchema,
+  targetRef: EntityRefSchema,
+  relation: ContractIdentifierSchema,
+  evidenceRefs: z12.array(EntityRefSchema).default([])
+}).strict();
+var RadarPanoramaSchema = z12.object({
+  contract: z12.literal("RadarPanorama"),
+  nodes: z12.array(RadarPanoramaNodeSchema),
+  edges: z12.array(RadarPanoramaEdgeSchema),
+  generatedAt: IsoDateTimeSchema
+}).strict();
+var BrandGeneticsProfileSchema = z12.object({
+  contract: z12.literal("BrandGeneticsProfile"),
+  brandRef: EntityRefSchema,
+  categories: z12.array(ContractIdentifierSchema).default([]),
+  signature: z12.record(ContractIdentifierSchema, z12.number().finite()),
+  relatedRefs: z12.array(EntityRefSchema).default([]),
+  evidenceRefs: z12.array(EntityRefSchema).default([]),
+  computedAt: IsoDateTimeSchema
+}).strict();
+var RadarOpportunityMatrixPointSchema = z12.object({
+  subjectRef: EntityRefSchema,
+  label: z12.string().trim().min(1),
+  x: z12.number().finite(),
+  y: z12.number().finite(),
+  score: z12.number().finite(),
+  evidenceRefs: z12.array(EntityRefSchema).default([])
+}).strict();
+var RadarOpportunityMatrixSchema = z12.object({
+  contract: z12.literal("RadarOpportunityMatrix"),
+  xMetric: z12.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  yMetric: z12.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  points: z12.array(RadarOpportunityMatrixPointSchema),
+  computedAt: IsoDateTimeSchema
+}).strict();
+var RadarQueryBodySchema = z12.object({
+  contract: z12.literal("RadarQueryBody"),
+  queryId: ContractIdentifierSchema,
+  filters: z12.record(z12.string(), JsonValueSchema).default({}),
+  sort: z12.object({
+    field: ContractIdentifierSchema,
+    direction: z12.enum(["asc", "desc"])
+  }).strict(),
+  pageSize: z12.number().int().min(1).max(200),
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var SavedRadarQuerySchema = z12.object({
+  contract: z12.literal("SavedRadarQuery"),
+  savedQueryId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  ownerRef: EntityRefSchema,
+  name: z12.string().trim().min(1),
+  queryRef: EntityRefSchema,
+  expectedVersion: z12.number().int().nonnegative(),
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var RadarSelectionSchema = z12.object({
+  contract: z12.literal("RadarSelection"),
+  selectionId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  ownerRef: EntityRefSchema,
+  subjectRefs: z12.array(EntityRefSchema),
+  status: z12.enum(["stashed", "selected", "rejected", "archived"]),
+  note: z12.string().optional(),
+  expectedVersion: z12.number().int().nonnegative(),
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var RadarAnalysisRunSchema = z12.object({
+  contract: z12.literal("RadarAnalysisRun"),
+  runId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  selectionRef: EntityRefSchema,
+  workflowRef: EntityRefSchema,
+  executionRef: EntityRefSchema.optional(),
+  designProjectRef: EntityRefSchema.optional(),
+  replayedFromRef: EntityRefSchema.optional(),
+  workflowDefinitionTeamId: ContractIdentifierSchema.optional(),
+  workflowInput: z12.record(z12.string(), JsonValueSchema).default({}),
+  createDesignProject: z12.boolean().default(true),
+  designProjectName: z12.string().trim().min(1).max(200).optional(),
+  modelRef: EntityRefSchema,
+  requestId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  status: z12.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  outputRefs: z12.array(EntityRefSchema).default([]),
+  error: z12.object({
+    code: ContractIdentifierSchema,
+    message: z12.string().trim().min(1),
+    retryable: z12.boolean()
+  }).strict().optional(),
+  startedAt: IsoDateTimeSchema.optional(),
+  completedAt: IsoDateTimeSchema.optional(),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var RadarActionRecordSchema = z12.object({
+  contract: z12.literal("RadarActionRecord"),
+  actionId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  actorRef: EntityRefSchema,
+  action: z12.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
+  targetRef: EntityRefSchema,
+  requestId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  expectedVersion: z12.number().int().nonnegative(),
+  occurredAt: IsoDateTimeSchema
+}).strict();
+var RadarWritebackRecordSchema = z12.object({
+  contract: z12.literal("RadarWritebackRecord"),
+  writebackId: ContractIdentifierSchema,
+  actionRef: EntityRefSchema,
+  targetRef: EntityRefSchema,
+  status: z12.enum(["PENDING", "APPLIED", "FAILED"]),
+  resultingVersion: z12.number().int().nonnegative().optional(),
+  error: z12.string().trim().min(1).optional(),
+  recordedAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/workflow-definition.ts
+import { z as z13 } from "zod";
+var ConductorTaskTypeSchema = z13.enum([
+  "SIMPLE",
+  "DYNAMIC",
+  "FORK_JOIN",
+  "FORK_JOIN_DYNAMIC",
+  "DECISION",
+  "SWITCH",
+  "JOIN",
+  "DO_WHILE",
+  "SUB_WORKFLOW",
+  "START_WORKFLOW",
+  "EVENT",
+  "WAIT",
+  "HUMAN",
+  "USER_DEFINED",
+  "HTTP",
+  "LAMBDA",
+  "INLINE",
+  "EXCLUSIVE_JOIN",
+  "TERMINATE",
+  "KAFKA_PUBLISH",
+  "JSON_JQ_TRANSFORM",
+  "SET_VARIABLE",
+  "CALL_MCP_TOOL",
+  "GENERATE_AUDIO",
+  "GENERATE_IMAGE",
+  "GENERATE_PDF",
+  "GENERATE_VIDEO",
+  "LIST_MCP_TOOLS",
+  "LLM_CHAT_COMPLETE",
+  "LLM_GENERATE_EMBEDDINGS",
+  "LLM_INDEX_TEXT",
+  "LLM_SEARCH_INDEX",
+  "TITUS",
+  "USER_TASK"
+]);
+var requiredTaskFields = {
+  DO_WHILE: ["inputParameters", "loopOver"],
+  EVENT: ["sink"],
+  FORK_JOIN: ["forkTasks"],
+  FORK_JOIN_DYNAMIC: ["inputParameters", "dynamicForkTasksParam", "dynamicForkTasksInputParamName"],
+  DYNAMIC: ["inputParameters"],
+  JOIN: ["joinOn"],
+  SUB_WORKFLOW: ["subWorkflowParam"],
+  SWITCH: ["inputParameters", "decisionCases", "evaluatorType", "expression"],
+  DECISION: ["inputParameters", "decisionCases"],
+  WAIT: ["inputParameters"],
+  TERMINATE: ["inputParameters"]
+};
+var ConductorTaskDefinitionSchema = z13.lazy(
+  () => z13.object({
+    name: ContractIdentifierSchema,
+    taskReferenceName: ContractIdentifierSchema,
+    type: ConductorTaskTypeSchema,
+    inputParameters: z13.record(z13.string(), JsonValueSchema).optional(),
+    startDelay: z13.number().int().nonnegative().optional(),
+    optional: z13.boolean().optional(),
+    asyncComplete: z13.boolean().optional(),
+    rateLimited: z13.boolean().optional(),
+    retryCount: z13.number().int().nonnegative().optional(),
+    taskDefinition: z13.record(z13.string(), JsonValueSchema).optional(),
+    loopCondition: z13.string().optional(),
+    loopOver: z13.array(ConductorTaskDefinitionSchema).optional(),
+    sink: z13.string().optional(),
+    forkTasks: z13.array(z13.array(ConductorTaskDefinitionSchema)).optional(),
+    joinOn: z13.array(ContractIdentifierSchema).optional(),
+    defaultExclusiveJoinTask: z13.array(ContractIdentifierSchema).optional(),
+    dynamicForkTasksParam: z13.string().optional(),
+    dynamicForkTasksInputParamName: z13.string().optional(),
+    subWorkflowParam: z13.object({
+      $ref: z13.string().optional(),
+      name: ContractIdentifierSchema,
+      version: z13.number().int().positive().optional(),
+      taskToDomain: z13.record(z13.string(), z13.string()).optional(),
+      workflowDefinition: z13.record(z13.string(), JsonValueSchema).optional()
+    }).strict().optional(),
+    decisionCases: z13.record(z13.string(), z13.array(ConductorTaskDefinitionSchema)).optional(),
+    defaultCase: z13.array(ConductorTaskDefinitionSchema).optional(),
+    evaluatorType: z13.enum(["value-param", "javascript", "graaljs"]).optional(),
+    expression: z13.string().optional(),
+    __alias: JsonValueSchema.optional(),
+    callbackFromWorker: z13.boolean().optional(),
+    caseExpression: JsonValueSchema.optional(),
+    caseValueParam: z13.string().optional(),
+    dependencies: z13.array(JsonValueSchema).optional(),
+    description: z13.string().optional(),
+    dynamicTaskNameParam: z13.string().optional(),
+    joinMode: z13.string().optional(),
+    permissive: z13.boolean().optional(),
+    joinTaskRef: ContractIdentifierSchema.optional(),
+    forkTaskRef: ContractIdentifierSchema.optional()
+  }).strict().superRefine((task, context) => {
+    for (const field of requiredTaskFields[task.type] ?? []) {
+      if (task[field] === void 0) {
+        context.addIssue({ code: "custom", path: [field], message: `${task.type} task requires ${String(field)}.` });
+      }
+    }
+    if (task.type === "DO_WHILE" && (task.inputParameters?.mode === void 0 || task.inputParameters.mode === "expression") && task.loopCondition === void 0 && task.inputParameters?.loopCondition === void 0) {
+      context.addIssue({ code: "custom", path: ["loopCondition"], message: "Expression DO_WHILE task requires loopCondition." });
+    }
+  })
+);
+var ConductorWorkflowDefinitionSchema = z13.object({
+  ownerApp: z13.string().optional(),
+  createTime: z13.number().int().nonnegative().optional(),
+  updateTime: z13.number().int().nonnegative().optional(),
+  createdBy: z13.string().optional(),
+  updatedBy: z13.string().optional(),
+  name: ContractIdentifierSchema,
+  description: z13.string().optional(),
+  version: z13.number().int().positive(),
+  tasks: z13.array(ConductorTaskDefinitionSchema),
+  inputParameters: z13.array(ContractIdentifierSchema),
+  outputParameters: z13.record(z13.string(), JsonValueSchema).optional(),
+  failureWorkflow: ContractIdentifierSchema.optional(),
+  schemaVersion: z13.number().int().positive().optional(),
+  restartable: z13.boolean().optional(),
+  workflowStatusListenerEnabled: z13.boolean().optional(),
+  ownerEmail: z13.string().email().optional(),
+  timeoutPolicy: z13.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+  timeoutSeconds: z13.number().int().nonnegative(),
+  variables: z13.record(z13.string(), JsonValueSchema).optional(),
+  inputTemplate: z13.record(z13.string(), JsonValueSchema).optional()
+}).strict();
+var WorkflowParameterTypeSchema = z13.enum([
+  "string",
+  "file",
+  "number",
+  "boolean",
+  "options",
+  "json",
+  "notice",
+  "canvas-assist"
+]);
+var WorkflowConditionalStateSchema = z13.object({
+  conditions: z13.array(
+    z13.object({
+      field: z13.string(),
+      operator: z13.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
+      value: JsonValueSchema
+    }).strict()
+  ),
+  logic: z13.enum(["AND", "OR"]).optional()
+}).strict();
+var ImageSelectMappingAppearanceSchema = z13.object({
+  columns: z13.number().int().min(1).max(4).optional(),
+  cardSize: z13.enum(["sm", "md", "lg"]).optional(),
+  imageAspectRatio: z13.enum(["square", "4:5", "3:4", "16:9"]).optional(),
+  gap: z13.enum(["sm", "md", "lg"]).optional(),
+  radius: z13.enum(["sm", "md", "lg", "xl"]).optional(),
+  borderStyle: z13.enum(["none", "soft", "strong"]).optional(),
+  borderWidth: z13.union([z13.literal(0), z13.literal(1), z13.literal(2)]).optional(),
+  enableScroll: z13.boolean().optional(),
+  maxHeight: z13.number().int().min(160).max(1200).optional(),
+  enableCollapse: z13.boolean().optional(),
+  visibleRows: z13.number().int().min(1).max(6).optional(),
+  hideLabel: z13.boolean().optional(),
+  hideDescription: z13.boolean().optional(),
+  hideValue: z13.boolean().optional()
+}).strict();
+var ComfyWorkflowPortBindingSchema = z13.object({
+  node: z13.union([z13.string(), z13.number()]),
+  key: z13.string().optional()
+}).strict();
+var WorkflowParameterTypeOptionsSchema = z13.object({
+  editor: z13.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
+  editorLanguage: z13.enum(["javaScript", "json", "python", "sql"]).optional(),
+  maxValue: z13.number().optional(),
+  minValue: z13.number().optional(),
+  max: z13.number().optional(),
+  min: z13.number().optional(),
+  multipleValues: z13.boolean().optional(),
+  numberPrecision: z13.number().nonnegative().optional(),
+  password: z13.boolean().optional(),
+  rows: z13.number().int().positive().optional(),
+  assetType: z13.string().optional(),
+  accept: z13.string().optional(),
+  maxSize: z13.number().positive().optional(),
+  fileType: z13.string().optional(),
+  aiMultiShotMainImageField: z13.string().optional(),
+  aiMultiShotWorkflowAppId: z13.string().optional(),
+  aiMultiShotWorkflowId: z13.string().optional(),
+  allowCustomInput: z13.boolean().optional(),
+  allowUploadVideo: z13.boolean().optional(),
+  aspectRatioField: z13.string().optional(),
+  assemblyValueType: z13.string().optional(),
+  autoAnalyzeDesignImage: z13.boolean().optional(),
+  autoDetectAspectRatio: z13.boolean().optional(),
+  autoIncrementId: z13.boolean().optional(),
+  comfyOptions: ComfyWorkflowPortBindingSchema.optional(),
+  comfyuiModelServerId: z13.string().optional(),
+  comfyuiModelTypeName: z13.string().optional(),
+  defaultCustomInput: JsonValueSchema.optional(),
+  descriptionAlert: z13.boolean().optional(),
+  disabled: z13.union([z13.boolean(), WorkflowConditionalStateSchema]).optional(),
+  editable: z13.union([z13.boolean(), WorkflowConditionalStateSchema]).optional(),
+  enableAiMultiShot: z13.boolean().optional(),
+  enableBooleanSwitchMode: z13.boolean().optional(),
+  enableClear: z13.boolean().optional(),
+  enableExpand: z13.boolean().optional(),
+  enableImageMask: z13.boolean().optional(),
+  enableImageOverlay: z13.boolean().optional(),
+  enablePopupEditor: z13.boolean().optional(),
+  enablePromptFontSize: z13.boolean().optional(),
+  enableReset: z13.boolean().optional(),
+  enableSelectItemIcon: z13.boolean().optional(),
+  enableSelectList: z13.boolean().optional(),
+  enableSelectSearch: z13.boolean().optional(),
+  enableSliderEnterMode: z13.boolean().optional(),
+  enableVoice: z13.boolean().optional(),
+  expandButtonText: z13.string().optional(),
+  foldUp: z13.boolean().optional(),
+  hidden: z13.boolean().optional(),
+  hideRequiredDot: z13.boolean().optional(),
+  inlineTitleWithSelect: z13.boolean().optional(),
+  knowledgeGraphButtonText: z13.string().optional(),
+  identifyAttributeCount: z13.union([z13.number().nonnegative(), z13.string().min(1), z13.object({ min: z13.number().nonnegative().optional(), max: z13.number().nonnegative().optional() }).strict()]).optional(),
+  identifyAttributes: z13.array(JsonValueSchema).optional(),
+  identifyMaxVariants: z13.number().int().nonnegative().optional(),
+  identifySourceField: z13.string().optional(),
+  imageOverlayBaseField: z13.string().optional(),
+  imageOverlayOverlayField: z13.string().optional(),
+  imageSelectMappingAppearance: ImageSelectMappingAppearanceSchema.optional(),
+  imageSelectMappingColumns: z13.number().int().min(1).max(4).optional(),
+  imageSelectMappingEnableCustomUpload: z13.boolean().optional(),
+  imageSelectMappingHideLabel: z13.boolean().optional(),
+  imageSelectMappingHideLink: z13.boolean().optional(),
+  imageSelectMappingHideMeta: z13.boolean().optional(),
+  imageSelectMappingInlineUseLargeUploadBox: z13.boolean().optional(),
+  imageSelectMappingPromptField: z13.string().optional(),
+  imageSelectMappingTabOrder: z13.enum(["template-first", "upload-first"]).optional(),
+  imageSelectMappingTabWidthMode: z13.enum(["content", "fill"]).optional(),
+  imageSelectMappingTemplatePrompt: LocalizedTextSchema.optional(),
+  imageSelectMappingTemplateTabTitle: LocalizedTextSchema.optional(),
+  imageSelectMappingUploadMode: z13.enum(["tabs", "inline"]).optional(),
+  imageSelectMappingUploadPrompt: LocalizedTextSchema.optional(),
+  imageSelectMappingUploadTabTitle: LocalizedTextSchema.optional(),
+  endpoints: z13.array(JsonValueSchema).optional(),
+  examples: z13.array(JsonValueSchema).optional(),
+  extraData: JsonValueSchema.optional(),
+  layer: JsonValueSchema.optional(),
+  map: JsonValueSchema.optional(),
+  multiline: z13.boolean().optional(),
+  options: z13.array(JsonValueSchema).optional(),
+  originalFiles: z13.array(JsonValueSchema).optional(),
+  placeholder: LocalizedTextSchema.optional(),
+  preserveSelectListOrder: z13.boolean().optional(),
+  promptDictionary: JsonValueSchema.optional(),
+  promptFontSize: z13.number().optional(),
+  promptModeToggle: JsonValueSchema.optional(),
+  requireActiveSelectFilter: z13.boolean().optional(),
+  restoreDefaultOnEmptyEnter: z13.boolean().optional(),
+  search: z13.boolean().optional(),
+  selectButtonEnableCollapse: z13.boolean().optional(),
+  selectButtonVisibleRows: z13.number().int().positive().optional(),
+  selectList: z13.array(JsonValueSchema).optional(),
+  selectListDisplayMode: z13.string().optional(),
+  selectPromptField: z13.string().optional(),
+  showAddLocalFileButton: z13.boolean().optional(),
+  singleColumn: z13.boolean().optional(),
+  singleFrameForMultiple: z13.boolean().optional(),
+  textSingleLine: z13.boolean().optional(),
+  textareaMiniHeight: z13.number().nonnegative().optional(),
+  tips: LocalizedTextSchema.optional(),
+  visibility: JsonValueSchema.optional(),
+  voiceButtonText: z13.string().optional(),
+  designAnalysisFields: z13.array(JsonValueSchema).optional(),
+  designAnalysisFillStrategy: z13.string().optional(),
+  designAnalysisMaxFields: z13.number().int().nonnegative().optional(),
+  designAnalysisType: z13.string().optional(),
+  designAnalysisFieldPrefix: z13.string().optional()
+}).strict();
+var WorkflowParameterSchema = z13.lazy(
+  () => z13.object({
+    displayName: LocalizedTextSchema,
+    name: ContractIdentifierSchema,
+    type: WorkflowParameterTypeSchema,
+    typeOptions: WorkflowParameterTypeOptionsSchema.optional(),
+    default: JsonValueSchema.optional(),
+    description: LocalizedTextSchema.optional(),
+    hint: z13.string().optional(),
+    displayOptions: z13.object({
+      hide: z13.record(z13.string(), z13.array(JsonValueSchema)).optional(),
+      show: z13.record(z13.string(), z13.array(JsonValueSchema)).optional()
+    }).strict().optional(),
+    options: z13.array(z13.union([
+      z13.object({ name: LocalizedTextSchema, value: z13.union([z13.string(), z13.number(), z13.boolean()]), action: z13.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
+      WorkflowParameterSchema,
+      z13.object({ displayName: z13.string(), name: ContractIdentifierSchema, values: z13.array(WorkflowParameterSchema) }).strict()
+    ])).optional(),
+    placeholder: LocalizedTextSchema.optional(),
+    isNodeSetting: z13.boolean().optional(),
+    noDataExpression: z13.boolean().optional(),
+    required: z13.boolean().optional(),
+    example: z13.string().optional(),
+    extractValue: z13.object({ type: z13.literal("regex"), regex: z13.string() }).strict().optional(),
+    properties: z13.array(WorkflowParameterSchema).optional(),
+    assetType: z13.string().optional(),
+    flag: z13.boolean().optional(),
+    enableExpand: z13.boolean().optional(),
+    enableVoice: z13.boolean().optional(),
+    expandButtonText: z13.string().optional(),
+    knowledgeGraphButtonText: z13.string().optional(),
+    selectListDisplayMode: z13.string().optional(),
+    voiceButtonText: z13.string().optional()
+  }).strict()
+);
+var WorkflowOutputBindingSchema = z13.object({ key: ContractIdentifierSchema, value: z13.string() }).strict();
+var WorkflowNodeSchema = z13.object({
+  id: ContractIdentifierSchema,
+  referenceName: ContractIdentifierSchema,
+  capabilityRef: ContractIdentifierSchema,
+  capabilityVersion: ContractIdentifierSchema.optional(),
+  inputBindings: z13.record(z13.string(), JsonValueSchema).default({}),
+  configuration: z13.object({ executor: z13.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 = z13.object({
+  from: ContractIdentifierSchema,
+  to: ContractIdentifierSchema,
+  outputPort: ContractIdentifierSchema.optional(),
+  inputPort: ContractIdentifierSchema.optional(),
+  condition: z13.string().optional()
+}).strict();
+var WorkflowTriggerSchema = z13.object({
+  id: ContractIdentifierSchema,
+  type: z13.enum(["manual", "schedule", "webhook", "event", "api"]),
+  enabled: z13.boolean(),
+  schedule: z13.object({ cron: z13.string().trim().min(1) }).strict().optional(),
+  webhook: z13.object({
+    path: z13.string().trim().min(1).optional(),
+    method: z13.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
+    auth: z13.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
+    basicAuth: z13.object({ username: z13.string(), password: z13.string() }).strict().optional(),
+    headerAuth: z13.object({ name: z13.string().trim().min(1), value: z13.string() }).strict().optional(),
+    responseUntil: z13.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
+  }).strict().optional(),
+  event: z13.object({
+    eventType: ContractIdentifierSchema,
+    configuration: JsonValueSchema.optional()
+  }).strict().optional()
+}).strict().superRefine((trigger, context) => {
+  if (trigger.type === "schedule" && !trigger.schedule) context.addIssue({ code: "custom", path: ["schedule"], message: "Schedule trigger requires schedule configuration." });
+  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 = z13.object({
+  taskReferenceName: ContractIdentifierSchema,
+  issueType: z13.enum(["ERROR", "WARNING"]),
+  detailReason: z13.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
+  humanMessage: z13.object({ en: z13.string(), zh: z13.string() }).strict()
+}).strict();
+var WorkflowDefinitionSchema = z13.object({
+  contract: z13.literal("WorkflowDefinition"),
+  metadata: ContractMetadataSchema.omit({ name: true, description: true, labels: true }).extend({
+    name: LocalizedTextSchema,
+    description: LocalizedTextSchema.optional(),
+    role: z13.enum(["workflow", "template"]),
+    teamId: ContractIdentifierSchema,
+    creatorRef: EntityRefSchema,
+    tags: z13.array(ContractIdentifierSchema).default([])
+  }).strict(),
+  revision: z13.object({
+    kind: z13.enum(["release", "backup"]),
+    recordVersion: z13.number().int().positive(),
+    sourceVersion: z13.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: z13.object({ iconUrl: z13.string().optional(), thumbnail: z13.string().optional() }).strict(),
+  ports: z13.object({ inputs: z13.array(ContractPortSchema).default([]), outputs: z13.array(ContractPortSchema).default([]) }).strict(),
+  parameters: z13.object({ variables: z13.array(WorkflowParameterSchema).default([]), outputs: z13.array(WorkflowOutputBindingSchema).default([]) }).strict(),
+  graph: z13.object({ nodes: z13.array(WorkflowNodeSchema), edges: z13.array(WorkflowEdgeSchema).default([]) }).strict(),
+  execution: z13.object({
+    timeoutMs: z13.number().int().positive().optional(),
+    retries: z13.number().int().nonnegative().default(0),
+    concurrencyLimit: z13.number().int().positive().optional(),
+    idempotency: z13.enum(["required", "supported", "none"]),
+    rateLimit: z13.object({ enabled: z13.boolean(), max: z13.number().int().nonnegative(), windowMs: z13.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: z13.object({
+      ownerApp: z13.string().optional(),
+      createTime: z13.number().int().nonnegative().optional(),
+      updateTime: z13.number().int().nonnegative().optional(),
+      createdBy: z13.string().optional(),
+      updatedBy: z13.string().optional(),
+      failureWorkflow: ContractIdentifierSchema.optional(),
+      schemaVersion: z13.number().int().positive().optional(),
+      restartable: z13.boolean().optional(),
+      workflowStatusListenerEnabled: z13.boolean().optional(),
+      ownerEmail: z13.string().email().optional(),
+      timeoutPolicy: z13.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+      variables: z13.record(z13.string(), JsonValueSchema).optional(),
+      inputTemplate: z13.record(z13.string(), JsonValueSchema).optional()
+    }).strict()
+  }).strict(),
+  triggers: z13.array(WorkflowTriggerSchema).default([]),
+  views: z13.array(z13.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
+  dataContracts: z13.object({ reads: z13.array(ContractIdentifierSchema).default([]), writes: z13.array(ContractIdentifierSchema).default([]), emits: z13.array(ContractIdentifierSchema).default([]) }).strict(),
+  governance: z13.object({ activated: z13.boolean(), validated: z13.boolean(), validationIssues: z13.array(WorkflowValidationIssueSchema).default([]), hidden: z13.boolean().optional() }).strict(),
+  interfaces: z13.object({
+    openai: z13.object({ enabled: z13.boolean(), modelName: z13.string().trim().min(1).optional() }).strict(),
+    shortcutRef: EntityRefSchema.optional(),
+    preferredAppId: ContractIdentifierSchema.optional()
+  }).strict().superRefine((interfaces, context) => {
+    if (interfaces.openai.enabled && !interfaces.openai.modelName) context.addIssue({ code: "custom", path: ["openai", "modelName"], message: "Enabled OpenAI interface requires modelName." });
+    if (interfaces.shortcutRef && interfaces.shortcutRef.kind !== "workflow") context.addIssue({ code: "custom", path: ["shortcutRef", "kind"], message: "shortcutRef must reference a workflow." });
+  })
+}).strict().superRefine((definition, context) => {
+  const nodeIds = new Set(definition.graph.nodes.map((node) => node.id));
+  const references = new Set(definition.graph.nodes.map((node) => node.referenceName));
+  if (nodeIds.size !== definition.graph.nodes.length) context.addIssue({ code: "custom", path: ["graph", "nodes"], message: "Workflow node ids must be unique." });
+  if (references.size !== definition.graph.nodes.length) context.addIssue({ code: "custom", path: ["graph", "nodes"], message: "Workflow node reference names must be unique." });
+  definition.graph.edges.forEach((edge, index) => {
+    if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to)) context.addIssue({ code: "custom", path: ["graph", "edges", index], message: "Workflow edges must reference existing node ids." });
+  });
+  if (definition.revision.kind === "release" && definition.metadata.version !== definition.revision.recordVersion) context.addIssue({ code: "custom", path: ["revision", "recordVersion"], message: "Release recordVersion must equal metadata.version." });
+});
+export {
+  ActorRefSchema,
+  AgentRuntimeEventSchema,
+  ApplicationHandoffEndpointSchema,
+  ApplicationHandoffSchema,
+  ApplicationRunSchema,
+  ArtifactAccessSchema,
+  ArtifactManifestSchema,
+  AuthorityScopeSchema,
+  BodyRelationRecordSchema,
+  BrandBodySchema,
+  BrandGeneticsProfileSchema,
+  CapabilityManifestSchema,
+  CapabilityProviderBindingSchema,
+  CapabilityRegistryDocumentSchema,
+  CapabilityRegistryEntrySchema,
+  CapabilityRegistrySourceSchema,
+  CapabilitySourceTypeSchema,
+  ChangeImpactGraphSchema,
+  ChangeImpactSchema,
+  CompletionEventSchema,
+  CompletionHeaderSchema,
+  ConceptDefinitionSchema,
+  ConceptRelationshipSchema,
+  ConductorTaskDefinitionSchema,
+  ConductorTaskTypeSchema,
+  ConductorWorkflowDefinitionSchema,
+  ContractIdentifierSchema,
+  ContractMetadataSchema,
+  ContractPortSchema,
+  ContractVersionSchema,
+  DataContinuityEnvelopeSchema,
+  DeclarationGraphEdgeSchema,
+  DesignTokenSourceSchema,
+  DomainCommandDefinitionSchema,
+  DomainCommandSchema,
+  DomainEventSchema,
+  EntityRefSchema,
+  ExecutionLinkSchema,
+  ExpiringAccessGrantSchema,
+  HotwordBodySchema,
+  IsoDateTimeSchema,
+  JsonObjectSchema,
+  JsonValueSchema,
+  LineageRecordSchema,
+  LocaleIdentifierSchema,
+  LocalizedTextSchema,
+  OntologyDefinitionSchema,
+  OutputRecordSchema,
+  OverlayNodeSchema,
+  OverlayZIndexLaneSchema,
+  PageDefinitionSchema,
+  PageGuardProjectionSchema,
+  PageNavigationProjectionSchema,
+  PageRendererProjectionSchema,
+  PageRoutePathSchema,
+  PageRouteProjectionSchema,
+  PageRuntimeDescriptorSchema,
+  PageRuntimeProjectionSchema,
+  PageTypeSchema,
+  PageVisibilitySchema,
+  ProductBodySchema,
+  ProductContextSchema,
+  ProductDeclarationSchema,
+  ProjectionSpecSchema,
+  RadarActionRecordSchema,
+  RadarAnalysisRunSchema,
+  RadarDecisionMetricsSchema,
+  RadarOpportunityMatrixPointSchema,
+  RadarOpportunityMatrixSchema,
+  RadarPanoramaEdgeSchema,
+  RadarPanoramaNodeSchema,
+  RadarPanoramaSchema,
+  RadarQueryBodySchema,
+  RadarScoreModelBodySchema,
+  RadarScoreProjectionSchema,
+  RadarSelectionSchema,
+  RadarWritebackRecordSchema,
+  RenderActivationSchema,
+  RenderLayoutSchema,
+  RenderLifecycleSchema,
+  RenderNodeKindSchema,
+  RenderNodeSchema,
+  RenderNodeStateSchema,
+  RenderResponsiveRuleSchema,
+  RenderScrollSchema,
+  RenderSurfaceSchema,
+  RenderTreeSchema,
+  RequestScopeSchema,
+  ResolvedThemeTokensSchema,
+  SavedRadarQuerySchema,
+  Sha256Schema,
+  SourceRecordRefSchema,
+  StorageLocatorSchema,
+  TenantApplicationConfigSchema,
+  TenantAuthBindingSchema,
+  TenantAuthBindingsSchema,
+  TenantDataBindingSchema,
+  TenantDataBindingsSchema,
+  TenantDesignTokensConfigSchema,
+  TenantProductConfigSchema,
+  TenantRuntimeConfigSchema,
+  TenantWorkbenchConfigSchema,
+  TenantWorkbenchPageContextSchema,
+  TenantWorkbenchPageEnvelopeSchema,
+  TenantWorkbenchPageGroupSchema,
+  ThemeTokenGroupSchema,
+  ThemeTokenSchema,
+  ThemeTokenTypeSchema,
+  ThemeTokensSchema,
+  TrendIngestRunSchema,
+  TrendMetricSnapshotSchema,
+  TrendSourceRecordSchema,
+  TrendSourceSchema,
+  ViewProviderDescriptorSchema,
+  WorkflowDefinitionSchema,
+  WorkflowEdgeSchema,
+  WorkflowNodeSchema,
+  WorkflowOutputBindingSchema,
+  WorkflowParameterSchema,
+  WorkflowParameterTypeSchema,
+  WorkflowTriggerSchema,
+  WorkflowValidationIssueSchema
+};
+//# sourceMappingURL=index.mjs.map