@intentius/chant 0.124.51 → 0.124.54

package/dist/components/cli-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-support.d.ts","sourceRoot":"","sources":["../../src/components/cli-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAiC,KAAK,SAAS,EAAE,KAAK,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAClH,OAAO,EAQL,KAAK,eAAe,EAGpB,KAAK,eAAe,EACrB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAErE,OAAO,EAAuC,KAAK,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAChG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAqC,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAK3F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9D,yDAAyD;AACzD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,qFAAqF;AACrF,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqBnG;AAED,+FAA+F;AAC/F,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,0FAA0F;IAC1F,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,sFAAsF;AACtF,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAuBvH;AAED,4GAA4G;AAC5G,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3C;;gEAE4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;4EAGwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACrC;;;;;2DAKuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACtC;;kBAEc;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACvC,6GAA6G;IAC7G,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,6FAA6F;AAC7F,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,EACjB,WAAW,CAAC,EAAE,oBAAoB,EAAE,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAqD/B;AAED,iJAAiJ;AACjJ,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAErC;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,EAC9E,UAAU,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,EAC9D,UAAU,EAAE,CAAC,EAAE,GACd,CAAC,EAAE,CAML;AAED,iEAAiE;AACjE,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACrF,oHAAoH;IACpH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+MAA+M;IAC/M,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACtC;AAqBD;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE,wBAAwB,EAClC,OAAO,CAAC,EAAE,OAAO;AACjB;;;;;;;GAOG;AACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,GACnC,OAAO,CAAC,wBAAwB,CAAC,CA+BnC;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAkB1F;AAED,6FAA6F;AAC7F,MAAM,WAAW,oBAAoB;IACnC,wGAAwG;IACxG,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;IACtD;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6HAA6H;IAC7H,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC/C;;;OAGG;IACH,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACrC,8KAA8K;IAC9K,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,gGAAgG;AAChG,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,2DAA2D;AAC3D,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,6FAA6F;IAC7F,GAAG,CAAC,EAAE,eAAe,CAAC;IACtB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,4GAA4G;IAC5G,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0IAA0I;IAC1I,KAAK,CAAC,EAAE;QACN,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,iBAAiB,CAAC;QACxB,mHAAmH;QACnH,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,uFAAuF;QACvF,QAAQ,CAAC,EAAE,kBAAkB,CAAC;KAC/B,CAAC;IACF,wSAAwS;IACxS,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,uFAAuF;AACvF,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,sHAAsH;IACtH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,2GAA2G;IAC3G,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,uGAAuG;AACvG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,OAAO;AACjB,4RAA4R;AAC5R,WAAW,CAAC,EAAE,oBAAoB,EAAE,GACnC,OAAO,CAAC,wBAAwB,CAAC,CAoCnC;AA6DD,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAgK9B"}
+{"version":3,"file":"cli-support.d.ts","sourceRoot":"","sources":["../../src/components/cli-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAiC,KAAK,SAAS,EAAE,KAAK,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAClH,OAAO,EAQL,KAAK,eAAe,EAGpB,KAAK,eAAe,EAErB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAErE,OAAO,EAAuC,KAAK,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAChG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAqC,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAK3F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAI5C,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9D,yDAAyD;AACzD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,qFAAqF;AACrF,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAqBnG;AAED,+FAA+F;AAC/F,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,0FAA0F;IAC1F,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,kBAAkB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,sFAAsF;AACtF,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAuBvH;AAED,4GAA4G;AAC5G,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3C;;gEAE4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;4EAGwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACrC;;;;;2DAKuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACtC;;kBAEc;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACvC,6GAA6G;IAC7G,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,6FAA6F;AAC7F,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,EACjB,WAAW,CAAC,EAAE,oBAAoB,EAAE,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAqD/B;AAED,iJAAiJ;AACjJ,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC;AAErC;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,EAC9E,UAAU,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,EAC9D,UAAU,EAAE,CAAC,EAAE,GACd,CAAC,EAAE,CAML;AAED,iEAAiE;AACjE,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACrF,oHAAoH;IACpH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+MAA+M;IAC/M,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACtC;AAqBD;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE,wBAAwB,EAClC,OAAO,CAAC,EAAE,OAAO;AACjB;;;;;;;GAOG;AACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,GACnC,OAAO,CAAC,wBAAwB,CAAC,CA+BnC;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAkB1F;AAED,6FAA6F;AAC7F,MAAM,WAAW,oBAAoB;IACnC,wGAAwG;IACxG,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;IACtD;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6HAA6H;IAC7H,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC/C;;;OAGG;IACH,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACrC,8KAA8K;IAC9K,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,gGAAgG;AAChG,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,2DAA2D;AAC3D,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,6FAA6F;IAC7F,GAAG,CAAC,EAAE,eAAe,CAAC;IACtB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,4GAA4G;IAC5G,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0IAA0I;IAC1I,KAAK,CAAC,EAAE;QACN,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,iBAAiB,CAAC;QACxB,mHAAmH;QACnH,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,uFAAuF;QACvF,QAAQ,CAAC,EAAE,kBAAkB,CAAC;KAC/B,CAAC;IACF,wSAAwS;IACxS,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACrC,kHAAkH;IAClH,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,uFAAuF;AACvF,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,sHAAsH;IACtH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB;;;;;OAKG;IACH,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,eAAe,EAAE,CAAA;KAAE,CAAC;IACvD,2GAA2G;IAC3G,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,uGAAuG;AACvG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,OAAO;AACjB,4RAA4R;AAC5R,WAAW,CAAC,EAAE,oBAAoB,EAAE,GACnC,OAAO,CAAC,wBAAwB,CAAC,CAoCnC;AAiDD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG;IAAE,OAAO,EAAE,eAAe,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAchJ;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAmM9B"}

package/dist/components/cli-support.js

@@ -33,7 +33,9 @@ import { dirname, relative } from "node:path";
 import { existsSync, statSync } from "node:fs";
 import { getHeadCommit } from "../lifecycle/git.js";
 import { buildCapabilityRegistry } from "./capability-plugin-loader.js";
+import { componentSetFanOut, formRunGroups, planAndRunComponentGroup } from "./groups.js";
 import { applyConfigDefaults } from "./config-defaults.js";
+import { withDeclaredReads } from "./declared-reads.js";
 import { loadChantConfig } from "../config.js";
 /** Discover components under `path` and shape them for `chant list --components`. */
 export async function listComponents(path, sandbox) {
@@ -348,6 +350,13 @@ function resolveComponentList(selector, discovered, all) {
         };
     }
     const enabled = withoutDisabled(discovered, all);
+    return { success: true, ...dependencyClosure(names, enabled), list: { named: names, enabled } };
+}
+/**
+ * `names` and every component of `enabled` they depend on, transitively, in
+ * `enabled`'s order, and which of those the names did not give (#3950).
+ */
+export function dependencyClosure(names, enabled) {
     const byName = new Map(enabled.map((c) => [c.name, c]));
     const included = new Set();
     const visit = (name) => {
@@ -362,20 +371,13 @@ function resolveComponentList(selector, discovered, all) {
         visit(name);
     const targets = enabled.filter((c) => included.has(c.name));
     const named = new Set(names);
-    return { success: true, targets, added: targets.map((c) => c.name).filter((n) => !named.has(n)) };
+    return { targets, added: targets.map((c) => c.name).filter((n) => !named.has(n)) };
 }
 export async function runComponents(path, selector, options = {}) {
     const resolved = await resolveComponentTargets(path, selector, options.sandbox, options.buildParams);
     if (!resolved.success) {
         return { success: false, selected: [], error: resolved.error };
     }
-    const targets = resolved.targets;
-    const narrowed = options.targets ?? {};
-    const outside = Object.keys(narrowed).filter((name) => !targets.some((c) => c.name === name));
-    if (outside.length > 0) {
-        return { success: false, selected: [], error: `--target names ${outside.join(", ")}, which this run does not run` };
-    }
-    const targeted = Object.keys(narrowed).length > 0 ? { targets: narrowed } : {};
     // (#629) Resolve `chant.config.ts`'s `sbom`/`signing`/`vulnPolicy` sections
     // and fill their defaults into every recognized step (`generate-sbom`,
     // `sign`/`attest-provenance`, `verify`, `vuln-gate`) that didn't already
@@ -393,8 +395,28 @@ export async function runComponents(path, selector, options = {}) {
             lexicons: lexiconNames(config.lexicons),
         }));
     const env = options.env ?? "local";
-    const selected = targets.map((c) => c.name);
-    const resolvedTargets = targets.map((component) => applyConfigDefaults(component, config));
+    // #4516: the reads a capability finds in its steps' files (a template's
+    // Fn::ImportValue) order a set run as `deriveFanOut` orders a fan-out, so an
+    // importer runs after the component whose export it reads. A list takes its
+    // closure again with them written in, so a listed importer pulls in its
+    // exporter. A single name runs on its own, against seeded outputs.
+    let resolvedTargets;
+    let added = resolved.added ?? [];
+    if (resolved.list) {
+        const enabled = await withDeclaredReads(resolved.list.enabled.map((component) => applyConfigDefaults(component, config)), registry, path);
+        ({ targets: resolvedTargets, added } = dependencyClosure(resolved.list.named, enabled));
+    }
+    else {
+        const defaulted = resolved.targets.map((component) => applyConfigDefaults(component, config));
+        resolvedTargets = selector === "all" ? await withDeclaredReads(defaulted, registry, path) : defaulted;
+    }
+    const selected = resolvedTargets.map((c) => c.name);
+    const narrowed = options.targets ?? {};
+    const outside = Object.keys(narrowed).filter((name) => !selected.includes(name));
+    if (outside.length > 0) {
+        return { success: false, selected: [], error: `--target names ${outside.join(", ")}, which this run does not run` };
+    }
+    const targeted = Object.keys(narrowed).length > 0 ? { targets: narrowed } : {};
     // Cross-component/cross-stack outputs to resolve references against. Seeded
     // from a caller (a downstream CI job passing an upstream job's dumped
     // outputs via `--seed-outputs`); grows as this run's components complete.
@@ -409,16 +431,37 @@ export async function runComponents(path, selector, options = {}) {
     const releaseIdentity = () => (revision ? { revision } : {});
     try {
         if (selector === "all" || isComponentList(selector)) {
+            // ws-107 (#4465): the components a capability takes as one plan in their
+            // wave and apply as one group, by the rule the pull-request run uses.
+            // A cycle or unknown dependency throws here the error the driver would:
+            // `componentSetFanOut` drops a dependency outside the set, so the full
+            // graph is resolved first.
+            resolveComponentGraph(resolvedTargets);
+            const grouped = await formRunGroups({ components: resolvedTargets, plan: componentSetFanOut(resolvedTargets), registry, env });
             if (isComponentList(selector) && options.onPlan) {
                 // Resolved here, before dispatch, so the order is printed before any
-                // component runs. A cycle or unknown dependency throws the same error
-                // `runInterpretDriver` would, caught below.
-                const graph = resolveComponentGraph(resolvedTargets);
-                options.onPlan({ order: graph.order, waves: graph.waves, added: resolved.added ?? [] });
+                // component runs.
+                options.onPlan({ order: grouped.order, waves: grouped.waves.filter((w) => w.length > 0), added });
             }
+            const byName = new Map(resolvedTargets.map((c) => [c.name, c]));
+            const groups = grouped.groups?.length
+                ? {
+                    waves: grouped.waves,
+                    groups: grouped.groups,
+                    run: (group, componentOutputs) => planAndRunComponentGroup({
+                        group,
+                        components: byName,
+                        registry,
+                        env,
+                        ctxOf: (name) => deployContext({ env, releaseIdentity, ...targeted }, name),
+                        componentOutputs,
+                    }),
+                }
+                : undefined;
             const run = await runInterpretDriver(resolvedTargets, registry, {
                 env,
                 releaseIdentity,
+                ...(groups ? { groups } : {}),
                 ...targeted,
                 componentOutputs: seedOutputs,
                 ...(emit ? { onRunEvent: emit } : {}),
@@ -430,6 +473,7 @@ export async function runComponents(path, selector, options = {}) {
                 selected,
                 components: resolvedTargets,
                 buildParams: options.buildParams,
+                ...(grouped.groups?.length || grouped.fallbacks?.length ? { grouped } : {}),
                 ...(run.status === "gated" && run.gate
                     ? {
                         gated: {

package/dist/components/covered-round.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Covered rounds (#4419): a round planned after an upstream applied is
+ * covered by the pull request's first approval when it does only what that
+ * approval previewed.
+ *
+ * A member that reads an output an upstream in the same change has not
+ * created yet is previewed with a hole: the input is marked unknown
+ * (`PrMember.unknownInputs`). Once the upstream applied, the apply plans the
+ * member again with the real value. That fresh plan is covered when
+ *
+ * - it touches only components the first plan previewed,
+ * - within each, only the logical ids and actions previewed (and no
+ *   replacement the preview did not show), and
+ * - the only inputs that differ are the ones the preview marked unknown.
+ *
+ * A lexicon that can say more than the change set's entries (CloudFormation
+ * previews the member with placeholder parameters and reads the real change
+ * set afterwards) supplies a {@link PlanShape} on its `CapabilityPlan`.
+ * Core decides coverage; the lexicon only reports what it planned.
+ *
+ * A shape may go below the entry, to the properties a change touches and the
+ * ones an unknown input drives. Where it does, a property may drop out when
+ * an unknown input drives it (the real value turned out equal to the current
+ * one), and never otherwise, and a property may never be added.
+ *
+ * Coverage binds to the digest of the first approval. {@link coveredRound}
+ * takes that digest and records it, so a round planned for a different
+ * composition never counts as covered by an approval of another one.
+ */
+import type { ChangeSetAction, ChangeSetDocument } from "../change-set.js";
+/** CloudFormation's `Replacement`, in lower case. */
+export type ShapeReplacement = "true" | "false" | "conditional";
+/** One resource a plan touches. */
+export interface PlanShapeEntry {
+    /** The resource's id in the lexicon's own terms: a CloudFormation logical id, a Terraform address. */
+    logicalId: string;
+    action: ChangeSetAction;
+    /**
+     * Whether the change replaces the resource, for an `update` or `replace`.
+     * `conditional` is the preview not knowing, because a parameter it
+     * depends on was a placeholder. Absent means the lexicon does not say.
+     */
+    replacement?: ShapeReplacement;
+    /** The resource's type, when the lexicon says. Compared for equality when both sides carry it. */
+    type?: string;
+    /**
+     * The properties the change touches, when the lexicon lists them. Present
+     * on both sides, the fresh plan may touch fewer where an unknown input
+     * drives them, and never more.
+     */
+    properties?: string[];
+    /**
+     * The properties an unknown input drives. On an update a subset of
+     * `properties`; on a create, where a planner cannot list properties, they
+     * stand alone. Present (even empty) on an entry that carries detail.
+     */
+    unknown?: string[];
+}
+/** What one member's plan does, without the values: what a lexicon supplies and core compares. */
+export interface PlanShape {
+    /** The member the shape is of, as in the change set. */
+    member: string;
+    /** Every resource the plan touches. A `no-op` or `read` entry may be left out. */
+    entries: PlanShapeEntry[];
+    /**
+     * The inputs the plan was made without, as `<component>.<output>`: the
+     * ones the preview marked unknown. A fresh plan lists none of them; it
+     * is the inputs that were filled in that are recorded.
+     */
+    unknownInputs: string[];
+    /**
+     * The inputs the plan read with a value, by reference. When both shapes
+     * carry a reference, the values must be equal, or an input that was
+     * known has changed. Optional: a shape without it is checked on its
+     * entries alone, plus the change set's own attributes in core.
+     */
+    knownInputs?: Record<string, unknown>;
+}
+/**
+ * Every way `fresh` goes beyond `previewed`, as reasons; none means covered.
+ * Both are shapes of the same member.
+ *
+ * The fresh plan may match the preview exactly, or be narrower where an
+ * unknown input drives it: a property whose real value equals the current one
+ * drops out, a replacement that depended on a stand-in may not happen. It
+ * may never add a resource, add a property, change an action or a type,
+ * replace more than previewed, read an input that is still unknown, or read a
+ * known input as another value.
+ */
+export declare function planShapeDifferences(previewed: PlanShape, fresh: PlanShape): string[];
+/**
+ * Why `fresh` is not covered by `previewed`, or `undefined` when it is: the
+ * first of {@link planShapeDifferences}.
+ */
+export declare function planShapeCovers(previewed: PlanShape, fresh: PlanShape): string | undefined;
+/** A shape in the order that makes equal shapes digest equal. */
+export declare function normalizePlanShape(shape: PlanShape): PlanShape;
+export declare function planShapeDigest(shape: PlanShape): string;
+/**
+ * What a lexicon hands the run for a previewed member, through
+ * `DeployContext.plans[member]`. `kind` is the lexicon's own so its `run`
+ * can tell a shape from its other artifacts.
+ */
+export interface PlanShapeArtifact {
+    kind: string;
+    member: string;
+    shape: PlanShape;
+    digest: string;
+}
+/**
+ * Thrown by a member's `run` when the change it created is not covered by the
+ * shape previewed. The change set is deleted unexecuted. `planMoved` is
+ * core's mark for a moved plan, so the command that applied it exits 3.
+ */
+export declare class PlanShapeMovedError extends Error {
+    readonly member: string;
+    readonly differences: string[];
+    readonly planMoved = true;
+    constructor(member: string, differences: string[]);
+}
+/** The shape a change-set document gives for `member`, when its lexicon supplies none. */
+export declare function shapeFromChangeSet(doc: ChangeSetDocument, member: string, inputs?: {
+    unknownInputs?: string[];
+    knownInputs?: Record<string, unknown>;
+}): PlanShape;
+/** What a round was covered by, as the report records it (`PrRound.covered`). */
+export interface RoundCover {
+    /** The digest of the first approval, which the coverage is bound to. */
+    digest: string;
+    /** The inputs the first plan marked unknown and this round planned with a value, `<component>.<output>`, sorted. */
+    filledInputs: string[];
+}
+export type RoundCoverage = ({
+    covered: true;
+} & RoundCover) | {
+    covered: false;
+    reason: string;
+};
+/** One side of the comparison: a plan set, as far as coverage needs it. */
+export interface CoverageSide {
+    doc: ChangeSetDocument;
+    /** Per member, its component and (first plan only) the inputs it was previewed without. */
+    members: {
+        member: string;
+        component: string;
+        unknownInputs?: string[];
+    }[];
+    /** Shapes a lexicon supplied, by member. Where absent, the change set gives the shape. */
+    shapes?: Record<string, PlanShape>;
+}
+export interface CoveredRoundInput {
+    /** The first plan, whose approval is being relied on. */
+    approved: CoverageSide;
+    /** The digest that approval binds: the report's `digest`. */
+    approvedDigest: string;
+    /** The round's fresh plan. */
+    fresh: CoverageSide;
+    /**
+     * Known inputs that changed between the first plan and the round, as
+     * `<component>.<output>`: an input the first plan read with a value that
+     * stands as another one now. Core reads them from the outputs.
+     */
+    changedKnown?: ReadonlyMap<string, string[]> | Record<string, string[]>;
+    /** The check on the change set's own attributes, per member (`planCoveredBy`). */
+    attributes?: (member: string) => string | undefined;
+}
+/**
+ * Whether the approval of `approvedDigest` covers `fresh`. Covered, the
+ * result names the digest and the inputs that were filled in; not covered,
+ * the reason, which the apply reports with the approval it asks for.
+ */
+export declare function coveredRound(input: CoveredRoundInput): RoundCoverage;
+//# sourceMappingURL=covered-round.d.ts.map

package/dist/components/covered-round.d.ts.map

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

package/dist/components/covered-round.js

@@ -0,0 +1,200 @@
+/**
+ * Covered rounds (#4419): a round planned after an upstream applied is
+ * covered by the pull request's first approval when it does only what that
+ * approval previewed.
+ *
+ * A member that reads an output an upstream in the same change has not
+ * created yet is previewed with a hole: the input is marked unknown
+ * (`PrMember.unknownInputs`). Once the upstream applied, the apply plans the
+ * member again with the real value. That fresh plan is covered when
+ *
+ * - it touches only components the first plan previewed,
+ * - within each, only the logical ids and actions previewed (and no
+ *   replacement the preview did not show), and
+ * - the only inputs that differ are the ones the preview marked unknown.
+ *
+ * A lexicon that can say more than the change set's entries (CloudFormation
+ * previews the member with placeholder parameters and reads the real change
+ * set afterwards) supplies a {@link PlanShape} on its `CapabilityPlan`.
+ * Core decides coverage; the lexicon only reports what it planned.
+ *
+ * A shape may go below the entry, to the properties a change touches and the
+ * ones an unknown input drives. Where it does, a property may drop out when
+ * an unknown input drives it (the real value turned out equal to the current
+ * one), and never otherwise, and a property may never be added.
+ *
+ * Coverage binds to the digest of the first approval. {@link coveredRound}
+ * takes that digest and records it, so a round planned for a different
+ * composition never counts as covered by an approval of another one.
+ */
+import { computePlanDigest } from "../lifecycle/plan-digest.js";
+const SKIPPED = new Set(["no-op", "read"]);
+const REPLACEMENT_RANK = { false: 0, conditional: 1, true: 2 };
+/** An entry with property detail is compared whatever its action: a lexicon that lists properties means it. */
+const skipped = (e) => SKIPPED.has(e.action) && e.properties === undefined;
+/**
+ * Every way `fresh` goes beyond `previewed`, as reasons; none means covered.
+ * Both are shapes of the same member.
+ *
+ * The fresh plan may match the preview exactly, or be narrower where an
+ * unknown input drives it: a property whose real value equals the current one
+ * drops out, a replacement that depended on a stand-in may not happen. It
+ * may never add a resource, add a property, change an action or a type,
+ * replace more than previewed, read an input that is still unknown, or read a
+ * known input as another value.
+ */
+export function planShapeDifferences(previewed, fresh) {
+    const member = fresh.member;
+    const out = [];
+    const was = new Map(previewed.entries.map((e) => [e.logicalId, e]));
+    const now = new Set();
+    for (const e of fresh.entries) {
+        if (skipped(e))
+            continue;
+        now.add(e.logicalId);
+        const p = was.get(e.logicalId);
+        if (!p) {
+            out.push(`${member} now plans to ${e.action} ${e.logicalId}, which the first plan did not`);
+            continue;
+        }
+        if (p.action !== e.action)
+            out.push(`${member} now plans to ${e.action} ${e.logicalId}, where the first plan showed ${p.action}`);
+        if (p.type !== undefined && e.type !== undefined && p.type !== e.type)
+            out.push(`${member} now has ${e.logicalId} as ${e.type}, where the first plan showed ${p.type}`);
+        if (p.properties && e.properties) {
+            const extra = e.properties.filter((x) => !p.properties.includes(x));
+            if (extra.length > 0)
+                out.push(`${member} now also changes ${extra.join(", ")} on ${e.logicalId}`);
+            const driven = p.unknown ?? [];
+            const lost = p.properties.filter((x) => !driven.includes(x) && !e.properties.includes(x));
+            if (lost.length > 0)
+                out.push(`${member} no longer changes ${lost.join(", ")} on ${e.logicalId}, which no unknown input drives`);
+        }
+        if (e.replacement === "true" && p.replacement !== "true" && p.replacement !== "conditional") {
+            out.push(`${member} now replaces ${e.logicalId}, which the first plan did not show`);
+        }
+        else if (e.replacement === "conditional" && p.replacement !== "conditional" && p.replacement !== "true") {
+            out.push(`${member} may now replace ${e.logicalId}, which the first plan did not show`);
+        }
+        else if (e.replacement && p.replacement && p.unknown?.length === 0 && REPLACEMENT_RANK[e.replacement] < REPLACEMENT_RANK[p.replacement]) {
+            out.push(`${member} replacement of ${e.logicalId} was ${p.replacement}, now ${e.replacement}, and no unknown input drives it`);
+        }
+    }
+    // A previewed change that is gone: allowed only where unknown inputs drive all of it.
+    for (const p of previewed.entries) {
+        if (now.has(p.logicalId) || skipped(p) || !p.properties)
+            continue;
+        const driven = p.unknown ?? [];
+        if (!(p.properties.length > 0 && p.properties.every((x) => driven.includes(x)))) {
+            out.push(`${member} no longer plans to ${p.action} ${p.logicalId}, which the first plan did and no unknown input drives`);
+        }
+    }
+    const unknown = new Set(previewed.unknownInputs);
+    const stillUnknown = fresh.unknownInputs[0];
+    if (stillUnknown)
+        out.push(`${member} still reads ${stillUnknown}, which is not known yet`);
+    for (const [ref, value] of Object.entries(fresh.knownInputs ?? {})) {
+        if (unknown.has(ref))
+            continue;
+        if (!previewed.knownInputs)
+            continue;
+        if (!(ref in previewed.knownInputs))
+            out.push(`${member} now reads ${ref}, which the first plan did not`);
+        else if (JSON.stringify(previewed.knownInputs[ref] ?? null) !== JSON.stringify(value ?? null)) {
+            out.push(`${member} now reads ${ref} as a different value than the first plan`);
+        }
+    }
+    return out;
+}
+/**
+ * Why `fresh` is not covered by `previewed`, or `undefined` when it is: the
+ * first of {@link planShapeDifferences}.
+ */
+export function planShapeCovers(previewed, fresh) {
+    return planShapeDifferences(previewed, fresh)[0];
+}
+/** A shape in the order that makes equal shapes digest equal. */
+export function normalizePlanShape(shape) {
+    const sorted = (xs) => [...new Set(xs)].sort();
+    return {
+        member: shape.member,
+        entries: shape.entries
+            .map((e) => ({
+            logicalId: e.logicalId,
+            action: e.action,
+            ...(e.replacement ? { replacement: e.replacement } : {}),
+            ...(e.type !== undefined ? { type: e.type } : {}),
+            ...(e.properties ? { properties: sorted(e.properties) } : {}),
+            ...(e.unknown ? { unknown: sorted(e.unknown) } : {}),
+        }))
+            .sort((a, b) => a.logicalId.localeCompare(b.logicalId) || a.action.localeCompare(b.action)),
+        unknownInputs: sorted(shape.unknownInputs),
+        ...(shape.knownInputs ? { knownInputs: shape.knownInputs } : {}),
+    };
+}
+export function planShapeDigest(shape) {
+    return computePlanDigest("plan-shape", normalizePlanShape(shape));
+}
+/**
+ * Thrown by a member's `run` when the change it created is not covered by the
+ * shape previewed. The change set is deleted unexecuted. `planMoved` is
+ * core's mark for a moved plan, so the command that applied it exits 3.
+ */
+export class PlanShapeMovedError extends Error {
+    constructor(member, differences) {
+        super(`"${member}": refusing to apply. The change differs from the preview that was approved: ${differences.join("; ")}. Plan it again.`);
+        this.member = member;
+        this.differences = differences;
+        this.planMoved = true;
+        this.name = "PlanShapeMovedError";
+    }
+}
+/** The shape a change-set document gives for `member`, when its lexicon supplies none. */
+export function shapeFromChangeSet(doc, member, inputs = {}) {
+    return {
+        member,
+        entries: doc.entries
+            .filter((e) => e.member === member)
+            .map((e) => ({ logicalId: e.deposed ? `${e.address}#${e.deposed}` : e.address, action: e.action })),
+        unknownInputs: [...(inputs.unknownInputs ?? [])].sort(),
+        ...(inputs.knownInputs ? { knownInputs: inputs.knownInputs } : {}),
+    };
+}
+/**
+ * Whether the approval of `approvedDigest` covers `fresh`. Covered, the
+ * result names the digest and the inputs that were filled in; not covered,
+ * the reason, which the apply reports with the approval it asks for.
+ */
+export function coveredRound(input) {
+    const { approved, fresh } = input;
+    const previewedComponents = new Set(approved.members.map((m) => m.component));
+    const approvedMember = new Map(approved.members.map((m) => [m.member, m]));
+    const filled = new Set();
+    for (const m of fresh.members) {
+        if (!previewedComponents.has(m.component))
+            return { covered: false, reason: `${m.component} was not in the first plan` };
+        const was = approvedMember.get(m.member);
+        if (!was)
+            return { covered: false, reason: `${m.member} was not in the first plan` };
+        if (was.component !== m.component)
+            return { covered: false, reason: `${m.member} moved from ${was.component} to ${m.component}` };
+        const previewed = approved.shapes?.[m.member] ?? shapeFromChangeSet(approved.doc, m.member, { unknownInputs: was.unknownInputs });
+        const both = [...new Set([...(previewed.unknownInputs ?? []), ...(was.unknownInputs ?? [])])];
+        // A lexicon that only knows the upstream stack lists the bare component; the member names the output. Keep the named one.
+        const unknownInputs = both.filter((ref) => !both.some((other) => other.startsWith(`${ref}.`))).sort();
+        const now = fresh.shapes?.[m.member] ?? shapeFromChangeSet(fresh.doc, m.member);
+        const reason = planShapeCovers({ ...previewed, unknownInputs }, now);
+        if (reason)
+            return { covered: false, reason };
+        const changed = (input.changedKnown instanceof Map ? input.changedKnown.get(m.component) : input.changedKnown?.[m.component]) ?? [];
+        const changedKnown = changed.filter((ref) => !unknownInputs.includes(ref));
+        if (changedKnown.length > 0)
+            return { covered: false, reason: `${m.member} reads ${changedKnown.join(", ")}, which the first plan read as another value` };
+        const attrs = input.attributes?.(m.member);
+        if (attrs)
+            return { covered: false, reason: attrs };
+        for (const ref of unknownInputs)
+            filled.add(ref);
+    }
+    return { covered: true, digest: input.approvedDigest, filledInputs: [...filled].sort() };
+}

package/dist/components/declared-reads.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Reads a capability finds in the files its steps name (#4466).
+ *
+ * A read core can see is a `stackOutput()` or `@<component>.publish.*`
+ * reference in a step. A CloudFormation template that imports another
+ * stack's export reads that stack too, but the read sits inside the
+ * template. A capability that can find such reads says so through
+ * `Capability.declaredReads`, and {@link withDeclaredReads} writes each one
+ * into the reader's step as the `stackOutput()` reference a person would have
+ * written, plus a `dependsOn` on the upstream. From there on it is an ordinary
+ * read: it orders the fan-out, it is named under `unknownInputs` while the
+ * upstream's plan cannot say the value, and a reader whose plan read another
+ * value than the upstream applied is held for a round.
+ */
+import type { CapabilityRegistry, DeclaredRead } from "./capability.js";
+import type { DriverComponent } from "./driver.js";
+/** A declared read with the kind of the step it names. */
+export type PlacedRead = DeclaredRead & {
+    index: number;
+    kind: string;
+};
+/**
+ * Each capability's declared reads among `components` (#4466): every read a
+ * capability with `declaredReads` reports between two components of the
+ * project, its own reads of itself left out. A capability that throws
+ * reports none.
+ */
+export declare function declaredReadsOf(components: readonly DriverComponent[], registry: CapabilityRegistry, root: string): Promise<PlacedRead[]>;
+/**
+ * `components` with each declared read written in (#4466): the reader's
+ * step gets `{ stackOutput: { stack: upstream, name: output } }` at the
+ * read's place, unless something sits there already, and the reader depends
+ * on the upstream. Components no read names come back as they were.
+ */
+export declare function applyDeclaredReads(components: readonly DriverComponent[], reads: readonly PlacedRead[]): DriverComponent[];
+/** {@link declaredReadsOf} and {@link applyDeclaredReads} in one: `components` with their declared reads written in. */
+export declare function withDeclaredReads(components: readonly DriverComponent[], registry: CapabilityRegistry, root: string): Promise<DriverComponent[]>;
+//# sourceMappingURL=declared-reads.d.ts.map

package/dist/components/declared-reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-reads.d.ts","sourceRoot":"","sources":["../../src/components/declared-reads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAsB,MAAM,cAAc,CAAC;AACzF,OAAO,KAAK,EAAE,eAAe,EAA2B,MAAM,UAAU,CAAC;AAGzE,0DAA0D;AAC1D,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAmCxE;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,QAAQ,EAAE,kBAAkB,EAC5B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,UAAU,EAAE,CAAC,CA6BvB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,EAAE,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,eAAe,EAAE,CAyB1H;AAED,wHAAwH;AACxH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,EAAE,QAAQ,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAGtJ"}