@flanksource/clicky-ui 0.3.34 → 0.3.36

package/dist/data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../src/data.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../src/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EACL,KAAK,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,YAAY,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,wBAAwB,GAC9B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,EAC/B,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,GACxB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,SAAS,EACT,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,kBAAkB,EAClB,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,4BAA4B,EAC5B,6BAA6B,EAC7B,qBAAqB,EACrB,KAAK,oBAAoB,GAC1B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,YAAY,EACZ,yBAAyB,EACzB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,SAAS,EACT,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,UAAU,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,YAAY,EACZ,KAAK,eAAe,EACpB,KAAK,aAAa,GACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EACL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,cAAc,GACpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,SAAS,GACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5F,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACnF,OAAO,EACL,UAAU,EACV,eAAe,EACf,eAAe,EACf,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,UAAU,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EACL,IAAI,EACJ,SAAS,EACT,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,GACzB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAClG,OAAO,EACL,YAAY,EACZ,YAAY,IAAI,aAAa,EAC7B,eAAe,EACf,oBAAoB,EACpB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,IAAI,kBAAkB,EAC5C,KAAK,yBAAyB,GAC/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,YAAY,EACZ,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,GAChC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,UAAU,EACV,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EACL,SAAS,EACT,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,sBAAsB,EACtB,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,mBAAmB,GACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjF,cAAc,sBAAsB,CAAC;AACrC,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,+BAA+B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,GACjC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,KAAK,qBAAqB,GAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,KAAK,qBAAqB,GAC3B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,EACL,eAAe,EACf,KAAK,oBAAoB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,UAAU,EACV,QAAQ,EACR,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,QAAQ,GACd,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,YAAY,EACZ,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,iBAAiB,GACvB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,kBAAkB,EAClB,KAAK,uBAAuB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,cAAc,EACd,KAAK,mBAAmB,EACxB,KAAK,aAAa,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,iBAAiB,EACjB,KAAK,sBAAsB,GAC5B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,0BAA0B,EAC1B,iBAAiB,EACjB,0BAA0B,EAC1B,uBAAuB,EACvB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC5H,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,GAC1B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,gBAAgB,GACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EACL,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,WAAW,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,KAAK,eAAe,GACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAClG,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACpF,OAAO,EAAE,QAAQ,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAClF,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,+BAA+B,EAC/B,oBAAoB,EACpB,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,KAAK,mBAAmB,GACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,cAAc,sBAAsB,CAAC;AACrC,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,cAAc,EACd,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EACL,cAAc,EACd,cAAc,EACd,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,cAAc,GACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,eAAe,EACf,cAAc,EACd,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,WAAW,GACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EACL,aAAa,EACb,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,GAC7B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,KAAK,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAC1F,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EACL,UAAU,EACV,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAChG,OAAO,EACL,sBAAsB,EACtB,KAAK,2BAA2B,GACjC,MAAM,2CAA2C,CAAC;AACnD,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,UAAU,GAChB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,iBAAiB,GACvB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,aAAa,EACb,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,GAC5B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,GACxB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,aAAa,GACd,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,iBAAiB,GAClB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,cAAc,EACd,KAAK,WAAW,GACjB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EACL,UAAU,EACV,KAAK,eAAe,EACpB,KAAK,wBAAwB,GAC9B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,GACtB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,KAAK,iBAAiB,GACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,gBAAgB,EAChB,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,qBAAqB,GAC3B,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACnE,YAAY,EACV,QAAQ,EACR,UAAU,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,OAAO,EACP,SAAS,EACT,MAAM,EACN,WAAW,GACZ,MAAM,kBAAkB,CAAC"}

package/dist/data.js

@@ -76,6 +76,11 @@ import { Timeline } from "./data/Timeline.js";
 import { DEBUG_CAPTURE_HEADER, DEBUG_REFRESH_INSPECTION_HEADER, debugCaptureHeaders, debugConsoleAvailable, debugConsoleOpen, registerDebugConsole, revealDebugConsole, setDebugCaptureLevel, setDebugConsoleOpen, setDebugRefreshInspection, subscribeToDebugConsole } from "./data/debugConsoleSignal.js";
 import { useDebugAction } from "./data/useDebugAction.js";
 import { allGroupsTerminal, isTerminalStatus } from "./data/TaskSnapshot.js";
+import { TaskStreamTabs } from "./data/TaskStreamTabs.js";
+import { TaskMetadataChips } from "./data/TaskHeaderExtras.js";
+import { TaskMetadata } from "./data/TaskProcessMetadata.js";
+import { isFlatMetadata, isMetadataLink, metadataEntries } from "./data/task-metadata.js";
+import { applyTaskOutputDelta, emptyTaskStreams, withTaskStreams } from "./data/task-streams.js";
 import { bucketTasks, logLevelColor, taskSegments, taskStatusBg, taskStatusColor, taskStatusIcon } from "./data/task-status.js";
 import { isFailedOrWarn, taskGroupErrorCount, taskGroupErrors, taskGroupJson, taskGroupMarkdown, taskMarkdown } from "./data/task-copy.js";
 import { TaskProgress } from "./data/TaskProgress.js";
@@ -556,7 +561,10 @@ export {
   TagList,
   TaskManager,
   TaskManagerButton,
+  TaskMetadata,
+  TaskMetadataChips,
   TaskProgress,
+  TaskStreamTabs,
   TestAttempts,
   TestDetailPanel,
   TestFailureDetail,
@@ -1201,6 +1209,7 @@ export {
   answerPrompt,
   applyFixtureFrontmatterRaw,
   applyFixtureFrontmatterState,
+  applyTaskOutputDelta,
   assertCalloutValue,
   assignAxes,
   badgeVariants,
@@ -1236,6 +1245,7 @@ export {
   decodeFilterState,
   deriveProgressBars,
   detectDumpFormat,
+  emptyTaskStreams,
   emptyTestFilters,
   emptyVerifySummary,
   encodeFilterState,
@@ -1270,8 +1280,10 @@ export {
   inferColumns,
   isApplicationStackFrame,
   isFailedOrWarn,
+  isFlatMetadata,
   isGroupCollapsedByDefault,
   isLeaf,
+  isMetadataLink,
   isRuntimeFrame,
   isTerminalStatus,
   latestOf,
@@ -1279,6 +1291,7 @@ export {
   markdownDocumentStats,
   matchesFilterState,
   mergeSeries,
+  metadataEntries,
   mockMarkdownPreview,
   modeToFormat,
   normalizeErrorDiagnostics,
@@ -1357,6 +1370,7 @@ export {
   verificationAdapters,
   verifyReportCounts,
   verifyReportTests,
+  withTaskStreams,
   workloadKindLabel,
   workloadStatusLabel,
   workloadStatusTone

package/dist/data.js.map

@@ -1 +1 @@
-{"version":3,"file":"data.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"data.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/expressions/lang/attributes.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const environment = require("./environment.cjs");
+function celAttributes(spec) {
+  const global = [];
+  const member = [];
+  for (const fn of spec.functions) {
+    if (fn.memberOnly) member.push(fn.name);
+    else global.push(leafOf(fn.name));
+  }
+  return {
+    // `true`/`false`/`null` are constants, and colouring them as keywords too
+    // would let whichever rule ran first decide.
+    keywords: spec.keywords.filter((word) => !CONSTANTS.includes(word)),
+    constants: [...CONSTANTS],
+    typeKeywords: spec.types,
+    macros: spec.macros.map((macro) => macro.name),
+    namespaces: spec.namespaces,
+    globalFunctions: global,
+    memberFunctions: member
+  };
+}
+function goTemplateAttributes(spec) {
+  return {
+    keywords: spec.keywords,
+    builtins: spec.builtins,
+    namespaces: spec.namespaces,
+    functions: spec.functions.filter((fn) => !fn.namespace).map((fn) => fn.name)
+  };
+}
+function attributesFor(languageId, spec) {
+  switch (environment.pathFlavour(languageId)) {
+    case "cel":
+      return normalize(celAttributes(spec.cel));
+    case "gotemplate":
+      return normalize(goTemplateAttributes(spec.gotemplate));
+    default:
+      return null;
+  }
+}
+const CONSTANTS = ["true", "false", "null"];
+function normalize(attributes) {
+  const out = {};
+  for (const [name, words] of Object.entries(attributes)) {
+    out[name] = [...new Set(words)].sort();
+  }
+  return out;
+}
+function leafOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot < 0 ? name : name.slice(dot + 1);
+}
+exports.attributesFor = attributesFor;
+exports.celAttributes = celAttributes;
+exports.goTemplateAttributes = goTemplateAttributes;
+//# sourceMappingURL=attributes.cjs.map

package/dist/expressions/lang/attributes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.cjs","sources":["../../../src/expressions/lang/attributes.ts"],"sourcesContent":["import type { CelSpec, GoTemplateSpec, GomplateSpec } from \"./types\";\nimport { pathFlavour } from \"./environment\";\n\n/**\n * The Monarch word lists a tokenizer rule refers to as `@name`.\n *\n * The tokenizers themselves are fixed: their rules match any dotted call and\n * then dispatch on these lists (`$1@namespaces`, `$1@globalFunctions`, …). So a\n * host's own `catalog.query` needs no new grammar — only `catalog` in\n * `namespaces` and `query` in `globalFunctions`.\n *\n * This mirrors the derivation in `genmonarch/lang_cel.go` and\n * `lang_gotemplate.go`. `attributes.test.ts` recomputes the generated bundle\n * from the generated spec and asserts the two agree, so the mirror cannot drift\n * silently.\n */\nexport type Attributes = Record<string, string[]>;\n\n/** CEL's word lists, minus `operators`, which comes from the grammar. */\nexport function celAttributes(spec: CelSpec): Attributes {\n  const global: string[] = [];\n  const member: string[] = [];\n  for (const fn of spec.functions) {\n    if (fn.memberOnly) member.push(fn.name);\n    else global.push(leafOf(fn.name));\n  }\n\n  return {\n    // `true`/`false`/`null` are constants, and colouring them as keywords too\n    // would let whichever rule ran first decide.\n    keywords: spec.keywords.filter((word) => !CONSTANTS.includes(word)),\n    constants: [...CONSTANTS],\n    typeKeywords: spec.types,\n    macros: spec.macros.map((macro) => macro.name),\n    namespaces: spec.namespaces,\n    globalFunctions: global,\n    memberFunctions: member,\n  };\n}\n\n/** The go-template word lists, shared by the bare and embedded languages. */\nexport function goTemplateAttributes(spec: GoTemplateSpec): Attributes {\n  return {\n    keywords: spec.keywords,\n    builtins: spec.builtins,\n    namespaces: spec.namespaces,\n    functions: spec.functions.filter((fn) => !fn.namespace).map((fn) => fn.name),\n  };\n}\n\n/** The word lists for one language id, or null where a spec does not drive it. */\nexport function attributesFor(languageId: string, spec: GomplateSpec): Attributes | null {\n  switch (pathFlavour(languageId)) {\n    case \"cel\":\n      return normalize(celAttributes(spec.cel));\n    case \"gotemplate\":\n      return normalize(goTemplateAttributes(spec.gotemplate));\n    default:\n      // JSONPath's vocabulary is the grammar's own, with nothing to extend.\n      return null;\n  }\n}\n\nconst CONSTANTS = [\"true\", \"false\", \"null\"];\n\n/**\n * Sorted and deduplicated, matching `Language.MarshalJSON` on the Go side, so a\n * recomputed list compares equal to a generated one.\n */\nfunction normalize(attributes: Attributes): Attributes {\n  const out: Attributes = {};\n  for (const [name, words] of Object.entries(attributes)) {\n    out[name] = [...new Set(words)].sort();\n  }\n  return out;\n}\n\nfunction leafOf(name: string) {\n  const dot = name.lastIndexOf(\".\");\n  return dot < 0 ? name : name.slice(dot + 1);\n}\n"],"names":["pathFlavour"],"mappings":";;;AAmBO,SAAS,cAAc,MAA2B;AACvD,QAAM,SAAmB,CAAA;AACzB,QAAM,SAAmB,CAAA;AACzB,aAAW,MAAM,KAAK,WAAW;AAC/B,QAAI,GAAG,WAAY,QAAO,KAAK,GAAG,IAAI;AAAA,QACjC,QAAO,KAAK,OAAO,GAAG,IAAI,CAAC;AAAA,EAClC;AAEA,SAAO;AAAA;AAAA;AAAA,IAGL,UAAU,KAAK,SAAS,OAAO,CAAC,SAAS,CAAC,UAAU,SAAS,IAAI,CAAC;AAAA,IAClE,WAAW,CAAC,GAAG,SAAS;AAAA,IACxB,cAAc,KAAK;AAAA,IACnB,QAAQ,KAAK,OAAO,IAAI,CAAC,UAAU,MAAM,IAAI;AAAA,IAC7C,YAAY,KAAK;AAAA,IACjB,iBAAiB;AAAA,IACjB,iBAAiB;AAAA,EAAA;AAErB;AAGO,SAAS,qBAAqB,MAAkC;AACrE,SAAO;AAAA,IACL,UAAU,KAAK;AAAA,IACf,UAAU,KAAK;AAAA,IACf,YAAY,KAAK;AAAA,IACjB,WAAW,KAAK,UAAU,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,EAAE,IAAI,CAAC,OAAO,GAAG,IAAI;AAAA,EAAA;AAE/E;AAGO,SAAS,cAAc,YAAoB,MAAuC;AACvF,UAAQA,YAAAA,YAAY,UAAU,GAAA;AAAA,IAC5B,KAAK;AACH,aAAO,UAAU,cAAc,KAAK,GAAG,CAAC;AAAA,IAC1C,KAAK;AACH,aAAO,UAAU,qBAAqB,KAAK,UAAU,CAAC;AAAA,IACxD;AAEE,aAAO;AAAA,EAAA;AAEb;AAEA,MAAM,YAAY,CAAC,QAAQ,SAAS,MAAM;AAM1C,SAAS,UAAU,YAAoC;AACrD,QAAM,MAAkB,CAAA;AACxB,aAAW,CAAC,MAAM,KAAK,KAAK,OAAO,QAAQ,UAAU,GAAG;AACtD,QAAI,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC,EAAE,KAAA;AAAA,EAClC;AACA,SAAO;AACT;AAEA,SAAS,OAAO,MAAc;AAC5B,QAAM,MAAM,KAAK,YAAY,GAAG;AAChC,SAAO,MAAM,IAAI,OAAO,KAAK,MAAM,MAAM,CAAC;AAC5C;;;;"}

package/dist/expressions/lang/attributes.d.ts

@@ -0,0 +1,22 @@
+import { CelSpec, GoTemplateSpec, GomplateSpec } from './types';
+/**
+ * The Monarch word lists a tokenizer rule refers to as `@name`.
+ *
+ * The tokenizers themselves are fixed: their rules match any dotted call and
+ * then dispatch on these lists (`$1@namespaces`, `$1@globalFunctions`, …). So a
+ * host's own `catalog.query` needs no new grammar — only `catalog` in
+ * `namespaces` and `query` in `globalFunctions`.
+ *
+ * This mirrors the derivation in `genmonarch/lang_cel.go` and
+ * `lang_gotemplate.go`. `attributes.test.ts` recomputes the generated bundle
+ * from the generated spec and asserts the two agree, so the mirror cannot drift
+ * silently.
+ */
+export type Attributes = Record<string, string[]>;
+/** CEL's word lists, minus `operators`, which comes from the grammar. */
+export declare function celAttributes(spec: CelSpec): Attributes;
+/** The go-template word lists, shared by the bare and embedded languages. */
+export declare function goTemplateAttributes(spec: GoTemplateSpec): Attributes;
+/** The word lists for one language id, or null where a spec does not drive it. */
+export declare function attributesFor(languageId: string, spec: GomplateSpec): Attributes | null;
+//# sourceMappingURL=attributes.d.ts.map

package/dist/expressions/lang/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/expressions/lang/attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGrE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;AAElD,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAmBvD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU,CAOrE;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,UAAU,GAAG,IAAI,CAUvF"}

package/dist/expressions/lang/attributes.js

@@ -0,0 +1,56 @@
+import { pathFlavour } from "./environment.js";
+function celAttributes(spec) {
+  const global = [];
+  const member = [];
+  for (const fn of spec.functions) {
+    if (fn.memberOnly) member.push(fn.name);
+    else global.push(leafOf(fn.name));
+  }
+  return {
+    // `true`/`false`/`null` are constants, and colouring them as keywords too
+    // would let whichever rule ran first decide.
+    keywords: spec.keywords.filter((word) => !CONSTANTS.includes(word)),
+    constants: [...CONSTANTS],
+    typeKeywords: spec.types,
+    macros: spec.macros.map((macro) => macro.name),
+    namespaces: spec.namespaces,
+    globalFunctions: global,
+    memberFunctions: member
+  };
+}
+function goTemplateAttributes(spec) {
+  return {
+    keywords: spec.keywords,
+    builtins: spec.builtins,
+    namespaces: spec.namespaces,
+    functions: spec.functions.filter((fn) => !fn.namespace).map((fn) => fn.name)
+  };
+}
+function attributesFor(languageId, spec) {
+  switch (pathFlavour(languageId)) {
+    case "cel":
+      return normalize(celAttributes(spec.cel));
+    case "gotemplate":
+      return normalize(goTemplateAttributes(spec.gotemplate));
+    default:
+      return null;
+  }
+}
+const CONSTANTS = ["true", "false", "null"];
+function normalize(attributes) {
+  const out = {};
+  for (const [name, words] of Object.entries(attributes)) {
+    out[name] = [...new Set(words)].sort();
+  }
+  return out;
+}
+function leafOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot < 0 ? name : name.slice(dot + 1);
+}
+export {
+  attributesFor,
+  celAttributes,
+  goTemplateAttributes
+};
+//# sourceMappingURL=attributes.js.map

package/dist/expressions/lang/attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.js","sources":["../../../src/expressions/lang/attributes.ts"],"sourcesContent":["import type { CelSpec, GoTemplateSpec, GomplateSpec } from \"./types\";\nimport { pathFlavour } from \"./environment\";\n\n/**\n * The Monarch word lists a tokenizer rule refers to as `@name`.\n *\n * The tokenizers themselves are fixed: their rules match any dotted call and\n * then dispatch on these lists (`$1@namespaces`, `$1@globalFunctions`, …). So a\n * host's own `catalog.query` needs no new grammar — only `catalog` in\n * `namespaces` and `query` in `globalFunctions`.\n *\n * This mirrors the derivation in `genmonarch/lang_cel.go` and\n * `lang_gotemplate.go`. `attributes.test.ts` recomputes the generated bundle\n * from the generated spec and asserts the two agree, so the mirror cannot drift\n * silently.\n */\nexport type Attributes = Record<string, string[]>;\n\n/** CEL's word lists, minus `operators`, which comes from the grammar. */\nexport function celAttributes(spec: CelSpec): Attributes {\n  const global: string[] = [];\n  const member: string[] = [];\n  for (const fn of spec.functions) {\n    if (fn.memberOnly) member.push(fn.name);\n    else global.push(leafOf(fn.name));\n  }\n\n  return {\n    // `true`/`false`/`null` are constants, and colouring them as keywords too\n    // would let whichever rule ran first decide.\n    keywords: spec.keywords.filter((word) => !CONSTANTS.includes(word)),\n    constants: [...CONSTANTS],\n    typeKeywords: spec.types,\n    macros: spec.macros.map((macro) => macro.name),\n    namespaces: spec.namespaces,\n    globalFunctions: global,\n    memberFunctions: member,\n  };\n}\n\n/** The go-template word lists, shared by the bare and embedded languages. */\nexport function goTemplateAttributes(spec: GoTemplateSpec): Attributes {\n  return {\n    keywords: spec.keywords,\n    builtins: spec.builtins,\n    namespaces: spec.namespaces,\n    functions: spec.functions.filter((fn) => !fn.namespace).map((fn) => fn.name),\n  };\n}\n\n/** The word lists for one language id, or null where a spec does not drive it. */\nexport function attributesFor(languageId: string, spec: GomplateSpec): Attributes | null {\n  switch (pathFlavour(languageId)) {\n    case \"cel\":\n      return normalize(celAttributes(spec.cel));\n    case \"gotemplate\":\n      return normalize(goTemplateAttributes(spec.gotemplate));\n    default:\n      // JSONPath's vocabulary is the grammar's own, with nothing to extend.\n      return null;\n  }\n}\n\nconst CONSTANTS = [\"true\", \"false\", \"null\"];\n\n/**\n * Sorted and deduplicated, matching `Language.MarshalJSON` on the Go side, so a\n * recomputed list compares equal to a generated one.\n */\nfunction normalize(attributes: Attributes): Attributes {\n  const out: Attributes = {};\n  for (const [name, words] of Object.entries(attributes)) {\n    out[name] = [...new Set(words)].sort();\n  }\n  return out;\n}\n\nfunction leafOf(name: string) {\n  const dot = name.lastIndexOf(\".\");\n  return dot < 0 ? name : name.slice(dot + 1);\n}\n"],"names":[],"mappings":";AAmBO,SAAS,cAAc,MAA2B;AACvD,QAAM,SAAmB,CAAA;AACzB,QAAM,SAAmB,CAAA;AACzB,aAAW,MAAM,KAAK,WAAW;AAC/B,QAAI,GAAG,WAAY,QAAO,KAAK,GAAG,IAAI;AAAA,QACjC,QAAO,KAAK,OAAO,GAAG,IAAI,CAAC;AAAA,EAClC;AAEA,SAAO;AAAA;AAAA;AAAA,IAGL,UAAU,KAAK,SAAS,OAAO,CAAC,SAAS,CAAC,UAAU,SAAS,IAAI,CAAC;AAAA,IAClE,WAAW,CAAC,GAAG,SAAS;AAAA,IACxB,cAAc,KAAK;AAAA,IACnB,QAAQ,KAAK,OAAO,IAAI,CAAC,UAAU,MAAM,IAAI;AAAA,IAC7C,YAAY,KAAK;AAAA,IACjB,iBAAiB;AAAA,IACjB,iBAAiB;AAAA,EAAA;AAErB;AAGO,SAAS,qBAAqB,MAAkC;AACrE,SAAO;AAAA,IACL,UAAU,KAAK;AAAA,IACf,UAAU,KAAK;AAAA,IACf,YAAY,KAAK;AAAA,IACjB,WAAW,KAAK,UAAU,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,EAAE,IAAI,CAAC,OAAO,GAAG,IAAI;AAAA,EAAA;AAE/E;AAGO,SAAS,cAAc,YAAoB,MAAuC;AACvF,UAAQ,YAAY,UAAU,GAAA;AAAA,IAC5B,KAAK;AACH,aAAO,UAAU,cAAc,KAAK,GAAG,CAAC;AAAA,IAC1C,KAAK;AACH,aAAO,UAAU,qBAAqB,KAAK,UAAU,CAAC;AAAA,IACxD;AAEE,aAAO;AAAA,EAAA;AAEb;AAEA,MAAM,YAAY,CAAC,QAAQ,SAAS,MAAM;AAM1C,SAAS,UAAU,YAAoC;AACrD,QAAM,MAAkB,CAAA;AACxB,aAAW,CAAC,MAAM,KAAK,KAAK,OAAO,QAAQ,UAAU,GAAG;AACtD,QAAI,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC,EAAE,KAAA;AAAA,EAClC;AACA,SAAO;AACT;AAEA,SAAS,OAAO,MAAc;AAC5B,QAAM,MAAM,KAAK,YAAY,GAAG;AAChC,SAAO,MAAM,IAAI,OAAO,KAAK,MAAM,MAAM,CAAC;AAC5C;"}

package/dist/expressions/lang/completion.cjs

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const hover = require("./hover.cjs");
+const environment = require("./environment.cjs");
+const prefix = require("./prefix.cjs");
+function registerCompletion(monaco, languageId, options) {
+  return monaco.languages.registerCompletionItemProvider(
+    languageId,
+    completionProvider(monaco, languageId, options)
+  );
+}
+function completionProvider(monaco, languageId, { spec, environment: environment2 }) {
+  const items = catalogueItems(monaco, languageId, spec);
+  return {
+    // A dot must retrigger, or `k8s.` offers nothing until another key is hit.
+    triggerCharacters: ["."],
+    provideCompletionItems(model, position) {
+      const suggestions = environmentItems(
+        monaco,
+        model,
+        position,
+        languageId,
+        environment2
+      );
+      const range = wordRange(model, position);
+      for (const item of items) suggestions.push({ ...item, range });
+      return { suggestions };
+    }
+  };
+}
+function catalogueItems(monaco, languageId, spec) {
+  switch (environment.pathFlavour(languageId)) {
+    case "cel":
+      return celCompletionItems(monaco, spec);
+    case "gotemplate":
+      return goTemplateCompletionItems(monaco, spec);
+    default:
+      return [];
+  }
+}
+function environmentItems(monaco, model, position, languageId, environment$1) {
+  if (!environment$1) return [];
+  const document = environment$1();
+  if (document === void 0 || document === null) return [];
+  const prefix$1 = prefix.environmentPrefixAt(model, position, languageId);
+  if (!prefix$1) return [];
+  const parent = environment.resolvePath(document, prefix$1.segments);
+  if (parent === void 0) return [];
+  const kinds = monaco.languages.CompletionItemKind;
+  const range = {
+    startLineNumber: position.lineNumber,
+    endLineNumber: position.lineNumber,
+    startColumn: prefix$1.startColumn,
+    endColumn: prefix$1.endColumn
+  };
+  const typedHead = prefix$1.typed.slice(0, prefix$1.typed.length - prefix$1.leaf.length);
+  const items = [];
+  for (const entry of environment.childEntries(parent)) {
+    const insertText = environment.pathExpression(languageId, [...prefix$1.segments, entry.segment]);
+    if (insertText === null) continue;
+    items.push({
+      label: entry.key,
+      kind: entry.container ? kinds.Folder : kinds.Field,
+      insertText,
+      filterText: `${typedHead}${entry.key}`,
+      detail: `${entry.kind} · ${entry.summary}`,
+      // A key of the document being evaluated beats any catalogue entry: it is
+      // what the author came to the editor to write.
+      sortText: `0${entry.key}`,
+      range
+    });
+  }
+  return items;
+}
+function celCompletionItems(monaco, spec) {
+  const kinds = monaco.languages.CompletionItemKind;
+  const items = [];
+  for (const fn of spec.cel.functions) {
+    items.push(buildFunctionItem(monaco, fn, celInsertText(fn), kinds.Function));
+  }
+  for (const macro of spec.cel.macros) {
+    items.push(buildMacroItem(monaco, macro));
+  }
+  for (const keyword of spec.cel.keywords) {
+    items.push({
+      label: keyword,
+      kind: kinds.Keyword,
+      insertText: keyword,
+      detail: "CEL keyword"
+    });
+  }
+  for (const type of spec.cel.types) {
+    items.push({ label: type, kind: kinds.TypeParameter, insertText: type, detail: "CEL type" });
+  }
+  return items;
+}
+function goTemplateCompletionItems(monaco, spec) {
+  const kinds = monaco.languages.CompletionItemKind;
+  const items = [];
+  for (const fn of spec.gotemplate.functions) {
+    items.push(buildFunctionItem(monaco, fn, fn.name, kinds.Function));
+  }
+  for (const builtin of spec.gotemplate.builtins) {
+    items.push({
+      label: builtin,
+      kind: kinds.Function,
+      insertText: builtin,
+      detail: "text/template builtin"
+    });
+  }
+  for (const keyword of spec.gotemplate.keywords) {
+    items.push({
+      label: keyword,
+      kind: kinds.Keyword,
+      insertText: keyword,
+      detail: "template keyword"
+    });
+  }
+  return items;
+}
+function buildFunctionItem(monaco, fn, insertText, kind) {
+  var _a, _b;
+  const detail = fn.signature ?? ((_b = (_a = fn.overloads) == null ? void 0 : _a[0]) == null ? void 0 : _b.result);
+  return {
+    label: fn.name,
+    kind: fn.memberOnly ? monaco.languages.CompletionItemKind.Method : kind,
+    insertText,
+    ...detail === void 0 ? {} : { detail },
+    documentation: { value: hover.functionDocumentation(fn) },
+    filterText: fn.name,
+    // Un-namespaced names first: they are the short, common ones, and a
+    // namespace is easy to reach by typing its prefix.
+    sortText: fn.namespace ? `2${fn.name}` : `1${fn.name}`
+  };
+}
+function buildMacroItem(monaco, macro) {
+  return {
+    label: macro.name,
+    kind: monaco.languages.CompletionItemKind.Keyword,
+    insertText: macro.name,
+    detail: `macro (${macro.argCount === 0 ? "variadic" : `${macro.argCount} args`})`,
+    documentation: { value: hover.macroDocumentation(macro) },
+    filterText: macro.name,
+    sortText: `1${macro.name}`
+  };
+}
+function celInsertText(fn) {
+  var _a, _b, _c, _d;
+  const arity = ((_b = (_a = fn.overloads) == null ? void 0 : _a[0]) == null ? void 0 : _b.args.length) ?? 0;
+  const receiver = ((_d = (_c = fn.overloads) == null ? void 0 : _c[0]) == null ? void 0 : _d.member) ? 1 : 0;
+  return arity - receiver === 0 ? `${fn.name}()` : `${fn.name}(`;
+}
+function wordRange(model, position) {
+  const word = model.getWordUntilPosition(position);
+  return {
+    startLineNumber: position.lineNumber,
+    endLineNumber: position.lineNumber,
+    startColumn: word.startColumn,
+    endColumn: word.endColumn
+  };
+}
+exports.completionProvider = completionProvider;
+exports.registerCompletion = registerCompletion;
+//# sourceMappingURL=completion.cjs.map

package/dist/expressions/lang/completion.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.cjs","sources":["../../../src/expressions/lang/completion.ts"],"sourcesContent":["import type * as monaco from \"monaco-editor\";\nimport type { GomplateSpec, Monaco, SpecFunction, SpecMacro } from \"./types\";\nimport { functionDocumentation, macroDocumentation } from \"./hover\";\nimport { childEntries, pathExpression, pathFlavour, resolvePath } from \"./environment\";\nimport { environmentPrefixAt } from \"./prefix\";\n\n/** Supplies the document expressions are evaluated against, on every request. */\nexport type EnvironmentSource = () => unknown;\n\nexport interface CompletionOptions {\n  /** The catalogue to complete from — gomplate's, or a host's merged over it. */\n  spec: GomplateSpec;\n  environment?: EnvironmentSource | undefined;\n}\n\n/**\n * Registers completion for one language.\n *\n * The catalogue half is built once per registration, so a host that supplies\n * its own spec re-registers rather than mutating in place. The document half is\n * rebuilt per request, because the document is being edited alongside the\n * expression.\n */\nexport function registerCompletion(\n  monaco: Monaco,\n  languageId: string,\n  options: CompletionOptions,\n) {\n  return monaco.languages.registerCompletionItemProvider(\n    languageId,\n    completionProvider(monaco, languageId, options),\n  );\n}\n\n/**\n * The provider `registerCompletion` installs, exposed so it can be driven\n * directly by a test over a real model rather than through Monaco's registry.\n */\nexport function completionProvider(\n  monaco: Monaco,\n  languageId: string,\n  { spec, environment }: CompletionOptions,\n) {\n  const items = catalogueItems(monaco, languageId, spec);\n  return {\n    // A dot must retrigger, or `k8s.` offers nothing until another key is hit.\n    triggerCharacters: [\".\"],\n    provideCompletionItems(model: monaco.editor.ITextModel, position: monaco.Position) {\n      const suggestions: monaco.languages.CompletionItem[] = environmentItems(\n        monaco,\n        model,\n        position,\n        languageId,\n        environment,\n      );\n      const range = wordRange(model, position);\n      for (const item of items) suggestions.push({ ...item, range });\n      return { suggestions };\n    },\n  };\n}\n\n/**\n * A completion item without its range. The range depends on the cursor, so it\n * is attached per request while the rest of the item is built once.\n */\ntype Item = Omit<monaco.languages.CompletionItem, \"range\">;\n\nfunction catalogueItems(monaco: Monaco, languageId: string, spec: GomplateSpec): Item[] {\n  switch (pathFlavour(languageId)) {\n    case \"cel\":\n      return celCompletionItems(monaco, spec);\n    case \"gotemplate\":\n      return goTemplateCompletionItems(monaco, spec);\n    default:\n      // JSONPath's dialect has no catalogue to generate from; its completions\n      // come entirely from the document.\n      return [];\n  }\n}\n\n/**\n * The keys reachable from the cursor's position in the document.\n *\n * Each item replaces the whole path typed so far with a freshly rendered one,\n * rather than appending to it, so what lands in the editor is always valid in\n * that language — quoting an awkward key, or dropping the suggestion entirely\n * where the language cannot express the path.\n */\nfunction environmentItems(\n  monaco: Monaco,\n  model: monaco.editor.ITextModel,\n  position: monaco.Position,\n  languageId: string,\n  environment: EnvironmentSource | undefined,\n): monaco.languages.CompletionItem[] {\n  if (!environment) return [];\n  const document = environment();\n  if (document === undefined || document === null) return [];\n\n  const prefix = environmentPrefixAt(model, position, languageId);\n  if (!prefix) return [];\n\n  const parent = resolvePath(document, prefix.segments);\n  if (parent === undefined) return [];\n\n  const kinds = monaco.languages.CompletionItemKind;\n  const range = {\n    startLineNumber: position.lineNumber,\n    endLineNumber: position.lineNumber,\n    startColumn: prefix.startColumn,\n    endColumn: prefix.endColumn,\n  };\n\n  // Monaco filters a candidate against the model text from the range start to\n  // the cursor, so `filterText` has to continue what was typed rather than\n  // repeat the rendered path: `pod.items[0]` does not match `pod.items.`, and\n  // the subscripted keys would be filtered straight back out.\n  const typedHead = prefix.typed.slice(0, prefix.typed.length - prefix.leaf.length);\n\n  const items: monaco.languages.CompletionItem[] = [];\n  for (const entry of childEntries(parent)) {\n    const insertText = pathExpression(languageId, [...prefix.segments, entry.segment]);\n    if (insertText === null) continue;\n    items.push({\n      label: entry.key,\n      kind: entry.container ? kinds.Folder : kinds.Field,\n      insertText,\n      filterText: `${typedHead}${entry.key}`,\n      detail: `${entry.kind} · ${entry.summary}`,\n      // A key of the document being evaluated beats any catalogue entry: it is\n      // what the author came to the editor to write.\n      sortText: `0${entry.key}`,\n      range,\n    });\n  }\n  return items;\n}\n\nfunction celCompletionItems(monaco: Monaco, spec: GomplateSpec) {\n  const kinds = monaco.languages.CompletionItemKind;\n  const items: Item[] = [];\n\n  for (const fn of spec.cel.functions) {\n    items.push(buildFunctionItem(monaco, fn, celInsertText(fn), kinds.Function));\n  }\n  for (const macro of spec.cel.macros) {\n    items.push(buildMacroItem(monaco, macro));\n  }\n  for (const keyword of spec.cel.keywords) {\n    items.push({\n      label: keyword,\n      kind: kinds.Keyword,\n      insertText: keyword,\n      detail: \"CEL keyword\",\n    });\n  }\n  for (const type of spec.cel.types) {\n    items.push({ label: type, kind: kinds.TypeParameter, insertText: type, detail: \"CEL type\" });\n  }\n  return items;\n}\n\nfunction goTemplateCompletionItems(monaco: Monaco, spec: GomplateSpec) {\n  const kinds = monaco.languages.CompletionItemKind;\n  const items: Item[] = [];\n\n  for (const fn of spec.gotemplate.functions) {\n    items.push(buildFunctionItem(monaco, fn, fn.name, kinds.Function));\n  }\n  for (const builtin of spec.gotemplate.builtins) {\n    items.push({\n      label: builtin,\n      kind: kinds.Function,\n      insertText: builtin,\n      detail: \"text/template builtin\",\n    });\n  }\n  for (const keyword of spec.gotemplate.keywords) {\n    items.push({\n      label: keyword,\n      kind: kinds.Keyword,\n      insertText: keyword,\n      detail: \"template keyword\",\n    });\n  }\n  return items;\n}\n\nfunction buildFunctionItem(\n  monaco: Monaco,\n  fn: SpecFunction,\n  insertText: string,\n  kind: monaco.languages.CompletionItemKind,\n): Item {\n  // A function with neither a Go signature nor an overload has no detail to\n  // show; the key has to be absent rather than explicitly undefined.\n  const detail = fn.signature ?? fn.overloads?.[0]?.result;\n  return {\n    label: fn.name,\n    kind: fn.memberOnly ? monaco.languages.CompletionItemKind.Method : kind,\n    insertText,\n    ...(detail === undefined ? {} : { detail }),\n    documentation: { value: functionDocumentation(fn) },\n    filterText: fn.name,\n    // Un-namespaced names first: they are the short, common ones, and a\n    // namespace is easy to reach by typing its prefix.\n    sortText: fn.namespace ? `2${fn.name}` : `1${fn.name}`,\n  };\n}\n\nfunction buildMacroItem(monaco: Monaco, macro: SpecMacro): Item {\n  return {\n    label: macro.name,\n    kind: monaco.languages.CompletionItemKind.Keyword,\n    insertText: macro.name,\n    detail: `macro (${macro.argCount === 0 ? \"variadic\" : `${macro.argCount} args`})`,\n    documentation: { value: macroDocumentation(macro) },\n    filterText: macro.name,\n    sortText: `1${macro.name}`,\n  };\n}\n\n/**\n * CEL functions take parentheses; a member-only function is offered without a\n * leading dot because the dot is already typed when completion fires.\n */\nfunction celInsertText(fn: SpecFunction) {\n  const arity = fn.overloads?.[0]?.args.length ?? 0;\n  const receiver = fn.overloads?.[0]?.member ? 1 : 0;\n  return arity - receiver === 0 ? `${fn.name}()` : `${fn.name}(`;\n}\n\nfunction wordRange(\n  model: {\n    getWordUntilPosition(p: { lineNumber: number; column: number }): {\n      startColumn: number;\n      endColumn: number;\n    };\n  },\n  position: { lineNumber: number; column: number },\n) {\n  const word = model.getWordUntilPosition(position);\n  return {\n    startLineNumber: position.lineNumber,\n    endLineNumber: position.lineNumber,\n    startColumn: word.startColumn,\n    endColumn: word.endColumn,\n  };\n}\n"],"names":["environment","pathFlavour","prefix","environmentPrefixAt","resolvePath","childEntries","pathExpression","functionDocumentation","macroDocumentation"],"mappings":"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"}

package/dist/expressions/lang/completion.d.ts

@@ -0,0 +1,29 @@
+import { GomplateSpec, Monaco } from './types';
+import type * as monaco from "monaco-editor";
+/** Supplies the document expressions are evaluated against, on every request. */
+export type EnvironmentSource = () => unknown;
+export interface CompletionOptions {
+    /** The catalogue to complete from — gomplate's, or a host's merged over it. */
+    spec: GomplateSpec;
+    environment?: EnvironmentSource | undefined;
+}
+/**
+ * Registers completion for one language.
+ *
+ * The catalogue half is built once per registration, so a host that supplies
+ * its own spec re-registers rather than mutating in place. The document half is
+ * rebuilt per request, because the document is being edited alongside the
+ * expression.
+ */
+export declare function registerCompletion(monaco: Monaco, languageId: string, options: CompletionOptions): monaco.IDisposable;
+/**
+ * The provider `registerCompletion` installs, exposed so it can be driven
+ * directly by a test over a real model rather than through Monaco's registry.
+ */
+export declare function completionProvider(monaco: Monaco, languageId: string, { spec, environment }: CompletionOptions): {
+    triggerCharacters: string[];
+    provideCompletionItems(model: monaco.editor.ITextModel, position: monaco.Position): {
+        suggestions: monaco.languages.CompletionItem[];
+    };
+};
+//# sourceMappingURL=completion.d.ts.map

package/dist/expressions/lang/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../src/expressions/lang/completion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAA2B,MAAM,SAAS,CAAC;AAK7E,iFAAiF;AACjF,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC;AAE9C,MAAM,WAAW,iBAAiB;IAChC,+EAA+E;IAC/E,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iBAAiB,sBAM3B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,iBAAiB;;kCAMR,MAAM,CAAC,MAAM,CAAC,UAAU,YAAY,MAAM,CAAC,QAAQ;;;EAapF"}