bonemarrow 1.1.0

package/LICENSE

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

package/dist/bonemarrow.js

@@ -0,0 +1,1068 @@
+"use strict";
+var bone = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    Collection: () => Collection,
+    Elements: () => Elements,
+    Model: () => Model,
+    View: () => View,
+    createScope: () => createScope,
+    el: () => el,
+    fetchJson: () => fetchJson
+  });
+
+  // src/core/scope.ts
+  function createScopeInternal(parent) {
+    const controller = new AbortController();
+    const cleanups = [];
+    const children = /* @__PURE__ */ new Set();
+    let disposed = false;
+    const scope = {
+      signal: controller.signal,
+      onDispose(fn) {
+        if (disposed) {
+          try {
+            fn();
+          } catch (error) {
+            console.error("[Scope] Error in dispose callback:", error);
+          }
+          return;
+        }
+        cleanups.push(fn);
+      },
+      createChild() {
+        if (disposed) {
+          console.warn(
+            "[Scope] Attempted to create child from disposed scope"
+          );
+          const deadScope = createScopeInternal(null);
+          deadScope.dispose();
+          return deadScope;
+        }
+        const child = createScopeInternal(scope);
+        children.add(child);
+        child.onDispose(() => children.delete(child));
+        return child;
+      },
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        for (const child of children) {
+          child.dispose();
+        }
+        children.clear();
+        controller.abort();
+        for (let i = cleanups.length - 1; i >= 0; i--) {
+          try {
+            cleanups[i]();
+          } catch (error) {
+            console.error(
+              "[Scope] Error in cleanup function:",
+              error
+            );
+          }
+        }
+        cleanups.length = 0;
+        if (scope._inFlight) {
+          scope._inFlight.clear();
+          delete scope._inFlight;
+        }
+      }
+    };
+    parent == null ? void 0 : parent.onDispose(() => scope.dispose());
+    return scope;
+  }
+  var windowScope = null;
+  function getWindowScope() {
+    if (windowScope) return windowScope;
+    windowScope = createScopeInternal(null);
+    const disposeAll = () => {
+      if (!windowScope) return;
+      windowScope.dispose();
+      windowScope = null;
+    };
+    window.addEventListener("pagehide", disposeAll);
+    window.addEventListener("beforeunload", disposeAll);
+    return windowScope;
+  }
+  function createScope() {
+    return getWindowScope().createChild();
+  }
+
+  // src/core/fetch.ts
+  function requestKey(url, init) {
+    var _a;
+    return `${(_a = init == null ? void 0 : init.method) != null ? _a : "GET"}:${url}`;
+  }
+  async function fetchJson(url, options = {}) {
+    var _a;
+    const {
+      scope,
+      abort = false,
+      timeout,
+      retryOnFailure = 0,
+      retryDelay = 0,
+      dedupe = false,
+      init,
+      parse
+    } = options;
+    const internalScope = scope;
+    let inFlight;
+    let key;
+    if (dedupe && internalScope) {
+      inFlight = (_a = internalScope._inFlight) != null ? _a : internalScope._inFlight = /* @__PURE__ */ new Map();
+      key = requestKey(url, init);
+      const existing = inFlight.get(key);
+      if (existing) {
+        return existing;
+      }
+    }
+    const promise = (async () => {
+      let attempt = 0;
+      while (true) {
+        const controller = new AbortController();
+        if (abort && scope) {
+          scope.signal.addEventListener(
+            "abort",
+            () => controller.abort(),
+            { once: true }
+          );
+        }
+        let timeoutId;
+        if (typeof timeout === "number") {
+          timeoutId = setTimeout(
+            () => controller.abort(),
+            timeout
+          );
+        }
+        try {
+          const res = await fetch(url, {
+            ...init,
+            signal: controller.signal
+          });
+          if (!res.ok) {
+            throw new Error(
+              `HTTP ${res.status}: ${res.statusText}`
+            );
+          }
+          const json = await res.json();
+          return parse ? parse(json) : json;
+        } catch (err) {
+          attempt++;
+          if (err instanceof DOMException && err.name === "AbortError") {
+            throw err;
+          }
+          if (attempt > retryOnFailure) {
+            throw err;
+          }
+          if (retryDelay > 0) {
+            await new Promise(
+              (resolve) => setTimeout(resolve, retryDelay)
+            );
+          }
+        } finally {
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+        }
+      }
+    })();
+    if (inFlight && key && internalScope) {
+      inFlight.set(key, promise);
+      const cleanup = () => {
+        inFlight.delete(key);
+      };
+      promise.then(cleanup, cleanup);
+      internalScope.onDispose(cleanup);
+    }
+    return promise;
+  }
+
+  // src/core/emitter.ts
+  var Emitter = class {
+    constructor() {
+      this.events = /* @__PURE__ */ new Map();
+    }
+    on(event, fn, scope) {
+      let set = this.events.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.events.set(event, set);
+      }
+      set.add(fn);
+      let disposed = false;
+      const cleanup = () => {
+        if (disposed) return;
+        disposed = true;
+        set.delete(fn);
+        if (set.size === 0) {
+          this.events.delete(event);
+        }
+      };
+      scope == null ? void 0 : scope.onDispose(cleanup);
+      return cleanup;
+    }
+    once(event, fn, scope) {
+      const wrapper = (...args) => {
+        cleanup();
+        fn(...args);
+      };
+      const cleanup = this.on(event, wrapper, scope);
+      return cleanup;
+    }
+    emit(event, ...args) {
+      const handlers = this.events.get(event);
+      if (!handlers || handlers.size === 0) return;
+      const handlersArray = Array.from(handlers);
+      for (const fn of handlersArray) {
+        try {
+          fn(...args);
+        } catch (error) {
+          console.error(
+            `Error in event handler for "${event}":`,
+            error
+          );
+        }
+      }
+    }
+    off(event) {
+      this.events.delete(event);
+    }
+    clear() {
+      this.events.clear();
+    }
+    hasListeners(event) {
+      var _a, _b;
+      return ((_b = (_a = this.events.get(event)) == null ? void 0 : _a.size) != null ? _b : 0) > 0;
+    }
+    listenerCount(event) {
+      var _a, _b;
+      return (_b = (_a = this.events.get(event)) == null ? void 0 : _a.size) != null ? _b : 0;
+    }
+    eventNames() {
+      return Array.from(this.events.keys());
+    }
+  };
+
+  // src/refresh/sequentialRefresh.ts
+  function startSequentialRefresh(fn, opts) {
+    const {
+      interval,
+      scope,
+      immediate = true,
+      onError,
+      maxRetries = 0,
+      backoff = false
+    } = opts;
+    let stopped = false;
+    let timeoutId;
+    let consecutiveErrors = 0;
+    let isRunning = false;
+    const calculateDelay = () => {
+      if (!backoff || consecutiveErrors === 0) {
+        return interval;
+      }
+      const multiplier = Math.min(2 ** consecutiveErrors, 10);
+      return interval * multiplier;
+    };
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+    };
+    const loop = async () => {
+      if (stopped) return;
+      if (isRunning) {
+        console.warn(
+          "[SequentialRefresh] Previous execution still running"
+        );
+        return;
+      }
+      isRunning = true;
+      try {
+        await fn();
+        consecutiveErrors = 0;
+      } catch (error) {
+        consecutiveErrors++;
+        if (onError) {
+          try {
+            onError(error);
+          } catch (handlerError) {
+            console.error(
+              "[SequentialRefresh] Error in error handler:",
+              handlerError
+            );
+          }
+        } else {
+          console.error(
+            "[SequentialRefresh] Error in refresh function:",
+            error
+          );
+        }
+        if (maxRetries > 0 && consecutiveErrors >= maxRetries) {
+          console.error(
+            `[SequentialRefresh] Max retries (${maxRetries}) exceeded. Stopping refresh.`
+          );
+          stop();
+          return;
+        }
+      } finally {
+        isRunning = false;
+      }
+      if (!stopped) {
+        const delay = calculateDelay();
+        timeoutId = setTimeout(loop, delay);
+      }
+    };
+    if (immediate) {
+      loop();
+    } else {
+      timeoutId = setTimeout(loop, interval);
+    }
+    scope.onDispose(stop);
+    return stop;
+  }
+
+  // src/data/model.ts
+  var Model = class {
+    constructor(initial) {
+      this.emitter = new Emitter();
+      this.destroyed = false;
+      this.initial = { ...initial };
+      this.data = { ...initial };
+    }
+    get(key) {
+      this.checkDestroyed();
+      return this.data[key];
+    }
+    getAll() {
+      this.checkDestroyed();
+      return { ...this.data };
+    }
+    set(patch) {
+      this.checkDestroyed();
+      const changes = {};
+      let hasChanges = false;
+      for (const key of Object.keys(patch)) {
+        if (patch[key] !== this.data[key]) {
+          changes[key] = patch[key];
+          hasChanges = true;
+        }
+      }
+      if (!hasChanges) {
+        return false;
+      }
+      Object.assign(this.data, changes);
+      this.emitter.emit("change", changes);
+      return true;
+    }
+    reset() {
+      this.checkDestroyed();
+      const resetData = { ...this.initial };
+      const hasChanges = Object.keys(resetData).some(
+        (key) => resetData[key] !== this.data[key]
+      );
+      if (hasChanges) {
+        this.data = resetData;
+        this.emitter.emit("change", resetData);
+      }
+    }
+    has(key, value) {
+      this.checkDestroyed();
+      return this.data[key] === value;
+    }
+    onChange(fn, scope) {
+      this.checkDestroyed();
+      return this.emitter.on("change", fn, scope);
+    }
+    async fetch(url, options) {
+      this.checkDestroyed();
+      const patch = await fetchJson(url, options);
+      this.set(patch);
+      return this.getAll();
+    }
+    autoRefresh(url, options) {
+      this.checkDestroyed();
+      return startSequentialRefresh(
+        () => this.fetch(url, {
+          ...options.fetch,
+          scope: options.scope
+        }),
+        options
+      );
+    }
+    destroy() {
+      if (this.destroyed) return;
+      this.destroyed = true;
+      this.emitter.clear();
+    }
+    isDestroyed() {
+      return this.destroyed;
+    }
+    checkDestroyed() {
+      if (this.destroyed) {
+        throw new Error("[Model] Cannot use destroyed model");
+      }
+    }
+  };
+
+  // src/data/collection.ts
+  var Collection = class {
+    constructor() {
+      this.items = [];
+      this.emitter = new Emitter();
+      this.destroyed = false;
+    }
+    getAll() {
+      this.checkDestroyed();
+      return [...this.items];
+    }
+    get length() {
+      this.checkDestroyed();
+      return this.items.length;
+    }
+    at(index) {
+      this.checkDestroyed();
+      return this.items[index];
+    }
+    add(...items) {
+      this.checkDestroyed();
+      this.items.push(...items);
+      this.emitter.emit("add", items);
+    }
+    remove(predicate) {
+      this.checkDestroyed();
+      const removed = [];
+      for (let i = this.items.length - 1; i >= 0; i--) {
+        if (predicate(this.items[i], i)) {
+          removed.unshift(this.items[i]);
+          this.items.splice(i, 1);
+        }
+      }
+      if (removed.length > 0) {
+        this.emitter.emit("remove", removed);
+      }
+      return removed;
+    }
+    removeAt(index) {
+      this.checkDestroyed();
+      if (index < 0 || index >= this.items.length) {
+        return void 0;
+      }
+      const [item] = this.items.splice(index, 1);
+      this.emitter.emit("remove", [item]);
+      return item;
+    }
+    find(predicate) {
+      this.checkDestroyed();
+      return this.items.find(predicate);
+    }
+    findIndex(predicate) {
+      this.checkDestroyed();
+      return this.items.findIndex(predicate);
+    }
+    filter(predicate) {
+      this.checkDestroyed();
+      return this.items.filter(predicate);
+    }
+    map(fn) {
+      this.checkDestroyed();
+      return this.items.map(fn);
+    }
+    forEach(fn) {
+      this.checkDestroyed();
+      this.items.forEach(fn);
+    }
+    some(predicate) {
+      this.checkDestroyed();
+      return this.items.some(predicate);
+    }
+    every(predicate) {
+      this.checkDestroyed();
+      return this.items.every(predicate);
+    }
+    sort(compareFn) {
+      this.checkDestroyed();
+      this.items.sort(compareFn);
+      this.emitter.emit("sort");
+    }
+    reset(items) {
+      this.checkDestroyed();
+      this.items = [...items];
+      this.emitter.emit("reset", this.items);
+    }
+    clear() {
+      this.checkDestroyed();
+      if (this.items.length > 0) {
+        this.items = [];
+        this.emitter.emit("reset", []);
+      }
+    }
+    async fetch(url, options) {
+      this.checkDestroyed();
+      const items = await fetchJson(url, options);
+      this.reset(items);
+      return this.getAll();
+    }
+    onAdd(fn, scope) {
+      this.checkDestroyed();
+      return this.emitter.on("add", fn, scope);
+    }
+    onRemove(fn, scope) {
+      this.checkDestroyed();
+      return this.emitter.on("remove", fn, scope);
+    }
+    onReset(fn, scope) {
+      this.checkDestroyed();
+      return this.emitter.on("reset", fn, scope);
+    }
+    onSort(fn, scope) {
+      this.checkDestroyed();
+      return this.emitter.on("sort", fn, scope);
+    }
+    onChange(fn, scope) {
+      this.checkDestroyed();
+      const c1 = this.onAdd(fn, scope);
+      const c2 = this.onRemove(fn, scope);
+      const c3 = this.onReset(fn, scope);
+      const c4 = this.onSort(fn, scope);
+      return () => {
+        c1();
+        c2();
+        c3();
+        c4();
+      };
+    }
+    autoRefresh(url, opts) {
+      this.checkDestroyed();
+      return startSequentialRefresh(
+        () => this.fetch(url, {
+          ...opts.fetch,
+          scope: opts.scope
+        }),
+        opts
+      );
+    }
+    destroy() {
+      if (this.destroyed) return;
+      this.destroyed = true;
+      this.items = [];
+      this.emitter.clear();
+    }
+    isDestroyed() {
+      return this.destroyed;
+    }
+    checkDestroyed() {
+      if (this.destroyed) {
+        throw new Error(
+          "[Collection] Cannot use destroyed collection"
+        );
+      }
+    }
+  };
+
+  // src/dom/elements.ts
+  var Elements = class _Elements {
+    constructor(nodes) {
+      this.nodes = nodes;
+    }
+    get length() {
+      return this.nodes.length;
+    }
+    each(fn) {
+      this.nodes.forEach(fn);
+      return this;
+    }
+    get(index = 0) {
+      var _a;
+      return (_a = this.nodes[index]) != null ? _a : null;
+    }
+    first() {
+      var _a;
+      return (_a = this.nodes[0]) != null ? _a : null;
+    }
+    last() {
+      var _a;
+      return (_a = this.nodes[this.nodes.length - 1]) != null ? _a : null;
+    }
+    find(selector) {
+      const out = [];
+      this.each((el2) => {
+        out.push(...Array.from(el2.querySelectorAll(selector)));
+      });
+      return new _Elements(out);
+    }
+    filter(predicate) {
+      if (typeof predicate === "string") {
+        return new _Elements(
+          this.nodes.filter((el2) => el2.matches(predicate))
+        );
+      }
+      return new _Elements(this.nodes.filter(predicate));
+    }
+    parent() {
+      const parents = [];
+      this.each((el2) => {
+        if (el2.parentElement) {
+          parents.push(el2.parentElement);
+        }
+      });
+      return new _Elements(parents);
+    }
+    closest(selector) {
+      const matches = [];
+      this.each((el2) => {
+        const match = el2.closest(selector);
+        if (match) {
+          matches.push(match);
+        }
+      });
+      return new _Elements(matches);
+    }
+    children() {
+      const children = [];
+      this.each((el2) => {
+        children.push(...Array.from(el2.children));
+      });
+      return new _Elements(children);
+    }
+    text(value) {
+      var _a, _b;
+      if (value === void 0) {
+        return (_b = (_a = this.get()) == null ? void 0 : _a.textContent) != null ? _b : "";
+      }
+      return this.each((el2) => {
+        el2.textContent = value;
+      });
+    }
+    html(value) {
+      var _a, _b;
+      if (value === void 0) {
+        return (_b = (_a = this.get()) == null ? void 0 : _a.innerHTML) != null ? _b : "";
+      }
+      return this.each((el2) => {
+        el2.innerHTML = value;
+      });
+    }
+    attr(name, value) {
+      var _a, _b;
+      if (value === void 0) {
+        return (_b = (_a = this.get()) == null ? void 0 : _a.getAttribute(name)) != null ? _b : "";
+      }
+      return this.each((el2) => {
+        el2.setAttribute(name, value);
+      });
+    }
+    removeAttr(name) {
+      return this.each((el2) => {
+        el2.removeAttribute(name);
+      });
+    }
+    data(key, value) {
+      var _a;
+      if (value === void 0) {
+        const el2 = this.get();
+        return el2 instanceof HTMLElement ? (_a = el2.dataset[key]) != null ? _a : "" : "";
+      }
+      return this.each((el2) => {
+        if (el2 instanceof HTMLElement) {
+          el2.dataset[key] = value;
+        }
+      });
+    }
+    val(value) {
+      if (value === void 0) {
+        const el2 = this.get();
+        if (el2 instanceof HTMLInputElement || el2 instanceof HTMLTextAreaElement || el2 instanceof HTMLSelectElement) {
+          return el2.value;
+        }
+        return "";
+      }
+      return this.each((el2) => {
+        if (el2 instanceof HTMLInputElement || el2 instanceof HTMLTextAreaElement || el2 instanceof HTMLSelectElement) {
+          el2.value = value;
+        }
+      });
+    }
+    on(event, handler, scope) {
+      return this.each((el2) => {
+        el2.addEventListener(event, handler);
+        scope == null ? void 0 : scope.onDispose(() => {
+          el2.removeEventListener(event, handler);
+        });
+      });
+    }
+    once(event, handler) {
+      return this.each((el2) => {
+        el2.addEventListener(event, handler, { once: true });
+      });
+    }
+    off(event, handler) {
+      return this.each((el2) => {
+        el2.removeEventListener(event, handler);
+      });
+    }
+    trigger(event, detail) {
+      return this.each((el2) => {
+        el2.dispatchEvent(
+          new CustomEvent(event, { detail })
+        );
+      });
+    }
+    addClass(classes) {
+      const classList = classes.split(" ").filter(Boolean);
+      return this.each((el2) => {
+        el2.classList.add(...classList);
+      });
+    }
+    removeClass(classes) {
+      const classList = classes.split(" ").filter(Boolean);
+      return this.each((el2) => {
+        el2.classList.remove(...classList);
+      });
+    }
+    toggleClass(classes, force) {
+      const classList = classes.split(" ").filter(Boolean);
+      return this.each((el2) => {
+        classList.forEach((cls) => {
+          el2.classList.toggle(cls, force);
+        });
+      });
+    }
+    hasClass(className) {
+      return this.nodes.some(
+        (el2) => el2.classList.contains(className)
+      );
+    }
+    css(property, value) {
+      if (typeof property === "string" && value === void 0) {
+        const el2 = this.get();
+        return el2 instanceof HTMLElement ? getComputedStyle(el2).getPropertyValue(property) : "";
+      }
+      if (typeof property === "string") {
+        return this.each((el2) => {
+          if (el2 instanceof HTMLElement) {
+            el2.style.setProperty(property, value);
+          }
+        });
+      }
+      return this.each((el2) => {
+        if (el2 instanceof HTMLElement) {
+          Object.entries(property).forEach(
+            ([key, val]) => {
+              el2.style.setProperty(key, val);
+            }
+          );
+        }
+      });
+    }
+    show() {
+      return this.each((el2) => {
+        if (el2 instanceof HTMLElement) {
+          el2.style.display = "";
+        }
+      });
+    }
+    hide() {
+      return this.each((el2) => {
+        if (el2 instanceof HTMLElement) {
+          el2.style.display = "none";
+        }
+      });
+    }
+    toggle(show) {
+      return this.each((el2) => {
+        if (el2 instanceof HTMLElement) {
+          const shouldShow = show != null ? show : el2.style.display === "none";
+          el2.style.display = shouldShow ? "" : "none";
+        }
+      });
+    }
+    isVisible() {
+      return this.nodes.some((el2) => {
+        if (el2 instanceof HTMLElement) {
+          return el2.style.display !== "none" && el2.offsetParent !== null;
+        }
+        return false;
+      });
+    }
+    append(content) {
+      return this.each((el2) => {
+        if (typeof content === "string") {
+          el2.insertAdjacentHTML("beforeend", content);
+        } else if (content instanceof _Elements) {
+          content.each(
+            (child) => el2.appendChild(child.cloneNode(true))
+          );
+        } else {
+          el2.appendChild(content);
+        }
+      });
+    }
+    prepend(content) {
+      return this.each((el2) => {
+        if (typeof content === "string") {
+          el2.insertAdjacentHTML("afterbegin", content);
+        } else if (content instanceof _Elements) {
+          const first = el2.firstChild;
+          content.each((child) => {
+            el2.insertBefore(
+              child.cloneNode(true),
+              first
+            );
+          });
+        } else {
+          el2.insertBefore(content, el2.firstChild);
+        }
+      });
+    }
+    remove() {
+      return this.each((el2) => {
+        el2.remove();
+      });
+    }
+    empty() {
+      return this.each((el2) => {
+        el2.innerHTML = "";
+      });
+    }
+    clone(deep = true) {
+      return new _Elements(
+        this.nodes.map(
+          (el2) => el2.cloneNode(deep)
+        )
+      );
+    }
+    focus() {
+      const el2 = this.get();
+      if (el2 instanceof HTMLElement) {
+        el2.focus();
+      }
+      return this;
+    }
+    blur() {
+      const el2 = this.get();
+      if (el2 instanceof HTMLElement) {
+        el2.blur();
+      }
+      return this;
+    }
+  };
+
+  // src/dom/el.ts
+  function el(input, root) {
+    if (typeof input === "string") {
+      const selector = input.trim();
+      if (!selector) {
+        return new Elements([]);
+      }
+      try {
+        return new Elements(
+          Array.from(
+            (root != null ? root : document).querySelectorAll(selector)
+          )
+        );
+      } catch (error) {
+        console.error(
+          `[el] Invalid selector: "${selector}"`,
+          error
+        );
+        return new Elements([]);
+      }
+    }
+    if (input instanceof Element) {
+      return new Elements([input]);
+    }
+    if (input instanceof NodeList) {
+      return new Elements(
+        Array.from(input)
+      );
+    }
+    if (input instanceof HTMLCollection) {
+      return new Elements(Array.from(input));
+    }
+    if (Array.isArray(input)) {
+      const elements = input.filter(
+        (item) => item instanceof Element
+      );
+      if (elements.length !== input.length) {
+        console.warn(
+          "[el] Some items in array were not Elements and were filtered out"
+        );
+      }
+      return new Elements(elements);
+    }
+    console.warn(
+      "[el] Unrecognized input type:",
+      typeof input
+    );
+    return new Elements([]);
+  }
+
+  // src/view/view.ts
+  var View = class {
+    constructor(root, model, options = {}) {
+      this.root = root;
+      this.model = model;
+      this.destroyed = false;
+      this.children = /* @__PURE__ */ new Set();
+      this.options = {
+        autoDestroy: true,
+        ...options
+      };
+      this.scope = options.parentScope ? options.parentScope.createChild() : createScope();
+      if (this.options.autoDestroy) {
+        this.setupAutoDestroy();
+      }
+      this.init();
+    }
+    init() {
+    }
+    $(selector) {
+      return el(selector, this.root);
+    }
+    $root() {
+      return el(this.root);
+    }
+    createChild(ViewClass, root, model) {
+      this.checkDestroyed();
+      const child = new ViewClass(root, model, {
+        parentScope: this.scope,
+        autoDestroy: false
+      });
+      this.children.add(child);
+      child.scope.onDispose(() => {
+        this.children.delete(child);
+      });
+      return child;
+    }
+    createChildren(ViewClass, selector, modelFn) {
+      this.checkDestroyed();
+      const views = [];
+      this.$(selector).each((element, index) => {
+        const model = modelFn ? modelFn(element, index) : void 0;
+        views.push(this.createChild(ViewClass, element, model));
+      });
+      return views;
+    }
+    emit(event, detail) {
+      this.checkDestroyed();
+      this.$root().trigger(event, detail);
+    }
+    on(event, handler) {
+      this.checkDestroyed();
+      this.$root().on(event, handler, this.scope);
+    }
+    show() {
+      this.checkDestroyed();
+      this.$root().show();
+    }
+    hide() {
+      this.checkDestroyed();
+      this.$root().hide();
+    }
+    toggle(force) {
+      this.checkDestroyed();
+      this.$root().toggle(force);
+    }
+    isVisible() {
+      return this.$root().isVisible();
+    }
+    isDestroyed() {
+      return this.destroyed;
+    }
+    getRoot() {
+      return this.root;
+    }
+    getModel() {
+      return this.model;
+    }
+    destroy() {
+      if (this.destroyed) return;
+      this.destroyed = true;
+      for (const child of this.children) {
+        try {
+          child.destroy();
+        } catch (error) {
+          console.error(
+            "[View] Error destroying child view:",
+            error
+          );
+        }
+      }
+      this.children.clear();
+      try {
+        this.scope.dispose();
+      } catch (error) {
+        console.error(
+          "[View] Error disposing scope:",
+          error
+        );
+      }
+      if (this.model && typeof this.model.destroy === "function") {
+        try {
+          this.model.destroy();
+        } catch (error) {
+          console.error(
+            "[View] Error destroying model:",
+            error
+          );
+        }
+      }
+    }
+    setupAutoDestroy() {
+      const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          for (const removed of Array.from(
+            mutation.removedNodes
+          )) {
+            if (removed === this.root || removed instanceof Element && removed.contains(this.root)) {
+              this.destroy();
+              observer.disconnect();
+              return;
+            }
+          }
+        }
+      });
+      if (this.root.parentElement) {
+        observer.observe(this.root.parentElement, {
+          childList: true,
+          subtree: true
+        });
+      }
+      this.scope.onDispose(() => {
+        observer.disconnect();
+      });
+    }
+    checkDestroyed() {
+      if (this.destroyed) {
+        throw new Error(
+          "[View] Cannot use destroyed view"
+        );
+      }
+    }
+  };
+  return __toCommonJS(index_exports);
+})();

package/dist/bonemarrow.min.js

@@ -0,0 +1 @@
+"use strict";var bone=(()=>{var F=Object.defineProperty;var V=Object.getOwnPropertyDescriptor;var R=Object.getOwnPropertyNames;var O=Object.prototype.hasOwnProperty;var H=(n,e)=>{for(var t in e)F(n,t,{get:e[t],enumerable:!0})},P=(n,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of R(e))!O.call(n,s)&&s!==t&&F(n,s,{get:()=>e[s],enumerable:!(r=V(e,s))||r.enumerable});return n};var $=n=>P(F({},"__esModule",{value:!0}),n);var q={};H(q,{Collection:()=>L,Elements:()=>a,Model:()=>x,View:()=>M,createScope:()=>S,el:()=>w,fetchJson:()=>E});function C(n){let e=new AbortController,t=[],r=new Set,s=!1,o={signal:e.signal,onDispose(i){if(s){try{i()}catch(l){console.error("[Scope] Error in dispose callback:",l)}return}t.push(i)},createChild(){if(s){console.warn("[Scope] Attempted to create child from disposed scope");let l=C(null);return l.dispose(),l}let i=C(o);return r.add(i),i.onDispose(()=>r.delete(i)),i},dispose(){if(!s){s=!0;for(let i of r)i.dispose();r.clear(),e.abort();for(let i=t.length-1;i>=0;i--)try{t[i]()}catch(l){console.error("[Scope] Error in cleanup function:",l)}t.length=0,o._inFlight&&(o._inFlight.clear(),delete o._inFlight)}}};return n==null||n.onDispose(()=>o.dispose()),o}var y=null;function K(){if(y)return y;y=C(null);let n=()=>{y&&(y.dispose(),y=null)};return window.addEventListener("pagehide",n),window.addEventListener("beforeunload",n),y}function S(){return K().createChild()}function I(n,e){var t;return`${(t=e==null?void 0:e.method)!=null?t:"GET"}:${n}`}async function E(n,e={}){var v;let{scope:t,abort:r=!1,timeout:s,retryOnFailure:o=0,retryDelay:i=0,dedupe:l=!1,init:m,parse:f}=e,h=t,d,p;if(l&&h){d=(v=h._inFlight)!=null?v:h._inFlight=new Map,p=I(n,m);let c=d.get(p);if(c)return c}let g=(async()=>{let c=0;for(;;){let b=new AbortController;r&&t&&t.signal.addEventListener("abort",()=>b.abort(),{once:!0});let A;typeof s=="number"&&(A=setTimeout(()=>b.abort(),s));try{let u=await fetch(n,{...m,signal:b.signal});if(!u.ok)throw new Error(`HTTP ${u.status}: ${u.statusText}`);let D=await u.json();return f?f(D):D}catch(u){if(c++,u instanceof DOMException&&u.name==="AbortError"||c>o)throw u;i>0&&await new Promise(D=>setTimeout(D,i))}finally{A&&clearTimeout(A)}}})();if(d&&p&&h){d.set(p,g);let c=()=>{d.delete(p)};g.then(c,c),h.onDispose(c)}return g}var T=class{constructor(){this.events=new Map}on(e,t,r){let s=this.events.get(e);s||(s=new Set,this.events.set(e,s)),s.add(t);let o=!1,i=()=>{o||(o=!0,s.delete(t),s.size===0&&this.events.delete(e))};return r==null||r.onDispose(i),i}once(e,t,r){let s=(...i)=>{o(),t(...i)},o=this.on(e,s,r);return o}emit(e,...t){let r=this.events.get(e);if(!r||r.size===0)return;let s=Array.from(r);for(let o of s)try{o(...t)}catch(i){console.error(`Error in event handler for "${e}":`,i)}}off(e){this.events.delete(e)}clear(){this.events.clear()}hasListeners(e){var t,r;return((r=(t=this.events.get(e))==null?void 0:t.size)!=null?r:0)>0}listenerCount(e){var t,r;return(r=(t=this.events.get(e))==null?void 0:t.size)!=null?r:0}eventNames(){return Array.from(this.events.keys())}};function k(n,e){let{interval:t,scope:r,immediate:s=!0,onError:o,maxRetries:i=0,backoff:l=!1}=e,m=!1,f,h=0,d=!1,p=()=>{if(!l||h===0)return t;let c=Math.min(2**h,10);return t*c},g=()=>{m||(m=!0,f!==void 0&&(clearTimeout(f),f=void 0))},v=async()=>{if(!m){if(d){console.warn("[SequentialRefresh] Previous execution still running");return}d=!0;try{await n(),h=0}catch(c){if(h++,o)try{o(c)}catch(b){console.error("[SequentialRefresh] Error in error handler:",b)}else console.error("[SequentialRefresh] Error in refresh function:",c);if(i>0&&h>=i){console.error(`[SequentialRefresh] Max retries (${i}) exceeded. Stopping refresh.`),g();return}}finally{d=!1}if(!m){let c=p();f=setTimeout(v,c)}}};return s?v():f=setTimeout(v,t),r.onDispose(g),g}var x=class{constructor(e){this.emitter=new T;this.destroyed=!1;this.initial={...e},this.data={...e}}get(e){return this.checkDestroyed(),this.data[e]}getAll(){return this.checkDestroyed(),{...this.data}}set(e){this.checkDestroyed();let t={},r=!1;for(let s of Object.keys(e))e[s]!==this.data[s]&&(t[s]=e[s],r=!0);return r?(Object.assign(this.data,t),this.emitter.emit("change",t),!0):!1}reset(){this.checkDestroyed();let e={...this.initial};Object.keys(e).some(r=>e[r]!==this.data[r])&&(this.data=e,this.emitter.emit("change",e))}has(e,t){return this.checkDestroyed(),this.data[e]===t}onChange(e,t){return this.checkDestroyed(),this.emitter.on("change",e,t)}async fetch(e,t){this.checkDestroyed();let r=await E(e,t);return this.set(r),this.getAll()}autoRefresh(e,t){return this.checkDestroyed(),k(()=>this.fetch(e,{...t.fetch,scope:t.scope}),t)}destroy(){this.destroyed||(this.destroyed=!0,this.emitter.clear())}isDestroyed(){return this.destroyed}checkDestroyed(){if(this.destroyed)throw new Error("[Model] Cannot use destroyed model")}};var L=class{constructor(){this.items=[];this.emitter=new T;this.destroyed=!1}getAll(){return this.checkDestroyed(),[...this.items]}get length(){return this.checkDestroyed(),this.items.length}at(e){return this.checkDestroyed(),this.items[e]}add(...e){this.checkDestroyed(),this.items.push(...e),this.emitter.emit("add",e)}remove(e){this.checkDestroyed();let t=[];for(let r=this.items.length-1;r>=0;r--)e(this.items[r],r)&&(t.unshift(this.items[r]),this.items.splice(r,1));return t.length>0&&this.emitter.emit("remove",t),t}removeAt(e){if(this.checkDestroyed(),e<0||e>=this.items.length)return;let[t]=this.items.splice(e,1);return this.emitter.emit("remove",[t]),t}find(e){return this.checkDestroyed(),this.items.find(e)}findIndex(e){return this.checkDestroyed(),this.items.findIndex(e)}filter(e){return this.checkDestroyed(),this.items.filter(e)}map(e){return this.checkDestroyed(),this.items.map(e)}forEach(e){this.checkDestroyed(),this.items.forEach(e)}some(e){return this.checkDestroyed(),this.items.some(e)}every(e){return this.checkDestroyed(),this.items.every(e)}sort(e){this.checkDestroyed(),this.items.sort(e),this.emitter.emit("sort")}reset(e){this.checkDestroyed(),this.items=[...e],this.emitter.emit("reset",this.items)}clear(){this.checkDestroyed(),this.items.length>0&&(this.items=[],this.emitter.emit("reset",[]))}async fetch(e,t){this.checkDestroyed();let r=await E(e,t);return this.reset(r),this.getAll()}onAdd(e,t){return this.checkDestroyed(),this.emitter.on("add",e,t)}onRemove(e,t){return this.checkDestroyed(),this.emitter.on("remove",e,t)}onReset(e,t){return this.checkDestroyed(),this.emitter.on("reset",e,t)}onSort(e,t){return this.checkDestroyed(),this.emitter.on("sort",e,t)}onChange(e,t){this.checkDestroyed();let r=this.onAdd(e,t),s=this.onRemove(e,t),o=this.onReset(e,t),i=this.onSort(e,t);return()=>{r(),s(),o(),i()}}autoRefresh(e,t){return this.checkDestroyed(),k(()=>this.fetch(e,{...t.fetch,scope:t.scope}),t)}destroy(){this.destroyed||(this.destroyed=!0,this.items=[],this.emitter.clear())}isDestroyed(){return this.destroyed}checkDestroyed(){if(this.destroyed)throw new Error("[Collection] Cannot use destroyed collection")}};var a=class n{constructor(e){this.nodes=e}get length(){return this.nodes.length}each(e){return this.nodes.forEach(e),this}get(e=0){var t;return(t=this.nodes[e])!=null?t:null}first(){var e;return(e=this.nodes[0])!=null?e:null}last(){var e;return(e=this.nodes[this.nodes.length-1])!=null?e:null}find(e){let t=[];return this.each(r=>{t.push(...Array.from(r.querySelectorAll(e)))}),new n(t)}filter(e){return typeof e=="string"?new n(this.nodes.filter(t=>t.matches(e))):new n(this.nodes.filter(e))}parent(){let e=[];return this.each(t=>{t.parentElement&&e.push(t.parentElement)}),new n(e)}closest(e){let t=[];return this.each(r=>{let s=r.closest(e);s&&t.push(s)}),new n(t)}children(){let e=[];return this.each(t=>{e.push(...Array.from(t.children))}),new n(e)}text(e){var t,r;return e===void 0?(r=(t=this.get())==null?void 0:t.textContent)!=null?r:"":this.each(s=>{s.textContent=e})}html(e){var t,r;return e===void 0?(r=(t=this.get())==null?void 0:t.innerHTML)!=null?r:"":this.each(s=>{s.innerHTML=e})}attr(e,t){var r,s;return t===void 0?(s=(r=this.get())==null?void 0:r.getAttribute(e))!=null?s:"":this.each(o=>{o.setAttribute(e,t)})}removeAttr(e){return this.each(t=>{t.removeAttribute(e)})}data(e,t){var r;if(t===void 0){let s=this.get();return s instanceof HTMLElement&&(r=s.dataset[e])!=null?r:""}return this.each(s=>{s instanceof HTMLElement&&(s.dataset[e]=t)})}val(e){if(e===void 0){let t=this.get();return t instanceof HTMLInputElement||t instanceof HTMLTextAreaElement||t instanceof HTMLSelectElement?t.value:""}return this.each(t=>{(t instanceof HTMLInputElement||t instanceof HTMLTextAreaElement||t instanceof HTMLSelectElement)&&(t.value=e)})}on(e,t,r){return this.each(s=>{s.addEventListener(e,t),r==null||r.onDispose(()=>{s.removeEventListener(e,t)})})}once(e,t){return this.each(r=>{r.addEventListener(e,t,{once:!0})})}off(e,t){return this.each(r=>{r.removeEventListener(e,t)})}trigger(e,t){return this.each(r=>{r.dispatchEvent(new CustomEvent(e,{detail:t}))})}addClass(e){let t=e.split(" ").filter(Boolean);return this.each(r=>{r.classList.add(...t)})}removeClass(e){let t=e.split(" ").filter(Boolean);return this.each(r=>{r.classList.remove(...t)})}toggleClass(e,t){let r=e.split(" ").filter(Boolean);return this.each(s=>{r.forEach(o=>{s.classList.toggle(o,t)})})}hasClass(e){return this.nodes.some(t=>t.classList.contains(e))}css(e,t){if(typeof e=="string"&&t===void 0){let r=this.get();return r instanceof HTMLElement?getComputedStyle(r).getPropertyValue(e):""}return typeof e=="string"?this.each(r=>{r instanceof HTMLElement&&r.style.setProperty(e,t)}):this.each(r=>{r instanceof HTMLElement&&Object.entries(e).forEach(([s,o])=>{r.style.setProperty(s,o)})})}show(){return this.each(e=>{e instanceof HTMLElement&&(e.style.display="")})}hide(){return this.each(e=>{e instanceof HTMLElement&&(e.style.display="none")})}toggle(e){return this.each(t=>{if(t instanceof HTMLElement){let r=e!=null?e:t.style.display==="none";t.style.display=r?"":"none"}})}isVisible(){return this.nodes.some(e=>e instanceof HTMLElement?e.style.display!=="none"&&e.offsetParent!==null:!1)}append(e){return this.each(t=>{typeof e=="string"?t.insertAdjacentHTML("beforeend",e):e instanceof n?e.each(r=>t.appendChild(r.cloneNode(!0))):t.appendChild(e)})}prepend(e){return this.each(t=>{if(typeof e=="string")t.insertAdjacentHTML("afterbegin",e);else if(e instanceof n){let r=t.firstChild;e.each(s=>{t.insertBefore(s.cloneNode(!0),r)})}else t.insertBefore(e,t.firstChild)})}remove(){return this.each(e=>{e.remove()})}empty(){return this.each(e=>{e.innerHTML=""})}clone(e=!0){return new n(this.nodes.map(t=>t.cloneNode(e)))}focus(){let e=this.get();return e instanceof HTMLElement&&e.focus(),this}blur(){let e=this.get();return e instanceof HTMLElement&&e.blur(),this}};function w(n,e){if(typeof n=="string"){let t=n.trim();if(!t)return new a([]);try{return new a(Array.from((e!=null?e:document).querySelectorAll(t)))}catch(r){return console.error(`[el] Invalid selector: "${t}"`,r),new a([])}}if(n instanceof Element)return new a([n]);if(n instanceof NodeList)return new a(Array.from(n));if(n instanceof HTMLCollection)return new a(Array.from(n));if(Array.isArray(n)){let t=n.filter(r=>r instanceof Element);return t.length!==n.length&&console.warn("[el] Some items in array were not Elements and were filtered out"),new a(t)}return console.warn("[el] Unrecognized input type:",typeof n),new a([])}var M=class{constructor(e,t,r={}){this.root=e;this.model=t;this.destroyed=!1;this.children=new Set;this.options={autoDestroy:!0,...r},this.scope=r.parentScope?r.parentScope.createChild():S(),this.options.autoDestroy&&this.setupAutoDestroy(),this.init()}init(){}$(e){return w(e,this.root)}$root(){return w(this.root)}createChild(e,t,r){this.checkDestroyed();let s=new e(t,r,{parentScope:this.scope,autoDestroy:!1});return this.children.add(s),s.scope.onDispose(()=>{this.children.delete(s)}),s}createChildren(e,t,r){this.checkDestroyed();let s=[];return this.$(t).each((o,i)=>{let l=r?r(o,i):void 0;s.push(this.createChild(e,o,l))}),s}emit(e,t){this.checkDestroyed(),this.$root().trigger(e,t)}on(e,t){this.checkDestroyed(),this.$root().on(e,t,this.scope)}show(){this.checkDestroyed(),this.$root().show()}hide(){this.checkDestroyed(),this.$root().hide()}toggle(e){this.checkDestroyed(),this.$root().toggle(e)}isVisible(){return this.$root().isVisible()}isDestroyed(){return this.destroyed}getRoot(){return this.root}getModel(){return this.model}destroy(){if(!this.destroyed){this.destroyed=!0;for(let e of this.children)try{e.destroy()}catch(t){console.error("[View] Error destroying child view:",t)}this.children.clear();try{this.scope.dispose()}catch(e){console.error("[View] Error disposing scope:",e)}if(this.model&&typeof this.model.destroy=="function")try{this.model.destroy()}catch(e){console.error("[View] Error destroying model:",e)}}}setupAutoDestroy(){let e=new MutationObserver(t=>{for(let r of t)for(let s of Array.from(r.removedNodes))if(s===this.root||s instanceof Element&&s.contains(this.root)){this.destroy(),e.disconnect();return}});this.root.parentElement&&e.observe(this.root.parentElement,{childList:!0,subtree:!0}),this.scope.onDispose(()=>{e.disconnect()})}checkDestroyed(){if(this.destroyed)throw new Error("[View] Cannot use destroyed view")}};return $(q);})();

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "bonemarrow",
+  "version": "1.1.0",
+  "description": "A modern jQuery + Backbone replacement",
+  "license": "MIT",
+
+  "main": "dist/bonemarrow.js",
+  "unpkg": "dist/bonemarrow.js",
+
+  "files": ["dist"],
+
+  "scripts": {
+    "build": "npm run build:iife && npm run build:min",
+    "build:iife": "esbuild src/index.ts --bundle --format=iife --global-name=bone --target=es2019 --outfile=dist/bonemarrow.js",
+    "build:min": "esbuild src/index.ts --bundle --format=iife --global-name=bone --target=es2019 --minify --outfile=dist/bonemarrow.min.js"
+  }
+}

package/readme.md

@@ -0,0 +1,225 @@
+# 🦴 BoneMarrow
+
+**BoneMarrow** is a lightweight, lifecycle-aware JavaScript/TypeScript library for building structured UI logic on top of server-rendered HTML — without jQuery, virtual DOMs, or heavyweight frameworks.
+
+It provides a small set of **explicit primitives** for managing UI behavior, async operations, and state in a predictable way.
+
+---
+
+## Why BoneMarrow?
+
+Modern web apps often fall into two extremes:
+
+* **jQuery-style code** that becomes unmaintainable at scale
+* **SPA frameworks** that are too heavy for many server-rendered apps
+
+BoneMarrow sits in between.
+
+It helps you:
+
+* Modernize legacy applications incrementally
+* Replace jQuery patterns safely
+* Keep server-rendered HTML
+* Avoid framework lock-in
+* Write code that is easy to reason about and debug
+
+---
+
+## Core Ideas
+
+* **Explicit lifecycles** using scopes
+* **Abort-safe async** by default
+* **No hidden background work**
+* **No global mutable state**
+* **No `$`**
+* **No magic**
+
+If something happens, you should know *where*, *when*, and *why*.
+
+---
+
+## What BoneMarrow Provides
+
+### Scope
+
+A lifecycle container that:
+
+* Owns async work
+* Aborts fetches on disposal
+* Cleans up event listeners
+* Supports parent / child scopes
+
+### Fetch Pipeline
+
+A unified fetch helper with optional:
+
+* abort
+* timeout
+* retry on failure
+* scope-local request de-duplication
+
+### Model
+
+* Simple observable state
+* Patch-based updates
+* Fetch and auto-refresh support
+
+### Collection
+
+* List-based state
+* Reset semantics
+* Fetch and auto-refresh support
+
+### Auto Refresh
+
+* Sequential polling (no overlapping requests)
+* Next refresh starts only after the previous fetch completes
+
+### DOM Utilities
+
+* `el()` selector helper
+* `Elements` wrapper
+* Scoped event handling
+
+### View
+
+* UI composition primitive
+* Owns a DOM root and scope
+* Automatic cleanup on destroy
+
+---
+
+## Quick Example
+
+```ts
+const user = new bone.Model({ name: "John" });
+
+class UserView extends bone.View<typeof user> {
+  protected init() {
+    this.$(".name").text(this.model.get("name"));
+
+    this.model.onChange(patch => {
+      if (patch.name) {
+        this.$(".name").text(patch.name);
+      }
+    });
+
+    this.$(".btn").on(
+      "click",
+      () => this.model.set({ name: "Smith" }),
+      this.scope
+    );
+  }
+}
+
+new UserView(document.getElementById("app")!, user);
+```
+
+Everything created inside the view:
+
+* is scoped
+* is cleaned up automatically
+* stops when the view is destroyed
+
+---
+
+## Sequential Auto Refresh (Polling)
+
+```ts
+user.autoRefresh("/api/user/42", {
+  scope: this.scope,
+  interval: 5000,
+  fetch: { abort: true }
+});
+```
+
+Actual behavior:
+
+```
+fetch → complete → wait 5s → fetch → complete → wait 5s
+```
+
+No overlapping requests. No runaway timers.
+
+---
+
+## jQuery-like UI, Without jQuery
+
+BoneMarrow is well suited for building:
+
+* dialogs
+* dropdowns
+* tabs
+* dashboards
+* admin panels
+
+All with:
+
+* explicit ownership
+* predictable cleanup
+* no global state
+
+---
+
+## Progressive Enhancement Friendly
+
+BoneMarrow works best when:
+
+* HTML is rendered by the server
+* JavaScript enhances behavior
+* Pages still work without JS
+
+Perfect for:
+
+* ASP.NET MVC / Razor
+* Rails
+* PHP
+* Django
+* Large legacy apps
+
+---
+
+## Documentation
+
+* Full documentation is available in **`DOCS.md`**
+* Includes detailed API reference
+* Covers scopes, fetch, models, collections, views, and patterns
+
+---
+
+## Size
+
+Approximate sizes (production build):
+
+* ~9 KB raw
+* ~4–5 KB minified
+* ~2–3 KB gzip
+
+Smaller than most “micro” libraries, without sacrificing structure.
+
+---
+
+## What BoneMarrow Is Not
+
+* ❌ Not a framework
+* ❌ Not a virtual DOM
+* ❌ Not reactive magic
+* ❌ Not an SPA replacement
+
+BoneMarrow provides **primitives**, not rules.
+
+---
+
+## License
+
+MIT © Karthick Raj
+
+---
+
+## Final Thought
+
+> **BoneMarrow is intentionally boring.
+> Boring code scales.**
+
+If you want clarity, explicit lifecycles, and predictable async behavior without the weight of a framework, BoneMarrow is built for that.
+