@wildo-ai/saas-frontend-lib 1.0.1 → 1.1.0

package/dist/esm/core/execution/useExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecution.js","sourceRoot":"","sources":["../../../../../src/core/execution/useExecution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAEjE,OAAO,EACL,qBAAqB,EACrB,2BAA2B,EAC3B,kCAAkC,EAClC,yCAAyC,GAC1C,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,+BAA+B,EAC/B,sCAAsC,GACvC,MAAM,wDAAwD,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,6CAA6C,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAK/F,OAAO,EAAE,eAAe,EAAE,MAAM,sDAAsD,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,+DAA+D,CAAC;AACjG,OAAO,EACL,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,4DAA4D,CAAC;AACpE,OAAO,EAAE,iCAAiC,EAAE,MAAM,uEAAuE,CAAC;AAE1H,OAAO,EAAE,mBAAmB,EAAE,MAAM,wDAAwD,CAAC;AAC7F,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,GAE1B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,mEAAmE,CAAC;AAKpG,OAAO,EACL,4CAA4C,EAC5C,+CAA+C,EAC/C,iCAAiC,EACjC,qCAAqC,GAEtC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,uBAAuB,GASxB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,2CAA2C,EAAE,MAAM,+CAA+C,CAAC;AAQ5G;;;;;;;GAOG;AACH,SAAS,8BAA8B;IACrC,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAC7E,OAAO,oBAAoB,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;IACnD,CAAC;IAED,OAAO,oBAAoB,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AACrF,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,+BAA+B;IACtC,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAC7E,OAAO,qBAAqB,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;IACpD,CAAC;IAED,OAAO,qBAAqB,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AACtF,CAAC;AA0oBD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY;IAC1B,MAAM,gBAAgB,GAAG,6BAA6B,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC,CAAC;IAC5F,MAAM,EAAE,QAAQ,EAAE,GAAG,mBAAmB,EAAE,CAAC;IAC3C,MAAM,EAAE,6BAA6B,EAAE,GAAG,2CAA2C,EAAE,CAAC;IAExF,oEAAoE;IACpE,6EAA6E;IAC7E,0EAA0E;IAC1E,yEAAyE;IACzE,4EAA4E;IAC5E,kCAAkC;IAClC,MAAM,EAAE,IAAI,EAAE,GAAG,WAAW,EAAE,CAAC;IAC/B,MAAM,SAAS,GAAG,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC/C,MAAM,oBAAoB,GAAG,SAAS,EAAE,WAAW,IAAI,KAAK,CAAC;IAC7D,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAC7B,MAAM,uBAAuB,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC;IAC7D,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IACvB,uBAAuB,CAAC,OAAO,GAAG,oBAAoB,CAAC;IAEvD,wEAAwE;IACxE,0EAA0E;IAC1E,yEAAyE;IACzE,mEAAmE;IACnE,+DAA+D;IAC/D,uEAAuE;IACvE,sDAAsD;IACtD,sEAAsE;IACtE,mEAAmE;IACnE,yEAAyE;IACzE,oEAAoE;IACpE,uEAAuE;IACvE,kEAAkE;IAClE,gEAAgE;IAChE,sEAAsE;IACtE,qEAAqE;IACrE,8BAA8B;IAC9B,MAAM,eAAe,GAAG,MAAM,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAC9D,eAAe,CAAC,OAAO,GAAG,gBAAgB,CAAC,YAAY,CAAC;IAExD,MAAM,cAAc,GAAG,OAAO,CAA+C,GAAG,EAAE,CAAC,CACjF,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,aAAa,CAAC,EAAE,EAAE,CAAC;QAC5E,GAAG;QACH,iCAAiC,CAAC;YAChC,aAAa;YACb,QAAQ;SACT,CAAC;KACH,CAAC,CACH,CACF,EAAE,CAAC,gBAAgB,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEhD,MAAM,aAAa,GAAG,WAAW,CAAC,CAAC,GAAW,EAA4C,EAAE,CAAC,CAC3F,cAAc,CAAC,GAAG,CAAC,CACpB,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;IAErB,MAAM,oBAAoB,GAAG,WAAW,CAAC,CAAC,GAAW,EAAgC,EAAE;QACrF,MAAM,qBAAqB,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;QAElD,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CACb,4BAA4B,GAAG,0BAA0B,gBAAgB,CAAC,cAAc,CAAC,GAAG,yBAAyB,CACtH,CAAC;QACJ,CAAC;QAED,OAAO,qBAAqB,CAAC;IAC/B,CAAC,EAAE,CAAC,gBAAgB,CAAC,cAAc,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC;IAE1D,MAAM,qBAAqB,GAAG,WAAW,CAAC,CACxC,IAAW,EAC0B,EAAE;QACvC,OAAO,MAAM,CAAC,WAAW,CACvB,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC,CACb,CAAC;IAC3C,CAAC,EAAE,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAE3B,MAAM,eAAe,GAAG,WAAW,CAAC,CAClC,SAAyB,EAC2C,EAAE;QACtE,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7B,OAAO,qBAAqB,CAAC,SAAS,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,oBAAoB,CAAC,SAAmB,CAAC,CAAC;IACnD,CAAC,EAAE,CAAC,oBAAoB,EAAE,qBAAqB,CAAC,CAAC,CAAC;IAElD,MAAM,yBAAyB,GAAG,WAAW,CAAC,CAC5C,iBAA2B,EACM,EAAE;QACnC,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnC,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,+CAA+C,CAAC;YACrD,iBAAiB;YACjB,cAAc,EAAE,gBAAgB,CAAC,cAAc;YAC/C,QAAQ;SACT,CAAC,CAAC;IACL,CAAC,EAAE,CAAC,gBAAgB,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEhD,MAAM,6BAA6B,GAAG,WAAW,CAAqC,CAAC,MAAM,EAAE,EAAE;QAC/F,MAAM,iCAAiC,GAAG,CAAC,MAAM,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,MAAM,CAAiE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YAClK,MAAM,aAAa,GAAG,gBAAgB,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAC3D,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,MAAM,IAAI,KAAK,CACb,qEAAqE,GAAG,cAAc,gBAAgB,CAAC,cAAc,CAAC,GAAG,IAAI,CAC9H,CAAC;YACJ,CAAC;YAED,MAAM,iBAAiB,GAAG,4CAA4C,CAAC;gBACrE,aAAa;gBACb,QAAQ;aACT,CAAC,CAAC;YACH,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,OAAO,GAAG,CAAC;YACb,CAAC;YAED,oDAAoD;YACpD,6EAA6E;YAC7E,kEAAkE;YAClE,iFAAiF;YACjF,sEAAsE;YACtE,4DAA4D;YAC5D,MAAM,UAAU,GAAG,qCAAqC,CAAC,aAAa,CAAC,CAAC;YACxE,MAAM,yBAAyB,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC;YAClD,IAAI,yBAAyB,EAAE,CAAC;gBAC9B,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,aAAa,CAAC,yBAAyB,CAAC,CAAC;gBAC1F,MAAM,cAAc,GAAG,qBAAqB,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;gBAC9E,MAAM,uBAAuB,GAAG,qBAAqB,CAAC,kBAAkB,CAAC,yBAAyB,CAAC,CAAC;gBACpG,MAAM,mBAAmB,GAAG,qBAAqB,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;gBAExF,IACE,kBAAkB,KAAK,cAAc;uBAClC,uBAAuB,KAAK,mBAAmB,EAClD,CAAC;oBACD,MAAM,qBAAqB,CAAC,uBAAuB,CACjD,2BAA2B,CAAC,aAAa,EACzC;wBACE,SAAS,EAAE,gCAAgC;wBAC3C,OAAO,EAAE,4EAA4E,UAAU,IAAI;wBACnG,UAAU;wBACV,yBAAyB;wBACzB,qBAAqB,EAAE,iBAAiB;wBACxC,gBAAgB,EAAE,GAAG;wBACrB,gBAAgB,EAAE,gBAAgB,CAAC,cAAc,CAAC,GAAG;qBACtD,CACF,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,GAAG,CAAC,UAAU,CAAC,GAAG,iBAAiB,CAAC;YACpC,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAE,CAAC,CAAC;QACT,MAAM,cAAc,GAAqC;YACvD,GAAG,MAAM;YACT,0BAA0B,EAAE;gBAC1B,GAAG,iCAAiC;gBACpC,GAAG,CAAC,MAAM,CAAC,0BAA0B,IAAI,EAAE,CAAC;aAC7C;SACF,CAAC;QACF,MAAM,eAAe,GAAG,6BAA6B,CAAC,cAAc,CAAC,CAAC;QACtE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,eAAe,CAAC;QACpD,MAAM,WAAW,GAAG,MAAM,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;QAC1D,MAAM,cAAc,GAAG,QAAQ,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAC;QACrE,MAAM,oBAAoB,GAAG,qBAAqB,CAAC,yBAAyB,CAC1E,eAAe,CAAC,0BAA0B,EAC1C,QAAQ,CACT,CAAC;QACF,MAAM,sBAAsB,GAAG,sCAAsC,CAAC;YACpE,cAAc,EAAE,gBAAgB,CAAC,cAAc;YAC/C,YAAY;YACZ,SAAS;SACV,CAAC,CAAC;QACH,MAAM,0BAA0B,GAAG,eAAe,CAAC,wBAAwB,CACzE,gBAAgB,CAAC,cAAc,EAC/B,WAAW,CACZ,CAAC;QACF,MAAM,yBAAyB,GAA+B;YAC5D,GAAG,0BAA0B;YAC7B,GAAG,CAAC,MAAM,CAAC,mBAAmB,IAAI,EAAE,CAAC;SACtC,CAAC;QAEF,MAAM,iBAAiB,GAA+B;YACpD,WAAW,EAAE,qBAAqB,CAAC,kBAAkB;YACrD,eAAe;SAChB,CAAC;QAEF,MAAM,KAAK,GAAG,GAAY,EAAE;YAC1B,gBAAgB,CAAC,UAAU,CAAC,mBAAmB,CAAC;gBAC9C,OAAO,EAAE,iBAAiB;gBAC1B,mBAAmB,EAAE,yBAAyB;aAC/C,CAAC,CAAC;YACH,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;QAEF,MAAM,QAAQ,GAAG,GAAY,EAAE;YAC7B,IAAI,sBAAsB,KAAK,+BAA+B,CAAC,aAAa,EAAE,CAAC;gBAC7E,OAAO,KAAK,EAAE,CAAC;YACjB,CAAC;YAED,MAAM,UAAU,GAAG,cAAc;gBAC/B,CAAC,CAAC,yCAAyC,CAAC,gCAAgC,CACxE,cAAc,EACd,SAAS,EACT,QAAQ,CAAC,2BAA2B,CACrC;gBACH,CAAC,CAAC,EAAE,CAAC;YACP,MAAM,OAAO,GAAG,cAAc,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC;gBACrD,CAAC,CAAC,qBAAqB,CAAC,uBAAuB,CAC3C,UAAU,EACV,eAAe,CAAC,0BAA0B,EAC1C,YAAY,EACZ,cAAc,CAAC,uBAAuB,EACtC,eAAe,CAAC,2BAA2B,CAC5C,CAAC,GAAG;gBACP,CAAC,CAAC,SAAS,CAAC;YAEd,gBAAgB,CAAC,UAAU,CAAC,gBAAgB,CAAC;gBAC3C,OAAO,EAAE,iBAAiB;gBAC1B,OAAO;gBACP,sBAAsB,EAAE,MAAM,CAAC,sBAAsB;gBACrD,SAAS,EAAE;oBACT,GAAG,MAAM,CAAC,mBAAmB;oBAC7B,eAAe,EAAE,yBAAyB,CAAC,eAAe;oBAC1D,GAAG,CAAC,yBAAyB,CAAC,kBAAkB;wBAC9C,CAAC,CAAC,EAAE,kBAAkB,EAAE,yBAAyB,CAAC,kBAAkB,EAAE;wBACtE,CAAC,CAAC,EAAE,CAAC;oBACP,GAAG,CAAC,yBAAyB,CAAC,QAAQ;wBACpC,CAAC,CAAC,EAAE,QAAQ,EAAE,yBAAyB,CAAC,QAAQ,EAAE;wBAClD,CAAC,CAAC,EAAE,CAAC;iBACR;aACF,CAAC,CAAC;YAEH,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;QAEF,qEAAqE;QACrE,gEAAgE;QAChE,MAAM,gBAAgB,GAAG,kCAAkC,CAAC,mCAAmC,CAAC,SAAS,CAAC,CAAC;QAE3G,MAAM,OAAO,GAAG,KAAK,EAAE,WAAqC,EAAoB,EAAE;YAChF,MAAM,oBAAoB,GAAG,iCAAiC,CAAC;gBAC7D,SAAS;gBACT,WAAW;gBACX,iBAAiB,EAAE,eAAe,CAAC,iBAAiB;aACrD,CAAC,CAAC;YAEH,MAAM,aAAa,GAA2B;gBAC5C,eAAe,EAAE,8BAA8B,EAAE;gBACjD,gBAAgB;gBAChB,YAAY;gBACZ,WAAW;gBACX,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;aACtB,CAAC;YACF,gBAAgB,CAAC,UAAU,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;YAE9D,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,WAAW,CAAC,gBAAgB,EAAE;oBAClE,oBAAoB;oBACpB,2BAA2B,EAAE,eAAe,CAAC,2BAA2B;oBACxE,GAAG,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBACvE,CAAC,CAAC;gBAEH,sEAAsE;gBACtE,mEAAmE;gBACnE,sEAAsE;gBACtE,4BAA4B,CAAC;oBAC3B,IAAI,EAAE,OAAO,CAAC,OAAO;oBACrB,cAAc;oBACd,QAAQ;oBACR,YAAY;oBACZ,SAAS;oBACT,eAAe;oBACf,oBAAoB,EAAE,uBAAuB,CAAC,OAAO;oBACrD,MAAM;iBACP,CAAC,CAAC;gBAEH,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,uCAAuC;gBACvC,+DAA+D;gBAC/D,4DAA4D;gBAC5D,oEAAoE;gBACpE,qDAAqD;gBACrD,mEAAmE;gBACnE,iEAAiE;gBACjE,iEAAiE;gBACjE,oEAAoE;gBACpE,iEAAiE;gBACjE,4DAA4D;gBAC5D,MAAM,kBAAkB,GAAG,yBAAyB,CAAC,KAAK,CAAC,CAAC;gBAC5D,MAAM,uBAAuB,GAAG,CAAC,kBAAkB,CAAC;gBACpD,IAAI,uBAAuB,EAAE,CAAC;oBAC5B,eAAe,CAAC,WAAW,CAAC,KAAK,EAAE;wBACjC,MAAM,EAAE,SAAS;wBACjB,YAAY;wBACZ,mBAAmB,EAAE,WAAW;wBAChC,iBAAiB,EAAE;4BACjB,0BAA0B,EAAE,gBAAgB,CAAC,iBAAiB;4BAC9D,gBAAgB,EAAE,gBAAgB,CAAC,cAAc,CAAC,GAAG;4BACrD,gBAAgB;yBACjB;qBACF,CAAC,CAAC;gBACL,CAAC;gBACD,iEAAiE;gBACjE,+DAA+D;gBAC/D,gEAAgE;gBAChE,2DAA2D;gBAC3D,0DAA0D;gBAC1D,8DAA8D;gBAC9D,+DAA+D;gBAC/D,4DAA4D;gBAC5D,gDAAgD;gBAChD,MAAM,gBAAgB,GAAG;oBACvB,gBAAgB,EAAE,+BAA+B,EAAE;oBACnD,0BAA0B,EAAE,aAAa,CAAC,eAAe;oBACzD,gBAAgB;oBAChB,YAAY;oBACZ,WAAW;oBACX,SAAS,EAAE,aAAa,CAAC,SAAS;oBAClC,KAAK;oBACL,kBAAkB;oBAClB,uBAAuB;iBACxB,CAAC;gBACF,IAAI,iBAAkD,CAAC;gBACvD,IAAI,MAAM,CAAC,YAAY,EAAE,KAAK,KAAK,0BAA0B,CAAC,UAAU,EAAE,CAAC;oBACzE,iBAAiB,GAAG;wBAClB,GAAG,gBAAgB;wBACnB,KAAK,EAAE,MAAM,CAAC,YAAY,CAAC,KAAK;wBAChC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM;qBACnC,CAAC;gBACJ,CAAC;qBAAM,IAAI,MAAM,CAAC,YAAY,EAAE,KAAK,KAAK,0BAA0B,CAAC,gBAAgB,EAAE,CAAC;oBACtF,iBAAiB,GAAG;wBAClB,GAAG,gBAAgB;wBACnB,KAAK,EAAE,MAAM,CAAC,YAAY,CAAC,KAAK;qBACjC,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,iBAAiB,GAAG;wBAClB,GAAG,gBAAgB;wBACnB,KAAK,EAAE,0BAA0B,CAAC,MAAM;qBACzC,CAAC;gBACJ,CAAC;gBACD,MAAM,YAAY,GAAG,0BAA0B,CAAC,iBAAiB,CAAC,CAAC;gBACnE,gBAAgB,CAAC,UAAU,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;gBAC9D,MAAM,KAAK,CAAC;YACd,CAAC;oBAAS,CAAC;gBACT,gBAAgB,CAAC,UAAU,CAAC,gBAAgB,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;YAC9E,CAAC;QACH,CAAC,CAAC;QAEF,MAAM,cAAc,GAAG,GAAY,EAAE;YACnC,IAAI,CAAC;gBACH,OAAO,6BAA6B,CAAC;oBACnC,YAAY,EAAE,MAAM,CAAC,YAAY;oBACjC,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;oBACzC,wBAAwB,EAAE,MAAM,CAAC,wBAAwB;oBACzD,0BAA0B,EAAE,MAAM,CAAC,0BAA0B;oBAC7D,0BAA0B,EAAE,MAAM,CAAC,0BAA0B;oBAC7D,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;oBAC3C,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;oBAC/C,sBAAsB,EAAE,MAAM,CAAC,sBAAsB;oBACrD,aAAa,EAAE,qBAAqB,CAAC,IAAI;oBACzC,kBAAkB,EAAE,IAAI;iBACzB,CAAC,CAAC,QAAQ,EAAE,CAAC;YAChB,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC,CAAC;QAEF,mDAAmD;QACnD,EAAE;QACF,6DAA6D;QAC7D,EAAE;QACF,sEAAsE;QACtE,sEAAsE;QACtE,8DAA8D;QAC9D,uEAAuE;QACvE,qEAAqE;QACrE,mBAAmB;QACnB,kEAAkE;QAClE,8DAA8D;QAC9D,mEAAmE;QACnE,qEAAqE;QACrE,yDAAyD;QACzD,qDAAqD;QACrD,oEAAoE;QACpE,yBAAyB;QACzB,oEAAoE;QACpE,qEAAqE;QACrE,sEAAsE;QACtE,oEAAoE;QACpE,iEAAiE;QACjE,iEAAiE;QACjE,iDAAiD;QACjD,IAAI,eAAe,GAAiC,IAAI,CAAC;QACzD,IAAI,YAAY,GAA0C,IAAI,CAAC;QAC/D,MAAM,aAAa,GAAG,GAAmC,EAAE;YACzD,MAAM,IAAI,GAAG,eAAe,CAAC,OAAO,CAAC;YACrC,IAAI,eAAe,KAAK,IAAI,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;gBACtD,OAAO,YAAY,CAAC;YACtB,CAAC;YACD,MAAM,sBAAsB,GAA6B,EAAE,CAAC;YAC5D,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;gBACzD,IAAI,OAAO,CAAC,gBAAgB,KAAK,gBAAgB,EAAE,CAAC;oBAClD,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC;YACD,MAAM,qBAAqB,GAA4B,EAAE,CAAC;YAC1D,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;gBACvD,IAAI,MAAM,CAAC,gBAAgB,KAAK,gBAAgB,EAAE,CAAC;oBACjD,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC;YACD,MAAM,oBAAoB,GAA2B,EAAE,CAAC;YACxD,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;gBAC1B,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;oBACtD,IAAI,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;wBAClC,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBACpC,CAAC;gBACH,CAAC;YACH,CAAC;YACD,sEAAsE;YACtE,sEAAsE;YACtE,mEAAmE;YACnE,mDAAmD;YACnD,IAAI,aAAgD,CAAC;YACrD,KAAK,MAAM,SAAS,IAAI,qBAAqB,EAAE,CAAC;gBAC9C,IAAI,CAAC,aAAa,IAAI,SAAS,CAAC,UAAU,GAAG,aAAa,CAAC,UAAU,EAAE,CAAC;oBACtE,aAAa,GAAG,SAAS,CAAC;gBAC5B,CAAC;YACH,CAAC;YACD,YAAY,GAAG;gBACb,cAAc,EAAE,sBAAsB;gBACtC,aAAa,EAAE,qBAAqB;gBACpC,YAAY,EAAE,oBAAoB;gBAClC,SAAS,EAAE,sBAAsB,CAAC,MAAM,GAAG,CAAC;gBAC5C,SAAS,EAAE,qBAAqB,CAAC,MAAM,GAAG,CAAC;gBAC3C,OAAO,EAAE,oBAAoB,CAAC,MAAM,GAAG,CAAC;gBACxC,aAAa;aACd,CAAC;YACF,eAAe,GAAG,IAAI,CAAC;YACvB,OAAO,YAAY,CAAC;QACtB,CAAC,CAAC;QAEF,gDAAgD;QAChD,EAAE;QACF,qEAAqE;QACrE,mEAAmE;QACnE,+DAA+D;QAC/D,oEAAoE;QACpE,mEAAmE;QACnE,mEAAmE;QACnE,kEAAkE;QAClE,oCAAoC;QACpC,MAAM,eAAe,GAAG,GAAS,EAAE;YACjC,MAAM,IAAI,GAAG,eAAe,CAAC,OAAO,CAAC;YACrC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;gBACvD,IAAI,MAAM,CAAC,gBAAgB,KAAK,gBAAgB,EAAE,CAAC;oBACjD,gBAAgB,CAAC,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;gBACzE,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QACF,MAAM,YAAY,GAAG,GAAS,EAAE;YAC9B,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;gBAC3B,OAAO;YACT,CAAC;YACD,MAAM,IAAI,GAAG,eAAe,CAAC,OAAO,CAAC;YACrC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;gBACtD,IAAI,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;oBAClC,gBAAgB,CAAC,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAC1D,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QACF,MAAM,KAAK,GAAG,KAAK,EAAE,WAAqC,EAAoB,EAAE;YAC9E,qDAAqD;YACrD,iEAAiE;YACjE,oEAAoE;YACpE,iEAAiE;YACjE,eAAe,EAAE,CAAC;YAClB,OAAO,OAAO,CAAC,WAAW,CAAC,CAAC;QAC9B,CAAC,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,cAAc;YACtB,eAAe;YACf,YAAY;YACZ,SAAS;YACT,WAAW;YACX,gBAAgB;YAChB,oBAAoB;YACpB,sBAAsB;YACtB,IAAI,MAAM;gBACR,OAAO,aAAa,EAAE,CAAC;YACzB,CAAC;YACD,OAAO;YACP,KAAK;YACL,QAAQ;YACR,cAAc;YACd,KAAK;YACL,eAAe;YACf,YAAY;SACb,CAAC;IACJ,CAAC,EAAE;QACD,6BAA6B;QAC7B,gBAAgB,CAAC,WAAW;QAC5B,gBAAgB,CAAC,UAAU;QAC3B,gBAAgB,CAAC,cAAc;QAC/B,gBAAgB,CAAC,cAAc;QAC/B,QAAQ;KACT,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,OAAO,CAAyB,GAAG,EAAE,CAAC,CAAC;QACtD,GAAG,EAAE,cAAc;QACnB,GAAG,EAAE,aAAa;QAClB,OAAO,EAAE,eAAoD;KAC9D,CAAC,EAAE;QACF,aAAa;QACb,cAAc;QACd,eAAe;KAChB,CAAC,CAAC;IAEH,MAAM,qBAAqB,GAAG,WAAW,CAAC,CACxC,WAAkB,EACuC,EAAE;QAC3D,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,EAAE;YACpD,MAAM,eAAe,GAAG,CAAC,SAA2C,EAAE,EAAE;gBACtE,MAAM,YAAY,GAA0B;oBAC1C,GAAG,UAAU;oBACb,GAAG,SAAS;oBACZ,0BAA0B,EAAE;wBAC1B,GAAG,CAAC,UAAU,CAAC,0BAA0B,IAAI,EAAE,CAAC;wBAChD,GAAG,CAAC,SAAS,EAAE,0BAA0B,IAAI,EAAE,CAAC;qBACjD;oBACD,iBAAiB,EAAE;wBACjB,GAAG,CAAC,UAAU,CAAC,iBAAiB,IAAI,EAAE,CAAC;wBACvC,GAAG,CAAC,SAAS,EAAE,iBAAiB,IAAI,EAAE,CAAC;qBACxC;oBACD,mBAAmB,EAAE;wBACnB,GAAG,CAAC,UAAU,CAAC,mBAAmB,IAAI,EAAE,CAAC;wBACzC,GAAG,CAAC,SAAS,EAAE,mBAAmB,IAAI,EAAE,CAAC;qBAC1C;iBACF,CAAC;gBAEF,OAAO,6BAA6B,CAAC,YAAY,CAAC,CAAC;YACrD,CAAC,CAAC;YAEF,MAAM,QAAQ,GAA4B;gBACxC,OAAO,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;gBACpF,KAAK,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE;gBACxD,QAAQ,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE;gBAC9D,cAAc,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,cAAc,EAAE;gBAC1E,IAAI,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC;aAChD,CAAC;YAEF,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACzB,CAAC,CAAC,CACwD,CAAC;IAC/D,CAAC,EAAE,CAAC,6BAA6B,CAAC,CAAC,CAAC;IAEpC,MAAM,OAAO,GAAG,OAAO,CAAwB,GAAG,EAAE,CAAC,CAAC;QACpD,SAAS,EAAE,6BAA6B;QACxC,UAAU,EAAE,qBAAqB;KAClC,CAAC,EAAE,CAAC,qBAAqB,EAAE,6BAA6B,CAAC,CAAC,CAAC;IAE5D,MAAM,eAAe,GAAG,OAAO,CAAgC,GAAG,EAAE,CAAC,CAAC;QACpE,IAAI,EAAE,gBAAgB,CAAC,UAAU,CAAC,mBAAmB;QACrD,KAAK,EAAE,gBAAgB,CAAC,UAAU,CAAC,oBAAoB;QACvD,YAAY,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE;KACxE,CAAC,EAAE;QACF,6BAA6B;QAC7B,gBAAgB,CAAC,UAAU,CAAC,oBAAoB;QAChD,gBAAgB,CAAC,UAAU,CAAC,mBAAmB;KAChD,CAAC,CAAC;IAEH,MAAM,OAAO,GAAG,OAAO,CAAwB,GAAG,EAAE;QAClD,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;QACnF,MAAM,4BAA4B,GAAG,MAAM,CAAC,MAAM,CAChD,gBAAgB,CAAC,YAAY,CAAC,4BAA4B,CAC3D,CAAC;QACF,MAAM,YAAY,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC;QAC/C,MAAM,6BAA6B,GAAG,4BAA4B,CAAC,MAAM,GAAG,CAAC,CAAC;QAC9E,MAAM,MAAM,GAAG,YAAY,IAAI,6BAA6B,CAAC;QAC7D,OAAO;YACL,cAAc;YACd,4BAA4B;YAC5B,MAAM;YACN,YAAY;YACZ,SAAS,EAAE,CAAC,SAAS,EAAE,EAAE;gBACvB,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,OAAO,YAAY,CAAC;gBACtB,CAAC;gBACD,OAAO,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACxC,CAAC;YACD,6BAA6B;YAC7B,0BAA0B,EAAE,CAAC,SAAS,EAAE,EAAE;gBACxC,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,OAAO,6BAA6B,CAAC;gBACvC,CAAC;gBACD,OAAO,4BAA4B,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACtD,CAAC;SACF,CAAC;IACJ,CAAC,EAAE;QACD,gBAAgB,CAAC,YAAY,CAAC,cAAc;QAC5C,gBAAgB,CAAC,YAAY,CAAC,4BAA4B;KAC3D,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,OAAO,CAAsB,GAAG,EAAE;QAC9C,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;QAC1E,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QACtC,OAAO;YACL,OAAO;YACP,UAAU;YACV,OAAO,EAAE,CAAC,SAAS,EAAE,EAAE;gBACrB,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,OAAO,UAAU,CAAC;gBACpB,CAAC;gBACD,OAAO,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACjC,CAAC;YACD,IAAI,EAAE,gBAAgB,CAAC,UAAU,CAAC,SAAS;YAC3C,KAAK,EAAE,gBAAgB,CAAC,UAAU,CAAC,UAAU;YAC7C,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,aAAa;SACpD,CAAC;IACJ,CAAC,EAAE;QACD,gBAAgB,CAAC,UAAU,CAAC,aAAa;QACzC,gBAAgB,CAAC,UAAU,CAAC,UAAU;QACtC,gBAAgB,CAAC,UAAU,CAAC,SAAS;QACrC,gBAAgB,CAAC,YAAY,CAAC,YAAY;KAC3C,CAAC,CAAC;IAEH,2EAA2E;IAC3E,0EAA0E;IAC1E,+CAA+C;IAC/C,MAAM,sBAAsB,GAAG,MAAM,CAAC,gBAAgB,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC;IACvF,MAAM,oBAAoB,GAAG,MAAM,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC;IACxE,MAAM,oBAAoB,GAAG,MAAM,CAAC,gBAAgB,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;IACzE,sBAAsB,CAAC,OAAO,GAAG,gBAAgB,CAAC,UAAU,CAAC,mBAAmB,CAAC;IACjF,oBAAoB,CAAC,OAAO,GAAG,gBAAgB,CAAC,iBAAiB,CAAC;IAClE,oBAAoB,CAAC,OAAO,GAAG,gBAAgB,CAAC,cAAc,CAAC,GAAG,CAAC;IAEnE,MAAM,0BAA0B,GAAG,WAAW,CAAC,CAAC,KAAiC,EAAyB,EAAE;QAC1G,MAAM,kBAAkB,GAAG,yBAAyB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAClE,oEAAoE;QACpE,kEAAkE;QAClE,4DAA4D;QAC5D,MAAM,uBAAuB,GAAG,CAAC,KAAK,CAAC,oBAAoB,IAAI,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC;QAC5F,IAAI,uBAAuB,EAAE,CAAC;YAC5B,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,EAAE;gBACvC,MAAM,EAAE,QAAQ;gBAChB,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,mBAAmB,EAAE,KAAK,CAAC,WAAW;gBACtC,iBAAiB,EAAE;oBACjB,0BAA0B,EAAE,oBAAoB,CAAC,OAAO;oBACxD,gBAAgB,EAAE,oBAAoB,CAAC,OAAO;oBAC9C,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,KAAK,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBAChF;aACF,CAAC,CAAC;QACL,CAAC;QACD,qEAAqE;QACrE,kEAAkE;QAClE,uEAAuE;QACvE,uEAAuE;QACvE,MAAM,cAAc,GAAG;YACrB,gBAAgB,EAAE,+BAA+B,EAAE;YACnD,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,kBAAkB;YAClB,uBAAuB;SACxB,CAAC;QACF,IAAI,YAAmC,CAAC;QACxC,IAAI,KAAK,CAAC,KAAK,KAAK,0BAA0B,CAAC,UAAU,EAAE,CAAC;YAC1D,YAAY,GAAG,0BAA0B,CAAC;gBACxC,GAAG,cAAc;gBACjB,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,MAAM,EAAE,KAAK,CAAC,MAAM;aACrB,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,KAAK,CAAC,KAAK,KAAK,0BAA0B,CAAC,gBAAgB,EAAE,CAAC;YACvE,YAAY,GAAG,0BAA0B,CAAC;gBACxC,GAAG,cAAc;gBACjB,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,KAAK,CAAC,KAAK,KAAK,0BAA0B,CAAC,sBAAsB,EAAE,CAAC;YAC7E,YAAY,GAAG,0BAA0B,CAAC;gBACxC,GAAG,cAAc;gBACjB,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,WAAW,EAAE,KAAK,CAAC,WAAW;aAC/B,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,YAAY,GAAG,0BAA0B,CAAC;gBACxC,GAAG,cAAc;gBACjB,KAAK,EAAE,0BAA0B,CAAC,MAAM;aACzC,CAAC,CAAC;QACL,CAAC;QACD,sBAAsB,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QAC7C,OAAO,YAAY,CAAC;IACtB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,MAAM,GAAG,OAAO,CAAuB,GAAG,EAAE;QAChD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;QACjF,MAAM,YAAY,GAAG,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC;QAC9C,OAAO;YACL,aAAa;YACb,YAAY;YACZ,SAAS,EAAE,CAAC,SAAS,EAAE,EAAE;gBACvB,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,OAAO,YAAY,CAAC;gBACtB,CAAC;gBACD,OAAO,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACvC,CAAC;YACD,OAAO,EAAE,0BAA0B;YACnC,KAAK,EAAE,gBAAgB,CAAC,UAAU,CAAC,iBAAiB;YACpD,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,qBAAqB;SAC5D,CAAC;IACJ,CAAC,EAAE;QACD,0BAA0B;QAC1B,gBAAgB,CAAC,UAAU,CAAC,qBAAqB;QACjD,gBAAgB,CAAC,UAAU,CAAC,iBAAiB;QAC7C,gBAAgB,CAAC,YAAY,CAAC,aAAa;KAC5C,CAAC,CAAC;IAEH,OAAO,OAAO,CAAiB,GAAG,EAAE,CAAC,CAAC;QACpC,IAAI,EAAE,gBAAgB,CAAC,cAAc;QACrC,MAAM,EAAE,gBAAgB,CAAC,MAAM;QAC/B,KAAK,EAAE,gBAAgB,CAAC,YAAY;QACpC,0BAA0B,EAAE,gBAAgB,CAAC,0BAA0B;QACvE,iBAAiB,EAAE,gBAAgB,CAAC,iBAAiB;QACrD,cAAc,EAAE,gBAAgB,CAAC,cAAc;QAC/C,WAAW,EAAE,gBAAgB,CAAC,WAAW;QACzC,gBAAgB,EAAE,gBAAgB,CAAC,UAAU,CAAC,gBAAgB;QAC9D,SAAS,EAAE;YACT,IAAI,EAAE,gBAAgB,CAAC,UAAU,CAAC,aAAa;YAC/C,KAAK,EAAE,gBAAgB,CAAC,UAAU,CAAC,cAAc;SAClD;QACD,eAAe;QACf,OAAO;QACP,KAAK;QACL,MAAM;QACN,cAAc;QACd,aAAa;QACb,oBAAoB;QACpB,QAAQ;QACR,yBAAyB;QACzB,6BAA6B;QAC7B,OAAO;KACR,CAAC,EAAE;QACF,OAAO;QACP,yBAAyB;QACzB,6BAA6B;QAC7B,gBAAgB,CAAC,MAAM;QACvB,gBAAgB,CAAC,0BAA0B;QAC3C,gBAAgB,CAAC,WAAW;QAC5B,gBAAgB,CAAC,UAAU;QAC3B,gBAAgB,CAAC,cAAc;QAC/B,gBAAgB,CAAC,iBAAiB;QAClC,gBAAgB,CAAC,YAAY;QAC7B,gBAAgB,CAAC,cAAc;QAC/B,eAAe;QACf,OAAO;QACP,KAAK;QACL,MAAM;QACN,aAAa;QACb,cAAc;QACd,oBAAoB;QACpB,QAAQ;KACT,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { useCallback, useContext, useMemo, useRef } from 'react';\n\nimport {\n  CoreResourceOperation,\n  ErrorCustomMessageReference,\n  ResourcesConfig_OperationPathUtils,\n  ResourcesConfigOperationsUrlsBuilderUtils,\n} from '@wildo-ai/saas-models';\nimport {\n  ExecutionNavigationHandlingMode,\n  resolveExecutionNavigationHandlingMode,\n} from '~wildo-frontend-lib/core/config/execution-view.schemas';\nimport { useEventBus } from '~wildo-frontend-lib/core/events/useEventBus';\nimport { NavigationContentType } from '~wildo-frontend-lib/core/navigation/navigation.schemas';\nimport type {\n  NavigationInitiatorContext,\n  NavigationZone,\n} from '~wildo-frontend-lib/core/navigation/navigation.schemas';\nimport { NavigationUtils } from '~wildo-frontend-lib/core/navigation/navigation.utils';\nimport { WebSocketContext } from '~wildo-frontend-lib/core/requests/websockets/WebSocketContext';\nimport {\n  frontendResourceUtils,\n  FrontendResourceUtils,\n} from '~wildo-frontend-lib/core/resources/frontend-resource.utils';\nimport { mergeBulkSelectionIntoRequestData } from '~wildo-frontend-lib/core/resources/operation-semantics.frontend.utils';\nimport type { ResourceRegistryContextType } from '~wildo-frontend-lib/core/resources/ResourceRegistryContext';\nimport { useResourceRegistry } from '~wildo-frontend-lib/core/resources/useResourceRegistry';\nimport { emitResourceOperationOutcome } from './execution-outcome-emission.utils';\nimport {\n  buildExecutionFailedAction,\n  isErrorMarkedByHttpClient,\n  type BuildExecutionFailedActionInput,\n} from './execution-failure-handling.utils';\nimport { errorManagement } from '~wildo-frontend-lib/core/errors/error-management.frontend.service';\nimport type {\n  FrontendResourceConfiguration_Operation,\n  FrontendResourceOperationContext,\n} from '~wildo-frontend-lib/core/resources/resources.frontend.schemas';\nimport {\n  buildExecutionParticipationContextIdentifier,\n  buildExecutionParticipationContextualParameters,\n  buildExecutionParticipationHandle,\n  getExecutionParticipationResourceType,\n  type ExecutionParticipationHandle,\n} from './execution-participation.utils';\nimport {\n  assertExecutionRuntimeContext,\n  ExecutionFailedActionScope,\n  ExecutionRuntimeContext,\n  type ExecutionAnchor,\n  type ExecutionDirtyMarker,\n  type ExecutionEmbeddableContent,\n  type ExecutionFailedAction,\n  type ExecutionNavigationValue,\n  type ExecutionPendingAction,\n  type ExecutionPendingPrefetch,\n  type ExecutionRuntimeState,\n} from './ExecutionRuntimeContext';\nimport type { ExecutionViewDefinition } from '~wildo-frontend-lib/core/config/execution-view.schemas';\nimport { useExecutionResourceOperationContextBuilder } from './useExecutionResourceOperationContextBuilder';\nimport type { ExecutionResourceOperationContextBuilderValue } from './useExecutionResourceOperationContextBuilder';\nimport type { ExecutionResourceOperationTarget } from './useExecutionResourceOperationContextBuilder';\n\ntype ExecutionParticipationRecord<TRefs extends readonly string[]> = {\n  [K in TRefs[number]]: ExecutionParticipationHandle;\n};\n\n/**\n * Opaque, collision-resistant id for a shell-tracked pending action.\n *\n * Kept private to the execution runtime — `actionRuntimeId` is surfaced via\n * the public `ExecutionPendingAction` type but its *generation* is a\n * framework detail so consumers cannot reach past the `execute()` verb to\n * push their own entries.\n */\nfunction createExecutionActionRuntimeId(): string {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return `execution-action-${crypto.randomUUID()}`;\n  }\n\n  return `execution-action-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\n/**\n * Opaque, collision-resistant id for a captured execution failure entry.\n *\n * Distinct namespace from `actionRuntimeId` so a failed action and its\n * originating pending action have different ids and a re-attempt of the same\n * action produces a fresh failure entry rather than mutating the prior one\n * (failure-handling-contract invariant #5).\n */\nfunction createExecutionFailureRuntimeId(): string {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return `execution-failure-${crypto.randomUUID()}`;\n  }\n\n  return `execution-failure-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\nexport interface ExecutionSubjectsValue {\n  all: Record<string, ExecutionParticipationHandle>;\n  get: (ref: string) => ExecutionParticipationHandle | undefined;\n  require: {\n    (ref: string): ExecutionParticipationHandle;\n    <TRefs extends readonly string[]>(refs: TRefs): ExecutionParticipationRecord<TRefs>;\n  };\n}\n\n/**\n * Optional per-action override for the scope assigned to failures captured by\n * the shell's `execute()` catch path.\n *\n * Default (when omitted): `ExecutionFailedActionScope.CUSTOM` — the captured\n * failure persists in `failedActions` until a consumer clears it\n * (`action.clearMyFailures()` / `errors.clear*`) or a global aggregator\n * mechanism removes it. CUSTOM-scoped failures survive every pane / embed\n * transition.\n *\n * Opt-in to `LOCAL_PANE` (with the active `paneId`) so the captured failure\n * **auto-prunes** on the next `closeLocalPane()` or\n * `openLocalPane(newPaneId, ...)` via `pruneFailedActionsForPaneTransition`\n * — the same prune wiring Slice I uses for LOCAL_PANE dirty markers. This is\n * the natural choice for buttons that live inside a pane: closing the pane\n * forgets the failed call without the consumer having to author cleanup.\n *\n * Opt-in to `EMBEDDED_CONTENT` so the captured failure auto-prunes on\n * embedded-content close/replace via `pruneFailedActionsForScopeChange`. This\n * fits actions wired through an `ExecutionEmbeddedContentValue.openResource`\n * surface where the failure semantics belong to the embed slot, not the\n * surrounding shell.\n *\n * The discriminated union enforces \"`paneId` is required for `LOCAL_PANE`\"\n * at the call site so a misconfigured action cannot escape the auto-prune\n * invariant by silently falling through with a missing paneId. Mirrors the\n * exact shape `errors.capture(...)` already accepts on the consumer-facing\n * seam (see `ExecutionErrorCaptureInput`) so both publish paths read with\n * the same vocabulary.\n *\n * Only the `execute()` catch path consumes this option — `embed()`,\n * `navigate()`, and `navigateToRead()` never publish failures into\n * `failedActions` themselves (they delegate to downstream layers that own\n * their own failure capture).\n */\nexport type ExecutionActionFailureScopeOption =\n  | { scope: ExecutionFailedActionScope.CUSTOM }\n  | { scope: ExecutionFailedActionScope.EMBEDDED_CONTENT }\n  | { scope: ExecutionFailedActionScope.LOCAL_PANE; paneId: string };\n\nexport type ExecutionActionTarget = ExecutionResourceOperationTarget & {\n  contextParticipationRefs?: string[];\n  navigationInitiator?: Omit<NavigationInitiatorContext, 'sourceZone'>;\n  relationshipTransition?: Parameters<ExecutionNavigationValue['delegateToParent']>[0]['relationshipTransition'];\n  /**\n   * Optional predicate used by `status.dirtyMarkers` / `status.isDirty` /\n   * `clearMyDirty()` to correlate this action with subtree dirty markers.\n   *\n   * Dirty markers do not carry an `operationPathKey` — they are subtree-\n   * scoped publisher state (\"this embed slot has unsaved edits\"), not\n   * action-invocation state. Per-action dirty correlation is therefore\n   * **opt-in**: pass a predicate that knows how this action's downstream\n   * subtree publishes dirty state (e.g. matching the bridge marker id\n   * `rmm:${resourceType}:${resourceId}` or scoping to a specific paneId).\n   *\n   * When omitted (the default), `status.dirtyMarkers` is empty,\n   * `status.isDirty` is `false`, and `clearMyDirty()` is a no-op. Loading\n   * and error correlation, by contrast, are automatic via `operationPathKey`\n   * because both registries already carry that key.\n   */\n  dirtyPredicate?: (marker: ExecutionDirtyMarker) => boolean;\n  /**\n   * Optional per-action failure-scope override consumed by the shell's\n   * `execute()` catch path — see `ExecutionActionFailureScopeOption` for\n   * the full contract (CUSTOM default, LOCAL_PANE/EMBEDDED_CONTENT opt-in\n   * for auto-prune integration).\n   */\n  failureScope?: ExecutionActionFailureScopeOption;\n};\n\n/** @wildo_source:part:start saas.frontend.execution-view.action-status-contract facet:kind:contract facet:audience:framework-author */\n/**\n * Per-action snapshot of the three shell-owned aggregator tiers\n * (loading / errors / dirty) narrowed to a single resolved action.\n *\n * Anchored at `saas.frontend.execution-view.action-status-contract` in\n * `useExecution.ts`. Lets renderers ask \"is *this button* in flight, has\n * it failed, is its subtree dirty?\" without hand-rolling predicates against\n * `execution.loading` / `execution.errors` / `execution.dirty` at every\n * call site.\n *\n * **Correlation contract**:\n *\n * - `pendingActions` / `failedActions` filter by the action's\n *   `operationPathKey` — same key the registries already carry, no new\n *   plumbing. Two actions targeting the same `(resourceType,\n *   operationIdentifier)` share the same key and therefore share status;\n *   this matches the framework's \"operation identity\" semantics.\n * - `dirtyMarkers` filter by the target's optional `dirtyPredicate`. When\n *   no predicate is provided the array is empty and `isDirty` is `false` —\n *   the contract is honest about the fact that dirty state is subtree-\n *   scoped and can't be auto-correlated to an action without consumer help.\n *\n * **Reactivity**: `status` is a **lazy getter** on the resolved action.\n * Each access reads the latest committed `runtimeState` via an internal\n * ref (cached per-`runtimeState`-identity so repeated reads in the same\n * render commit return the same object). The enclosing `actions` value\n * identity is **stable** across `runtimeState` mutations — only the\n * structural deps (navigation, participations, viewDefinition, registry)\n * influence its identity. This is deliberate: making `actions` flip on\n * every `setPendingActions` / `setFailedActions` / `setDirtyMarkers`\n * commit would cause downstream `useEffect([...ops])` patterns (the\n * canonical multi-action workflow shape, see `TodoListFlowExecutionView`)\n * to re-fire on the very state mutation they caused — an infinite loop\n * (mirrors the trap Slice F dodged by depending on the stable\n * `navigation` ref instead of the whole `executionContext` value; see G11\n * regression test).\n *\n * Re-render propagation still works because the public aggregator tiers\n * (`loading` / `dirty` / `errors`) DO list their respective `runtimeState`\n * sub-keys in their `useMemo` deps, and the top-level `ExecutionValue`\n * lists all three; so a mutation flips `useExecution()`'s return value\n * identity, the consumer re-renders, and re-reads `action.status` — at\n * which point the cache invalidates against the newly-committed\n * `runtimeState` reference and recomputes once.\n */\nexport interface ExecutionOperationActionStatus {\n  /** Pending actions whose `operationPathKey` matches this resolved action. */\n  pendingActions: readonly ExecutionPendingAction[];\n  /** Failed actions whose `operationPathKey` matches this resolved action. */\n  failedActions: readonly ExecutionFailedAction[];\n  /**\n   * Dirty markers matching the target's `dirtyPredicate`. Empty when no\n   * predicate was provided — see the `dirtyPredicate` JSDoc on\n   * `ExecutionActionTarget` for why dirty correlation is opt-in.\n   */\n  dirtyMarkers: readonly ExecutionDirtyMarker[];\n  /**\n   * `pendingActions.length > 0`.\n   *\n   * **Execute-action tier only.** This flag is *not* an aggregator across\n   * the loading tiers — participation prefetches (Slice H) intentionally\n   * do not flow into per-action status because prefetches do not carry an\n   * `operationPathKey` correlation key. For \"is anything in flight that\n   * touches this action's participation?\", consumers compose\n   * `status.isPending || execution.loading.isParticipationPrefetching((p)\n   * => p.participationRefs.includes(target.participationRef))` explicitly\n   * — the framework refuses to guess the cross-tier mapping.\n   */\n  isPending: boolean;\n  /** `failedActions.length > 0`. */\n  isErrored: boolean;\n  /** `dirtyMarkers.length > 0`. Always `false` without a `dirtyPredicate`. */\n  isDirty: boolean;\n  /**\n   * Most recently captured failure (largest `capturedAt`). Encapsulates\n   * the manual `failedActions.reduce(...)` pattern repeated in every\n   * inline-error UX. `undefined` when no captured failure matches.\n   */\n  latestFailure: ExecutionFailedAction | undefined;\n}\n\n/**\n * A single action verb-bundle resolved from an `ExecutionActionTarget`.\n *\n * Exposes four mutually-exclusive-intent verbs and three cross-tier\n * sugar methods:\n *\n * - `execute` — run the underlying resource operation through `doOperation()`\n *   without mounting any surface. Used for mutations or orchestration.\n * - `embed` — mount the target resource-operation surface inside the\n *   execution shell's embedded-content slot (the \"embed\" seam).\n * - `navigate` — delegate to the router, unless the view's navigation policy\n *   resolves this operation to `EMBED_LOCALLY`, in which case it embeds.\n *   This is the \"respect the authored policy\" verb.\n * - `navigateToRead` — sugar for `navigate()` targeting the addressable READ\n *   operation of the same resource; returns false if the READ is not\n *   addressable.\n *\n * Cross-tier sugar (Slice G):\n *\n * - `retry(requestData?)` — clear failures matching this action's\n *   `operationPathKey`, then re-execute. Equivalent to `clearMyFailures();\n *   await execute(requestData);` but conveys retry intent.\n * - `clearMyFailures()` — clear failures matching this action's\n *   `operationPathKey` without re-executing. Use for \"Dismiss\" UX next to\n *   a per-button error banner.\n * - `clearMyDirty()` — clear dirty markers matching the target's\n *   `dirtyPredicate`. No-op when no predicate was provided (the dirty-\n *   correlation contract is opt-in; see `ExecutionActionTarget.dirtyPredicate`).\n *\n * The aggregator-tier predicates from `execution.loading.isPending(...)` /\n * `execution.errors.isErrored(...)` / `execution.dirty.isDirty(...)` remain\n * the right tool for *cross-action* questions (\"is anything in flight?\",\n * \"is anything dirty in the embed slot?\"). `status` and the sugar methods\n * are for *per-action* questions.\n */\nexport interface ExecutionOperationAction {\n  target: ExecutionActionTarget;\n  resourceContext: FrontendResourceOperationContext;\n  resourceType: string;\n  operation: FrontendResourceConfiguration_Operation;\n  operationId: string;\n  /**\n   * Canonical `operationPathKey` the shell will pass to `doOperation()`\n   * for this action. Stable across re-renders for the same resolved\n   * `(resourceType, operationIdentifier)` and used as the correlation key\n   * for `status.pendingActions` / `status.failedActions` / `clearMyFailures()`\n   * / `retry()`. Surfaced so consumers can write custom predicates against\n   * the top-level aggregators (`execution.loading.isPending((p) =>\n   * p.operationPathKey === action.operationPathKey)`).\n   */\n  operationPathKey: string;\n  contextualParameters: Record<string, string | number>;\n  navigationHandlingMode: ExecutionNavigationHandlingMode;\n  /** Per-action snapshot of loading/errors/dirty — see `ExecutionOperationActionStatus`. */\n  status: ExecutionOperationActionStatus;\n  execute: (requestData?: Record<string, unknown>) => Promise<unknown>;\n  embed: () => boolean;\n  navigate: () => boolean;\n  navigateToRead: () => boolean;\n  /**\n   * Clear failures matching this action's `operationPathKey` (read live at\n   * call time, not from a build-time snapshot), then re-execute.\n   */\n  retry: (requestData?: Record<string, unknown>) => Promise<unknown>;\n  /**\n   * Clear all currently-registered failures matching this action's\n   * `operationPathKey`. Reads the live `failedActions` registry at call\n   * time, so a memoized action object cleanly clears entries that landed\n   * after it was built. No-op when no failures match.\n   */\n  clearMyFailures: () => void;\n  /**\n   * Clear dirty markers matching the target's `dirtyPredicate`, read live\n   * from the dirty-markers registry at call time. No-op when no predicate\n   * was provided (opt-in correlation contract — see\n   * `ExecutionActionTarget.dirtyPredicate`).\n   */\n  clearMyDirty: () => void;\n}\n/** @wildo_source:part:end saas.frontend.execution-view.action-status-contract */\n\n/**\n * @wildo_source:part:start saas.frontend.execution-view.action-status-contract.per-action-retry-loop facet:layer:frontend facet:family:execution-view\n *\n * Slice J refinement — the per-action retry loop UX pattern enabled by the\n * Slice G `status.latestFailure` selector + `retry()` / `clearMyFailures()`\n * sugar (parent contract: `saas.frontend.execution-view.action-status-contract`).\n *\n * **The pattern (single-action mutation surface):**\n *\n * ```tsx\n * const action = execution.actions.operation({\n *   resourceType: 'todos',\n *   resourceId,\n *   operationLike: CoreResourceOperation.DELETE,\n *   failureScope: { scope: ExecutionFailedActionScope.LOCAL_PANE, paneId },\n * });\n *\n * return (\n *   <>\n *     <Button\n *       disabled={action.status.isPending}\n *       onClick={() => { void action.execute(); }}\n *     >\n *       {action.status.isPending ? 'Deleting…' : 'Delete'}\n *     </Button>\n *     {action.status.latestFailure && (\n *       <Banner>\n *         {action.status.latestFailure.error.message}\n *         <Button onClick={() => { void action.retry(); }}>Retry</Button>\n *         <Button onClick={() => { action.clearMyFailures(); }}>Dismiss</Button>\n *       </Banner>\n *     )}\n *   </>\n * );\n * ```\n *\n * The whole retry loop closes inside one `ExecutionOperationAction` value:\n *\n * 1. **Fail path.** `execute()` rejects → the shell appends a captured entry\n *    to `failedActions` keyed by a fresh `failureRuntimeId`. On the next\n *    render `action.status.latestFailure` flips from `undefined` to the new\n *    entry (max-by-`capturedAt` over the operationPathKey-matched subset),\n *    `status.isErrored` is `true`, and the banner mounts.\n *\n * 2. **Retry path.** `retry()` runs `clearMyFailures()` first (subscribers\n *    reading `execution.errors` during the new `execute()` see a clean\n *    slate) then re-invokes `execute()` with the same `requestData`. A\n *    second rejection appends a fresh entry with a NEW `failureRuntimeId`\n *    — the contract guarantees re-attempts produce fresh entries rather\n *    than mutating the prior one (failure-handling-contract invariant #5).\n *    `latestFailure` therefore rotates id even when the error message is\n *    byte-identical, which lets a `useEffect([action.status.latestFailure\n *    ?.failureRuntimeId])` trigger toast/log side effects on every fresh\n *    failure rather than just on first appearance.\n *\n * 3. **Success path.** Successful `execute()` rejection-free completion\n *    leaves the (already-cleared) operationPathKey-matched subset empty;\n *    `latestFailure` settles to `undefined`, `isErrored` flips to `false`,\n *    the banner unmounts. No explicit clear-on-success is required because\n *    `retry()` already cleared the prior entries before re-executing.\n *\n * **Per-action vs. cross-action separation (load-bearing).** Use this\n * pattern only when one button = one operation = one banner. Multi-action\n * workflows (e.g. a 4-op data-hydration pipeline that surfaces a single\n * shared failure banner) MUST keep using the global aggregator\n * (`execution.errors.failedActions.reduce(...)` + manual\n * `clearGraphLoadFailures()` + workflow-level retry) — `retry()` is single-\n * action by design and forcing it onto a multi-op workflow would either\n * misattribute the retry to one op or require the consumer to call\n * `op1.retry(); op2.retry(); …` which loses the workflow's ordering. The\n * existing `clearMyFailures()` per-op sugar is still the right tool for\n * scoping the cleanup of multi-op workflows; only `retry()` itself stays\n * single-action.\n *\n * **`failureScope` opt-in (Slice J shell extension).** The shell's\n * `execute()` catch path defaults to `ExecutionFailedActionScope.CUSTOM`\n * (failures persist across pane / embed transitions until manually\n * cleared). Single-action mutation surfaces that live inside a pane should\n * set `failureScope: { scope: LOCAL_PANE, paneId }` on the target so the\n * shell's existing prune helpers (`pruneFailedActionsForPaneTransition`,\n * already wired to `closeLocalPane()` and `openLocalPane(newPaneId, ...)`\n * in `ExecutionView`) drop the captured entry on pane swap/close — the\n * inspector closes, the failure goes with it, the consumer authors zero\n * cleanup. Same shape opt-in exists for `EMBEDDED_CONTENT`-scoped\n * surfaces. The opt-in is per-target (settable on dictionary entries OR\n * per-call via `bind({ failureScope: … })` since `paneId` is per-call\n * fresh under the `paneId-fresh-per-open` policy from\n * `dirty-bridge-contract.local-pane`).\n *\n * **Identity invariant.** `action.status` is a lazy getter cached against\n * the live `runtimeState` reference (see the runtimeStateRef comment at\n * the top of `useExecution`); reads are stable inside one render commit\n * and recompute exactly once per commit. The enclosing `actions` value\n * identity does NOT flip on every `setFailedActions` commit, which is\n * what lets the canonical `useEffect([...ops])` workflow pattern\n * (`TodoListFlowExecutionView`'s `loadGraphResources()` shape) coexist\n * with per-action banners that re-render against the new failure entry.\n *\n * **Two-step destructive-confirm UX is consumer-owned.** The shell does\n * not grow modal/inline-confirm primitives (same rule as the dirty-state\n * confirm-on-close UX from `dirty-bridge-contract.local-pane`). Consumers\n * that need a destructive confirm before firing `execute()` author it\n * locally (state machine: `idle → confirm-pending(N seconds) → fire OR\n * revert`); the action verbs only run once the consumer commits.\n *\n * @wildo_source:part:end saas.frontend.execution-view.action-status-contract.per-action-retry-loop\n */\n\n/**\n * Runtime overrides passed when invoking a prepared dictionary entry.\n *\n * These are the pieces that vary per call site — a specific resource id, extra\n * context identifiers for a scoped list, or request data for a mutation.\n * Everything else (resourceType, operationLike, contextParticipationRefs, …)\n * was already baked in when the dictionary was declared.\n */\nexport type ExecutionActionRuntimeOverrides = Partial<Pick<\n  ExecutionActionTarget,\n  | 'resourceType'\n  | 'resourceId'\n  | 'contextResourceIdentifiers'\n  | 'additionalContext'\n  | 'navigationInitiator'\n  | 'relationshipTransition'\n  // `failureScope` is overridable per-call (Slice J): inspector-style\n  // surfaces hold a per-open paneId (`paneId-fresh-per-open` policy)\n  // that the dictionary `useMemo` cannot know about at declaration\n  // time. Allowing the override here lets a single dictionary entry\n  // serve every inspector instance while each per-call `bind({\n  // failureScope: { scope: LOCAL_PANE, paneId } })` keeps its captured\n  // failures correctly auto-pruned.\n  | 'failureScope'\n>>;\n\nexport interface ExecutionPreparedAction {\n  execute: (overrides?: ExecutionActionRuntimeOverrides, requestData?: Record<string, unknown>) => Promise<unknown>;\n  embed: (overrides?: ExecutionActionRuntimeOverrides) => boolean;\n  navigate: (overrides?: ExecutionActionRuntimeOverrides) => boolean;\n  navigateToRead: (overrides?: ExecutionActionRuntimeOverrides) => boolean;\n  /**\n   * Resolve the prepared action with optional runtime overrides into a full\n   * `ExecutionOperationAction` (target, resourceContext, status, verbs,\n   * cross-tier sugar). Use this when a single call site needs more than one\n   * verb against the same merged target — the work of resolving the target\n   * and building the resource context happens once instead of per-verb-call,\n   * and the resulting action object exposes `status` for per-action loading\n   * / errors / dirty queries.\n   *\n   * Equivalent to `actions.operation(mergedTarget)` where `mergedTarget` is\n   * the dictionary entry's base target merged with the overrides — same\n   * merge semantics as `execute(overrides, ...)`, `embed(overrides)`, etc.\n   */\n  bind: (overrides?: ExecutionActionRuntimeOverrides) => ExecutionOperationAction;\n}\n\nexport type ExecutionActionDictionary<TKeys extends string> = {\n  [K in TKeys]: ExecutionPreparedAction;\n};\n\nexport interface ExecutionActionsValue {\n  operation: (target: ExecutionActionTarget) => ExecutionOperationAction;\n  dictionary: <TDict extends Record<string, ExecutionActionTarget>>(\n    definitions: TDict,\n  ) => ExecutionActionDictionary<Extract<keyof TDict, string>>;\n}\n\n/**\n * Renderer-facing aggregate of shell-owned loading state.\n *\n * Anchored at `saas.frontend.execution-view.loading-aggregation` in\n * `ExecutionRuntimeContext.tsx`. Two tiers are wired today:\n *\n * 1. **Pending execute actions** — every `useExecution().actions.operation(...)\n *    .execute()` call. Populated by the shell's `doOperation()` bridge.\n * 2. **Participation prefetch entries** (Slice H) — in-flight async\n *    hydration of one or more execution participations. Populated via the\n *    `beginParticipationPrefetch` / `endParticipationPrefetch` helpers on\n *    `ExecutionNavigationValue`. **No in-tree producer registers entries\n *    today** because participation resolution is fully synchronous; the\n *    tier is wired now so future async participation sources don't need\n *    to re-shape the public surface. See the\n *    `loading-aggregation.participation-prefetch` sub-anchor for the\n *    full contract (intent classification, settle-always-clears,\n *    non-empty `participationRefs`, …).\n *\n * Embedded-layout internal loading and consumer-pushed phases stay\n * intentionally out of scope — see the parent anchor for the full\n * ownership contract.\n *\n * - `pendingActions` — stable snapshot of in-flight execute-action entries.\n * - `participationPrefetchActions` — stable snapshot of in-flight\n *   participation prefetch entries (empty array today; populated when a\n *   future producer materializes).\n * - `isBusy` — convenience aggregating **all** wired tiers:\n *   `pendingActions.length > 0 || participationPrefetchActions.length > 0`.\n *   Kept as the renderer-friendly \"anything in flight?\" label so it stays\n *   honest as new tiers ship; per-tier narrowing uses\n *   `isPending(...)` / `isParticipationPrefetching(...)` explicitly.\n * - `isAnyPending` — convenience: `pendingActions.length > 0`. Tier-scoped\n *   to execute actions only. Symmetric with `isAnyParticipationPrefetching`\n *   so the two loading tiers expose the same \"is anything in this tier in\n *   flight?\" boolean shape — uniform per-tier composition is the framework\n *   mindset rule, even if pre-Slice-H consumers reached for `isBusy` for\n *   the same answer (back when the two were equivalent). Use `isBusy` for\n *   \"any tier in flight?\", `isAnyPending` for \"any execute action in\n *   flight?\".\n * - `isPending(predicate?)` — query helper for per-button UX over\n *   pending **execute** actions only. Without a predicate, equivalent to\n *   `isAnyPending` (NOT `isBusy` — `isPending` is tier-scoped to execute\n *   actions). With a predicate (typically narrowing by `operationId`,\n *   `resourceType`, or `actionRuntimeId`), returns whether any tracked\n *   execute-action matches. The verb mirrors `dirty.isDirty(predicate?)`\n *   and `errors.isErrored(predicate?)` so the three shell-owned aggregator\n *   tiers expose the same predicate shape.\n * - `isAnyParticipationPrefetching` — convenience:\n *   `participationPrefetchActions.length > 0`. Symmetric with `isAnyPending`.\n * - `isParticipationPrefetching(predicate?)` — tier-scoped query helper\n *   for the prefetch tier. Without a predicate, equivalent to\n *   `isAnyParticipationPrefetching`. With a predicate (typically narrowing\n *   by `participationRefs.includes(ref)`, `resourceType`, or `intent ===\n *   REFRESH`), returns whether any tracked prefetch matches. Symmetric\n *   with `isPending` so per-tier UX composes uniformly across both\n *   loading tiers.\n */\nexport interface ExecutionLoadingValue {\n  pendingActions: readonly ExecutionPendingAction[];\n  participationPrefetchActions: readonly ExecutionPendingPrefetch[];\n  isBusy: boolean;\n  isAnyPending: boolean;\n  isPending: (predicate?: (action: ExecutionPendingAction) => boolean) => boolean;\n  isAnyParticipationPrefetching: boolean;\n  isParticipationPrefetching: (predicate?: (prefetch: ExecutionPendingPrefetch) => boolean) => boolean;\n}\n\n/**\n * Public dirty-state surface exposed on `useExecution().dirty`.\n *\n * Anchored at `saas.frontend.execution-view.dirty-state-contract` in\n * `ExecutionRuntimeContext.tsx`. The shell aggregates authored dirty\n * markers so any renderer can query a single truthful signal before\n * kicking zone transitions (close the embed, replace the embed, switch\n * panes, delegate to the router). The shell is informative only — it does\n * *not* block transitions. Consumers author their own confirm UX.\n *\n * - `markers` — stable snapshot of currently-registered dirty markers.\n * - `isAnyDirty` — convenience: `markers.length > 0`.\n * - `isDirty(predicate?)` — query helper. Without a predicate, equivalent\n *   to `isAnyDirty`; with a predicate (typically narrowing by `scope` or\n *   `paneId`), returns whether any registered marker matches.\n * - `mark(marker)` — register/replace a marker (idempotent on `markerId`).\n *   Publishers are whoever owns the unsaved state — a zone-B custom pane\n *   with editable fields, or an adapter wrapping an RMM-backed zone-A\n *   surface. See the contract anchor for lifecycle rules.\n * - `clear(markerId)` — remove a marker. No-op if the id is unknown.\n * - `clearAll()` — drop every registered marker. Mirrors `errors.clearAll()`\n *   so the two consumer-authored aggregator tiers expose the same bulk-clear\n *   primitive (typical \"Discard all unsaved edits\" UX).\n */\nexport interface ExecutionDirtyValue {\n  markers: readonly ExecutionDirtyMarker[];\n  isAnyDirty: boolean;\n  isDirty: (predicate?: (marker: ExecutionDirtyMarker) => boolean) => boolean;\n  mark: (marker: ExecutionDirtyMarker) => void;\n  clear: (markerId: string) => void;\n  clearAll: () => void;\n}\n\n/**\n * Input shape for `execution.errors.capture(...)`.\n *\n * Used by consumers that observe a failure outside the shell's `execute()`\n * bridge — e.g. wrapping an embedded layout's `onError`, catching a render-\n * adjacent throw, surfacing a backend WS error correlated to a UI surface —\n * and want it tracked in the same `execution.errors` aggregator the shell\n * populates from `execute()` rejections.\n *\n * `bridgeToCanonicalBus` defaults to `true` and matches the shell's own\n * detection logic: if `error.wildoError` is already attached (HTTP-layer\n * pre-bridge), the bridge call is skipped automatically. Set to `false` only\n * when the consumer has *already* emitted an explicit canonical error event\n * and wants to avoid the second hop.\n *\n * The discriminated union over `scope` enforces \"`paneId` is required for\n * `LOCAL_PANE` captures\" and \"`prefetchKey` is required for\n * `PARTICIPATION_PREFETCH` captures\" at compile time — consumers cannot\n * accidentally register a pane-scoped or prefetch-scoped failure that\n * escapes its respective auto-cleanup invariant. The\n * `PARTICIPATION_PREFETCH` arm is the consumer-facing seam for the\n * Slice K hooks (`useExecutionParticipationPrefetch` /\n * `useExecutionParticipationDataPrefetch`); see the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the full producer contract.\n */\ntype ExecutionErrorCaptureInputBase = {\n  error: unknown;\n  label?: string;\n  resourceType?: string;\n  operationId?: string;\n  operationPathKey?: string;\n  bridgeToCanonicalBus?: boolean;\n};\n\nexport type ExecutionErrorCaptureInput =\n  | (ExecutionErrorCaptureInputBase & { scope?: ExecutionFailedActionScope.CUSTOM })\n  | (ExecutionErrorCaptureInputBase & { scope: ExecutionFailedActionScope.EMBEDDED_CONTENT })\n  | (ExecutionErrorCaptureInputBase & {\n      scope: ExecutionFailedActionScope.LOCAL_PANE;\n      paneId: string;\n    })\n  | (ExecutionErrorCaptureInputBase & {\n      scope: ExecutionFailedActionScope.PARTICIPATION_PREFETCH;\n      /**\n       * Stable consumer-authored identity for the prefetch unit. The\n       * shell's `clearFailedActionsForPrefetchKey(key)` verb (Slice K)\n       * auto-clears every captured entry sharing this key on the next\n       * successful prefetch settle for the same key — so a stale\n       * banner from a previous failed attempt vanishes the moment the\n       * next attempt succeeds, no consumer cleanup required. Producer\n       * hooks (`useExecutionParticipationPrefetch` /\n       * `useExecutionParticipationDataPrefetch`) thread the same key\n       * they registered with the prefetch tier.\n       */\n      prefetchKey: string;\n    });\n\n/**\n * Public failure-handling surface exposed on `useExecution().errors`.\n *\n * Anchored at `saas.frontend.execution-view.failure-handling-contract` in\n * `ExecutionRuntimeContext.tsx`. The shell aggregates captured failures so\n * any renderer can drive inline retry UX without rebuilding ad hoc per-\n * component error state, and bridges non-HTTP rejections to the canonical\n * `ERROR_OCCURED` bus exactly once. The shell never retries on its own —\n * consumer owns the call site (callback-based retry).\n *\n * - `failedActions` — stable snapshot of captured failure entries. Named to\n *   match the underlying `ExecutionFailedAction` type and to mirror\n *   `loading.pendingActions` so the three shell-owned aggregator tiers\n *   (loading / dirty / errors) read with the same plural-of-the-type\n *   naming convention.\n * - `isAnyErrored` — convenience: `failedActions.length > 0`.\n * - `isErrored(predicate?)` — query helper. Without a predicate, equivalent\n *   to `isAnyErrored`; with a predicate (typically narrowing by\n *   `resourceType`, `operationId`, `scope`, or `paneId`), returns whether\n *   any captured entry matches.\n * - `capture(input)` — capture a consumer-authored failure into the\n *   aggregator. Returns the persisted `ExecutionFailedAction` so the caller\n *   can correlate it with subsequent `clear()` calls.\n * - `clear(failureRuntimeId)` — drop a single entry. No-op if unknown.\n * - `clearAll()` — drop every entry. Typical \"user clicked Retry\" flow:\n *   `errors.clearAll(); await retryAction();`\n */\nexport interface ExecutionErrorsValue {\n  failedActions: readonly ExecutionFailedAction[];\n  isAnyErrored: boolean;\n  isErrored: (predicate?: (entry: ExecutionFailedAction) => boolean) => boolean;\n  capture: (input: ExecutionErrorCaptureInput) => ExecutionFailedAction;\n  clear: (failureRuntimeId: string) => void;\n  clearAll: () => void;\n}\n\n/**\n * Direct control surface for the execution shell's embedded-content slot.\n *\n * This is the low-level bridge; most consumers should prefer the\n * `execution.actions.operation(...).embed()` action verb, which builds the\n * full `ExecutionEmbeddableContent` from a resource-operation target. Use\n * this only when you already hold an\n * `ExecutionEmbeddedContentState` (rare) or need to close the slot directly.\n */\nexport interface ExecutionEmbeddedContentValue {\n  open: ExecutionNavigationValue['openEmbeddedContent'];\n  close: ExecutionNavigationValue['closeEmbeddedContent'];\n  /**\n   * Typed sugar: build an `ExecutionOperationAction` for `target` and embed it.\n   * Equivalent to `execution.actions.operation(target).embed()`.\n   */\n  openResource: (target: ExecutionActionTarget) => boolean;\n}\n\nexport interface ExecutionValue {\n  view: ExecutionViewDefinition;\n  anchor: ExecutionAnchor | null;\n  state: ExecutionRuntimeState;\n  contextResourceIdentifiers?: Record<string, string>;\n  runtimeInstanceId: string;\n  navigationZone: NavigationZone;\n  doOperation: ResourceRegistryContextType['doOperation'];\n  delegateToParent: ExecutionNavigationValue['delegateToParent'];\n  localPane: {\n    open: ExecutionNavigationValue['openLocalPane'];\n    close: ExecutionNavigationValue['closeLocalPane'];\n  };\n  embeddedContent: ExecutionEmbeddedContentValue;\n  loading: ExecutionLoadingValue;\n  dirty: ExecutionDirtyValue;\n  errors: ExecutionErrorsValue;\n  participations: Record<string, ExecutionParticipationHandle>;\n  participation: (ref: string) => ExecutionParticipationHandle | undefined;\n  requireParticipation: (ref: string) => ExecutionParticipationHandle;\n  subjects: ExecutionSubjectsValue;\n  buildContextualParameters: (participationRefs: string[]) => Record<string, string | number>;\n  buildResourceOperationContext: ExecutionResourceOperationContextBuilderValue['buildResourceOperationContext'];\n  actions: ExecutionActionsValue;\n}\n\n/**\n * Single public execution renderer hook.\n *\n * This is the one business-facing entry point custom execution renderers should\n * consume. It exposes the mounted execution runtime plus the common derived\n * helpers renderers actually need, so app code does not have to compose a dozen\n * tiny selector hooks just to understand one execution surface.\n *\n * Internal low-level seams can still exist where React hook composition truly\n * requires them, but they are implementation details rather than the public\n * renderer API.\n */\nexport function useExecution(): ExecutionValue {\n  const executionRuntime = assertExecutionRuntimeContext(useContext(ExecutionRuntimeContext));\n  const { registry } = useResourceRegistry();\n  const { buildResourceOperationContext } = useExecutionResourceOperationContextBuilder();\n\n  // Canonical outcome-emission bridge: wire `.execute()` into the app\n  // EventBus as a `RESOURCE_OPERATION_EXECUTED` / `RESOURCE_REFRESH` producer.\n  // Anchored at `saas.frontend.execution-view.outcome-emission-contract` in\n  // `ExecutionRuntimeContext.tsx`. Refs keep the closure capture stable so\n  // `buildExecutionOperationAction`'s `useCallback` does not re-memo on every\n  // WS-flip or bus-identity change.\n  const { emit } = useEventBus();\n  const webSocket = useContext(WebSocketContext);\n  const isWebSocketConnected = webSocket?.isConnected ?? false;\n  const emitRef = useRef(emit);\n  const isWebSocketConnectedRef = useRef(isWebSocketConnected);\n  emitRef.current = emit;\n  isWebSocketConnectedRef.current = isWebSocketConnected;\n\n  // Slice G — reactive-but-stable trick. The per-action `status` snapshot\n  // (and the `clearMyFailures` / `clearMyDirty` sugar) must always read the\n  // *latest* `runtimeState`, but we **must not** include `runtimeState` in\n  // any `useCallback`/`useMemo` deps that the public `actions` value\n  // depends on — doing so would flip `actions` identity on every\n  // `setPendingActions` / `setFailedActions` / `setDirtyMarkers` commit,\n  // and any downstream consumer wrapping `loadXxx` in a\n  // `useEffect([...ops])` (the canonical multi-action workflow pattern,\n  // see `TodoListFlowExecutionView`) would re-fire on the very state\n  // mutation it caused — an infinite loop. Same shape of trap that Slice F\n  // dodged by depending on the stable `navigation` ref instead of the\n  // whole `executionContext` value (see G11 regression test). The ref is\n  // updated on every render so reads from inside the action see the\n  // freshly-committed state, while the `useCallback` identity for\n  // `buildExecutionOperationAction` stays pinned to the structural deps\n  // (navigation, participations, viewDefinition, registry — all stable\n  // across action invocations).\n  const runtimeStateRef = useRef(executionRuntime.runtimeState);\n  runtimeStateRef.current = executionRuntime.runtimeState;\n\n  const participations = useMemo<Record<string, ExecutionParticipationHandle>>(() => (\n    Object.fromEntries(\n      Object.entries(executionRuntime.participations).map(([ref, participation]) => [\n        ref,\n        buildExecutionParticipationHandle({\n          participation,\n          registry,\n        }),\n      ]),\n    )\n  ), [executionRuntime.participations, registry]);\n\n  const participation = useCallback((ref: string): ExecutionParticipationHandle | undefined => (\n    participations[ref]\n  ), [participations]);\n\n  const requireParticipation = useCallback((ref: string): ExecutionParticipationHandle => {\n    const resolvedParticipation = participations[ref];\n\n    if (!resolvedParticipation) {\n      throw new Error(\n        `Execution participation \"${ref}\" is required by view \"${executionRuntime.viewDefinition.ref}\" but was not resolved.`,\n      );\n    }\n\n    return resolvedParticipation;\n  }, [executionRuntime.viewDefinition.ref, participations]);\n\n  const requireParticipations = useCallback(<TRefs extends readonly string[]>(\n    refs: TRefs,\n  ): ExecutionParticipationRecord<TRefs> => {\n    return Object.fromEntries(\n      refs.map((ref) => [ref, requireParticipation(ref)]),\n    ) as ExecutionParticipationRecord<TRefs>;\n  }, [requireParticipation]);\n\n  const subjectsRequire = useCallback(<TRefs extends readonly string[]>(\n    refOrRefs: string | TRefs,\n  ): ExecutionParticipationHandle | ExecutionParticipationRecord<TRefs> => {\n    if (Array.isArray(refOrRefs)) {\n      return requireParticipations(refOrRefs);\n    }\n\n    return requireParticipation(refOrRefs as string);\n  }, [requireParticipation, requireParticipations]);\n\n  const buildContextualParameters = useCallback((\n    participationRefs: string[],\n  ): Record<string, string | number> => {\n    if (participationRefs.length === 0) {\n      return {};\n    }\n\n    return buildExecutionParticipationContextualParameters({\n      participationRefs,\n      participations: executionRuntime.participations,\n      registry,\n    });\n  }, [executionRuntime.participations, registry]);\n\n  const buildExecutionOperationAction = useCallback<ExecutionActionsValue['operation']>((target) => {\n    const derivedContextResourceIdentifiers = (target.contextParticipationRefs ?? []).reduce<FrontendResourceOperationContext['contextResourceIdentifiers']>((acc, ref) => {\n        const participation = executionRuntime.participations[ref];\n        if (!participation) {\n          throw new Error(\n            `Execution action target references unknown context participation \"${ref}\" on view \"${executionRuntime.viewDefinition.ref}\".`,\n          );\n        }\n\n        const contextIdentifier = buildExecutionParticipationContextIdentifier({\n          participation,\n          registry,\n        });\n        if (!contextIdentifier) {\n          return acc;\n        }\n\n        // Canonical `contextResourceIdentifiers` shape (see\n        // `FrontendResourceUtils.buildContextualParameters`) is `ResourceType → id`.\n        // Keying by the FK-alias field identifier would shadow downstream\n        // addressability lookups, which read `contextResourceIdentifiers[resourceType]`.\n        // The FK-alias survives inside the value's `fieldIdentifier` slot, so\n        // `buildContextualParameters` still emits FK-keyed entries.\n        const contextKey = getExecutionParticipationResourceType(participation);\n        const existingContextIdentifier = acc[contextKey];\n        if (existingContextIdentifier) {\n          const existingResourceId = frontendResourceUtils.getResourceId(existingContextIdentifier);\n          const nextResourceId = frontendResourceUtils.getResourceId(contextIdentifier);\n          const existingFieldIdentifier = frontendResourceUtils.getFieldIdentifier(existingContextIdentifier);\n          const nextFieldIdentifier = frontendResourceUtils.getFieldIdentifier(contextIdentifier);\n\n          if (\n            existingResourceId !== nextResourceId\n            || existingFieldIdentifier !== nextFieldIdentifier\n          ) {\n            throw FrontendResourceUtils.buildConfigurationError(\n              ErrorCustomMessageReference.CONFIGURATION,\n              {\n                component: 'useExecution.actions.operation',\n                message: `Execution action target resolved conflicting context participations for \"${contextKey}\".`,\n                contextKey,\n                existingContextIdentifier,\n                nextContextIdentifier: contextIdentifier,\n                participationRef: ref,\n                executionViewRef: executionRuntime.viewDefinition.ref,\n              },\n            );\n          }\n        }\n\n        acc[contextKey] = contextIdentifier;\n        return acc;\n      }, {});\n    const resolvedTarget: ExecutionResourceOperationTarget = {\n      ...target,\n      contextResourceIdentifiers: {\n        ...derivedContextResourceIdentifiers,\n        ...(target.contextResourceIdentifiers ?? {}),\n      },\n    };\n    const resourceContext = buildResourceOperationContext(resolvedTarget);\n    const { resourceType, operation } = resourceContext;\n    const operationId = String(operation.operationIdentifier);\n    const resourceConfig = registry.resourceConfigurations[resourceType];\n    const contextualParameters = FrontendResourceUtils.buildContextualParameters(\n      resourceContext.contextResourceIdentifiers,\n      registry,\n    );\n    const navigationHandlingMode = resolveExecutionNavigationHandlingMode({\n      viewDefinition: executionRuntime.viewDefinition,\n      resourceType,\n      operation,\n    });\n    const defaultNavigationInitiator = NavigationUtils.createOperationInitiator(\n      executionRuntime.navigationZone,\n      operationId,\n    );\n    const mergedNavigationInitiator: NavigationInitiatorContext = {\n      ...defaultNavigationInitiator,\n      ...(target.navigationInitiator ?? {}),\n    };\n\n    const embeddableContent: ExecutionEmbeddableContent = {\n      contentType: NavigationContentType.RESOURCE_OPERATION,\n      resourceContext,\n    };\n\n    const embed = (): boolean => {\n      executionRuntime.navigation.openEmbeddedContent({\n        content: embeddableContent,\n        navigationInitiator: mergedNavigationInitiator,\n      });\n      return true;\n    };\n\n    const navigate = (): boolean => {\n      if (navigationHandlingMode === ExecutionNavigationHandlingMode.EMBED_LOCALLY) {\n        return embed();\n      }\n\n      const routePaths = resourceConfig\n        ? ResourcesConfigOperationsUrlsBuilderUtils.buildOperationFrontendRoutePaths(\n            resourceConfig,\n            operation,\n            registry.allResourceFieldIdentifiers,\n          )\n        : [];\n      const urlPath = resourceConfig && routePaths.length > 0\n        ? frontendResourceUtils.selectMatchingRoutePath(\n            routePaths,\n            resourceContext.contextResourceIdentifiers,\n            resourceType,\n            resourceConfig.resourceFieldIdentifier,\n            resourceContext.parentResourcesRequirements,\n          ).url\n        : undefined;\n\n      executionRuntime.navigation.delegateToParent({\n        content: embeddableContent,\n        urlPath,\n        relationshipTransition: target.relationshipTransition,\n        initiator: {\n          ...target.navigationInitiator,\n          sourceOperation: mergedNavigationInitiator.sourceOperation,\n          ...(mergedNavigationInitiator.sourceRelationship\n            ? { sourceRelationship: mergedNavigationInitiator.sourceRelationship }\n            : {}),\n          ...(mergedNavigationInitiator.launcher\n            ? { launcher: mergedNavigationInitiator.launcher }\n            : {}),\n        },\n      });\n\n      return true;\n    };\n\n    // Hoisted so cross-tier sugar (`status`, `clearMyFailures`, `retry`)\n    // and the `execute` closure can share the same correlation key.\n    const operationPathKey = ResourcesConfig_OperationPathUtils.createOperationPathKeyFromOperation(operation);\n\n    const execute = async (requestData?: Record<string, unknown>): Promise<unknown> => {\n      const effectiveRequestData = mergeBulkSelectionIntoRequestData({\n        operation,\n        requestData,\n        additionalContext: resourceContext.additionalContext,\n      });\n\n      const pendingAction: ExecutionPendingAction = {\n        actionRuntimeId: createExecutionActionRuntimeId(),\n        operationPathKey,\n        resourceType,\n        operationId,\n        startedAt: Date.now(),\n      };\n      executionRuntime.navigation.beginPendingAction(pendingAction);\n\n      try {\n        const result = await executionRuntime.doOperation(operationPathKey, {\n          contextualParameters,\n          parentResourcesRequirements: resourceContext.parentResourcesRequirements,\n          ...(effectiveRequestData ? { requestData: effectiveRequestData } : {}),\n        });\n\n        // Canonical outcome emission — see `emitResourceOperationOutcome` for\n        // the contract. Fires before the finally clause clears the pending\n        // entry so `execution.loading.isBusy` is still true at emission time.\n        emitResourceOperationOutcome({\n          emit: emitRef.current,\n          resourceConfig,\n          registry,\n          resourceType,\n          operation,\n          resourceContext,\n          isWebSocketConnected: isWebSocketConnectedRef.current,\n          result,\n        });\n\n        return result;\n      } catch (error) {\n        // Failure-handling contract (Slice E):\n        // 1. Capture the failure into shell-tracked `failedActions` so\n        //    consumer error UX can read it from `execution.errors`.\n        // 2. Bridge to the canonical `ERROR_OCCURED` bus at most once. HTTP\n        //    rejections carry `error.wildoError` (stamped by\n        //    `wildo-http-client.handleHttpError`); when present, the shell\n        //    defers to that upstream processing rather than re-emitting,\n        //    even if the upstream policy decided to stay silent. See the\n        //    failure-handling-contract anchor in `ExecutionRuntimeContext`.\n        // 3. Re-throw the original error so consumer `.catch()` handlers\n        //    still observe it — the shell augments, never swallows.\n        const markedByHttpClient = isErrorMarkedByHttpClient(error);\n        const bridgedByExecutionShell = !markedByHttpClient;\n        if (bridgedByExecutionShell) {\n          errorManagement.handleError(error, {\n            source: 'promise',\n            resourceType,\n            operationIdentifier: operationId,\n            additionalContext: {\n              executionRuntimeInstanceId: executionRuntime.runtimeInstanceId,\n              executionViewRef: executionRuntime.viewDefinition.ref,\n              operationPathKey,\n            },\n          });\n        }\n        // Thread the per-action `failureScope` opt-in (Slice J) into the\n        // capture payload. The base fields are shared across all three\n        // discriminator branches; the scope-specific suffix narrows the\n        // input shape so `buildExecutionFailedAction` can keep its\n        // discriminated-union assertion (`paneId` is required for\n        // `LOCAL_PANE`, forbidden elsewhere) at compile time. When no\n        // `failureScope` is set we fall through to `CUSTOM` exactly as\n        // before — the default contract is preserved bit-for-bit so\n        // pre-Slice-J consumers see no behavior change.\n        const baseFailureInput = {\n          failureRuntimeId: createExecutionFailureRuntimeId(),\n          originatingActionRuntimeId: pendingAction.actionRuntimeId,\n          operationPathKey,\n          resourceType,\n          operationId,\n          startedAt: pendingAction.startedAt,\n          error,\n          markedByHttpClient,\n          bridgedByExecutionShell,\n        };\n        let failureBuildInput: BuildExecutionFailedActionInput;\n        if (target.failureScope?.scope === ExecutionFailedActionScope.LOCAL_PANE) {\n          failureBuildInput = {\n            ...baseFailureInput,\n            scope: target.failureScope.scope,\n            paneId: target.failureScope.paneId,\n          };\n        } else if (target.failureScope?.scope === ExecutionFailedActionScope.EMBEDDED_CONTENT) {\n          failureBuildInput = {\n            ...baseFailureInput,\n            scope: target.failureScope.scope,\n          };\n        } else {\n          failureBuildInput = {\n            ...baseFailureInput,\n            scope: ExecutionFailedActionScope.CUSTOM,\n          };\n        }\n        const failedAction = buildExecutionFailedAction(failureBuildInput);\n        executionRuntime.navigation.captureFailedAction(failedAction);\n        throw error;\n      } finally {\n        executionRuntime.navigation.endPendingAction(pendingAction.actionRuntimeId);\n      }\n    };\n\n    const navigateToRead = (): boolean => {\n      try {\n        return buildExecutionOperationAction({\n          resourceType: target.resourceType,\n          resourceId: target.resourceId,\n          participationRef: target.participationRef,\n          contextParticipationRefs: target.contextParticipationRefs,\n          contextResourceIdentifiers: target.contextResourceIdentifiers,\n          relationshipFieldOverrides: target.relationshipFieldOverrides,\n          additionalContext: target.additionalContext,\n          navigationInitiator: target.navigationInitiator,\n          relationshipTransition: target.relationshipTransition,\n          operationLike: CoreResourceOperation.READ,\n          requireAddressable: true,\n        }).navigate();\n      } catch {\n        return false;\n      }\n    };\n\n    // ----- Per-action status snapshot (Slice G) -----\n    //\n    // Computed **lazily** off `runtimeStateRef.current` so that:\n    //\n    // 1. The enclosing `buildExecutionOperationAction` `useCallback` does\n    //    not need `runtimeState` in its deps — keeping `actions` identity\n    //    stable across `setPendingActions` / `setFailedActions` /\n    //    `setDirtyMarkers` commits (see the runtimeStateRef comment at the\n    //    top of `useExecution`, and the G11 regression test for the loop\n    //    this dodges).\n    // 2. Repeated `action.status.X` accesses inside one render commit\n    //    return the same cached object (so a `useEffect` keyed on\n    //    `[action.status.latestFailure]` does not fire spuriously when\n    //    the consumer reads it twice). The cache key is the runtimeState\n    //    object identity itself; a new commit produces a new\n    //    `runtimeState` reference (see `ExecutionView`'s\n    //    `useMemo<ExecutionRuntimeState>` deps), invalidating the cache\n    //    on the next access.\n    // 3. Across renders, the consumer component re-renders whenever any\n    //    of `loading` / `errors` / `dirty` (the public aggregator tiers)\n    //    flips identity, because the top-level `ExecutionValue` `useMemo`\n    //    lists all three as deps. On that re-render the consumer either\n    //    re-invokes `actions.operation(target)` (fresh action, fresh\n    //    cache) or accesses `action.status` again (cache invalidates\n    //    against the new `runtimeStateRef.current`).\n    let cachedStatusFor: ExecutionRuntimeState | null = null;\n    let cachedStatus: ExecutionOperationActionStatus | null = null;\n    const computeStatus = (): ExecutionOperationActionStatus => {\n      const live = runtimeStateRef.current;\n      if (cachedStatusFor === live && cachedStatus !== null) {\n        return cachedStatus;\n      }\n      const matchingPendingActions: ExecutionPendingAction[] = [];\n      for (const pending of Object.values(live.pendingActions)) {\n        if (pending.operationPathKey === operationPathKey) {\n          matchingPendingActions.push(pending);\n        }\n      }\n      const matchingFailedActions: ExecutionFailedAction[] = [];\n      for (const failed of Object.values(live.failedActions)) {\n        if (failed.operationPathKey === operationPathKey) {\n          matchingFailedActions.push(failed);\n        }\n      }\n      const matchingDirtyMarkers: ExecutionDirtyMarker[] = [];\n      if (target.dirtyPredicate) {\n        for (const marker of Object.values(live.dirtyMarkers)) {\n          if (target.dirtyPredicate(marker)) {\n            matchingDirtyMarkers.push(marker);\n          }\n        }\n      }\n      // `latestFailure` = max-by capturedAt. Encapsulates the manual reduce\n      // pattern repeated in every inline-error UX. Returning the full entry\n      // (not just the error) preserves the originating action runtime id\n      // and bridge flags for richer per-button retry UX.\n      let latestFailure: ExecutionFailedAction | undefined;\n      for (const candidate of matchingFailedActions) {\n        if (!latestFailure || candidate.capturedAt > latestFailure.capturedAt) {\n          latestFailure = candidate;\n        }\n      }\n      cachedStatus = {\n        pendingActions: matchingPendingActions,\n        failedActions: matchingFailedActions,\n        dirtyMarkers: matchingDirtyMarkers,\n        isPending: matchingPendingActions.length > 0,\n        isErrored: matchingFailedActions.length > 0,\n        isDirty: matchingDirtyMarkers.length > 0,\n        latestFailure,\n      };\n      cachedStatusFor = live;\n      return cachedStatus;\n    };\n\n    // ----- Cross-tier sugar (Slice G, G-max) -----\n    //\n    // `clearMyFailures` / `clearMyDirty` read the **live** registries at\n    // call time (not a build-time snapshot) so a stale memoized action\n    // can still cleanly clear failures / dirty markers that landed\n    // *after* it was built. Race semantics: `clear*` against an unknown\n    // id is tolerated by the shell as a no-op, so an entry being added\n    // concurrently with the iteration is safely skipped (it just won't\n    // be cleared this turn — the consumer can call again, or the next\n    // render's status will surface it).\n    const clearMyFailures = (): void => {\n      const live = runtimeStateRef.current;\n      for (const failed of Object.values(live.failedActions)) {\n        if (failed.operationPathKey === operationPathKey) {\n          executionRuntime.navigation.clearFailedAction(failed.failureRuntimeId);\n        }\n      }\n    };\n    const clearMyDirty = (): void => {\n      if (!target.dirtyPredicate) {\n        return;\n      }\n      const live = runtimeStateRef.current;\n      for (const marker of Object.values(live.dirtyMarkers)) {\n        if (target.dirtyPredicate(marker)) {\n          executionRuntime.navigation.clearDirty(marker.markerId);\n        }\n      }\n    };\n    const retry = async (requestData?: Record<string, unknown>): Promise<unknown> => {\n      // Clear *before* re-executing so subscribers reading\n      // `execution.errors` during the new execute() see a clean slate.\n      // The captured rejection from the new execute() will be appended to\n      // the (now-empty-for-this-action) registry — typical \"Retry\" UX.\n      clearMyFailures();\n      return execute(requestData);\n    };\n\n    return {\n      target: resolvedTarget,\n      resourceContext,\n      resourceType,\n      operation,\n      operationId,\n      operationPathKey,\n      contextualParameters,\n      navigationHandlingMode,\n      get status(): ExecutionOperationActionStatus {\n        return computeStatus();\n      },\n      execute,\n      embed,\n      navigate,\n      navigateToRead,\n      retry,\n      clearMyFailures,\n      clearMyDirty,\n    };\n  }, [\n    buildResourceOperationContext,\n    executionRuntime.doOperation,\n    executionRuntime.navigation,\n    executionRuntime.participations,\n    executionRuntime.viewDefinition,\n    registry,\n  ]);\n\n  const subjects = useMemo<ExecutionSubjectsValue>(() => ({\n    all: participations,\n    get: participation,\n    require: subjectsRequire as ExecutionSubjectsValue['require'],\n  }), [\n    participation,\n    participations,\n    subjectsRequire,\n  ]);\n\n  const buildActionDictionary = useCallback(<TDict extends Record<string, ExecutionActionTarget>>(\n    definitions: TDict,\n  ): ExecutionActionDictionary<Extract<keyof TDict, string>> => {\n    return Object.fromEntries(\n      Object.entries(definitions).map(([key, baseTarget]) => {\n        const mergeAndResolve = (overrides?: ExecutionActionRuntimeOverrides) => {\n          const mergedTarget: ExecutionActionTarget = {\n            ...baseTarget,\n            ...overrides,\n            contextResourceIdentifiers: {\n              ...(baseTarget.contextResourceIdentifiers ?? {}),\n              ...(overrides?.contextResourceIdentifiers ?? {}),\n            },\n            additionalContext: {\n              ...(baseTarget.additionalContext ?? {}),\n              ...(overrides?.additionalContext ?? {}),\n            },\n            navigationInitiator: {\n              ...(baseTarget.navigationInitiator ?? {}),\n              ...(overrides?.navigationInitiator ?? {}),\n            },\n          };\n\n          return buildExecutionOperationAction(mergedTarget);\n        };\n\n        const prepared: ExecutionPreparedAction = {\n          execute: (overrides, requestData) => mergeAndResolve(overrides).execute(requestData),\n          embed: (overrides) => mergeAndResolve(overrides).embed(),\n          navigate: (overrides) => mergeAndResolve(overrides).navigate(),\n          navigateToRead: (overrides) => mergeAndResolve(overrides).navigateToRead(),\n          bind: (overrides) => mergeAndResolve(overrides),\n        };\n\n        return [key, prepared];\n      }),\n    ) as ExecutionActionDictionary<Extract<keyof TDict, string>>;\n  }, [buildExecutionOperationAction]);\n\n  const actions = useMemo<ExecutionActionsValue>(() => ({\n    operation: buildExecutionOperationAction,\n    dictionary: buildActionDictionary,\n  }), [buildActionDictionary, buildExecutionOperationAction]);\n\n  const embeddedContent = useMemo<ExecutionEmbeddedContentValue>(() => ({\n    open: executionRuntime.navigation.openEmbeddedContent,\n    close: executionRuntime.navigation.closeEmbeddedContent,\n    openResource: (target) => buildExecutionOperationAction(target).embed(),\n  }), [\n    buildExecutionOperationAction,\n    executionRuntime.navigation.closeEmbeddedContent,\n    executionRuntime.navigation.openEmbeddedContent,\n  ]);\n\n  const loading = useMemo<ExecutionLoadingValue>(() => {\n    const pendingActions = Object.values(executionRuntime.runtimeState.pendingActions);\n    const participationPrefetchActions = Object.values(\n      executionRuntime.runtimeState.participationPrefetchActions,\n    );\n    const isAnyPending = pendingActions.length > 0;\n    const isAnyParticipationPrefetching = participationPrefetchActions.length > 0;\n    const isBusy = isAnyPending || isAnyParticipationPrefetching;\n    return {\n      pendingActions,\n      participationPrefetchActions,\n      isBusy,\n      isAnyPending,\n      isPending: (predicate) => {\n        if (!predicate) {\n          return isAnyPending;\n        }\n        return pendingActions.some(predicate);\n      },\n      isAnyParticipationPrefetching,\n      isParticipationPrefetching: (predicate) => {\n        if (!predicate) {\n          return isAnyParticipationPrefetching;\n        }\n        return participationPrefetchActions.some(predicate);\n      },\n    };\n  }, [\n    executionRuntime.runtimeState.pendingActions,\n    executionRuntime.runtimeState.participationPrefetchActions,\n  ]);\n\n  const dirty = useMemo<ExecutionDirtyValue>(() => {\n    const markers = Object.values(executionRuntime.runtimeState.dirtyMarkers);\n    const isAnyDirty = markers.length > 0;\n    return {\n      markers,\n      isAnyDirty,\n      isDirty: (predicate) => {\n        if (!predicate) {\n          return isAnyDirty;\n        }\n        return markers.some(predicate);\n      },\n      mark: executionRuntime.navigation.markDirty,\n      clear: executionRuntime.navigation.clearDirty,\n      clearAll: executionRuntime.navigation.clearAllDirty,\n    };\n  }, [\n    executionRuntime.navigation.clearAllDirty,\n    executionRuntime.navigation.clearDirty,\n    executionRuntime.navigation.markDirty,\n    executionRuntime.runtimeState.dirtyMarkers,\n  ]);\n\n  // Stable refs so `capture` does not re-memoize on every navigation/runtime\n  // identity flip — its identity is part of the `errors` value, which feeds\n  // into the top-level memo of `ExecutionValue`.\n  const captureFailedActionRef = useRef(executionRuntime.navigation.captureFailedAction);\n  const runtimeInstanceIdRef = useRef(executionRuntime.runtimeInstanceId);\n  const viewDefinitionRefRef = useRef(executionRuntime.viewDefinition.ref);\n  captureFailedActionRef.current = executionRuntime.navigation.captureFailedAction;\n  runtimeInstanceIdRef.current = executionRuntime.runtimeInstanceId;\n  viewDefinitionRefRef.current = executionRuntime.viewDefinition.ref;\n\n  const captureFailureFromConsumer = useCallback((input: ExecutionErrorCaptureInput): ExecutionFailedAction => {\n    const markedByHttpClient = isErrorMarkedByHttpClient(input.error);\n    // The shell only bridges when the consumer hasn't opted out AND the\n    // error is not already marked by `wildo-http-client` (which means\n    // upstream already classified and decided whether to emit).\n    const bridgedByExecutionShell = (input.bridgeToCanonicalBus ?? true) && !markedByHttpClient;\n    if (bridgedByExecutionShell) {\n      errorManagement.handleError(input.error, {\n        source: 'manual',\n        resourceType: input.resourceType,\n        operationIdentifier: input.operationId,\n        additionalContext: {\n          executionRuntimeInstanceId: runtimeInstanceIdRef.current,\n          executionViewRef: viewDefinitionRefRef.current,\n          ...(input.operationPathKey ? { operationPathKey: input.operationPathKey } : {}),\n        },\n      });\n    }\n    // Narrow on the discriminant `input.scope` so TypeScript carries the\n    // `paneId` requirement into the LOCAL_PANE branch without a cast.\n    // Mirrors the symmetric pattern in `buildExecutionFailedAction` — same\n    // discriminated-union shape on both sides of the consumer-facing seam.\n    const baseBuildInput = {\n      failureRuntimeId: createExecutionFailureRuntimeId(),\n      operationPathKey: input.operationPathKey,\n      resourceType: input.resourceType,\n      operationId: input.operationId,\n      error: input.error,\n      label: input.label,\n      markedByHttpClient,\n      bridgedByExecutionShell,\n    };\n    let failedAction: ExecutionFailedAction;\n    if (input.scope === ExecutionFailedActionScope.LOCAL_PANE) {\n      failedAction = buildExecutionFailedAction({\n        ...baseBuildInput,\n        scope: input.scope,\n        paneId: input.paneId,\n      });\n    } else if (input.scope === ExecutionFailedActionScope.EMBEDDED_CONTENT) {\n      failedAction = buildExecutionFailedAction({\n        ...baseBuildInput,\n        scope: input.scope,\n      });\n    } else if (input.scope === ExecutionFailedActionScope.PARTICIPATION_PREFETCH) {\n      failedAction = buildExecutionFailedAction({\n        ...baseBuildInput,\n        scope: input.scope,\n        prefetchKey: input.prefetchKey,\n      });\n    } else {\n      failedAction = buildExecutionFailedAction({\n        ...baseBuildInput,\n        scope: ExecutionFailedActionScope.CUSTOM,\n      });\n    }\n    captureFailedActionRef.current(failedAction);\n    return failedAction;\n  }, []);\n\n  const errors = useMemo<ExecutionErrorsValue>(() => {\n    const failedActions = Object.values(executionRuntime.runtimeState.failedActions);\n    const isAnyErrored = failedActions.length > 0;\n    return {\n      failedActions,\n      isAnyErrored,\n      isErrored: (predicate) => {\n        if (!predicate) {\n          return isAnyErrored;\n        }\n        return failedActions.some(predicate);\n      },\n      capture: captureFailureFromConsumer,\n      clear: executionRuntime.navigation.clearFailedAction,\n      clearAll: executionRuntime.navigation.clearAllFailedActions,\n    };\n  }, [\n    captureFailureFromConsumer,\n    executionRuntime.navigation.clearAllFailedActions,\n    executionRuntime.navigation.clearFailedAction,\n    executionRuntime.runtimeState.failedActions,\n  ]);\n\n  return useMemo<ExecutionValue>(() => ({\n    view: executionRuntime.viewDefinition,\n    anchor: executionRuntime.anchor,\n    state: executionRuntime.runtimeState,\n    contextResourceIdentifiers: executionRuntime.contextResourceIdentifiers,\n    runtimeInstanceId: executionRuntime.runtimeInstanceId,\n    navigationZone: executionRuntime.navigationZone,\n    doOperation: executionRuntime.doOperation,\n    delegateToParent: executionRuntime.navigation.delegateToParent,\n    localPane: {\n      open: executionRuntime.navigation.openLocalPane,\n      close: executionRuntime.navigation.closeLocalPane,\n    },\n    embeddedContent,\n    loading,\n    dirty,\n    errors,\n    participations,\n    participation,\n    requireParticipation,\n    subjects,\n    buildContextualParameters,\n    buildResourceOperationContext,\n    actions,\n  }), [\n    actions,\n    buildContextualParameters,\n    buildResourceOperationContext,\n    executionRuntime.anchor,\n    executionRuntime.contextResourceIdentifiers,\n    executionRuntime.doOperation,\n    executionRuntime.navigation,\n    executionRuntime.navigationZone,\n    executionRuntime.runtimeInstanceId,\n    executionRuntime.runtimeState,\n    executionRuntime.viewDefinition,\n    embeddedContent,\n    loading,\n    dirty,\n    errors,\n    participation,\n    participations,\n    requireParticipation,\n    subjects,\n  ]);\n}\n"]}

package/dist/esm/core/execution/useExecutionDirtyBridge.d.ts

@@ -0,0 +1,205 @@
+/**
+ * @wildo_source:part:start saas.frontend.execution-view.dirty-bridge-contract facet:layer:frontend facet:family:execution-view
+ *
+ * Slice F primitive — generic publisher hook for the execution-shell
+ * dirty-state contract.
+ *
+ * The dirty-state contract (see `dirty-state-contract` anchor in
+ * `ExecutionRuntimeContext.tsx`) leaves "publisher owns mark/clear" as the
+ * load-bearing rule. `useExecutionDirtyBridge` is the canonical primitive
+ * that turns any boolean-shaped "is this surface dirty?" signal into a
+ * shell-published marker with the right scope, the right lifecycle, and
+ * the right cleanup — without the publisher having to know whether it is
+ * mounted inside an execution shell, which zone scope it occupies, or
+ * how the shell prunes markers on zone transitions.
+ *
+ * Two key invariants this hook enforces so consumers cannot get them wrong:
+ *
+ * 1. **No-op outside an execution shell.** When the hook is called from a
+ *    component tree that is NOT under `ExecutionRuntimeProvider`, it does
+ *    nothing — no marks, no clears, no errors. This makes the hook safe
+ *    to call unconditionally from framework components like
+ *    `ResourceAutomatedForm` that are mounted in plenty of non-execution
+ *    contexts (resource layouts, composite views, custom views).
+ *
+ * 2. **Always clear on unmount.** Whether the marker was registered as
+ *    `EMBEDDED_CONTENT`, `LOCAL_PANE`, or `CUSTOM`, the bridge clears it
+ *    when the publisher component unmounts. This guarantees that even
+ *    `CUSTOM` markers (which the shell never auto-prunes) cannot leak
+ *    when their owning component goes away.
+ *
+ * Scope inference is delegated to `ExecutionDirtyMarkerScopeContext`
+ * (companion file). The shell's embedded slot wraps its content in
+ * `<ExecutionDirtyMarkerScopeProvider scope={EMBEDDED_CONTENT}>` so any
+ * RMM-backed editor mounted into the embed publishes under the right
+ * scope. Consumers that render content into the local pane can wrap their
+ * pane content in `<ExecutionDirtyMarkerScopeProvider scope={LOCAL_PANE}
+ * paneId={...}>`. When neither provider is in scope, the bridge falls back
+ * to `CUSTOM` (informative, never auto-pruned, cleared on unmount).
+ *
+ * This primitive does not subscribe to any external store. The caller
+ * owns subscription (typically `useSyncExternalStore(rmm.subscribe,
+ * rmm.getSnapshot)` for an RMM-backed consumer) and feeds the resulting
+ * boolean in. That keeps the hook generic and avoids duplicate RMM
+ * subscriptions when the caller already has one.
+ *
+ * @wildo_source:part:end saas.frontend.execution-view.dirty-bridge-contract
+ *
+ * @wildo_source:part:start saas.frontend.execution-view.dirty-bridge-contract.local-pane facet:layer:frontend facet:family:execution-view
+ *
+ * Slice I refinement — `LOCAL_PANE`-flavor specifics for the dirty-bridge
+ * contract (Slice F primitive, see parent anchor
+ * `saas.frontend.execution-view.dirty-bridge-contract`).
+ *
+ * The `LOCAL_PANE` scope discriminant has different lifecycle semantics
+ * from `EMBEDDED_CONTENT` because it is **paneId-keyed**: the shell prunes
+ * `LOCAL_PANE` markers via `pruneDirtyMarkersForPaneTransition(previous,
+ * nextPaneId)`, which keeps markers whose `paneId` matches the active pane
+ * and drops the rest. That makes paneId stability a first-class consumer
+ * decision, not a contract default. This sub-anchor pins the three
+ * defensible policies and the trade-offs each one carries so future
+ * `LOCAL_PANE` consumers do not relitigate it case-by-case.
+ *
+ * **paneId derivation policies (consumer chooses; shell stays neutral):**
+ *
+ * 1. **Fresh per `localPane.open(...)` call** (e.g. `${prefix}-${randomUUID()}`).
+ *    Every open mints a new paneId; opening a different node, or even the
+ *    *same* node twice, transitions paneIds and triggers
+ *    `pruneDirtyMarkersForPaneTransition` to drop the previous pane's
+ *    `LOCAL_PANE` markers. Pros: aggressive cleanup, drafts never leak
+ *    across opens. Cons: closing-then-reopening the same logical surface
+ *    discards in-flight drafts (intentional under this policy).
+ *
+ * 2. **Stable per inspected entity** (e.g. `${prefix}:${entityId}`).
+ *    Re-opening the same entity reuses the paneId; markers persist across
+ *    re-opens (idempotent re-mark). Switching to a different entity
+ *    transitions paneIds and prunes the prior entity's markers. Pros:
+ *    drafts survive accidental close-reopen on the same surface. Cons:
+ *    requires the consumer to invalidate explicitly when the entity's
+ *    backing data changes server-side, otherwise a stale draft can survive
+ *    a refresh.
+ *
+ * 3. **Stable per pane name** (e.g. always `${prefix}`). Switching nodes
+ *    does NOT change paneId; the prune helper does not fire on payload
+ *    swap. **This is the trap policy** — drafts leak across logical
+ *    surfaces inside the same pane. Documented here so consumers do not
+ *    pick it accidentally; if you genuinely want one shared draft for "any
+ *    payload of this pane", say so explicitly in the marker label and own
+ *    the cross-payload semantics.
+ *
+ * **Auto-clear timing — three independent paths the consumer can rely on:**
+ *
+ * - `closeLocalPane()` calls `pruneDirtyMarkersForPaneTransition(previous,
+ *   null)` which drops every `LOCAL_PANE` marker (paneId mismatch with
+ *   `null`). Belt-and-suspenders cleanup #1.
+ *
+ * - `openLocalPane(nextPaneId, ...)` calls
+ *   `pruneDirtyMarkersForPaneTransition(previous, nextPaneId)` which drops
+ *   markers whose paneId differs from `nextPaneId`. Belt-and-suspenders
+ *   cleanup #2 — fires before the new pane content even mounts.
+ *
+ * - The bridge's own `useEffect` cleanup runs on publisher unmount
+ *   (component goes away when the pane content stops rendering) and on
+ *   any input-change re-run. Belt-and-suspenders cleanup #3.
+ *
+ * All three converge on the same end state: no `LOCAL_PANE` marker
+ * survives its pane. Consumers should not need to author manual
+ * `clearDirty(...)` calls for `LOCAL_PANE` markers in the close path.
+ *
+ * **Multi-marker per pane is supported.** Nothing in the contract says a
+ * pane gets one marker; consumers can call `useExecutionDirtyBridge`
+ * multiple times in the same pane subtree (one per editable field, one
+ * per logical "change set", etc.) and each call publishes its own
+ * marker. The shell's prune helpers are markerId-agnostic — they filter
+ * by scope/paneId only — so all markers belonging to the pane are
+ * cleared together on transition. This is the pattern the inspector
+ * dogfood uses (one marker per draft field).
+ *
+ * **Confirm-on-close UX is consumer-owned, not framework-owned.** This is
+ * the load-bearing rule from the parent dirty-state contract
+ * (`saas.frontend.execution-view.dirty-state-contract`): the shell is
+ * informative-only — it publishes the dirty signal and prunes on
+ * transitions, but it never blocks `closeLocalPane()` on dirty state.
+ * If the consumer wants a "Discard unsaved changes?" prompt, the
+ * consumer authors it (typically by gating the close button's `onClick`
+ * on `execution.dirty.isDirty((m) => m.scope === LOCAL_PANE && m.paneId
+ * === currentPaneId)`). The framework refuses to grow modal UX
+ * primitives because (a) confirm UX is application-specific (modal /
+ * inline / toast / route guard) and (b) gating shell APIs would
+ * couple the dirty contract to UX policy.
+ *
+ * **L1 acknowledged trade-off (carried over from Slice H pattern of
+ * recording rot risks at the anchor):** the bridge does not assert
+ * `paneId` matches the currently-active `localPane.paneId` when
+ * publishing a `LOCAL_PANE` marker. A bug in the consumer (e.g. typo'd
+ * paneId, racey re-render holding a stale paneId) would publish a
+ * marker that never matches the active pane and therefore never
+ * auto-clears via the prune helpers. The unmount cleanup is the only
+ * safety net in that case. Validation was rejected because (a) the
+ * publisher already lives inside the pane subtree by definition — a
+ * paneId mismatch is a programming error, not a runtime condition, and
+ * (b) a runtime check would force the bridge to subscribe to
+ * `executionContext.runtimeState.localPane`, which would re-fire the
+ * effect on every pane open/close (defeating the carefully-tuned deps
+ * list documented above). Re-evaluate at the first reported bug.
+ *
+ * @wildo_source:part:end saas.frontend.execution-view.dirty-bridge-contract.local-pane
+ */
+import { ExecutionDirtyMarkerScope } from './ExecutionRuntimeContext';
+/**
+ * Inputs for the dirty-marker bridge hook.
+ *
+ * `markerId` and `isDirty` are required; `markerId` must be stable across
+ * renders for the same logical surface (typically a content-derived key
+ * such as `rmm:${resourceType}:${resourceId}` for RMM-backed consumers).
+ * Re-marking is idempotent on the shell side — the bridge does not need
+ * to debounce.
+ */
+export interface UseExecutionDirtyBridgeInput {
+    /**
+     * Stable id used as `ExecutionDirtyMarker.markerId`. Must be stable
+     * across renders for the same logical surface so re-marks replace the
+     * existing entry (idempotent) rather than competing with a stale one.
+     * Typical pattern for RMM publishers: `rmm:${resourceType}:${resourceId}`.
+     */
+    markerId: string;
+    /**
+     * Current dirty state. Transitions drive the shell's marker lifecycle:
+     * `false → true` registers the marker, `true → false` clears it.
+     * Component unmount always clears regardless of the last value.
+     */
+    isDirty: boolean;
+    /**
+     * Optional human-readable reason exposed on the marker (e.g.
+     * "Unsaved task changes"). Surfaces in confirm dialogs / ambient badges
+     * authored by the consumer; the shell treats it as opaque metadata.
+     */
+    label?: string;
+    /**
+     * Optional explicit scope override. When set, takes precedence over the
+     * scope from `ExecutionDirtyMarkerScopeContext`. Useful for callers that
+     * want to publish under a specific scope regardless of where they are
+     * mounted (e.g. a CUSTOM marker emitted by a sidebar that happens to
+     * live inside the embed slot today but represents app-level state).
+     */
+    scopeOverride?: {
+        scope: ExecutionDirtyMarkerScope.EMBEDDED_CONTENT;
+    } | {
+        scope: ExecutionDirtyMarkerScope.LOCAL_PANE;
+        paneId: string;
+    } | {
+        scope: ExecutionDirtyMarkerScope.CUSTOM;
+    };
+}
+/**
+ * Bridge a boolean dirty signal into the execution-shell dirty-state
+ * aggregator.
+ *
+ * Safe to call unconditionally — no-ops when there is no
+ * `ExecutionRuntimeProvider` in scope. Idempotent on `markerId`: re-marks
+ * replace the existing entry; clears for an unknown id are tolerated.
+ * Always clears on unmount, including for CUSTOM-scope markers that the
+ * shell would otherwise never prune.
+ */
+export declare function useExecutionDirtyBridge(input: UseExecutionDirtyBridgeInput): void;
+//# sourceMappingURL=useExecutionDirtyBridge.d.ts.map

package/dist/esm/core/execution/useExecutionDirtyBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecutionDirtyBridge.d.ts","sourceRoot":"","sources":["../../../../../src/core/execution/useExecutionDirtyBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkJG;AAIH,OAAO,EACL,yBAAyB,EAG1B,MAAM,2BAA2B,CAAC;AAGnC;;;;;;;;GAQG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,aAAa,CAAC,EACV;QAAE,KAAK,EAAE,yBAAyB,CAAC,gBAAgB,CAAA;KAAE,GACrD;QAAE,KAAK,EAAE,yBAAyB,CAAC,UAAU,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAC/D;QAAE,KAAK,EAAE,yBAAyB,CAAC,MAAM,CAAA;KAAE,CAAC;CACjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,4BAA4B,GAAG,IAAI,CA8FjF"}