@inf-monkeys-tech/monkeys 1.1.24 → 1.1.25

package/lib/esm/chunk-4ZSCTEY6.mjs

@@ -0,0 +1,1009 @@
+import {
+  ContractIdentifierSchema,
+  ContractVersionSchema,
+  DeclarativeDiagnosticSchema,
+  EntityRefSchema,
+  IsoDateTimeSchema,
+  JsonObjectSchema,
+  JsonValueSchema,
+  LineageRecordSchema,
+  NavigationSchema,
+  PageSchema,
+  ProductSurfaceSchema,
+  RevisionRefSchema,
+  Sha256Schema,
+  TenantScopeSchema
+} from "./chunk-KRIKORSN.mjs";
+
+// src/contracts/artifact.ts
+import { z } from "zod";
+var StorageLocatorSchema = z.object({
+  provider: ContractIdentifierSchema,
+  bucket: ContractIdentifierSchema.optional(),
+  key: ContractIdentifierSchema,
+  region: ContractIdentifierSchema.optional(),
+  url: z.string().url().optional(),
+  expiresAt: IsoDateTimeSchema.optional()
+}).strict();
+var ArtifactAccessSchema = z.object({
+  tenantId: ContractIdentifierSchema.optional(),
+  teamId: ContractIdentifierSchema.optional(),
+  ownerRef: EntityRefSchema.optional(),
+  visibility: z.enum(["private", "team", "tenant", "public"])
+}).strict();
+var ArtifactManifestSchema = z.object({
+  contract: z.literal("ArtifactManifest"),
+  artifactId: ContractIdentifierSchema,
+  kind: ContractIdentifierSchema,
+  mimeType: z.string().trim().min(1),
+  byteSize: z.number().int().nonnegative().optional(),
+  sha256: Sha256Schema,
+  storage: StorageLocatorSchema,
+  sourceRef: EntityRefSchema.optional(),
+  runRef: EntityRefSchema,
+  outputRef: EntityRefSchema,
+  producer: z.object({
+    service: ContractIdentifierSchema,
+    version: ContractIdentifierSchema,
+    capabilityRef: EntityRefSchema.optional()
+  }).strict(),
+  access: ArtifactAccessSchema,
+  metadata: z.record(z.string(), JsonValueSchema).default({}),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var OutputRecordSchema = z.object({
+  contract: z.literal("OutputRecord"),
+  outputId: ContractIdentifierSchema,
+  runRef: EntityRefSchema,
+  outputPort: ContractIdentifierSchema,
+  value: JsonValueSchema.optional(),
+  artifactRefs: z.array(EntityRefSchema).default([]),
+  schemaRef: ContractIdentifierSchema.optional(),
+  createdAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/aggregate-commit.ts
+import { z as z2 } from "zod";
+var AggregateIdentifierSchema = z2.string().trim().min(1).max(128);
+var AggregateRequestIdentifierSchema = z2.string().trim().min(1).max(256);
+var AggregateMutationsLimit = 500;
+var AggregateAssetSchema = z2.object({
+  id: AggregateIdentifierSchema,
+  name: z2.string().trim().min(1).max(500),
+  asset_type: AggregateIdentifierSchema,
+  primary_content: JsonObjectSchema,
+  status: z2.string().trim().min(1).max(64).optional(),
+  creator_user_id: AggregateIdentifierSchema.optional(),
+  properties: JsonObjectSchema.optional(),
+  files: z2.array(JsonObjectSchema).max(100).optional(),
+  media: z2.string().max(4096).optional(),
+  thumbnail: z2.string().max(4096).optional(),
+  media_ref: JsonObjectSchema.optional(),
+  keywords: z2.string().max(2e3).optional(),
+  extra: JsonObjectSchema.optional(),
+  sort: z2.number().int().nonnegative().optional()
+}).strict();
+var AggregateAssetUpsertSchema = z2.object({
+  ontology_id: AggregateIdentifierSchema,
+  asset: AggregateAssetSchema,
+  tag_ids: z2.array(AggregateIdentifierSchema).max(200).optional()
+}).strict();
+var AggregateAssetDeleteSchema = z2.object({
+  ontology_id: AggregateIdentifierSchema,
+  asset_id: AggregateIdentifierSchema
+}).strict();
+var AggregateFeatureValueWriteSchema = z2.object({
+  ontology_id: AggregateIdentifierSchema,
+  asset_id: AggregateIdentifierSchema,
+  column_id: AggregateIdentifierSchema,
+  value_text: z2.string().max(1e6).nullable()
+}).strict();
+var AggregateFeatureRelationTargetSchema = z2.object({
+  ontology_id: AggregateIdentifierSchema,
+  asset_id: AggregateIdentifierSchema
+}).strict();
+var AggregateFeatureRelationReplaceSchema = z2.object({
+  ontology_id: AggregateIdentifierSchema,
+  asset_id: AggregateIdentifierSchema,
+  column_id: AggregateIdentifierSchema,
+  targets: z2.array(AggregateFeatureRelationTargetSchema).max(AggregateMutationsLimit)
+}).strict();
+var AggregateAssetRelationObjectSchema = z2.object({
+  object_kind: z2.string().trim().min(1).max(64),
+  object_id: z2.string().trim().min(1).max(256),
+  properties: JsonObjectSchema.optional()
+}).strict();
+var AggregateAssetRelationReplaceSchema = z2.object({
+  ontology_id: AggregateIdentifierSchema,
+  asset_id: AggregateIdentifierSchema,
+  relation_kind: z2.string().trim().min(1).max(64),
+  objects: z2.array(AggregateAssetRelationObjectSchema).max(AggregateMutationsLimit)
+}).strict();
+var AggregateContainerMembershipWriteSchema = z2.object({
+  ontology_id: AggregateIdentifierSchema,
+  container_view_id: AggregateIdentifierSchema,
+  asset_id: AggregateIdentifierSchema,
+  present: z2.boolean()
+}).strict();
+var AggregateCommitRequestSchema = z2.object({
+  contract: z2.literal("AggregateCommitRequest"),
+  aggregate_id: AggregateIdentifierSchema,
+  request_id: AggregateRequestIdentifierSchema,
+  idempotency_key: AggregateIdentifierSchema,
+  expected_head_commit_id: AggregateIdentifierSchema.optional(),
+  message: z2.string().trim().max(500).optional(),
+  assets: z2.array(AggregateAssetUpsertSchema).max(AggregateMutationsLimit).optional(),
+  asset_deletes: z2.array(AggregateAssetDeleteSchema).max(AggregateMutationsLimit).optional(),
+  feature_values: z2.array(AggregateFeatureValueWriteSchema).max(AggregateMutationsLimit).optional(),
+  feature_relations: z2.array(AggregateFeatureRelationReplaceSchema).max(AggregateMutationsLimit).optional(),
+  asset_relations: z2.array(AggregateAssetRelationReplaceSchema).max(AggregateMutationsLimit).optional(),
+  container_memberships: z2.array(AggregateContainerMembershipWriteSchema).max(AggregateMutationsLimit).optional()
+}).strict().superRefine((request, context) => {
+  const mutationCount = (request.assets?.length ?? 0) + (request.asset_deletes?.length ?? 0) + (request.feature_values?.length ?? 0) + (request.feature_relations?.length ?? 0) + (request.asset_relations?.length ?? 0) + (request.container_memberships?.length ?? 0);
+  if (mutationCount === 0) {
+    context.addIssue({ code: "custom", message: "at least one aggregate mutation is required" });
+  }
+});
+
+// src/contracts/context.ts
+import { z as z3 } from "zod";
+var ActorRefSchema = z3.object({
+  kind: z3.enum(["human", "agent", "service", "tenant", "public"]),
+  id: ContractIdentifierSchema.optional(),
+  userId: ContractIdentifierSchema.optional(),
+  agentId: ContractIdentifierSchema.optional(),
+  serviceId: ContractIdentifierSchema.optional()
+}).strict();
+var AuthorityScopeSchema = z3.object({
+  resource: ContractIdentifierSchema,
+  actions: z3.array(ContractIdentifierSchema).min(1),
+  constraints: z3.record(z3.string(), JsonValueSchema).optional()
+}).strict();
+var RequestScopeSchema = z3.object({
+  contract: z3.literal("RequestScope"),
+  requestId: ContractIdentifierSchema,
+  traceId: ContractIdentifierSchema.optional(),
+  appId: ContractIdentifierSchema,
+  tenantId: ContractIdentifierSchema.optional(),
+  teamId: ContractIdentifierSchema.optional(),
+  actor: ActorRefSchema,
+  session: z3.object({
+    authType: ContractIdentifierSchema,
+    authenticated: z3.boolean(),
+    membershipVerified: z3.boolean()
+  }).strict(),
+  permissionCodes: z3.array(ContractIdentifierSchema).default([]),
+  authority: z3.array(AuthorityScopeSchema).default([]),
+  issuedAt: IsoDateTimeSchema
+}).strict();
+var ExecutionLinkSchema = z3.object({
+  contract: z3.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 = z3.object({
+  contract: z3.literal("CompletionHeader"),
+  eventId: ContractIdentifierSchema,
+  runtimeEventId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  sequence: z3.number().int().nonnegative(),
+  execution: ExecutionLinkSchema,
+  producer: z3.object({
+    service: ContractIdentifierSchema,
+    runtime: ContractIdentifierSchema,
+    version: ContractIdentifierSchema
+  }).strict(),
+  status: z3.enum(["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"]),
+  occurredAt: IsoDateTimeSchema,
+  payloadSchemaRef: ContractIdentifierSchema.optional()
+}).strict();
+var CompletionEventSchema = z3.object({
+  header: CompletionHeaderSchema,
+  payload: JsonValueSchema.optional()
+}).strict();
+var AgentRuntimeEventSchema = z3.object({
+  contract: z3.literal("AgentRuntimeEvent"),
+  runtimeEventId: ContractIdentifierSchema,
+  streamId: ContractIdentifierSchema,
+  sequence: z3.number().int().nonnegative(),
+  requestId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  threadId: ContractIdentifierSchema.optional(),
+  eventType: z3.enum(["messages:append", "messages:update", "thread:update", "tool-call:upsert", "session:event"]),
+  payload: JsonValueSchema,
+  occurredAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/continuity.ts
+import { z as z4 } from "zod";
+var DataContinuityEnvelopeSchema = z4.object({
+  contract: z4.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 = z4.object({
+  contract: z4.literal("BodyRelationRecord"),
+  relationId: ContractIdentifierSchema,
+  relationKind: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  objectRef: EntityRefSchema,
+  ownerRepo: ContractIdentifierSchema,
+  authorityScope: z4.enum(["tenant", "team", "global"]),
+  properties: JsonObjectSchema.default({}),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var ApplicationRunSchema = z4.object({
+  contract: z4.literal("ApplicationRun"),
+  runId: ContractIdentifierSchema,
+  definitionRef: EntityRefSchema,
+  runtimeLedgerRef: EntityRefSchema.optional(),
+  requestId: ContractIdentifierSchema,
+  actorRef: EntityRefSchema,
+  status: z4.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]),
+  inputRefs: z4.array(EntityRefSchema).default([]),
+  outputRefs: z4.array(EntityRefSchema).default([]),
+  startedAt: IsoDateTimeSchema.optional(),
+  completedAt: IsoDateTimeSchema.optional(),
+  expiresAt: IsoDateTimeSchema.optional(),
+  metadata: JsonObjectSchema.default({})
+}).strict().superRefine((run, context) => {
+  if (run.definitionRef.kind !== "workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["definitionRef", "kind"],
+      message: "definitionRef must reference a workflow-definition."
+    });
+  }
+  if (run.runtimeLedgerRef && run.runtimeLedgerRef.kind !== "workflow-run") {
+    context.addIssue({
+      code: "custom",
+      path: ["runtimeLedgerRef", "kind"],
+      message: "runtimeLedgerRef must reference a workflow-run."
+    });
+  }
+  if ((run.status === "RUNNING" || run.status === "COMPLETED" || run.status === "CANCELLED") && !run.runtimeLedgerRef) {
+    context.addIssue({
+      code: "custom",
+      path: ["runtimeLedgerRef"],
+      message: `${run.status} ApplicationRun requires runtimeLedgerRef.`
+    });
+  }
+  if (run.status === "RUNNING" && !run.startedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["startedAt"],
+      message: "RUNNING ApplicationRun requires startedAt."
+    });
+  }
+  if (["COMPLETED", "FAILED", "CANCELLED", "EXPIRED"].includes(run.status) && !run.completedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["completedAt"],
+      message: `Terminal ApplicationRun status ${run.status} requires completedAt.`
+    });
+  }
+});
+var ExpiringAccessGrantSchema = z4.object({
+  contract: z4.literal("ExpiringAccessGrant"),
+  grantId: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  resourceRef: EntityRefSchema,
+  permissions: z4.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/declarative-document-import.ts
+import { z as z5 } from "zod";
+var sameScope = (left, right) => ["tenantRef", "dataSpaceRef", "teamRef"].every(
+  (key) => left[key]?.kind === right[key]?.kind && left[key]?.id === right[key]?.id && left[key]?.ownerRepo === right[key]?.ownerRepo
+);
+var DeclarativeImportDocumentSchema = z5.union([
+  PageSchema,
+  NavigationSchema
+]);
+var requestShape = {
+  document: DeclarativeImportDocumentSchema,
+  surface: ProductSurfaceSchema,
+  environmentId: ContractIdentifierSchema.optional()
+};
+function supportsSurface(value) {
+  return value.document.contract === "Page" ? value.document.surface === value.surface : value.document.supportedSurfaces.includes(value.surface);
+}
+var DeclarativeDocumentImportRequestSchema = z5.object(requestShape).strict().refine(supportsSurface, {
+  path: ["surface"],
+  message: "The document does not support the selected surface."
+});
+var DeclarativeDocumentImportIntentSchema = z5.object({
+  ...requestShape,
+  expectedVersion: z5.number().int().nonnegative(),
+  expectedPlanHash: Sha256Schema,
+  idempotencyKey: z5.string().trim().min(1).max(256)
+}).strict().refine(supportsSurface, {
+  path: ["surface"],
+  message: "The document does not support the selected surface."
+});
+var DeclarativeDocumentImportPlanSchema = z5.object({
+  contract: z5.literal("DeclarativeDocumentImportPlan"),
+  schemaVersion: z5.literal(1),
+  resourceKind: z5.enum(["page", "navigation"]),
+  resourceId: ContractIdentifierSchema,
+  surface: ProductSurfaceSchema,
+  sourceContentHash: Sha256Schema,
+  environmentRevisionRef: RevisionRefSchema,
+  document: DeclarativeImportDocumentSchema,
+  tenantScope: TenantScopeSchema.nullable(),
+  requiresInitialization: z5.boolean(),
+  expectedVersion: z5.number().int().nonnegative(),
+  currentContentHash: Sha256Schema.nullable(),
+  changed: z5.boolean(),
+  diagnostics: z5.array(DeclarativeDiagnosticSchema),
+  dependencyContentHash: Sha256Schema,
+  planHash: Sha256Schema
+}).strict().superRefine((value, context) => {
+  const kind = value.document.contract === "Page" ? "page" : "navigation";
+  const id = value.document.contract === "Page" ? value.document.pageId : value.document.navigationId;
+  if (kind !== value.resourceKind || id !== value.resourceId || !supportsSurface(value))
+    context.addIssue({
+      code: "custom",
+      path: ["document"],
+      message: "The plan must identify its document and supported surface."
+    });
+  if (value.requiresInitialization !== (value.tenantScope === null))
+    context.addIssue({
+      code: "custom",
+      path: ["requiresInitialization"],
+      message: "Only an uninitialized target may omit tenantScope."
+    });
+  if (value.environmentRevisionRef.kind !== "environment")
+    context.addIssue({
+      code: "custom",
+      path: ["environmentRevisionRef"],
+      message: "The import plan must pin an environment revision."
+    });
+  if (value.tenantScope && !sameScope(value.tenantScope, value.document.tenantScope))
+    context.addIssue({
+      code: "custom",
+      path: ["tenantScope"],
+      message: "The plan and bound document must belong to the same scope."
+    });
+});
+var DeclarativeDocumentImportResultSchema = z5.object({
+  action: z5.literal("import"),
+  changed: z5.boolean(),
+  plan: DeclarativeDocumentImportPlanSchema,
+  revisionRef: RevisionRefSchema
+}).strict().superRefine((value, context) => {
+  if (value.changed !== value.plan.changed || value.revisionRef.kind !== value.plan.resourceKind || value.revisionRef.id !== value.plan.resourceId || value.revisionRef.revision !== value.plan.expectedVersion + Number(value.changed) || !value.revisionRef.tenantScope || !sameScope(value.revisionRef.tenantScope, value.plan.document.tenantScope)) {
+    context.addIssue({
+      code: "custom",
+      path: ["revisionRef"],
+      message: "The import result must identify the exact saved or unchanged draft revision."
+    });
+  }
+});
+
+// src/contracts/trend.ts
+import { z as z6 } from "zod";
+var RadarDecisionMetricsSchema = z6.object({
+  currentSales: z6.number().finite(),
+  forecastSales: z6.number().finite(),
+  searchHeat: z6.number().finite(),
+  socialHeat: z6.number().finite(),
+  confidence: z6.number().min(0).max(1)
+}).strict();
+var TrendSourceSchema = z6.object({
+  sourceId: ContractIdentifierSchema,
+  provider: ContractIdentifierSchema,
+  channel: z6.enum(["trend", "ecommerce", "social", "search", "internal"]),
+  collectedAt: IsoDateTimeSchema,
+  sourceUrl: z6.string().url().optional(),
+  evidenceRefs: z6.array(EntityRefSchema).default([])
+}).strict();
+var TrendIngestRunSchema = z6.object({
+  contract: z6.literal("TrendIngestRun"),
+  ingestRunId: ContractIdentifierSchema,
+  sourceId: ContractIdentifierSchema,
+  requestId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  status: z6.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
+  recordCount: z6.number().int().nonnegative(),
+  errorCount: z6.number().int().nonnegative(),
+  startedAt: IsoDateTimeSchema,
+  completedAt: IsoDateTimeSchema.optional()
+}).strict();
+var TrendSourceRecordSchema = z6.object({
+  contract: z6.literal("TrendSourceRecord"),
+  sourceRecordId: ContractIdentifierSchema,
+  source: TrendSourceSchema,
+  ingestRunRef: EntityRefSchema,
+  recordVersion: z6.number().int().positive(),
+  contentHash: Sha256Schema,
+  payload: JsonValueSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  collectedAt: IsoDateTimeSchema
+}).strict();
+var HotwordBodySchema = z6.object({
+  contract: z6.literal("HotwordBody"),
+  hotwordId: ContractIdentifierSchema,
+  label: z6.string().trim().min(1),
+  normalizedLabel: z6.string().trim().min(1),
+  categories: z6.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z6.array(TrendSourceSchema).min(1),
+  relationRefs: z6.array(EntityRefSchema).default([]),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var CommerceBodyFieldsSchema = {
+  displayName: z6.string().trim().min(1),
+  normalizedName: z6.string().trim().min(1),
+  categories: z6.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z6.array(EntityRefSchema).min(1),
+  relationRefs: z6.array(EntityRefSchema).default([]),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema
+};
+var BrandBodySchema = z6.object({
+  contract: z6.literal("BrandBody"),
+  brandId: ContractIdentifierSchema,
+  ...CommerceBodyFieldsSchema
+}).strict();
+var ProductBodySchema = z6.object({
+  contract: z6.literal("ProductBody"),
+  productId: ContractIdentifierSchema,
+  brandRef: EntityRefSchema.optional(),
+  ...CommerceBodyFieldsSchema
+}).strict();
+var TrendMetricSnapshotSchema = z6.object({
+  contract: z6.literal("TrendMetricSnapshot"),
+  snapshotId: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  observedAt: IsoDateTimeSchema,
+  metrics: z6.record(z6.string(), z6.number().finite()),
+  confidence: z6.number().min(0).max(1),
+  evidenceRefs: z6.array(EntityRefSchema).min(1)
+}).strict();
+var RadarScoreModelBodySchema = z6.object({
+  contract: z6.literal("RadarScoreModelBody"),
+  modelId: ContractIdentifierSchema,
+  version: z6.number().int().positive(),
+  weights: RadarDecisionMetricsSchema,
+  thresholds: z6.record(z6.string(), z6.number().finite()).default({}),
+  explanationRules: z6.record(z6.string(), z6.string().trim().min(1)).default({}),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var RadarScoreProjectionSchema = z6.object({
+  contract: z6.literal("RadarScoreProjection"),
+  projectionId: ContractIdentifierSchema,
+  subjectRef: EntityRefSchema,
+  modelRef: EntityRefSchema,
+  totalScore: z6.number().finite(),
+  dimensions: RadarDecisionMetricsSchema,
+  evidenceRefs: z6.array(EntityRefSchema).min(1),
+  freshnessAt: IsoDateTimeSchema
+}).strict();
+var RadarPanoramaNodeSchema = z6.object({
+  ref: EntityRefSchema,
+  label: z6.string().trim().min(1),
+  categories: z6.array(ContractIdentifierSchema).default([]),
+  score: z6.number().finite().optional(),
+  freshnessAt: IsoDateTimeSchema.optional()
+}).strict();
+var RadarPanoramaEdgeSchema = z6.object({
+  sourceRef: EntityRefSchema,
+  targetRef: EntityRefSchema,
+  relation: ContractIdentifierSchema,
+  evidenceRefs: z6.array(EntityRefSchema).default([])
+}).strict();
+var RadarPanoramaSchema = z6.object({
+  contract: z6.literal("RadarPanorama"),
+  nodes: z6.array(RadarPanoramaNodeSchema),
+  edges: z6.array(RadarPanoramaEdgeSchema),
+  generatedAt: IsoDateTimeSchema
+}).strict();
+var BrandGeneticsProfileSchema = z6.object({
+  contract: z6.literal("BrandGeneticsProfile"),
+  brandRef: EntityRefSchema,
+  categories: z6.array(ContractIdentifierSchema).default([]),
+  signature: z6.record(ContractIdentifierSchema, z6.number().finite()),
+  relatedRefs: z6.array(EntityRefSchema).default([]),
+  evidenceRefs: z6.array(EntityRefSchema).default([]),
+  computedAt: IsoDateTimeSchema
+}).strict();
+var RadarOpportunityMatrixPointSchema = z6.object({
+  subjectRef: EntityRefSchema,
+  label: z6.string().trim().min(1),
+  x: z6.number().finite(),
+  y: z6.number().finite(),
+  score: z6.number().finite(),
+  evidenceRefs: z6.array(EntityRefSchema).default([])
+}).strict();
+var RadarOpportunityMatrixSchema = z6.object({
+  contract: z6.literal("RadarOpportunityMatrix"),
+  xMetric: z6.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  yMetric: z6.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  points: z6.array(RadarOpportunityMatrixPointSchema),
+  computedAt: IsoDateTimeSchema
+}).strict();
+var RadarQueryBodySchema = z6.object({
+  contract: z6.literal("RadarQueryBody"),
+  queryId: ContractIdentifierSchema,
+  filters: z6.record(z6.string(), JsonValueSchema).default({}),
+  sort: z6.object({
+    field: ContractIdentifierSchema,
+    direction: z6.enum(["asc", "desc"])
+  }).strict(),
+  pageSize: z6.number().int().min(1).max(200),
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var SavedRadarQuerySchema = z6.object({
+  contract: z6.literal("SavedRadarQuery"),
+  savedQueryId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  ownerRef: EntityRefSchema,
+  name: z6.string().trim().min(1),
+  queryRef: EntityRefSchema,
+  expectedVersion: z6.number().int().nonnegative(),
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var RadarSelectionSchema = z6.object({
+  contract: z6.literal("RadarSelection"),
+  selectionId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  ownerRef: EntityRefSchema,
+  subjectRefs: z6.array(EntityRefSchema),
+  status: z6.enum(["stashed", "selected", "rejected", "archived"]),
+  note: z6.string().optional(),
+  expectedVersion: z6.number().int().nonnegative(),
+  updatedAt: IsoDateTimeSchema
+}).strict();
+var versionedRefFields = {
+  id: ContractIdentifierSchema,
+  version: z6.union([z6.number().int().positive(), z6.string().trim().min(1)]).optional(),
+  ownerRepo: ContractIdentifierSchema.optional()
+};
+var TrendRadarCollectionAssetRefSchema = z6.object({
+  kind: z6.literal("asset"),
+  ...versionedRefFields
+}).strict();
+var TrendRadarCollectionSelectionRefSchema = z6.object({
+  kind: z6.literal("radar-selection"),
+  ...versionedRefFields
+}).strict();
+var TrendRadarCollectionRunRefSchema = z6.object({
+  kind: z6.literal("radar-analysis-run"),
+  ...versionedRefFields
+}).strict();
+var TrendRadarCollectionSubjectRefSchema = z6.object({
+  kind: z6.literal("hotword"),
+  ...versionedRefFields
+}).strict();
+var TrendRadarCollectionArtifactRefSchema = z6.object({
+  kind: z6.literal("artifact"),
+  ...versionedRefFields
+}).strict();
+var TrendRadarCollectionRecipeEntrySchema = z6.object({
+  subjectRef: TrendRadarCollectionSubjectRefSchema,
+  label: z6.string().trim().min(1).max(200)
+}).strict();
+var TrendRadarCollectionRecipeSchema = z6.object({
+  category: z6.array(TrendRadarCollectionRecipeEntrySchema),
+  design: z6.array(TrendRadarCollectionRecipeEntrySchema),
+  audience: z6.array(TrendRadarCollectionRecipeEntrySchema)
+}).strict().refine(
+  (recipe) => recipe.category.length + recipe.design.length + recipe.audience.length > 0,
+  "A Trend Radar collection recipe must contain at least one subject."
+);
+var TrendRadarCollectionDecisionAxisSchema = z6.object({
+  key: ContractIdentifierSchema,
+  label: z6.string().trim().min(1).max(200).optional(),
+  value: z6.number().finite()
+}).strict();
+var TrendRadarCollectionDecisionProjectionSchema = z6.object({
+  axes: z6.array(TrendRadarCollectionDecisionAxisSchema).max(32).optional(),
+  overallScore: z6.number().finite().optional(),
+  itemRank: z6.number().finite().optional(),
+  sourceRefs: z6.array(EntityRefSchema).optional(),
+  outputRefs: z6.array(EntityRefSchema).optional()
+}).strict().superRefine((projection, context) => {
+  const hasProjection = Boolean(
+    projection.axes?.length || projection.overallScore !== void 0 || projection.itemRank !== void 0 || projection.sourceRefs?.length || projection.outputRefs?.length
+  );
+  if (!hasProjection) {
+    context.addIssue({
+      code: "custom",
+      message: "A decision projection must contain canonical decision data or references."
+    });
+  }
+  const seenAxisKeys = /* @__PURE__ */ new Set();
+  projection.axes?.forEach((axis, index) => {
+    if (seenAxisKeys.has(axis.key)) {
+      context.addIssue({
+        code: "custom",
+        path: ["axes", index, "key"],
+        message: `Duplicate decision axis key: ${axis.key}`
+      });
+    }
+    seenAxisKeys.add(axis.key);
+  });
+});
+var TrendRadarCollectionArtifactProjectionSchema = z6.object({
+  artifactRef: TrendRadarCollectionArtifactRefSchema,
+  url: z6.string().url().optional(),
+  thumbnailUrl: z6.string().url().optional(),
+  mimeType: z6.string().trim().min(1).optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var TrendRadarCollectionProjectionWritebackSchema = z6.object({
+  status: z6.enum(["PENDING", "APPLIED", "FAILED"]),
+  updatedAt: IsoDateTimeSchema,
+  error: z6.object({
+    code: ContractIdentifierSchema,
+    message: z6.string().trim().min(1),
+    retryable: z6.boolean()
+  }).strict().optional()
+}).strict().superRefine((writeback, context) => {
+  if (writeback.status === "FAILED" && !writeback.error) {
+    context.addIssue({
+      code: "custom",
+      path: ["error"],
+      message: "A failed collection projection writeback must include an error."
+    });
+  }
+  if (writeback.status !== "FAILED" && writeback.error) {
+    context.addIssue({
+      code: "custom",
+      path: ["error"],
+      message: "Only a failed collection projection writeback may include an error."
+    });
+  }
+});
+var TrendRadarCollectionItemSchema = z6.object({
+  contract: z6.literal("TrendRadarCollectionItem"),
+  schemaVersion: z6.literal(1),
+  selectionRef: TrendRadarCollectionSelectionRefSchema,
+  recipe: TrendRadarCollectionRecipeSchema,
+  status: z6.enum(["SAVED", "QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  latestRunRef: TrendRadarCollectionRunRefSchema.optional(),
+  decisionProjection: TrendRadarCollectionDecisionProjectionSchema.optional(),
+  artifactProjection: TrendRadarCollectionArtifactProjectionSchema.optional(),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema,
+  generatedAt: IsoDateTimeSchema.optional()
+}).strict();
+var RadarAnalysisRunSchema = z6.object({
+  contract: z6.literal("RadarAnalysisRun"),
+  runId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  selectionRef: EntityRefSchema,
+  workflowRef: EntityRefSchema,
+  executionRef: EntityRefSchema.optional(),
+  designProjectRef: EntityRefSchema.optional(),
+  replayedFromRef: EntityRefSchema.optional(),
+  collectionAssetRef: TrendRadarCollectionAssetRefSchema.optional(),
+  collectionProjectionWriteback: TrendRadarCollectionProjectionWritebackSchema.optional(),
+  workflowDefinitionTeamId: ContractIdentifierSchema.optional(),
+  workflowInput: z6.record(z6.string(), JsonValueSchema).default({}),
+  createDesignProject: z6.boolean().default(true),
+  designProjectName: z6.string().trim().min(1).max(200).optional(),
+  modelRef: EntityRefSchema,
+  requestId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  status: z6.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  outputRefs: z6.array(EntityRefSchema).default([]),
+  error: z6.object({
+    code: ContractIdentifierSchema,
+    message: z6.string().trim().min(1),
+    retryable: z6.boolean()
+  }).strict().optional(),
+  startedAt: IsoDateTimeSchema.optional(),
+  completedAt: IsoDateTimeSchema.optional(),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var RadarAnalysisAssetSchema = z6.object({
+  artifactRef: EntityRefSchema,
+  kind: ContractIdentifierSchema,
+  mimeType: z6.string().trim().min(1).optional(),
+  url: z6.string().url(),
+  metadata: z6.record(z6.string(), JsonValueSchema).default({}),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var RadarAnalysisDetailSchema = z6.object({
+  contract: z6.literal("RadarAnalysisDetail"),
+  run: RadarAnalysisRunSchema,
+  runVersion: z6.number().int().positive(),
+  selection: RadarSelectionSchema,
+  outputs: z6.array(OutputRecordSchema),
+  assets: z6.array(RadarAnalysisAssetSchema),
+  lineage: z6.array(LineageRecordSchema)
+}).strict();
+var RadarActionRecordSchema = z6.object({
+  contract: z6.literal("RadarActionRecord"),
+  actionId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  actorRef: EntityRefSchema,
+  action: z6.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
+  targetRef: EntityRefSchema,
+  requestId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  expectedVersion: z6.number().int().nonnegative(),
+  occurredAt: IsoDateTimeSchema
+}).strict();
+var RadarWritebackRecordSchema = z6.object({
+  contract: z6.literal("RadarWritebackRecord"),
+  writebackId: ContractIdentifierSchema,
+  actionRef: EntityRefSchema,
+  targetRef: EntityRefSchema,
+  status: z6.enum(["PENDING", "APPLIED", "FAILED"]),
+  resultingVersion: z6.number().int().nonnegative().optional(),
+  error: z6.string().trim().min(1).optional(),
+  recordedAt: IsoDateTimeSchema
+}).strict();
+
+// src/contracts/workflow-runtime.ts
+import { z as z7 } from "zod";
+var WorkflowCatalogEntrySchema = z7.object({
+  contract: z7.literal("WorkflowCatalogEntry"),
+  workflowId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  creatorRef: EntityRefSchema,
+  currentDefinitionRef: EntityRefSchema,
+  lifecycle: z7.enum(["ACTIVE", "DELETED"]),
+  asset: z7.object({
+    preset: z7.boolean(),
+    marketplacePublished: z7.boolean(),
+    publishConfig: JsonObjectSchema.optional(),
+    sort: z7.number().int(),
+    forkFromRef: EntityRefSchema.optional(),
+    notAuthorized: z7.boolean()
+  }).strict(),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema,
+  deletedAt: IsoDateTimeSchema.optional()
+}).strict().superRefine((entry, context) => {
+  if (entry.creatorRef.kind !== "user" && entry.creatorRef.kind !== "service") {
+    context.addIssue({
+      code: "custom",
+      path: ["creatorRef", "kind"],
+      message: "creatorRef must reference a user or service."
+    });
+  }
+  if (entry.currentDefinitionRef.kind !== "workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["currentDefinitionRef", "kind"],
+      message: "currentDefinitionRef must reference a workflow-definition."
+    });
+  }
+  if (entry.lifecycle === "DELETED" && !entry.deletedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["deletedAt"],
+      message: "Deleted workflow catalog entries require deletedAt."
+    });
+  }
+  if (entry.lifecycle === "ACTIVE" && entry.deletedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["deletedAt"],
+      message: "Active workflow catalog entries cannot declare deletedAt."
+    });
+  }
+});
+var WorkflowPublicationSchema = z7.object({
+  contract: z7.literal("WorkflowPublication"),
+  publicationId: ContractIdentifierSchema,
+  definitionRef: EntityRefSchema,
+  runtimeDefinitionRef: EntityRefSchema,
+  sourceHash: Sha256Schema,
+  compiledHash: Sha256Schema,
+  status: z7.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
+  publisherRef: EntityRefSchema,
+  publishedAt: IsoDateTimeSchema.optional(),
+  failureReason: z7.string().trim().min(1).optional()
+}).strict().superRefine((publication, context) => {
+  if (publication.definitionRef.kind !== "workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["definitionRef", "kind"],
+      message: "definitionRef must reference a workflow-definition."
+    });
+  }
+  if (publication.runtimeDefinitionRef.kind !== "conductor-workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["runtimeDefinitionRef", "kind"],
+      message: "runtimeDefinitionRef must reference a conductor-workflow-definition."
+    });
+  }
+  if (publication.status === "PUBLISHED" && !publication.publishedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["publishedAt"],
+      message: "Published workflow publications require publishedAt."
+    });
+  }
+  if (publication.status === "FAILED" && !publication.failureReason) {
+    context.addIssue({
+      code: "custom",
+      path: ["failureReason"],
+      message: "Failed workflow publications require failureReason."
+    });
+  }
+});
+var WorkflowCompletionCommitSchema = z7.object({
+  contract: z7.literal("WorkflowCompletionCommit"),
+  commitId: ContractIdentifierSchema,
+  run: ApplicationRunSchema,
+  outputs: z7.array(OutputRecordSchema),
+  artifacts: z7.array(ArtifactManifestSchema),
+  lineage: LineageRecordSchema,
+  completedAt: IsoDateTimeSchema
+}).strict().superRefine((commit, context) => {
+  const expectedRunId = commit.run.runId;
+  const referencesRun = (value) => value.runRef.kind === "application-run" && value.runRef.id === expectedRunId;
+  commit.outputs.forEach((output, index) => {
+    if (!referencesRun(output)) {
+      context.addIssue({
+        code: "custom",
+        path: ["outputs", index, "runRef"],
+        message: "Every output must reference the committed ApplicationRun."
+      });
+    }
+  });
+  commit.artifacts.forEach((artifact, index) => {
+    if (!referencesRun(artifact)) {
+      context.addIssue({
+        code: "custom",
+        path: ["artifacts", index, "runRef"],
+        message: "Every artifact must reference the committed ApplicationRun."
+      });
+    }
+  });
+  if (commit.lineage.subjectRef.kind !== "application-run" || commit.lineage.subjectRef.id !== expectedRunId) {
+    context.addIssue({
+      code: "custom",
+      path: ["lineage", "subjectRef"],
+      message: "Completion lineage must use the committed ApplicationRun as its subject."
+    });
+  }
+  const outputIds = new Set(commit.outputs.map((output) => output.outputId));
+  commit.artifacts.forEach((artifact, index) => {
+    if (artifact.outputRef.kind !== "workflow-output" || !outputIds.has(artifact.outputRef.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["artifacts", index, "outputRef"],
+        message: "Artifact outputRef must reference an output in the same commit."
+      });
+    }
+  });
+});
+var WorkflowCompletionReceiptSchema = z7.object({
+  contract: z7.literal("WorkflowCompletionReceipt"),
+  commitId: ContractIdentifierSchema,
+  runRef: EntityRefSchema,
+  outputRefs: z7.array(EntityRefSchema),
+  artifactRefs: z7.array(EntityRefSchema),
+  contentHash: Sha256Schema,
+  committedAt: IsoDateTimeSchema,
+  idempotentReplay: z7.boolean()
+}).strict().superRefine((receipt, context) => {
+  if (receipt.runRef.kind !== "application-run") {
+    context.addIssue({
+      code: "custom",
+      path: ["runRef", "kind"],
+      message: "runRef must reference an application-run."
+    });
+  }
+  receipt.outputRefs.forEach((ref, index) => {
+    if (ref.kind !== "workflow-output") {
+      context.addIssue({
+        code: "custom",
+        path: ["outputRefs", index, "kind"],
+        message: "outputRefs must reference workflow-output records."
+      });
+    }
+  });
+  receipt.artifactRefs.forEach((ref, index) => {
+    if (ref.kind !== "artifact") {
+      context.addIssue({
+        code: "custom",
+        path: ["artifactRefs", index, "kind"],
+        message: "artifactRefs must reference artifacts."
+      });
+    }
+  });
+});
+
+export {
+  StorageLocatorSchema,
+  ArtifactAccessSchema,
+  ArtifactManifestSchema,
+  OutputRecordSchema,
+  AggregateAssetSchema,
+  AggregateAssetUpsertSchema,
+  AggregateAssetDeleteSchema,
+  AggregateFeatureValueWriteSchema,
+  AggregateFeatureRelationTargetSchema,
+  AggregateFeatureRelationReplaceSchema,
+  AggregateAssetRelationObjectSchema,
+  AggregateAssetRelationReplaceSchema,
+  AggregateContainerMembershipWriteSchema,
+  AggregateCommitRequestSchema,
+  ActorRefSchema,
+  AuthorityScopeSchema,
+  RequestScopeSchema,
+  ExecutionLinkSchema,
+  CompletionHeaderSchema,
+  CompletionEventSchema,
+  AgentRuntimeEventSchema,
+  DataContinuityEnvelopeSchema,
+  BodyRelationRecordSchema,
+  ApplicationRunSchema,
+  ExpiringAccessGrantSchema,
+  DeclarativeImportDocumentSchema,
+  DeclarativeDocumentImportRequestSchema,
+  DeclarativeDocumentImportIntentSchema,
+  DeclarativeDocumentImportPlanSchema,
+  DeclarativeDocumentImportResultSchema,
+  RadarDecisionMetricsSchema,
+  TrendSourceSchema,
+  TrendIngestRunSchema,
+  TrendSourceRecordSchema,
+  HotwordBodySchema,
+  BrandBodySchema,
+  ProductBodySchema,
+  TrendMetricSnapshotSchema,
+  RadarScoreModelBodySchema,
+  RadarScoreProjectionSchema,
+  RadarPanoramaNodeSchema,
+  RadarPanoramaEdgeSchema,
+  RadarPanoramaSchema,
+  BrandGeneticsProfileSchema,
+  RadarOpportunityMatrixPointSchema,
+  RadarOpportunityMatrixSchema,
+  RadarQueryBodySchema,
+  SavedRadarQuerySchema,
+  RadarSelectionSchema,
+  TrendRadarCollectionAssetRefSchema,
+  TrendRadarCollectionSelectionRefSchema,
+  TrendRadarCollectionRunRefSchema,
+  TrendRadarCollectionSubjectRefSchema,
+  TrendRadarCollectionArtifactRefSchema,
+  TrendRadarCollectionRecipeEntrySchema,
+  TrendRadarCollectionRecipeSchema,
+  TrendRadarCollectionDecisionAxisSchema,
+  TrendRadarCollectionDecisionProjectionSchema,
+  TrendRadarCollectionArtifactProjectionSchema,
+  TrendRadarCollectionProjectionWritebackSchema,
+  TrendRadarCollectionItemSchema,
+  RadarAnalysisRunSchema,
+  RadarAnalysisAssetSchema,
+  RadarAnalysisDetailSchema,
+  RadarActionRecordSchema,
+  RadarWritebackRecordSchema,
+  WorkflowCatalogEntrySchema,
+  WorkflowPublicationSchema,
+  WorkflowCompletionCommitSchema,
+  WorkflowCompletionReceiptSchema
+};
+//# sourceMappingURL=chunk-4ZSCTEY6.mjs.map