@skaile/workspaces 4.29.0 → 4.30.0

package/dist/{chunk-KPRZHEEI.js → chunk-ORH2BZEM.js}

@@ -1,4 +1,4 @@
-import * as z from 'zod';
+import * as z2 from 'zod';
 
 // factory-assets/connectors/flow/contract/classifier.ts
 var RESERVED_CLASSIFIER_FIELDS = ["confidence", "calibrated"];
@@ -798,15 +798,44 @@ function resolveFlowBindings(bindings, context, nodeOutputOrigin = {}, flowInput
   }
   return { values, origins };
 }
-var jsonValue = () => z.json();
-var nonEmptyString = z.string().min(1);
-var flowAssetIdentity = z.string().regex(
+function consumerExpressions(node) {
+  const expressions = (node.contract?.requires ?? []).map(({ expr }) => expr);
+  expressions.push(...collectFlowBindingExpressions(node.contract?.input));
+  if (node.run?.kind === "router") {
+    expressions.push(...node.run.routes.map(({ when }) => when));
+  }
+  return expressions;
+}
+function readsProducerOutput(node, producerId) {
+  return consumerExpressions(node).some(
+    (expression) => inspectFlowExpression(expression, false).some(
+      ({ path }) => path.startsWith(`nodes.${producerId}.output.fields.`)
+    )
+  );
+}
+function getConsumedOutputSchema(flow, producerId) {
+  const producer = flow.nodes.find(({ id }) => id === producerId);
+  const schema = producer?.contract?.output?.fields;
+  if (!schema) return void 0;
+  return flow.nodes.some(
+    (consumer) => consumer.id !== producerId && readsProducerOutput(consumer, producerId)
+  ) ? schema : void 0;
+}
+function compileOutputFieldsSchema(schema) {
+  return z2.fromJSONSchema(schema);
+}
+function invalidOutputFieldsSchemaMessage(error) {
+  return `invalid authored JSON Schema: ${error instanceof Error ? error.message : String(error)}`;
+}
+var jsonValue = () => z2.json();
+var nonEmptyString = z2.string().min(1);
+var flowAssetIdentity = z2.string().regex(
   /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
   "Flow identity must be lowercase kebab-case without path separators"
 );
-var jsonSchema = z.record(z.string(), jsonValue());
-var bindingName = z.string().regex(FLOW_BINDING_NAME_PATTERN, "Binding name is reserved");
-var nodeBindings = z.preprocess(
+var jsonSchema = z2.record(z2.string(), jsonValue());
+var bindingName = z2.string().regex(FLOW_BINDING_NAME_PATTERN, "Binding name is reserved");
+var nodeBindings = z2.preprocess(
   (value, context) => {
     if (typeof value === "object" && value !== null) {
       for (const key of Object.keys(value)) {
@@ -817,7 +846,7 @@ var nodeBindings = z.preprocess(
     }
     return value;
   },
-  z.record(bindingName, jsonValue())
+  z2.record(bindingName, jsonValue())
 );
 var MISSING_FIELD = /* @__PURE__ */ Symbol("missing-field");
 function declaredFieldSchema(schema, path) {
@@ -832,7 +861,7 @@ function declaredFieldSchema(schema, path) {
   }
   return current;
 }
-var FlowInputContractSchema = z.strictObject({
+var FlowInputContractSchema = z2.strictObject({
   schema: jsonSchema,
   example: jsonValue().optional(),
   labelField: nonEmptyString.optional()
@@ -847,45 +876,45 @@ var FlowInputContractSchema = z.strictObject({
     });
   }
 });
-var FlowOutputContractSchema = z.strictObject({
+var FlowOutputContractSchema = z2.strictObject({
   schema: jsonSchema
 });
-var PreconditionSchema = z.strictObject({
+var PreconditionSchema = z2.strictObject({
   expr: nonEmptyString,
   message: nonEmptyString.optional()
 });
-var ArtifactContractSchema = z.strictObject({
+var ArtifactContractSchema = z2.strictObject({
   kind: nonEmptyString,
-  lifetime: z.enum(["session", "persistent"])
+  lifetime: z2.enum(["session", "persistent"])
 });
-var NodeOutputContractSchema = z.strictObject({
+var NodeOutputContractSchema = z2.strictObject({
   fields: jsonSchema.optional(),
-  artifacts: z.array(ArtifactContractSchema).optional()
+  artifacts: z2.array(ArtifactContractSchema).optional()
 });
-var NodeContractSchema = z.strictObject({
-  requires: z.array(PreconditionSchema).optional(),
+var NodeContractSchema = z2.strictObject({
+  requires: z2.array(PreconditionSchema).optional(),
   input: nodeBindings.optional(),
   output: NodeOutputContractSchema.optional()
 });
-var NodeGateSchema = z.strictObject({
-  approval: z.enum(["none", "optional", "mandatory"])
+var NodeGateSchema = z2.strictObject({
+  approval: z2.enum(["none", "optional", "mandatory"])
 });
-var NodeControlSchema = z.strictObject({
-  optional: z.boolean().optional(),
-  retries: z.number().int().min(0).optional(),
-  timeoutSec: z.number().positive().optional(),
+var NodeControlSchema = z2.strictObject({
+  optional: z2.boolean().optional(),
+  retries: z2.number().int().min(0).optional(),
+  timeoutSec: z2.number().positive().optional(),
   parallelGroup: nonEmptyString.optional()
 });
-var runAssets = { assets: z.array(nonEmptyString).optional() };
-var modelTier = z.enum(["small", "default", "deep"]);
-var AgentRunSchema = z.strictObject({
-  kind: z.literal("agent"),
+var runAssets = { assets: z2.array(nonEmptyString).optional() };
+var modelTier = z2.enum(["small", "default", "deep"]);
+var AgentRunSchema = z2.strictObject({
+  kind: z2.literal("agent"),
   instruction: nonEmptyString,
   model: modelTier.optional(),
   ...runAssets
 });
-var SubpromptRunSchema = z.strictObject({
-  kind: z.literal("subprompt"),
+var SubpromptRunSchema = z2.strictObject({
+  kind: z2.literal("subprompt"),
   instruction: nonEmptyString,
   model: modelTier.optional(),
   ...runAssets
@@ -899,73 +928,77 @@ function invalidCaptureDestinationMessage(kind, nodeId, channel, destination) {
   const kindLabel = kind === "check" ? "Check" : "Function";
   return `${kindLabel} node ${nodeId} run.capture.${channel} destination "${destination}" is invalid; expected fields.<name>`;
 }
+function duplicateCaptureDestinationMessage(kind, nodeId, fieldName) {
+  const kindLabel = kind === "check" ? "Check" : "Function";
+  return `${kindLabel} node ${nodeId} run.capture.stdout and run.capture.stderr both write fields.${fieldName}; stderr would overwrite stdout, so capture them into different fields`;
+}
 var deterministicRun = {
-  runtime: z.enum(["shell", "node", "python"]).optional(),
+  runtime: z2.enum(["shell", "node", "python"]).optional(),
   command: nonEmptyString,
   cwd: nonEmptyString.optional(),
-  successExit: z.array(z.number().int()).optional(),
-  capture: z.strictObject({ stdout: nonEmptyString.optional(), stderr: nonEmptyString.optional() }).optional(),
+  successExit: z2.array(z2.number().int()).optional(),
+  capture: z2.strictObject({ stdout: nonEmptyString.optional(), stderr: nonEmptyString.optional() }).optional(),
   ...runAssets
 };
-var FunctionRunSchema = z.strictObject({
-  kind: z.literal("function"),
+var FunctionRunSchema = z2.strictObject({
+  kind: z2.literal("function"),
   ...deterministicRun
 });
-var CheckRunSchema = z.strictObject({
-  kind: z.literal("check"),
-  onFail: z.enum(["escalate", "fail"]).default("escalate"),
+var CheckRunSchema = z2.strictObject({
+  kind: z2.literal("check"),
+  onFail: z2.enum(["escalate", "fail"]).default("escalate"),
   ...deterministicRun
 });
-var InputChoiceSchema = z.strictObject({
+var InputChoiceSchema = z2.strictObject({
   id: nonEmptyString,
   label: nonEmptyString,
   description: nonEmptyString.optional()
 });
-var FormFieldSchema = z.strictObject({
+var FormFieldSchema = z2.strictObject({
   id: nonEmptyString,
   label: nonEmptyString,
-  type: z.enum(["text", "textarea", "number", "choice", "file", "date", "boolean"]),
-  required: z.boolean().optional(),
-  options: z.array(InputChoiceSchema).optional(),
-  accept: z.array(nonEmptyString).optional()
+  type: z2.enum(["text", "textarea", "number", "choice", "file", "date", "boolean"]),
+  required: z2.boolean().optional(),
+  options: z2.array(InputChoiceSchema).optional(),
+  accept: z2.array(nonEmptyString).optional()
 });
-var InputSchema = z.discriminatedUnion("kind", [
-  z.strictObject({ kind: z.literal("text"), multiline: z.boolean().optional() }),
-  z.strictObject({
-    kind: z.literal("choice"),
-    options: z.array(InputChoiceSchema).min(1),
-    multiple: z.boolean().optional()
+var InputSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({ kind: z2.literal("text"), multiline: z2.boolean().optional() }),
+  z2.strictObject({
+    kind: z2.literal("choice"),
+    options: z2.array(InputChoiceSchema).min(1),
+    multiple: z2.boolean().optional()
   }),
-  z.strictObject({ kind: z.literal("form"), fields: z.array(FormFieldSchema) }),
-  z.strictObject({
-    kind: z.literal("file"),
-    accept: z.array(nonEmptyString).optional(),
-    maxSize: z.number().positive().optional(),
-    multiple: z.boolean().optional()
+  z2.strictObject({ kind: z2.literal("form"), fields: z2.array(FormFieldSchema) }),
+  z2.strictObject({
+    kind: z2.literal("file"),
+    accept: z2.array(nonEmptyString).optional(),
+    maxSize: z2.number().positive().optional(),
+    multiple: z2.boolean().optional()
   })
 ]);
-var GateRunSchema = z.strictObject({
-  kind: z.literal("gate"),
+var GateRunSchema = z2.strictObject({
+  kind: z2.literal("gate"),
   prompt: nonEmptyString,
   schema: InputSchema,
   ...runAssets
 });
-var RouteSchema = z.strictObject({
+var RouteSchema = z2.strictObject({
   when: nonEmptyString,
   target: nonEmptyString.nullable()
 });
-var RouterRunSchema = z.strictObject({
-  kind: z.literal("router"),
-  routes: z.array(RouteSchema).min(1),
+var RouterRunSchema = z2.strictObject({
+  kind: z2.literal("router"),
+  routes: z2.array(RouteSchema).min(1),
   ...runAssets
 });
-var SubFlowRunSchema = z.strictObject({
-  kind: z.literal("sub-flow"),
+var SubFlowRunSchema = z2.strictObject({
+  kind: z2.literal("sub-flow"),
   flow: flowAssetIdentity,
-  passContext: z.boolean().optional(),
+  passContext: z2.boolean().optional(),
   ...runAssets
 });
-var RunSchema = z.discriminatedUnion("kind", [
+var RunSchema = z2.discriminatedUnion("kind", [
   AgentRunSchema,
   SubpromptRunSchema,
   FunctionRunSchema,
@@ -974,7 +1007,7 @@ var RunSchema = z.discriminatedUnion("kind", [
   RouterRunSchema,
   SubFlowRunSchema
 ]);
-var NodeSchema = z.strictObject({
+var NodeSchema = z2.strictObject({
   id: nonEmptyString,
   label: nonEmptyString,
   description: nonEmptyString,
@@ -984,35 +1017,35 @@ var NodeSchema = z.strictObject({
   gate: NodeGateSchema.optional(),
   control: NodeControlSchema.optional()
 });
-var EdgeSchema = z.strictObject({
+var EdgeSchema = z2.strictObject({
   id: nonEmptyString,
   source: nonEmptyString,
   target: nonEmptyString,
-  type: z.enum(["flow", "parallel", "optional"])
+  type: z2.enum(["flow", "parallel", "optional"])
 });
-var FlowDefaultsSchema = z.strictObject({
-  approval: z.enum(["checkpoint", "auto", "manual"]).optional(),
+var FlowDefaultsSchema = z2.strictObject({
+  approval: z2.enum(["checkpoint", "auto", "manual"]).optional(),
   researchDepth: nonEmptyString.optional(),
-  autoReview: z.boolean().optional(),
+  autoReview: z2.boolean().optional(),
   verbosity: nonEmptyString.optional(),
-  cliMode: z.boolean().optional(),
+  cliMode: z2.boolean().optional(),
   run_input: jsonValue().optional(),
-  parameters: z.record(z.string(), jsonValue()).optional()
+  parameters: z2.record(z2.string(), jsonValue()).optional()
 });
-var FlowMetaSchema = z.strictObject({
+var FlowMetaSchema = z2.strictObject({
   icon: nonEmptyString.optional(),
   category: nonEmptyString.optional(),
-  tags: z.array(nonEmptyString).optional(),
+  tags: z2.array(nonEmptyString).optional(),
   stage: nonEmptyString.optional(),
-  onboarding: z.strictObject({
-    input_style: z.enum(["freeform", "structured", "repo"]),
+  onboarding: z2.strictObject({
+    input_style: z2.enum(["freeform", "structured", "repo"]),
     placeholder: nonEmptyString.optional(),
-    fields: z.array(nonEmptyString).optional()
+    fields: z2.array(nonEmptyString).optional()
   }).optional()
 });
-var FlowDefinitionObjectSchema = z.strictObject({
+var FlowDefinitionObjectSchema = z2.strictObject({
   $schema: nonEmptyString.optional(),
-  schemaVersion: z.literal(2),
+  schemaVersion: z2.literal(2),
   id: nonEmptyString,
   version: nonEmptyString,
   name: nonEmptyString,
@@ -1021,8 +1054,8 @@ var FlowDefinitionObjectSchema = z.strictObject({
   output: FlowOutputContractSchema.optional(),
   defaults: FlowDefaultsSchema.optional(),
   entry: nonEmptyString.optional(),
-  nodes: z.array(NodeSchema),
-  edges: z.array(EdgeSchema),
+  nodes: z2.array(NodeSchema),
+  edges: z2.array(EdgeSchema),
   meta: FlowMetaSchema.optional()
 });
 function parseFlowDefinitionStructure(data) {
@@ -1084,6 +1117,17 @@ var FlowDefinitionSchema = FlowDefinitionObjectSchema.superRefine((flow, context
           message: invalidCaptureDestinationMessage(node.run.kind, node.id, channel, destination)
         });
       }
+      const { stdout, stderr } = node.run.capture ?? {};
+      const stdoutField = stdout === void 0 ? void 0 : captureDestinationFieldName(stdout);
+      if (stdoutField !== void 0 && stderr !== void 0) {
+        if (captureDestinationFieldName(stderr) === stdoutField) {
+          context.addIssue({
+            code: "custom",
+            path: ["nodes", index, "run", "capture", "stderr"],
+            message: duplicateCaptureDestinationMessage(node.run.kind, node.id, stdoutField)
+          });
+        }
+      }
     }
   }
   if (flow.entry !== void 0 && !nodeIds.has(flow.entry)) {
@@ -1209,6 +1253,7 @@ var FlowDefinitionSchema = FlowDefinitionObjectSchema.superRefine((flow, context
     }
   }
   validateClassifierRules(flow, context);
+  validateConsumedOutputSchemasCompile(flow, context);
   const state = /* @__PURE__ */ new Map();
   for (const nodeId of nodeIds) {
     if (state.has(nodeId)) continue;
@@ -1233,6 +1278,31 @@ var FlowDefinitionSchema = FlowDefinitionObjectSchema.superRefine((flow, context
     }
   }
 });
+function validateConsumedOutputSchemasCompile(flow, context) {
+  for (const [nodeIndex, node] of flow.nodes.entries()) {
+    const fields = node.contract?.output?.fields;
+    if (!fields) continue;
+    let compileError;
+    try {
+      compileOutputFieldsSchema(fields);
+      continue;
+    } catch (error) {
+      compileError = error;
+    }
+    let consumed;
+    try {
+      consumed = getConsumedOutputSchema(flow, node.id) !== void 0;
+    } catch {
+      continue;
+    }
+    if (!consumed) continue;
+    context.addIssue({
+      code: "custom",
+      path: ["nodes", nodeIndex, "contract", "output", "fields"],
+      message: `node ${node.id} contract.output.fields: ${invalidOutputFieldsSchemaMessage(compileError)}`
+    });
+  }
+}
 var ORDERING_OPERATORS = /* @__PURE__ */ new Set(["<", "<=", ">", ">="]);
 function validateClassifierRules(flow, context) {
   const classifierIds = /* @__PURE__ */ new Set();
@@ -1331,6 +1401,6 @@ function validateClassifierRules(flow, context) {
   }
 }
 
-export { FLOW_CAPTURE_CHANNELS, FLOW_CAPTURE_DESTINATION_PATTERN, FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, InputSchema, RESERVED_CLASSIFIER_FIELDS, captureDestinationFieldName, checkClassifierShape, classifierDecision, collectFlowBindingExpressions, declaresReservedClassifierField, evaluate, evaluateFlowExpression, hasConstantlyFalsePrecondition, inspectFlowExpression, inspectFlowExpressionComparisons, invalidCaptureDestinationMessage, parseFlowDefinitionStructure, resolveFlowBindings, stableFlowJson, withoutReservedClassifierFields };
-//# sourceMappingURL=chunk-KPRZHEEI.js.map
-//# sourceMappingURL=chunk-KPRZHEEI.js.map
+export { FLOW_CAPTURE_CHANNELS, FLOW_CAPTURE_DESTINATION_PATTERN, FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, InputSchema, RESERVED_CLASSIFIER_FIELDS, captureDestinationFieldName, checkClassifierShape, classifierDecision, compileOutputFieldsSchema, declaresReservedClassifierField, duplicateCaptureDestinationMessage, evaluate, evaluateFlowExpression, getConsumedOutputSchema, hasConstantlyFalsePrecondition, inspectFlowExpressionComparisons, invalidCaptureDestinationMessage, invalidOutputFieldsSchemaMessage, parseFlowDefinitionStructure, resolveFlowBindings, stableFlowJson, withoutReservedClassifierFields };
+//# sourceMappingURL=chunk-ORH2BZEM.js.map
+//# sourceMappingURL=chunk-ORH2BZEM.js.map