From 8634712deba3e37bc249cae88d606999085d411a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C4=9Bj=20Such=C3=A1nek?= <jsem@matejsuchanek.cz>
Date: Wed, 5 Aug 2026 22:35:39 +0200
Subject: [PATCH 1/4] DEV-6448 Add SEB scene and Track examples

---
 README.md                                     |   4 +-
 .../seb-causal-scene-recall/README.md         |  53 ++++++
 .../seb-causal-scene-recall/example.yaml      |  33 ++++
 .../seb-causal-scene-recall/sce01.seb.json    |  24 +++
 .../seb-causal-scene-recall/scene-recall.be   |  35 ++++
 .../seb-segmented-id-track-player/README.md   |  58 +++++++
 .../example.yaml                              |  34 ++++
 .../segmented-track-player.be                 | 155 ++++++++++++++++++
 .../track-artifacts.json                      |  49 ++++++
 9 files changed, 444 insertions(+), 1 deletion(-)
 create mode 100644 data/v2/examples/seb-causal-scene-recall/README.md
 create mode 100644 data/v2/examples/seb-causal-scene-recall/example.yaml
 create mode 100644 data/v2/examples/seb-causal-scene-recall/sce01.seb.json
 create mode 100644 data/v2/examples/seb-causal-scene-recall/scene-recall.be
 create mode 100644 data/v2/examples/seb-segmented-id-track-player/README.md
 create mode 100644 data/v2/examples/seb-segmented-id-track-player/example.yaml
 create mode 100644 data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be
 create mode 100644 data/v2/examples/seb-segmented-id-track-player/track-artifacts.json

diff --git a/README.md b/README.md
index 8ac7a46..d8b0b7d 100644
--- a/README.md
+++ b/README.md
@@ -33,7 +33,9 @@ data/v2/examples/
 ├── controller-push-button-click-hold-dim-dali/      # momentary push button: short click toggles, hold dims brigh
 ├── controller-toggle-button-hold-dim-dali/          # single toggle button ramps DALI brightness, reverses on press
 ├── gledopto-gl-rc-001wl-espnow-remote/              # Berry espnow.rx examples for a GLEDOPTO GL-RC-001WL remote
-└── network-nested-element-groups/                   # App elementsJson + controlPages group → groups → devices pattern
+├── network-nested-element-groups/                   # App elementsJson + controlPages group → groups → devices pattern
+├── seb-causal-scene-recall/                         # recall a mixed-ID SEB scene at the causal event time
+└── seb-segmented-id-track-player/                   # play an ordered one-ID Track from bounded SEB segments
 ```
 
 ## Example Rules
diff --git a/data/v2/examples/seb-causal-scene-recall/README.md b/data/v2/examples/seb-causal-scene-recall/README.md
new file mode 100644
index 0000000..542b381
--- /dev/null
+++ b/data/v2/examples/seb-causal-scene-recall/README.md
@@ -0,0 +1,53 @@
+# Causal NetworkStorage Scene Recall with SEB
+
+This firmware 0.12.11 example turns a normal LABEL EventState into a local
+multi-event scene on every prepared Controller.
+
+An authoritative source emits:
+
+```berry
+spectoda.emitEvent("scene", "sce01", ID255, 31)
+```
+
+`scene-recall.be` observes `$scene[ID255]`, loads `sce01.seb` from local
+NetworkStorage and calls `SEB.land` with the callback's exact `event_millis`.
+All zero-offset scene records therefore receive the same causal Network clock
+as the event that requested the scene.
+
+## Requirements
+
+- Firmware must be exactly **0.12.11** with the final fixed-record SEB v1 API.
+- Add `scene-recall.be` to the Project Berry loaded on every participating
+  Controller.
+- Upload the exact bytes from the `hex` field in `sce01.seb.json` as a binary
+  NetworkStorage file named `sce01.seb` on those Controllers.
+- The trigger EventState is `$scene[ID255]` with a LABEL value.
+- Do not include `$scene[ID255]` in the compiled scene, or recall would recurse.
+
+The synthetic scene changes:
+
+- `$brigh[ID255]` to `50%`
+- `$color[ID1]` to `#112233` with priority `7`
+
+SEB still uses EventStore as the only state authority. A Controller that misses
+the simultaneous local landing may converge later through normal EventStore
+synchronization.
+
+## `SEB.land`, not `SEB.emit`
+
+The same Project script runs on multiple Controllers, so it must use
+`SEB.land`. Calling `SEB.emit` independently from all of them would multiply
+network traffic and duplicate authoritative emissions. Reserve `SEB.emit` for
+one deliberately selected source.
+
+## Failure and retry behavior
+
+The scene is validated and its complete deduplicated contribution is reserved
+before EventStore changes. A validation, time-conversion or queue-capacity
+failure applies nothing and returns a named error. The example logs that error;
+a production Project can retry the same `(bytes, at)` pair after the runtime
+queue has drained.
+
+The provisional variable-record blob from the earlier unreleased development
+work is not accepted by this firmware version. Recompile every scene together
+with the Project plugin before using 0.12.11.
diff --git a/data/v2/examples/seb-causal-scene-recall/example.yaml b/data/v2/examples/seb-causal-scene-recall/example.yaml
new file mode 100644
index 0000000..80ebe8f
--- /dev/null
+++ b/data/v2/examples/seb-causal-scene-recall/example.yaml
@@ -0,0 +1,33 @@
+schemaVersion: example.v2
+slug: seb-causal-scene-recall
+title: Causal NetworkStorage Scene Recall with SEB
+category: controller
+summary: >-
+  Expand a LABEL EventState such as scene=sce01 into a mixed-ID, zero-duration
+  SEB scene stored in NetworkStorage. Every prepared Controller lands the scene
+  through EventStore at the exact local-millis token of the trigger event.
+tags:
+  - berry-plugin
+  - eventstore
+  - networkstorage
+  - scene
+  - seb
+  - synchronized-events
+hardware: >-
+  Requires exactly firmware 0.12.11 with the final SEB v1 component. Install
+  the same Project Berry script and sce01.seb bytes on every Controller that
+  should land the scene simultaneously. The example uses synthetic EventStates
+  brigh[ID255] and color[ID1]. It contains no Network key, MAC address or
+  customer data.
+files:
+  - path: README.md
+    role: readme
+    language: markdown
+  - path: scene-recall.be
+    role: copy-ready Project Berry plugin
+    language: berry
+  - path: sce01.seb.json
+    role: exact NetworkStorage artifact bytes and decoded reference
+    language: json
+related:
+  - seb-segmented-id-track-player
diff --git a/data/v2/examples/seb-causal-scene-recall/sce01.seb.json b/data/v2/examples/seb-causal-scene-recall/sce01.seb.json
new file mode 100644
index 0000000..8d406f9
--- /dev/null
+++ b/data/v2/examples/seb-causal-scene-recall/sce01.seb.json
@@ -0,0 +1,24 @@
+{
+  "schema": "spectoda.seb.artifact.v1",
+  "firmware": "0.12.11",
+  "filename": "sce01.seb",
+  "encoding": "hex",
+  "hex": "534542010c00020000000c000b08af2fc89148020000ff003f332211d2c33c0300000107",
+  "durationMs": 0,
+  "records": [
+    {
+      "value": { "type": "percentage", "value": 50 },
+      "identifier": "brigh",
+      "offsetMs": 0,
+      "id": 255,
+      "priority": 0
+    },
+    {
+      "value": { "type": "color", "value": "#112233" },
+      "identifier": "color",
+      "offsetMs": 0,
+      "id": 1,
+      "priority": 7
+    }
+  ]
+}
diff --git a/data/v2/examples/seb-causal-scene-recall/scene-recall.be b/data/v2/examples/seb-causal-scene-recall/scene-recall.be
new file mode 100644
index 0000000..7b794b8
--- /dev/null
+++ b/data/v2/examples/seb-causal-scene-recall/scene-recall.be
@@ -0,0 +1,35 @@
+# Project Berry for firmware 0.12.11.
+#
+# A broadcast $scene[ID255] LABEL event loads <label>.seb from NetworkStorage.
+# The trigger itself must not be part of the compiled scene.
+def SceneRecall(S)
+    var label = S.find("label", "scene")
+    var id = S.find("id", 255)
+    var extension = S.find("extension", ".seb")
+    var trigger = EVS(label, id)
+    var last_millis = nil
+
+    trigger.cb = def(value, event_id, event_millis)
+        if event_millis == nil || event_millis == last_millis || !value.is(31)
+            return
+        end
+
+        last_millis = event_millis
+        var name = value.get(31) + extension
+        var bytes_value = spectoda.getNetworkStorageData(name)
+
+        if bytes_value == nil
+            print("SceneRecall missing", name)
+            return
+        end
+
+        var result = SEB.land(bytes_value, {"at": event_millis})
+        if !result["ok"]
+            print("SceneRecall failed", name, result["error"])
+        end
+    end
+
+    return Plugin(nil)
+end
+
+SceneRecall({"label": "scene", "id": ID255})
diff --git a/data/v2/examples/seb-segmented-id-track-player/README.md b/data/v2/examples/seb-segmented-id-track-player/README.md
new file mode 100644
index 0000000..305183e
--- /dev/null
+++ b/data/v2/examples/seb-segmented-id-track-player/README.md
@@ -0,0 +1,58 @@
+# Timeline-Driven Segmented Single-ID SEB Track
+
+This firmware 0.12.11 example keeps Player policy in Project Berry and uses the
+native `SEB.land` component only as an atomic timed EventStore primitive.
+
+The logical Track controls one state: `$brigh[ID1]`. It is represented by two
+ordered 500 ms SEB segments:
+
+| NetworkStorage file | Timeline start | Values |
+|---|---:|---|
+| `brigh-000.seb` | 0 ms | 0% at 0 ms, 75% at 100 ms, 100% at 500 ms |
+| `brigh-001.seb` | 500 ms | 25% at 0 ms, 50% at 250 ms, 75% at 500 ms |
+
+This outer ordered list is the Track. SEB itself has no Track name, file name,
+ID-homogeneity, loop or seek flag.
+
+## Requirements
+
+- Firmware must be exactly **0.12.11** with final fixed-record SEB v1.
+- Add `segmented-track-player.be` to the Project Berry on every participating
+  Controller.
+- Convert every `hex` string in `track-artifacts.json` to its exact binary
+  bytes and upload it under the listed NetworkStorage filename.
+- Start the shared timeline at `0 ms`, or seek to the explicitly supported
+  `500 ms` checkpoint.
+
+## Forward playback and pause
+
+Berry polls `timeline.getState()`. For each active segment it derives one
+stable local-millis `at` from `timeline.toMillis(segmentStart)`, keeps the
+source cursor and calls `SEB.land` with an inclusive relative `until`.
+
+While the timeline is paused, the plugin does not call the forward executor.
+No future EventState is inserted into EventStore. On resume, due records are
+processed with their original per-record Network clocks rather than the resume
+time.
+
+## Checkpoint seek
+
+The example has state checkpoints at timeline `0 ms` and `500 ms`. A timeline
+epoch discontinuity must match one of those explicit positions. Berry lands the
+checkpoint scene at the seek time, then sets the next segment cursor to `1`
+because the segment's offset-zero state is already represented by the
+checkpoint.
+
+SEB does not infer history and the Player does not replay skipped side effects.
+Add another compiled checkpoint and its next `(segment, cursor)` position for
+every additional seek target that the Project supports.
+
+## Distributed landing
+
+The reference Player uses `SEB.land` on all prepared Controllers. EventStore
+remains the authority and provides its normal later synchronization. Use
+`SEB.emit` only in a different design with one explicitly authoritative Player
+source.
+
+One SEB segment is limited to 65,535 ms and 240 records. Split longer or denser
+Tracks in the outer Project list instead of changing the native format.
diff --git a/data/v2/examples/seb-segmented-id-track-player/example.yaml b/data/v2/examples/seb-segmented-id-track-player/example.yaml
new file mode 100644
index 0000000..6db5e92
--- /dev/null
+++ b/data/v2/examples/seb-segmented-id-track-player/example.yaml
@@ -0,0 +1,34 @@
+schemaVersion: example.v2
+slug: seb-segmented-id-track-player
+title: Timeline-Driven Segmented Single-ID SEB Track
+category: controller
+summary: >-
+  Drive one logical brigh[ID1] Track from the shared timeline using bounded SEB
+  segments. Project Berry owns segment selection, stable local-millis anchors,
+  pause behavior, cursors and explicit checkpoint reconstruction after seek.
+tags:
+  - berry-plugin
+  - event-player
+  - eventstore
+  - networkstorage
+  - seb
+  - timeline
+  - checkpoint
+hardware: >-
+  Requires exactly firmware 0.12.11 with timeline.getState(), timeline.toMillis()
+  and final SEB v1. Install the same Berry source and binary NetworkStorage
+  artifacts on each Controller participating in distributed playback. The
+  example targets only synthetic brigh[ID1] and supports explicit timeline
+  entry/seek positions 0 ms and 500 ms.
+files:
+  - path: README.md
+    role: readme
+    language: markdown
+  - path: segmented-track-player.be
+    role: copy-ready Project Berry player
+    language: berry
+  - path: track-artifacts.json
+    role: exact NetworkStorage segment and checkpoint bytes
+    language: json
+related:
+  - seb-causal-scene-recall
diff --git a/data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be b/data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be
new file mode 100644
index 0000000..a811191
--- /dev/null
+++ b/data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be
@@ -0,0 +1,155 @@
+# Project-level timeline Player for firmware 0.12.11.
+# Segment: [NetworkStorage file, timeline start ms, duration ms].
+# Checkpoint: [exact seek time, scene file, next segment, next source cursor].
+def TimelinePlayer(S)
+    var segments = S.find("segments", [])
+    var checkpoints = S.find("checkpoints", [])
+    var debug = S.find("debug", false)
+    var R = {
+        "segment": 0,
+        "cursor": 0,
+        "bytes": nil,
+        "at": nil,
+        "last_time": 0,
+        "last_epoch": 0,
+        "last_paused": true,
+        "ready": false
+    }
+
+    def reset_segment(segment_index, cursor)
+        R["segment"] = segment_index
+        R["cursor"] = cursor
+        R["bytes"] = nil
+        R["at"] = nil
+    end
+
+    def open_segment()
+        if R["segment"] < 0 || R["segment"] >= segments.size()
+            return false
+        end
+
+        var segment = segments[R["segment"]]
+        var bytes_value = spectoda.getNetworkStorageData(segment[0])
+        var at = timeline.toMillis(segment[1])
+        if bytes_value == nil || at == nil
+            if debug
+                print("TimelinePlayer cannot open", segment[0])
+            end
+            return false
+        end
+
+        R["bytes"] = bytes_value
+        R["at"] = at
+        return true
+    end
+
+    def process_forward(target)
+        while R["segment"] < segments.size()
+            var segment = segments[R["segment"]]
+            if target < segment[1]
+                return true
+            end
+            if R["bytes"] == nil && !open_segment()
+                return false
+            end
+
+            var until = target - segment[1]
+            if until > segment[2]
+                until = segment[2]
+            end
+
+            var result = SEB.land(R["bytes"], {
+                "at": R["at"],
+                "cursor": R["cursor"],
+                "until": until
+            })
+            if !result["ok"]
+                if debug
+                    print("TimelinePlayer SEB error", result["error"])
+                end
+                return false
+            end
+            R["cursor"] = result["cursor"]
+
+            if !result["done"]
+                return true
+            end
+            reset_segment(R["segment"] + 1, 0)
+        end
+        return true
+    end
+
+    def reconcile(target)
+        var index = 0
+        while index < checkpoints.size()
+            var checkpoint = checkpoints[index]
+            if checkpoint[0] == target
+                var bytes_value = spectoda.getNetworkStorageData(checkpoint[1])
+                var at = timeline.toMillis(target)
+                if bytes_value == nil || at == nil
+                    return false
+                end
+
+                var result = SEB.land(bytes_value, {"at": at})
+                if !result["ok"] || !result["done"]
+                    if debug
+                        print("TimelinePlayer checkpoint error", result["error"])
+                    end
+                    return false
+                end
+
+                reset_segment(checkpoint[2], checkpoint[3])
+                return true
+            end
+            index += 1
+        end
+
+        if debug
+            print("TimelinePlayer missing checkpoint", target)
+        end
+        return false
+    end
+
+    return Plugin(def()
+        var state = timeline.getState()
+        var time = state["time"]
+        var epoch = state["epoch"]
+
+        if !R["ready"]
+            if !reconcile(time)
+                return
+            end
+            R["ready"] = true
+        # A pause-to-play transition is forward continuation even when the
+        # transport refreshes its epoch. A paused seek was reconciled already.
+        elif R["last_paused"] && !state["paused"] && time >= R["last_time"]
+            if !process_forward(time)
+                return
+            end
+        elif epoch != R["last_epoch"] || time < R["last_time"]
+            if !reconcile(time)
+                return
+            end
+        elif !state["paused"]
+            if !process_forward(time)
+                return
+            end
+        end
+
+        R["last_time"] = time
+        R["last_epoch"] = epoch
+        R["last_paused"] = state["paused"]
+    end)
+end
+
+TimelinePlayer({
+    "segments": [
+        ["brigh-000.seb", 0, 500],
+        ["brigh-001.seb", 500, 500]
+    ],
+    "checkpoints": [
+        [0, "brigh-cp-000.seb", 0, 1],
+        [500, "brigh-cp-500.seb", 1, 1]
+    ],
+    "debug": false
+})
diff --git a/data/v2/examples/seb-segmented-id-track-player/track-artifacts.json b/data/v2/examples/seb-segmented-id-track-player/track-artifacts.json
new file mode 100644
index 0000000..ed1c4d3
--- /dev/null
+++ b/data/v2/examples/seb-segmented-id-track-player/track-artifacts.json
@@ -0,0 +1,49 @@
+{
+  "schema": "spectoda.seb.artifact-set.v1",
+  "firmware": "0.12.11",
+  "encoding": "hex",
+  "track": {
+    "identifier": "brigh",
+    "id": 1
+  },
+  "files": [
+    {
+      "filename": "brigh-000.seb",
+      "timelineStartMs": 0,
+      "durationMs": 500,
+      "hex": "534542010c000300f4010c000b000000c8914802000001000b8c8647c8914802640001020b105e5fc8914802f4010100",
+      "values": [
+        { "offsetMs": 0, "percentage": 0, "priority": 0 },
+        { "offsetMs": 100, "percentage": 75, "priority": 2 },
+        { "offsetMs": 500, "percentage": 100, "priority": 0 }
+      ]
+    },
+    {
+      "filename": "brigh-001.seb",
+      "timelineStartMs": 500,
+      "durationMs": 500,
+      "hex": "534542010c000300f4010c000b84d717c8914802000001000b08af2fc8914802fa0001000b8c8647c8914802f4010100",
+      "values": [
+        { "offsetMs": 0, "percentage": 25, "priority": 0 },
+        { "offsetMs": 250, "percentage": 50, "priority": 0 },
+        { "offsetMs": 500, "percentage": 75, "priority": 0 }
+      ]
+    },
+    {
+      "filename": "brigh-cp-000.seb",
+      "seekTimelineMs": 0,
+      "nextSegment": 0,
+      "nextCursor": 1,
+      "hex": "534542010c00010000000c000b000000c891480200000100",
+      "state": { "percentage": 0 }
+    },
+    {
+      "filename": "brigh-cp-500.seb",
+      "seekTimelineMs": 500,
+      "nextSegment": 1,
+      "nextCursor": 1,
+      "hex": "534542010c00010000000c000b84d717c891480200000100",
+      "state": { "percentage": 25 }
+    }
+  ]
+}

From 6e50cc47f89b217f177c780ebbba956141b18951 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C4=9Bj=20Such=C3=A1nek?= <jsem@matejsuchanek.cz>
Date: Thu, 6 Aug 2026 00:55:46 +0200
Subject: [PATCH 2/4] Examples: Document the 4 KiB SEB segment limit

---
 data/v2/examples/seb-segmented-id-track-player/README.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/data/v2/examples/seb-segmented-id-track-player/README.md b/data/v2/examples/seb-segmented-id-track-player/README.md
index 305183e..e6d15ac 100644
--- a/data/v2/examples/seb-segmented-id-track-player/README.md
+++ b/data/v2/examples/seb-segmented-id-track-player/README.md
@@ -54,5 +54,8 @@ remains the authority and provides its normal later synchronization. Use
 `SEB.emit` only in a different design with one explicitly authoritative Player
 source.
 
-One SEB segment is limited to 65,535 ms and 240 records. Split longer or denser
-Tracks in the outer Project list instead of changing the native format.
+One SEB segment is limited to 65,535 ms and 340 records (4,092 bytes within one
+4,096-byte LittleFS data-block budget). One atomic due contribution is still
+limited to the 240-event runtime queue, so split simultaneous dense windows.
+Split longer or denser Tracks in the outer Project list instead of changing the
+native format.

From cbccd603a4fd7ced67d832137302fbfb7a69410e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C4=9Bj=20Such=C3=A1nek?= <jsem@matejsuchanek.cz>
Date: Sat, 8 Aug 2026 14:44:30 +0200
Subject: [PATCH 3/4] Examples: Align timed SEB guides with final firmware

Use the final timeline.at projection in the public segmented Track example and document pause/resume, 24-hour timeline wrap, and the 340-event atomic limit.

Scene recall remains tied to the causal trigger time and explicitly independent from the shared timeline.
---
 .../seb-causal-scene-recall/README.md         |  3 +++
 .../seb-segmented-id-track-player/README.md   | 25 +++++++++++++------
 .../example.yaml                              |  4 +--
 .../segmented-track-player.be                 | 19 ++++++++------
 4 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/data/v2/examples/seb-causal-scene-recall/README.md b/data/v2/examples/seb-causal-scene-recall/README.md
index 542b381..2e253fc 100644
--- a/data/v2/examples/seb-causal-scene-recall/README.md
+++ b/data/v2/examples/seb-causal-scene-recall/README.md
@@ -14,6 +14,9 @@ NetworkStorage and calls `SEB.land` with the callback's exact `event_millis`.
 All zero-offset scene records therefore receive the same causal Network clock
 as the event that requested the scene.
 
+This path is deliberately independent of timeline state. It does not call
+`timeline.at()` and remains causal while the shared timeline is paused.
+
 ## Requirements
 
 - Firmware must be exactly **0.12.11** with the final fixed-record SEB v1 API.
diff --git a/data/v2/examples/seb-segmented-id-track-player/README.md b/data/v2/examples/seb-segmented-id-track-player/README.md
index e6d15ac..76cc843 100644
--- a/data/v2/examples/seb-segmented-id-track-player/README.md
+++ b/data/v2/examples/seb-segmented-id-track-player/README.md
@@ -27,13 +27,22 @@ ID-homogeneity, loop or seek flag.
 ## Forward playback and pause
 
 Berry polls `timeline.getState()`. For each active segment it derives one
-stable local-millis `at` from `timeline.toMillis(segmentStart)`, keeps the
+local-millis `at` from `timeline.at(segmentStart)`, keeps the
 source cursor and calls `SEB.land` with an inclusive relative `until`.
 
 While the timeline is paused, the plugin does not call the forward executor.
-No future EventState is inserted into EventStore. On resume, due records are
-processed with their original per-record Network clocks rather than the resume
-time.
+No future EventState is inserted into EventStore. Resume keeps the timeline
+epoch but creates a new causal projection. The plugin reopens timing for the
+remaining source suffix, so future record clocks include wall-clock time spent
+paused. Seek or loop changes the epoch and reconstructs both timing and cursor
+from a complete checkpoint.
+
+`timeline.at(position)` projects the current `(timeline position P, Network
+clock C)` reference as `C + (position - P)`. It returns a signed wrapping local
+millis token, or `nil` outside the unambiguous ±2^31 ms conversion window.
+Timeline position itself is a 24-hour ring (`0..86,399,999`), independent from
+the local token's 32-bit wrap. Midnight stays continuous for Players, Layers
+and animations; an exact 12-hour position difference is ambiguous.
 
 ## Checkpoint seek
 
@@ -55,7 +64,7 @@ remains the authority and provides its normal later synchronization. Use
 source.
 
 One SEB segment is limited to 65,535 ms and 340 records (4,092 bytes within one
-4,096-byte LittleFS data-block budget). One atomic due contribution is still
-limited to the 240-event runtime queue, so split simultaneous dense windows.
-Split longer or denser Tracks in the outer Project list instead of changing the
-native format.
+4,096-byte LittleFS data-block budget). One atomic due contribution accepts the
+full 340-record SEB. A 341st pending event fails before queue, EventStore or
+cursor mutation. Split longer Tracks in the outer Project list instead of
+changing the native format.
diff --git a/data/v2/examples/seb-segmented-id-track-player/example.yaml b/data/v2/examples/seb-segmented-id-track-player/example.yaml
index 6db5e92..326a153 100644
--- a/data/v2/examples/seb-segmented-id-track-player/example.yaml
+++ b/data/v2/examples/seb-segmented-id-track-player/example.yaml
@@ -4,7 +4,7 @@ title: Timeline-Driven Segmented Single-ID SEB Track
 category: controller
 summary: >-
   Drive one logical brigh[ID1] Track from the shared timeline using bounded SEB
-  segments. Project Berry owns segment selection, stable local-millis anchors,
+  segments. Project Berry owns segment selection, local-millis projections,
   pause behavior, cursors and explicit checkpoint reconstruction after seek.
 tags:
   - berry-plugin
@@ -15,7 +15,7 @@ tags:
   - timeline
   - checkpoint
 hardware: >-
-  Requires exactly firmware 0.12.11 with timeline.getState(), timeline.toMillis()
+  Requires exactly firmware 0.12.11 with timeline.getState(), timeline.at()
   and final SEB v1. Install the same Berry source and binary NetworkStorage
   artifacts on each Controller participating in distributed playback. The
   example targets only synthetic brigh[ID1] and supports explicit timeline
diff --git a/data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be b/data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be
index a811191..ffffdac 100644
--- a/data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be
+++ b/data/v2/examples/seb-segmented-id-track-player/segmented-track-player.be
@@ -30,7 +30,7 @@ def TimelinePlayer(S)
 
         var segment = segments[R["segment"]]
         var bytes_value = spectoda.getNetworkStorageData(segment[0])
-        var at = timeline.toMillis(segment[1])
+        var at = timeline.at(segment[1])
         if bytes_value == nil || at == nil
             if debug
                 print("TimelinePlayer cannot open", segment[0])
@@ -85,7 +85,7 @@ def TimelinePlayer(S)
             var checkpoint = checkpoints[index]
             if checkpoint[0] == target
                 var bytes_value = spectoda.getNetworkStorageData(checkpoint[1])
-                var at = timeline.toMillis(target)
+                var at = timeline.at(target)
                 if bytes_value == nil || at == nil
                     return false
                 end
@@ -120,16 +120,19 @@ def TimelinePlayer(S)
                 return
             end
             R["ready"] = true
-        # A pause-to-play transition is forward continuation even when the
-        # transport refreshes its epoch. A paused seek was reconciled already.
-        elif R["last_paused"] && !state["paused"] && time >= R["last_time"]
-            if !process_forward(time)
-                return
-            end
         elif epoch != R["last_epoch"] || time < R["last_time"]
             if !reconcile(time)
                 return
             end
+        # Resume keeps the epoch but establishes a new causal projection.
+        # Reopen timing for the remaining source suffix so its event clocks
+        # include the wall-clock interval spent paused.
+        elif R["last_paused"] && !state["paused"]
+            R["bytes"] = nil
+            R["at"] = nil
+            if !process_forward(time)
+                return
+            end
         elif !state["paused"]
             if !process_forward(time)
                 return

From 928509b722b1e67fb4e2eb002e8da024dc86845c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C4=9Bj=20Such=C3=A1nek?= <jsem@matejsuchanek.cz>
Date: Sat, 8 Aug 2026 18:27:52 +0200
Subject: [PATCH 4/4] SEB: Recall scenes directly from NetworkStorage

Use the native NetworkStorage source overload so Project Berry no longer materializes scene payloads in its constrained heap. The trigger event's causal millis token remains the single timestamp for every landed scene value.\n\nRefresh the public terminology to distinguish Event values from EventStore state.
---
 data/v2/examples/seb-causal-scene-recall/README.md   | 10 +++++-----
 .../v2/examples/seb-causal-scene-recall/example.yaml |  6 +++---
 .../examples/seb-causal-scene-recall/scene-recall.be | 12 ++++--------
 3 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/data/v2/examples/seb-causal-scene-recall/README.md b/data/v2/examples/seb-causal-scene-recall/README.md
index 2e253fc..4430e28 100644
--- a/data/v2/examples/seb-causal-scene-recall/README.md
+++ b/data/v2/examples/seb-causal-scene-recall/README.md
@@ -1,6 +1,6 @@
 # Causal NetworkStorage Scene Recall with SEB
 
-This firmware 0.12.11 example turns a normal LABEL EventState into a local
+This firmware 0.12.11 example turns a normal LABEL Event value into a local
 multi-event scene on every prepared Controller.
 
 An authoritative source emits:
@@ -9,8 +9,8 @@ An authoritative source emits:
 spectoda.emitEvent("scene", "sce01", ID255, 31)
 ```
 
-`scene-recall.be` observes `$scene[ID255]`, loads `sce01.seb` from local
-NetworkStorage and calls `SEB.land` with the callback's exact `event_millis`.
+`scene-recall.be` observes `$scene[ID255]` and calls the native NetworkStorage
+source overload of `SEB.land` with the callback's exact `event_millis`.
 All zero-offset scene records therefore receive the same causal Network clock
 as the event that requested the scene.
 
@@ -24,7 +24,7 @@ This path is deliberately independent of timeline state. It does not call
   Controller.
 - Upload the exact bytes from the `hex` field in `sce01.seb.json` as a binary
   NetworkStorage file named `sce01.seb` on those Controllers.
-- The trigger EventState is `$scene[ID255]` with a LABEL value.
+- The trigger Event is `$scene[ID255]` with a LABEL value.
 - Do not include `$scene[ID255]` in the compiled scene, or recall would recurse.
 
 The synthetic scene changes:
@@ -48,7 +48,7 @@ one deliberately selected source.
 The scene is validated and its complete deduplicated contribution is reserved
 before EventStore changes. A validation, time-conversion or queue-capacity
 failure applies nothing and returns a named error. The example logs that error;
-a production Project can retry the same `(bytes, at)` pair after the runtime
+a production Project can retry the same `(filename, at)` pair after the runtime
 queue has drained.
 
 The provisional variable-record blob from the earlier unreleased development
diff --git a/data/v2/examples/seb-causal-scene-recall/example.yaml b/data/v2/examples/seb-causal-scene-recall/example.yaml
index 80ebe8f..2f093f1 100644
--- a/data/v2/examples/seb-causal-scene-recall/example.yaml
+++ b/data/v2/examples/seb-causal-scene-recall/example.yaml
@@ -3,7 +3,7 @@ slug: seb-causal-scene-recall
 title: Causal NetworkStorage Scene Recall with SEB
 category: controller
 summary: >-
-  Expand a LABEL EventState such as scene=sce01 into a mixed-ID, zero-duration
+  Expand a LABEL Event such as scene=sce01 into a mixed-ID, zero-duration
   SEB scene stored in NetworkStorage. Every prepared Controller lands the scene
   through EventStore at the exact local-millis token of the trigger event.
 tags:
@@ -16,8 +16,8 @@ tags:
 hardware: >-
   Requires exactly firmware 0.12.11 with the final SEB v1 component. Install
   the same Project Berry script and sce01.seb bytes on every Controller that
-  should land the scene simultaneously. The example uses synthetic EventStates
-  brigh[ID255] and color[ID1]. It contains no Network key, MAC address or
+  should land the scene simultaneously. The example uses synthetic Event
+  values brigh[ID255] and color[ID1]. It contains no Network key, MAC address or
   customer data.
 files:
   - path: README.md
diff --git a/data/v2/examples/seb-causal-scene-recall/scene-recall.be b/data/v2/examples/seb-causal-scene-recall/scene-recall.be
index 7b794b8..9eb39fd 100644
--- a/data/v2/examples/seb-causal-scene-recall/scene-recall.be
+++ b/data/v2/examples/seb-causal-scene-recall/scene-recall.be
@@ -16,14 +16,10 @@ def SceneRecall(S)
 
         last_millis = event_millis
         var name = value.get(31) + extension
-        var bytes_value = spectoda.getNetworkStorageData(name)
-
-        if bytes_value == nil
-            print("SceneRecall missing", name)
-            return
-        end
-
-        var result = SEB.land(bytes_value, {"at": event_millis})
+        var result = SEB.land(name, {
+            "source": "networkStorage",
+            "at": event_millis
+        })
         if !result["ok"]
             print("SceneRecall failed", name, result["error"])
         end