@elaraai/e3-ui 1.0.97 → 1.0.99

package/dist/test/allocation/allocation.examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"allocation.examples.d.ts","sourceRoot":"","sources":["../../../test/allocation/allocation.examples.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"allocation.examples.d.ts","sourceRoot":"","sources":["../../../test/allocation/allocation.examples.tsx"],"names":[],"mappings":"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"}

package/dist/test/allocation/allocation.examples.js

@@ -6,56 +6,104 @@ import { jsx as _jsx, jsxs as _jsxs } from "@elaraai/e3-ui/jsx-runtime";
 /** @jsxImportSource @elaraai/e3-ui */
 import { ArrayType, DateTimeType, DictType, East, FunctionType, NullType, PatchType, StringType, example, none, some, variant } from "@elaraai/east";
 import e3 from "@elaraai/e3";
-import { Box, Field, Reactive, Slice, UIComponentType, VStack } from "@elaraai/east-ui";
+import { Box, Button, Field, HStack, Reactive, Slice, Text, UIComponentType, VStack } from "@elaraai/east-ui";
 import { Allocation, Data, Func, Record, Schedule } from "@elaraai/e3-ui";
 import { Bay, Kiln, KilnBin, MinimalBin, TimberLoad, YardDay, yardArrivals, yardBayRows, yardBinHistoryRows, yardBinRows, yardDay, yardDayHistoryRows, yardDayRows, yardKilns, yardMinimalBinRows, yardPublishedDay, yardSplitDay, } from "./kiln-yard.js";
 // The kiln yard's own records (`Builder Interfaces Spec.md` §6.5): its bins and the days of its plan, which the board
 // writes, each through its patch door; and what it reads — its kilns, its loads and its bays.
 /** The bins, every day's, each the yard's own row. */
-export const kilnBins = e3.record("kiln_bins", DictType(StringType, KilnBin), yardBinRows);
-export const kilnBinsPatch = e3.mutation.patch(kilnBins);
-/** The bins by their time: what the board's slice reads a day of them through, its navigation writing the range. */
-export const kilnBinsByTime = e3.recordIndex("kiln_bins_by_time", kilnBins, { interval: { from: "at", to: "at" } });
+export const kilnBins = e3.record("kiln_bins", DictType(StringType, KilnBin), {
+    initial: yardBinRows,
+    indexes: (index) => ({
+        // The bins by their time: what the board's slice reads a day of them through, its navigation writing the range.
+        kiln_bins_by_time: index.interval({ from: "at", to: "at" }),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
+});
 /** The days of the yard's plan, what the board publishes: Tue 4 May issued, Tue 11 and Wed 12 drafts. */
-export const yardDays = e3.record("yard_days", DictType(DateTimeType, YardDay), yardDayRows);
-export const yardDaysPatch = e3.mutation.patch(yardDays);
+export const yardDays = e3.record("yard_days", DictType(DateTimeType, YardDay), {
+    initial: yardDayRows,
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
+});
 /** The same bins, locked for the day: their door, a checked one, refuses every change, naming why — what a Save over it is answered. */
-export const kilnLockedBins = e3.record("kiln_locked_bins", DictType(StringType, KilnBin), yardBinRows);
-export const kilnLockedBinsByTime = e3.recordIndex("kiln_locked_bins_by_time", kilnLockedBins, { interval: { from: "at", to: "at" } });
-export const kilnLockedBinsPatch = e3.mutation.reduce("patch", kilnLockedBins, East.function([DictType(StringType, KilnBin), PatchType(DictType(StringType, KilnBin))], DictType(StringType, KilnBin), ($, bins, _patch) => {
-    $.error("the yard's bins are locked for the day");
-    return bins;
-}));
+export const kilnLockedBins = e3.record("kiln_locked_bins", DictType(StringType, KilnBin), {
+    initial: yardBinRows,
+    indexes: (index) => ({
+        kiln_locked_bins_by_time: index.interval({ from: "at", to: "at" }),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.reduce(East.function([DictType(StringType, KilnBin), PatchType(DictType(StringType, KilnBin))], DictType(StringType, KilnBin), ($, bins, _patch) => {
+            $.error("the yard's bins are locked for the day");
+            return bins;
+        })),
+    }),
+});
 /** The same days, locked: the site office issues them, and their door refuses every change, naming why. */
-export const yardLockedDays = e3.record("yard_locked_days", DictType(DateTimeType, YardDay), yardDayRows);
-export const yardLockedDaysPatch = e3.mutation.reduce("patch", yardLockedDays, East.function([DictType(DateTimeType, YardDay), PatchType(DictType(DateTimeType, YardDay))], DictType(DateTimeType, YardDay), ($, days, _patch) => {
-    $.error("the site office issues the yard's days");
-    return days;
-}));
+export const yardLockedDays = e3.record("yard_locked_days", DictType(DateTimeType, YardDay), {
+    initial: yardDayRows,
+    mutations: (mutation) => ({
+        patch: mutation.reduce(East.function([DictType(DateTimeType, YardDay), PatchType(DictType(DateTimeType, YardDay))], DictType(DateTimeType, YardDay), ($, days, _patch) => {
+            $.error("the site office issues the yard's days");
+            return days;
+        })),
+    }),
+});
 /** Two years of the yard's bins, for the board read a day at a time through its slice. */
-export const kilnBinHistory = e3.record("kiln_bin_history", DictType(StringType, KilnBin), yardBinHistoryRows);
-export const kilnBinHistoryPatch = e3.mutation.patch(kilnBinHistory);
-export const kilnBinHistoryByTime = e3.recordIndex("kiln_bin_history_by_time", kilnBinHistory, { interval: { from: "at", to: "at" } });
+export const kilnBinHistory = e3.record("kiln_bin_history", DictType(StringType, KilnBin), {
+    initial: yardBinHistoryRows,
+    indexes: (index) => ({
+        kiln_bin_history_by_time: index.interval({ from: "at", to: "at" }),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
+});
 /** The days of those two years, read by key. */
-export const yardDayHistory = e3.record("yard_day_history", DictType(DateTimeType, YardDay), yardDayHistoryRows);
-export const yardDayHistoryPatch = e3.mutation.patch(yardDayHistory);
+export const yardDayHistory = e3.record("yard_day_history", DictType(DateTimeType, YardDay), {
+    initial: yardDayHistoryRows,
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
+});
 // The kilns, indexed by group for the narrowing; and by group then max, so a group and a range of max combine, and by name, for a search.
-export const kilns = e3.record("kilns", DictType(StringType, Kiln), yardKilns);
-export const kilnsByGroup = e3.recordIndex("kilns_by_group", kilns, { on: ["group"] });
-export const kilnsByGroupMax = e3.recordIndex("kilns_by_group_max", kilns, { on: ["group", "max"] });
-export const kilnsByName = e3.recordIndex("kilns_by_name", kilns, { on: ["name"] });
-// The kilns' patch door: another session's edit of the yard's kilns, as the renderer's tests on e3 commit it (#1376).
-export const kilnsPatch = e3.mutation.patch(kilns);
+export const kilns = e3.record("kilns", DictType(StringType, Kiln), {
+    initial: yardKilns,
+    indexes: (index) => ({
+        kilns_by_group: index.on(["group"]),
+        kilns_by_group_max: index.on(["group", "max"]),
+        kilns_by_name: index.on(["name"]),
+    }),
+    mutations: (mutation) => ({
+        // The kilns' patch door: another session's edit of the yard's kilns, as the renderer's tests on e3 commit it (#1376).
+        patch: mutation.patch(),
+    }),
+});
 // Every load the day may book: booked or not, the board tells them apart by its bins; indexed by spec for the narrowing.
-export const arrivals = e3.record("arrivals", DictType(StringType, TimberLoad), yardArrivals);
-export const arrivalsBySpec = e3.recordIndex("arrivals_by_spec", arrivals, { on: ["spec"] });
+export const arrivals = e3.record("arrivals", DictType(StringType, TimberLoad), {
+    initial: yardArrivals,
+    indexes: (index) => ({
+        arrivals_by_spec: index.on(["spec"]),
+    }),
+});
 // The unloading bays, by key: each takes one bin an hour, at its offset past the hour; indexed by area, and by cover, for the narrowing.
-export const yardBays = e3.record("yard_bays", DictType(StringType, Bay), yardBayRows);
-export const yardBaysByArea = e3.recordIndex("yard_bays_by_area", yardBays, { on: ["area"] });
-export const yardBaysByCover = e3.recordIndex("yard_bays_by_cover", yardBays, { on: ["cover"] });
+export const yardBays = e3.record("yard_bays", DictType(StringType, Bay), {
+    initial: yardBayRows,
+    indexes: (index) => ({
+        yard_bays_by_area: index.on(["area"]),
+        yard_bays_by_cover: index.on(["cover"]),
+    }),
+});
 // The smallest board's own bins (§6.5): the board's roles alone.
-export const minimalBins = e3.record("kiln_minimal_bins", DictType(StringType, MinimalBin), yardMinimalBinRows);
-export const minimalBinsPatch = e3.mutation.patch(minimalBins);
+export const minimalBins = e3.record("kiln_minimal_bins", DictType(StringType, MinimalBin), {
+    initial: yardMinimalBinRows,
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
+});
 /** The yard's fit's body: the built-in rules, then a greedy look-ahead over the day's other loads. */
 export const yardFitBody = East.function([Allocation.Types.FitRequest(KilnBin)], Allocation.Types.FitResult, ($, req) => {
     const answer = $.const(Allocation.answer(KilnBin));
@@ -88,7 +136,7 @@ export const allocationMinimal = example({
     description: "The smallest board over the app's own records: bins with only the board's roles — their bay, time, load, m³, split across kilns and drying time — the bays, the kilns and the day's loads, and the yard's fit on e3. No library, no inspector and no Publish; every gesture is still a draft until Save.",
     keywords: ["Allocation", "Schedule.events", "Schedule.resources", "Allocation.arrivals", "Record.bind", "Func.bind", "e3.function", "fit", "minimal", "BuilderFrame", "Save"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(minimalBins, [minimalBinsPatch]));
+            const bins = $.let(Record.bind(minimalBins));
             const loads = $.let(Data.bind(arrivals));
             const yard = $.let(Data.bind(kilns));
             const bays = $.let(Data.bind(yardBays));
@@ -108,17 +156,17 @@ export const allocationKilnYard = example({
     keywords: ["Allocation", "Schedule.events", "Schedule.resources", "Schedule.periods", "Allocation.arrivals", "Slice.bindRecords", "Data.bindPaged", "Func.bind", "fit", "check", "columns", "links", "Publish", "Library", "narrowing"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
             // What the board writes: the bins and the days of the plan, each through its patch door.
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay, kiln and load is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea, yardBaysByCover] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroupMax, kilnsByName] }));
-            const loadIndex = $.let(Data.bindPaged(arrivals, { indexes: [arrivalsBySpec] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area", "yard_bays_by_cover"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group_max", "kilns_by_name"] }));
+            const loadIndex = $.let(Data.bindPaged(arrivals, { indexes: ["arrivals_by_spec"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationKilnYard", {
                 // The day's bins: the board's navigation writes the range; no chip picks the day.
                 bin: { source: byTime, range: "at" },
@@ -180,17 +228,17 @@ export const allocationTable = example({
     description: "The kiln yard as a Table: one row per bay slot and one per extra bin of a batch, in four foldable time bands, narrowed by the bays' area or cover, the kilns' group, max or name, and the loads' spec; the same drafts, library and inspector as the Timeline.",
     keywords: ["Allocation", "Table", "Schedule.events", "Schedule.resources", "Schedule.periods", "Allocation.arrivals", "Func.bind", "columns", "Chooser", "Slice.bindRecords"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay, kiln and load is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea, yardBaysByCover] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroupMax, kilnsByName] }));
-            const loadIndex = $.let(Data.bindPaged(arrivals, { indexes: [arrivalsBySpec] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area", "yard_bays_by_cover"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group_max", "kilns_by_name"] }));
+            const loadIndex = $.let(Data.bindPaged(arrivals, { indexes: ["arrivals_by_spec"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationTable", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, icon: { prefix: "fas", name: "warehouse" },
@@ -235,16 +283,16 @@ export const allocationLabels = example({
     description: "The kiln yard in its own words: labels={{ lane: \"Bay\", arrival: { one: \"Delivery\", other: \"Deliveries\" }, resource: \"Kiln\", quantity: \"Vol\" }} names the board's lanes, arrivals, resources and quantity everywhere it writes them — the Table's heads, the Chooser, the placeholders, the drag captions, the banners and the narrowing's summary — and table={{ bands }} sets the Table's time bands to the yard's shifts.",
     keywords: ["Allocation", "labels", "nouns", "arrival", "Table", "bands", "Schedule.events", "Allocation.arrivals", "Func.bind"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationLabels", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, fields: { area: { label: "Area", hints: ["North", "South"] } } },
@@ -285,16 +333,16 @@ export const allocationPublished = example({
     description: "A published day, Tue 4 May, its status the yard's own day issued: read-only under its banner; navigation, the narrowing, the focus, links and the inspector still work.",
     keywords: ["Allocation", "Schedule.periods", "Publish", "published", "readOnly", "Record.bind"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationPublished", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, fields: { area: { label: "Area", hints: ["North", "South"] } } },
@@ -335,15 +383,15 @@ export const allocationNoPublish = example({
     description: "The kiln yard with no `periods`: no status chip and no Publish; Save writes the day's bins as drafts.",
     keywords: ["Allocation", "periods", "publish", "Save", "Schedule.events", "Record.bind"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationNoPublish", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, fields: { area: { label: "Area", hints: ["North", "South"] } } },
@@ -384,16 +432,16 @@ export const allocationSplit = example({
     description: "Loads split across kilns on Wed 12 May: each bin's parts on their kilns, one load with 4 m³ unallocated and its Partly allocated issue, and a link to each part.",
     keywords: ["Allocation", "split", "parts", "unallocated", "Find a fit", "links", "Schedule.events"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationSplit", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, fields: { area: { label: "Area", hints: ["North", "South"] } } },
@@ -432,20 +480,20 @@ export const allocationSplit = example({
 });
 export const allocationWindowed = example({
     description: "Two years of bins read a day at a time through the slice's bin source — an interval index over their times, its range the board's own navigation — and the plan's days by key: only the active day and the open picker's month are requested, never a record whole.",
-    keywords: ["Allocation", "Schedule.events", "Schedule.periods", "Slice.bindRecords", "Data.bindPaged", "recordIndex", "interval", "history", "entries", "BuilderFrame", "Save", "Publish"], inputs: [],
+    keywords: ["Allocation", "Schedule.events", "Schedule.periods", "Slice.bindRecords", "Data.bindPaged", "indexes", "interval", "history", "entries", "BuilderFrame", "Save", "Publish"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBinHistory, [kilnBinHistoryPatch]));
+            const bins = $.let(Record.bind(kilnBinHistory));
             const entries = $.let(Data.bindPaged(kilnBinHistory));
-            const byTime = $.let(Data.bindPaged(kilnBinHistory, { indexes: [kilnBinHistoryByTime] }));
+            const byTime = $.let(Data.bindPaged(kilnBinHistory, { indexes: ["kiln_bin_history_by_time"] }));
             // The days of the plan read by key: the day, and the open picker's month.
-            const days = $.let(Record.bind(yardDayHistory, [yardDayHistoryPatch]));
+            const days = $.let(Record.bind(yardDayHistory));
             const dayEntries = $.let(Data.bindPaged(yardDayHistory));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationWindowed", {
                 // The day's bins: the board's navigation writes the range.
                 bin: { source: byTime, range: "at" },
@@ -487,16 +535,16 @@ export const allocationMobile = example({
     description: "The kiln yard in a 390px container: a card per kiln (or per slot in the Table) with Book, Reserve, Allocate, Unlink and Back to Arrivals in anchored popovers; no drag source or target.",
     keywords: ["Allocation", "mobile", "narrow", "cards", "Schedule.events", "Record.bind"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationMobile", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, fields: { area: { label: "Area", hints: ["North", "South"] } } },
@@ -537,16 +585,16 @@ export const allocationCustomBin = example({
     description: "The bin kind's own inspector: the yard's typed bin form — its m³ and its loading instruction, each change the bin written back whole — in place of the built-in quantity field and the row's other fields.",
     keywords: ["Allocation", "Schedule.events", "inspector", "bin", "Field", "typed form"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationCustomBin", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, fields: { area: { label: "Area", hints: ["North", "South"] } } },
@@ -594,16 +642,16 @@ export const allocationFitRule = example({
     description: "The ready-made fit with one yard rule over it, as an e3.function: a bulk kiln takes no load under 20 m³, so LD-2235 (8 m³) fits K-305 alone.",
     keywords: ["Allocation", "fit", "e3.function", "Func.bind", "Allocation.fit", "Allocation.answer", "rule"], inputs: [],
     fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
-            const bins = $.let(Record.bind(kilnBins, [kilnBinsPatch]));
+            const bins = $.let(Record.bind(kilnBins));
             const entries = $.let(Data.bindPaged(kilnBins));
-            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: [kilnBinsByTime] }));
-            const days = $.let(Record.bind(yardDays, [yardDaysPatch]));
+            const byTime = $.let(Data.bindPaged(kilnBins, { indexes: ["kiln_bins_by_time"] }));
+            const days = $.let(Record.bind(yardDays));
             // Every bay and kiln is the calculation scope; the narrowing only chooses which show.
             const yard = $.let(Data.bind(kilns));
             const loads = $.let(Data.bind(arrivals));
             const bays = $.let(Data.bind(yardBays));
-            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: [yardBaysByArea] }));
-            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: [kilnsByGroup] }));
+            const bayIndex = $.let(Data.bindPaged(yardBays, { indexes: ["yard_bays_by_area"] }));
+            const kilnIndex = $.let(Data.bindPaged(kilns, { indexes: ["kilns_by_group"] }));
             const slice = $.let(Slice.bindRecords("ex.allocationFitRule", {
                 bin: { source: byTime, range: "at" },
                 bays: { source: bayIndex, fields: { area: { label: "Area", hints: ["North", "South"] } } },
@@ -640,4 +688,46 @@ export const allocationFitRule = example({
                     ] }) });
         } })),
 });
+/** The bins the conflicts example edits, in a record of their own, so no other example's edits meet them. */
+export const conflictBins = e3.record("kiln_conflict_bins", DictType(StringType, MinimalBin), {
+    initial: yardMinimalBinRows,
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+        // Someone else's save: every bin a quarter hour later, and 1 m³ more on each of its kilns, its m³ with them.
+        elsewhere: mutation.reduce(East.function([DictType(StringType, MinimalBin)], DictType(StringType, MinimalBin), (_$, bins) => bins.map((_$2, bin) => ({
+            bay: bin.bay, at: bin.at.addMinutes(15n), load: bin.load,
+            m3: bin.m3.add(bin.kilns.size().toFloat()),
+            kilns: bin.kilns.map((_$3, share) => share.add(1.0)),
+            dryFor: bin.dryFor,
+        })))),
+    }),
+});
+/**
+ * Your edits meeting someone else's save, in one window: edit, then press
+ * Someone else saves, which saves another person's change to the same bins —
+ * every bin a quarter hour later, and 1 m³ more on each of its kilns. A bin you
+ * moved is a conflict on its time; a bin's m³ you changed is one card, its
+ * split across kilns going with it. Each press saves their change again.
+ */
+export const allocationConflicts = example({
+    description: "Your edits meeting someone else's save, in one window — move a bin or change its m³ in the panel, then press Someone else saves, which saves another person's change to the same bins (every bin a quarter hour later, 1 m³ more on each of its kilns), so yours conflict and wait to be chosen, an m³ and its split across kilns one card",
+    keywords: ["Allocation", "conflict", "conflicts", "someone else", "Choose", "quantity", "split", "Schedule.events", "Record.bind", "mutate", "Button", "inspector", "Save"], inputs: [],
+    fn: East.function([], UIComponentType, _$ => _jsx(Reactive, { children: $ => {
+            const bins = $.let(Record.bind(conflictBins, ["patch"]));
+            const others = $.let(Record.bind(conflictBins, ["elsewhere"]));
+            const theirs = $.const(East.function([], NullType, ($) => { $(others.mutate.elsewhere()); }));
+            const loads = $.let(Data.bind(arrivals));
+            const yard = $.let(Data.bind(kilns));
+            const bays = $.let(Data.bind(yardBays));
+            const fit = $.let(Func.bind(minimalFit));
+            return _jsxs(VStack, { gap: "3", align: "stretch", children: [_jsxs(HStack, { gap: "3", children: [_jsx(Button, { variant: "outline", onClick: theirs, loading: others.mutate.pending(), children: "Someone else saves" }), _jsx(Text, { color: "fg.muted", children: "Their change: every bin a quarter hour later, 1 m\u00B3 more on each of its kilns" })] }), _jsx(Box, { width: "100%", height: "760px", children: _jsx(Allocation, { id: "allocationConflicts", fit: fit, inspector: true, view: { date: yardDay }, events: { bin: Schedule.events(bins, {
+                                    name: "Bin", icon: "box",
+                                    at: "at", resource: { field: "bay", of: "bays" }, arrival: "load",
+                                    quantity: { field: "m3", unit: "m³" }, parts: { field: "kilns", of: "kilns" }, hold: "dryFor",
+                                }) }, resources: {
+                                bays: Schedule.resources(bays.read(), { name: "Bays", icon: "warehouse", label: b => b.name, offset: b => b.offset }),
+                                kilns: Schedule.resources(yard.read(), { name: "Kilns", icon: "fire", label: k => k.name, min: k => k.min, max: k => k.max, jobs: k => k.charges }),
+                            }, arrivals: Allocation.arrivals(loads.read(), { label: l => l.code, quantity: l => l.m3, hold: l => variant("days", l.dryingDays) }) }) })] });
+        } })),
+});
 //# sourceMappingURL=allocation.examples.js.map