kerfjs 2.0.0 → 3.0.0-beta.1

package/dist/dev.js

@@ -0,0 +1,607 @@
+import { truncateRowHtml } from './chunk-YHH7OUFA.js';
+import { LIST_MARKER_PREFIX } from './chunk-GY4XV2UV.js';
+import { installDevHooks } from './chunk-VVDJLWMP.js';
+export { clearDevHooks, devHooks, installDevHooks } from './chunk-VVDJLWMP.js';
+import { signal, Signal } from '@preact/signals-core';
+
+// src/dev-warn-config.ts
+var ENV_NAME = {
+  rebuiltListeners: "KERF_DEV_WARN_REBUILT_LISTENERS",
+  untrackedSignals: "KERF_DEV_WARN_UNTRACKED_SIGNALS",
+  narrowSet: "KERF_DEV_WARN_NARROW_SET",
+  delegateInEffect: "KERF_DEV_WARN_DELEGATE_IN_EFFECT",
+  eachInMorphSkip: "KERF_DEV_WARN_EACH_IN_MORPH_SKIP",
+  duplicateEachKeys: "KERF_DEV_WARN_DUPLICATE_EACH_KEYS",
+  staleBinding: "KERF_DEV_WARN_STALE_BINDING",
+  valueOnlyRerender: "KERF_DEV_WARN_VALUE_ONLY_RERENDER",
+  listRebind: "KERF_DEV_WARN_LIST_REBIND",
+  staleIndex: "KERF_DEV_WARN_STALE_INDEX",
+  parserRepair: "KERF_DEV_WARN_PARSER_REPAIR",
+  invariants: "KERF_DEV_INVARIANTS"
+};
+var overrides = /* @__PURE__ */ new Map();
+function applyWarningOptions(options) {
+  for (const [key, value] of Object.entries(options)) {
+    const envName = ENV_NAME[key];
+    if (envName === void 0 || value === void 0) continue;
+    overrides.set(envName, value === false ? false : value === true ? "1" : value);
+  }
+}
+function devFlag(envName) {
+  const override = overrides.get(envName);
+  if (override !== void 0) return override === false ? void 0 : override;
+  const proc = globalThis.process;
+  return proc?.env?.[envName];
+}
+
+// src/dev-binding-warn.ts
+var warnedHoles = /* @__PURE__ */ new Set();
+function isOptedIn() {
+  return devFlag("KERF_DEV_WARN_STALE_BINDING") === "1";
+}
+function describeHole(b) {
+  return b.kind === "attr" ? `attr '${b.attr}' (id '${b.id}')` : `text (id '${b.id}')`;
+}
+function maybeWarnStaleBinding(prevWired, current) {
+  if (!isOptedIn()) return;
+  const n = Math.min(prevWired.length, current.length);
+  for (let i = 0; i < n; i++) {
+    const cur = current[i];
+    if (prevWired[i].signal === cur.signal) continue;
+    if (warnedHoles.has(cur.id)) continue;
+    warnedHoles.add(cur.id);
+    console.warn(
+      `kerf: fine-grained binding ${describeHole(cur)} switched to a different signal instance on a render whose static-surrounds HTML was byte-for-byte unchanged. On that fast path kerf keeps the original binding effect and does NOT re-bind, so this hole is now stale \u2014 it still tracks the FIRST signal instance and will not reflect the new one. Bind one computed that switches internally (e.g. class={computed(() => cond.value ? sigA.value : sigB.value)}) instead of switching which signal instance you bind (see docs/2-reactivity \xA72.9). Set KERF_DEV_WARN_STALE_BINDING=0 (or unset it) to silence this warning.`
+    );
+  }
+}
+
+// src/dev-delegate-warn.ts
+var depth = 0;
+var warned = false;
+function isOptedIn2() {
+  return devFlag("KERF_DEV_WARN_DELEGATE_IN_EFFECT") === "1";
+}
+function enterEffect() {
+  depth++;
+}
+function exitEffect() {
+  depth--;
+}
+function isDevWarnDelegateInEffectEnabled() {
+  return isOptedIn2();
+}
+function warnIfInsideEffect(fn) {
+  if (!isOptedIn2()) return;
+  if (depth === 0) return;
+  if (warned) return;
+  warned = true;
+  console.warn(
+    `kerf: ${fn}() was called inside an effect() body. Every effect re-run installs a fresh root listener; the effect disposer cleans up the reactive subscription but not the listeners, so listener count grows linearly with signal churn and each listener pins its handler closure. Register the delegate once at module or setup scope and gate behavior on the signal *inside the handler* where the read is free. See docs/5-event-delegation.md \xA75.3 "When capturing the disposer still isn't enough". Set KERF_DEV_WARN_DELEGATE_IN_EFFECT=0 (or unset it) to silence this warning.`
+  );
+}
+
+// src/dev-each-warn.ts
+var warnedIds = /* @__PURE__ */ new Set();
+function isOptedIn3() {
+  return devFlag("KERF_DEV_WARN_EACH_IN_MORPH_SKIP") === "1";
+}
+function hasMorphSkipAncestor(el, root) {
+  let ancestor = el.parentElement;
+  while (ancestor !== null && ancestor !== root) {
+    if (ancestor.dataset.morphSkip !== void 0) return true;
+    ancestor = ancestor.parentElement;
+  }
+  return false;
+}
+function maybeWarnEachInMorphSkip(id, liveParent, rootEl) {
+  if (!isOptedIn3()) return;
+  if (warnedIds.has(id)) return;
+  if (!hasMorphSkipAncestor(liveParent, rootEl)) return;
+  warnedIds.add(id);
+  console.warn(
+    `kerf: each() list '${id}' is inside a data-morph-skip subtree. The keyed reconciler still updates the list rows, but any static signal-reactive JSX inside the same skipped ancestor (e.g. <p>{count.value}</p>) is frozen \u2014 the morph never visits it. Remove data-morph-skip from any element that contains reactive JSX content and reserve it for truly library-owned hosts. Set KERF_DEV_WARN_EACH_IN_MORPH_SKIP=0 (or unset it) to silence this warning.`
+  );
+}
+var warnedDupIds = /* @__PURE__ */ new Set();
+function isOptedInDupKeys() {
+  return devFlag("KERF_DEV_WARN_DUPLICATE_EACH_KEYS") === "1";
+}
+function maybeWarnDuplicateCacheKeys(id, segItems) {
+  if (!isOptedInDupKeys()) return;
+  if (warnedDupIds.has(id)) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const si of segItems) {
+    if (seen.has(si.cacheKey)) {
+      warnedDupIds.add(id);
+      console.warn(
+        `kerf: each() list '${id}' has duplicate cacheKey values (duplicate: ${String(si.cacheKey)}). The cacheKey function should return a unique value per row so kerf can tell apart items for memoization \u2014 duplicate values cause some rows to return stale cached HTML when external state that affects their render changes. Set KERF_DEV_WARN_DUPLICATE_EACH_KEYS=0 (or unset it) to silence this warning.`
+      );
+      return;
+    }
+    seen.add(si.cacheKey);
+  }
+}
+
+// src/dev-invariants.ts
+function mode() {
+  const value = devFlag("KERF_DEV_INVARIANTS");
+  if (value === "throw") return "throw";
+  return value === "1" ? "warn" : "off";
+}
+function listInvariantsEnabled() {
+  return mode() !== "off";
+}
+function childIndexer() {
+  const cache = /* @__PURE__ */ new Map();
+  return (parent, node) => {
+    let index = cache.get(parent);
+    if (index === void 0) {
+      index = /* @__PURE__ */ new Map();
+      const kids = parent.childNodes;
+      for (let i = 0; i < kids.length; i++) index.set(kids[i], i);
+      cache.set(parent, index);
+    }
+    return index.get(node) ?? -1;
+  };
+}
+function describe(id, problem) {
+  return `kerf invariant violated after reconcile \u2014 each() list '${id}': ${problem}`;
+}
+function findListInvariantViolations(rootEl, bindings, expectedCounts) {
+  const problems = [];
+  const owners = /* @__PURE__ */ new Map();
+  const indexIn = childIndexer();
+  const spans = [];
+  for (const [id, binding] of bindings) {
+    const { marker, liveParent, items } = binding;
+    const expected = expectedCounts?.get(id);
+    if (expected !== void 0 && items.length !== expected) {
+      problems.push(describe(id, `holds ${items.length} row(s) but its source has ${expected} \u2014 the reconcile dropped or duplicated rows`));
+    }
+    if (!rootEl.contains(marker)) {
+      problems.push(describe(id, "its marker comment is no longer inside the mount root, so every future reconcile would mutate a detached tree"));
+      continue;
+    }
+    if (marker.data !== `${LIST_MARKER_PREFIX}${id}`) {
+      problems.push(describe(id, `its marker reads '${marker.data}' \u2014 the id is carried by a different marker node, so this binding describes another list`));
+    }
+    const markerIndex = indexIn(liveParent, marker);
+    if (markerIndex === -1) {
+      problems.push(describe(id, "its marker is not a child of the parent the binding records"));
+      continue;
+    }
+    let previousIndex = markerIndex;
+    let first = -1;
+    for (let i = 0; i < items.length; i++) {
+      const node = items[i].node;
+      const index = indexIn(liveParent, node);
+      if (index === -1) {
+        problems.push(describe(id, `bound row ${i} is not a child of the list's parent (<${liveParent.tagName.toLowerCase()}>)${node.isConnected ? " \u2014 it is attached elsewhere in the document" : " \u2014 it is detached"}`));
+        continue;
+      }
+      if (index <= previousIndex) {
+        problems.push(describe(id, `bound row ${i} appears at child position ${index}, which is not after the previous one (${previousIndex}) \u2014 the rows are out of order or have crossed the marker`));
+      }
+      previousIndex = index;
+      if (first === -1) first = index;
+      const owner = owners.get(node);
+      if (owner !== void 0) {
+        problems.push(describe(id, `bound row ${i} is also claimed by list '${owner}'`));
+      } else {
+        owners.set(node, id);
+      }
+    }
+    if (first !== -1) spans.push({ id, parent: liveParent, from: first, to: previousIndex });
+  }
+  for (let a = 0; a < spans.length; a++) {
+    for (let b = a + 1; b < spans.length; b++) {
+      if (spans[a].parent !== spans[b].parent) continue;
+      if (spans[a].from <= spans[b].to && spans[b].from <= spans[a].to) {
+        problems.push(describe(spans[a].id, `its rows (child positions ${spans[a].from}-${spans[a].to}) overlap those of list '${spans[b].id}' (${spans[b].from}-${spans[b].to}) in the same parent`));
+      }
+    }
+  }
+  return problems;
+}
+function maybeCheckListInvariants(rootEl, bindings, expectedCounts) {
+  const level = mode();
+  if (level === "off") return;
+  const problems = findListInvariantViolations(rootEl, bindings, expectedCounts);
+  if (problems.length === 0) return;
+  const report = `${problems.join("\n")}
+This is a kerf bug, not an application one \u2014 please report it with the markup that produced it. Set KERF_DEV_INVARIANTS=1 to warn instead of throw, or unset it to disable these checks.`;
+  if (level === "throw") throw new Error(report);
+  console.warn(report);
+}
+
+// src/dev-list-index-warn.ts
+var warnedIds2 = /* @__PURE__ */ new Set();
+function isOptedInStaleIndex() {
+  return devFlag("KERF_DEV_WARN_STALE_INDEX") === "1";
+}
+function maybeWarnStaleIndex(id) {
+  if (warnedIds2.has(id)) return;
+  warnedIds2.add(id);
+  console.warn(
+    `kerf: each() list '${id}' reused a memoized row at a new index this render, but its render function takes an \`index\` argument. Rows are memoized by object identity, not by position, so a reorder or an insert/remove ahead of a surviving row serves that row's cached HTML \u2014 computed at its OLD index. A numbered list, zebra striping, or an "N of M" label will silently show the wrong value. If the row output depends on the index, fold it into the memo key: each(items, render, { cacheKey: (_, i) => i }) (combine with your own key if you have one). If the index is not used in the output, ignore this. Set KERF_DEV_WARN_STALE_INDEX=0 (or unset it) to silence this warning.`
+  );
+}
+
+// src/dev-list-key-warn.ts
+function maybeWarnListIdShift(id) {
+  console.warn(
+    `kerf each(): list '${id}' is now a different list than it was last render. Lists without a key are identified by call order, so adding or removing an each() call before this one reassigns its identity \u2014 kerf rebuilds the list from scratch and its rows lose DOM identity, focus, scroll position and in-progress IME composition. Give the affected lists a stable key: each(items, render, { key: 'my-list' }). Keying the conditional list is usually enough \u2014 a keyed list does not take a call-order slot, so its siblings stop shifting too.`
+  );
+}
+
+// src/dev-list-rebind-warn.ts
+var warnedIds3 = /* @__PURE__ */ new Set();
+function isOptedIn4() {
+  return devFlag("KERF_DEV_WARN_LIST_REBIND") === "1";
+}
+function maybeWarnListRebind(id, liveParent) {
+  if (!isOptedIn4()) return;
+  if (warnedIds3.has(id)) return;
+  warnedIds3.add(id);
+  console.warn(
+    `kerf: each() list '${id}' had its container (<${liveParent.tagName.toLowerCase()}>) rebuilt by the morph this render \u2014 an ancestor's tag changed so the subtree was replaced, or a same-tag sibling positionally took the container's place. The list re-binds and repopulates automatically, but its rows were re-created from scratch: focus, scroll positions, in-progress IME composition, and any imperative listeners on the old row nodes are lost. If the rows should survive, give the LIST'S OWN container a stable id/data-key (keying the conditional sibling instead only helps when it is removed, not when it reappears) and keep the tags of the list's ancestors stable across renders. Set KERF_DEV_WARN_LIST_REBIND=0 (or unset it) to silence this warning.`
+  );
+}
+
+// src/dev-listener-warn.ts
+var LISTENER_MARKER = /* @__PURE__ */ Symbol.for("kerfjs.devListener");
+var patched = false;
+var warned2 = false;
+function isOptedIn5() {
+  return devFlag("KERF_DEV_WARN_REBUILT_LISTENERS") === "1";
+}
+function findAddEventListenerProto() {
+  const probe = document.createElement("div");
+  let proto = Object.getPrototypeOf(probe);
+  while (!Object.prototype.hasOwnProperty.call(proto, "addEventListener")) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return proto;
+}
+function patchAddEventListenerOnce() {
+  if (patched) return;
+  patched = true;
+  const proto = findAddEventListenerProto();
+  const orig = proto.addEventListener;
+  proto.addEventListener = function(type, listener, options) {
+    if (this instanceof Element) {
+      this[LISTENER_MARKER] = true;
+    }
+    return orig.call(this, type, listener, options);
+  };
+}
+function hasMarkedListener(el) {
+  if (el[LISTENER_MARKER] === true) return true;
+  const stack = [];
+  for (let i = 0; i < el.children.length; i++) stack.push(el.children[i]);
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    if (cur[LISTENER_MARKER] === true) return true;
+    for (let i = 0; i < cur.children.length; i++) stack.push(cur.children[i]);
+  }
+  return false;
+}
+function emitWarning() {
+  if (warned2) return;
+  warned2 = true;
+  console.warn(
+    "kerf: a node inside a mount()-managed tree was removed/rebuilt while carrying an imperative addEventListener listener. The listener is gone with the old node. Use `delegate(rootEl, 'click', '[data-action=\"...\"]', handler)` so the listener lives on a stable ancestor and survives re-renders, or wrap the host in `data-morph-skip` if the subtree is library-owned (Monaco, xterm, D3 charts). Set KERF_DEV_WARN_REBUILT_LISTENERS=0 (or unset it) to silence this warning."
+  );
+}
+function installListenerRebuildWarn(rootEl) {
+  if (!isOptedIn5()) return null;
+  patchAddEventListenerOnce();
+  const observer = new MutationObserver((mutations) => {
+    if (warned2) return;
+    for (const m of mutations) {
+      for (let i = 0; i < m.removedNodes.length; i++) {
+        const removed = m.removedNodes[i];
+        if (!(removed instanceof Element)) continue;
+        if (hasMarkedListener(removed)) {
+          emitWarning();
+          return;
+        }
+      }
+    }
+  });
+  observer.observe(rootEl, { childList: true, subtree: true });
+  return observer;
+}
+
+// src/dev-parser-repair-warn.ts
+var BLOCK_TAGS = [
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "details",
+  "div",
+  "dl",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "main",
+  "menu",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "ul"
+];
+var SCAN = new RegExp(`<(/?p|${BLOCK_TAGS.join("|")})[\\s/>]`, "gi");
+var warnedPairs = /* @__PURE__ */ new Set();
+function isOptedIn6() {
+  return devFlag("KERF_DEV_WARN_PARSER_REPAIR") === "1";
+}
+function findParagraphRepair(html) {
+  SCAN.lastIndex = 0;
+  let inParagraph = false;
+  for (let m = SCAN.exec(html); m !== null; m = SCAN.exec(html)) {
+    const tag = m[1].toLowerCase();
+    if (tag === "/p") {
+      inParagraph = false;
+      continue;
+    }
+    if (tag === "p") {
+      if (inParagraph) return "p";
+      inParagraph = true;
+      continue;
+    }
+    if (inParagraph) return tag;
+  }
+  return null;
+}
+function maybeWarnParserRepair(html) {
+  if (!isOptedIn6()) return;
+  const tag = findParagraphRepair(html);
+  if (tag === null) return;
+  const pair = `p>${tag}`;
+  if (warnedPairs.has(pair)) return;
+  warnedPairs.add(pair);
+  console.warn(
+    `kerf: a <${tag}> inside a <p> will not survive parsing. <p> may contain only phrasing content, so the HTML parser closes it before a block-level child \u2014 your <p> ends up EMPTY and the <${tag}> (plus everything after it) becomes its sibling instead of its child. kerf then reconciles that repaired tree correctly, so updates still work; what you lose is the structure you wrote, along with any CSS or querySelector that assumed it. Use a <div> (or a phrasing element like <span>) in place of the <p>, or move the block content outside it. Set KERF_DEV_WARN_PARSER_REPAIR=0 (or unset it) to silence this warning.`
+  );
+}
+
+// src/dev-rerender-warn.ts
+function isOptedIn7() {
+  return devFlag("KERF_DEV_WARN_VALUE_ONLY_RERENDER") === "1";
+}
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var COMMENT_NODE = 8;
+function _isValueOnlyDiff(a, b) {
+  const an = a.childNodes;
+  const bn = b.childNodes;
+  if (an.length !== bn.length) return false;
+  for (let i = 0; i < an.length; i++) {
+    const x = an[i];
+    const y = bn[i];
+    if (x.nodeType !== y.nodeType) return false;
+    if (x.nodeType === ELEMENT_NODE) {
+      if (x.tagName !== y.tagName) return false;
+      if (!_isValueOnlyDiff(x, y)) return false;
+    } else if (x.nodeType === COMMENT_NODE) {
+      if (x.data !== y.data) return false;
+    } else if (x.nodeType !== TEXT_NODE) {
+      return false;
+    }
+  }
+  return true;
+}
+function maybeWarnValueOnlyRerender(prevHtml, nextHtml, ctx) {
+  if (ctx.warned || !isOptedIn7()) return;
+  const a = document.createElement("template");
+  const b = document.createElement("template");
+  a.innerHTML = prevHtml;
+  b.innerHTML = nextHtml;
+  if (!_isValueOnlyDiff(a.content, b.content)) return;
+  ctx.warned = true;
+  console.warn(
+    "kerf: this re-render changed only text content and attribute values \u2014 no structural change \u2014 so every changed hole could be a fine-grained binding instead. Values bind, structure re-renders: pass the signal/computed itself ({count}, class={sig}) rather than reading .value in the hole, and each change updates just that node with no render re-run (a mount whose render reads no .value never re-renders at all). See docs/2-reactivity \xA72.9. Set KERF_DEV_WARN_VALUE_ONLY_RERENDER=0 (or unset it) to silence this warning."
+  );
+}
+
+// src/dev-row-key-warn.ts
+function maybeWarnMissingRowKey(rowEl, rowHtml, binding) {
+  if (binding.warnedMissingKey === true) return;
+  binding.warnedMissingKey = true;
+  if (rowEl.id !== "" || rowEl.hasAttribute("data-key")) return;
+  console.warn(
+    `kerf each(): the first row has no \`id\` or \`data-key\` attribute. Without one, rows match positionally \u2014 an insert/remove at the head shifts every row's identity, so focused inputs jump to the wrong row, mid-edit textareas swap content with their neighbor, and any per-row state silently follows the wrong item. Add \`data-key={item.id}\` (or set \`id\`) to the top-level element returned by the row render. Row HTML: ${JSON.stringify(truncateRowHtml(rowHtml))}`
+  );
+}
+var WARNING_MESSAGE = "kerf: signal was written but has no subscribers. Did you read `.value` outside of a render fn / effect()? Hoisted reads do not subscribe, so subsequent writes will not re-render. Move the read inside mount()'s render fn or effect() callback. Set KERF_DEV_WARN_UNTRACKED_SIGNALS=0 (or unset it) to silence this warning.";
+var DevSignal = class extends Signal {
+  __hasSubscriber = false;
+  __warned = false;
+  __constructed = false;
+  constructor(initial) {
+    super(initial, {
+      watched() {
+        this.__hasSubscriber = true;
+      }
+    });
+    this.__constructed = true;
+  }
+  get value() {
+    return super.value;
+  }
+  set value(v) {
+    super.value = v;
+    if (this.__constructed && !this.__hasSubscriber && !this.__warned) {
+      this.__warned = true;
+      console.warn(WARNING_MESSAGE);
+    }
+  }
+};
+function isDevWarnUntrackedEnabled() {
+  return devFlag("KERF_DEV_WARN_UNTRACKED_SIGNALS") === "1";
+}
+var coverageNoticeShown = false;
+function noteUntrackedCoverage() {
+  if (coverageNoticeShown) return;
+  coverageNoticeShown = true;
+  console.warn(
+    "kerf: KERF_DEV_WARN_UNTRACKED_SIGNALS only covers signals created AFTER kerfjs/dev is installed. Static imports are hoisted above `await import('kerfjs/dev')`, so module-scope signals in the modules you import are created first and this warning cannot see them \u2014 you may get no warnings even where the bug exists. To cover them, make `import 'kerfjs/dev'` the FIRST STATIC import of a dev-only entry file (static imports evaluate in order), then load the rest of your app. Set KERF_DEV_WARN_UNTRACKED_SIGNALS=0 (or unset it) to silence this warning."
+  );
+}
+
+// src/dev-store-warn.ts
+var WARNING_PREFIX = "kerf: defineStore.set() called with keys missing from the current state \u2014 ";
+var WARNING_SUFFIX = ". set() REPLACES state; the missing keys will be undefined after this call. Use `set({ ...get(), ...next })` to merge instead, or update each call site to pass the full state. Set KERF_DEV_WARN_NARROW_SET=0 (or unset it) to silence this warning.";
+function isOptedIn8() {
+  return devFlag("KERF_DEV_WARN_NARROW_SET") === "1";
+}
+function isPlainObjectState(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (Array.isArray(v)) return false;
+  return true;
+}
+function maybeWarnNarrowSet(prev, next, ctx) {
+  if (ctx.warned) return;
+  if (!isOptedIn8()) return;
+  if (!isPlainObjectState(prev) || !isPlainObjectState(next)) return;
+  const missing = [];
+  for (const k of Object.keys(prev)) {
+    if (!(k in next)) missing.push(k);
+  }
+  if (missing.length === 0) return;
+  ctx.warned = true;
+  const keysList = missing.map((k) => `\`${k}\``).join(", ");
+  console.warn(`${WARNING_PREFIX}${keysList}${WARNING_SUFFIX}`);
+}
+
+// src/utils/devReadonly.ts
+var RULE_MESSAGE = "kerf: store state is read-only \u2014 all writes must go through actions (build a new state object and pass it to `set()`). Mutating the object returned by `get()` is a Rule 8 violation and never notifies subscribers.";
+var proxyToRaw = /* @__PURE__ */ new WeakMap();
+var rawToProxy = /* @__PURE__ */ new WeakMap();
+function isWrappable(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (Array.isArray(v)) return true;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+var handler = {
+  get(target, prop, receiver) {
+    const value = Reflect.get(target, prop, receiver);
+    return isWrappable(value) ? devReadonlyProxy(value) : value;
+  },
+  set() {
+    throw new TypeError(RULE_MESSAGE);
+  },
+  deleteProperty() {
+    throw new TypeError(RULE_MESSAGE);
+  },
+  defineProperty() {
+    throw new TypeError(RULE_MESSAGE);
+  }
+};
+function devReadonlyProxy(obj) {
+  if (proxyToRaw.has(obj)) return obj;
+  const cached = rawToProxy.get(obj);
+  if (cached) return cached;
+  const p = new Proxy(obj, handler);
+  rawToProxy.set(obj, p);
+  proxyToRaw.set(p, obj);
+  return p;
+}
+function toRaw(value) {
+  return unwrap(value);
+}
+function unwrap(v) {
+  if (v === null || typeof v !== "object") return v;
+  const raw = proxyToRaw.get(v);
+  if (raw !== void 0) return raw;
+  if (!isWrappable(v)) return v;
+  if (Array.isArray(v)) {
+    let changed2 = false;
+    const out2 = v.map((item) => {
+      const u = unwrap(item);
+      if (u !== item) changed2 = true;
+      return u;
+    });
+    return changed2 ? out2 : v;
+  }
+  let changed = false;
+  const src = v;
+  const out = {};
+  for (const k of Object.keys(src)) {
+    const u = unwrap(src[k]);
+    if (u !== src[k]) changed = true;
+    out[k] = u;
+  }
+  return changed ? out : v;
+}
+
+// src/dev.ts
+function enableWarnings(options) {
+  applyWarningOptions(options);
+  if (isDevWarnUntrackedEnabled()) noteUntrackedCoverage();
+}
+var DEV_HOOKS = {
+  // --- reactive ---------------------------------------------------------
+  signalFactory: (value) => isDevWarnUntrackedEnabled() ? new DevSignal(value) : signal(value),
+  wrapEffect: (fn) => {
+    if (!isDevWarnDelegateInEffectEnabled()) return fn;
+    return () => {
+      enterEffect();
+      try {
+        return fn();
+      } finally {
+        exitEffect();
+      }
+    };
+  },
+  // --- delegate ---------------------------------------------------------
+  delegateInEffect: warnIfInsideEffect,
+  // --- store ------------------------------------------------------------
+  narrowSet: maybeWarnNarrowSet,
+  storeReadonly: devReadonlyProxy,
+  storeToRaw: toRaw,
+  // --- mount ------------------------------------------------------------
+  listenerRebuild: installListenerRebuildWarn,
+  listIdShift: maybeWarnListIdShift,
+  parserRepair: maybeWarnParserRepair,
+  staleBindingEnabled: isOptedIn,
+  staleBinding: maybeWarnStaleBinding,
+  listInvariantsEnabled,
+  listInvariants: maybeCheckListInvariants,
+  valueOnlyRerender: maybeWarnValueOnlyRerender,
+  listRebind: maybeWarnListRebind,
+  eachInMorphSkip: maybeWarnEachInMorphSkip,
+  missingRowKey: maybeWarnMissingRowKey,
+  // --- each -------------------------------------------------------------
+  staleIndexEnabled: isOptedInStaleIndex,
+  staleIndex: maybeWarnStaleIndex,
+  duplicateCacheKeys: maybeWarnDuplicateCacheKeys,
+  // --- urlScreen --------------------------------------------------------
+  urlScreenThrow: (message) => {
+    throw new Error(message);
+  }
+};
+installDevHooks(DEV_HOOKS);
+if (isDevWarnUntrackedEnabled()) noteUntrackedCoverage();
+
+export { DEV_HOOKS, enableWarnings };
+//# sourceMappingURL=dev.js.map
+//# sourceMappingURL=dev.js.map