@elaraai/e3-ui 1.0.86 → 1.0.88

package/dist/src/utils/row-inspector.js

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * An author's own UI for one row in an inspector, on the wire: the Sheet's
+ * own Details (SB58, #1188) and a Plan event kind's own inspector (PB60,
+ * #1197). The author writes a typed East function over the row and a writer
+ * of the edited row; it crosses to the renderer wrapped over bytes, so a
+ * payload is one type whatever the rows hold.
+ *
+ * @packageDocumentation
+ */
+import { BlobType, East, Expr, FunctionType, NullType, isTypeEqual, } from "@elaraai/east";
+import { UIComponentType } from "@elaraai/east-ui";
+/**
+ * An author's own UI for one row, on the wire: the row as bytes, and the
+ * writer that takes the edited row back as bytes, to what the inspector shows
+ * in place of its form.
+ */
+export const RowInspectorType = FunctionType([BlobType, FunctionType([BlobType], NullType)], UIComponentType);
+/**
+ * Checks an author's `(row, update) => UIComponentType` against the row type,
+ * then wraps it so the row and the edited row cross as bytes. The author's
+ * function is captured as it is and called only where the renderer draws it,
+ * never here.
+ *
+ * @param fn - The author's function
+ * @param rowType - The row type
+ * @param refusal - What a function of another type is refused with, naming the option
+ * @returns The wrapped function
+ * @throws {Error} With `refusal` when the function is not `(Row, (Row) => Null) => UIComponentType`
+ */
+export function rowInspector(fn, rowType, refusal) {
+    const update = FunctionType([rowType], NullType);
+    const author = East.value(fn);
+    const t = Expr.type(author);
+    const fits = t.type === "Function" && t.inputs?.length === 2 && isTypeEqual(t.inputs[0], rowType) && isTypeEqual(t.inputs[1], update)
+        && t.output !== undefined && isTypeEqual(t.output, UIComponentType);
+    if (!fits)
+        throw new Error(refusal);
+    return East.function([BlobType, FunctionType([BlobType], NullType)], UIComponentType, ($, bytes, write) => {
+        const draw = $.const(author);
+        const row = $.const(bytes.decodeBeast(rowType, "v2"));
+        const typed = $.const(East.function([rowType], NullType, ($2, edited) => { $2(write(East.Blob.encodeBeast(edited, "v2"))); }));
+        return draw(row, typed);
+    });
+}
+//# sourceMappingURL=row-inspector.js.map

package/dist/src/utils/row-inspector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-inspector.js","sourceRoot":"","sources":["../../../src/utils/row-inspector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AAEH,OAAO,EACH,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,WAAW,GAE5D,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,YAAY,CAAC,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC;AAK9G;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,EAAW,EAAE,OAAmB,EAAE,OAAe;IAC1E,MAAM,MAAM,GAAG,YAAY,CAAC,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;IACjD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,EAAsC,CAA2B,CAAC;IAC5F,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAyB,CAA6D,CAAC;IAC3G,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAE,EAAE,OAAO,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAE,EAAE,MAAM,CAAC;WAChI,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACxE,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IACpC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACtG,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,MAAgH,CAAC,CAAC;QACvI,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/H,OAAO,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC5B,CAAC,CAAC,CAAC;AACP,CAAC"}

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

@@ -16,8 +16,8 @@ export declare const thresholdPatchInput: e3.DatasetDef<import("@elaraai/east").
 export declare const countInput: e3.DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "count">]>;
 export declare const nameInput: e3.DatasetDef<StringType, [variant<"field", "inputs">, variant<"field", "name">]>;
 /**
- * The RAW ops row — deliberately FLAT and scalar: a batch code, the job's
- * window as a start week + a duration, its tonnage, a utilisation reading, and
+ * The RAW ops row — deliberately FLAT and scalar: a job ticket, the job's
+ * window as a start week + a duration, its sheets, a utilisation reading, and
  * the lifecycle state. No dates, no display strings.
  *
  * Everything the canvas shows — the run bars, their labels, quantities, the
@@ -27,12 +27,12 @@ export declare const nameInput: e3.DatasetDef<StringType, [variant<"field", "inp
  * the series.
  */
 export declare const OpsRow: StructType<{
-    readonly batch: StringType;
+    readonly ticket: StringType;
     /** ISO week the job starts (2026); the series turns it into an instant. */
     readonly startWeek: IntegerType;
     /** Duration in weeks. */
     readonly weeks: IntegerType;
-    readonly tonnes: FloatType;
+    readonly sheets: FloatType;
     /** % utilisation, which the load series expands into a weekly strip. */
     readonly load: FloatType;
     readonly state: import("@elaraai/east").VariantType<{
@@ -48,14 +48,14 @@ export declare const OpsRow: StructType<{
         readonly rejected: NullType;
     }>;
 }>;
-/** One line's machines (or the dock's berths), keyed by id. */
-export declare const OpsLine: DictType<StringType, StructType<{
-    readonly batch: StringType;
+/** One hall's presses (or the delivery vans), keyed by id. */
+export declare const OpsHall: DictType<StringType, StructType<{
+    readonly ticket: StringType;
     /** ISO week the job starts (2026); the series turns it into an instant. */
     readonly startWeek: IntegerType;
     /** Duration in weeks. */
     readonly weeks: IntegerType;
-    readonly tonnes: FloatType;
+    readonly sheets: FloatType;
     /** % utilisation, which the load series expands into a weekly strip. */
     readonly load: FloatType;
     readonly state: import("@elaraai/east").VariantType<{
@@ -74,10 +74,10 @@ export declare const OpsLine: DictType<StringType, StructType<{
 /**
  * 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
- * snapshot harness) serves windows out of. Fifty machines across five
- * production lines plus a dock's ten berths.
+ * snapshot harness) serves windows out of. Fifty presses across five
+ * halls plus ten delivery vans.
  *
- * GROUPED by line, as the dataflow that produces it would store it: a canvas
+ * GROUPED by hall, as the dataflow that produces it would store it: a canvas
  * nests what its data nests, and a paged source is grouped where it is made —
  * in an e3 task — never on the canvas one window at a time (#822).
  *
@@ -86,12 +86,12 @@ export declare const OpsLine: DictType<StringType, StructType<{
  * estimated ahead of it.
  */
 export declare const opsInput: e3.DatasetDef<DictType<StringType, DictType<StringType, StructType<{
-    readonly batch: StringType;
+    readonly ticket: StringType;
     /** ISO week the job starts (2026); the series turns it into an instant. */
     readonly startWeek: IntegerType;
     /** Duration in weeks. */
     readonly weeks: IntegerType;
-    readonly tonnes: FloatType;
+    readonly sheets: FloatType;
     /** % utilisation, which the load series expands into a weekly strip. */
     readonly load: FloatType;
     readonly state: import("@elaraai/east").VariantType<{
@@ -156,7 +156,9 @@ export declare const workQueue: e3.RecordIndexDef<"by_status", DictType<StringTy
 }>>, StructType<{
     readonly status: StringType;
     readonly due: DateTimeType;
-}>, StringType>;
+}>, StringType, undefined> & {
+    interval: undefined;
+};
 export declare const dataBindFloat: import("@elaraai/east").ExampleDef<[], any>;
 export declare const dataBindVariants: import("@elaraai/east").ExampleDef<[], any>;
 export declare const dataBindStagedFloat: import("@elaraai/east").ExampleDef<[], any>;
@@ -171,27 +173,27 @@ export declare const dataBindPagedIndex: import("@elaraai/east").ExampleDef<[],
  * into the package.
  */
 export declare const unitCountInput: e3.DatasetDef<IntegerType, [variant<"field", "inputs">, variant<"field", "unit_count">]>;
-/** A generated unit: the weeks it runs, and what it weighs. */
+/** A generated unit: the weeks it runs, and how many sheets it prints. */
 export declare const UnitRow: StructType<{
     readonly start: DateTimeType;
     readonly end: DateTimeType;
-    readonly tonnes: FloatType;
+    readonly sheets: FloatType;
 }>;
 /**
  * The units, generated from their count — keyed `U10000`, `U10001`, …: fixed
  * width, so key order is build order. Each runs two weeks, from one of ten
- * consecutive weeks starting at W27, and weighs 40 to 119 t.
+ * consecutive weeks starting at W27, and prints 40 to 119 k sheets.
  */
 export declare const generateUnits: import("@elaraai/east").CallableFunctionExpr<[IntegerType], DictType<StringType, StructType<{
     readonly start: DateTimeType;
     readonly end: DateTimeType;
-    readonly tonnes: FloatType;
+    readonly sheets: FloatType;
 }>>>;
 /** The task that generates the units — its output is the dataset the canvas pages. */
 export declare const unitsTask: e3.TaskDef<DictType<StringType, StructType<{
     readonly start: DateTimeType;
     readonly end: DateTimeType;
-    readonly tonnes: FloatType;
+    readonly sheets: FloatType;
 }>>, [variant<"field", "tasks">, variant<"field", "units">, variant<"field", "output">]>;
 export declare const dataBindPagedBlocks: import("@elaraai/east").ExampleDef<[], any>;
 /** A bill-of-materials part — an assembly holds its parts (#954). `cost` is the

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,UAAU,EAAa,UAAU,EAAc,OAAO,EAAW,MAAM,eAAe,CAAC;AAGpN,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAElC,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,+DAA+D;AAC/D,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;;;;;;eA0C3D,CAAC;AAEH,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,+DAA+D;AAC/D,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,6CA4B7B,CAAC"}
+{"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,UAAU,EAAa,UAAU,EAAc,OAAO,EAAW,MAAM,eAAe,CAAC;AAGpN,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAElC,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,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"}

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

@@ -5,8 +5,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "@elaraai/e3-ui/jsx-runtime";
  */
 /** @jsxImportSource @elaraai/e3-ui */
 import { ArrayType, DateTimeType, DictType, East, FloatType, FunctionType, IntegerType, NullType, OptionType, RecursiveType, StringType, PatchType, StructType, none, some, variant, example } from "@elaraai/east";
-import { Button, EventStateType, Format, Input, Plan, Reactive, Separator, Sheet, Slider, Stat, Table, Text, UIComponentType, VStack } from "@elaraai/east-ui";
-import { Data } from "@elaraai/e3-ui";
+import { Box, Button, EventStateType, Format, Input, Reactive, Separator, Slider, Stat, Table, Text, UIComponentType, VStack } from "@elaraai/east-ui";
+import { Data, Plan, Sheet } from "@elaraai/e3-ui";
 import * as e3 from "@elaraai/e3";
 export const thresholdInput = e3.input('threshold', FloatType, variant('value', 50.0));
 export const thresholdPatchInput = e3.input('threshold_patch', PatchType(FloatType), variant('value', variant("unchanged", null)));
@@ -21,8 +21,8 @@ const CONFIRMED = variant("confirmed", null);
 const PROPOSED = variant("proposed", variant("recommended", null));
 const ESTIMATED = variant("estimated", null);
 /**
- * The RAW ops row — deliberately FLAT and scalar: a batch code, the job's
- * window as a start week + a duration, its tonnage, a utilisation reading, and
+ * The RAW ops row — deliberately FLAT and scalar: a job ticket, the job's
+ * window as a start week + a duration, its sheets, a utilisation reading, and
  * the lifecycle state. No dates, no display strings.
  *
  * Everything the canvas shows — the run bars, their labels, quantities, the
@@ -32,25 +32,25 @@ const ESTIMATED = variant("estimated", null);
  * the series.
  */
 export const OpsRow = StructType({
-    batch: StringType,
+    ticket: StringType,
     /** ISO week the job starts (2026); the series turns it into an instant. */
     startWeek: IntegerType,
     /** Duration in weeks. */
     weeks: IntegerType,
-    tonnes: FloatType,
+    sheets: FloatType,
     /** % utilisation, which the load series expands into a weekly strip. */
     load: FloatType,
     state: EventStateType,
 });
-/** One line's machines (or the dock's berths), keyed by id. */
-export const OpsLine = DictType(StringType, OpsRow);
+/** One hall's presses (or the delivery vans), keyed by id. */
+export const OpsHall = 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
- * snapshot harness) serves windows out of. Fifty machines across five
- * production lines plus a dock's ten berths.
+ * snapshot harness) serves windows out of. Fifty presses across five
+ * halls plus ten delivery vans.
  *
- * GROUPED by line, as the dataflow that produces it would store it: a canvas
+ * GROUPED by hall, as the dataflow that produces it would store it: a canvas
  * nests what its data nests, and a paged source is grouped where it is made —
  * in an e3 task — never on the canvas one window at a time (#822).
  *
@@ -58,80 +58,80 @@ export const OpsLine = DictType(StringType, OpsRow);
  * observed at the back, in-progress across it, confirmed then proposed then
  * estimated ahead of it.
  */
-export const opsInput = e3.input('ops', DictType(StringType, OpsLine), variant('value', new Map([
-    ["Line 1", new Map([
-            ["L1-M01", { batch: "B-201", startWeek: 25n, weeks: 3n, tonnes: 96.0, load: 78.0, state: ACTUAL }],
-            ["L1-M02", { batch: "B-204", startWeek: 26n, weeks: 2n, tonnes: 64.0, load: 71.0, state: ACTUAL }],
-            ["L1-M03", { batch: "B-214", startWeek: 28n, weeks: 3n, tonnes: 112.0, load: 88.0, state: RUNNING }],
-            ["L1-M04", { batch: "B-208", startWeek: 27n, weeks: 4n, tonnes: 104.0, load: 84.0, state: RUNNING }],
-            ["L1-M05", { batch: "B-219", startWeek: 31n, weeks: 3n, tonnes: 88.0, load: 66.0, state: CONFIRMED }],
-            ["L1-M06", { batch: "B-223", startWeek: 32n, weeks: 2n, tonnes: 72.0, load: 59.0, state: CONFIRMED }],
-            ["L1-M07", { batch: "B-231", startWeek: 33n, weeks: 4n, tonnes: 120.0, load: 92.0, state: PROPOSED }],
-            ["L1-M08", { batch: "B-236", startWeek: 35n, weeks: 3n, tonnes: 96.0, load: 74.0, state: PROPOSED }],
-            ["L1-M09", { batch: "B-242", startWeek: 36n, weeks: 3n, tonnes: 80.0, load: 63.0, state: ESTIMATED }],
-            ["L1-M10", { batch: "B-247", startWeek: 37n, weeks: 2n, tonnes: 56.0, load: 48.0, state: ESTIMATED }],
+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 }],
         ])],
-    ["Line 2", new Map([
-            ["L2-M01", { batch: "B-302", startWeek: 25n, weeks: 4n, tonnes: 118.0, load: 91.0, state: ACTUAL }],
-            ["L2-M02", { batch: "B-307", startWeek: 27n, weeks: 2n, tonnes: 52.0, load: 55.0, state: ACTUAL }],
-            ["L2-M03", { batch: "B-311", startWeek: 29n, weeks: 3n, tonnes: 92.0, load: 80.0, state: RUNNING }],
-            ["L2-M04", { batch: "B-316", startWeek: 30n, weeks: 2n, tonnes: 68.0, load: 61.0, state: CONFIRMED }],
-            ["L2-M05", { batch: "B-320", startWeek: 31n, weeks: 4n, tonnes: 128.0, load: 96.0, state: CONFIRMED }],
-            ["L2-M06", { batch: "B-325", startWeek: 33n, weeks: 3n, tonnes: 84.0, load: 69.0, state: PROPOSED }],
-            ["L2-M07", { batch: "B-329", startWeek: 34n, weeks: 2n, tonnes: 60.0, load: 52.0, state: PROPOSED }],
-            ["L2-M08", { batch: "B-334", startWeek: 35n, weeks: 4n, tonnes: 112.0, load: 87.0, state: PROPOSED }],
-            ["L2-M09", { batch: "B-338", startWeek: 37n, weeks: 3n, tonnes: 76.0, load: 64.0, state: ESTIMATED }],
-            ["L2-M10", { batch: "B-343", startWeek: 38n, weeks: 2n, tonnes: 48.0, load: 44.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 }],
         ])],
-    ["Line 3", new Map([
-            ["L3-M01", { batch: "B-401", startWeek: 24n, weeks: 3n, tonnes: 88.0, load: 73.0, state: ACTUAL }],
-            ["L3-M02", { batch: "B-405", startWeek: 26n, weeks: 4n, tonnes: 124.0, load: 94.0, state: ACTUAL }],
-            ["L3-M03", { batch: "B-410", startWeek: 29n, weeks: 2n, tonnes: 56.0, load: 51.0, state: RUNNING }],
-            ["L3-M04", { batch: "B-414", startWeek: 30n, weeks: 3n, tonnes: 100.0, load: 82.0, state: RUNNING }],
-            ["L3-M05", { batch: "B-419", startWeek: 32n, weeks: 2n, tonnes: 72.0, load: 62.0, state: CONFIRMED }],
-            ["L3-M06", { batch: "B-424", startWeek: 33n, weeks: 4n, tonnes: 116.0, load: 90.0, state: CONFIRMED }],
-            ["L3-M07", { batch: "B-428", startWeek: 35n, weeks: 3n, tonnes: 92.0, load: 76.0, state: PROPOSED }],
-            ["L3-M08", { batch: "B-433", startWeek: 36n, weeks: 2n, tonnes: 64.0, load: 57.0, state: PROPOSED }],
-            ["L3-M09", { batch: "B-437", startWeek: 37n, weeks: 4n, tonnes: 108.0, load: 85.0, state: ESTIMATED }],
-            ["L3-M10", { batch: "B-441", startWeek: 39n, weeks: 2n, tonnes: 44.0, load: 41.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 }],
         ])],
-    ["Line 4", new Map([
-            ["L4-M01", { batch: "B-502", startWeek: 25n, weeks: 2n, tonnes: 60.0, load: 54.0, state: ACTUAL }],
-            ["L4-M02", { batch: "B-506", startWeek: 27n, weeks: 3n, tonnes: 96.0, load: 79.0, state: ACTUAL }],
-            ["L4-M03", { batch: "B-511", startWeek: 28n, weeks: 4n, tonnes: 132.0, load: 98.0, state: RUNNING }],
-            ["L4-M04", { batch: "B-515", startWeek: 31n, weeks: 2n, tonnes: 68.0, load: 60.0, state: CONFIRMED }],
-            ["L4-M05", { batch: "B-520", startWeek: 32n, weeks: 3n, tonnes: 104.0, load: 83.0, state: CONFIRMED }],
-            ["L4-M06", { batch: "B-524", startWeek: 34n, weeks: 2n, tonnes: 76.0, load: 67.0, state: PROPOSED }],
-            ["L4-M07", { batch: "B-529", startWeek: 35n, weeks: 4n, tonnes: 120.0, load: 93.0, state: PROPOSED }],
-            ["L4-M08", { batch: "B-533", startWeek: 37n, weeks: 3n, tonnes: 84.0, load: 70.0, state: ESTIMATED }],
-            ["L4-M09", { batch: "B-538", startWeek: 38n, weeks: 2n, tonnes: 52.0, load: 47.0, state: ESTIMATED }],
-            ["L4-M10", { batch: "B-542", startWeek: 39n, weeks: 3n, tonnes: 88.0, load: 72.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 }],
         ])],
-    ["Line 5", new Map([
-            ["L5-M01", { batch: "B-601", startWeek: 24n, weeks: 4n, tonnes: 110.0, load: 86.0, state: ACTUAL }],
-            ["L5-M02", { batch: "B-605", startWeek: 26n, weeks: 2n, tonnes: 58.0, load: 53.0, state: ACTUAL }],
-            ["L5-M03", { batch: "B-609", startWeek: 28n, weeks: 3n, tonnes: 94.0, load: 77.0, state: RUNNING }],
-            ["L5-M04", { batch: "B-613", startWeek: 30n, weeks: 4n, tonnes: 126.0, load: 95.0, state: RUNNING }],
-            ["L5-M05", { batch: "B-618", startWeek: 32n, weeks: 2n, tonnes: 70.0, load: 61.0, state: CONFIRMED }],
-            ["L5-M06", { batch: "B-622", startWeek: 33n, weeks: 3n, tonnes: 98.0, load: 81.0, state: CONFIRMED }],
-            ["L5-M07", { batch: "B-627", startWeek: 35n, weeks: 2n, tonnes: 66.0, load: 58.0, state: PROPOSED }],
-            ["L5-M08", { batch: "B-631", startWeek: 36n, weeks: 4n, tonnes: 114.0, load: 89.0, state: PROPOSED }],
-            ["L5-M09", { batch: "B-636", startWeek: 38n, weeks: 3n, tonnes: 82.0, load: 68.0, state: ESTIMATED }],
-            ["L5-M10", { batch: "B-640", startWeek: 39n, weeks: 2n, tonnes: 50.0, load: 45.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 }],
         ])],
-    // The dock's berths — the same flat row, read as weekly load strips
-    // rather than run bars (see the `docks` series below).
-    ["Docks", new Map([
-            ["D-01", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 46.0, state: CONFIRMED }],
-            ["D-02", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 58.0, state: CONFIRMED }],
-            ["D-03", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 67.0, state: CONFIRMED }],
-            ["D-04", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 74.0, state: CONFIRMED }],
-            ["D-05", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 81.0, state: CONFIRMED }],
-            ["D-06", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 88.0, state: CONFIRMED }],
-            ["D-07", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 93.0, state: CONFIRMED }],
-            ["D-08", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 97.0, state: CONFIRMED }],
-            ["D-09", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 64.0, state: CONFIRMED }],
-            ["D-10", { batch: "—", startWeek: 27n, weeks: 12n, tonnes: 0.0, load: 52.0, state: CONFIRMED }],
+    // 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 }],
         ])],
 ])));
 /**
@@ -263,10 +263,10 @@ export const dataBindPagedPlan = example({
         "canvas", "series", "collection", "large", "dataset", "Reactive", "stream",
         "grouped", "children", "rollup", "group",
     ],
-    description: "Bind a collection dataset BY WINDOW and hand it straight to a Plan — `Data.bindPaged(ops)` returns the paged handle, the row-source contract the canvas recognises by its East type, and the factory wraps `page` with the series' row-building functions so each window's rows become canvas rows client-side. The dataset is GROUPED by line where it is made (an e3 task), so the canvas nests what the data nests: a line's span row rolls up the union of its machines' runs, stepped down into with `Plan.children`, and the dock is one collapsed group strip over its berths. The stored rows are FLAT scalars (a start week, a duration, a tonnage, a load reading); the series expressions do the reading — week arithmetic turns indices into instants, one job becomes a setup bar plus its run, and `East.Array.generate` expands a single load figure into a twelve-week heat strip. The dataset is never fetched whole and nothing here touches bytes, offsets or beast2",
+    description: "Bind a collection dataset BY WINDOW and hand it straight to a Plan — `Data.bindPaged(ops)` returns the paged handle, the row-source contract the canvas recognises by its East type, and the factory wraps `page` with the series' row-building functions so each window's rows become canvas rows client-side. The dataset is GROUPED by hall where it is made (an e3 task), so the canvas nests what the data nests: a hall's span row rolls up the union of its presses' runs, stepped down into with `Plan.children`, and the vans are one collapsed group strip. The stored rows are FLAT scalars (a start week, a duration, a sheet count, a load reading); the series expressions do the reading — week arithmetic turns indices into instants, one job becomes a make-ready bar plus its run, and `East.Array.generate` expands a single load figure into a twelve-week heat strip. The dataset is never fetched whole and nothing here touches bytes, offsets or beast2",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
             // The paged handle — the dataset's element type comes from the def,
-            // so `page(offset, limit)` is typed Option<Dict<String, OpsLine>>
+            // so `page(offset, limit)` is typed Option<Dict<String, OpsHall>>
             // with no decode step to write.
             const paged = $.let(Data.bindPaged(opsInput));
             // Monday of ISO week n, 2026 (W1 Monday = 2025-12-29). The stored
@@ -276,56 +276,56 @@ export const dataBindPagedPlan = example({
                 return w1.addWeeks(n.subtract(1n));
             }));
             const series = $.const([
-                // Lines — one span row per line whose own runs are none: it
+                // Halls — one span row per hall whose own runs are none: it
                 // DECLARES a union rollup, so its ×k concurrency bands are the
-                // renderer's, over the machines stepped down into from the
-                // line's own entry — exact in every window, since a line
-                // arrives with all of its machines.
-                Plan.series.span(OpsLine, {
-                    key: "lines", title: "Lines",
-                    match: (_l, line) => line.equal("Docks").not(),
-                    label: (_l, line) => line,
+                // renderer's, over the presses stepped down into from the
+                // hall's own entry — exact in every window, since a hall
+                // arrives with all of its presses.
+                Plan.series.span(OpsHall, {
+                    key: "halls", title: "Halls",
+                    match: (_h, hall) => hall.equal("Vans").not(),
+                    label: (_h, hall) => hall,
                     runs: _l => [],
                     rollup: "union",
                     children: Plan.children((l) => l, [
-                        // Machines — each flat row becomes TWO bars: a one-week
-                        // setup ahead of the job, then the run itself, with its
-                        // label and quantity built from the batch code and tonnage
-                        // (a quantity carries its unit — the line's bands sum by it).
+                        // 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
+                        // (a quantity carries its unit — the hall's bands sum by it).
                         Plan.series.span(OpsRow, {
-                            key: "machines", title: "Machines",
+                            key: "presses", title: "Presses",
                             label: (_r, k) => k, id: true,
-                            value: r => some(East.str `${East.Float.printFixed(r.tonnes, 0n)} t`),
+                            value: r => some(East.str `${East.Float.printFixed(r.sheets, 0n)} k sheets`),
                             runs: r => [
                                 Plan.run({
-                                    key: East.str `${r.batch}-set`,
+                                    key: East.str `${r.ticket}-mr`,
                                     start: week(r.startWeek.subtract(1n)), end: week(r.startWeek),
-                                    label: "SET", state: r.state,
+                                    label: "MAKEREADY", state: r.state,
                                 }),
                                 Plan.run({
-                                    key: r.batch,
+                                    key: r.ticket,
                                     start: week(r.startWeek), end: week(r.startWeek.add(r.weeks)),
-                                    label: East.str `RUN · ${r.batch}`,
-                                    quantity: Plan.quantity(r.tonnes, { unit: "t", format: Format.Number({ maximumFractionDigits: 0n }) }),
+                                    label: East.str `RUN · ${r.ticket}`,
+                                    quantity: Plan.quantity(r.sheets, { unit: "k sheets", format: Format.Number({ maximumFractionDigits: 0n }) }),
                                     state: r.state,
                                 }),
                             ],
                         }),
                     ]),
                 }),
-                // Docks — one collapsed group strip, its mean derived from the
-                // berths it nests: the SAME flat row read as a load strip, one
+                // Vans — one collapsed group strip, its mean derived from the
+                // vans it nests: the SAME flat row read as a load strip, one
                 // scalar `load` expanded by `East.Array.generate` into a cell
-                // per week, drifting with a per-berth phase so the strip reads
+                // per week, drifting with a per-van phase so the strip reads
                 // as a real profile rather than a flat band.
-                Plan.series.group(OpsLine, {
-                    key: "docks", title: "Docks",
-                    match: (_l, line) => line.equal("Docks"),
-                    label: (_l, line) => line,
+                Plan.series.group(OpsHall, {
+                    key: "vans", title: "Vans",
+                    match: (_h, hall) => hall.equal("Vans"),
+                    label: (_h, hall) => hall,
                     collapsed: true, summaryAggregate: "mean",
                     children: Plan.children((l) => l, [
                         Plan.series.heat(OpsRow, {
-                            key: "berths", title: "Berths",
+                            key: "van-load", title: "Van load",
                             label: (_r, k) => k, id: true,
                             cells: r => Plan.heatCells(East.Array.generate(12n, Plan.Types.HeatCell, ($, i) => {
                                 const drift = $.let(i.toFloat().multiply(2.5).subtract(6.0), FloatType);
@@ -341,7 +341,7 @@ export const dataBindPagedPlan = example({
                         }),
                     ]),
                 }),
-            ], ArrayType(Plan.Types.Series(OpsLine)));
+            ], ArrayType(Plan.Types.Series(OpsHall)));
             const axis = $.const(Plan.axis({
                 window: { min: week(24n), max: week(42n) },
                 resolution: "week", resolutions: ["month", "week", "day"], now: week(31n),
@@ -398,12 +398,12 @@ export const dataBindPagedIndex = example({
  * into the package.
  */
 export const unitCountInput = e3.input('unit_count', IntegerType, variant('value', 3000n));
-/** A generated unit: the weeks it runs, and what it weighs. */
-export const UnitRow = StructType({ start: DateTimeType, end: DateTimeType, tonnes: FloatType });
+/** A generated unit: the weeks it runs, and how many sheets it prints. */
+export const UnitRow = StructType({ start: DateTimeType, end: DateTimeType, sheets: FloatType });
 /**
  * The units, generated from their count — keyed `U10000`, `U10001`, …: fixed
  * width, so key order is build order. Each runs two weeks, from one of ten
- * consecutive weeks starting at W27, and weighs 40 to 119 t.
+ * consecutive weeks starting at W27, and prints 40 to 119 k sheets.
  */
 export const generateUnits = East.function([IntegerType], DictType(StringType, UnitRow), ($, count) => {
     // Monday of ISO week 1, 2026.
@@ -411,7 +411,7 @@ export const generateUnits = East.function([IntegerType], DictType(StringType, U
     return East.Array.range(0n, count).toDict((_$, i) => East.str `U${i.add(10000n)}`, ($2, i) => $2.const({
         start: w1.addWeeks(i.remainder(10n).add(26n)),
         end: w1.addWeeks(i.remainder(10n).add(28n)),
-        tonnes: i.remainder(80n).add(40n).toFloat(),
+        sheets: i.remainder(80n).add(40n).toFloat(),
     }, UnitRow));
 });
 /** The task that generates the units — its output is the dataset the canvas pages. */
@@ -437,10 +437,10 @@ export const dataBindPagedBlocks = example({
                 Plan.series.span(UnitRow, {
                     key: "jobs", title: "Jobs",
                     label: (_r, k) => k, id: true,
-                    value: r => some(East.str `${East.Float.printFixed(r.tonnes, 0n)} t`),
+                    value: r => some(East.str `${East.Float.printFixed(r.sheets, 0n)} k sheets`),
                     runs: (r, k) => [Plan.run({
                             key: "run", start: r.start, end: r.end, label: East.str `RUN · ${k}`,
-                            quantity: Plan.quantity(r.tonnes, { unit: "t", format: Format.Number({ maximumFractionDigits: 0n }) }),
+                            quantity: Plan.quantity(r.sheets, { unit: "k sheets", format: Format.Number({ maximumFractionDigits: 0n }) }),
                             state: "actual",
                         })],
                 }),
@@ -534,7 +534,7 @@ export const JobRow = StructType({ start: OptionType(DateTimeType), task: String
  */
 export const generateJobs = East.function([IntegerType], DictType(StringType, JobRow), ($, count) => {
     const day0 = $.const(new Date("2026-01-05T00:00:00Z"), DateTimeType);
-    const tasks = $.const(["Machining", "Painting", "Packaging"], ArrayType(StringType));
+    const tasks = $.const(["Routing", "Spraying", "Wrapping"], ArrayType(StringType));
     return East.Array.range(0n, count).toDict((_$, i) => East.str `J${i.add(1000n)}`, ($2, i) => $2.const({
         start: some(day0.addDays(i)),
         task: tasks.get(i.remainder(3n)),
@@ -552,11 +552,11 @@ export const dataBindPagedSheet = example({
     description: "A paged sheet over a BOUND keyed dataset — `Data.bindPaged(jobsTask)` over the jobs an `e3.task` generates: windows land as the planner scrolls, the footer counts elements, the blank tail appears once the source is exhausted, and key search seeks the dataset's own keys. A keyed source needs no `id` — its key is the row id. Read-only: a sheet edits a paged source only through an authoritative `onApply`, which this one declares none of",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
             const jobs = $.let(Data.bindPaged(jobsTask));
-            return (_jsxs(VStack, { gap: "3", align: "stretch", children: [_jsx(Sheet, { data: jobs, columns: {
-                            start: Sheet.column.date(JobRow, { header: "Start", width: "96px" }),
-                            task: Sheet.column.text(JobRow, { header: "Task", width: "180px" }),
-                            qty: Sheet.column.quantity(JobRow, { header: "Qty", width: "112px", format: Format.Number({ maximumFractionDigits: 0n }) }),
-                        }, readOnly: true, style: { height: "420px" } }), _jsx(Text.MonoLabel, { children: "Bound dataset \u00B7 key search and paging" })] }));
+            return (_jsxs(VStack, { gap: "3", align: "stretch", children: [_jsx(Box, { height: "420px", children: _jsx(Sheet, { data: jobs, columns: {
+                                start: Sheet.column.date(JobRow, { header: "Start", width: "96px" }),
+                                task: Sheet.column.text(JobRow, { header: "Task", width: "180px" }),
+                                qty: Sheet.column.quantity(JobRow, { header: "Qty", width: "112px", format: Format.Number({ maximumFractionDigits: 0n }) }),
+                            }, readOnly: true }) }), _jsx(Text.MonoLabel, { children: "Bound dataset \u00B7 key search and paging" })] }));
         } }))),
     inputs: [],
 });