feat(B-0824): generator-as-time-source for non-linear time + IObservable simulation + typed time-units + Rx/DST/scheduler best-practices#5265
Merged
AceHack merged 3 commits intoMay 26, 2026
Conversation
…injection primitive (Aaron 2026-05-26) Two complementary Aaron 2026-05-26 substrate landings: 1. "concretly the difference between DI and Simulation is if you DI the generator function or the IObservable of the function." 2. "IObservable is now you go from static / no time to injecting time" The distinction is a SINGLE BIT — what you wrap the injected function in: - Inject Generator<T> = static / NOW (DI; Sub-target 12) - Inject IObservable<Generator<T>> = time-injection / OVER-TIME (Simulation) IObservable IS THE time-injection primitive. The architectural transformation: take any function-shape + wrap in IObservable → static dependency becomes time-flowing dependency → DI container becomes simulation environment. 4-property comparison table (without/with IObservable wrap) + 6-substrate-stack reactive-extensions table (Sub-targets 7-12 + B-0825 time-axis) — IObservable-DI shift IS what makes B-0825 time-modeled deps FIRST-CLASS at substrate-engineering scope. Time isn't a parameter you pass; it's an axis the substrate INJECTS via IObservable wrapping. 6-system prior-art table (Angular Observable / React useContext-Subject / Spring Reactive Mono-Flux / F# IObservable / Rx core / CockroachDB CHANGEFEEDs) — Zeta inherits the universal reactive-DI pattern. Substrate-engineering implication: Simulation IS DI-with-time-axis- injected-via-IObservable-wrapping. Composes with DST always-active discipline (simulation IS DST substrate at substrate-engineering scope). Sub-target 13 (new — IObservable time-injection substrate): 6 sub-tasks covering CockroachDB CHANGEFEEDS as generator-stream primitive / reactive composition graph (Rx semantics) / subscriber pattern / backpressure (throttle/debounce/sample/buffer) / time-bounded subscription (AS OF SYSTEM TIME T1..T2; composes with B-0825) / F# reactive-composition DSL patterns. Complete substrate stack now 6-layer: - 7: WHERE (CockroachDB) - 8: HOW compose (library design) - 10: WHEN/WHERE execute (GPU/CPU/distributed-SQL) - 11: HOW reach nodes (shared-generative-base) - 12: WHO requests + WHO provides (static DI; Ace AND Helm) - 13: WHEN time-evolution happens (IObservable wrapping = simulation; time becomes injected substrate dimension) Sub-target 12 + 13 = the static-DI ↔ reactive-simulation continuum. Both first-class; substrate-engineering picks per-injection-point mode. Co-Authored-By: Claude <noreply@anthropic.com>
…s (HLC primary); CockroachDB HLC is substrate-native non-scalar answer (Aaron 2026-05-26 question) Aaron 2026-05-26 question after IObservable time-injection landing: "it's scalar time it seems unless you can think of the unit" Scalar IS the default (wall-clock seconds; IObservable's natural emission cadence) BUT substrate-native richer time-units exist + compose per scope. 8-candidate time-unit table: - CockroachDB HLC (Hybrid Logical Clock) — substrate-native PRIMARY answer; causally-consistent across nodes; combines wall-clock + logical-counter - Generator-cycle — per-emission tick; substrate-internal step-count - Vector clock / Lamport — causality-as-unit; partial-order semantics - AI-rate tick — per-AI-decision; Sub-target 3 cadence - GPU frame — Sub-target 10 triangle/GPU substrate - Hilbert-Polya spectral eigenvalue spacing — exotic; quantum-substrate composition; future-direction - Substrate-edit cycles — per-commit/per-PR/per-merge - Heartbeat / cron tick — agent operation scope Substrate is OPEN to multiple time-units composing simultaneously per default-to-both rule. Each tick-domain operates at its scope; combinators compose across tick-domains via Rx's timestamp + combineLatest / withLatestFrom / zip primitives. Time-unit conversion IS substrate-engineering work; substrate provides the primitives. Substrate-engineering implication for Sub-target 13: IObservable subscription includes time-unit declaration; subscribers see typed time alongside generator-value emissions; backpressure semantics operate in chosen time-unit. Sub-target 14 (new — time-unit substrate): 6 sub-tasks covering time-unit type registry / IObservable wrapping with declared unit / cross-unit conversion primitives / HLC default / per-Sub-target recommendations / F# typed time-unit (phantom-type or measure-of) for compile-time correctness. Complete substrate stack now 7-layer: - 7: WHERE (CockroachDB) - 8: HOW compose (library design) - 10: WHEN/WHERE execute (GPU/CPU/distributed-SQL) - 11: HOW reach nodes (shared-generative-base) - 12: WHO requests + WHO provides (static DI; Ace AND Helm) - 13: WHEN time-evolution happens (IObservable wrapping = simulation) - 14: WHAT time IS (typed time-units; HLC primary; scalar default) Sub-target 14 answers Aaron's question: scalar IS the default; substrate OPEN to richer units; CockroachDB HLC is substrate-native primary non-scalar answer. Co-Authored-By: Claude <noreply@anthropic.com>
…cheduler best-practices (Aaron 2026-05-26)
Two composing Aaron 2026-05-26 substrate landings:
1. "the generator as time source is very interesting for non linear time"
2. "generator as time source is rx and dst best practices in other
language schedulers and such"
The substrate inherits well-trodden scheduler-as-time-source prior-art —
NOT novel; it's the Rx-IScheduler / DST-virtual-time-scheduler /
Akka-Dispatcher / Tokio-runtime pattern at substrate-engineering scope.
8-system prior-art table (Rx / DST / Akka / Erlang BEAM / Tokio /
JS event-loop / F# Async / Apache Spark) — Zeta inherits decades of
scheduler-design substrate for free.
8-property linear-vs-non-linear comparison table:
- Monotonic / Single timeline / Branching / Replay / Forking /
Converging / Sparse density / Counterfactual
6 substrate-engineering implications:
1. Migration planning (parallel timelines; pre-commit exploration)
2. Disaster recovery (deterministic replay from earlier state)
3. A/B substrate experimentation (parallel timelines; per-tenant cutover)
4. Time-travel debugging (deterministic re-execution at any past tick)
5. Counterfactual analysis ("what if CVE patched 2 weeks earlier")
6. Sparse/dense time-density (production AI-rate vs test deterministic-stepping)
Composes with Sub-target 14 (time-unit) — time-unit answers "how do we
measure ticks?"; non-linear time answers "what topologies of ticks?".
Both compose.
Sub-target 15 (new): 7 sub-tasks covering generator-cycle default unit /
fork(gen, point) branching / replay(gen, snapshot) / merge(timeline_a,
timeline_b, conflict_resolver) / what_if(gen, alt_input, from_point)
counterfactual / dense_tick/sparse_tick density operators / Rx-IScheduler
+ DST-test-scheduler + F# scheduler-pattern integration mapping.
Complete substrate stack now 8-layer:
- 7: WHERE (CockroachDB)
- 8: HOW compose
- 10: WHEN/WHERE execute
- 11: HOW reach nodes
- 12: WHO requests + WHO provides (DI)
- 13: WHEN time-evolution happens (IObservable simulation)
- 14: WHAT time IS (typed time-units; HLC primary)
- 15: WHAT TOPOLOGIES OF TIME (non-linear time; branching/replay/
forking/converging/counterfactual/sparse-dense; inherits Rx/DST/
scheduler best-practices)
Sub-target 15 IS the non-linear-time topology complement to Sub-target
14's tick-counting unit. Together = full simulation substrate.
Note: also re-lands Sub-targets 13 + 14 via cherry-pick — those commits
were authored after #5260 PR auto-merge fired so didn't land via that
PR; this PR re-applies them on current main.
Co-Authored-By: Claude <noreply@anthropic.com>
|
You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard. |
AceHack
deleted the
otto-cli/b0824-generator-as-time-source-non-linear-time-2026-05-26
branch
This was referenced May 26, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Three Aaron 2026-05-26 substrate landings — Sub-targets 13 + 14 + 15:
Substrate inherits well-trodden scheduler-as-time-source prior-art (Rx-IScheduler / DST-virtual-time / Akka-Dispatcher / Erlang BEAM / Tokio / JS event-loop / F# Async / Apache Spark — 8-system table).
8-property linear-vs-non-linear comparison + 6 substrate-engineering implications (migration planning / disaster recovery / A/B substrate experimentation / time-travel debugging / counterfactual analysis / sparse-dense time-density).
Sub-target 15 has 7 sub-tasks: generator-cycle default unit / fork-branching / replay primitive / merge-converging / what-if counterfactual / dense-tick/sparse-tick density operators / Rx-IScheduler + DST-test-scheduler + F# scheduler-pattern integration.
Complete substrate stack now 8-layer (Sub-targets 7 + 8 + 10 + 11 + 12 + 13 + 14 + 15).
Sub-target 14 answers "how do we measure ticks?"; Sub-target 15 answers "what topologies of ticks?". Together = full simulation substrate.
Re-lands Sub-targets 13 + 14 via cherry-pick — those commits were authored after #5260 auto-merge fired.
Test plan
🤖 Generated with Claude Code