Dimensional Bottles: Cached Static Intelligence with Per-Call Data Slosh over Immutable Frames

Kody Wildfeuer · RapterBox LLC · August 28, 2026

Public preprint. First public disclosure: August 29, 2026. The architecture was reduced to practice in RAPP Zoo v1.2.0 on August 28/29, 2026. No constituent mechanism below—event projection, static/dynamic binding, declarative visualization, asynchronous refresh, content addressing, or procedural memory—is claimed as individually new. The contribution claimed is the restricted artifact contract and its implemented composition. This preprint has not undergone peer review.

Abstract

Applications built around large language models often recompute stable interpretive structure together with changing input data. We present dimensional bottles, a restricted projection-artifact contract that separates a reusable specification from an immutable source event and its per-call binding (informally, the data slosh). A bottle combines deterministic selection metadata, a bounded scene specification, frame-hash provenance, renderer compatibility, and an immutable successor policy. A fixed local runtime can project a new frame without invoking a model; optional tool-enabled model refinement may propose a successor, but generated-bottle persistence remains subject to an independent application capability and revalidation. We implemented the contract in RAPP Zoo v1.2.0. Two process-separated, counterbalanced benchmark runs each retained 200 raw match observations and 90 raw renderer observations against one pinned frame and the clean three-bottle catalog. Matcher medians were 1.4 and 1.2 ms; child renderer-ready medians were 145.7 and 99.8 ms. Two separate end-to-end refinement observations completed in 17.934 and 26.208 s. One source frame was projected through two specifications as observably different identity and briefing views while retaining the same frame hash, and one generated successor persisted across application restart. The results establish single-host feasibility and execution ordering, not performance superiority, human usefulness, publisher authenticity, cross-device determinism, or monetary savings.

Keywords: immutable events; declarative projection; local-first systems; semantic caching; materialized views; procedural memory; content addressing; large language models.

1 · Introduction

During implementation of a live estate briefing, a stable visual and interpretive specification was repeatedly carried through a model path even though only the current census had changed. The same system could select a local specification and initialize its renderer in approximately one tenth of a second, while creation of a new specification required tens of seconds. The thesis of this work is narrow: when interpretation is stable relative to the arrival rate of source events, it can be represented as an explicit artifact and removed from the model-critical path.

The static/dynamic split itself is established in event-sourced projections, materialized views, partial evaluation, reactive visualization, prompt reuse, and procedural memory [5]–[18]. Dimensional bottles do not replace those ideas. They combine selected properties into one deliberately restricted contract: an immutable event is matched to a bounded data specification; a fixed local runtime computes a fresh projection; registry transport carries data rather than renderer code; and accepted model refinement creates a successor artifact rather than mutating its predecessor.

We claim four contributions: (1) a closed bottle schema coupling applicability metadata, scene constraints, frame-hash provenance, and renderer compatibility; (2) a data-only transport and local execution boundary whose guarantees and omissions are stated explicitly; (3) a successor-on-accepted-refinement lifecycle separating content-derived local naming, minted identity, and transport digests; and (4) an artifact-backed implementation and single-host microbenchmark. The evaluation asks whether the model-independent path executes as designed, whether one frame can support observably different projections without source mutation, and which trust properties the implemented transport and runtime do—and do not—provide.

2 · Substrate and artifact contract

The source substrate is RAPP/1 [1]: an eleven-key immutable frame with domain-separated payload and whole-frame hashes, registered event kinds, chain links, and optional detached JWS authentication using canonical JSON [2]–[4]. RAPP/1 is prior work by the same author and is not claimed here.

2.1 Source frame

The released foundry receives one frame rather than a stream repository. It therefore accepts a structurally and cryptographically self-consistent registered-kind genesis: exact key set, kind/stream-family compatibility, payload and frame hashes, genesis and wire rules, and verification of any present signature through configured registry material. An unsigned body or memory genesis establishes content integrity but not authenticated authorship or independent stream-of-record status. The current route exposes no non-genesis interface; such an interface would require a previously verified head, external stream binding, rollback state, and fork handling.

2.2 Bottle and per-call binding

A bottle B is a closed projection specification containing an identifier and RAPPID, version, finite applicability dimensions, renderer contract, full seed, projection kind, scene constraints, and binding rule. “Static intelligence” is used operationally: the record contains explicit interpretive decisions, not model weights or independent reasoning. The per-call binding S(F), informally the data slosh, contains the verified frame and optional bounded local context. It is not persisted as bottle memory and confers no identity or authority.

2.3 Projection and accepted refinement

The first expression is local projection. Neither B nor F changes. The second is optional refinement. Acceptance mints a fresh RAPPID and a collision-resistant, content-derived 96-bit local name; it does not make the generated identity or completed record content-addressed. RAR transport separately hashes serialized public records.

3 · Design

3.1 Restricted projection artifact

The contract enforces five properties. First, projection does not edit the frame. Second, ordinary projection does not edit the bottle. Third, per-call bindings disappear without erasing the specification. Fourth, different bottles may project one frame without asserting different source facts. Fifth, accepted refinement creates a successor rather than overwriting the predecessor. These properties are implementation invariants, not claims of new view or lens theory.

3.2 Deterministic selection

Let T(F,q) be normalized tokens from the frame kind, payload, and optional query, and D(B) the bottle's applicability dimensions. The current selector scores exact overlap and bounded substring affinity:

Ties are ordered by identifier. If every score is zero, the frame hash selects a stable fallback. This simple selector is not claimed as a novel retrieval algorithm; it makes the artifact choice inspectable and model-independent.

3.3 Local path and refinement path

The local path verifies the input, selects a bottle, initializes the fixed renderer, and applies the per-call binding. In parallel, the application may send the same frame and selection to a tool-enabled local agent runtime and language model. The general pattern of immediate local work plus asynchronous refresh is established [21]; here it is one part of the bottle contract, not a standalone contribution.

Model output is parsed by Electron and revalidated by the Zoo before it can enter /api/holograms/generated, which additionally requires an Electron-held capability. A validation agent was installed and its invocation was observed in one refinement run, but orchestration does not require an agent receipt. Electron and Zoo validation are the enforced generated-bottle gates.

3.4 Successor creation and persistence

Random refinement adds fresh entropy; deterministic refinement derives its seed from the frame and validated design. The local identifier retains 96 seed bits and stays within the RAPPID slug bound. On the tested filesystem, publication uses an exclusive temporary file and hard link, providing an atomic no-clobber point. A randomized collision is detected and retried; deterministic reuse is allowed only when full seed and source frame match. Directory-fsync crash durability and filesystems without hard-link support were not evaluated.

3.5 Data-only transport

RAR publishes a mutable index containing record URLs and SHA-256 digests. The Zoo fetches an allowlisted record, verifies byte equality with the digest in the currently fetched index, checks exact record and scene schemas, and installs the bytes. This provides current-index-relative integrity, not publisher authentication, freshness, rollback protection, or an immutable local admission receipt. A signed or commit-pinned monotonic index would be required for those stronger properties.

Bottle fields are bounded data and are not interpreted as executable renderer components. Recognized remote URLs and active-script forms are rejected; other code-looking strings may pass as text but are rendered inertly through text or canvas operations. The paper therefore claims a non-evaluating renderer boundary, not semantic detection of every possible program fragment.

3.6 Execution and transport threat model

The local agent runtime is intentionally tool-enabled and runs with ordinary user privileges. It can cause side effects through installed tools, including persistence paths other than generated-bottle admission. Frame payloads and public bottle strings enter its prompt as untrusted data, so prompt injection and tool misuse remain in the threat model. The narrow enforced claim is that the Brainstem cannot commit a generated design through /api/holograms/generated without the Electron capability and independent Zoo validation.

The renderer iframe has a discriminated message envelope and verifies source window, schema tag, and bottle identifier. The context object is not exact-schema, depth, or size validated; this is an implementation gap. Desktop messages could target the exact hologram.localhost origin, while opaque mobile children require a different origin strategy. The child document denies network connections.

A remotely exposed PWA control plane additionally requires an authenticated HTTPS reverse proxy or trusted tunnel. The release does not provide one, and its mobile evidence is a mobile-sized browser test on the local host—not a secure remote deployment or a physical-device result.

3.7 Runtime ownership

The desktop supervisor expects an explicitly installed local Brainstem or explicit path overrides; it does not execute a remote installer. Existing-process adoption checks reported source path, soul path, and required agents, but does not cryptographically attest the Brainstem binary. Spawn failures become visible failed states. Disabling Python bytecode generation prevented launch-time .pyc creation, and the tested macOS bundle remained signature-valid after launch; this observation does not make the unpacked application resources generally write-proof.

4 · Reduction to practice

4.1 Artifact and measurement protocol

The implementation is RAPP Zoo v1.2.0 [22], built from source commit 35e316fa4c4e95790d56db631abf6231698742c2 and released at merge commit 42f06849b576d5d596f210390ca04e5295ea86c7. The public bottle records and agent admission are recorded in [23] and [24].

Measurements ran on an Apple M4 Max host with 16 logical CPUs and 128 GiB RAM under Darwin 25.6.0, Electron 43.2.0, Brainstem 0.6.16, and Three.js r128. A published benchmark script drove the Electron page through the Chrome DevTools Protocol. Runs A and B used separate Electron processes and separate user-data directories, one isolated RAPP home, the clean three-bottle catalog, and the same archived frame fixture. Each run used ten matcher warm-ups followed by 200 retained matcher observations and 30 Latin-rotated rounds across three bottles (90 retained renderer observations). Each bottle appeared ten times in each order position. No samples were excluded.

Matcher time spans one loopback /api/holograms/match request and JSON response. Renderer-ready time starts at openHologram() and ends when the child posts rapp-zoo-hologram-ready after its first synchronous renderer.render call. Bound time ends after the child rebuilds with the per-call binding and posts rapp-zoo-hologram-bound; it is not a compositor presentation measurement. Percentiles use nearest rank, sorted[ceil(p·n)-1].

4.2 Local microbenchmark

Per-bottle renderer-ready medians in runs A/B were 157.1/91.5 ms for Holo Avatar, 132.8/101.4 ms for The Briefing, and 132.0/100.4 ms for HOLO in the Nexus. The corresponding p95 values were 231.6/170.4, 275.9/155.8, and 230.9/158.7 ms. These are mixed-cache measurements: the experiment counterbalances order but does not separately identify process-cold, shared-asset-cold, renderer-cold, and warm conditions.

Two separate end-to-end refinement observations completed in 17.934 and 26.208 s. They were not collected as part of the matcher/renderer traces and are not a distribution. One recorded 17.934 s run includes an observed HologramForge tool log; the enforced admission remained Electron parsing, the Electron capability, and Zoo revalidation.

4.3 Same-frame projection and persistence

Frame fbb86cd78e2092a836c4de9602f072d7b22f0f8bc5b1bf92dffb40f7ce01f0e5 was projected through Holo Avatar and The Briefing. The outputs were observably different: the first was a live identity view titled Sable-ling; the second was a live data briefing. Both displayed the same source prefix, and the parent retained the same complete frame hash before and after both projections. No output-distance metric was applied.

One generated bottle persisted across a full application restart and was subsequently projected without a model request. A forced randomized identifier collision was detected, new entropy was selected, and the original file remained byte-identical. The latter establishes no-clobber behavior on the tested filesystem, not power-loss durability.

4.4 Validation and package observations

The released tree passed 48 Python/RAPP tests, 18 Electron tests, the pinned official RAPP checker, and package builds on macOS, Windows, and Linux. These results support protocol validation, schema enforcement, collision handling, and buildability; CI did not launch every packaged platform or reproduce the local browser observations. A separate local transcript records post-launch codesign --verify --deep --strict success for the macOS bundle and the absence of generated bytecode in its unpacked Python resources.

4.5 Artifact availability

The companion artifact archive contains the exact benchmark script, both raw benchmark runs (400 matcher and 180 renderer samples total), full trial order and labels, the pinned three-bottle catalog requirement, exact benchmark frame, percentile rule, implementation and paper hashes, a replayable same-frame harness with hash-bound iframe-only screenshots, both refinement observations, a replayable redacted signing chronology, and the paper acceptance gate. The implementation and public records remain available through [22]–[24].

5 · Related work and position

The nearest established system shape is immutable event → versioned projector → derived view. Event-sourced systems and their schema evolution are well established [5]; materialized views retain or maintain derived data [12]; one-way projection is a strict subset of the bidirectional lens problem [11]. Reactive Vega demonstrates a persistent declarative specification over changing streams [6], and partial evaluation formalizes specialization of static program structure against dynamic input [7]. Dimensional bottles do not introduce these mechanisms. Their narrow distinction is the combined artifact contract: deterministic applicability metadata, fixed allowlisted scene schema, frame-hash provenance, digest-checked registry transport, fixed sandboxed execution, and immutable successor admission.

Prompt Cache and related inference systems reuse static prompt structure while retaining the model on the execution path [8]. Semantic answer caches replay a prior output for an approximately matching request [9], while RAG retrieves evidence for model generation [10]. A bottle instead accepts an exact unseen frame and recomputes a fresh local projection without a model. The two-path execution policy is nevertheless an instance of the established immediate-result/background-refresh pattern [21], not an independent novelty claim.

Declarative and generated visualization are particularly close. Vega-Lite specifies portable JSON graphics [13]; Data2Vis and LIDA generate visualization specifications from data or language [14], [15]. Bottles differ by restricting the executable surface, including deterministic selection and frame provenance, separating current-index record integrity from runtime authority, and requiring accepted refinement to become a successor artifact. These additions are a systems composition, not a new grammar of graphics.

Procedural agent memories store reusable skills, workflows, or applicability cues for later tasks: Voyager maintains an executable skill library [16], Agent Workflow Memory retrieves induced workflows [17], and SkillLens uses visual skill cards with retrieval and verification signals [18]. MemGPT instead manages model-context memory tiers [20]. A bottle is narrower than procedural memory: it is bounded data interpreted by a fixed local renderer and can produce output without an executing model or agent. IPFS supplies a broader content-addressed systems comparison [19], but the generated bottle identity in the present implementation is not itself content-addressed.

6 · Limitations

This is a single-owner, single-host reduction and local microbenchmark. It has no alternative-system baseline, concurrent-load study, human usefulness evaluation, compositor-present measurement, independent operator, physical second-device reproduction, token accounting, monetary cost, or repeated model-refinement distribution. The two counterbalanced runs reduce fixed-order bias but remain mixed-cache; process-cold, shared-asset-cold, renderer-cold, and warm conditions are not separated. The fast path is model-independent by construction; one refinement completing under a model different from the requested default does not establish model-independent refinement.

The trust boundary is also narrower than the initial design language suggested. RAR digests establish byte agreement with a mutable fetched index, not publisher authenticity or rollback resistance. The message channel is discriminated but not closed-schema. The tool-enabled Brainstem is not least-privilege and remains exposed to prompt injection from untrusted strings. Remote PWA use requires an authenticated HTTPS deployment that is not part of the release. The current scene grammar covers two projection families, and bottle governance across authors—versioning, revocation, composition, ownership transfer, and conflicting applicability vocabularies—remains untested.

A peer-reviewed systems submission requires controlled baselines against an ordinary event projector, a declarative visualization specification, a plain static Three.js configuration, semantic answer caching, and model-first prompt reuse; randomized process-cold/warm experiments on multiple physical systems; raw first-present traces; repeated refinements with exact model, token, cost, and tool records; parser fuzzing; and an independent artifact evaluation. An HCI submission additionally requires evidence about comprehension, trust, authoring, or task outcomes.

7 · Conclusion

The reduction demonstrates a restricted composition rather than a new static/dynamic programming primitive. A bounded projection specification can be selected for an immutable frame, executed by a fixed local renderer without a model, and retained unchanged while optional refinement proposes a separately identified successor. In the reported implementation, that contract supported repeated low-latency local execution, same-frame/different-view projection, digest-checked data transport, and cross-run reuse. The defensible result is therefore not that bottles supersede caches, views, visualization grammars, or procedural memory, but that their selected properties can be combined into an inspectable artifact and authority boundary: persist the specification, bind new data explicitly, preserve the source, and make refinement create a successor.

References

1. K. Wildfeuer, “RAPP/1: Unified normative specification of identity, canonicalization, the frame, the wire, and the egg,” rev-6, 2026. https://kody-w.github.io/rapp-1/.
2. R. Rundgren, B. Jordan, and S. Erdtman, “JSON Canonicalization Scheme (JCS),” RFC 8785, 2020. doi: 10.17487/RFC8785.
3. M. Jones, J. Bradley, and N. Sakimura, “JSON Web Signature (JWS),” RFC 7515, 2015. doi: 10.17487/RFC7515.
4. M. Jones, “JSON Web Signature (JWS) Unencoded Payload Option,” RFC 7797, 2016. doi: 10.17487/RFC7797.
5. M. Overeem, M. Spoor, S. Jansen, and S. Brinkkemper, “An Empirical Characterization of Event Sourced Systems and Their Schema Evolution—Lessons from Industry,” Journal of Systems and Software, vol. 178, Art. 110970, 2021. doi: 10.1016/j.jss.2021.110970.
6. A. Satyanarayan, R. Russell, J. Hoffswell, and J. Heer, “Reactive Vega: A Streaming Dataflow Architecture for Declarative Interactive Visualization,” IEEE Transactions on Visualization and Computer Graphics, vol. 22, no. 1, pp. 659–668, 2016. doi: 10.1109/TVCG.2015.2467091.
7. N. D. Jones, “An Introduction to Partial Evaluation,” ACM Computing Surveys, vol. 28, no. 3, pp. 480–503, 1996. doi: 10.1145/243439.243447.
8. I. Gim, G. Chen, S. Lee, N. Sarda, A. Khandelwal, and L. Zhong, “Prompt Cache: Modular Attention Reuse for Low-Latency Inference,” Proceedings of Machine Learning and Systems, vol. 6, pp. 325–338, 2024.
9. F. Bang, “GPTCache: An Open-Source Semantic Cache for LLM Applications Enabling Faster Answers and Cost Savings,” in Proc. 3rd Workshop for Natural Language Processing Open Source Software, pp. 212–218, 2023. doi: 10.18653/v1/2023.nlposs-1.24.
10. P. Lewis et al., “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks,” in Advances in Neural Information Processing Systems, vol. 33, pp. 9459–9474, 2020.
11. J. N. Foster, M. B. Greenwald, J. T. Moore, B. C. Pierce, and A. Schmitt, “Combinators for Bidirectional Tree Transformations: A Linguistic Approach to the View-Update Problem,” ACM Transactions on Programming Languages and Systems, vol. 29, no. 3, Art. 17, 2007. doi: 10.1145/1232420.1232424.
12. R. Chirkova and J. Yang, “Materialized Views,” Foundations and Trends in Databases, vol. 4, no. 4, pp. 295–405, 2012. doi: 10.1561/1900000020.
13. A. Satyanarayan, D. Moritz, K. Wongsuphasawat, and J. Heer, “Vega-Lite: A Grammar of Interactive Graphics,” IEEE Transactions on Visualization and Computer Graphics, vol. 23, no. 1, pp. 341–350, 2017. doi: 10.1109/TVCG.2016.2599030.
14. V. Dibia and C. Demiralp, “Data2Vis: Automatic Generation of Data Visualizations Using Sequence-to-Sequence Recurrent Neural Networks,” IEEE Computer Graphics and Applications, vol. 39, no. 5, pp. 33–46, 2019. doi: 10.1109/MCG.2019.2924636.
15. V. Dibia, “LIDA: A Tool for Automatic Generation of Grammar-Agnostic Visualizations and Infographics Using Large Language Models,” in Proc. 61st Annual Meeting of the ACL: System Demonstrations, pp. 113–126, 2023. doi: 10.18653/v1/2023.acl-demo.11.
16. G. Wang et al., “Voyager: An Open-Ended Embodied Agent with Large Language Models,” arXiv:2305.16291, 2023.
17. Z. Z. Wang, J. Mao, D. Fried, and G. Neubig, “Agent Workflow Memory,” arXiv:2409.07429, 2024.
18. Z. Liu et al., “SkillLens: Visual Skill Cards for Retrieval-Augmented GUI Action Prediction and On-Policy Distillation,” arXiv:2608.10775, 2026.
19. J. Benet, “IPFS—Content Addressed, Versioned, P2P File System,” arXiv:1407.3561, 2014.
20. C. Packer et al., “MemGPT: Towards LLMs as Operating Systems,” arXiv:2310.08560, 2023. doi: 10.48550/arXiv.2310.08560.
21. M. Nottingham, “HTTP Cache-Control Extensions for Stale Content,” RFC 5861, 2010. doi: 10.17487/RFC5861.
22. RAPP Zoo, “v1.2.0—Hologram Bottle Foundry,” 2026. Release and implementation record.
23. RAR, “Dimensional hologram bottle records,” kody-w/RAR#639, 2026.
24. RAR, “Notarized HologramDOGG agent,” kody-w/RAR#640, 2026.