berylx-py 0.1.0__tar.gz

berylx_py-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: ci
+on:
+  push:
+  pull_request:
+  workflow_call:
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install -r requirements-dev.txt
+      - run: python -m pip install -e .
+      - name: Regression and Unit barrier
+        run: python -m pytest -q tests/test_regression.py tests/test_darkcore.py tests/test_oracle.py tests/test_boundaries.py tests/test_timeline.py
+      - name: Property barrier
+        run: python -m pytest -q tests/test_properties.py
+      - run: ruff check src tests scripts
+      - run: ruff format --check src tests scripts
+      - run: mypy src/berylx
+      - run: python -m build
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+      - run: npx --yes prettier@3.6.2 --check README.md 'docs/**/*.md' '.github/**/*.yml' 'tests/fixtures/*.json'

berylx_py-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,90 @@
+name: Publish to PyPI
+on:
+  push:
+    branches: [main]
+    paths: [pyproject.toml]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pypi-publication
+  cancel-in-progress: false
+
+jobs:
+  eligibility:
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    outputs:
+      needed: ${{ steps.version.outputs.needed }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.14"
+      - name: Check whether this version needs publication
+        id: version
+        shell: python
+        run: |
+          import os
+          import tomllib
+          from urllib.error import HTTPError
+          from urllib.parse import quote
+          from urllib.request import urlopen
+
+          with open("pyproject.toml", "rb") as source:
+              project = tomllib.load(source)["project"]
+          name, version = project["name"], project["version"]
+          url = f"https://pypi.org/pypi/{quote(name, safe='')}/{quote(version, safe='')}/json"
+          try:
+              with urlopen(url, timeout=30) as response:
+                  if response.status != 200:
+                      raise RuntimeError(f"Unexpected PyPI response: {response.status}")
+              needed = "false"
+              print(f"::notice::{name} {version} is already published; skipping upload")
+          except HTTPError as error:
+              if error.code != 404:
+                  raise
+              needed = "true"
+              print(f"{name} {version} is not published; proceeding through CI")
+          with open(os.environ["GITHUB_OUTPUT"], "a") as output:
+              print(f"needed={needed}", file=output)
+
+  validate:
+    needs: eligibility
+    if: needs.eligibility.outputs.needed == 'true'
+    uses: ./.github/workflows/ci.yml
+
+  build:
+    needs: validate
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.14"
+      - run: python -m pip install -r requirements-dev.txt 'twine>=6,<7'
+      - run: python -m build
+      - run: python -m twine check --strict dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: python-distributions
+          path: dist/*
+          if-no-files-found: error
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/berylx-py/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: python-distributions
+          path: dist/
+      - name: Publish distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # release/v1

berylx_py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 minamorl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

berylx_py-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include requirements-dev.txt
+recursive-include tests *.py *.json
+recursive-include docs *.md *.spec
+recursive-include evidence *.txt
+recursive-include scripts *.py *.mjs
+recursive-include .github *.yml

berylx_py-0.1.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: berylx-py
+Version: 0.1.0
+Summary: Immutable state workflows over a tagged Freer effect monad
+Author: minamorl
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/minamorl/berylx-py
+Project-URL: Repository, https://github.com/minamorl/berylx-py
+Project-URL: Issues, https://github.com/minamorl/berylx-py/issues
+Project-URL: Documentation, https://github.com/minamorl/berylx-py#readme
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: hypothesis>=6; extra == "dev"
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: ruff>=0.9; extra == "dev"
+Requires-Dist: mypy>=1; extra == "dev"
+Dynamic: license-file
+
+# berylx-py
+
+Immutable state workflows interpreted through a tagged Freer effect monad. Python
+port of [minamorl/berylx-ts](https://github.com/minamorl/berylx-ts), frozen at
+[`24aabcd6059547f15b5b2817592e3d0dd4f258bb`](https://github.com/minamorl/berylx-ts/tree/24aabcd6059547f15b5b2817592e3d0dd4f258bb)
+(TS 0.4.0). The frozen revision equals upstream HEAD observed on 2026-10-29.
+
+## Install
+
+Python 3.11 or newer. After the first PyPI release is published, install with:
+
+```bash
+python -m pip install berylx-py
+```
+
+Or install from this source directory:
+
+```bash
+python -m pip install .
+```
+
+The public repository is https://github.com/minamorl/berylx-py .
+Install directly from GitHub:
+
+```bash
+python -m pip install 'git+https://github.com/minamorl/berylx-py.git'
+```
+
+For development from this source directory:
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install -r requirements-dev.txt
+python -m pip install -e .
+```
+
+## Releasing
+
+Update `project.version` in `pyproject.toml`, then commit and push to `main`.
+The publishing workflow checks whether that version already exists on PyPI. A new
+version runs the complete Python 3.11–3.14 CI matrix, builds and checks the
+artifacts, then publishes through the registered Trusted Publisher. An existing
+version is skipped. PyPI or network errors fail the check instead of uploading.
+The workflow can also be dispatched manually from `main` to retry an unpublished
+version; no PyPI token needs to be stored in GitHub.
+
+## Workflows
+
+```python
+from berylx import Root, Task, Ok
+
+root = Root.of({'user': {'name': '  mina  '}, 'total': 0})
+trim = Task.of('trim', lambda f: f.at('user').at('name').update(str.strip))
+charge = Task.of('charge', lambda f: f.at('total').set(100))
+result = root.call(trim.then(charge))
+assert isinstance(result, Ok)
+assert root.at('user').at('name').get() == 'mina'
+assert root.state()['total'] == 100
+```
+
+`Focus`/`Lay` is a snapshot; `at` navigates, `set`/`put`/`update` return a new root
+focus. Dicts and lists are defensively copied into read-only views. `Root` commits
+only successful results automatically. An `Err` carries its partial focus, structured
+error, cause and trace; `unwrap()` explicitly raises. `Catch` recovers at a sequence
+boundary; `rescue_with` wraps a whole workflow.
+
+`a.par(b)` starts each branch from the same snapshot. Default strict three-way merge
+preserves independent changes to existing keys and reports `merge_conflict` for
+incompatible same-path changes. `.reduce(Merge.deep())` explicitly selects
+right-biased two-way merging. `.accumulate()` collects failures. The default
+`short_circuit` selects the first failure **after every branch settles**; it does
+not cancel work. `AsyncTask` runs with `await EffectTree.run_async(...)`.
+
+## Monads and effect interpretation
+
+```python
+from berylx import darkcore as d
+
+program = d.op('lookup', {'id': 7}, int).bind(lambda n: d.pure(n + 1))
+assert d.run(program, {'lookup': lambda payload: 41}) == 42
+assert d.run(program, {'lookup': lambda payload: 9}) == 10
+
+stateful = d.State.get().bind(
+    lambda n: d.State.put(n + 1).seq(d.State.get())
+)
+assert stateful.run(10) == (11, 11)
+assert d.Err('failed').bind(lambda x: d.Ok(x + 1)) == d.Err('failed')
+```
+
+Darkcore supplies `Just/Nothing`, `Right/Left`, `Ok/Err`, `Success/Failure`, `State`
+and `Effect`. These value result classes are distinct from workflow `Ok/Err`.
+`Validation.bind` short-circuits; `Validation.ap` accumulates errors and intentionally
+differs from the application operation induced by its bind.
+
+Tasks compile into inspectable tagged payloads `(node, focus)` over the same Effect
+substrate. Handler maps interpret the tree; `EffectTree.around`/`around_async` wrap
+nested tasks, effects and recovery. Callbacks declaring a required second positional
+parameter receive `Perform`; recovery callbacks receive it as their third.
+
+```python
+from berylx import Task, EffectTree
+
+fetch = Task('fetch', lambda f, p: f.put('answer', p.perform('lookup', 7)))
+handlers = EffectTree.real_handlers({'lookup': lambda key: 42})
+assert EffectTree.run(fetch, {}, handlers).focus.get()['answer'] == 42
+assert EffectTree.dry_run(fetch, {}).steps == ['fetch']
+```
+
+Dry-run skips task bodies but still evaluates predicates. It is a planning
+interpreter, not proof of behavioral equivalence. Real and virtual IO handlers
+interpret the same `darkcore.IOEffects` programs.
+
+## Equivalence and differences
+
+The supported runtime contract includes monad values/state/effects, immutable
+focus, structured failures, sequence/parallel/branch/recovery, async interpretation,
+Root history/subscriptions, scoped factories, graph output and Cray adapters.
+Timeline scheduling and Root integration are exposed in `berylx.timeline` and
+`berylx.timeline_berylx` (clock injection, human waits, recurring origins and
+concurrent commit merge). See [the frozen contract](docs/equivalence.md) and
+[API mapping](docs/api.md) for exact boundaries.
+
+Python names are snake_case; `or_else`/`and_then` avoid keywords. Python exceptions,
+truthiness and numbers follow Python rules. `None` combines JavaScript null and
+undefined. Python generics do not reproduce TS compile-time path-key inference.
+Browser/npm exports are not applicable. The port does not claim unrestricted
+cross-language equivalence for arbitrary objects, numeric edge cases or deletions
+through parallel's strict reducer. Timeline uses a separate deletion-aware merge.
+
+## Validation
+
+Regression/unit tests and independently captured TypeScript observations were
+written and run RED before implementation. After all regression/unit gates pass,
+Hypothesis checks generated monad/composition/state/failure/merge properties.
+
+```bash
+python -m pytest -q tests/test_regression.py tests/test_darkcore.py tests/test_oracle.py tests/test_boundaries.py tests/test_timeline.py
+python -m pytest -q tests/test_properties.py
+python -m pytest -q
+ruff check src tests
+ruff format --check src tests
+mypy src/berylx
+python -m build
+```
+
+The type gate checks implementation bodies; it does not prove TS-style path types.
+[Recorded evidence](evidence/) includes phase gates. To regenerate the independent
+oracle, build a separate TS checkout at the frozen revision, then run:
+
+```bash
+node scripts/ts_oracle.mjs /absolute/path/to/berylx-ts/dist/index.js
+```
+
+Its output must match `tests/fixtures/ts-observations.json`. Python compares state,
+error envelopes, handler order, State and value-monad observations against that
+fixture, without importing or executing the TS implementation.
+
+MIT licensed; original TypeScript implementation copyright 2026 minamorl is
+retained in [LICENSE](LICENSE).

berylx_py-0.1.0/README.md

@@ -0,0 +1,160 @@
+# berylx-py
+
+Immutable state workflows interpreted through a tagged Freer effect monad. Python
+port of [minamorl/berylx-ts](https://github.com/minamorl/berylx-ts), frozen at
+[`24aabcd6059547f15b5b2817592e3d0dd4f258bb`](https://github.com/minamorl/berylx-ts/tree/24aabcd6059547f15b5b2817592e3d0dd4f258bb)
+(TS 0.4.0). The frozen revision equals upstream HEAD observed on 2026-10-29.
+
+## Install
+
+Python 3.11 or newer. After the first PyPI release is published, install with:
+
+```bash
+python -m pip install berylx-py
+```
+
+Or install from this source directory:
+
+```bash
+python -m pip install .
+```
+
+The public repository is https://github.com/minamorl/berylx-py .
+Install directly from GitHub:
+
+```bash
+python -m pip install 'git+https://github.com/minamorl/berylx-py.git'
+```
+
+For development from this source directory:
+
+```bash
+python -m venv .venv
+. .venv/bin/activate
+python -m pip install -r requirements-dev.txt
+python -m pip install -e .
+```
+
+## Releasing
+
+Update `project.version` in `pyproject.toml`, then commit and push to `main`.
+The publishing workflow checks whether that version already exists on PyPI. A new
+version runs the complete Python 3.11–3.14 CI matrix, builds and checks the
+artifacts, then publishes through the registered Trusted Publisher. An existing
+version is skipped. PyPI or network errors fail the check instead of uploading.
+The workflow can also be dispatched manually from `main` to retry an unpublished
+version; no PyPI token needs to be stored in GitHub.
+
+## Workflows
+
+```python
+from berylx import Root, Task, Ok
+
+root = Root.of({'user': {'name': '  mina  '}, 'total': 0})
+trim = Task.of('trim', lambda f: f.at('user').at('name').update(str.strip))
+charge = Task.of('charge', lambda f: f.at('total').set(100))
+result = root.call(trim.then(charge))
+assert isinstance(result, Ok)
+assert root.at('user').at('name').get() == 'mina'
+assert root.state()['total'] == 100
+```
+
+`Focus`/`Lay` is a snapshot; `at` navigates, `set`/`put`/`update` return a new root
+focus. Dicts and lists are defensively copied into read-only views. `Root` commits
+only successful results automatically. An `Err` carries its partial focus, structured
+error, cause and trace; `unwrap()` explicitly raises. `Catch` recovers at a sequence
+boundary; `rescue_with` wraps a whole workflow.
+
+`a.par(b)` starts each branch from the same snapshot. Default strict three-way merge
+preserves independent changes to existing keys and reports `merge_conflict` for
+incompatible same-path changes. `.reduce(Merge.deep())` explicitly selects
+right-biased two-way merging. `.accumulate()` collects failures. The default
+`short_circuit` selects the first failure **after every branch settles**; it does
+not cancel work. `AsyncTask` runs with `await EffectTree.run_async(...)`.
+
+## Monads and effect interpretation
+
+```python
+from berylx import darkcore as d
+
+program = d.op('lookup', {'id': 7}, int).bind(lambda n: d.pure(n + 1))
+assert d.run(program, {'lookup': lambda payload: 41}) == 42
+assert d.run(program, {'lookup': lambda payload: 9}) == 10
+
+stateful = d.State.get().bind(
+    lambda n: d.State.put(n + 1).seq(d.State.get())
+)
+assert stateful.run(10) == (11, 11)
+assert d.Err('failed').bind(lambda x: d.Ok(x + 1)) == d.Err('failed')
+```
+
+Darkcore supplies `Just/Nothing`, `Right/Left`, `Ok/Err`, `Success/Failure`, `State`
+and `Effect`. These value result classes are distinct from workflow `Ok/Err`.
+`Validation.bind` short-circuits; `Validation.ap` accumulates errors and intentionally
+differs from the application operation induced by its bind.
+
+Tasks compile into inspectable tagged payloads `(node, focus)` over the same Effect
+substrate. Handler maps interpret the tree; `EffectTree.around`/`around_async` wrap
+nested tasks, effects and recovery. Callbacks declaring a required second positional
+parameter receive `Perform`; recovery callbacks receive it as their third.
+
+```python
+from berylx import Task, EffectTree
+
+fetch = Task('fetch', lambda f, p: f.put('answer', p.perform('lookup', 7)))
+handlers = EffectTree.real_handlers({'lookup': lambda key: 42})
+assert EffectTree.run(fetch, {}, handlers).focus.get()['answer'] == 42
+assert EffectTree.dry_run(fetch, {}).steps == ['fetch']
+```
+
+Dry-run skips task bodies but still evaluates predicates. It is a planning
+interpreter, not proof of behavioral equivalence. Real and virtual IO handlers
+interpret the same `darkcore.IOEffects` programs.
+
+## Equivalence and differences
+
+The supported runtime contract includes monad values/state/effects, immutable
+focus, structured failures, sequence/parallel/branch/recovery, async interpretation,
+Root history/subscriptions, scoped factories, graph output and Cray adapters.
+Timeline scheduling and Root integration are exposed in `berylx.timeline` and
+`berylx.timeline_berylx` (clock injection, human waits, recurring origins and
+concurrent commit merge). See [the frozen contract](docs/equivalence.md) and
+[API mapping](docs/api.md) for exact boundaries.
+
+Python names are snake_case; `or_else`/`and_then` avoid keywords. Python exceptions,
+truthiness and numbers follow Python rules. `None` combines JavaScript null and
+undefined. Python generics do not reproduce TS compile-time path-key inference.
+Browser/npm exports are not applicable. The port does not claim unrestricted
+cross-language equivalence for arbitrary objects, numeric edge cases or deletions
+through parallel's strict reducer. Timeline uses a separate deletion-aware merge.
+
+## Validation
+
+Regression/unit tests and independently captured TypeScript observations were
+written and run RED before implementation. After all regression/unit gates pass,
+Hypothesis checks generated monad/composition/state/failure/merge properties.
+
+```bash
+python -m pytest -q tests/test_regression.py tests/test_darkcore.py tests/test_oracle.py tests/test_boundaries.py tests/test_timeline.py
+python -m pytest -q tests/test_properties.py
+python -m pytest -q
+ruff check src tests
+ruff format --check src tests
+mypy src/berylx
+python -m build
+```
+
+The type gate checks implementation bodies; it does not prove TS-style path types.
+[Recorded evidence](evidence/) includes phase gates. To regenerate the independent
+oracle, build a separate TS checkout at the frozen revision, then run:
+
+```bash
+node scripts/ts_oracle.mjs /absolute/path/to/berylx-ts/dist/index.js
+```
+
+Its output must match `tests/fixtures/ts-observations.json`. Python compares state,
+error envelopes, handler order, State and value-monad observations against that
+fixture, without importing or executing the TS implementation.
+
+MIT licensed; original TypeScript implementation copyright 2026 minamorl is
+retained in [LICENSE](LICENSE).

berylx_py-0.1.0/docs/api.md

@@ -0,0 +1,79 @@
+# API correspondence and deliberate boundaries
+
+| TypeScript surface                                      | Python surface                           | Contract                                                 |
+| ------------------------------------------------------- | ---------------------------------------- | -------------------------------------------------------- |
+| Focus / Lay                                             | Focus / Lay                              | immutable snapshot and lazy path operations              |
+| toObject / toLay / toState                              | to_object / to_lay / to_state            | same state boundaries                                    |
+| Root / RootOptions.historyLimit                         | Root(..., history_limit=N)               | success-only commit, bounded history                     |
+| Flow / State.and                                        | Flow / State.and_then                    | immediate execution / pending composition                |
+| Task / AsyncTask                                        | Task / AsyncTask                         | sync / async callback boundaries                         |
+| then / par / rescueWith                                 | then / par / rescue_with                 | sequence / shared-base parallel / recovery               |
+| When / Else / Branch.or                                 | When / Else / Branch.or_else             | ordered predicates and fallback                          |
+| Catch / Rescue / RescueBlock                            | same names                               | partial-state recovery                                   |
+| ResultOps                                               | ResultOps                                | normalization and failure-preserving bind/map            |
+| BerylxError.failedNode/parallelErrors/withContext       | failed_node/parallel_errors/with_context | structured error properties                              |
+| error.toObject                                          | error.to_object                          | serialized keys retain TS camelCase for interoperability |
+| Merge.keepLeft/keepRight/deep/strict                    | keep_left/keep_right/deep/strict         | same reducer policies                                    |
+| EffectTree build/run/runAsync                           | build/run/run_async                      | same tagged Freer representation                         |
+| realHandlers/asyncRealHandlers/around/aroundAsync       | snake_case counterparts                  | propagating handler maps                                 |
+| runSubtree/runSubtreeAsync/branchMatches                | snake_case counterparts                  | interpreter utilities                                    |
+| EffectTree dryRun                                       | dry_run                                  | task names + Ok unchanged focus                          |
+| Perform                                                 | Perform                                  | custom effect dispatch                                   |
+| ControlSignal                                           | ControlSignal                            | ordinary Exception marker escaping task conversion       |
+| Darkcore Maybe/Either/Result/Validation/State/Effect    | berylx.darkcore (also Darkcore)          | distinct value monads, state and Freer effects           |
+| Darkcore fold/foldAsync/run/runAsync                    | fold/fold_async/run/run_async            | synchronous/asynchronous handlers                        |
+| IOEffects / VirtualWorld / realHandlers                 | IOEffects / VirtualWorld / real_handlers | explicit real/virtual IO                                 |
+| Workflow / Graph                                        | Workflow / Graph                         | workflow wrapper, structural DOT/Mermaid                 |
+| berylx<S>()                                             | berylx()                                 | scoped constructors; no recursive static path inference  |
+| attachRoot                                              | attach_root                              | projection, snapshot/commit callbacks, unsubscribe       |
+| Cray/fromCrayResult/toCrayResult                        | Cray/from_cray_result/to_cray_result     | structural result adapter, Python method spellings       |
+| Timeline / ExecutablePlan / KeyframeTrack               | berylx.timeline equivalents              | clock-driven scheduler                                   |
+| BerylxTimeline / BerylxTimelinePlan / waitForHumanLogin | berylx.timeline_berylx snake_case        | async effect integration, concurrent commit              |
+
+## Explicit exclusions and adaptations
+
+- EffectTree's low-level public TS helpers `recover`, `runParallel`, `runBranch`,
+  `runRescue`, `realRecover` and their async variants are not exported as public
+  Python helpers. Equivalent execution is available through `run`/`run_async` and
+  handler maps. In particular, the TS legacy `recover(RescueBlock, Err)` inconsistency
+  is not reproduced as an extra path.
+- TS `deriveFmap`/`deriveAp` helper exports are not public here; each monad implements
+  their derivations. Python Effect additionally provides fmap/map/ap.
+- The JSON-shaped equivalence domain is string-keyed mappings, finite numbers,
+  booleans, strings, lists and None; no symbols, prototype traversal, sparse array
+  holes or JavaScript bigint/undefined identity is claimed. List growth uses None.
+  Nonplain objects retain identity; updates use Python `with_patch` instead of JS
+  `with`. Dict/list cycles are preserved; repeated mutable children are cloned
+  independently. Tuples are treated as application values and are not deeply frozen.
+- to_object/get expose read-only mapping/list views. Use `berylx.core.plain` to make
+  ordinary containers for JSON serialization. Cyclic values are not JSON encodable.
+  Merge's structural equality/recursion is intended for acyclic values, as upstream.
+- Python truthiness (empty containers false), arbitrary-precision ints, numeric
+  conversion, exception names/messages, and object equality follow Python. Custom
+  object comparison is not promised equivalent to JS identity. Inputs for matching
+  numeric observations should use finite safe JS integers and explicit predicates.
+- `history_limit=True` is rejected (Python bool is an int subtype; JS boolean also
+  fails Number.isInteger). Pure callback arity counts required positional parameters
+  before the first default, analogous to Function.length. Zero-argument callbacks
+  receive no arguments because Python cannot ignore surplus positional arguments.
+- Python cancellation/KeyboardInterrupt/SystemExit are BaseException control paths,
+  not ordinary Err. Cancellation semantics are native asyncio, not JS Promise.
+  Recovery blocks are synchronous; use AsyncTask recovery for awaited operations.
+- The fold loop executes long right-associated programs iteratively; arbitrary deeply
+  left-associated bind closures are not guaranteed stack-safe, matching TS's limitation.
+- Parallel strict follows upstream missing-key behavior, not deletion semantics:
+  one missing side adopts the present side, and a key missing from both sides can
+  expose an internal missing sentinel. Properties exclude deletions and incompatible
+  container shape changes. Timeline's separate commit join handles deletions.
+- Graph node/edge structure is preserved, with JSON-safe DOT quoting (upstream raw
+  quotes can produce invalid DOT). Rendering is not claimed byte-identical for
+  escaped names. Cray duck typing recognizes Python is_success/is_failure methods,
+  plus success/ok/tag fields; JS camelCase-only foreign methods need an adapter.
+- IO is UTF-8 text. Real now returns timezone-aware datetime; ask returns an empty
+  string at EOF, virtual exhausted input/env return None. Virtual random equivalence
+  is limited to nonempty sequences of nonnegative integers and positive n; negative
+  modulo, empty sequences and zero divisors use Python behavior. OS error types,
+  console rendering and shell behavior are platform-specific. No external IO occurs
+  merely by constructing an IOEffects tree.
+- Python package version starts at 0.1.0 independently of TS 0.4.0. No PyPI artifact,
+  browser bundle, Node module shim, or TypeScript compile-time fixture parity claimed.