@requence/service 0.8.2-edge.1149 → 0.8.2-edge.1154

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (27) hide show
  1. package/build/chunk-974rc2jy.js.map +1 -1
  2. package/build/index.js +29 -7
  3. package/build/index.js.map +4 -4
  4. package/build/types/helpers/src/index.d.ts +1 -0
  5. package/build/types/helpers/src/index.d.ts.map +1 -1
  6. package/build/types/helpers/src/protocol/NodeTree.d.ts +21 -0
  7. package/build/types/helpers/src/protocol/NodeTree.d.ts.map +1 -1
  8. package/build/types/helpers/src/protocol/clientProperties.d.ts +50 -0
  9. package/build/types/helpers/src/protocol/clientProperties.d.ts.map +1 -1
  10. package/build/types/helpers/src/protocol/command.d.ts +799 -0
  11. package/build/types/helpers/src/protocol/command.d.ts.map +1 -1
  12. package/build/types/helpers/src/protocol/index.d.ts +1 -0
  13. package/build/types/helpers/src/protocol/index.d.ts.map +1 -1
  14. package/build/types/helpers/src/protocol/nodeType.d.ts +14 -0
  15. package/build/types/helpers/src/protocol/nodeType.d.ts.map +1 -1
  16. package/build/types/helpers/src/protocol/sliceTreeList.d.ts +81 -0
  17. package/build/types/helpers/src/protocol/sliceTreeList.d.ts.map +1 -0
  18. package/build/types/helpers/src/protocol/templateNodeTypes.d.ts.map +1 -1
  19. package/build/types/helpers/src/protocol/treeNodes.d.ts +629 -4
  20. package/build/types/helpers/src/protocol/treeNodes.d.ts.map +1 -1
  21. package/build/types/helpers/src/protocol/update.d.ts +14 -0
  22. package/build/types/helpers/src/protocol/update.d.ts.map +1 -1
  23. package/build/types/helpers/src/utils/amqpPublishRetry.d.ts +113 -18
  24. package/build/types/helpers/src/utils/amqpPublishRetry.d.ts.map +1 -1
  25. package/build/types/helpers/src/utils/sliceClock.d.ts +61 -0
  26. package/build/types/helpers/src/utils/sliceClock.d.ts.map +1 -0
  27. package/package.json +1 -1
package/build/types/helpers/src/protocol/command.d.ts CHANGED
@@ -1,9 +1,798 @@
1
1
  import { z } from 'zod/v4';
2
+ import { type InputTreeList, type TreeList } from './treeNodes.ts';
2
3
  export declare const abortCommandSchema: z.ZodObject<{
3
4
  type: z.ZodLiteral<"ABORT">;
4
5
  reason: z.ZodOptional<z.ZodString>;
5
6
  }, z.core.$strip>;
6
7
  export type AbortCommand = z.infer<typeof abortCommandSchema>;
8
+ /**
9
+ * "Re-announce this task's state" (issue #136).
10
+ *
11
+ * A caller that owns a row for the task — `ui/backend` — has seen no update for
12
+ * it long past the point where one was due, and cannot tell from its own state
13
+ * whether the task is running with a lost `TASK_START` or was never registered
14
+ * at all. This asks the only party that knows. The answer is an UPDATE, never a
15
+ * reply: a re-announced `TASK_START` when the machine is there, a `TASK_ERROR`
16
+ * when it is not — so every status change keeps travelling the one path
17
+ * (operator → update → monitor).
18
+ *
19
+ * A command rather than a direct publish into `operator.shards` (which is how
20
+ * the operator's own progress watchdog pokes a shard owner): a tenant may only
21
+ * write to its own exchange, and that exchange is bound into the shard family
22
+ * already. Riding the tenant exchange also puts the poke BEHIND this task's own
23
+ * CREATE in the same shard's FIFO — but that orders DELIVERY, not handling: the
24
+ * shard consumer has up to `PREFETCH` deliveries in handlers at once, so the
25
+ * poke can still be ANSWERED while the CREATE it is asking about is mid-flight
26
+ * (issue #140). The operator closes that gap itself: its consumer backs off a
27
+ * reconcile whose task has a CREATE in a handler on the same instance
28
+ * (`packages/operator/src/consumers/tasks.ts`).
29
+ */
30
+ export declare const reconcileCommandSchema: z.ZodObject<{
31
+ type: z.ZodLiteral<"RECONCILE">;
32
+ }, z.core.$strip>;
33
+ export type ReconcileCommand = z.infer<typeof reconcileCommandSchema>;
34
+ /**
35
+ * The CREATE command, parameterised by HOW its tree gets validated.
36
+ *
37
+ * Validating a `treeList` is the single most expensive thing either end of this
38
+ * wire does — measured ~4 s for a 300 kB tree with 23 references — so both ends
39
+ * splice a content-hashed memo in here: the operator on receipt (#132),
40
+ * `task-builder` before it publishes (#138), through the one cache in
41
+ * `../treeListCache.ts`. Everything else about a CREATE is the same on both
42
+ * sides. The plain `createCommandSchema` below, with no memo at all, is what
43
+ * anyone else validating a CREATE gets.
44
+ *
45
+ * A parameter rather than two schemas, because the rest of the command must NOT
46
+ * be duplicated: a second copy of this transform would go on accepting fields
47
+ * the other one has started to reject, and — since the caller hashes exactly
48
+ * what it is handed here — a drifting `allowMultipleOutputs` would key the cache
49
+ * on something other than what it stores. One shape, two tree parsers.
50
+ */
51
+ export declare function createCommandSchemaWith(parseTreeList: (treeList: InputTreeList) => TreeList): z.ZodPipe<z.ZodObject<{
52
+ type: z.ZodLiteral<"CREATE">;
53
+ treeList: z.ZodObject<{
54
+ tree: z.ZodObject<{
55
+ nodes: z.ZodArray<z.ZodAny>;
56
+ edges: z.ZodArray<z.ZodAny>;
57
+ }, z.core.$strip>;
58
+ references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
59
+ schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
60
+ }, z.core.$strip>;
61
+ input: z.ZodAny;
62
+ options: z.ZodObject<{
63
+ maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
64
+ mode: z.ZodDefault<z.ZodEnum<{
65
+ CONTINUOUS: "CONTINUOUS";
66
+ LINEAR: "LINEAR";
67
+ }>>;
68
+ priority: z.ZodDefault<z.ZodInt>;
69
+ uploadUrl: z.ZodOptional<z.ZodString>;
70
+ streamUrl: z.ZodOptional<z.ZodString>;
71
+ maxPayloadSize: z.ZodOptional<z.ZodNumber>;
72
+ maxFileSize: z.ZodOptional<z.ZodNumber>;
73
+ continuous: z.ZodDefault<z.ZodObject<{
74
+ maxReconnects: z.ZodDefault<z.ZodNumber>;
75
+ }, z.core.$strip>>;
76
+ referencedBy: z.ZodOptional<z.ZodObject<{
77
+ rootTaskId: z.ZodUUID;
78
+ taskId: z.ZodUUID;
79
+ nodeId: z.ZodUUID;
80
+ messageId: z.ZodUUID;
81
+ epoch: z.ZodOptional<z.ZodUUID>;
82
+ }, z.core.$strip>>;
83
+ }, z.core.$strip>;
84
+ }, z.core.$strip>, z.ZodTransform<{
85
+ type: "CREATE";
86
+ input: any;
87
+ options: {
88
+ maxExecutions: number;
89
+ mode: "CONTINUOUS" | "LINEAR";
90
+ priority: number;
91
+ uploadUrl?: string | undefined;
92
+ streamUrl?: string | undefined;
93
+ maxPayloadSize?: number | undefined;
94
+ maxFileSize?: number | undefined;
95
+ continuous: {
96
+ maxReconnects: number;
97
+ };
98
+ referencedBy?: {
99
+ rootTaskId: string;
100
+ taskId: string;
101
+ nodeId: string;
102
+ messageId: string;
103
+ epoch?: string | undefined;
104
+ } | undefined;
105
+ };
106
+ treeList: {
107
+ tree: {
108
+ nodes: ({
109
+ id: string;
110
+ type: "entry";
111
+ alias?: string | undefined;
112
+ inputSchema: import("json-schema").JSONSchema7;
113
+ } | {
114
+ outputs: {
115
+ name: string | null;
116
+ schema: import("json-schema").JSONSchema7 | null;
117
+ }[];
118
+ id: string;
119
+ type: "service";
120
+ alias?: string | undefined;
121
+ inputSchema: {
122
+ type: "null";
123
+ } | ({
124
+ type: "object";
125
+ } & import("json-schema").JSONSchema7) | ({
126
+ $ref: string;
127
+ } & import("json-schema").JSONSchema7) | ({
128
+ oneOf: ({
129
+ type: "null";
130
+ } | ({
131
+ type: "object";
132
+ } & import("json-schema").JSONSchema7) | ({
133
+ $ref: string;
134
+ } & import("json-schema").JSONSchema7))[];
135
+ } & import("json-schema").JSONSchema7);
136
+ name: string;
137
+ version: string;
138
+ configuration?: any;
139
+ configurationSchema: import("json-schema").JSONSchema7;
140
+ ttl?: number | undefined;
141
+ retry: number;
142
+ retryDelay?: number | undefined;
143
+ mode: "CONTINUOUS" | "LINEAR";
144
+ privileged: boolean;
145
+ wireCodec?: "json" | "msgpack" | undefined;
146
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
147
+ configurationServices?: {
148
+ outputs: {
149
+ name: string | null;
150
+ schema: import("json-schema").JSONSchema7 | null;
151
+ }[];
152
+ id: string;
153
+ type: "service";
154
+ alias?: string | undefined;
155
+ inputSchema: {
156
+ type: "null";
157
+ } | ({
158
+ type: "object";
159
+ } & import("json-schema").JSONSchema7) | ({
160
+ $ref: string;
161
+ } & import("json-schema").JSONSchema7) | ({
162
+ oneOf: ({
163
+ type: "null";
164
+ } | ({
165
+ type: "object";
166
+ } & import("json-schema").JSONSchema7) | ({
167
+ $ref: string;
168
+ } & import("json-schema").JSONSchema7))[];
169
+ } & import("json-schema").JSONSchema7);
170
+ name: string;
171
+ version: string;
172
+ configuration?: any;
173
+ configurationSchema: import("json-schema").JSONSchema7;
174
+ ttl?: number | undefined;
175
+ retry: number;
176
+ retryDelay?: number | undefined;
177
+ mode: "CONTINUOUS" | "LINEAR";
178
+ privileged: boolean;
179
+ wireCodec?: "json" | "msgpack" | undefined;
180
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
181
+ configurationServices?: /*elided*/ any[] | undefined;
182
+ }[] | undefined;
183
+ } | {
184
+ outputs: {
185
+ name: string | null;
186
+ schema: import("json-schema").JSONSchema7 | null;
187
+ }[];
188
+ id: string;
189
+ type: "logic";
190
+ alias?: string | undefined;
191
+ script: string;
192
+ concurrency: boolean;
193
+ language: "javascript" | "python" | "typescript";
194
+ maxExecutionTime: number;
195
+ } | {
196
+ id: string;
197
+ type: "or";
198
+ alias?: string | undefined;
199
+ } | {
200
+ outputs: {
201
+ name: string | null;
202
+ schema: import("json-schema").JSONSchema7 | null;
203
+ }[];
204
+ id: string;
205
+ type: "reference";
206
+ alias?: string | undefined;
207
+ reference: string;
208
+ enabled: boolean;
209
+ inputSchema: {
210
+ type: "null";
211
+ } | ({
212
+ type: "object";
213
+ } & import("json-schema").JSONSchema7) | ({
214
+ $ref: string;
215
+ } & import("json-schema").JSONSchema7) | ({
216
+ oneOf: ({
217
+ type: "null";
218
+ } | ({
219
+ type: "object";
220
+ } & import("json-schema").JSONSchema7) | ({
221
+ $ref: string;
222
+ } & import("json-schema").JSONSchema7))[];
223
+ } & import("json-schema").JSONSchema7);
224
+ } | {
225
+ id: string;
226
+ type: "exit";
227
+ alias?: string | undefined;
228
+ inputSchema?: import("json-schema").JSONSchema7 | undefined;
229
+ } | {
230
+ id: string;
231
+ type: "comment";
232
+ text: string;
233
+ alias?: string | undefined;
234
+ })[];
235
+ edges: {
236
+ id: string;
237
+ source: string;
238
+ sourceHandle: string | null;
239
+ target: string;
240
+ }[];
241
+ };
242
+ references?: {
243
+ id: string;
244
+ options: {
245
+ maxExecutions: number;
246
+ mode: "CONTINUOUS" | "LINEAR";
247
+ };
248
+ tree: {
249
+ nodes: ({
250
+ id: string;
251
+ type: "entry";
252
+ alias?: string | undefined;
253
+ inputSchema: import("json-schema").JSONSchema7;
254
+ } | {
255
+ outputs: {
256
+ name: string | null;
257
+ schema: import("json-schema").JSONSchema7 | null;
258
+ }[];
259
+ id: string;
260
+ type: "service";
261
+ alias?: string | undefined;
262
+ inputSchema: {
263
+ type: "null";
264
+ } | ({
265
+ type: "object";
266
+ } & import("json-schema").JSONSchema7) | ({
267
+ $ref: string;
268
+ } & import("json-schema").JSONSchema7) | ({
269
+ oneOf: ({
270
+ type: "null";
271
+ } | ({
272
+ type: "object";
273
+ } & import("json-schema").JSONSchema7) | ({
274
+ $ref: string;
275
+ } & import("json-schema").JSONSchema7))[];
276
+ } & import("json-schema").JSONSchema7);
277
+ name: string;
278
+ version: string;
279
+ configuration?: any;
280
+ configurationSchema: import("json-schema").JSONSchema7;
281
+ ttl?: number | undefined;
282
+ retry: number;
283
+ retryDelay?: number | undefined;
284
+ mode: "CONTINUOUS" | "LINEAR";
285
+ privileged: boolean;
286
+ wireCodec?: "json" | "msgpack" | undefined;
287
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
288
+ configurationServices?: {
289
+ outputs: {
290
+ name: string | null;
291
+ schema: import("json-schema").JSONSchema7 | null;
292
+ }[];
293
+ id: string;
294
+ type: "service";
295
+ alias?: string | undefined;
296
+ inputSchema: {
297
+ type: "null";
298
+ } | ({
299
+ type: "object";
300
+ } & import("json-schema").JSONSchema7) | ({
301
+ $ref: string;
302
+ } & import("json-schema").JSONSchema7) | ({
303
+ oneOf: ({
304
+ type: "null";
305
+ } | ({
306
+ type: "object";
307
+ } & import("json-schema").JSONSchema7) | ({
308
+ $ref: string;
309
+ } & import("json-schema").JSONSchema7))[];
310
+ } & import("json-schema").JSONSchema7);
311
+ name: string;
312
+ version: string;
313
+ configuration?: any;
314
+ configurationSchema: import("json-schema").JSONSchema7;
315
+ ttl?: number | undefined;
316
+ retry: number;
317
+ retryDelay?: number | undefined;
318
+ mode: "CONTINUOUS" | "LINEAR";
319
+ privileged: boolean;
320
+ wireCodec?: "json" | "msgpack" | undefined;
321
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
322
+ configurationServices?: any[] | undefined;
323
+ }[] | undefined;
324
+ } | {
325
+ outputs: {
326
+ name: string | null;
327
+ schema: import("json-schema").JSONSchema7 | null;
328
+ }[];
329
+ id: string;
330
+ type: "logic";
331
+ alias?: string | undefined;
332
+ script: string;
333
+ concurrency: boolean;
334
+ language: "javascript" | "python" | "typescript";
335
+ maxExecutionTime: number;
336
+ } | {
337
+ id: string;
338
+ type: "or";
339
+ alias?: string | undefined;
340
+ } | {
341
+ outputs: {
342
+ name: string | null;
343
+ schema: import("json-schema").JSONSchema7 | null;
344
+ }[];
345
+ id: string;
346
+ type: "reference";
347
+ alias?: string | undefined;
348
+ reference: string;
349
+ enabled: boolean;
350
+ inputSchema: {
351
+ type: "null";
352
+ } | ({
353
+ type: "object";
354
+ } & import("json-schema").JSONSchema7) | ({
355
+ $ref: string;
356
+ } & import("json-schema").JSONSchema7) | ({
357
+ oneOf: ({
358
+ type: "null";
359
+ } | ({
360
+ type: "object";
361
+ } & import("json-schema").JSONSchema7) | ({
362
+ $ref: string;
363
+ } & import("json-schema").JSONSchema7))[];
364
+ } & import("json-schema").JSONSchema7);
365
+ } | {
366
+ id: string;
367
+ type: "exit";
368
+ alias?: string | undefined;
369
+ inputSchema?: import("json-schema").JSONSchema7 | undefined;
370
+ } | {
371
+ id: string;
372
+ type: "comment";
373
+ text: string;
374
+ alias?: string | undefined;
375
+ })[];
376
+ edges: {
377
+ id: string;
378
+ source: string;
379
+ sourceHandle: string | null;
380
+ target: string;
381
+ }[];
382
+ };
383
+ }[] | undefined;
384
+ schemas?: Record<string, import("json-schema").JSONSchema7> | undefined;
385
+ };
386
+ }, {
387
+ type: "CREATE";
388
+ treeList: {
389
+ tree: {
390
+ nodes: any[];
391
+ edges: any[];
392
+ };
393
+ references?: any[] | undefined;
394
+ schemas?: Record<string, any> | undefined;
395
+ };
396
+ input: any;
397
+ options: {
398
+ maxExecutions: number;
399
+ mode: "CONTINUOUS" | "LINEAR";
400
+ priority: number;
401
+ uploadUrl?: string | undefined;
402
+ streamUrl?: string | undefined;
403
+ maxPayloadSize?: number | undefined;
404
+ maxFileSize?: number | undefined;
405
+ continuous: {
406
+ maxReconnects: number;
407
+ };
408
+ referencedBy?: {
409
+ rootTaskId: string;
410
+ taskId: string;
411
+ nodeId: string;
412
+ messageId: string;
413
+ epoch?: string | undefined;
414
+ } | undefined;
415
+ };
416
+ }>>;
417
+ /**
418
+ * The same command, for a tree parser that yields to the event loop (#134).
419
+ *
420
+ * A separate factory rather than one that takes either kind, because the two
421
+ * cannot share a call site: zod only awaits a transform whose RETURN is a
422
+ * promise, so the async arm has to be an `async` transform — and that makes the
423
+ * whole schema `parseAsync`-only, which the sync side must not become. Both
424
+ * memoizing callers are on this arm now (#138 moved `task-builder` over, which
425
+ * cost it nothing: `publishTask` was already `async`); the sync arm is the
426
+ * `commandSchema` union and anyone validating a CREATE without a cache. What
427
+ * they share is everything that defines the command: one envelope, one
428
+ * validation input.
429
+ */
430
+ export declare function createCommandSchemaWithAsync(parseTreeList: (treeList: InputTreeList) => Promise<TreeList>): z.ZodPipe<z.ZodObject<{
431
+ type: z.ZodLiteral<"CREATE">;
432
+ treeList: z.ZodObject<{
433
+ tree: z.ZodObject<{
434
+ nodes: z.ZodArray<z.ZodAny>;
435
+ edges: z.ZodArray<z.ZodAny>;
436
+ }, z.core.$strip>;
437
+ references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
438
+ schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
439
+ }, z.core.$strip>;
440
+ input: z.ZodAny;
441
+ options: z.ZodObject<{
442
+ maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
443
+ mode: z.ZodDefault<z.ZodEnum<{
444
+ CONTINUOUS: "CONTINUOUS";
445
+ LINEAR: "LINEAR";
446
+ }>>;
447
+ priority: z.ZodDefault<z.ZodInt>;
448
+ uploadUrl: z.ZodOptional<z.ZodString>;
449
+ streamUrl: z.ZodOptional<z.ZodString>;
450
+ maxPayloadSize: z.ZodOptional<z.ZodNumber>;
451
+ maxFileSize: z.ZodOptional<z.ZodNumber>;
452
+ continuous: z.ZodDefault<z.ZodObject<{
453
+ maxReconnects: z.ZodDefault<z.ZodNumber>;
454
+ }, z.core.$strip>>;
455
+ referencedBy: z.ZodOptional<z.ZodObject<{
456
+ rootTaskId: z.ZodUUID;
457
+ taskId: z.ZodUUID;
458
+ nodeId: z.ZodUUID;
459
+ messageId: z.ZodUUID;
460
+ epoch: z.ZodOptional<z.ZodUUID>;
461
+ }, z.core.$strip>>;
462
+ }, z.core.$strip>;
463
+ }, z.core.$strip>, z.ZodTransform<{
464
+ type: "CREATE";
465
+ input: any;
466
+ options: {
467
+ maxExecutions: number;
468
+ mode: "CONTINUOUS" | "LINEAR";
469
+ priority: number;
470
+ uploadUrl?: string | undefined;
471
+ streamUrl?: string | undefined;
472
+ maxPayloadSize?: number | undefined;
473
+ maxFileSize?: number | undefined;
474
+ continuous: {
475
+ maxReconnects: number;
476
+ };
477
+ referencedBy?: {
478
+ rootTaskId: string;
479
+ taskId: string;
480
+ nodeId: string;
481
+ messageId: string;
482
+ epoch?: string | undefined;
483
+ } | undefined;
484
+ };
485
+ treeList: {
486
+ tree: {
487
+ nodes: ({
488
+ id: string;
489
+ type: "entry";
490
+ alias?: string | undefined;
491
+ inputSchema: import("json-schema").JSONSchema7;
492
+ } | {
493
+ outputs: {
494
+ name: string | null;
495
+ schema: import("json-schema").JSONSchema7 | null;
496
+ }[];
497
+ id: string;
498
+ type: "service";
499
+ alias?: string | undefined;
500
+ inputSchema: {
501
+ type: "null";
502
+ } | ({
503
+ type: "object";
504
+ } & import("json-schema").JSONSchema7) | ({
505
+ $ref: string;
506
+ } & import("json-schema").JSONSchema7) | ({
507
+ oneOf: ({
508
+ type: "null";
509
+ } | ({
510
+ type: "object";
511
+ } & import("json-schema").JSONSchema7) | ({
512
+ $ref: string;
513
+ } & import("json-schema").JSONSchema7))[];
514
+ } & import("json-schema").JSONSchema7);
515
+ name: string;
516
+ version: string;
517
+ configuration?: any;
518
+ configurationSchema: import("json-schema").JSONSchema7;
519
+ ttl?: number | undefined;
520
+ retry: number;
521
+ retryDelay?: number | undefined;
522
+ mode: "CONTINUOUS" | "LINEAR";
523
+ privileged: boolean;
524
+ wireCodec?: "json" | "msgpack" | undefined;
525
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
526
+ configurationServices?: {
527
+ outputs: {
528
+ name: string | null;
529
+ schema: import("json-schema").JSONSchema7 | null;
530
+ }[];
531
+ id: string;
532
+ type: "service";
533
+ alias?: string | undefined;
534
+ inputSchema: {
535
+ type: "null";
536
+ } | ({
537
+ type: "object";
538
+ } & import("json-schema").JSONSchema7) | ({
539
+ $ref: string;
540
+ } & import("json-schema").JSONSchema7) | ({
541
+ oneOf: ({
542
+ type: "null";
543
+ } | ({
544
+ type: "object";
545
+ } & import("json-schema").JSONSchema7) | ({
546
+ $ref: string;
547
+ } & import("json-schema").JSONSchema7))[];
548
+ } & import("json-schema").JSONSchema7);
549
+ name: string;
550
+ version: string;
551
+ configuration?: any;
552
+ configurationSchema: import("json-schema").JSONSchema7;
553
+ ttl?: number | undefined;
554
+ retry: number;
555
+ retryDelay?: number | undefined;
556
+ mode: "CONTINUOUS" | "LINEAR";
557
+ privileged: boolean;
558
+ wireCodec?: "json" | "msgpack" | undefined;
559
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
560
+ configurationServices?: /*elided*/ any[] | undefined;
561
+ }[] | undefined;
562
+ } | {
563
+ outputs: {
564
+ name: string | null;
565
+ schema: import("json-schema").JSONSchema7 | null;
566
+ }[];
567
+ id: string;
568
+ type: "logic";
569
+ alias?: string | undefined;
570
+ script: string;
571
+ concurrency: boolean;
572
+ language: "javascript" | "python" | "typescript";
573
+ maxExecutionTime: number;
574
+ } | {
575
+ id: string;
576
+ type: "or";
577
+ alias?: string | undefined;
578
+ } | {
579
+ outputs: {
580
+ name: string | null;
581
+ schema: import("json-schema").JSONSchema7 | null;
582
+ }[];
583
+ id: string;
584
+ type: "reference";
585
+ alias?: string | undefined;
586
+ reference: string;
587
+ enabled: boolean;
588
+ inputSchema: {
589
+ type: "null";
590
+ } | ({
591
+ type: "object";
592
+ } & import("json-schema").JSONSchema7) | ({
593
+ $ref: string;
594
+ } & import("json-schema").JSONSchema7) | ({
595
+ oneOf: ({
596
+ type: "null";
597
+ } | ({
598
+ type: "object";
599
+ } & import("json-schema").JSONSchema7) | ({
600
+ $ref: string;
601
+ } & import("json-schema").JSONSchema7))[];
602
+ } & import("json-schema").JSONSchema7);
603
+ } | {
604
+ id: string;
605
+ type: "exit";
606
+ alias?: string | undefined;
607
+ inputSchema?: import("json-schema").JSONSchema7 | undefined;
608
+ } | {
609
+ id: string;
610
+ type: "comment";
611
+ text: string;
612
+ alias?: string | undefined;
613
+ })[];
614
+ edges: {
615
+ id: string;
616
+ source: string;
617
+ sourceHandle: string | null;
618
+ target: string;
619
+ }[];
620
+ };
621
+ references?: {
622
+ id: string;
623
+ options: {
624
+ maxExecutions: number;
625
+ mode: "CONTINUOUS" | "LINEAR";
626
+ };
627
+ tree: {
628
+ nodes: ({
629
+ id: string;
630
+ type: "entry";
631
+ alias?: string | undefined;
632
+ inputSchema: import("json-schema").JSONSchema7;
633
+ } | {
634
+ outputs: {
635
+ name: string | null;
636
+ schema: import("json-schema").JSONSchema7 | null;
637
+ }[];
638
+ id: string;
639
+ type: "service";
640
+ alias?: string | undefined;
641
+ inputSchema: {
642
+ type: "null";
643
+ } | ({
644
+ type: "object";
645
+ } & import("json-schema").JSONSchema7) | ({
646
+ $ref: string;
647
+ } & import("json-schema").JSONSchema7) | ({
648
+ oneOf: ({
649
+ type: "null";
650
+ } | ({
651
+ type: "object";
652
+ } & import("json-schema").JSONSchema7) | ({
653
+ $ref: string;
654
+ } & import("json-schema").JSONSchema7))[];
655
+ } & import("json-schema").JSONSchema7);
656
+ name: string;
657
+ version: string;
658
+ configuration?: any;
659
+ configurationSchema: import("json-schema").JSONSchema7;
660
+ ttl?: number | undefined;
661
+ retry: number;
662
+ retryDelay?: number | undefined;
663
+ mode: "CONTINUOUS" | "LINEAR";
664
+ privileged: boolean;
665
+ wireCodec?: "json" | "msgpack" | undefined;
666
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
667
+ configurationServices?: {
668
+ outputs: {
669
+ name: string | null;
670
+ schema: import("json-schema").JSONSchema7 | null;
671
+ }[];
672
+ id: string;
673
+ type: "service";
674
+ alias?: string | undefined;
675
+ inputSchema: {
676
+ type: "null";
677
+ } | ({
678
+ type: "object";
679
+ } & import("json-schema").JSONSchema7) | ({
680
+ $ref: string;
681
+ } & import("json-schema").JSONSchema7) | ({
682
+ oneOf: ({
683
+ type: "null";
684
+ } | ({
685
+ type: "object";
686
+ } & import("json-schema").JSONSchema7) | ({
687
+ $ref: string;
688
+ } & import("json-schema").JSONSchema7))[];
689
+ } & import("json-schema").JSONSchema7);
690
+ name: string;
691
+ version: string;
692
+ configuration?: any;
693
+ configurationSchema: import("json-schema").JSONSchema7;
694
+ ttl?: number | undefined;
695
+ retry: number;
696
+ retryDelay?: number | undefined;
697
+ mode: "CONTINUOUS" | "LINEAR";
698
+ privileged: boolean;
699
+ wireCodec?: "json" | "msgpack" | undefined;
700
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
701
+ configurationServices?: any[] | undefined;
702
+ }[] | undefined;
703
+ } | {
704
+ outputs: {
705
+ name: string | null;
706
+ schema: import("json-schema").JSONSchema7 | null;
707
+ }[];
708
+ id: string;
709
+ type: "logic";
710
+ alias?: string | undefined;
711
+ script: string;
712
+ concurrency: boolean;
713
+ language: "javascript" | "python" | "typescript";
714
+ maxExecutionTime: number;
715
+ } | {
716
+ id: string;
717
+ type: "or";
718
+ alias?: string | undefined;
719
+ } | {
720
+ outputs: {
721
+ name: string | null;
722
+ schema: import("json-schema").JSONSchema7 | null;
723
+ }[];
724
+ id: string;
725
+ type: "reference";
726
+ alias?: string | undefined;
727
+ reference: string;
728
+ enabled: boolean;
729
+ inputSchema: {
730
+ type: "null";
731
+ } | ({
732
+ type: "object";
733
+ } & import("json-schema").JSONSchema7) | ({
734
+ $ref: string;
735
+ } & import("json-schema").JSONSchema7) | ({
736
+ oneOf: ({
737
+ type: "null";
738
+ } | ({
739
+ type: "object";
740
+ } & import("json-schema").JSONSchema7) | ({
741
+ $ref: string;
742
+ } & import("json-schema").JSONSchema7))[];
743
+ } & import("json-schema").JSONSchema7);
744
+ } | {
745
+ id: string;
746
+ type: "exit";
747
+ alias?: string | undefined;
748
+ inputSchema?: import("json-schema").JSONSchema7 | undefined;
749
+ } | {
750
+ id: string;
751
+ type: "comment";
752
+ text: string;
753
+ alias?: string | undefined;
754
+ })[];
755
+ edges: {
756
+ id: string;
757
+ source: string;
758
+ sourceHandle: string | null;
759
+ target: string;
760
+ }[];
761
+ };
762
+ }[] | undefined;
763
+ schemas?: Record<string, import("json-schema").JSONSchema7> | undefined;
764
+ };
765
+ }, {
766
+ type: "CREATE";
767
+ treeList: {
768
+ tree: {
769
+ nodes: any[];
770
+ edges: any[];
771
+ };
772
+ references?: any[] | undefined;
773
+ schemas?: Record<string, any> | undefined;
774
+ };
775
+ input: any;
776
+ options: {
777
+ maxExecutions: number;
778
+ mode: "CONTINUOUS" | "LINEAR";
779
+ priority: number;
780
+ uploadUrl?: string | undefined;
781
+ streamUrl?: string | undefined;
782
+ maxPayloadSize?: number | undefined;
783
+ maxFileSize?: number | undefined;
784
+ continuous: {
785
+ maxReconnects: number;
786
+ };
787
+ referencedBy?: {
788
+ rootTaskId: string;
789
+ taskId: string;
790
+ nodeId: string;
791
+ messageId: string;
792
+ epoch?: string | undefined;
793
+ } | undefined;
794
+ };
795
+ }>>;
7
796
  export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
8
797
  type: z.ZodLiteral<"CREATE">;
9
798
  treeList: z.ZodObject<{
@@ -99,6 +888,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
99
888
  mode: "CONTINUOUS" | "LINEAR";
100
889
  privileged: boolean;
101
890
  wireCodec?: "json" | "msgpack" | undefined;
891
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
102
892
  configurationServices?: {
103
893
  outputs: {
104
894
  name: string | null;
@@ -132,6 +922,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
132
922
  mode: "CONTINUOUS" | "LINEAR";
133
923
  privileged: boolean;
134
924
  wireCodec?: "json" | "msgpack" | undefined;
925
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
135
926
  configurationServices?: /*elided*/ any[] | undefined;
136
927
  }[] | undefined;
137
928
  } | {
@@ -238,6 +1029,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
238
1029
  mode: "CONTINUOUS" | "LINEAR";
239
1030
  privileged: boolean;
240
1031
  wireCodec?: "json" | "msgpack" | undefined;
1032
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
241
1033
  configurationServices?: {
242
1034
  outputs: {
243
1035
  name: string | null;
@@ -271,6 +1063,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
271
1063
  mode: "CONTINUOUS" | "LINEAR";
272
1064
  privileged: boolean;
273
1065
  wireCodec?: "json" | "msgpack" | undefined;
1066
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
274
1067
  configurationServices?: any[] | undefined;
275
1068
  }[] | undefined;
276
1069
  } | {
@@ -370,6 +1163,8 @@ export type CreateCommand = z.infer<typeof createCommandSchema>;
370
1163
  export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
371
1164
  type: z.ZodLiteral<"ABORT">;
372
1165
  reason: z.ZodOptional<z.ZodString>;
1166
+ }, z.core.$strip>, z.ZodObject<{
1167
+ type: z.ZodLiteral<"RECONCILE">;
373
1168
  }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
374
1169
  type: z.ZodLiteral<"CREATE">;
375
1170
  treeList: z.ZodObject<{
@@ -465,6 +1260,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
465
1260
  mode: "CONTINUOUS" | "LINEAR";
466
1261
  privileged: boolean;
467
1262
  wireCodec?: "json" | "msgpack" | undefined;
1263
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
468
1264
  configurationServices?: {
469
1265
  outputs: {
470
1266
  name: string | null;
@@ -498,6 +1294,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
498
1294
  mode: "CONTINUOUS" | "LINEAR";
499
1295
  privileged: boolean;
500
1296
  wireCodec?: "json" | "msgpack" | undefined;
1297
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
501
1298
  configurationServices?: /*elided*/ any[] | undefined;
502
1299
  }[] | undefined;
503
1300
  } | {
@@ -604,6 +1401,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
604
1401
  mode: "CONTINUOUS" | "LINEAR";
605
1402
  privileged: boolean;
606
1403
  wireCodec?: "json" | "msgpack" | undefined;
1404
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
607
1405
  configurationServices?: {
608
1406
  outputs: {
609
1407
  name: string | null;
@@ -637,6 +1435,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
637
1435
  mode: "CONTINUOUS" | "LINEAR";
638
1436
  privileged: boolean;
639
1437
  wireCodec?: "json" | "msgpack" | undefined;
1438
+ wireCodecReason?: "fleet-capable" | "missing-capability" | "no-replicas" | "presence-unavailable" | "replicas-unaccounted" | undefined;
640
1439
  configurationServices?: any[] | undefined;
641
1440
  }[] | undefined;
642
1441
  } | {