@elaraai/e3-ui 1.0.97 → 1.0.99

package/dist/test/bind/data/data.examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data.examples.d.ts","sourceRoot":"","sources":["../../../../test/bind/data/data.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAAsC;AACtC,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAQ,SAAS,EAAgB,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,UAAU,EAAa,UAAU,EAAc,OAAO,EAAW,MAAM,eAAe,CAAC;AAG7N,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAGlC,eAAO,MAAM,cAAc,uFAAsE,CAAC;AAClG,eAAO,MAAM,mBAAmB;;;;;;sEAAkG,CAAC;AACnI,eAAO,MAAM,UAAU,qFAAgE,CAAC;AACxF,eAAO,MAAM,SAAS,mFAAiE,CAAC;AAWxF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM;;IAEf,2EAA2E;;IAE3E,yBAAyB;;;IAGzB,wEAAwE;;;;;;;;;;;;;;EAG1E,CAAC;AACH,8DAA8D;AAC9D,eAAO,MAAM,OAAO;;IAVhB,2EAA2E;;IAE3E,yBAAyB;;;IAGzB,wEAAwE;;;;;;;;;;;;;;GAKzB,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ;;IA1BjB,2EAA2E;;IAE3E,yBAAyB;;;IAGzB,wEAAwE;;;;;;;;;;;;;;4DAgGxE,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;IAIrB;6DACyD;;;EAG3D,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,YAAY;;;EAAwD,CAAC;AAElF;;;;GAIG;AACH,eAAO,MAAM,UAAU;;;;IAdnB;6DACyD;;;oEAgC1D,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;IAxClB;6DACyD;;;;;;;;CA0C3D,CAAC;AAEH,yHAAyH;AACzH,eAAO,MAAM,eAAe;;;;IA9CxB;6DACyD;;;;;;;;;;YADzD;qEACyD;;;;;;;;YADzD;qEACyD;;;;;;;;;;YADzD;qEACyD;;;;;;;;YADzD;qEACyD;;;;;;;;;;;oBADzD;6EACyD;;;;;;;;oBADzD;6EACyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6CD,CAAC;AAE7D,eAAO,MAAM,aAAa,6CAWxB,CAAC;AAEH,eAAO,MAAM,gBAAgB,6CAoD3B,CAAC;AAEH,eAAO,MAAM,mBAAmB,6CAW9B,CAAC;AAEH,eAAO,MAAM,sBAAsB,6CA2CjC,CAAC;AAEH,eAAO,MAAM,iBAAiB,6CAiG5B,CAAC;AAEH,eAAO,MAAM,qBAAqB,6CAyBhC,CAAC;AAEH,eAAO,MAAM,kBAAkB,6CAmB7B,CAAC;AAOH;;;;;GAKG;AACH,eAAO,MAAM,cAAc,0FAAgE,CAAC;AAE5F,0EAA0E;AAC1E,eAAO,MAAM,OAAO;;;;EAA4E,CAAC;AAEjG;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;IAWxB,CAAC;AAEH,sFAAsF;AACtF,eAAO,MAAM,SAAS;;;;wFAAoD,CAAC;AAE3E,eAAO,MAAM,mBAAmB,6CA+C9B,CAAC;AAIH;;uBAEuB;AACvB,eAAO,MAAM,OAAO;;;;;;GAMjB,CAAC;AAEJ;+CAC+C;AAC/C,eAAO,MAAM,QAAQ;;;;;;iEA4BlB,CAAC;AAEJ,eAAO,MAAM,kBAAkB,6CA0B7B,CAAC;AAIH,4GAA4G;AAC5G,eAAO,MAAM,aAAa,yFAA6D,CAAC;AAExF,iEAAiE;AACjE,eAAO,MAAM,MAAM;;;;EAAgG,CAAC;AAEpH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;IAWvB,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,QAAQ;;;;uFAAiD,CAAC;AAEvE,eAAO,MAAM,kBAAkB,6CA6B7B,CAAC;AAOH,wHAAwH;AACxH,eAAO,MAAM,kBAAkB,oHAE3B,CAAC;AAEL,kGAAkG;AAClG,eAAO,MAAM,aAAa;;;;;;EAAkF,CAAC;AAC7G,eAAO,MAAM,kBAAkB;;;;;;qEAAkG,CAAC;AAElI,2EAA2E;AAC3E,eAAO,MAAM,UAAU;;;;EAA2D,CAAC;AACnF,eAAO,MAAM,sBAAsB;;;;2EAE/B,CAAC;AAEL,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,uGAAmF,CAAC;AAEjH,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,uGAAyE,CAAC;AAExG,8CAA8C;AAC9C,eAAO,MAAM,cAAc;;EAAoC,CAAC;AAChE,kGAAkG;AAClG,eAAO,MAAM,oBAAoB;;wEAE7B,CAAC;AAEL,0FAA0F;AAC1F,eAAO,MAAM,iBAAiB,sHACkH,CAAC;AAEjJ,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,2GAAyF,CAAC;AAE3H;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mHAOpB,CAAC;AAER,mFAAmF;AACnF,eAAO,MAAM,WAAW,kKAA4F,CAAC;AAErH,4CAA4C;AAC5C,eAAO,MAAM,UAAU,8IAAwI,CAAC;AAChK,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,yKAA8D,CAAC;AAE7F,yIAAyI;AACzI,eAAO,MAAM,iBAAiB,yKAe3B,CAAC;AASJ,kGAAkG;AAClG,eAAO,MAAM,aAAa;;;EAAgE,CAAC;AAC3F,6GAA6G;AAC7G,eAAO,MAAM,aAAa;;;uEAIvB,CAAC;AACJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAmC,CAAC;AACnE,eAAO,MAAM,YAAY;;;;;CAA6D,CAAC;AACvF,eAAO,MAAM,aAAa;;;;;CAAgE,CAAC;AAE3F,gGAAgG;AAChG,eAAO,MAAM,aAAa;;;;EAAqG,CAAC;AAChI;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;0EAU1B,CAAC;AACJ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAsC,CAAC;AAEzE,eAAO,MAAM,gBAAgB;;;;;;CAAkE,CAAC;AAChG,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;CAAiH,CAAC;AACpJ,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAA0F,CAAC;AAEvH,8DAA8D;AAC9D,eAAO,MAAM,YAAY;;;EAAkE,CAAC;AAC5F,yCAAyC;AACzC,eAAO,MAAM,YAAY;;;;;;EAA2E,CAAC;AACrG,qIAAqI;AACrI,eAAO,MAAM,aAAa;;;;;;uEAKvB,CAAC;AACJ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAmC,CAAC;AACnE,eAAO,MAAM,qBAAqB;;;;;;;;CAAwE,CAAC;AAC3G,eAAO,MAAM,oBAAoB;;;;;;;;;;CAE/B,CAAC;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;CAGrC,CAAC;AACH,eAAO,MAAM,cAAc;;;;;;;;;;CAGzB,CAAC;AACH,eAAO,MAAM,eAAe;;;;;;;;;;CAG1B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;CAE1B,CAAC;AACH,eAAO,MAAM,cAAc;;;;;;;;CAEzB,CAAC;AACH,eAAO,MAAM,uBAAuB;;;;;;;;CAGlC,CAAC"}
+{"version":3,"file":"data.examples.d.ts","sourceRoot":"","sources":["../../../../test/bind/data/data.examples.tsx"],"names":[],"mappings":"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"}

package/dist/test/bind/data/data.examples.js

@@ -43,8 +43,8 @@ export const OpsRow = StructType({
     load: FloatType,
     state: EventStateType,
 });
-/** One hall's presses (or the delivery vans), keyed by id. */
-export const OpsHall = DictType(StringType, OpsRow);
+/** One hall — its presses (or the delivery vans), a Dict keyed by id, which its series step down into by field. */
+export const OpsHall = StructType({ presses: DictType(StringType, OpsRow) });
 /**
  * The seeded ops schedule — an `e3.input`'s default IS the dataset's initial
  * value, so this is what a freshly-deployed workspace (and the offline
@@ -60,80 +60,80 @@ export const OpsHall = DictType(StringType, OpsRow);
  * estimated ahead of it.
  */
 export const opsInput = e3.input('ops', DictType(StringType, OpsHall), variant('value', new Map([
-    ["Hall 1", new Map([
-            ["H1-P01", { ticket: "J-4603", startWeek: 25n, weeks: 3n, sheets: 96.0, load: 78.0, state: ACTUAL }],
-            ["H1-P02", { ticket: "J-4612", startWeek: 26n, weeks: 2n, sheets: 64.0, load: 71.0, state: ACTUAL }],
-            ["H1-P03", { ticket: "J-4642", startWeek: 28n, weeks: 3n, sheets: 112.0, load: 88.0, state: RUNNING }],
-            ["H1-P04", { ticket: "J-4624", startWeek: 27n, weeks: 4n, sheets: 104.0, load: 84.0, state: RUNNING }],
-            ["H1-P05", { ticket: "J-4657", startWeek: 31n, weeks: 3n, sheets: 88.0, load: 66.0, state: CONFIRMED }],
-            ["H1-P06", { ticket: "J-4669", startWeek: 32n, weeks: 2n, sheets: 72.0, load: 59.0, state: CONFIRMED }],
-            ["H1-P07", { ticket: "J-4693", startWeek: 33n, weeks: 4n, sheets: 120.0, load: 92.0, state: PROPOSED }],
-            ["H1-P08", { ticket: "J-4708", startWeek: 35n, weeks: 3n, sheets: 96.0, load: 74.0, state: PROPOSED }],
-            ["H1-P09", { ticket: "J-4726", startWeek: 36n, weeks: 3n, sheets: 80.0, load: 63.0, state: ESTIMATED }],
-            ["H1-P10", { ticket: "J-4741", startWeek: 37n, weeks: 2n, sheets: 56.0, load: 48.0, state: ESTIMATED }],
-        ])],
-    ["Hall 2", new Map([
-            ["H2-P01", { ticket: "J-4906", startWeek: 25n, weeks: 4n, sheets: 118.0, load: 91.0, state: ACTUAL }],
-            ["H2-P02", { ticket: "J-4921", startWeek: 27n, weeks: 2n, sheets: 52.0, load: 55.0, state: ACTUAL }],
-            ["H2-P03", { ticket: "J-4933", startWeek: 29n, weeks: 3n, sheets: 92.0, load: 80.0, state: RUNNING }],
-            ["H2-P04", { ticket: "J-4948", startWeek: 30n, weeks: 2n, sheets: 68.0, load: 61.0, state: CONFIRMED }],
-            ["H2-P05", { ticket: "J-4960", startWeek: 31n, weeks: 4n, sheets: 128.0, load: 96.0, state: CONFIRMED }],
-            ["H2-P06", { ticket: "J-4975", startWeek: 33n, weeks: 3n, sheets: 84.0, load: 69.0, state: PROPOSED }],
-            ["H2-P07", { ticket: "J-4987", startWeek: 34n, weeks: 2n, sheets: 60.0, load: 52.0, state: PROPOSED }],
-            ["H2-P08", { ticket: "J-5002", startWeek: 35n, weeks: 4n, sheets: 112.0, load: 87.0, state: PROPOSED }],
-            ["H2-P09", { ticket: "J-5014", startWeek: 37n, weeks: 3n, sheets: 76.0, load: 64.0, state: ESTIMATED }],
-            ["H2-P10", { ticket: "J-5029", startWeek: 38n, weeks: 2n, sheets: 48.0, load: 44.0, state: ESTIMATED }],
-        ])],
-    ["Hall 3", new Map([
-            ["H3-P01", { ticket: "J-5203", startWeek: 24n, weeks: 3n, sheets: 88.0, load: 73.0, state: ACTUAL }],
-            ["H3-P02", { ticket: "J-5215", startWeek: 26n, weeks: 4n, sheets: 124.0, load: 94.0, state: ACTUAL }],
-            ["H3-P03", { ticket: "J-5230", startWeek: 29n, weeks: 2n, sheets: 56.0, load: 51.0, state: RUNNING }],
-            ["H3-P04", { ticket: "J-5242", startWeek: 30n, weeks: 3n, sheets: 100.0, load: 82.0, state: RUNNING }],
-            ["H3-P05", { ticket: "J-5257", startWeek: 32n, weeks: 2n, sheets: 72.0, load: 62.0, state: CONFIRMED }],
-            ["H3-P06", { ticket: "J-5272", startWeek: 33n, weeks: 4n, sheets: 116.0, load: 90.0, state: CONFIRMED }],
-            ["H3-P07", { ticket: "J-5284", startWeek: 35n, weeks: 3n, sheets: 92.0, load: 76.0, state: PROPOSED }],
-            ["H3-P08", { ticket: "J-5299", startWeek: 36n, weeks: 2n, sheets: 64.0, load: 57.0, state: PROPOSED }],
-            ["H3-P09", { ticket: "J-5311", startWeek: 37n, weeks: 4n, sheets: 108.0, load: 85.0, state: ESTIMATED }],
-            ["H3-P10", { ticket: "J-5323", startWeek: 39n, weeks: 2n, sheets: 44.0, load: 41.0, state: ESTIMATED }],
-        ])],
-    ["Hall 4", new Map([
-            ["H4-P01", { ticket: "J-5506", startWeek: 25n, weeks: 2n, sheets: 60.0, load: 54.0, state: ACTUAL }],
-            ["H4-P02", { ticket: "J-5518", startWeek: 27n, weeks: 3n, sheets: 96.0, load: 79.0, state: ACTUAL }],
-            ["H4-P03", { ticket: "J-5533", startWeek: 28n, weeks: 4n, sheets: 132.0, load: 98.0, state: RUNNING }],
-            ["H4-P04", { ticket: "J-5545", startWeek: 31n, weeks: 2n, sheets: 68.0, load: 60.0, state: CONFIRMED }],
-            ["H4-P05", { ticket: "J-5560", startWeek: 32n, weeks: 3n, sheets: 104.0, load: 83.0, state: CONFIRMED }],
-            ["H4-P06", { ticket: "J-5572", startWeek: 34n, weeks: 2n, sheets: 76.0, load: 67.0, state: PROPOSED }],
-            ["H4-P07", { ticket: "J-5587", startWeek: 35n, weeks: 4n, sheets: 120.0, load: 93.0, state: PROPOSED }],
-            ["H4-P08", { ticket: "J-5599", startWeek: 37n, weeks: 3n, sheets: 84.0, load: 70.0, state: ESTIMATED }],
-            ["H4-P09", { ticket: "J-5614", startWeek: 38n, weeks: 2n, sheets: 52.0, load: 47.0, state: ESTIMATED }],
-            ["H4-P10", { ticket: "J-5626", startWeek: 39n, weeks: 3n, sheets: 88.0, load: 72.0, state: ESTIMATED }],
-        ])],
-    ["Hall 5", new Map([
-            ["H5-P01", { ticket: "J-5803", startWeek: 24n, weeks: 4n, sheets: 110.0, load: 86.0, state: ACTUAL }],
-            ["H5-P02", { ticket: "J-5815", startWeek: 26n, weeks: 2n, sheets: 58.0, load: 53.0, state: ACTUAL }],
-            ["H5-P03", { ticket: "J-5827", startWeek: 28n, weeks: 3n, sheets: 94.0, load: 77.0, state: RUNNING }],
-            ["H5-P04", { ticket: "J-5839", startWeek: 30n, weeks: 4n, sheets: 126.0, load: 95.0, state: RUNNING }],
-            ["H5-P05", { ticket: "J-5854", startWeek: 32n, weeks: 2n, sheets: 70.0, load: 61.0, state: CONFIRMED }],
-            ["H5-P06", { ticket: "J-5866", startWeek: 33n, weeks: 3n, sheets: 98.0, load: 81.0, state: CONFIRMED }],
-            ["H5-P07", { ticket: "J-5881", startWeek: 35n, weeks: 2n, sheets: 66.0, load: 58.0, state: PROPOSED }],
-            ["H5-P08", { ticket: "J-5893", startWeek: 36n, weeks: 4n, sheets: 114.0, load: 89.0, state: PROPOSED }],
-            ["H5-P09", { ticket: "J-5908", startWeek: 38n, weeks: 3n, sheets: 82.0, load: 68.0, state: ESTIMATED }],
-            ["H5-P10", { ticket: "J-5920", startWeek: 39n, weeks: 2n, sheets: 50.0, load: 45.0, state: ESTIMATED }],
-        ])],
+    ["Hall 1", { presses: new Map([
+                ["H1-P01", { ticket: "J-4603", startWeek: 25n, weeks: 3n, sheets: 96.0, load: 78.0, state: ACTUAL }],
+                ["H1-P02", { ticket: "J-4612", startWeek: 26n, weeks: 2n, sheets: 64.0, load: 71.0, state: ACTUAL }],
+                ["H1-P03", { ticket: "J-4642", startWeek: 28n, weeks: 3n, sheets: 112.0, load: 88.0, state: RUNNING }],
+                ["H1-P04", { ticket: "J-4624", startWeek: 27n, weeks: 4n, sheets: 104.0, load: 84.0, state: RUNNING }],
+                ["H1-P05", { ticket: "J-4657", startWeek: 31n, weeks: 3n, sheets: 88.0, load: 66.0, state: CONFIRMED }],
+                ["H1-P06", { ticket: "J-4669", startWeek: 32n, weeks: 2n, sheets: 72.0, load: 59.0, state: CONFIRMED }],
+                ["H1-P07", { ticket: "J-4693", startWeek: 33n, weeks: 4n, sheets: 120.0, load: 92.0, state: PROPOSED }],
+                ["H1-P08", { ticket: "J-4708", startWeek: 35n, weeks: 3n, sheets: 96.0, load: 74.0, state: PROPOSED }],
+                ["H1-P09", { ticket: "J-4726", startWeek: 36n, weeks: 3n, sheets: 80.0, load: 63.0, state: ESTIMATED }],
+                ["H1-P10", { ticket: "J-4741", startWeek: 37n, weeks: 2n, sheets: 56.0, load: 48.0, state: ESTIMATED }],
+            ]) }],
+    ["Hall 2", { presses: new Map([
+                ["H2-P01", { ticket: "J-4906", startWeek: 25n, weeks: 4n, sheets: 118.0, load: 91.0, state: ACTUAL }],
+                ["H2-P02", { ticket: "J-4921", startWeek: 27n, weeks: 2n, sheets: 52.0, load: 55.0, state: ACTUAL }],
+                ["H2-P03", { ticket: "J-4933", startWeek: 29n, weeks: 3n, sheets: 92.0, load: 80.0, state: RUNNING }],
+                ["H2-P04", { ticket: "J-4948", startWeek: 30n, weeks: 2n, sheets: 68.0, load: 61.0, state: CONFIRMED }],
+                ["H2-P05", { ticket: "J-4960", startWeek: 31n, weeks: 4n, sheets: 128.0, load: 96.0, state: CONFIRMED }],
+                ["H2-P06", { ticket: "J-4975", startWeek: 33n, weeks: 3n, sheets: 84.0, load: 69.0, state: PROPOSED }],
+                ["H2-P07", { ticket: "J-4987", startWeek: 34n, weeks: 2n, sheets: 60.0, load: 52.0, state: PROPOSED }],
+                ["H2-P08", { ticket: "J-5002", startWeek: 35n, weeks: 4n, sheets: 112.0, load: 87.0, state: PROPOSED }],
+                ["H2-P09", { ticket: "J-5014", startWeek: 37n, weeks: 3n, sheets: 76.0, load: 64.0, state: ESTIMATED }],
+                ["H2-P10", { ticket: "J-5029", startWeek: 38n, weeks: 2n, sheets: 48.0, load: 44.0, state: ESTIMATED }],
+            ]) }],
+    ["Hall 3", { presses: new Map([
+                ["H3-P01", { ticket: "J-5203", startWeek: 24n, weeks: 3n, sheets: 88.0, load: 73.0, state: ACTUAL }],
+                ["H3-P02", { ticket: "J-5215", startWeek: 26n, weeks: 4n, sheets: 124.0, load: 94.0, state: ACTUAL }],
+                ["H3-P03", { ticket: "J-5230", startWeek: 29n, weeks: 2n, sheets: 56.0, load: 51.0, state: RUNNING }],
+                ["H3-P04", { ticket: "J-5242", startWeek: 30n, weeks: 3n, sheets: 100.0, load: 82.0, state: RUNNING }],
+                ["H3-P05", { ticket: "J-5257", startWeek: 32n, weeks: 2n, sheets: 72.0, load: 62.0, state: CONFIRMED }],
+                ["H3-P06", { ticket: "J-5272", startWeek: 33n, weeks: 4n, sheets: 116.0, load: 90.0, state: CONFIRMED }],
+                ["H3-P07", { ticket: "J-5284", startWeek: 35n, weeks: 3n, sheets: 92.0, load: 76.0, state: PROPOSED }],
+                ["H3-P08", { ticket: "J-5299", startWeek: 36n, weeks: 2n, sheets: 64.0, load: 57.0, state: PROPOSED }],
+                ["H3-P09", { ticket: "J-5311", startWeek: 37n, weeks: 4n, sheets: 108.0, load: 85.0, state: ESTIMATED }],
+                ["H3-P10", { ticket: "J-5323", startWeek: 39n, weeks: 2n, sheets: 44.0, load: 41.0, state: ESTIMATED }],
+            ]) }],
+    ["Hall 4", { presses: new Map([
+                ["H4-P01", { ticket: "J-5506", startWeek: 25n, weeks: 2n, sheets: 60.0, load: 54.0, state: ACTUAL }],
+                ["H4-P02", { ticket: "J-5518", startWeek: 27n, weeks: 3n, sheets: 96.0, load: 79.0, state: ACTUAL }],
+                ["H4-P03", { ticket: "J-5533", startWeek: 28n, weeks: 4n, sheets: 132.0, load: 98.0, state: RUNNING }],
+                ["H4-P04", { ticket: "J-5545", startWeek: 31n, weeks: 2n, sheets: 68.0, load: 60.0, state: CONFIRMED }],
+                ["H4-P05", { ticket: "J-5560", startWeek: 32n, weeks: 3n, sheets: 104.0, load: 83.0, state: CONFIRMED }],
+                ["H4-P06", { ticket: "J-5572", startWeek: 34n, weeks: 2n, sheets: 76.0, load: 67.0, state: PROPOSED }],
+                ["H4-P07", { ticket: "J-5587", startWeek: 35n, weeks: 4n, sheets: 120.0, load: 93.0, state: PROPOSED }],
+                ["H4-P08", { ticket: "J-5599", startWeek: 37n, weeks: 3n, sheets: 84.0, load: 70.0, state: ESTIMATED }],
+                ["H4-P09", { ticket: "J-5614", startWeek: 38n, weeks: 2n, sheets: 52.0, load: 47.0, state: ESTIMATED }],
+                ["H4-P10", { ticket: "J-5626", startWeek: 39n, weeks: 3n, sheets: 88.0, load: 72.0, state: ESTIMATED }],
+            ]) }],
+    ["Hall 5", { presses: new Map([
+                ["H5-P01", { ticket: "J-5803", startWeek: 24n, weeks: 4n, sheets: 110.0, load: 86.0, state: ACTUAL }],
+                ["H5-P02", { ticket: "J-5815", startWeek: 26n, weeks: 2n, sheets: 58.0, load: 53.0, state: ACTUAL }],
+                ["H5-P03", { ticket: "J-5827", startWeek: 28n, weeks: 3n, sheets: 94.0, load: 77.0, state: RUNNING }],
+                ["H5-P04", { ticket: "J-5839", startWeek: 30n, weeks: 4n, sheets: 126.0, load: 95.0, state: RUNNING }],
+                ["H5-P05", { ticket: "J-5854", startWeek: 32n, weeks: 2n, sheets: 70.0, load: 61.0, state: CONFIRMED }],
+                ["H5-P06", { ticket: "J-5866", startWeek: 33n, weeks: 3n, sheets: 98.0, load: 81.0, state: CONFIRMED }],
+                ["H5-P07", { ticket: "J-5881", startWeek: 35n, weeks: 2n, sheets: 66.0, load: 58.0, state: PROPOSED }],
+                ["H5-P08", { ticket: "J-5893", startWeek: 36n, weeks: 4n, sheets: 114.0, load: 89.0, state: PROPOSED }],
+                ["H5-P09", { ticket: "J-5908", startWeek: 38n, weeks: 3n, sheets: 82.0, load: 68.0, state: ESTIMATED }],
+                ["H5-P10", { ticket: "J-5920", startWeek: 39n, weeks: 2n, sheets: 50.0, load: 45.0, state: ESTIMATED }],
+            ]) }],
     // The delivery vans — the same flat row, read as weekly load strips
     // rather than run bars (see the `vans` series below).
-    ["Vans", new Map([
-            ["V-01", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 46.0, state: CONFIRMED }],
-            ["V-02", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 58.0, state: CONFIRMED }],
-            ["V-03", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 67.0, state: CONFIRMED }],
-            ["V-04", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 74.0, state: CONFIRMED }],
-            ["V-05", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 81.0, state: CONFIRMED }],
-            ["V-06", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 88.0, state: CONFIRMED }],
-            ["V-07", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 93.0, state: CONFIRMED }],
-            ["V-08", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 97.0, state: CONFIRMED }],
-            ["V-09", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 64.0, state: CONFIRMED }],
-            ["V-10", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 52.0, state: CONFIRMED }],
-        ])],
+    ["Vans", { presses: new Map([
+                ["V-01", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 46.0, state: CONFIRMED }],
+                ["V-02", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 58.0, state: CONFIRMED }],
+                ["V-03", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 67.0, state: CONFIRMED }],
+                ["V-04", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 74.0, state: CONFIRMED }],
+                ["V-05", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 81.0, state: CONFIRMED }],
+                ["V-06", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 88.0, state: CONFIRMED }],
+                ["V-07", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 93.0, state: CONFIRMED }],
+                ["V-08", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 97.0, state: CONFIRMED }],
+                ["V-09", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 64.0, state: CONFIRMED }],
+                ["V-10", { ticket: "—", startWeek: 27n, weeks: 12n, sheets: 0.0, load: 52.0, state: CONFIRMED }],
+            ]) }],
 ])));
 /**
  * A maintenance work order — the row of the `work_orders` record, keyed by
@@ -156,37 +156,38 @@ export const WorkQueueKey = StructType({ status: StringType, due: DateTimeType }
  * workspace holds, and deploy builds its index over it. The ids run in the
  * order the orders were raised, which is nothing like the order they are due.
  */
-export const workOrders = e3.record('work_orders', DictType(StringType, WorkOrderRow), new Map([
-    ["WO-1001", { site: "North", title: "Replace kiln 2 burner", crew: "Mech A", status: "planned", due: new Date("2026-10-19T00:00:00Z") }],
-    ["WO-1002", { site: "North", title: "Calibrate belt scale 4", crew: "Inst", status: "late", due: new Date("2026-09-15T00:00:00Z") }],
-    ["WO-1003", { site: "South", title: "Reline crusher jaw", crew: "Mech B", status: "open", due: new Date("2026-09-25T00:00:00Z") }],
-    ["WO-1004", { site: "South", title: "Grease stacker bearings", crew: "Mech B", status: "open", due: new Date("2026-09-24T00:00:00Z") }],
-    ["WO-1005", { site: "Port", title: "Inspect shiploader boom", crew: "Struct", status: "late", due: new Date("2026-09-18T00:00:00Z") }],
-    ["WO-1006", { site: "North", title: "Swap conveyor 7 idlers", crew: "Mech A", status: "open", due: new Date("2026-09-29T00:00:00Z") }],
-    ["WO-1007", { site: "Port", title: "Test dust suppression pumps", crew: "Elec", status: "planned", due: new Date("2026-10-06T00:00:00Z") }],
-    ["WO-1008", { site: "South", title: "Replace screen deck panels", crew: "Mech B", status: "late", due: new Date("2026-09-11T00:00:00Z") }],
-    ["WO-1009", { site: "North", title: "Thermal scan MCC room", crew: "Elec", status: "open", due: new Date("2026-09-26T00:00:00Z") }],
-    ["WO-1010", { site: "Port", title: "Rebuild reclaimer gearbox", crew: "Mech A", status: "planned", due: new Date("2026-10-26T00:00:00Z") }],
-    ["WO-1011", { site: "South", title: "Align apron feeder", crew: "Mech B", status: "open", due: new Date("2026-10-01T00:00:00Z") }],
-    ["WO-1012", { site: "North", title: "Service compressor 2", crew: "Mech A", status: "late", due: new Date("2026-09-21T00:00:00Z") }],
-    ["WO-1013", { site: "Port", title: "Weld chute liner", crew: "Struct", status: "open", due: new Date("2026-09-30T00:00:00Z") }],
-    ["WO-1014", { site: "South", title: "Replace pump 3 impeller", crew: "Mech B", status: "planned", due: new Date("2026-10-09T00:00:00Z") }],
-    ["WO-1015", { site: "North", title: "Relamp stockpile towers", crew: "Elec", status: "planned", due: new Date("2026-10-13T00:00:00Z") }],
-    ["WO-1016", { site: "Port", title: "Tension berth 2 belt", crew: "Mech A", status: "open", due: new Date("2026-09-24T00:00:00Z") }],
-    ["WO-1017", { site: "South", title: "Inspect tailings line", crew: "Struct", status: "late", due: new Date("2026-09-22T00:00:00Z") }],
-    ["WO-1018", { site: "North", title: "Change kiln 1 seals", crew: "Mech A", status: "planned", due: new Date("2026-11-02T00:00:00Z") }],
-]));
-/**
- * The dispatch queue — every work order under `{status, due}`, carrying its
- * title so the queue renders from index pages alone and never reads an
- * order's row.
- */
-export const workQueue = e3.recordIndex('by_status', workOrders, {
-    key: East.function([StringType, WorkOrderRow], WorkQueueKey, ($, _id, order) => ({ status: order.status, due: order.due })),
-    value: East.function([StringType, WorkOrderRow], StringType, ($, _id, order) => order.title),
+export const workOrders = e3.record('work_orders', DictType(StringType, WorkOrderRow), {
+    initial: new Map([
+        ["WO-1001", { site: "North", title: "Replace kiln 2 burner", crew: "Mech A", status: "planned", due: new Date("2026-10-19T00:00:00Z") }],
+        ["WO-1002", { site: "North", title: "Calibrate belt scale 4", crew: "Inst", status: "late", due: new Date("2026-09-15T00:00:00Z") }],
+        ["WO-1003", { site: "South", title: "Reline crusher jaw", crew: "Mech B", status: "open", due: new Date("2026-09-25T00:00:00Z") }],
+        ["WO-1004", { site: "South", title: "Grease stacker bearings", crew: "Mech B", status: "open", due: new Date("2026-09-24T00:00:00Z") }],
+        ["WO-1005", { site: "Port", title: "Inspect shiploader boom", crew: "Struct", status: "late", due: new Date("2026-09-18T00:00:00Z") }],
+        ["WO-1006", { site: "North", title: "Swap conveyor 7 idlers", crew: "Mech A", status: "open", due: new Date("2026-09-29T00:00:00Z") }],
+        ["WO-1007", { site: "Port", title: "Test dust suppression pumps", crew: "Elec", status: "planned", due: new Date("2026-10-06T00:00:00Z") }],
+        ["WO-1008", { site: "South", title: "Replace screen deck panels", crew: "Mech B", status: "late", due: new Date("2026-09-11T00:00:00Z") }],
+        ["WO-1009", { site: "North", title: "Thermal scan MCC room", crew: "Elec", status: "open", due: new Date("2026-09-26T00:00:00Z") }],
+        ["WO-1010", { site: "Port", title: "Rebuild reclaimer gearbox", crew: "Mech A", status: "planned", due: new Date("2026-10-26T00:00:00Z") }],
+        ["WO-1011", { site: "South", title: "Align apron feeder", crew: "Mech B", status: "open", due: new Date("2026-10-01T00:00:00Z") }],
+        ["WO-1012", { site: "North", title: "Service compressor 2", crew: "Mech A", status: "late", due: new Date("2026-09-21T00:00:00Z") }],
+        ["WO-1013", { site: "Port", title: "Weld chute liner", crew: "Struct", status: "open", due: new Date("2026-09-30T00:00:00Z") }],
+        ["WO-1014", { site: "South", title: "Replace pump 3 impeller", crew: "Mech B", status: "planned", due: new Date("2026-10-09T00:00:00Z") }],
+        ["WO-1015", { site: "North", title: "Relamp stockpile towers", crew: "Elec", status: "planned", due: new Date("2026-10-13T00:00:00Z") }],
+        ["WO-1016", { site: "Port", title: "Tension berth 2 belt", crew: "Mech A", status: "open", due: new Date("2026-09-24T00:00:00Z") }],
+        ["WO-1017", { site: "South", title: "Inspect tailings line", crew: "Struct", status: "late", due: new Date("2026-09-22T00:00:00Z") }],
+        ["WO-1018", { site: "North", title: "Change kiln 1 seals", crew: "Mech A", status: "planned", due: new Date("2026-11-02T00:00:00Z") }],
+    ]),
+    indexes: (index) => ({
+        // The dispatch queue — every work order under `{status, due}`, carrying its
+        // title so the queue renders from index pages alone and never reads an
+        // order's row.
+        by_status: index.key(East.function([StringType, WorkOrderRow], WorkQueueKey, ($, _id, order) => ({ status: order.status, due: order.due })), { value: East.function([StringType, WorkOrderRow], StringType, ($, _id, order) => order.title) }),
+    }),
+    mutations: (mutation) => ({
+        // The work orders' patch door: another session's change to an order commits through it, and moves the queue with it.
+        patch: mutation.patch(),
+    }),
 });
-/** The work orders' patch door: another session's change to an order commits through it, and moves the queue with it. */
-export const workOrdersPatch = e3.mutation.patch(workOrders);
 export const dataBindFloat = example({
     keywords: ["Data", "bind", "Reactive", "Float", "dataset", "read"],
     description: "Bind to a Float dataset and display its current value",
@@ -290,7 +291,7 @@ export const dataBindPagedPlan = example({
                     label: (_h, hall) => hall,
                     runs: _l => [],
                     rollup: "union",
-                    children: Plan.children((l) => l, [
+                    children: Plan.children("presses", [
                         // Presses — each flat row becomes TWO bars: a one-week
                         // make-ready ahead of the job, then the run itself, with its
                         // label and quantity built from the job ticket and sheets
@@ -326,7 +327,7 @@ export const dataBindPagedPlan = example({
                     match: (_h, hall) => hall.equal("Vans"),
                     label: (_h, hall) => hall,
                     collapsed: true, summaryAggregate: "mean",
-                    children: Plan.children((l) => l, [
+                    children: Plan.children("presses", [
                         Plan.series.heat(OpsRow, {
                             key: "van-load", title: "Van load",
                             label: (_r, k) => k, id: true,
@@ -374,14 +375,14 @@ export const dataBindPagedRevision = example({
 });
 export const dataBindPagedIndex = example({
     keywords: [
-        "Data", "bindPaged", "index", "recordIndex", "record", "secondary index", "queue", "ordered",
+        "Data", "bindPaged", "index", "indexes", "record", "secondary index", "queue", "ordered",
         "window", "covering", "projection", "ik", "key", "value", "row", "join", "Table", "paged", "by_status",
     ],
-    description: "Read a record THROUGH one of its indexes — `Data.bindPaged(workOrders, { index: workQueue })` serves the INDEX's pages in the index's own order, so the dispatch queue arrives late-first and by due date within each status, whatever the work orders' ids are. Each row is `{ ik, key, value, row }`: the index key, the order's id, and the title the index covers — so the Table renders from index pages alone and reads no order's row (`join: true` would fill `row` from the record too)",
+    description: "Read a record THROUGH one of its indexes — `Data.bindPaged(workOrders, { index: \"by_status\" })` serves the INDEX's pages in the index's own order, so the dispatch queue arrives late-first and by due date within each status, whatever the work orders' ids are. Each row is `{ ik, key, value, row }`: the index key, the order's id, and the title the index covers — so the Table renders from index pages alone and reads no order's row (`join: true` would fill `row` from the record too)",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
-            // Pass the index DECLARATION, not its name: the window's type —
-            // its key and what it covers — comes from it.
-            const queue = $.let(Data.bindPaged(workOrders, { index: workQueue }));
+            // Name one of the record's indexes: the window's type — its key
+            // and what it covers — comes from the index's declaration.
+            const queue = $.let(Data.bindPaged(workOrders, { index: "by_status" }));
             return _jsx(Table, { data: queue, columns: {
                     ik: { header: "Due", value: (ik) => East.str `${ik.status} · ${ik.due.printFormatted("ddd D MMM")}` },
                     value: { header: "Work order" },
@@ -614,7 +615,7 @@ export const countsSaid = East.function([DictType(StringType, IntegerType)], UIC
 export const previewCountsView = ui('preview_counts_view', [previewCountsInput], countsSaid);
 /** A ui task over the work orders, their queue read a window at a time beside the commits of their record, which is never read whole. */
 export const previewOrdersView = ui('preview_orders_view', [], East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
-        const orders = $.let(Data.bindPaged(workOrders, { index: workQueue }));
+        const orders = $.let(Data.bindPaged(workOrders, { index: "by_status" }));
         const record = $.let(Record.bind(workOrders, []));
         const commits = $.let(record.history().match({
             some: (_$2, history) => history.size(),
@@ -631,14 +632,20 @@ export const previewOrdersView = ui('preview_orders_view', [], East.function([],
 /** A person and the skills they hold: a Set field, which an index lists once under each skill. */
 export const IndexedPerson = StructType({ name: StringType, skills: SetType(StringType) });
 /** People by key: Ada and Amy share skill `b`, and Abe holds none, so the skills index lists him nowhere. */
-export const indexedPeople = e3.record('indexed_people', DictType(StringType, IndexedPerson), new Map([
-    ["p1", { name: "Ada", skills: new Set(["a", "b"]) }],
-    ["p2", { name: "Abe", skills: new Set() }],
-    ["p3", { name: "Amy", skills: new Set(["b"]) }],
-]));
-export const indexedPeoplePatch = e3.mutation.patch(indexedPeople);
-export const peopleByName = e3.recordIndex('by_name', indexedPeople, { on: ["name"] });
-export const peopleBySkill = e3.recordIndex('by_skill', indexedPeople, { on: ["skills"] });
+export const indexedPeople = e3.record('indexed_people', DictType(StringType, IndexedPerson), {
+    initial: new Map([
+        ["p1", { name: "Ada", skills: new Set(["a", "b"]) }],
+        ["p2", { name: "Abe", skills: new Set() }],
+        ["p3", { name: "Amy", skills: new Set(["b"]) }],
+    ]),
+    indexes: (index) => ({
+        by_name: index.on(["name"]),
+        by_skill: index.on(["skills"]),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
+});
 /** An event of a status over a span of time: no end is an instant, and no start the backlog. */
 export const IntervalEvent = StructType({ status: StringType, start: OptionType(DateTimeType), end: OptionType(DateTimeType) });
 /**
@@ -647,55 +654,168 @@ export const IntervalEvent = StructType({ status: StringType, start: OptionType(
  * it ends, an instant at each of its bounds, one cancelled and one in the
  * backlog — what an overlap with `[2 Oct, 3 Oct)` takes and what it leaves.
  */
-export const indexedIntervals = e3.record('indexed_intervals', DictType(StringType, IntervalEvent), new Map([
-    ["backlog", { status: "Ready", start: none, end: none }],
-    ["carry", { status: "Ready", start: some(new Date("2026-10-01T22:00:00Z")), end: some(new Date("2026-10-02T06:00:00Z")) }],
-    ["span", { status: "Ready", start: some(new Date("2025-01-01T00:00:00Z")), end: some(new Date("2027-01-01T00:00:00Z")) }],
-    ["inside", { status: "Ready", start: some(new Date("2026-10-02T10:00:00Z")), end: some(new Date("2026-10-02T11:00:00Z")) }],
-    ["ends-at-from", { status: "Ready", start: some(new Date("2026-10-01T12:00:00Z")), end: some(new Date("2026-10-02T00:00:00Z")) }],
-    ["starts-at-to", { status: "Ready", start: some(new Date("2026-10-03T00:00:00Z")), end: some(new Date("2026-10-03T01:00:00Z")) }],
-    ["instant-at-from", { status: "Ready", start: some(new Date("2026-10-02T00:00:00Z")), end: none }],
-    ["instant-at-to", { status: "Ready", start: some(new Date("2026-10-03T00:00:00Z")), end: none }],
-    ["cancelled", { status: "Cancelled", start: some(new Date("2026-01-01T00:00:00Z")), end: some(new Date("2027-01-01T00:00:00Z")) }],
-]));
-export const indexedIntervalsPatch = e3.mutation.patch(indexedIntervals);
-// The start alone is listed first: a declared overlap must never be read as a start range because its index came first.
-export const intervalsByStart = e3.recordIndex('by_start', indexedIntervals, { on: ["start"] });
-export const intervalsByStatusTime = e3.recordIndex('by_status_time', indexedIntervals, { on: ["status"], interval: { from: "start", to: "end" } });
-export const intervalsByTime = e3.recordIndex('by_time', indexedIntervals, { interval: { from: "start", to: "end" } });
-/** A step of a flow: its lane, and who owns it, if anyone. */
-export const ComputedStep = StructType({ lane: StringType, owner: OptionType(StringType) });
-/** A flow: what it is, and its steps. */
-export const ComputedFlow = StructType({ description: StringType, states: ArrayType(ComputedStep) });
-/** Flows whose indexes are computed from their steps: `a` has two steps in one lane, `c` a step no one owns, and `d` none at all. */
-export const computedFlows = e3.record('computed_flows', DictType(StringType, ComputedFlow), new Map([
-    ["a", { description: "Inbound", states: [{ lane: "load", owner: some("team-a") }, { lane: "load", owner: some("team-a") }, { lane: "review", owner: none }] }],
-    ["b", { description: "Inbound", states: [{ lane: "load", owner: some("team-b") }] }],
-    ["c", { description: "Returns", states: [{ lane: "review", owner: none }] }],
-    ["d", { description: "Empty", states: [] }],
-]));
-export const computedFlowsPatch = e3.mutation.patch(computedFlows);
-export const computedByDescription = e3.recordIndex('description', computedFlows, { on: ["description"] });
-export const computedByStateCount = e3.recordIndex('state_count', computedFlows, {
-    key: East.function([StringType, ComputedFlow], StructType({ stateCount: IntegerType }), (_$, _id, flow) => ({ stateCount: flow.states.size() })),
+export const indexedIntervals = e3.record('indexed_intervals', DictType(StringType, IntervalEvent), {
+    initial: new Map([
+        ["backlog", { status: "Ready", start: none, end: none }],
+        ["carry", { status: "Ready", start: some(new Date("2026-10-01T22:00:00Z")), end: some(new Date("2026-10-02T06:00:00Z")) }],
+        ["span", { status: "Ready", start: some(new Date("2025-01-01T00:00:00Z")), end: some(new Date("2027-01-01T00:00:00Z")) }],
+        ["inside", { status: "Ready", start: some(new Date("2026-10-02T10:00:00Z")), end: some(new Date("2026-10-02T11:00:00Z")) }],
+        ["ends-at-from", { status: "Ready", start: some(new Date("2026-10-01T12:00:00Z")), end: some(new Date("2026-10-02T00:00:00Z")) }],
+        ["starts-at-to", { status: "Ready", start: some(new Date("2026-10-03T00:00:00Z")), end: some(new Date("2026-10-03T01:00:00Z")) }],
+        ["instant-at-from", { status: "Ready", start: some(new Date("2026-10-02T00:00:00Z")), end: none }],
+        ["instant-at-to", { status: "Ready", start: some(new Date("2026-10-03T00:00:00Z")), end: none }],
+        ["cancelled", { status: "Cancelled", start: some(new Date("2026-01-01T00:00:00Z")), end: some(new Date("2027-01-01T00:00:00Z")) }],
+    ]),
+    indexes: (index) => ({
+        // The start alone is listed first: a declared overlap must never be read as a start range because its index came first.
+        by_start: index.on(["start"]),
+        by_status_time: index.interval({ on: ["status"], from: "start", to: "end" }),
+        by_time: index.interval({ from: "start", to: "end" }),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
 });
-export const computedByDescriptionCount = e3.recordIndex('description_count', computedFlows, {
-    key: East.function([StringType, ComputedFlow], StructType({ description: StringType, stateCount: IntegerType }), (_$, _id, flow) => ({ description: flow.description, stateCount: flow.states.size() })),
+/** A rack on a data centre floor, in metres: its hall, where it stands — by its centre — if anywhere yet, and its footprint. */
+export const IndexedRack = StructType({ hall: StringType, x: OptionType(FloatType), y: OptionType(FloatType), w: FloatType, h: FloatType });
+/**
+ * Racks on a floor: three in hall A along a row, one in hall B across the
+ * aisle, one in hall B far down the floor, and one in hall A not yet placed —
+ * what a window over the row takes, what its margin takes, and what it leaves.
+ */
+export const indexedRacks = e3.record('indexed_racks', DictType(StringType, IndexedRack), {
+    initial: new Map([
+        ["r1", { hall: "A", x: some(1.0), y: some(1.0), w: 0.6, h: 1.2 }],
+        ["r2", { hall: "A", x: some(2.0), y: some(1.0), w: 0.6, h: 1.2 }],
+        ["r3", { hall: "A", x: some(3.0), y: some(1.0), w: 0.6, h: 1.2 }],
+        ["r4", { hall: "B", x: some(2.0), y: some(3.5), w: 0.6, h: 1.2 }],
+        ["far", { hall: "B", x: some(40.0), y: some(40.0), w: 0.6, h: 1.2 }],
+        ["unplaced", { hall: "A", x: none, y: none, w: 0.6, h: 1.2 }],
+    ]),
+    indexes: (index) => ({
+        // The window whatever the rail chooses, and beside it a choice of halls and the window in one read; both carry their rows.
+        racks_by_area: index.area({ x: "x", y: "y", width: "w", height: "h", at: "centre", cell: 0.01 }),
+        racks_by_hall_area: index.area({ on: ["hall"], x: "x", y: "y", width: "w", height: "h", at: "centre", cell: 0.01 }),
+        racks_by_hall: index.on(["hall"]),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
 });
-export const computedByLane = e3.recordIndex('lane', computedFlows, {
-    keys: East.function([StringType, ComputedFlow], SetType(StructType({ lane: StringType })), (_$, _id, flow) => flow.states.toSet((_$2, state) => ({ lane: state.lane }))),
+/**
+ * A rack whose fields are named as e3's own parts of a generated key once were
+ * (#1432): `area`, `__area`, `tile` and `__tile`. No name is reserved — e3's
+ * parts are its index's kind's — so each is a field of the rail like any
+ * other, and an area index may be led by them.
+ */
+export const NamedRack = StructType({
+    area: StringType, __area: StringType, tile: StringType, __tile: StringType, x: OptionType(FloatType), y: OptionType(FloatType),
 });
-export const computedByOwner = e3.recordIndex('owner', computedFlows, {
-    keys: East.function([StringType, ComputedFlow], SetType(StructType({ owner: OptionType(StringType) })), (_$, _id, flow) => flow.states.toSet((_$2, state) => ({ owner: state.owner }))),
+/**
+ * Five racks: two in area A1 by B — one inside the window over the floor's
+ * corner, one far down it — one by C and one in A2 inside it, and one in A1 by
+ * B not yet placed.
+ */
+export const namedRacks = e3.record('named_racks', DictType(StringType, NamedRack), {
+    initial: new Map([
+        ["n1", { area: "A1", __area: "B", tile: "T1", __tile: "U1", x: some(1.0), y: some(1.0) }],
+        ["n2", { area: "A1", __area: "B", tile: "T2", __tile: "U1", x: some(100.0), y: some(100.0) }],
+        ["n3", { area: "A1", __area: "C", tile: "T1", __tile: "U2", x: some(1.5), y: some(1.5) }],
+        ["n4", { area: "A2", __area: "B", tile: "T1", __tile: "U2", x: some(2.0), y: some(2.0) }],
+        ["unplaced", { area: "A1", __area: "B", tile: "T2", __tile: "U1", x: none, y: none }],
+    ]),
+    indexes: (index) => ({
+        // Each field leads a plain index; the window is read whatever the rail chooses, or beside a choice of `area` and `__area`.
+        named_by_area: index.on(["area"]),
+        named_by_under_area: index.on(["__area"]),
+        named_by_tile: index.on(["tile"]),
+        named_by_under_tile: index.on(["__tile"]),
+        named_by_place: index.area({ x: "x", y: "y", cell: 1 }),
+        named_by_area_place: index.area({ on: ["area", "__area"], x: "x", y: "y", cell: 1 }),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
 });
-// Scalar computed keys, each a field by its index's name.
-export const computedByLabel = e3.recordIndex('label', computedFlows, {
-    key: East.function([StringType, ComputedFlow], StringType, (_$, _id, flow) => flow.description),
+/** A rack's load: what its card's figure and its dot draw. */
+export const IndexedRackLoad = StructType({ kw: FloatType, alarm: StringType });
+/**
+ * The racks' loads, keyed as the racks are: two of the row's three, the rack
+ * across the aisle's and the far one's — none for `r3`, nor for the rack not
+ * yet placed, and one for a rack the floor does not hold — what a window's
+ * racks read their details by, through the runs the area index files them in
+ * (#1393).
+ */
+export const indexedRackLoads = e3.record('indexed_rack_loads', DictType(StringType, IndexedRackLoad), {
+    initial: new Map([
+        ["far", { kw: 1.0, alarm: "ok" }],
+        ["gone", { kw: 2.0, alarm: "ok" }],
+        ["r1", { kw: 4.2, alarm: "ok" }],
+        ["r2", { kw: 9.9, alarm: "warm" }],
+        ["r4", { kw: 11.1, alarm: "hot" }],
+    ]),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
 });
-export const computedBySize = e3.recordIndex('size', computedFlows, {
-    key: East.function([StringType, ComputedFlow], IntegerType, (_$, _id, flow) => flow.states.size()),
+/** A print job: the press it runs on, if any yet, its state, and when it runs, if it is scheduled. */
+export const IndexedJob = StructType({ press: OptionType(StringType), state: StringType, start: OptionType(DateTimeType), end: OptionType(DateTimeType) });
+/**
+ * Jobs on three presses about the week of Monday 5 October 2026: one carried in
+ * from the week before, one across the week's end into the next, one the whole
+ * month, two inside the week, an instant at its start, one on no press yet and
+ * one in the backlog — what a cell of some presses in a week holds, and what a
+ * month's totals count (#1039).
+ */
+export const indexedJobs = e3.record('indexed_jobs', DictType(StringType, IndexedJob), {
+    initial: new Map([
+        ["carry", { press: some("P-1"), state: "running", start: some(new Date("2026-10-02T20:00:00Z")), end: some(new Date("2026-10-05T04:00:00Z")) }],
+        ["across", { press: some("P-1"), state: "planned", start: some(new Date("2026-10-11T18:00:00Z")), end: some(new Date("2026-10-12T06:00:00Z")) }],
+        ["month", { press: some("P-2"), state: "planned", start: some(new Date("2026-10-01T00:00:00Z")), end: some(new Date("2026-11-01T00:00:00Z")) }],
+        ["inside", { press: some("P-2"), state: "running", start: some(new Date("2026-10-06T08:00:00Z")), end: some(new Date("2026-10-06T16:00:00Z")) }],
+        ["late", { press: some("P-3"), state: "late", start: some(new Date("2026-10-07T09:00:00Z")), end: some(new Date("2026-10-07T12:00:00Z")) }],
+        ["instant", { press: some("P-3"), state: "late", start: some(new Date("2026-10-05T00:00:00Z")), end: none }],
+        ["unpressed", { press: none, state: "planned", start: some(new Date("2026-10-06T00:00:00Z")), end: some(new Date("2026-10-06T02:00:00Z")) }],
+        ["backlog", { press: some("P-1"), state: "planned", start: none, end: none }],
+    ]),
+    indexes: (index) => ({
+        // The jobs a window overlaps, by state or not; their cells, some presses in a week, by state or not; and their totals,
+        // a press in a month.
+        jobs_by_time: index.interval({ from: "start", to: "end" }),
+        jobs_by_state_time: index.interval({ on: ["state"], from: "start", to: "end" }),
+        jobs_by_press_week: index.series({ key: "press", from: "start", to: "end", tile: "week" }),
+        jobs_by_state_press_week: index.series({ on: ["state"], key: "press", from: "start", to: "end", tile: "week" }),
+        jobs_by_press_month: index.summary({ key: "press", from: "start", to: "end", tile: "month" }),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
 });
-export const computedByDecisionOwner = e3.recordIndex('decisionOwner', computedFlows, {
-    keys: East.function([StringType, ComputedFlow], SetType(OptionType(StringType)), (_$, _id, flow) => flow.states.toSet((_$2, state) => state.owner)),
+/** A step of a flow: its lane, and who owns it, if anyone. */
+export const ComputedStep = StructType({ lane: StringType, owner: OptionType(StringType) });
+/** A flow: what it is, and its steps. */
+export const ComputedFlow = StructType({ description: StringType, states: ArrayType(ComputedStep) });
+/** Flows whose indexes are computed from their steps: `a` has two steps in one lane, `c` a step no one owns, and `d` none at all. */
+export const computedFlows = e3.record('computed_flows', DictType(StringType, ComputedFlow), {
+    initial: new Map([
+        ["a", { description: "Inbound", states: [{ lane: "load", owner: some("team-a") }, { lane: "load", owner: some("team-a") }, { lane: "review", owner: none }] }],
+        ["b", { description: "Inbound", states: [{ lane: "load", owner: some("team-b") }] }],
+        ["c", { description: "Returns", states: [{ lane: "review", owner: none }] }],
+        ["d", { description: "Empty", states: [] }],
+    ]),
+    indexes: (index) => ({
+        description: index.on(["description"]),
+        state_count: index.key(East.function([StringType, ComputedFlow], StructType({ stateCount: IntegerType }), (_$, _id, flow) => ({ stateCount: flow.states.size() }))),
+        description_count: index.key(East.function([StringType, ComputedFlow], StructType({ description: StringType, stateCount: IntegerType }), (_$, _id, flow) => ({ description: flow.description, stateCount: flow.states.size() }))),
+        lane: index.keys(East.function([StringType, ComputedFlow], SetType(StructType({ lane: StringType })), (_$, _id, flow) => flow.states.toSet((_$2, state) => ({ lane: state.lane })))),
+        owner: index.keys(East.function([StringType, ComputedFlow], SetType(StructType({ owner: OptionType(StringType) })), (_$, _id, flow) => flow.states.toSet((_$2, state) => ({ owner: state.owner })))),
+        // Scalar computed keys, each a field by its index's name.
+        label: index.key(East.function([StringType, ComputedFlow], StringType, (_$, _id, flow) => flow.description)),
+        size: index.key(East.function([StringType, ComputedFlow], IntegerType, (_$, _id, flow) => flow.states.size())),
+        decisionOwner: index.keys(East.function([StringType, ComputedFlow], SetType(OptionType(StringType)), (_$, _id, flow) => flow.states.toSet((_$2, state) => state.owner))),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
 });
 //# sourceMappingURL=data.examples.js.map