@telorun/run 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @telorun/run
+
+## 0.1.1
+
+### Patch Changes
+
+- Automated release.
+- Updated dependencies
+  - @telorun/sdk@0.2.6

package/LICENSE

@@ -0,0 +1,17 @@
+# SUSTAINABLE USE LICENSE (Fair-code)
+
+Copyright (c) 2026 DiglyAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute the Software for any purpose—including commercial purposes—subject to the following conditions:
+
+1. ANTI-COMPETITION RESTRICTION: The Software may not be provided to third parties as a managed service, commercial SaaS (Software-as-a-Service), PaaS (Platform-as-a-Service), BaaS (Backend-as-a-Service), or similar offering where the primary value provided to the user is the functionality of the Software itself, without a separate commercial license from the copyright holder.
+
+2. PERMITTED COMMERCIAL USE: You are free to use the Software to build, host, and monetize your own commercial applications, products, and services, provided such use does not violate Clause 1.
+
+3. ATTRIBUTION: This copyright notice and license must be included in all copies or substantial portions of the Software.
+
+4. CONTRIBUTIONS: Contributions to the Software are welcome and encouraged. By contributing, you agree that your contributions may be incorporated into the Software and distributed under this license.
+
+5. DISCLAIMER: The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the Software or the use or other dealings in the Software.
+
+For commercial licensing, managed hosting exemptions, or enterprise inquiries, please contact DiglyAI.

package/dist/sequence.d.ts

@@ -0,0 +1,66 @@
+import type { Invocable, KindRef, ResourceContext, ScopeHandle } from "@telorun/sdk";
+interface RetryPolicy {
+    attempts?: number;
+    delay?: string;
+}
+interface InvokeStep {
+    name: string;
+    when?: string;
+    invoke: KindRef<Invocable>;
+    inputs?: Record<string, unknown>;
+    retry?: RetryPolicy;
+}
+interface IfStep {
+    name: string;
+    if: string;
+    then: Step[];
+    else?: Step[];
+}
+interface WhileStep {
+    name: string;
+    while: string;
+    do: Step[];
+}
+interface SwitchStep {
+    name: string;
+    switch: string;
+    cases: Record<string, Step[]>;
+    default?: Step[];
+}
+interface TryStep {
+    name: string;
+    when?: string;
+    try: Step[];
+    catch?: Step[];
+    finally?: Step[];
+}
+type Step = InvokeStep | IfStep | WhileStep | SwitchStep | TryStep;
+interface RunSequenceManifest {
+    metadata: Record<string, string | number | boolean>;
+    with?: ScopeHandle;
+    targets?: string[];
+    inputs?: Record<string, Record<string, unknown>>;
+    outputs?: Record<string, unknown>;
+    steps: Step[];
+}
+declare class RunSequence {
+    private readonly ctx;
+    readonly resource: RunSequenceManifest;
+    constructor(ctx: ResourceContext, resource: RunSequenceManifest);
+    init(): Promise<void>;
+    private resolveInvokes;
+    run(): Promise<void>;
+    invoke(inputs: Record<string, unknown>): Promise<unknown>;
+    private runScopeTargets;
+    teardown(): Promise<void>;
+    private executeSteps;
+    private executeStep;
+    private executeInvokeStep;
+    private executeIfStep;
+    private executeWhileStep;
+    private executeSwitchStep;
+    private executeTryStep;
+}
+export declare function register(): void;
+export declare function create(resource: RunSequenceManifest, ctx: ResourceContext): Promise<RunSequence>;
+export {};

package/dist/sequence.js

@@ -0,0 +1,217 @@
+function isInvokeStep(step) {
+    return "invoke" in step;
+}
+function isIfStep(step) {
+    return "if" in step;
+}
+function isWhileStep(step) {
+    return "while" in step;
+}
+function isSwitchStep(step) {
+    return "switch" in step;
+}
+function isTryStep(step) {
+    return "try" in step;
+}
+class RunSequence {
+    ctx;
+    resource;
+    constructor(ctx, resource) {
+        this.ctx = ctx;
+        this.resource = resource;
+    }
+    async init() {
+        this.resolveInvokes(this.resource.steps);
+    }
+    resolveInvokes(stepList) {
+        for (const step of stepList) {
+            if (isInvokeStep(step)) {
+                const raw = step.invoke;
+                if (!raw || typeof raw.invoke !== "function") {
+                    step.invoke = this.ctx.resolveChildren(raw, step.name);
+                }
+            }
+            if (isIfStep(step)) {
+                this.resolveInvokes(step.then);
+                if (step.else)
+                    this.resolveInvokes(step.else);
+            }
+            if (isWhileStep(step))
+                this.resolveInvokes(step.do);
+            if (isSwitchStep(step)) {
+                for (const branch of Object.values(step.cases))
+                    this.resolveInvokes(branch);
+                if (step.default)
+                    this.resolveInvokes(step.default);
+            }
+            if (isTryStep(step)) {
+                this.resolveInvokes(step.try);
+                if (step.catch)
+                    this.resolveInvokes(step.catch);
+                if (step.finally)
+                    this.resolveInvokes(step.finally);
+            }
+        }
+    }
+    async run() {
+        if (this.resource.with) {
+            await this.resource.with.run(async (scope) => {
+                await this.runScopeTargets(scope);
+                await this.executeSteps(this.resource.steps, {}, scope, {});
+            });
+        }
+        else {
+            await this.executeSteps(this.resource.steps, {}, undefined, {});
+        }
+    }
+    async invoke(inputs) {
+        const steps = {};
+        const extraCtx = inputs ?? {};
+        if (this.resource.with) {
+            await this.resource.with.run(async (scope) => {
+                await this.runScopeTargets(scope);
+                await this.executeSteps(this.resource.steps, steps, scope, extraCtx);
+            });
+        }
+        else {
+            await this.executeSteps(this.resource.steps, steps, undefined, extraCtx);
+        }
+        if (this.resource.outputs) {
+            return this.ctx.expandValue(this.resource.outputs, { steps, ...extraCtx });
+        }
+        return steps;
+    }
+    async runScopeTargets(scope) {
+        if (!this.resource.targets?.length)
+            return;
+        await Promise.all(this.resource.targets.map((name) => {
+            const instance = scope.getInstance(name);
+            if (typeof instance.run !== "function") {
+                throw new Error(`Scope target '${name}' does not have a run() method`);
+            }
+            return instance.run();
+        }));
+    }
+    async teardown() { }
+    async executeSteps(stepList, steps, scope, extraCtx) {
+        for (const step of stepList) {
+            await this.executeStep(step, steps, scope, extraCtx);
+        }
+    }
+    async executeStep(step, steps, scope, extraCtx) {
+        if (isInvokeStep(step))
+            await this.executeInvokeStep(step, steps, scope, extraCtx);
+        else if (isIfStep(step))
+            await this.executeIfStep(step, steps, scope, extraCtx);
+        else if (isWhileStep(step))
+            await this.executeWhileStep(step, steps, scope, extraCtx);
+        else if (isSwitchStep(step))
+            await this.executeSwitchStep(step, steps, scope, extraCtx);
+        else if (isTryStep(step))
+            await this.executeTryStep(step, steps, scope, extraCtx);
+        else
+            throw new Error(`Step "${step.name}" has no recognized type key`);
+    }
+    async executeInvokeStep(step, steps, scope, extraCtx) {
+        const cel = { steps, ...extraCtx };
+        if (step.when !== undefined && !this.ctx.expandValue(step.when, cel))
+            return;
+        const inputs = this.ctx.expandValue(step.inputs ?? {}, cel);
+        const raw = step.invoke;
+        let result;
+        if (raw && typeof raw.invoke === "function") {
+            result = await raw.invoke(inputs);
+        }
+        else {
+            const ref = raw;
+            if (scope) {
+                result = await scope.getInstance(ref.name).invoke(inputs);
+            }
+            else {
+                result = await this.ctx.invoke(ref.kind, ref.name, inputs, { retry: step.retry });
+            }
+        }
+        steps[step.name] = { result };
+    }
+    async executeIfStep(step, steps, scope, extraCtx) {
+        if (this.ctx.expandValue(step.if, { steps, ...extraCtx })) {
+            await this.executeSteps(step.then, steps, scope, extraCtx);
+        }
+        else if (step.else) {
+            await this.executeSteps(step.else, steps, scope, extraCtx);
+        }
+    }
+    async executeWhileStep(step, steps, scope, extraCtx) {
+        while (this.ctx.expandValue(step.while, { steps, ...extraCtx })) {
+            await this.executeSteps(step.do, steps, scope, extraCtx);
+        }
+    }
+    async executeSwitchStep(step, steps, scope, extraCtx) {
+        const key = String(this.ctx.expandValue(step.switch, { steps, ...extraCtx }));
+        if (Object.prototype.hasOwnProperty.call(step.cases, key)) {
+            await this.executeSteps(step.cases[key], steps, scope, extraCtx);
+        }
+        else if (step.default) {
+            await this.executeSteps(step.default, steps, scope, extraCtx);
+        }
+        else {
+            throw new Error(`Switch step "${step.name}": no matching case for "${key}" and no default`);
+        }
+    }
+    async executeTryStep(step, steps, scope, extraCtx) {
+        if (step.when !== undefined && !this.ctx.expandValue(step.when, { steps, ...extraCtx }))
+            return;
+        let tryFailed = false;
+        let tryError;
+        try {
+            await this.executeSteps(step.try, steps, scope, extraCtx);
+        }
+        catch (err) {
+            tryFailed = true;
+            tryError = err;
+        }
+        if (tryFailed) {
+            if (step.catch) {
+                const seqErr = toSequenceError(tryError, step.name);
+                try {
+                    await this.executeSteps(step.catch, steps, scope, { ...extraCtx, error: seqErr });
+                }
+                catch (catchErr) {
+                    if (step.finally) {
+                        await this.executeSteps(step.finally, steps, scope, {
+                            ...extraCtx,
+                            error: toSequenceError(catchErr, step.name),
+                        });
+                    }
+                    throw catchErr;
+                }
+                if (step.finally) {
+                    await this.executeSteps(step.finally, steps, scope, { ...extraCtx, error: null });
+                }
+            }
+            else {
+                if (step.finally) {
+                    await this.executeSteps(step.finally, steps, scope, {
+                        ...extraCtx,
+                        error: toSequenceError(tryError, step.name),
+                    });
+                }
+                throw tryError;
+            }
+        }
+        else if (step.finally) {
+            await this.executeSteps(step.finally, steps, scope, { ...extraCtx, error: null });
+        }
+    }
+}
+function toSequenceError(err, stepName) {
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err instanceof Error && err.code != null
+        ? err.code
+        : null;
+    return { message, code, step: stepName };
+}
+export function register() { }
+export async function create(resource, ctx) {
+    return new RunSequence(ctx, resource);
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@telorun/run",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./src/sequence.ts",
+  "module": "./src/sequence.ts",
+  "exports": {
+    "./sequence": {
+      "bun": "./src/sequence.ts",
+      "import": "./dist/sequence.js"
+    }
+  },
+  "dependencies": {
+    "@telorun/sdk": "0.2.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json"
+  }
+}

package/src/sequence.ts

@@ -0,0 +1,318 @@
+import type { Invocable, KindRef, ResourceContext, ScopeContext, ScopeHandle } from "@telorun/sdk";
+
+interface RetryPolicy {
+  attempts?: number;
+  delay?: string;
+}
+
+interface InvokeStep {
+  name: string;
+  when?: string;
+  invoke: KindRef<Invocable>;
+  inputs?: Record<string, unknown>;
+  retry?: RetryPolicy;
+}
+
+interface IfStep {
+  name: string;
+  if: string;
+  then: Step[];
+  else?: Step[];
+}
+
+interface WhileStep {
+  name: string;
+  while: string;
+  do: Step[];
+}
+
+interface SwitchStep {
+  name: string;
+  switch: string;
+  cases: Record<string, Step[]>;
+  default?: Step[];
+}
+
+interface TryStep {
+  name: string;
+  when?: string;
+  try: Step[];
+  catch?: Step[];
+  finally?: Step[];
+}
+
+type Step = InvokeStep | IfStep | WhileStep | SwitchStep | TryStep;
+
+interface RunSequenceManifest {
+  metadata: Record<string, string | number | boolean>;
+  with?: ScopeHandle;
+  targets?: string[];
+  inputs?: Record<string, Record<string, unknown>>;
+  outputs?: Record<string, unknown>;
+  steps: Step[];
+}
+
+interface SequenceError {
+  message: string;
+  code: string | null;
+  step: string;
+}
+
+function isInvokeStep(step: Step): step is InvokeStep {
+  return "invoke" in step;
+}
+function isIfStep(step: Step): step is IfStep {
+  return "if" in step;
+}
+function isWhileStep(step: Step): step is WhileStep {
+  return "while" in step;
+}
+function isSwitchStep(step: Step): step is SwitchStep {
+  return "switch" in step;
+}
+function isTryStep(step: Step): step is TryStep {
+  return "try" in step;
+}
+
+class RunSequence {
+  constructor(
+    private readonly ctx: ResourceContext,
+    public readonly resource: RunSequenceManifest,
+  ) {}
+
+  async init(): Promise<void> {
+    this.resolveInvokes(this.resource.steps);
+  }
+
+  private resolveInvokes(stepList: Step[]): void {
+    for (const step of stepList) {
+      if (isInvokeStep(step)) {
+        const raw = step.invoke as unknown;
+        if (!raw || typeof (raw as Invocable).invoke !== "function") {
+          (step as InvokeStep).invoke = this.ctx.resolveChildren(
+            raw as any,
+            step.name,
+          ) as KindRef<Invocable>;
+        }
+      }
+      if (isIfStep(step)) {
+        this.resolveInvokes(step.then);
+        if (step.else) this.resolveInvokes(step.else);
+      }
+      if (isWhileStep(step)) this.resolveInvokes(step.do);
+      if (isSwitchStep(step)) {
+        for (const branch of Object.values(step.cases)) this.resolveInvokes(branch);
+        if (step.default) this.resolveInvokes(step.default);
+      }
+      if (isTryStep(step)) {
+        this.resolveInvokes(step.try);
+        if (step.catch) this.resolveInvokes(step.catch);
+        if (step.finally) this.resolveInvokes(step.finally);
+      }
+    }
+  }
+
+  async run(): Promise<void> {
+    if (this.resource.with) {
+      await this.resource.with.run(async (scope) => {
+        await this.runScopeTargets(scope);
+        await this.executeSteps(this.resource.steps, {}, scope, {});
+      });
+    } else {
+      await this.executeSteps(this.resource.steps, {}, undefined, {});
+    }
+  }
+
+  async invoke(inputs: Record<string, unknown>): Promise<unknown> {
+    const steps: Record<string, unknown> = {};
+    const extraCtx = inputs ?? {};
+
+    if (this.resource.with) {
+      await this.resource.with.run(async (scope) => {
+        await this.runScopeTargets(scope);
+        await this.executeSteps(this.resource.steps, steps, scope, extraCtx);
+      });
+    } else {
+      await this.executeSteps(this.resource.steps, steps, undefined, extraCtx);
+    }
+
+    if (this.resource.outputs) {
+      return this.ctx.expandValue(this.resource.outputs, { steps, ...extraCtx });
+    }
+    return steps;
+  }
+
+  private async runScopeTargets(scope: ScopeContext): Promise<void> {
+    if (!this.resource.targets?.length) return;
+    await Promise.all(
+      this.resource.targets.map((name) => {
+        const instance = scope.getInstance(name);
+        if (typeof instance.run !== "function") {
+          throw new Error(`Scope target '${name}' does not have a run() method`);
+        }
+        return instance.run();
+      }),
+    );
+  }
+
+  async teardown(): Promise<void> {}
+
+  private async executeSteps(
+    stepList: Step[],
+    steps: Record<string, unknown>,
+    scope: ScopeContext | undefined,
+    extraCtx: Record<string, unknown>,
+  ): Promise<void> {
+    for (const step of stepList) {
+      await this.executeStep(step, steps, scope, extraCtx);
+    }
+  }
+
+  private async executeStep(
+    step: Step,
+    steps: Record<string, unknown>,
+    scope: ScopeContext | undefined,
+    extraCtx: Record<string, unknown>,
+  ): Promise<void> {
+    if (isInvokeStep(step)) await this.executeInvokeStep(step, steps, scope, extraCtx);
+    else if (isIfStep(step)) await this.executeIfStep(step, steps, scope, extraCtx);
+    else if (isWhileStep(step)) await this.executeWhileStep(step, steps, scope, extraCtx);
+    else if (isSwitchStep(step)) await this.executeSwitchStep(step, steps, scope, extraCtx);
+    else if (isTryStep(step)) await this.executeTryStep(step, steps, scope, extraCtx);
+    else throw new Error(`Step "${(step as Step).name}" has no recognized type key`);
+  }
+
+  private async executeInvokeStep(
+    step: InvokeStep,
+    steps: Record<string, unknown>,
+    scope: ScopeContext | undefined,
+    extraCtx: Record<string, unknown>,
+  ): Promise<void> {
+    const cel = { steps, ...extraCtx };
+    if (step.when !== undefined && !this.ctx.expandValue(step.when, cel)) return;
+
+    const inputs = this.ctx.expandValue(step.inputs ?? {}, cel) as Record<string, unknown>;
+    const raw = step.invoke as unknown;
+    let result: unknown;
+
+    if (raw && typeof (raw as Invocable).invoke === "function") {
+      result = await (raw as Invocable).invoke(inputs);
+    } else {
+      const ref = raw as KindRef<Invocable>;
+      if (scope) {
+        result = await (scope.getInstance(ref.name) as unknown as Invocable).invoke(inputs);
+      } else {
+        result = await this.ctx.invoke(ref.kind, ref.name, inputs, { retry: step.retry });
+      }
+    }
+
+    steps[step.name] = { result };
+  }
+
+  private async executeIfStep(
+    step: IfStep,
+    steps: Record<string, unknown>,
+    scope: ScopeContext | undefined,
+    extraCtx: Record<string, unknown>,
+  ): Promise<void> {
+    if (this.ctx.expandValue(step.if, { steps, ...extraCtx })) {
+      await this.executeSteps(step.then, steps, scope, extraCtx);
+    } else if (step.else) {
+      await this.executeSteps(step.else, steps, scope, extraCtx);
+    }
+  }
+
+  private async executeWhileStep(
+    step: WhileStep,
+    steps: Record<string, unknown>,
+    scope: ScopeContext | undefined,
+    extraCtx: Record<string, unknown>,
+  ): Promise<void> {
+    while (this.ctx.expandValue(step.while, { steps, ...extraCtx })) {
+      await this.executeSteps(step.do, steps, scope, extraCtx);
+    }
+  }
+
+  private async executeSwitchStep(
+    step: SwitchStep,
+    steps: Record<string, unknown>,
+    scope: ScopeContext | undefined,
+    extraCtx: Record<string, unknown>,
+  ): Promise<void> {
+    const key = String(this.ctx.expandValue(step.switch, { steps, ...extraCtx }));
+    if (Object.prototype.hasOwnProperty.call(step.cases, key)) {
+      await this.executeSteps(step.cases[key], steps, scope, extraCtx);
+    } else if (step.default) {
+      await this.executeSteps(step.default, steps, scope, extraCtx);
+    } else {
+      throw new Error(`Switch step "${step.name}": no matching case for "${key}" and no default`);
+    }
+  }
+
+  private async executeTryStep(
+    step: TryStep,
+    steps: Record<string, unknown>,
+    scope: ScopeContext | undefined,
+    extraCtx: Record<string, unknown>,
+  ): Promise<void> {
+    if (step.when !== undefined && !this.ctx.expandValue(step.when, { steps, ...extraCtx })) return;
+
+    let tryFailed = false;
+    let tryError: unknown;
+
+    try {
+      await this.executeSteps(step.try, steps, scope, extraCtx);
+    } catch (err) {
+      tryFailed = true;
+      tryError = err;
+    }
+
+    if (tryFailed) {
+      if (step.catch) {
+        const seqErr = toSequenceError(tryError, step.name);
+        try {
+          await this.executeSteps(step.catch, steps, scope, { ...extraCtx, error: seqErr });
+        } catch (catchErr) {
+          if (step.finally) {
+            await this.executeSteps(step.finally, steps, scope, {
+              ...extraCtx,
+              error: toSequenceError(catchErr, step.name),
+            });
+          }
+          throw catchErr;
+        }
+        if (step.finally) {
+          await this.executeSteps(step.finally, steps, scope, { ...extraCtx, error: null });
+        }
+      } else {
+        if (step.finally) {
+          await this.executeSteps(step.finally, steps, scope, {
+            ...extraCtx,
+            error: toSequenceError(tryError, step.name),
+          });
+        }
+        throw tryError;
+      }
+    } else if (step.finally) {
+      await this.executeSteps(step.finally, steps, scope, { ...extraCtx, error: null });
+    }
+  }
+}
+
+function toSequenceError(err: unknown, stepName: string): SequenceError {
+  const message = err instanceof Error ? err.message : String(err);
+  const code =
+    err instanceof Error && (err as Error & { code?: string }).code != null
+      ? (err as Error & { code?: string }).code!
+      : null;
+  return { message, code, step: stepName };
+}
+
+export function register(): void {}
+
+export async function create(
+  resource: RunSequenceManifest,
+  ctx: ResourceContext,
+): Promise<RunSequence> {
+  return new RunSequence(ctx, resource);
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "files": [],
+  "include": ["src/**/*.ts", "test/**/*.ts"],
+  "compilerOptions": {
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "references": [
+    {
+      "path": "tsconfig.lib.json"
+    },
+    {
+      "path": "tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"],
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "strict": true,
+    "esModuleInterop": true,
+    "types": ["node", "jest"]
+  },
+  "files": [],
+  "include": ["test/**/*.ts"]
+}