@inf-monkeys-tech/monkeys 1.0.69 → 1.0.71

package/lib/esm/index.mjs

@@ -14863,22 +14863,77 @@ var WorkflowDefinitionSchema = z19.object({
   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." });
 });
 
-// src/contracts/workflow-runtime.ts
+// src/contracts/workflow-column.ts
 import { z as z20 } from "zod";
-var WorkflowCatalogEntrySchema = z20.object({
-  contract: z20.literal("WorkflowCatalogEntry"),
+var WorkflowColumnFieldRefSchema = z20.object({
+  ontologyId: ContractIdentifierSchema,
+  fieldKey: ContractIdentifierSchema
+}).strict();
+var WorkflowColumnInputSchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("default") }).strict(),
+  z20.object({ kind: z20.literal("constant"), value: JsonValueSchema }).strict(),
+  z20.object({ kind: z20.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z20.object({
+    kind: z20.literal("context"),
+    field: z20.enum(["assetId", "teamId", "ontologyId", "columnId"])
+  }).strict()
+]);
+var WorkflowColumnDependencySchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("field"), field: WorkflowColumnFieldRefSchema }).strict(),
+  z20.object({
+    kind: z20.literal("relation"),
+    relation: WorkflowColumnFieldRefSchema,
+    direction: z20.enum(["incoming", "outgoing"]),
+    fields: z20.array(WorkflowColumnFieldRefSchema).max(100)
+  }).strict()
+]);
+var WorkflowColumnOutputPathSchema = z20.array(z20.string().min(1).max(256)).max(20);
+var WorkflowColumnOutputSchema = z20.object({
+  type: z20.enum(["number", "text", "json"]),
+  path: WorkflowColumnOutputPathSchema,
+  nullable: z20.boolean().default(false)
+}).strict();
+var WorkflowColumnBindingSchema = z20.object({
+  contract: z20.literal("WorkflowColumnBinding"),
+  version: z20.literal(1),
+  enabled: z20.boolean(),
+  paused: z20.boolean().default(false),
+  workflow: z20.object({
+    id: ContractIdentifierSchema,
+    version: z20.number().int().positive(),
+    inputSchemaHash: Sha256Schema
+  }).strict(),
+  inputs: z20.record(z20.string().min(1).max(128), WorkflowColumnInputSchema),
+  dependencies: z20.array(WorkflowColumnDependencySchema).max(100).default([]),
+  output: WorkflowColumnOutputSchema,
+  policy: z20.object({
+    debounceMs: z20.number().int().min(0).max(3e4).default(5e3),
+    maxDelayMs: z20.number().int().min(0).max(3e4).default(3e4),
+    concurrency: z20.number().int().min(1).max(32).default(2),
+    // Indexed queries need visible projections of their declared sources before execution.
+    requireSearchProjection: z20.boolean().optional()
+  }).strict().default({ debounceMs: 5e3, maxDelayMs: 3e4, concurrency: 2 }),
+  // The workflow supplies an ISO datetime with offset for one future expiry.
+  // Scheduling infrastructure needs no knowledge of months or business periods.
+  expiry: z20.object({ path: WorkflowColumnOutputPathSchema }).strict().optional()
+}).strict();
+
+// src/contracts/workflow-runtime.ts
+import { z as z21 } from "zod";
+var WorkflowCatalogEntrySchema = z21.object({
+  contract: z21.literal("WorkflowCatalogEntry"),
   workflowId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   creatorRef: EntityRefSchema,
   currentDefinitionRef: EntityRefSchema,
-  lifecycle: z20.enum(["ACTIVE", "DELETED"]),
-  asset: z20.object({
-    preset: z20.boolean(),
-    marketplacePublished: z20.boolean(),
+  lifecycle: z21.enum(["ACTIVE", "DELETED"]),
+  asset: z21.object({
+    preset: z21.boolean(),
+    marketplacePublished: z21.boolean(),
     publishConfig: JsonObjectSchema.optional(),
-    sort: z20.number().int(),
+    sort: z21.number().int(),
     forkFromRef: EntityRefSchema.optional(),
-    notAuthorized: z20.boolean()
+    notAuthorized: z21.boolean()
   }).strict(),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema,
@@ -14913,17 +14968,17 @@ var WorkflowCatalogEntrySchema = z20.object({
     });
   }
 });
-var WorkflowPublicationSchema = z20.object({
-  contract: z20.literal("WorkflowPublication"),
+var WorkflowPublicationSchema = z21.object({
+  contract: z21.literal("WorkflowPublication"),
   publicationId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
   runtimeDefinitionRef: EntityRefSchema,
   sourceHash: Sha256Schema,
   compiledHash: Sha256Schema,
-  status: z20.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
+  status: z21.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
   publisherRef: EntityRefSchema,
   publishedAt: IsoDateTimeSchema.optional(),
-  failureReason: z20.string().trim().min(1).optional()
+  failureReason: z21.string().trim().min(1).optional()
 }).strict().superRefine((publication, context) => {
   if (publication.definitionRef.kind !== "workflow-definition") {
     context.addIssue({
@@ -14954,12 +15009,12 @@ var WorkflowPublicationSchema = z20.object({
     });
   }
 });
-var WorkflowCompletionCommitSchema = z20.object({
-  contract: z20.literal("WorkflowCompletionCommit"),
+var WorkflowCompletionCommitSchema = z21.object({
+  contract: z21.literal("WorkflowCompletionCommit"),
   commitId: ContractIdentifierSchema,
   run: ApplicationRunSchema,
-  outputs: z20.array(OutputRecordSchema),
-  artifacts: z20.array(ArtifactManifestSchema),
+  outputs: z21.array(OutputRecordSchema),
+  artifacts: z21.array(ArtifactManifestSchema),
   lineage: LineageRecordSchema,
   completedAt: IsoDateTimeSchema
 }).strict().superRefine((commit, context) => {
@@ -15001,15 +15056,15 @@ var WorkflowCompletionCommitSchema = z20.object({
     }
   });
 });
-var WorkflowCompletionReceiptSchema = z20.object({
-  contract: z20.literal("WorkflowCompletionReceipt"),
+var WorkflowCompletionReceiptSchema = z21.object({
+  contract: z21.literal("WorkflowCompletionReceipt"),
   commitId: ContractIdentifierSchema,
   runRef: EntityRefSchema,
-  outputRefs: z20.array(EntityRefSchema),
-  artifactRefs: z20.array(EntityRefSchema),
+  outputRefs: z21.array(EntityRefSchema),
+  artifactRefs: z21.array(EntityRefSchema),
   contentHash: Sha256Schema,
   committedAt: IsoDateTimeSchema,
-  idempotentReplay: z20.boolean()
+  idempotentReplay: z21.boolean()
 }).strict().superRefine((receipt, context) => {
   if (receipt.runRef.kind !== "application-run") {
     context.addIssue({
@@ -15040,6 +15095,7 @@ var WorkflowCompletionReceiptSchema = z20.object({
 
 // src/schemas/index.ts
 var canonicalContractSchemas = {
+  "workflow-column-binding": WorkflowColumnBindingSchema,
   "agent-session-command": AgentSessionCommandSchema,
   "agent-session-targeted-command": AgentSessionTargetedCommandSchema,
   "agent-session-command-result": AgentSessionCommandResultSchema,
@@ -17805,6 +17861,49 @@ var compileWorkflowPersistenceProjection = (input) => {
   });
 };
 
+// src/runtime/workflow-column.ts
+function parseWorkflowColumnBinding(value) {
+  const binding = WorkflowColumnBindingSchema.parse(value);
+  if (Object.keys(binding.inputs).length > 100)
+    throw new Error("Workflow column supports at most 100 input bindings.");
+  if (binding.policy.maxDelayMs < binding.policy.debounceMs)
+    throw new Error("Workflow column maxDelayMs must be at least debounceMs.");
+  for (const name of Object.keys(binding.inputs)) {
+    if (name !== name.trim() || name.startsWith("__") || name === "constructor" || name === "prototype") {
+      throw new Error(`Invalid Workflow input name: ${name}`);
+    }
+  }
+  return binding;
+}
+function selectOwnValue(payload, path) {
+  let value = payload;
+  for (const key of path) {
+    if (value === null || typeof value !== "object" || !Object.prototype.hasOwnProperty.call(value, key)) {
+      throw new Error(`Workflow output is missing the configured path: ${JSON.stringify(path)}`);
+    }
+    value = value[key];
+  }
+  if (value === void 0) throw new Error("Workflow output is absent.");
+  return value;
+}
+function resolveWorkflowColumnResult(binding, payload, nowMs = Date.now()) {
+  const selected = selectOwnValue(payload, binding.output.path);
+  if (selected === null && !binding.output.nullable)
+    throw new Error("Workflow output is null but this column does not allow null results.");
+  if (selected !== null) {
+    if (binding.output.type === "number" && (typeof selected !== "number" || !Number.isFinite(selected)))
+      throw new Error("Workflow output must be a finite number.");
+    if (binding.output.type === "text" && typeof selected !== "string")
+      throw new Error("Workflow output must be text.");
+  }
+  const value = JsonValueSchema.parse(selected);
+  if (!binding.expiry) return { value };
+  const expiresAt = IsoDateTimeSchema.parse(selectOwnValue(payload, binding.expiry.path));
+  if (!Number.isFinite(nowMs) || Date.parse(expiresAt) <= nowMs)
+    throw new Error("Workflow expiry must be a future datetime.");
+  return { value, expiresAt };
+}
+
 // src/runtime/access-compiler.ts
 var uniqueBy = (values, key, label) => {
   const result = /* @__PURE__ */ new Map();
@@ -18271,6 +18370,12 @@ export {
   WorkbenchRuntimeBundleSchema,
   WorkbenchSchema,
   WorkflowCatalogEntrySchema,
+  WorkflowColumnBindingSchema,
+  WorkflowColumnDependencySchema,
+  WorkflowColumnFieldRefSchema,
+  WorkflowColumnInputSchema,
+  WorkflowColumnOutputPathSchema,
+  WorkflowColumnOutputSchema,
   WorkflowCompletionCommitSchema,
   WorkflowCompletionReceiptSchema,
   WorkflowDefinitionSchema,
@@ -18339,6 +18444,7 @@ export {
   normalizeAgentMode,
   normalizeStudioAgentMode,
   parseApplicationHandoff,
+  parseWorkflowColumnBinding,
   projectAgentSessionEvents,
   projectNavigationCompatibility,
   publishOpenApiToolCapabilityManifests,
@@ -18349,6 +18455,7 @@ export {
   resolveMenuActivationId,
   resolveThemeTokens,
   resolveWorkbenchEntry,
+  resolveWorkflowColumnResult,
   revisionRefKey,
   sameRevisionRef,
   sameStableRef,