@requence/task 1.0.0-alpha.49 → 1.0.0-alpha.50

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @requence/task
 
+## 1.0.0-alpha.50
+
+### Patch Changes
+
+- 6922266: trace ids
+
 ## 1.0.0-alpha.49
 
 ### Patch Changes

package/README.md

@@ -0,0 +1,383 @@
+# @requence/task
+
+This package lets you start and monitor Requence tasks programmatically from a TypeScript / Bun application.
+
+## Installation
+
+```bash
+npm install @requence/task
+```
+
+## Authentication
+
+Every call to `createTask` requires an **access token** — either a personal access token or a scoped token created at the organization, group, or project level.
+
+The token is resolved in this order:
+
+1. `accessToken` option passed to `createTask()`
+2. `REQUENCE_TASK_ACCESS_TOKEN` or `REQUENCE_ACCESS_TOKEN` environment variable
+3. `requence.task.accessToken` or `requence.accessToken` in `package.json`
+
+```bash
+REQUENCE_ACCESS_TOKEN=your-token bun run index.ts
+```
+
+## Basic Usage
+
+```typescript
+import { createTask } from '@requence/task'
+
+const result = await createTask({
+  taskTemplate: 'my-template',
+  input: { name: 'World' },
+})
+
+console.log(result.result) // The final output of the task
+```
+
+> **Note:** `await createTask(...)` waits for the **entire task** to finish. If you don't need to block, omit the `await` and use the returned task handle instead.
+
+## Task Handle
+
+`createTask` returns a **task handle** immediately. You can use it to access task metadata without waiting for the task to complete:
+
+```typescript
+const task = createTask({ taskTemplate: 'my-template', input: {} })
+
+const taskId = await task.getTaskId()   // Resolves as soon as the task is created
+const taskUrl = await task.getTaskUrl() // URL to view the task in the Requence UI
+
+await task.abort('No longer needed')    // Abort the running task
+await task.protect()                    // Protect the task from automatic cleanup
+
+// Await the final result when you need it
+const result = await task
+```
+
+The task handle is also an **AsyncIterable** — iterate over it to stream updates as the task executes.
+
+### Awaiting Finalization (Cheap Monitoring)
+
+By default, awaiting the result or iterating the handle starts full SSE monitoring. If you only need to confirm that the task passed input validation and started on the backend — without tracking every node — await `task.finalized()`:
+
+```typescript
+const task = createTask({ taskTemplate: 'my-template', input: { /* ... */ } })
+
+try {
+  const taskId = await task.finalized()
+  console.log(`Task ${taskId} is running in the background`)
+} catch (error) {
+  console.error('Validation failed:', error.message)
+}
+```
+
+`finalized()` resolves with the task ID on success, or rejects with a `TaskError` if the task cannot be created (e.g. schema validation failure).
+
+## Options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `taskTemplate` | `string` | — | **Required.** Name of the task template |
+| `input` | `unknown` | — | Required when the template defines an input schema |
+| `name` | `string` | — | Human-readable task name shown in the UI |
+| `priority` | `number` | `2` | Priority `0` (lowest) to `4` (highest) |
+| `accessToken` | `string` | — | Access token (falls back to env / config file) |
+| `requireAck` | `boolean` | `false` | Enable delivery guarantee (see below) |
+| `suppressBranchWarning` | `boolean` | `false` | Suppress the branch warning when running on a non-live branch |
+
+## Result
+
+When awaited, the task handle resolves to a result object:
+
+```typescript
+const result = await createTask({ taskTemplate: 'my-template', input: {} })
+
+result.input            // The input you provided
+result.result           // The final task output
+result.taskId           // Unique task identifier
+result.taskUrl          // URL to view the task in the Requence UI
+result.getNodeData(alias)  // Get output from a specific node by alias
+result.getNodeError(alias) // Get error from a specific node by alias
+```
+
+## Streaming Updates
+
+The task handle is an `AsyncIterable` that emits updates as the task executes. Iterate over it with `for await`:
+
+```typescript
+const task = createTask({
+  taskTemplate: 'my-template',
+  input: { data: [1, 2, 3] },
+})
+
+for await (const update of task) {
+  switch (update.type) {
+    case 'taskStart':
+      console.log(`Task ${update.taskId} started`)
+      break
+    case 'nodeStart':
+      console.log(`Node ${update.node.alias ?? update.node.id} started`)
+      break
+    case 'nodeUpdate':
+      console.log(`Node output:`, update.data)
+      break
+    case 'nodeError':
+      console.log(`Node error:`, update.error)
+      break
+    case 'nodeDefer':
+      console.log(`Node deferred:`, update.reason)
+      break
+    case 'nodeEnd':
+      console.log(`Node ${update.node.alias ?? update.node.id} finished`)
+      break
+    case 'taskEnd':
+      console.log(`Task completed:`, update.context.result)
+      break
+    case 'taskError':
+      console.log(`Task failed:`, update.reason)
+      break
+    case 'taskAborted':
+      console.log(`Task aborted:`, update.reason)
+      break
+  }
+}
+```
+
+### `onUpdate` callback
+
+Alternatively, pass a callback as the second argument to stream updates while still awaiting the final result:
+
+```typescript
+const result = await createTask(
+  { taskTemplate: 'my-template', input: {} },
+  (update) => {
+    console.log(`[${update.type}]`, update.timestamp)
+  },
+)
+```
+
+### Update types
+
+| Type | Description |
+|---|---|
+| `taskStart` | Task execution has begun. Contains `input` and `taskId`. |
+| `nodeStart` | A node started processing. Contains `node` info (id, type, alias). |
+| `nodeUpdate` | A node produced output. Contains `data` and `output` (named output, if any). |
+| `nodeError` | A node encountered an error. Contains `error` message. |
+| `nodeDefer` | A node has been deferred (waiting for an external callback). |
+| `nodeEnd` | A node finished processing. |
+| `taskEnd` | The task completed successfully. Contains final `result`. |
+| `taskError` | The task failed. Contains `reason`. |
+| `taskAborted` | The task was aborted. Contains `reason`. |
+
+### Context on every update
+
+Every update includes a `context` object with the current accumulated state:
+
+```typescript
+update.context.input                  // The task input
+update.context.taskId                 // The task ID
+update.context.result                 // Accumulated result (partial until taskEnd)
+update.context.getNodeData(alias)     // Output from a specific node by alias
+update.context.getNodeError(alias)    // Error from a specific node by alias
+```
+
+## Aborting a Task
+
+Via the task handle:
+
+```typescript
+const task = createTask({ taskTemplate: 'my-template', input: {} })
+await task.abort('No longer needed')
+```
+
+Or standalone, using a known task ID:
+
+```typescript
+import { abortTask } from '@requence/task'
+
+await abortTask({
+  taskId: 'some-task-id',
+  reason: 'Cancelled by user',
+})
+```
+
+## Protecting a Task
+
+Protected tasks are excluded from automatic cleanup — useful for important results you want to keep indefinitely.
+
+Via the task handle:
+
+```typescript
+const task = createTask({ taskTemplate: 'my-template', input: {} })
+await task.protect()
+```
+
+Or standalone:
+
+```typescript
+import { protectTask } from '@requence/task'
+
+await protectTask({ taskId: 'some-task-id' })
+```
+
+## Fetching a Task by ID
+
+Retrieve the current state of any task:
+
+```typescript
+import { getTask } from '@requence/task'
+
+const task = await getTask('some-task-id')
+// or: getTask({ taskId: 'some-task-id', accessToken: '...' })
+
+task.status        // 'SUCCESSFUL' | 'FAILED' | 'IDLE' | 'PENDING' | 'RUNNING' | 'STOPPED' | 'AWAITING_DELIVERY'
+task.statusText    // Human-readable status description, if any
+task.taskTemplate  // The task template name
+task.name          // Human-readable task name
+task.branch        // 'live' or a branch name
+
+task.context.input                 // The task's input
+task.context.result                // The task's result (if finished)
+task.context.getNodeData(alias)    // Output from a specific node
+task.context.getNodeError(alias)   // Error from a specific node
+```
+
+## Recreating a Task
+
+Re-run an existing task with the same template and input:
+
+```typescript
+import { recreateTask } from '@requence/task'
+
+const task = await recreateTask({
+  taskId: 'some-task-id',
+  name: 'My Retry',      // Optional — overrides the original name
+  priority: 3,           // Optional — overrides the original priority
+})
+
+const result = await task
+```
+
+## Watching All Tasks (`watchTasks`)
+
+Subscribe to real-time updates across **all tasks** — useful for dashboards, monitoring systems, or audit logs.
+
+```typescript
+import { watchTasks } from '@requence/task'
+
+const stop = watchTasks({
+  since: new Date(),
+  onUpdate(update) {
+    console.log(`[${update.type}] Task ${update.context.taskId}`)
+  },
+})
+
+// Later — disconnect the watcher
+stop()
+```
+
+`watchTasks` returns a stop function that is also an **AsyncIterable**:
+
+```typescript
+const watcher = watchTasks({ since: new Date() })
+
+for await (const update of watcher) {
+  console.log(update.type, update.context.taskId)
+
+  if (shouldStop) {
+    watcher() // stop watching
+    break
+  }
+}
+```
+
+### `watchTasks` options
+
+| Option | Type | Description |
+|---|---|---|
+| `since` | `Date` | **Required.** Only receive updates after this timestamp. |
+| `accessToken` | `string` | Access token (falls back to env / config file) |
+| `filter.only` | `string[]` | Filter to specific update types (e.g. `['taskEnd', 'taskError']`) |
+| `onUpdate` | `function` | Callback for each update |
+| `onConnect` | `function` | Called when the connection is established |
+| `onReconnecting` | `function` | Called when the connection is being re-established |
+| `onError` | `function` | Called on connection errors — receives `(status, reason)` |
+
+### Incomplete updates
+
+Each update from `watchTasks` includes an `incomplete` flag. When `true`, it means the watcher connected after the task had already started and the `taskStart` event was missed. Use this to decide whether to skip or partially process the update.
+
+It also includes a `rootTaskId` field — the ID of the root task when the update belongs to a sub-task, or `null` for top-level tasks.
+
+## Delivery Guarantee
+
+By default, a task transitions immediately from `RUNNING` to `SUCCESSFUL` / `FAILED` / `STOPPED` when it finishes. If the process that started the task crashes at the exact moment the terminal event is emitted, the event can be lost.
+
+Setting `requireAck: true` enables an explicit acknowledgement step:
+
+1. When the task reaches its terminal state the backend holds it in **`AWAITING_DELIVERY`** instead of immediately finalising.
+2. The SDK receives the terminal event over SSE and automatically sends an ACK back.
+3. Only after the ACK is received does the task move to its real final status, and the exact delivery timestamp is recorded.
+
+```typescript
+const result = await createTask({
+  taskTemplate: 'my-template',
+  input: { /* ... */ },
+  requireAck: true,
+})
+// Resolves only after the ACK has been confirmed
+```
+
+`requireAck` also works with `watchTasks` — when a task with `requireAck` reaches its terminal state, the watcher ACKs it automatically using the same access token.
+
+## CLI — Generate Types
+
+The package ships with a CLI that generates TypeScript types for your task templates, derived from the schemas defined in the Requence UI:
+
+```bash
+npx requence-task generate-types
+```
+
+This creates a `requence-env.d.ts` file in your project root. TypeScript picks it up automatically — `input`, `result`, and node data will be fully typed.
+
+### Options
+
+| Option | Default | Description |
+|---|---|---|
+| `--access-token` | — | Access token (falls back to env / config file) |
+| `--outfile` | `requence-env.d.ts` | Name of the generated type file |
+| `--outdir` | `.` | Directory to write the type file to |
+
+The token resolution order for the CLI is the same as for `createTask`: option → `REQUENCE_TASK_ACCESS_TOKEN` / `REQUENCE_ACCESS_TOKEN` env var → `requence.task.accessToken` / `requence.accessToken` in `package.json`.
+
+## Full Example
+
+```typescript
+import { createTask, watchTasks } from '@requence/task'
+
+// Start a task and stream its progress
+const task = createTask(
+  {
+    taskTemplate: 'invoice-processing',
+    input: { invoiceUrl: 'https://...' },
+    name: 'Invoice #1234',
+    priority: 3,
+  },
+  (update) => {
+    if (update.type === 'nodeUpdate') {
+      console.log('Node result:', update.data)
+    }
+  },
+)
+
+const taskId = await task.getTaskId()
+console.log('Started task:', taskId)
+
+try {
+  const result = await task
+  console.log('Final result:', result.result)
+} catch (error) {
+  console.error('Task failed:', error.message)
+}
+```

package/build/types/helpers/src/protocol/NodeTree.d.ts

@@ -3,6 +3,7 @@ export type OutputName = string | null;
 type ExtendedEdge = Edge & {
     traversed: number;
     data?: string;
+    traceIds: string[];
 };
 type Cycle = {
     node: Node;
@@ -52,6 +53,7 @@ export declare class NodeTree {
         name: string;
         version: string;
         configurationSchema: import("json-schema").JSONSchema7;
+        mode: "LINEAR" | "CONTINUOUS";
         outputs: {
             name: string | null;
             schema: import("json-schema").JSONSchema7 | null;
@@ -129,6 +131,7 @@ export declare class NodeTree {
         name: string;
         version: string;
         configurationSchema: import("json-schema").JSONSchema7;
+        mode: "LINEAR" | "CONTINUOUS";
         outputs: {
             name: string | null;
             schema: import("json-schema").JSONSchema7 | null;
@@ -201,6 +204,7 @@ export declare class NodeTree {
         name: string;
         version: string;
         configurationSchema: import("json-schema").JSONSchema7;
+        mode: "LINEAR" | "CONTINUOUS";
         outputs: {
             name: string | null;
             schema: import("json-schema").JSONSchema7 | null;
@@ -273,6 +277,7 @@ export declare class NodeTree {
         name: string;
         version: string;
         configurationSchema: import("json-schema").JSONSchema7;
+        mode: "LINEAR" | "CONTINUOUS";
         outputs: {
             name: string | null;
             schema: import("json-schema").JSONSchema7 | null;
@@ -344,6 +349,7 @@ export declare class NodeTree {
         name: string;
         version: string;
         configurationSchema: import("json-schema").JSONSchema7;
+        mode: "LINEAR" | "CONTINUOUS";
         outputs: {
             name: string | null;
             schema: import("json-schema").JSONSchema7 | null;
@@ -428,6 +434,7 @@ export declare class NodeTree {
             name: string;
             version: string;
             configurationSchema: import("json-schema").JSONSchema7;
+            mode: "LINEAR" | "CONTINUOUS";
             outputs: {
                 name: string | null;
                 schema: import("json-schema").JSONSchema7 | null;
@@ -484,8 +491,9 @@ export declare class NodeTree {
         handle: OutputName;
     }[];
     getTriggers(nodeId: string): string[];
-    traverse(nodeId: string, outputName: OutputName): void;
-    traverseWithData(nodeId: string, outputName: OutputName, data: unknown, overwrite?: boolean): void;
+    getTraceIds(nodeId: string): string[];
+    traverse(nodeId: string, outputName: OutputName, traceIds?: string[]): void;
+    traverseWithData(nodeId: string, outputName: OutputName, data: unknown, overwrite?: boolean, traceIds?: string[]): void;
     disconnect(sourceNodeId: string, sourceNodeOutputName: OutputName, targetNodeId: string): void;
     getData(nodeId: string, outputName: OutputName): unknown;
     traversed(sourceNodeId: string, targetNodeId: string): boolean;

package/build/types/helpers/src/protocol/NodeTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeTree.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/NodeTree.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"NodeTree.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/NodeTree.ts"],"names":[],"mappings":"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"}

package/build/types/helpers/src/protocol/command.d.ts

@@ -24,6 +24,9 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
         priority: z.ZodDefault<z.ZodInt>;
         uploadUrl: z.ZodOptional<z.ZodString>;
         streamUrl: z.ZodOptional<z.ZodString>;
+        continuous: z.ZodDefault<z.ZodObject<{
+            maxReconnects: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         referencedBy: z.ZodOptional<z.ZodObject<{
             rootTaskId: z.ZodUUID;
             taskId: z.ZodUUID;
@@ -52,6 +55,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
                 name: string;
                 version: string;
                 configurationSchema: import("json-schema").JSONSchema7;
+                mode: "LINEAR" | "CONTINUOUS";
                 outputs: {
                     name: string | null;
                     schema: import("json-schema").JSONSchema7 | null;
@@ -137,6 +141,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
                     name: string;
                     version: string;
                     configurationSchema: import("json-schema").JSONSchema7;
+                    mode: "LINEAR" | "CONTINUOUS";
                     outputs: {
                         name: string | null;
                         schema: import("json-schema").JSONSchema7 | null;
@@ -206,6 +211,9 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
         maxExecutions: number;
         mode: "LINEAR" | "CONTINUOUS";
         priority: number;
+        continuous: {
+            maxReconnects: number;
+        };
         uploadUrl?: string | undefined;
         streamUrl?: string | undefined;
         referencedBy?: {
@@ -230,6 +238,9 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
         maxExecutions: number;
         mode: "LINEAR" | "CONTINUOUS";
         priority: number;
+        continuous: {
+            maxReconnects: number;
+        };
         uploadUrl?: string | undefined;
         streamUrl?: string | undefined;
         referencedBy?: {
@@ -264,6 +275,9 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
         priority: z.ZodDefault<z.ZodInt>;
         uploadUrl: z.ZodOptional<z.ZodString>;
         streamUrl: z.ZodOptional<z.ZodString>;
+        continuous: z.ZodDefault<z.ZodObject<{
+            maxReconnects: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         referencedBy: z.ZodOptional<z.ZodObject<{
             rootTaskId: z.ZodUUID;
             taskId: z.ZodUUID;
@@ -292,6 +306,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
                 name: string;
                 version: string;
                 configurationSchema: import("json-schema").JSONSchema7;
+                mode: "LINEAR" | "CONTINUOUS";
                 outputs: {
                     name: string | null;
                     schema: import("json-schema").JSONSchema7 | null;
@@ -377,6 +392,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
                     name: string;
                     version: string;
                     configurationSchema: import("json-schema").JSONSchema7;
+                    mode: "LINEAR" | "CONTINUOUS";
                     outputs: {
                         name: string | null;
                         schema: import("json-schema").JSONSchema7 | null;
@@ -446,6 +462,9 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
         maxExecutions: number;
         mode: "LINEAR" | "CONTINUOUS";
         priority: number;
+        continuous: {
+            maxReconnects: number;
+        };
         uploadUrl?: string | undefined;
         streamUrl?: string | undefined;
         referencedBy?: {
@@ -470,6 +489,9 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
         maxExecutions: number;
         mode: "LINEAR" | "CONTINUOUS";
         priority: number;
+        continuous: {
+            maxReconnects: number;
+        };
         uploadUrl?: string | undefined;
         streamUrl?: string | undefined;
         referencedBy?: {

package/build/types/helpers/src/protocol/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAK1B,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuB3B,CAAA;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAqD,CAAA;AAC/E,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAK1B,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuB3B,CAAA;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAqD,CAAA;AAC/E,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/build/types/helpers/src/protocol/nodeType.d.ts

@@ -24,6 +24,10 @@ export declare const serviceNodeSchema: z.ZodObject<{
     ttl: z.ZodOptional<z.ZodNumber>;
     retry: z.ZodOptional<z.ZodNumber>;
     retryDelay: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        LINEAR: "LINEAR";
+        CONTINUOUS: "CONTINUOUS";
+    }>>;
     outputs: z.ZodArray<z.ZodObject<{
         name: z.ZodNullable<z.ZodString>;
         schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
@@ -110,6 +114,10 @@ export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     ttl: z.ZodOptional<z.ZodNumber>;
     retry: z.ZodOptional<z.ZodNumber>;
     retryDelay: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        LINEAR: "LINEAR";
+        CONTINUOUS: "CONTINUOUS";
+    }>>;
     outputs: z.ZodArray<z.ZodObject<{
         name: z.ZodNullable<z.ZodString>;
         schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;

package/build/types/helpers/src/protocol/nodeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeType.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/nodeType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAkC1B,eAAO,MAAM,eAAe;;;;;kBAK1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAExD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;kBAoBF,CAAA;AAC5B,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE5D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;kBAYA,CAAA;AAC5B,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAExD,eAAO,MAAM,YAAY;;;;kBAIvB,CAAA;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAA;AAElD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;kBAeJ,CAAA;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;kBAKzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AAEtD,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAG5D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;iBAKrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"nodeType.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/nodeType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAkC1B,eAAO,MAAM,eAAe;;;;;kBAK1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAExD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBF,CAAA;AAC5B,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE5D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;kBAYA,CAAA;AAC5B,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA;AAExD,eAAO,MAAM,YAAY;;;;kBAIvB,CAAA;AACF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAA;AAElD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;kBAeJ,CAAA;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;kBAKzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AAEtD,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAG5D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAQrB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;iBAKrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/build/types/helpers/src/protocol/taskOptions.d.ts

@@ -8,6 +8,9 @@ export declare const taskOptionsSchema: z.ZodObject<{
     priority: z.ZodDefault<z.ZodInt>;
     uploadUrl: z.ZodOptional<z.ZodString>;
     streamUrl: z.ZodOptional<z.ZodString>;
+    continuous: z.ZodDefault<z.ZodObject<{
+        maxReconnects: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     referencedBy: z.ZodOptional<z.ZodObject<{
         rootTaskId: z.ZodUUID;
         taskId: z.ZodUUID;

package/build/types/helpers/src/protocol/taskOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"taskOptions.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/taskOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;iBAc5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"taskOptions.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/taskOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBAmB5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/build/types/helpers/src/protocol/templateNodeTypes.d.ts

@@ -17,6 +17,10 @@ export declare const templateEntryNodeSchema: z.ZodObject<{
 export type TemplateEntryNode = z.output<typeof templateEntryNodeSchema>;
 export declare const templateServiceNodeSchema: z.ZodObject<{
     type: z.ZodLiteral<"service">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        LINEAR: "LINEAR";
+        CONTINUOUS: "CONTINUOUS";
+    }>>;
     id: z.ZodDefault<z.ZodUUID>;
     alias: z.ZodOptional<z.ZodString>;
     configuration: z.ZodOptional<z.ZodAny>;
@@ -163,6 +167,10 @@ export declare const templateTreeSchema: z.ZodObject<{
         flipped: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"service">;
+        mode: z.ZodDefault<z.ZodEnum<{
+            LINEAR: "LINEAR";
+            CONTINUOUS: "CONTINUOUS";
+        }>>;
         id: z.ZodDefault<z.ZodUUID>;
         alias: z.ZodOptional<z.ZodString>;
         configuration: z.ZodOptional<z.ZodAny>;

package/build/types/helpers/src/protocol/templateNodeTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templateNodeTypes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/templateNodeTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AA2B1B,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;iBAaT,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAEJ,CAAA;AAC7B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAElE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;iBAMX,CAAA;AAC7B,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAEhF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAEN,CAAA;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBAET,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,YAAY;;;;;;;;;iBAQvB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"templateNodeTypes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/templateNodeTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AA2B1B,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;iBAaT,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAEP,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAEJ,CAAA;AAC7B,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAElE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;iBAMX,CAAA;AAC7B,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAEhF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAEN,CAAA;AAC7B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBAET,CAAA;AAC7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE5E,eAAO,MAAM,YAAY;;;;;;;;;iBAQvB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/build/types/helpers/src/protocol/treeNodes.d.ts

@@ -23,6 +23,10 @@ export declare const treeSchema: z.ZodObject<{
         ttl: z.ZodOptional<z.ZodNumber>;
         retry: z.ZodOptional<z.ZodNumber>;
         retryDelay: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            LINEAR: "LINEAR";
+            CONTINUOUS: "CONTINUOUS";
+        }>>;
         outputs: z.ZodArray<z.ZodObject<{
             name: z.ZodNullable<z.ZodString>;
             schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
@@ -107,6 +111,10 @@ declare const extendedTreeSchema: z.ZodObject<{
         ttl: z.ZodOptional<z.ZodNumber>;
         retry: z.ZodOptional<z.ZodNumber>;
         retryDelay: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            LINEAR: "LINEAR";
+            CONTINUOUS: "CONTINUOUS";
+        }>>;
         outputs: z.ZodArray<z.ZodObject<{
             name: z.ZodNullable<z.ZodString>;
             schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
@@ -192,6 +200,10 @@ export declare const validatedTreeSchema: z.ZodPipe<z.ZodObject<{
         ttl: z.ZodOptional<z.ZodNumber>;
         retry: z.ZodOptional<z.ZodNumber>;
         retryDelay: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            LINEAR: "LINEAR";
+            CONTINUOUS: "CONTINUOUS";
+        }>>;
         outputs: z.ZodArray<z.ZodObject<{
             name: z.ZodNullable<z.ZodString>;
             schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
@@ -270,6 +282,7 @@ export declare const validatedTreeSchema: z.ZodPipe<z.ZodObject<{
         name: string;
         version: string;
         configurationSchema: import("json-schema").JSONSchema7;
+        mode: "LINEAR" | "CONTINUOUS";
         outputs: {
             name: string | null;
             schema: import("json-schema").JSONSchema7 | null;
@@ -348,6 +361,7 @@ export declare const validatedTreeSchema: z.ZodPipe<z.ZodObject<{
         name: string;
         version: string;
         configurationSchema: import("json-schema").JSONSchema7;
+        mode: "LINEAR" | "CONTINUOUS";
         outputs: {
             name: string | null;
             schema: import("json-schema").JSONSchema7 | null;
@@ -442,6 +456,10 @@ export declare const treeReferenceSchema: z.ZodObject<{
             ttl: z.ZodOptional<z.ZodNumber>;
             retry: z.ZodOptional<z.ZodNumber>;
             retryDelay: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                LINEAR: "LINEAR";
+                CONTINUOUS: "CONTINUOUS";
+            }>>;
             outputs: z.ZodArray<z.ZodObject<{
                 name: z.ZodNullable<z.ZodString>;
                 schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
@@ -528,6 +546,10 @@ export declare const treeListSchema: z.ZodObject<{
             ttl: z.ZodOptional<z.ZodNumber>;
             retry: z.ZodOptional<z.ZodNumber>;
             retryDelay: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                LINEAR: "LINEAR";
+                CONTINUOUS: "CONTINUOUS";
+            }>>;
             outputs: z.ZodArray<z.ZodObject<{
                 name: z.ZodNullable<z.ZodString>;
                 schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;
@@ -606,6 +628,7 @@ export declare const treeListSchema: z.ZodObject<{
             name: string;
             version: string;
             configurationSchema: import("json-schema").JSONSchema7;
+            mode: "LINEAR" | "CONTINUOUS";
             outputs: {
                 name: string | null;
                 schema: import("json-schema").JSONSchema7 | null;
@@ -684,6 +707,7 @@ export declare const treeListSchema: z.ZodObject<{
             name: string;
             version: string;
             configurationSchema: import("json-schema").JSONSchema7;
+            mode: "LINEAR" | "CONTINUOUS";
             outputs: {
                 name: string | null;
                 schema: import("json-schema").JSONSchema7 | null;
@@ -778,6 +802,10 @@ export declare const treeListSchema: z.ZodObject<{
                 ttl: z.ZodOptional<z.ZodNumber>;
                 retry: z.ZodOptional<z.ZodNumber>;
                 retryDelay: z.ZodOptional<z.ZodNumber>;
+                mode: z.ZodDefault<z.ZodEnum<{
+                    LINEAR: "LINEAR";
+                    CONTINUOUS: "CONTINUOUS";
+                }>>;
                 outputs: z.ZodArray<z.ZodObject<{
                     name: z.ZodNullable<z.ZodString>;
                     schema: z.ZodNullable<z.ZodCustom<import("json-schema").JSONSchema7, import("json-schema").JSONSchema7>>;

package/build/types/helpers/src/protocol/treeNodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeNodes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/treeNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAQ1B,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9C,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEtB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0Q/B,CAAA;AACD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBvB,CAAA;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}
+{"version":3,"file":"treeNodes.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/treeNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAQ1B,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9C,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEtB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE/D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0Q/B,CAAA;AACD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAEhE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBvB,CAAA;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/build/types/helpers/src/protocol/update.d.ts

@@ -3,6 +3,7 @@ declare const nodeInitUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -22,6 +23,7 @@ declare const nodeStartUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -41,6 +43,7 @@ declare const nodeErrorUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -59,6 +62,7 @@ declare const nodeUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -79,6 +83,7 @@ declare const nodeCallbackSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -109,6 +114,7 @@ declare const nodeEndUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -126,6 +132,7 @@ declare const nodeDebugUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -151,6 +158,7 @@ declare const nodeDeferUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -169,6 +177,7 @@ declare const taskStartUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"TASK_START">;
     parentTask: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         rootTaskId: z.ZodUUID;
@@ -183,6 +192,7 @@ declare const taskErrorUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"TASK_ERROR">;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -191,6 +201,7 @@ declare const taskEndUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"TASK_END">;
     exitName: z.ZodNullable<z.ZodString>;
     result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -200,6 +211,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -217,6 +229,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -234,6 +247,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -250,6 +264,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -268,6 +283,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -296,6 +312,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -311,6 +328,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -334,6 +352,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     node: z.ZodObject<{
         id: z.ZodUUID;
         type: z.ZodEnum<{
@@ -350,6 +369,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"TASK_START">;
     parentTask: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         rootTaskId: z.ZodUUID;
@@ -362,12 +382,14 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"TASK_ERROR">;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"TASK_END">;
     exitName: z.ZodNullable<z.ZodString>;
     result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -375,6 +397,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
     rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"TASK_ABORTED">;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "type">;

package/build/types/helpers/src/protocol/update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAmB1B,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;iBAEvB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAYzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,mBAAmB;;;;;;;iBAIvB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAO/D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAavB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAoB1B,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAEvB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;iBAYzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,mBAAmB;;;;;;;;iBAIvB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAO/D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAavB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@requence/task",
   "type": "module",
-  "version": "1.0.0-alpha.49",
+  "version": "1.0.0-alpha.50",
   "bin": {
     "requence-task": "build/cli.js"
   },