sibujs 4.5.0 → 4.6.0

package/dist/performance.cjs

@@ -58,6 +58,94 @@ __export(performance_exports, {
 });
 module.exports = __toCommonJS(performance_exports);
 
+// src/core/errors.ts
+var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
+function state() {
+  const g = globalThis;
+  const existing = g[ERROR_STATE_KEY];
+  if (existing) return existing;
+  const created = { handler: null, handlerDepth: 0 };
+  g[ERROR_STATE_KEY] = created;
+  return created;
+}
+function normalizeError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
+  return new Error(message, { cause: value });
+}
+function safeStringify(value) {
+  if (typeof value === "symbol") return value.toString();
+  try {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
+}
+var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
+function untrackedRun(fn) {
+  const api = globalThis[REACTIVE_REGISTRY_KEY];
+  return api?.untracked ? api.untracked(fn) : fn();
+}
+var PROPAGATE_EVENT = "sibu:error-propagate";
+function claimedByBoundary(error, context) {
+  const raw = context.node;
+  if (!raw || typeof CustomEvent === "undefined") return false;
+  const target = resolveEventTarget(raw);
+  if (!target) return false;
+  try {
+    const event = new CustomEvent(PROPAGATE_EVENT, {
+      bubbles: true,
+      cancelable: true,
+      detail: { error, context }
+    });
+    return target.dispatchEvent(event) === false;
+  } catch {
+    return false;
+  }
+}
+function resolveEventTarget(node) {
+  const ELEMENT_NODE = 1;
+  let current = node;
+  while (current) {
+    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  const self = node;
+  return typeof self.dispatchEvent === "function" ? self : null;
+}
+function defaultReport(error, context) {
+  if (typeof console === "undefined") return;
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
+}
+function reportError(error, context) {
+  const err = normalizeError(error);
+  untrackedRun(() => {
+    if (claimedByBoundary(err, context)) return;
+    const s = state();
+    const handler = s.handler;
+    if (handler && s.handlerDepth === 0) {
+      s.handlerDepth++;
+      try {
+        handler(error instanceof Error ? error : err, context);
+        return;
+      } catch (handlerError) {
+        if (typeof console !== "undefined") {
+          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
+          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
+        }
+      } finally {
+        s.handlerDepth--;
+      }
+    }
+    defaultReport(err, context);
+  });
+}
+
 // src/utils/globalSingleton.ts
 function globalSingleton(key, create) {
   const g = globalThis;
@@ -88,28 +176,34 @@ function insertTask(task) {
   }
   taskQueue.splice(i, 0, task);
 }
+function runTask(callback) {
+  try {
+    callback();
+  } catch (err) {
+    reportError(err, { phase: "scheduler", name: "scheduleUpdate" });
+  }
+}
 function processQueue() {
   if (_sched.isProcessing || taskQueue.length === 0) return;
   _sched.isProcessing = true;
   const startTime = performance.now();
   const timeSlice = 5;
-  while (taskQueue.length > 0) {
-    const task = taskQueue[0];
-    if (task.cancelled) {
+  try {
+    while (taskQueue.length > 0) {
+      const task = taskQueue[0];
+      if (task.cancelled) {
+        taskQueue.shift();
+        continue;
+      }
+      if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
+        break;
+      }
       taskQueue.shift();
-      continue;
-    }
-    if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
-      break;
-    }
-    taskQueue.shift();
-    try {
-      task.callback();
-    } catch (e) {
-      console.error("[Scheduler] Task error:", e);
+      runTask(task.callback);
     }
+  } finally {
+    _sched.isProcessing = false;
   }
-  _sched.isProcessing = false;
   if (taskQueue.length > 0) {
     scheduleFrame();
   }
@@ -177,11 +271,7 @@ function scheduleUpdate(priority, callback) {
     cancelled: false
   };
   if (priority === Priority.IMMEDIATE) {
-    try {
-      callback();
-    } catch (e) {
-      console.error("[Scheduler] Immediate task error:", e);
-    }
+    runTask(callback);
     return () => {
     };
   }
@@ -201,14 +291,15 @@ function flushScheduler() {
   _sched.scheduledHandle = null;
   _sched.scheduledKind = null;
   _sched.microtaskScheduled = false;
-  while (taskQueue.length > 0) {
-    const task = taskQueue.shift();
-    if (!task) break;
-    if (!task.cancelled) {
-      task.callback();
+  try {
+    while (taskQueue.length > 0) {
+      const task = taskQueue.shift();
+      if (!task) break;
+      if (!task.cancelled) runTask(task.callback);
     }
+  } finally {
+    _sched.isProcessing = false;
   }
-  _sched.isProcessing = false;
 }
 function pendingTasks() {
   return taskQueue.filter((t) => !t.cancelled).length;
@@ -246,92 +337,99 @@ function devWarn(message) {
   }
 }
 
-// src/core/errors.ts
-var ERROR_STATE_KEY = /* @__PURE__ */ Symbol.for("sibujs.runtime-errors.v1");
-function state() {
-  const g = globalThis;
-  const existing = g[ERROR_STATE_KEY];
-  if (existing) return existing;
-  const created = { handler: null, handlerDepth: 0 };
-  g[ERROR_STATE_KEY] = created;
-  return created;
-}
-function normalizeError(value) {
-  if (value instanceof Error) return value;
-  const message = typeof value === "string" ? value : `Non-Error value thrown: ${safeStringify(value)}`;
-  return new Error(message, { cause: value });
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var MAX_DRAIN_TEARDOWNS = 1e4;
+function reportDrainRunaway(label, executed, remaining) {
+  if (typeof console === "undefined") return;
+  console.error(
+    `[SibuJS ${label}] runaway cleanup: stopped after running ${executed} teardowns with ${remaining} still queued. Cleanup production did not stabilize before the teardown safety ceiling was reached \u2014 the remaining work was NOT run.`,
+    { executed, remaining }
+  );
 }
-function safeStringify(value) {
-  if (typeof value === "symbol") return value.toString();
-  try {
-    return typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
-  } catch {
-    return Object.prototype.toString.call(value);
-  }
+var activeBindingCount = 0;
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+var registrationCaptures = [];
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
 }
-function describe(context) {
-  return context.name ? `${context.phase} "${context.name}"` : context.phase;
+function endDisposerCapture() {
+  registrationCaptures.pop();
 }
-var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
-function untrackedRun(fn) {
-  const api = globalThis[REACTIVE_REGISTRY_KEY];
-  return api?.untracked ? api.untracked(fn) : fn();
-}
-var PROPAGATE_EVENT = "sibu:error-propagate";
-function claimedByBoundary(error, context) {
-  const raw = context.node;
-  if (!raw || typeof CustomEvent === "undefined") return false;
-  const target = resolveEventTarget(raw);
-  if (!target) return false;
-  try {
-    const event = new CustomEvent(PROPAGATE_EVENT, {
-      bubbles: true,
-      cancelable: true,
-      detail: { error, context }
-    });
-    return target.dispatchEvent(event) === false;
-  } catch {
-    return false;
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
   }
+  disposers.push(teardown);
+  if (DEV) activeBindingCount++;
+  const capture = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (capture) capture.entries.push([node, teardown]);
 }
-function resolveEventTarget(node) {
-  const ELEMENT_NODE = 1;
-  let current = node;
-  while (current) {
-    if (current.nodeType === ELEMENT_NODE && typeof current.dispatchEvent === "function") {
-      return current;
+function dispose(node) {
+  const stack = [node];
+  const order = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    order.push(current);
+    const children = Array.from(current.childNodes);
+    for (let i = 0; i < children.length; i++) {
+      stack.push(children[i]);
     }
-    current = current.parentNode;
   }
-  const self = node;
-  return typeof self.dispatchEvent === "function" ? self : null;
-}
-function defaultReport(error, context) {
-  if (typeof console === "undefined") return;
-  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
-}
-function reportError(error, context) {
-  const err = normalizeError(error);
-  untrackedRun(() => {
-    if (claimedByBoundary(err, context)) return;
-    const s = state();
-    const handler = s.handler;
-    if (handler && s.handlerDepth === 0) {
-      s.handlerDepth++;
+  for (let i = order.length - 1; i >= 0; i--) {
+    disposeNodeOwn(order[i]);
+  }
+}
+function disposeNodeOwn(node) {
+  if (!elementDisposers.has(node)) return;
+  let executed = 0;
+  let runaway = false;
+  while (!runaway) {
+    const pending = elementDisposers.get(node);
+    if (!pending || pending.length === 0) break;
+    const snapshot = pending.slice();
+    elementDisposers.delete(node);
+    if (DEV) activeBindingCount -= snapshot.length;
+    for (let i = 0; i < snapshot.length; i++) {
+      if (executed >= MAX_DRAIN_TEARDOWNS) {
+        const rest = snapshot.slice(i);
+        const added = elementDisposers.get(node);
+        elementDisposers.set(node, added ? rest.concat(added) : rest);
+        if (DEV) activeBindingCount += rest.length;
+        reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+        runaway = true;
+        break;
+      }
+      executed++;
       try {
-        handler(error instanceof Error ? error : err, context);
-        return;
-      } catch (handlerError) {
-        if (typeof console !== "undefined") {
-          const detail = handlerError instanceof Error ? handlerError.message : String(handlerError);
-          console.error(`[SibuJS] runtime error handler itself threw: ${detail}`, handlerError);
-        }
-      } finally {
-        s.handlerDepth--;
+        snapshot[i]();
+      } catch (err) {
+        reportError(err, { phase: "cleanup", name: "disposer" });
       }
     }
-    defaultReport(err, context);
-  });
+  }
+}
+function replaceChildrenSafely(parent, ...next) {
+  for (let i = 0; i < next.length; i++) {
+    const node = next[i];
+    node.parentNode?.removeChild(node);
+  }
+  const current = Array.from(parent.childNodes);
+  for (let i = 0; i < current.length; i++) {
+    dispose(current[i]);
+  }
+  parent.replaceChildren(...next);
 }
 
 // src/reactivity/track-core.ts
@@ -492,6 +590,7 @@ function retrack(effectFn, subscriber) {
   }
   currentSubscriber = subscriber;
   const sub = subscriber;
+  if (sub._cap === void 0) sub._cap = currentDisposerCapture();
   const epoch = ++subscriberEpochCounter;
   sub._epoch = epoch;
   sub._structDirty = false;
@@ -683,7 +782,12 @@ function drainQueue() {
       quarantined.add(sub);
       continue;
     }
-    safeInvoke(sub);
+    const pushed = beginDisposerCapture(sub._cap ?? null);
+    try {
+      safeInvoke(sub);
+    } finally {
+      if (pushed) endDisposerCapture();
+    }
   }
 }
 function drainNotificationQueue() {
@@ -819,7 +923,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.5.0" : "dev";
+var _runtimeVersion = true ? "4.6.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -1200,72 +1304,6 @@ function uniqueId(suffix) {
   return suffix ? `${id}-${suffix}` : id;
 }
 
-// src/core/rendering/dispose.ts
-var elementDisposers = /* @__PURE__ */ new WeakMap();
-var MAX_DRAIN_TEARDOWNS = 1e4;
-function reportDrainRunaway(label, executed, remaining) {
-  if (typeof console === "undefined") return;
-  console.error(
-    `[SibuJS ${label}] runaway cleanup: stopped after running ${executed} teardowns with ${remaining} still queued. Cleanup production did not stabilize before the teardown safety ceiling was reached \u2014 the remaining work was NOT run.`,
-    { executed, remaining }
-  );
-}
-var activeBindingCount = 0;
-function dispose(node) {
-  const stack = [node];
-  const order = [];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    order.push(current);
-    const children = Array.from(current.childNodes);
-    for (let i = 0; i < children.length; i++) {
-      stack.push(children[i]);
-    }
-  }
-  for (let i = order.length - 1; i >= 0; i--) {
-    const current = order[i];
-    if (elementDisposers.has(current)) {
-      let executed = 0;
-      let runaway = false;
-      while (!runaway) {
-        const pending = elementDisposers.get(current);
-        if (!pending || pending.length === 0) break;
-        const snapshot = pending.slice();
-        elementDisposers.delete(current);
-        if (DEV) activeBindingCount -= snapshot.length;
-        for (let i2 = 0; i2 < snapshot.length; i2++) {
-          if (executed >= MAX_DRAIN_TEARDOWNS) {
-            const rest = snapshot.slice(i2);
-            const added = elementDisposers.get(current);
-            elementDisposers.set(current, added ? rest.concat(added) : rest);
-            if (DEV) activeBindingCount += rest.length;
-            reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
-            runaway = true;
-            break;
-          }
-          executed++;
-          try {
-            snapshot[i2]();
-          } catch (err) {
-            reportError(err, { phase: "cleanup", name: "disposer" });
-          }
-        }
-      }
-    }
-  }
-}
-function replaceChildrenSafely(parent, ...next) {
-  for (let i = 0; i < next.length; i++) {
-    const node = next[i];
-    node.parentNode?.removeChild(node);
-  }
-  const current = Array.from(parent.childNodes);
-  for (let i = 0; i < current.length; i++) {
-    dispose(current[i]);
-  }
-  parent.replaceChildren(...next);
-}
-
 // src/utils/sanitize.ts
 function stripControlChars(value) {
   return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
@@ -1366,11 +1404,16 @@ function getDOMPool() {
   return _defaultPool;
 }
 var preloadedResources = /* @__PURE__ */ new Set();
+function hintKey(rel, as, crossorigin, href) {
+  return `${rel}\0${as}\0${crossorigin}\0${href}`;
+}
 function preloadResource(url, type = "fetch") {
   const safe = sanitizeUrl(url);
   if (!safe) return;
-  if (preloadedResources.has(safe)) return;
-  preloadedResources.add(safe);
+  const as = type === "script" || type === "style" || type === "image" ? type : "fetch";
+  const key = hintKey("preload", as, as === "fetch" ? "anonymous" : "", safe);
+  if (preloadedResources.has(key)) return;
+  preloadedResources.add(key);
   const link = document.createElement("link");
   link.rel = "preload";
   link.href = safe;
@@ -1393,8 +1436,9 @@ function preloadResource(url, type = "fetch") {
 function prefetch(url) {
   const safe = sanitizeUrl(url);
   if (!safe) return;
-  if (preloadedResources.has(safe)) return;
-  preloadedResources.add(safe);
+  const key = hintKey("prefetch", "", "", safe);
+  if (preloadedResources.has(key)) return;
+  preloadedResources.add(key);
   const link = document.createElement("link");
   link.rel = "prefetch";
   link.href = safe;
@@ -1463,65 +1507,92 @@ function block(factory) {
 }
 
 // src/performance/normalize.ts
+function dict(source) {
+  const out = /* @__PURE__ */ Object.create(null);
+  if (source) {
+    for (const key of Object.keys(source)) defineOwn(out, key, source[key]);
+  }
+  return out;
+}
+function ownGet(obj, key) {
+  return obj !== void 0 && Object.hasOwn(obj, key) ? obj[key] : void 0;
+}
+function defineOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function readEntityId(entity, idKey, typeName) {
+  const raw = entity !== null && typeof entity === "object" && Object.hasOwn(entity, idKey) ? entity[idKey] : void 0;
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+  throw new TypeError(
+    `[normalize] "${typeName}" entity has no valid "${idKey}" (expected a string or finite number, got ${raw === null ? "null" : typeof raw})`
+  );
+}
 function normalizedStore(schema) {
   const idKey = schema.idKey || "id";
   const [getState, setState] = signal({
     ids: [],
-    entities: {}
+    entities: dict()
   });
-  const idOf = (entity) => String(entity[idKey]);
+  const idOf = (entity) => readEntityId(entity, idKey, schema.name);
   function add(entity) {
     const id = idOf(entity);
     setState((prev) => {
-      const ids = prev.ids.includes(id) ? prev.ids : [...prev.ids, id];
-      return {
-        ids,
-        entities: { ...prev.entities, [id]: entity }
-      };
+      const ids = Object.hasOwn(prev.entities, id) ? prev.ids : [...prev.ids, id];
+      const entities = dict(prev.entities);
+      defineOwn(entities, id, entity);
+      return { ids, entities };
     });
   }
   function addMany(entities) {
+    const ids = entities.map(idOf);
     setState((prev) => {
       const nextIds = [...prev.ids];
-      const nextEntities = { ...prev.entities };
-      for (const entity of entities) {
-        const id = idOf(entity);
-        if (!nextIds.includes(id)) {
+      const nextEntities = dict(prev.entities);
+      entities.forEach((entity, i) => {
+        const id = ids[i];
+        if (!Object.hasOwn(nextEntities, id)) {
           nextIds.push(id);
         }
-        nextEntities[id] = entity;
-      }
+        defineOwn(nextEntities, id, entity);
+      });
       return { ids: nextIds, entities: nextEntities };
     });
   }
   function get(id) {
-    const state2 = getState();
-    return state2.entities[id];
+    return ownGet(getState().entities, id);
   }
   function getAll() {
     const state2 = getState();
     return state2.ids.map((id) => state2.entities[id]);
   }
   function update(id, partial) {
-    setState((prev) => {
-      const existing = prev.entities[id];
-      if (!existing) return prev;
-      return {
-        ids: prev.ids,
-        entities: {
-          ...prev.entities,
-          [id]: { ...existing, ...partial }
-        }
-      };
+    const prev = getState();
+    if (!Object.hasOwn(prev.entities, id)) return;
+    if (partial !== null && typeof partial === "object" && Object.hasOwn(partial, idKey)) {
+      const nextId = readEntityId(partial, idKey, schema.name);
+      if (nextId !== id) {
+        throw new Error(
+          `[normalizedStore] update("${id}") cannot change "${idKey}" to "${nextId}"; remove and re-add the entity instead.`
+        );
+      }
+    }
+    setState((current) => {
+      const existing = ownGet(current.entities, id);
+      if (!existing) return current;
+      const entities = dict(current.entities);
+      defineOwn(entities, id, { ...existing, ...partial });
+      return { ids: current.ids, entities };
     });
   }
   function remove(id) {
     setState((prev) => {
-      if (!prev.entities[id]) return prev;
-      const { [id]: _, ...remainingEntities } = prev.entities;
+      if (!Object.hasOwn(prev.entities, id)) return prev;
+      const entities = dict(prev.entities);
+      delete entities[id];
       return {
         ids: prev.ids.filter((existingId) => existingId !== id),
-        entities: remainingEntities
+        entities
       };
     });
   }
@@ -1532,31 +1603,37 @@ function normalizedStore(schema) {
   return { add, addMany, get, getAll, update, remove, select, getState };
 }
 function normalize(data, schema) {
-  const entities = {};
+  const entities = dict();
   function ensureTable(name) {
-    if (!entities[name]) {
-      entities[name] = {};
+    let table = ownGet(entities, name);
+    if (!table) {
+      table = dict();
+      defineOwn(entities, name, table);
     }
-    return entities[name];
+    return table;
   }
   function normalizeEntity(entity, entitySchema) {
     const entityIdKey = entitySchema.idKey || "id";
-    const id = String(entity[entityIdKey]);
+    const id = readEntityId(entity, entityIdKey, entitySchema.name);
     const table = ensureTable(entitySchema.name);
     const flat = { ...entity };
     if (entitySchema.relations) {
       for (const [field, relationType] of Object.entries(entitySchema.relations)) {
-        const value = entity[field];
+        const value = Object.hasOwn(entity, field) ? entity[field] : void 0;
         if (value == null) continue;
         const relSchema = { name: relationType };
         if (Array.isArray(value)) {
-          flat[field] = value.map((item) => normalizeEntity(item, relSchema));
+          defineOwn(
+            flat,
+            field,
+            value.map((item) => normalizeEntity(item, relSchema))
+          );
         } else if (typeof value === "object") {
-          flat[field] = normalizeEntity(value, relSchema);
+          defineOwn(flat, field, normalizeEntity(value, relSchema));
         }
       }
     }
-    table[id] = flat;
+    defineOwn(table, id, flat);
     return id;
   }
   if (Array.isArray(data)) {
@@ -1567,20 +1644,24 @@ function normalize(data, schema) {
   return { result, entities };
 }
 function denormalize(id, entities, schema) {
-  const table = entities[schema.name];
+  const table = ownGet(entities, schema.name);
   if (!table) return void 0;
-  const entity = table[id];
+  const entity = ownGet(table, id);
   if (!entity) return void 0;
   const result = { ...entity };
   if (schema.relations) {
     for (const [field, relationType] of Object.entries(schema.relations)) {
-      const value = entity[field];
+      const value = ownGet(entity, field);
       if (value == null) continue;
       const relSchema = { name: relationType };
       if (Array.isArray(value)) {
-        result[field] = value.map((relId) => denormalize(relId, entities, relSchema));
+        defineOwn(
+          result,
+          field,
+          value.map((relId) => denormalize(relId, entities, relSchema))
+        );
       } else if (typeof value === "string") {
-        result[field] = denormalize(value, entities, relSchema);
+        defineOwn(result, field, denormalize(value, entities, relSchema));
       }
     }
   }
@@ -1790,13 +1871,24 @@ function lazyChunk(id, loader, registry, fallback) {
     if (fallback) {
       container.appendChild(fallback());
     }
+    let disposed = false;
+    registerDisposer(container, () => {
+      disposed = true;
+    });
     registry.load(id, async () => {
       const mod = await loader();
       return typeof mod === "function" ? mod : mod.default;
     }).then((component) => {
+      if (disposed) return;
+      const node = component();
+      if (disposed) {
+        dispose(node);
+        return;
+      }
       clearChildren(container);
-      container.appendChild(component());
+      container.appendChild(node);
     }).catch((err) => {
+      if (disposed) return;
       clearChildren(container);
       const errorEl = document.createElement("div");
       errorEl.textContent = `Failed to load chunk '${id}': ${err.message}`;