@geastack/core 0.1.41 → 0.1.43

package/README.md

@@ -13,8 +13,8 @@ npm install @geastack/core
 Apps import the types and the runtime modules:
 
 ```tsx
-import type { Style } from '@geastack/core'
-import { View, Text } from '@geastack/engine'
+import type { Style } from "@geastack/core";
+import { View, Text } from "@geastack/engine";
 ```
 
 Everything else in the package is consumed by tooling, not by app code. The
@@ -37,15 +37,15 @@ before this hook runs. Field initializers and constructors initialize state;
 code that needs a rendered canvas belongs in the hook.
 
 ```tsx
-import { ReactiveComponent } from '@geastack/core'
+import { ReactiveComponent } from "@geastack/core";
 
 class Counter extends ReactiveComponent {
-  count = 0
+  count = 0;
   onAfterRender(): void {
-    this.count = 1
+    this.count = 1;
   }
   template(): JSX.Element {
-    return <div>{this.count}</div>
+    return <div>{this.count}</div>;
   }
 }
 ```
@@ -63,15 +63,42 @@ changes need to preserve the shared component and native-type contracts.
 WebSocket constructor argument for connection headers on ESP32 native hosts:
 
 ```ts
-const socket = new WebSocket('wss://api.openai.com/v1/live/sessions', '', {
-  headers: [{ name: 'Authorization', value: `Bearer ${process.env.OPENAI_API_KEY}` }],
-})
+const socket = new WebSocket("wss://api.openai.com/v1/live/sessions", "", {
+  headers: [
+    { name: "Authorization", value: `Bearer ${process.env.OPENAI_API_KEY}` },
+  ],
+});
 ```
 
 Use these paired versions or newer when a service requires bearer authentication
 in the WebSocket handshake. Header names and values are validated before the
 connection starts. This native option is unavailable in browser WebSockets.
 
+## File-backed native assets
+
+Native apps can keep images and baked font atlases on a mounted volume instead
+of in the executable. Opt in through the app manifest:
+
+```json
+{
+  "gea": {
+    "embeddedAssets": {
+      "storage": { "type": "file", "directory": "/nand" }
+    }
+  }
+}
+```
+
+The generators emit content-addressed `.bin` payloads and a `.assets.json`
+deployment manifest alongside each generated C++ source. Copy each `local` file
+to its `remote` path, for example with `gea devctl push`, before starting the app.
+The target must register a mount provider; ESP32 targets also need external BSS
+enabled. The runtime reads and validates the entire bundle once into permanent
+RAM buffers. Render-time image and font lookups use those buffers, with no file
+I/O. Missing, truncated or corrupt bundles are rejected until the next process
+start. Retain older content-addressed files when firmware rollback is required.
+Apps without this option continue embedding their assets in the executable.
+
 ## Related packages
 
 - `@geastack/engine` renders the element tree, `@geastack/host` supplies the

package/events.cpp

@@ -35,6 +35,7 @@ int EventTarget::pressValue() const
 
 const char *PointerEvent::typeName() const
 {
+	if (!subscriberTypeName.empty()) return subscriberTypeName.c_str();
 	switch (type) {
 	case PointerEventType::TouchStart:
 		return "touchstart";
@@ -46,12 +47,22 @@ const char *PointerEvent::typeName() const
 		return "click";
 	case PointerEventType::Input:
 		return "input";
+	case PointerEventType::FocusIn: return "focusin";
+	case PointerEventType::FocusOut: return "focusout";
+	case PointerEventType::Change:
+		return "change";
+	case PointerEventType::PointerCancel:
+		return "pointercancel";
 	case PointerEventType::KeyUp:
 		return "keyup";
 	case PointerEventType::KeyDown:
 		return "keydown";
 	case PointerEventType::Rotary:
 		return "rotary";
+	case PointerEventType::WindowBlur:
+		return "blur";
+	case PointerEventType::WindowResize:
+		return "resize";
 	case PointerEventType::Scroll:
 		return "scroll";
 	}

package/gea_app_entry.cpp

@@ -31,6 +31,7 @@ void drainMicrotasks();
 
 extern "C" void gea_cycle_collection_defer_begin() __attribute__((weak));
 extern "C" void gea_cycle_collection_defer_end() __attribute__((weak));
+extern "C" bool gea_embedded_assets_prepare() __attribute__((weak));
 
 namespace gea::framework::app {
 
@@ -91,6 +92,9 @@ private:
 
 void Application::init(int width, int height, double devicePixelRatio)
 {
+    // File-backed static symbols must be populated before generated code can
+    // construct an image directly from them. Embedded assets need no hook.
+    if (gea_embedded_assets_prepare) gea_embedded_assets_prepare();
 	// Top-level construction allocates the entire native object graph. Keep the
 	// generated collector at a host safepoint until initialization has unwound,
 	// just as Application::frame does for animation callbacks.

package/gea_sources.mjs

@@ -78,7 +78,7 @@ export function cxxSources(env = process.env) {
       'tree_state', 'node_lifecycle', 'display_invalidation', 'layout_snapshot',
       'absolute_leaf_refresh', 'viewport_region', 'dirty_regions', 'root_scroll_refresh',
       'node', 'view_element', 'text_element', 'image_element', 'style', 'css_atom',
-      'document', 'core', 'tree_nodes', 'tree_style', 'tree_scroll_mirror', 'tree_render',
+      'document', 'selector', 'core', 'tree_nodes', 'tree_style', 'tree_scroll_mirror', 'tree_render',
       'view', 'text', 'image_node', 'layout', 'render', 'input', 'input_render',
       'virtual_keyboard', 'canvas_element', 'canvas_store', 'tree_events'
     ]),
@@ -87,6 +87,8 @@ export function cxxSources(env = process.env) {
     ...cpp(join(elements, 'ui'), ['camera_element', 'virtual_list']),
     // @geastack/host — platform layer + services
     ...cpp(host, ['input', 'wifi', 'bluetooth', 'geolocation']),
+    // Only native Linux targets opt into their existing libcurl dependency.
+    ...(env.GEA_DESKTOP_WEBSOCKET_CURL === '1' ? [join(host, 'host/websocket_curl.cpp')] : []),
     ...cpp(join(host, 'host'), [
       'timers', 'worker', 'input', 'device', 'display', 'fetch', 'media', 'rtc', 'websocket', 'http', 'wifi',
       'ble', 'apps', 'audio', 'audio_worklet', 'audio_buffer_runtime', 'video', 'mjpeg', 'image', 'touch', 'imu', 'memory', 'camera', 'geolocation',
@@ -105,10 +107,18 @@ export function cxxSources(env = process.env) {
   ]
 }
 
+// Apple targets compile Objective-C++ separately with ARC/Foundation. Keep the
+// framework transport provider at the same source authority as C/C++ inputs.
+export function objcxxSources(env = process.env) {
+  const { host } = packageDirs(env)
+  return [join(host, 'host/websocket_apple.mm')]
+}
+
 const queries = {
   'include-flags': includeFlags,
   'c-sources': cSources,
-  'cxx-sources': cxxSources
+  'cxx-sources': cxxSources,
+  'objcxx-sources': objcxxSources
 }
 
 const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)

package/gea_sources.sh

@@ -4,7 +4,7 @@
 # no bash, so `execute_process(COMMAND bash -c ...)` failed and no ESP32 target
 # could configure. Node is already a hard requirement of every path that gets
 # here (the CLI and geatsc are Node), so reading it from Node costs no new
-# dependency, and keeping these three function names means shell callers that
+# dependency, and keeping the existing function names means shell callers that
 # `source` this file (simulator build-web.sh, core's own test) do not change.
 #
 # Caller must export GEA_CORE = the @geastack/core package dir, plus
@@ -34,3 +34,8 @@ gea_fw_c_sources() {
 gea_fw_cxx_sources() {
   __gea_sources_run cxx-sources
 }
+
+# Apple-only framework sources (ARC/Foundation); ordinary C++ targets do not call this.
+gea_fw_objcxx_sources() {
+  __gea_sources_run objcxx-sources
+}

package/include/canvas.h

@@ -213,6 +213,7 @@ public:
 	void drawText(const char *text, int x, int y, pixel::native_t color, float scale);
 	void drawTextFont(const char *text, int x, int y, pixel::native_t color, int font_id);
 	void drawTextFontFamily(const char *text, int x, int y, pixel::native_t color, int family_id, int size_px);
+	void drawTextFontFamily(const char *text, int x, int y, pixel::native_t color, int family_id, int size_px,int weight,int stretch);
 	// Rotated 90deg for panel-native landscape rendering: the anchor and the
 	// text advance are in LANDSCAPE coordinates; every glyph pixel writes to
 	// the portrait panel address (panel_x = ly, panel_y = height-1-lx). The

package/include/display.h

@@ -356,6 +356,7 @@ public:
 	static void drawText(const char *text, int x, int y, gea::framework::graphics::pixel::native_t color, float scale);
 	static void drawTextFont(const char *text, int x, int y, gea::framework::graphics::pixel::native_t color, int font_id);
 	static void drawTextFontFamily(const char *text, int x, int y, gea::framework::graphics::pixel::native_t color, int family_id, int size_px);
+	static void drawTextFontFamily(const char *text,int x,int y,gea::framework::graphics::pixel::native_t color,int family_id,int size_px,int weight,int stretch);
 	static void setPixel(int x, int y, gea::framework::graphics::pixel::native_t color);
 	static void fillRoundedRect(int x, int y, int w, int h, int tl, int tr, int br, int bl, gea::framework::graphics::pixel::native_t color);
 	static void fillRoundedRectBoxesRgb565(const int16_t *xs, const int16_t *ys, int count,

package/include/event_listener_options.h

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+#include <cstddef>
+#include <cstdlib>
+#include <type_traits>
+namespace gea { template <typename... Arms> class TaggedUnion; }
+namespace gea::framework::events {
+struct NativeListenerOptions { bool capture=false; bool once=false; };
+inline NativeListenerOptions listenerOptions(bool capture) { return {capture,false}; }
+template <typename Boolean> bool listenerOptionBoolean(const Boolean &value) {
+ if constexpr (std::is_same_v<Boolean,bool>) return value;
+ else { static_assert(std::is_same_v<std::remove_cvref_t<decltype(*value)>,bool>); return value.has_value() && *value; }
+}
+// Exact generated record fields remain native Optional<bool>; never Value/boxing.
+template <typename Record> requires requires(const Record &value) { value->capture; value->once; }
+NativeListenerOptions listenerOptions(const Record &value) {
+ if (!value) return {};
+ return {listenerOptionBoolean(value->capture),listenerOptionBoolean(value->once)};
+}
+template <std::size_t Index=0, typename... Arms>
+NativeListenerOptions listenerOptions(const gea::TaggedUnion<Arms...> &value) {
+ if (value.template is<Index>()) return listenerOptions(value.template get<Index>());
+ if constexpr (Index+1<sizeof...(Arms)) return listenerOptions<Index+1>(value);
+ else std::abort();
+}
+}

package/include/events.h

@@ -1,10 +1,17 @@
 #pragma once
 
 #include "event.h"
+#include "native_identity.h"
 
 #include <cstdint>
 #include <functional>
 #include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace gea::detail { struct RefVisitor; template<class T> struct TraceEdges; }
 
 namespace gea::framework::events {
 
@@ -17,7 +24,13 @@ enum class PointerEventType {
 	KeyDown,
 	Rotary,
 	Scroll,
-	KeyUp
+	KeyUp,
+	PointerCancel,
+	WindowBlur,
+	WindowResize,
+	Change,
+	FocusIn,
+	FocusOut
 };
 
 enum class EventPhase {
@@ -29,10 +42,13 @@ enum class EventPhase {
 
 class EventTarget {
 public:
-	explicit EventTarget(int nodeId = -1) : nodeId_(nodeId) {}
+	explicit EventTarget(int nodeId = -1) : nodeId_(nodeId), identity_(identity::node(nodeId)) {}
+	const void *identity() const { return identity_.get(); }
+	std::shared_ptr<const void> weakIdentityOwner() const { return identity_; }
+	const identity::Owner &identityOwner() const { return identity_; }
 
-	int id() const { return nodeId_; }
-	bool valid() const { return nodeId_ >= 0; }
+	int id() const { return valid() ? nodeId_ : -1; }
+	bool valid() const { return identity::current(nodeId_, identity_); }
 	const char *getAttribute(const char *name) const;
 	const char *dataset(const char *name) const;
 	int pressId() const;
@@ -40,6 +56,7 @@ public:
 
 private:
 	int nodeId_;
+	identity::Owner identity_;
 };
 
 struct TouchPoint {
@@ -86,6 +103,9 @@ struct PointerEvent {
 	int targetId = -1;
 	int currentTargetId = -1;
 	int pointerId = 0;
+	// Unknown/non-pointer producers never impersonate a primary button edge.
+	int button = -1;
+	std::uint32_t buttons = 0;
 	int x = 0;
 	int y = 0;
 	int clientX = 0;
@@ -97,12 +117,25 @@ struct PointerEvent {
 	int pressId = -1;
 	int pressValue = -1;
 	int keyCode = 0;
+	// Native keyboard metadata. Non-keyboard producers retain explicit empty
+	// strings/false flags; no browser record or boxed event is involved.
+	std::string key;
+	std::string code;
+	bool altKey = false;
+	bool ctrlKey = false;
+	bool metaKey = false;
+	bool shiftKey = false;
+	bool repeat = false;
+	bool isComposing = false;
 	int delta = 0;
 	bool primary = true;
 	bool bubbles = true;
 	bool cancelable = true;
 	EventControlFlag defaultPrevented;
 	EventControlFlag propagationStopped;
+	identity::Occurrence occurrenceIdentity;
+	const void *identity() const { return occurrenceIdentity.identity(); }
+	std::shared_ptr<const void> weakIdentityOwner() const { return occurrenceIdentity.owner(); }
 	EventPhase eventPhase = EventPhase::None;
 	TouchPoint touches[1]{};
 	TouchPoint targetTouches[1]{};
@@ -111,12 +144,83 @@ struct PointerEvent {
 	int targetTouchesLength = 0;
 	int changedTouchesLength = 0;
 
+	// Scoped subscriber spelling; physical phase/type and occurrence stay unchanged.
+	std::string subscriberTypeName;
 	const char *typeName() const;
 	void preventDefault();
 	void stopPropagation();
 };
 
-using EventListener = std::function<void(PointerEvent &)>;
+// Ordinary native callbacks keep the platform std::function's own small-object
+// storage. Explicit ADL-traceable callbacks instead own a concrete copy: a
+// shared erased model would report one physical capture once for every copy.
+class EventListener {
+ struct Model {
+  virtual ~Model() = default;
+  virtual std::unique_ptr<Model> clone() const = 0;
+  virtual void invoke(PointerEvent&) const = 0;
+  virtual void trace(gea::detail::RefVisitor&) const = 0;
+ };
+ template<class F> struct Concrete final : Model {
+  mutable F callable;
+  explicit Concrete(F value) : callable(std::move(value)) {}
+  std::unique_ptr<Model> clone() const override { return std::make_unique<Concrete>(callable); }
+  void invoke(PointerEvent& event) const override { callable(event); }
+  void trace(gea::detail::RefVisitor& visitor) const override { geaTraceRefs(callable, visitor); }
+ };
+ std::function<void(PointerEvent&)> ordinary_;
+ std::unique_ptr<Model> traced_;
+public:
+ EventListener() = default;
+ EventListener(std::nullptr_t) noexcept {}
+ template<class F> requires (!std::is_same_v<std::decay_t<F>,EventListener> &&
+                            std::is_copy_constructible_v<std::decay_t<F>> &&
+                            std::is_invocable_r_v<void,std::decay_t<F>&,PointerEvent&>)
+ EventListener(F&& callable) {
+  using Held = std::decay_t<F>;
+  if constexpr (requires(const Held& held, gea::detail::RefVisitor& visitor) { geaTraceRefs(held,visitor); })
+   traced_ = std::make_unique<Concrete<Held>>(std::forward<F>(callable));
+  else ordinary_ = std::forward<F>(callable);
+ }
+ EventListener(const EventListener& other)
+  : ordinary_(other.ordinary_), traced_(other.traced_ ? other.traced_->clone() : nullptr) {}
+ EventListener(EventListener&&) noexcept = default;
+ EventListener& operator=(const EventListener& other) { EventListener copy(other); swap(copy); return *this; }
+ EventListener& operator=(EventListener&&) noexcept = default;
+ EventListener& operator=(std::nullptr_t) noexcept { ordinary_=nullptr; traced_.reset(); return *this; }
+ void swap(EventListener& other) noexcept { ordinary_.swap(other.ordinary_); traced_.swap(other.traced_); }
+ explicit operator bool() const noexcept { return bool(traced_) || bool(ordinary_); }
+ void operator()(PointerEvent& event) const { if(traced_) traced_->invoke(event); else ordinary_(event); }
+ friend void geaTraceRefs(const EventListener& value, gea::detail::RefVisitor& visitor) {
+  if(value.traced_) value.traced_->trace(visitor);
+ }
+};
+
+// Invocation has no hidden captures. Each owned capture occurs exactly once,
+// in this tuple, and nested adapters preserve that same ADL trace authority.
+template<class Invoke,class... Captures>
+struct ExplicitEventCallback {
+ static_assert(std::is_empty_v<Invoke>, "event invocation must be capture-free");
+ Invoke invoke;
+ std::tuple<Captures...> captures;
+ void operator()(PointerEvent& event) {
+  std::apply([&](auto&... values){invoke(values...,event);},captures);
+ }
+ friend void geaTraceRefs(const ExplicitEventCallback& value,gea::detail::RefVisitor& visitor) {
+  std::apply([&](const auto&... values){
+   auto trace=[&]<class T>(const T& capture){
+    if constexpr(requires { gea::detail::TraceEdges<T>::supported; })
+     gea::detail::TraceEdges<T>::visit(capture,visitor);
+    else if constexpr(requires { geaTraceRefs(capture,visitor); }) geaTraceRefs(capture,visitor);
+   };
+   (trace(values),...);
+  },value.captures);
+ }
+};
+template<class Invoke,class... Captures>
+auto explicitEventCallback(Invoke invoke,Captures&&... captures) {
+ return ExplicitEventCallback<Invoke,std::decay_t<Captures>...>{std::move(invoke),{std::forward<Captures>(captures)...}};
+}
 using EventListenerId = std::uint64_t;
 inline constexpr EventListenerId kInvalidEventListenerId = 0;
 

package/include/gea/embedded.h

@@ -10,6 +10,7 @@
 // includes gea/embedded-host.h instead (no engine/reactive dependency).
 #include "gea/embedded-host.h"
 #include "ui/document.h"
+#include "ui/child_node_list.h"
 #include "ui/signal.h"
 // Debug builds: attributes JSX listeners to nodes for DevTools.
 #include "ui/debugger_listeners.h"

package/include/graphics/font.h

@@ -2,6 +2,10 @@
 
 #include <cstdint>
 
+#ifndef GEA_EMBEDDED_TTF_FREETYPE
+#define GEA_EMBEDDED_TTF_FREETYPE 0
+#endif
+
 namespace gea::framework::graphics {
 
 struct Glyph {
@@ -98,6 +102,12 @@ struct RasterizedFontData {
 	const FontKerningPair *kerning = nullptr;
 	bool strictGlyphLookup = false;
 	int fallbackCodepoint = -1;
+#if GEA_EMBEDDED_TTF_FREETYPE
+ // Runtime slot reuse must not reuse Canvas sprite/glyph-cache identity.
+ std::uint64_t generation = 0;
+#else
+ static constexpr std::uint64_t generation = 0;
+#endif
 };
 
 class RasterizedFont final : public Font {
@@ -122,6 +132,7 @@ class FontRegistry {
 public:
 	static RasterizedFont rasterized(int fontId);
 	static RasterizedFont rasterizedFamily(int familyId, int sizePx);
+	static RasterizedFont rasterizedFamily(int familyId, int sizePx, int weight, int stretch);
 	static const BitmapFont8x16 &bitmap8x16();
 	static int familyId(const char *family);
 	static const char *familyName(int familyId);

package/include/native_identity.h

@@ -0,0 +1,65 @@
+#pragma once
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+namespace gea::framework::identity {
+struct Token {};
+using Owner = std::shared_ptr<const Token>;
+// A copied carrier retains the same occurrence, including copies made before
+// the first identity observation. Fresh event carriers have distinct tokens.
+class Occurrence {
+public:
+  Occurrence() = default;
+  Occurrence(const Occurrence &other) : owner_(other.owner()) {}
+  Occurrence &operator=(const Occurrence &other) {
+    if (this != &other) owner_ = other.owner();
+    return *this;
+  }
+  Owner owner() const {
+    if (!owner_) owner_ = std::make_shared<Token>();
+    return owner_;
+  }
+  const void *identity() const { return owner().get(); }
+private:
+  mutable Owner owner_;
+};
+// Tree ids are reused. Registry entries cover only the current allocation;
+// the tree retains live-node tokens until removal/clear. Retained handles
+// own retired tokens independently; weak collections never extend that life.
+struct NodeRegistry {
+  std::mutex mutex;
+  std::unordered_map<int, Owner> nodes;
+};
+inline NodeRegistry &registry() { static NodeRegistry value; return value; }
+inline Owner node(int id) {
+  if (id < 0) return {};
+  auto &r = registry();
+  std::lock_guard<std::mutex> lock(r.mutex);
+  const auto found = r.nodes.find(id);
+  return found == r.nodes.end() ? Owner{} : found->second;
+}
+inline bool current(int id, const Owner &owner) {
+  if (id < 0 || !owner) return false;
+  auto &r = registry();
+  std::lock_guard<std::mutex> lock(r.mutex);
+  const auto found = r.nodes.find(id);
+  return found != r.nodes.end() && found->second == owner;
+}
+inline void activate(int id) {
+  if (id < 0) return;
+  auto &r = registry();
+  std::lock_guard<std::mutex> lock(r.mutex);
+  r.nodes[id] = std::make_shared<Token>();
+}
+inline void retire(int id) {
+  auto &r = registry();
+  std::lock_guard<std::mutex> lock(r.mutex);
+  r.nodes.erase(id);
+}
+inline void clear() {
+  auto &r = registry();
+  std::lock_guard<std::mutex> lock(r.mutex);
+  r.nodes.clear();
+}
+} // namespace gea::framework::identity

package/include/platform/asset_bundle.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "platform/file_cache.h"
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+
+#ifdef ESP_PLATFORM
+#include "esp_attr.h"
+#if !CONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY
+#error "File-backed assets require external BSS storage on ESP32"
+#endif
+#define GEA_FILE_ASSET_BUFFER EXT_RAM_BSS_ATTR
+#else
+#define GEA_FILE_ASSET_BUFFER
+#endif
+
+namespace gea::platform::storage {
+struct AssetSegment {
+  unsigned char *data;
+  std::size_t size;
+};
+
+// The generator names immutable bundles by content. Validate the complete
+// payload before exposing any font/image, then retain it in RAM for rendering.
+inline bool loadAssetBundle(const char *path, const AssetSegment *segments,
+                            std::size_t count, std::size_t bytes,
+                            std::uint32_t expectedCrc) {
+  if (!ensureMounted())
+    return false;
+  auto *file = std::fopen(path, "rb");
+  if (!file) {
+    std::fprintf(stderr, "Gea asset bundle missing: %s\n", path);
+    return false;
+  }
+  std::uint32_t crc = 0xffffffffU;
+  constexpr std::uint32_t table[] = {
+      0x00000000U, 0x1db71064U, 0x3b6e20c8U, 0x26d930acU,
+      0x76dc4190U, 0x6b6b51f4U, 0x4db26158U, 0x5005713cU,
+      0xedb88320U, 0xf00f9344U, 0xd6d6a3e8U, 0xcb61b38cU,
+      0x9b64c2b0U, 0x86d3d2d4U, 0xa00ae278U, 0xbdbdf21cU};
+  std::size_t read = 0;
+  bool ok = true;
+  for (std::size_t index = 0; index < count; ++index) {
+    const auto &part = segments[index];
+    if (part.size > bytes - read ||
+        std::fread(part.data, 1, part.size, file) != part.size) {
+      ok = false;
+      break;
+    }
+    read += part.size;
+    for (std::size_t i = 0; i < part.size; ++i) {
+      crc ^= part.data[i];
+      crc = (crc >> 4) ^ table[crc & 15];
+      crc = (crc >> 4) ^ table[crc & 15];
+    }
+  }
+  ok = ok && read == bytes && (crc ^ 0xffffffffU) == expectedCrc &&
+       std::fgetc(file) == EOF && !std::ferror(file);
+  std::fclose(file);
+  if (!ok) {
+    for (std::size_t index = 0; index < count; ++index)
+      std::memset(segments[index].data, 0, segments[index].size);
+    std::fprintf(stderr, "Gea asset bundle failed validation: %s\n", path);
+  } else
+    std::fprintf(stderr, "Gea asset bundle loaded: %s (%lu bytes)\n", path,
+                 static_cast<unsigned long>(bytes));
+  return ok;
+}
+} // namespace gea::platform::storage