@unlaxer/tramli 1.2.1 → 1.3.0

package/dist/flow-instance.d.ts

@@ -24,6 +24,14 @@ export declare class FlowInstance<S extends string> {
     get exitState(): string | null;
     get isCompleted(): boolean;
     get activeSubFlow(): FlowInstance<any> | null;
+    /** State path from root to deepest active sub-flow. */
+    statePath(): string[];
+    /** State path as slash-separated string. */
+    statePathString(): string;
+    /** Types required by the next external transition (including in active sub-flows). */
+    waitingFor(): string[];
+    /** 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,30 @@ export class FlowInstance {
     get exitState() { return this._exitState; }
     get isCompleted() { return this._exitState !== null; }
     get activeSubFlow() { return this._activeSubFlow; }
+    /** State path from root to deepest active sub-flow. */
+    statePath() {
+        const path = [this._currentState];
+        if (this._activeSubFlow)
+            path.push(...this._activeSubFlow.statePath());
+        return path;
+    }
+    /** State path as slash-separated string. */
+    statePathString() { return this.statePath().join('/'); }
+    /** Types required by the next external transition (including in active sub-flows). */
+    waitingFor() {
+        if (this._activeSubFlow)
+            return this._activeSubFlow.waitingFor();
+        const ext = this.definition.externalFrom(this._currentState);
+        if (!ext?.guard)
+            return [];
+        return [...ext.guard.requires];
+    }
+    /** 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/dist/in-memory-flow-store.d.ts

@@ -5,6 +5,7 @@ export interface TransitionRecord {
     from: string | null;
     to: string;
     trigger: string;
+    subFlow: string | null;
     timestamp: Date;
 }
 export declare class InMemoryFlowStore {

package/dist/in-memory-flow-store.js

@@ -14,7 +14,8 @@ export class InMemoryFlowStore {
         this.flows.set(flow.id, flow);
     }
     recordTransition(flowId, from, to, trigger, _ctx) {
-        this._transitionLog.push({ flowId, from, to, trigger, timestamp: new Date() });
+        const subFlow = trigger.startsWith('subFlow:') ? trigger.substring(8, trigger.indexOf('/')) : null;
+        this._transitionLog.push({ flowId, from, to, trigger, subFlow, timestamp: new Date() });
     }
     get transitionLog() {
         return this._transitionLog;

package/dist/mermaid-generator.js

@@ -5,6 +5,25 @@ export class MermaidGenerator {
             lines.push(`  [*] --> ${def.initialState}`);
         const seen = new Set();
         for (const t of def.transitions) {
+            if (t.type === 'sub_flow' && t.subFlowDefinition) {
+                const subDef = t.subFlowDefinition;
+                lines.push(`  state ${t.from} {`);
+                if (subDef.initialState)
+                    lines.push(`    [*] --> ${subDef.initialState}`);
+                for (const st of subDef.transitions) {
+                    const sLabel = this.transitionLabel(st);
+                    lines.push(sLabel ? `    ${st.from} --> ${st.to}: ${sLabel}` : `    ${st.from} --> ${st.to}`);
+                }
+                for (const term of subDef.terminalStates)
+                    lines.push(`    ${term} --> [*]`);
+                lines.push('  }');
+                if (t.exitMappings) {
+                    for (const [exitName, target] of t.exitMappings) {
+                        lines.push(`  ${t.from} --> ${target}: ${exitName}`);
+                    }
+                }
+                continue;
+            }
             const key = `${t.from}->${t.to}`;
             if (seen.has(key))
                 continue;

package/package.json

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