@unlaxer/tramli 1.2.0 → 1.2.2

package/dist/flow-definition.d.ts

@@ -47,6 +47,8 @@ export declare class Builder<S extends string> {
     private checkRequiresProducesFrom;
     private checkAutoExternalConflict;
     private checkTerminalNoOutgoing;
+    private checkSubFlowNestingDepth;
+    private checkSubFlowCircularRef;
     private checkSubFlowExitCompleteness;
 }
 export declare class FromBuilder<S extends string> {

package/dist/flow-definition.js

@@ -119,6 +119,8 @@ export class Builder {
         this.checkAutoExternalConflict(def, errors);
         this.checkTerminalNoOutgoing(def, errors);
         this.checkSubFlowExitCompleteness(def, errors);
+        this.checkSubFlowNestingDepth(def, errors, 0);
+        this.checkSubFlowCircularRef(def, errors, new Set());
         if (errors.length > 0) {
             throw new FlowError('INVALID_FLOW_DEFINITION', `Flow '${this.name}' has ${errors.length} validation error(s):\n  - ${errors.join('\n  - ')}`);
         }
@@ -322,6 +324,29 @@ export class Builder {
             }
         }
     }
+    checkSubFlowNestingDepth(def, errors, depth) {
+        if (depth > 3) {
+            errors.push(`SubFlow nesting depth exceeds maximum of 3 (flow: ${def.name})`);
+            return;
+        }
+        for (const t of def.transitions) {
+            if (t.type === 'sub_flow' && t.subFlowDefinition) {
+                this.checkSubFlowNestingDepth(t.subFlowDefinition, errors, depth + 1);
+            }
+        }
+    }
+    checkSubFlowCircularRef(def, errors, visited) {
+        if (visited.has(def.name)) {
+            errors.push(`Circular sub-flow reference detected: ${[...visited].join(' -> ')} -> ${def.name}`);
+            return;
+        }
+        visited.add(def.name);
+        for (const t of def.transitions) {
+            if (t.type === 'sub_flow' && t.subFlowDefinition) {
+                this.checkSubFlowCircularRef(t.subFlowDefinition, errors, new Set(visited));
+            }
+        }
+    }
     checkSubFlowExitCompleteness(def, errors) {
         for (const t of def.transitions) {
             if (t.type !== 'sub_flow' || !t.subFlowDefinition)

package/dist/flow-engine.js

@@ -163,6 +163,9 @@ export class FlowEngine {
                 this.store.recordTransition(parentFlow.id, from, target, `subFlow:${subDef.name}/${subFlow.exitState}`, parentFlow.context);
                 return 1;
             }
+            // Error bubbling: no exit mapping → fall back to parent's error transitions
+            this.handleError(parentFlow, parentFlow.currentState);
+            return 1;
         }
         return 0; // sub-flow stopped at external
     }

package/dist/flow-instance.d.ts

@@ -24,6 +24,8 @@ export declare class FlowInstance<S extends string> {
     get exitState(): string | null;
     get isCompleted(): boolean;
     get activeSubFlow(): FlowInstance<any> | null;
+    /** Return a copy with the given version. For FlowStore optimistic locking. */
+    withVersion(newVersion: number): FlowInstance<S>;
     /** @internal */ transitionTo(state: S): void;
     /** @internal */ incrementGuardFailure(): void;
     /** @internal */ complete(exitState: string): void;

package/dist/flow-instance.js

@@ -47,6 +47,12 @@ export class FlowInstance {
     get exitState() { return this._exitState; }
     get isCompleted() { return this._exitState !== null; }
     get activeSubFlow() { return this._activeSubFlow; }
+    /** Return a copy with the given version. For FlowStore optimistic locking. */
+    withVersion(newVersion) {
+        const copy = FlowInstance.restore(this.id, this.sessionId, this.definition, this.context, this._currentState, this.createdAt, this.expiresAt, this._guardFailureCount, newVersion, this._exitState);
+        copy.setActiveSubFlow(this._activeSubFlow);
+        return copy;
+    }
     /** @internal */ transitionTo(state) { this._currentState = state; }
     /** @internal */ incrementGuardFailure() { this._guardFailureCount++; }
     /** @internal */ complete(exitState) { this._exitState = exitState; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unlaxer/tramli",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Constrained flow engine — state machines that prevent invalid transitions at build time",
   "type": "module",
   "exports": {