embedded-react 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,58 @@
+embedded-react
+Copyright 2026 Cory Lamming
+
+This product was created and is authored by Cory Lamming.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use the files in this project except in compliance with the License. You may
+obtain a copy of the License in the accompanying LICENSE file or at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations
+under the License.
+
+------------------------------------------------------------------------------
+Attribution
+------------------------------------------------------------------------------
+
+All original source code in this repository -- the C99 rendering engine, the
+hardware backends, the QuickJS bridge and NativeUI host config, the JSX-to-C
+ahead-of-time compiler, the toolchain, the simulator, and the demos -- is the
+original work of Cory Lamming, unless explicitly attributed otherwise.
+
+If you redistribute this work or derivative works, you must retain this NOTICE
+file and the attribution above, as required by Section 4 of the Apache License,
+Version 2.0.
+
+------------------------------------------------------------------------------
+Third-Party Components
+------------------------------------------------------------------------------
+
+This project builds against the following third-party software. These
+components are NOT redistributed in this repository's source tree; they are
+fetched as build-time dependencies (via CMake FetchContent and npm) and remain
+under their own respective licenses and copyrights:
+
+  * QuickJS / quickjs-ng -- a small embeddable JavaScript engine.
+    Copyright (c) Fabrice Bellard, Charlie Gordon, and the quickjs-ng
+    contributors. Licensed under the MIT License.
+    Used by the Flow A runtime bridge (bridges/quickjs/).
+
+  * React and react-reconciler -- the React component and reconciliation model.
+    Copyright (c) Meta Platforms, Inc. and affiliates.
+    Licensed under the MIT License.
+    Used by the Flow A bridge to drive the native engine.
+
+The embedded-react public API (e.g. the View / Text / Pressable / Animated /
+StyleSheet modules under bridges/quickjs/js/src/embedded-react/) is an original,
+independent reimplementation inspired by the React Native API surface. It is not
+derived from or copied out of React Native's source, and is the original work of
+Cory Lamming.
+
+Trademarks referenced in this project (including "React" and "React Native") are
+the property of their respective owners and are used here only for descriptive
+and interoperability purposes.

package/README.md

@@ -0,0 +1,224 @@
+# embedded-react — QuickJS JS layer (React reconciler)
+
+The JavaScript half of Flow A: a [`react-reconciler`](https://www.npmjs.com/package/react-reconciler)
+host config that maps React's host API onto the `NativeUI` bridge, so **JSX components drive the
+C engine**. Bundled to a single classic script that QuickJS runs with a plain `JS_Eval`.
+
+```
+React  →  react-reconciler  →  host-config.js  →  NativeUI.*  →  er_scene.h (engine)
+```
+
+## What an app imports
+
+The package is the React Native analog — same idiom (hooks from `react`, everything else here):
+
+```jsx
+import { useState } from 'react';
+import { View, Text, Pressable, StyleSheet, AppRegistry } from 'embedded-react';
+
+function App() { /* ... */ }
+AppRegistry.registerComponent('demo', () => App);
+```
+
+`embedded-react` resolves as a Node **package self-reference** (`package.json` `name` + `exports`),
+so esbuild and Vitest find it with no aliases.
+
+## Layout
+
+```
+src/
+  embedded-react/          the public package surface (what apps import)
+    index.js               barrel: components, StyleSheet, Platform, AppRegistry, Animated, Easing
+    components.js          host component tags (View, Text, … → ERNodeType)
+    StyleSheet.js          create() / flatten()
+    Platform.js            { OS: 'embedded', select }
+    AppRegistry.js         registerComponent(...) → mounts into a screen-sized root
+    Animated.js            Value / timing / spring / decay / View|Text|Image / interpolate
+    Easing.js              easing tokens (+ bezier) → engine curves
+    split-style.js         pure: split style into static props + animated bindings
+    __tests__/             co-located UNIT tests for the pure surface
+  host-config.js           reconciler host config → NativeUI.* (internal runtime)
+  renderer.js              createRoot(props).render(...); LegacyRoot (sync) (internal)
+  props.js                 pure prop helpers (flattenStyle / buildProps / isEventProp)
+  native-ui.js             re-exports globalThis.NativeUI (installed by the C bridge)
+  __tests__/               co-located UNIT tests (Vitest, *.unit.test.js, no engine)
+test/runtime/              e2e tests that need the real engine host
+  *.runtime.test.jsx       run inside QuickJS + engine via the headless harness
+  harness.js               check()/report() — records failures for the C runner
+  run.mjs                  bundles each runtime test + runs er-bridge-quickjs-runtest
+assets/                    build-time asset bakers (pure JS, no native deps) — see "Assets" below
+  rasterize.mjs            glyph path → coverage bitmap (supersampled, nonzero winding)
+  bake-font.mjs            TTF/OTF → engine BitmapFont glyph data (opentype.js)
+  bake-image.mjs           PNG → premultiplied ARGB8888 (pngjs)
+  emit-c.mjs               assemble assets.generated.c + the built-in font_data.c
+  build-builtin-font.mjs   regenerate the engine's default Inter font (npm run build:builtin-font)
+build.mjs                  esbuild a demo's index.jsx → dist/app.bundle.js + bake its imported assets
+pack-container.mjs         bundle + bytecode-compile + bake → dist/app.erpkg config container (npm run pack)
+  assets/emit-container.mjs  ERCF container writer (sections + QuickJS version stamp + CRC32)
+vitest.config.js           unit test config
+```
+
+The demo apps themselves live in the top-level **`demos/`** folder (one folder per demo), *not*
+here — this package is the library + reconciler + tests. `build.mjs` bundles a selected demo and
+resolves its `'embedded-react'` import to `src/embedded-react/index.js` via an esbuild alias. See
+[`demos/README.md`](../../../demos/README.md).
+
+The host config flattens RN `style` (+ nested arrays) into the flat prop bag, routes `on*`
+handlers to `setEvent`, and uses `shouldSetTextContent` so a flattenable `<Text>` subtree (a string,
+interpolation like `Hi {name}`, or nested `<Text>` runs) becomes the node's `text` + inline spans.
+`Animated`, `Easing`, and the web timer globals (`setTimeout` / `setInterval`) are all available;
+`useEffect` flushes via the host pump (BRIDGE.md §1.2, §1.4, §2).
+
+## Build
+
+```
+npm install
+npm run pack                # default demo → dist/app.erpkg (deployable config: bytecode + assets + CRC)
+npm run pack -- marine-dash # pack a specific demo (demos/<name>) instead
+npm run build               # lower-level: just bundle → dist/app.bundle.js (+ bake assets.generated.c)
+npm run create -- my-app    # scaffold a new app at demos/my-app (App.jsx + scripts); then `cd` + npm run sim
+```
+
+`npm run pack` is the deployable artifact the desktop demo and the ESP32 both load — see **Config
+container** below. `npm run build` is the lower-level bundle step (used by the bytecode/asset tooling
+and by firmware that prefers to compile assets in); both bake the demo's imported images and fonts
+(see **Assets**).
+
+## Assets (images and fonts)
+
+Asset handling is **import-driven** and fully build-time — there is no runtime decoder or font
+rasterizer on the device, and no Python toolchain. An app just imports a file and uses the name it
+returns:
+
+```jsx
+import logo from './assets/logo.png';      // → the baked image NAME ("logo")
+import Inter from './assets/Inter.ttf';     // → the baked font FAMILY ("Inter")
+
+<Image source={logo} style={{ width: 64, height: 64 }} />
+<Text style={{ fontFamily: Inter, fontSize: 18 }}>Hi</Text>
+```
+
+The baker produces the assets two ways, from the same bytes: `npm run pack` packs them **into the
+config container** (`app.erpkg`), registered at load time — this is what the desktop demo and ESP32
+use. `npm run build` also emits `dist/assets.generated.c` exposing **`er_register_assets()`**, for
+firmware that prefers to **compile assets into the image** and call it once at boot (`er_image_load` /
+`er_font_register`, both flash-resident, zero runtime RAM). Either way the asset name/family is the
+file's basename.
+
+- **Images:** PNG → premultiplied ARGB8888 (`bake-image.mjs`, via `pngjs`).
+- **Fonts:** TTF/OTF → pre-rasterized `BitmapFont` glyphs (`bake-font.mjs`, via `opentype.js` + a
+  pure-JS rasterizer). The engine has no runtime rasterizer, so the baker rasterizes **exactly the
+  literal `fontSize` values the bundle uses**. Computed/dynamic sizes snap to the nearest baked size
+  at runtime — pin them in `assets.config.js` if needed.
+
+Optional per-demo overrides live in `demos/<demo>/assets.config.js`:
+
+```js
+export default {
+  fonts: {
+    Inter: { sizes: [14, 18, 24], bpp: 4, glyphs: 'common' }, // bpp 1|2|4|8 (4 default); glyphs: 'ascii'|'common'|'minimal'|'greek'|[codepoints]
+  },
+};
+```
+
+The engine's **built-in default font** (`engine/font/font_data.c`, the Inter fallback used by any
+text without a custom `fontFamily`) is generated by the same baker — regenerate it with
+`npm run build:builtin-font` (then re-run the engine text tests, as glyph metrics shift slightly).
+
+## Config container
+
+`npm run pack` wraps the app into one deployable file — **`dist/app.erpkg`** (format `ERCF`):
+
+```
+magic "ERCF" | format_version | crc32 | qjs_tag | sections[ bytecode, asset pack ]
+```
+
+It bundles the demo, precompiles it to **QuickJS bytecode** (no parser/source shipped), bakes the
+imported assets into an ERPK pack, and wraps both with a **QuickJS version stamp** and an **integrity
+CRC32**. That one `.erpkg` is "the config": loaded by `er_runtime_load_container()` on the desktop, or
+flashed to a device's config partition. The loader verifies CRC + version (a config built for a
+different QuickJS is rejected, not run as garbage) and registers the assets before the app mounts. This
+is the firmware-vs-config split: the firmware (desktop exe / ESP32 image) ships once; the `.erpkg`
+ships and updates independently.
+
+> Two CRCs are different things: the container's internal CRC32 is embedded-react's own integrity
+> check (universal). A bootloader's transfer/flash CRC is a separate,
+> project-specific step layered on the `.erpkg` by your upload toolchain.
+
+The precompiler tool must be built once (`pack` looks for it in the usual build dirs, or set
+`ER_COMPILE_BIN`): `cmake -S bridges/quickjs -B bridges/quickjs/build && cmake --build
+bridges/quickjs/build --target er-bridge-quickjs-compile`.
+
+## Run (desktop)
+
+After `npm run pack`, **rebuild the `embedded-react-desktop` target** — its build copies
+`dist/app.erpkg` into the "config slot" next to the executable, and the host loads it **by default**
+(no argument), exactly as the ESP32 loads its config from flash:
+
+```
+examples/linux/build/embedded-react-desktop            # runs the config in the slot
+examples/linux/build/embedded-react-desktop  other.erpkg # or an explicit container / .qbc / .js path
+```
+
+The firmware ships no app and no baked assets — everything rides in the container. No config / a
+corrupt one shows an on-screen panel (no built-in fallback). The C host injects the globals the app
+expects: `NativeUI` (the bridge), `screen` (`{ width, height, scale }`), and `console`.
+
+> Iteration loop: edit `src/*` (library) or `demos/<name>/*` (app) → `npm run pack` → rebuild
+> `embedded-react-desktop` (re-copies the container into the slot) → run. Or, for an instant
+> edit-save-see loop, use the **simulator** (`npm run sim`).
+
+## Tests
+
+Two tiers, by what they need:
+
+```
+npm test            # unit: Vitest over src/**/__tests__/*.unit.test.js (pure JS, no engine)
+npm run test:runtime  # e2e: bundles test/runtime/*.runtime.test.jsx, runs each in the headless
+                      #      QuickJS+engine harness (no window) and checks the result
+npm run test:bytecode # same suite, but each bundle is precompiled to a .qbc bytecode blob and run
+                      #      via the bytecode path (JS_ReadObject) — proves the MCU load path
+```
+
+The runtime tiers need the harness exe built once (no SDL); `test:bytecode` also needs the compiler:
+
+```
+cmake --build bridges/quickjs/build --target er-bridge-quickjs-runtest er-bridge-quickjs-compile
+```
+
+Pick the tier by what the code touches: pure marshalling/logic → a co-located `*.unit.test.js`;
+anything that exercises the reconciler → engine pipeline → a `test/runtime/*.runtime.test.jsx`.
+
+## Status & known gaps
+
+- ✅ **Render, state, keyed-list reorder, and Animated all work end-to-end.** `<App/>` mounts, taps
+  re-render via `setState`, keyed reorder moves nodes (`insertBefore`/`appendChild`), and
+  `Animated.View` runs **native-driver** animations in the engine (no per-frame JS). Covered by
+  `test/runtime/reorder.runtime.test.jsx` and `animated.runtime.test.jsx`.
+- ✅ **Timers, Promises, and `useEffect` work.** `setTimeout`/`setInterval`/`clearTimeout`/
+  `clearInterval` and the Promise job queue are serviced each frame by the host pump
+  (`er_bridge_pump`, off the engine clock). React passive effects (`useEffect`) flush on the pump.
+  Covered by `timers.runtime.test.js` and `effects.runtime.test.jsx`.
+- ✅ **Animated composition + completion.** `sequence`/`parallel`/`stagger`/`delay`/`loop` and
+  `.start(({ finished }) => …)` all work — composition is pure JS over each child's start/stop, with
+  completion wired through the engine's `on_complete`. Covered by `anim-compose.runtime.test.js`.
+- ✅ **Multi-child `<Text>` + nested spans.** Interpolation (`Hi {name}`) and nested styled
+  `<Text>` runs both work — a flattenable `<Text>` owns its subtree and renders as the node's text
+  plus, when runs differ in style, an inline span array (`NativeUI.setTextSpans`, max 4). Covered by
+  `text-spans` unit + runtime tests.
+- ✅ **LayoutAnimation.** `LayoutAnimation.configureNext(...)` before a layout-changing state update
+  tweens every node whose computed rect moved on the next commit (in C — no per-frame JS). `Presets`
+  / `create` / `Types` / `Properties` and the `easeInEaseOut`/`linear`/`spring` shorthands. Covered
+  by `layout-animation` unit + `layout-anim.runtime.test.jsx`.
+- ✅ **Interpolate `extrapolate`.** `interpolate({ inputRange, outputRange, extrapolate })` supports
+  `'extend'` (default) / `'clamp'` / `'identity'`, with per-end `extrapolateLeft`/`extrapolateRight`
+  overrides. Math is engine-tested (`test_interpolate`); the bridge path by
+  `interpolate-extrapolate.runtime.test.js`.
+- ✅ **Bytecode + assets + `useAnimatedValue`.** The build compiles the bundle to a `.qbc` bytecode
+  blob (the MCU load path) and bakes imported images/fonts to flash-resident C; `useAnimatedValue` is
+  exported. Runs end-to-end on the desktop host and on ESP32-S3 hardware.
+- ✅ **State survives hot reload** — in the simulator, plain `useState` transparently persists across
+  saves (a sim-only build transform rewrites it to a persisting helper; press R to reset). On a device
+  it's just `useState`, so the same app code runs everywhere. `usePersistentState` is the underlying
+  helper, also exported for explicit use. See `/SIMULATOR.md`.
+- ⏳ **`create-embedded-react` scaffold** — the project-init CLI is still to come (§4).