@automate.ax/api-contract 0.61.1 → 0.62.1

package/dist/index.d.ts

@@ -1124,11 +1124,11 @@ export declare const contract: {
                 signalDependencyIds: import("zod").ZodArray<import("zod").ZodString>;
                 slot: import("zod").ZodNumber;
                 key: import("zod").ZodOptional<import("zod").ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
-                order: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                ordered: import("zod").ZodBoolean;
                 outcomeSeq: import("zod").ZodNumber;
                 policy: import("zod").ZodLiteral<"correlate">;
-                streamName: import("zod").ZodString;
-                streamNames: import("zod").ZodArray<import("zod").ZodString>;
+                streamIndex: import("zod").ZodNumber;
+                streamOrigins: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString>>;
                 ttl: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
             }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
                 actionDependencyIds: import("zod").ZodArray<import("zod").ZodString>;

package/dist/runtime.d.ts

@@ -61,11 +61,11 @@ declare const COORDINATION_OFFER_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
     signalDependencyIds: z.ZodArray<z.ZodString>;
     slot: z.ZodNumber;
     key: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
-    order: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ordered: z.ZodBoolean;
     outcomeSeq: z.ZodNumber;
     policy: z.ZodLiteral<"correlate">;
-    streamName: z.ZodString;
-    streamNames: z.ZodArray<z.ZodString>;
+    streamIndex: z.ZodNumber;
+    streamOrigins: z.ZodArray<z.ZodArray<z.ZodString>>;
     ttl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
 }, z.core.$strip>, z.ZodObject<{
     actionDependencyIds: z.ZodArray<z.ZodString>;
@@ -364,11 +364,11 @@ export declare const runtimeContract: {
             signalDependencyIds: z.ZodArray<z.ZodString>;
             slot: z.ZodNumber;
             key: z.ZodOptional<z.ZodCustom<import("@automate.ax/codec").Encodable, import("@automate.ax/codec").Encodable>>;
-            order: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ordered: z.ZodBoolean;
             outcomeSeq: z.ZodNumber;
             policy: z.ZodLiteral<"correlate">;
-            streamName: z.ZodString;
-            streamNames: z.ZodArray<z.ZodString>;
+            streamIndex: z.ZodNumber;
+            streamOrigins: z.ZodArray<z.ZodArray<z.ZodString>>;
             ttl: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         }, z.core.$strip>, z.ZodObject<{
             actionDependencyIds: z.ZodArray<z.ZodString>;

package/dist/runtime.js

@@ -142,37 +142,27 @@ const COORDINATION_DURATION_SCHEMA = z.union([
     z.string().min(1),
     z.number().nonnegative(),
 ]);
-const CORRELATION_STREAM_NAMES_SCHEMA = z
+const CORRELATION_STREAM_ORIGINS_SCHEMA = z
     .string()
     .min(1)
     .array()
-    .min(2)
-    .refine((names) => new Set(names).size === names.length, {
-    message: "Correlation stream names must be unique.",
-});
+    .min(1)
+    .array()
+    .min(2);
 const CORRELATION_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
     key: encodableSchema,
-    order: CORRELATION_STREAM_NAMES_SCHEMA.optional(),
+    ordered: z.boolean(),
     outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
     policy: z.literal("correlate"),
-    streamName: z.string().min(1),
-    streamNames: CORRELATION_STREAM_NAMES_SCHEMA,
+    streamIndex: z.number().int().nonnegative(),
+    streamOrigins: CORRELATION_STREAM_ORIGINS_SCHEMA,
     ttl: z.union([z.string().min(1), z.number().nonnegative()]).optional(),
 }).superRefine((entry, context) => {
-    if (!entry.streamNames.includes(entry.streamName)) {
-        context.addIssue({
-            code: "custom",
-            message: "Correlation stream must be included in streamNames.",
-            path: ["streamName"],
-        });
-    }
-    if (entry.order &&
-        (entry.order.length !== entry.streamNames.length ||
-            entry.order.some((name) => !entry.streamNames.includes(name)))) {
+    if (entry.streamIndex >= entry.streamOrigins.length) {
         context.addIssue({
             code: "custom",
-            message: "Correlation order must name every stream exactly once.",
-            path: ["order"],
+            message: "Correlation stream index must identify an input stream.",
+            path: ["streamIndex"],
         });
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/api-contract",
-  "version": "0.61.1",
+  "version": "0.62.1",
   "description": "Public oRPC contract for the Automate.ax API.",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@ai-sdk/gateway": "^4.0.46",
-    "@automate.ax/codec": "0.61.1",
+    "@automate.ax/codec": "0.62.1",
     "@orpc/contract": "1.15.0",
     "fast-json-stable-stringify": "^2.1.0",
     "zod": "^4.3.6"

package/src/runtime.ts

@@ -159,40 +159,28 @@ const COORDINATION_DURATION_SCHEMA = z.union([
   z.string().min(1),
   z.number().nonnegative(),
 ])
-const CORRELATION_STREAM_NAMES_SCHEMA = z
+const CORRELATION_STREAM_ORIGINS_SCHEMA = z
   .string()
   .min(1)
   .array()
+  .min(1)
+  .array()
   .min(2)
-  .refine((names) => new Set(names).size === names.length, {
-    message: "Correlation stream names must be unique.",
-  })
 
 const CORRELATION_OFFER_SCHEMA = SIGNAL_INVOCATION_DEPENDENCIES_SCHEMA.extend({
   key: encodableSchema,
-  order: CORRELATION_STREAM_NAMES_SCHEMA.optional(),
+  ordered: z.boolean(),
   outcomeSeq: OUTCOME_SEQUENCE_SCHEMA,
   policy: z.literal("correlate"),
-  streamName: z.string().min(1),
-  streamNames: CORRELATION_STREAM_NAMES_SCHEMA,
+  streamIndex: z.number().int().nonnegative(),
+  streamOrigins: CORRELATION_STREAM_ORIGINS_SCHEMA,
   ttl: z.union([z.string().min(1), z.number().nonnegative()]).optional(),
 }).superRefine((entry, context) => {
-  if (!entry.streamNames.includes(entry.streamName)) {
-    context.addIssue({
-      code: "custom",
-      message: "Correlation stream must be included in streamNames.",
-      path: ["streamName"],
-    })
-  }
-  if (
-    entry.order &&
-    (entry.order.length !== entry.streamNames.length ||
-      entry.order.some((name) => !entry.streamNames.includes(name)))
-  ) {
+  if (entry.streamIndex >= entry.streamOrigins.length) {
     context.addIssue({
       code: "custom",
-      message: "Correlation order must name every stream exactly once.",
-      path: ["order"],
+      message: "Correlation stream index must identify an input stream.",
+      path: ["streamIndex"],
     })
   }
 })