surf-core 0.1.0

package/dist/surf.js

@@ -0,0 +1,911 @@
+var SurfModule = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  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/cell.js
+  var cell_exports = {};
+  __export(cell_exports, {
+    clearPreserved: () => clearPreserved,
+    default: () => cell_default,
+    findAll: () => findAll2,
+    getCellId: () => getCellId,
+    getState: () => getState,
+    init: () => init2,
+    initAll: () => initAll,
+    restore: () => restore,
+    setProperty: () => setProperty,
+    setState: () => setState,
+    snapshot: () => snapshot
+  });
+  function parseSeed(seedExpr) {
+    if (!seedExpr)
+      return {};
+    const trimmed = seedExpr.trim();
+    try {
+      const expression = trimmed.startsWith("{") ? `return ${trimmed}` : `return { ${trimmed} }`;
+      return new Function(expression)();
+    } catch (e) {
+      console.warn(`[Surf] Invalid seed expression: "${trimmed}"`, e);
+      return {};
+    }
+  }
+  function getCellId(element) {
+    return element.getAttribute(CELL_ID_ATTR) || element.id || null;
+  }
+  function findAll2(container = document) {
+    return container.querySelectorAll(`[${CELL_ATTR}]`);
+  }
+  function init2(element) {
+    if (!element.hasAttribute(CELL_ATTR)) {
+      console.warn("[Surf] Element is not a cell:", element);
+      return {};
+    }
+    const cellId = getCellId(element);
+    if (cellId && cellIdStates.has(cellId)) {
+      const preservedState = cellIdStates.get(cellId);
+      cellStates.set(element, preservedState);
+      return preservedState;
+    }
+    const cellExpr = element.getAttribute(CELL_ATTR);
+    const state = parseSeed(cellExpr || "{}");
+    cellStates.set(element, state);
+    if (cellId) {
+      cellIdStates.set(cellId, state);
+    }
+    return state;
+  }
+  function getState(element) {
+    if (!cellStates.has(element)) {
+      return init2(element);
+    }
+    return cellStates.get(element);
+  }
+  function setState(element, newState) {
+    const currentState = getState(element);
+    const updatedState = { ...currentState, ...newState };
+    cellStates.set(element, updatedState);
+    const cellId = getCellId(element);
+    if (cellId) {
+      cellIdStates.set(cellId, updatedState);
+    }
+    return updatedState;
+  }
+  function setProperty(element, key, value) {
+    return setState(element, { [key]: value });
+  }
+  function snapshot(container = document) {
+    const cells = findAll2(container);
+    const snap = /* @__PURE__ */ new Map();
+    cells.forEach((cell) => {
+      const cellId = getCellId(cell);
+      if (cellId) {
+        snap.set(cellId, { ...getState(cell) });
+      }
+    });
+    return snap;
+  }
+  function restore(snap) {
+    snap.forEach((state, cellId) => {
+      cellIdStates.set(cellId, state);
+    });
+  }
+  function initAll(container = document) {
+    const cells = findAll2(container);
+    cells.forEach((cell) => init2(cell));
+  }
+  function clearPreserved(cellId) {
+    cellIdStates.delete(cellId);
+  }
+  var CELL_ATTR, CELL_ID_ATTR, cellStates, cellIdStates, cell_default;
+  var init_cell = __esm({
+    "src/cell.js"() {
+      CELL_ATTR = "d-cell";
+      CELL_ID_ATTR = "d-cell-id";
+      cellStates = /* @__PURE__ */ new WeakMap();
+      cellIdStates = /* @__PURE__ */ new Map();
+      cell_default = {
+        findAll: findAll2,
+        getCellId,
+        init: init2,
+        getState,
+        setState,
+        setProperty,
+        snapshot,
+        restore,
+        initAll,
+        clearPreserved
+      };
+    }
+  });
+
+  // src/surf.js
+  var surf_exports = {};
+  __export(surf_exports, {
+    Cell: () => cell_exports,
+    Echo: () => echo_exports,
+    Patch: () => patch_exports,
+    Pulse: () => pulse_exports,
+    Signal: () => signal_exports,
+    Surface: () => surface_exports,
+    default: () => surf_default
+  });
+
+  // src/surface.js
+  var surface_exports = {};
+  __export(surface_exports, {
+    append: () => append,
+    default: () => surface_default,
+    findAll: () => findAll,
+    getById: () => getById,
+    getBySelector: () => getBySelector,
+    init: () => init,
+    prepend: () => prepend,
+    replace: () => replace
+  });
+  var SURFACE_ATTR = "d-surface";
+  function findAll() {
+    return document.querySelectorAll(`[${SURFACE_ATTR}]`);
+  }
+  function getById(id) {
+    const cleanId = id.startsWith("#") ? id.slice(1) : id;
+    const element = document.getElementById(cleanId);
+    if (element && element.hasAttribute(SURFACE_ATTR)) {
+      return element;
+    }
+    return null;
+  }
+  function getBySelector(selector) {
+    const element = document.querySelector(selector);
+    if (element && element.hasAttribute(SURFACE_ATTR)) {
+      return element;
+    }
+    return null;
+  }
+  function replace(selectorOrElement, html) {
+    let surface;
+    if (typeof selectorOrElement === "string") {
+      surface = getBySelector(selectorOrElement) || document.querySelector(selectorOrElement);
+    } else {
+      surface = selectorOrElement;
+    }
+    if (!surface) {
+      console.warn(`[Surf] Surface not found: ${selectorOrElement}`);
+      return null;
+    }
+    const template = document.createElement("template");
+    template.innerHTML = html.trim();
+    surface.innerHTML = "";
+    while (template.content.firstChild) {
+      surface.appendChild(template.content.firstChild);
+    }
+    return surface;
+  }
+  function append(selectorOrElement, html) {
+    return inject(selectorOrElement, html, "beforeend");
+  }
+  function prepend(selectorOrElement, html) {
+    return inject(selectorOrElement, html, "afterbegin");
+  }
+  function inject(selectorOrElement, html, position) {
+    let surface;
+    if (typeof selectorOrElement === "string") {
+      surface = getBySelector(selectorOrElement) || document.querySelector(selectorOrElement);
+    } else {
+      surface = selectorOrElement;
+    }
+    if (!surface) {
+      console.warn(`[Surf] Surface not found: ${selectorOrElement}`);
+      return null;
+    }
+    const template = document.createElement("template");
+    template.innerHTML = html.trim();
+    const fragment = document.createDocumentFragment();
+    while (template.content.firstChild) {
+      fragment.appendChild(template.content.firstChild);
+    }
+    if (position === "beforeend") {
+      surface.appendChild(fragment);
+    } else {
+      surface.insertBefore(fragment, surface.firstChild);
+    }
+    return surface;
+  }
+  function init() {
+    const surfaces = findAll();
+    surfaces.forEach((surface) => {
+      surface.setAttribute("data-surf-ready", "true");
+    });
+  }
+  var surface_default = {
+    findAll,
+    getById,
+    getBySelector,
+    replace,
+    append,
+    prepend,
+    init
+  };
+
+  // src/surf.js
+  init_cell();
+
+  // src/signal.js
+  var signal_exports = {};
+  __export(signal_exports, {
+    cleanup: () => cleanup,
+    default: () => signal_default,
+    initAll: () => initAll2,
+    register: () => register,
+    updateBindings: () => updateBindings
+  });
+  init_cell();
+  var SIGNAL_ATTR = "d-signal";
+  var TEXT_ATTR = "d-text";
+  var SHOW_ATTR = "d-show";
+  var ATTR_ATTR = "d-attr";
+  var modules = {};
+  function register(name, module) {
+    modules[name] = module;
+  }
+  var boundListeners = /* @__PURE__ */ new WeakMap();
+  function findParentCell(element) {
+    return element.closest("[d-cell]");
+  }
+  function evaluate(expr, state) {
+    if (!expr || !state)
+      return void 0;
+    const trimmed = expr.trim();
+    if (trimmed in state) {
+      return state[trimmed];
+    }
+    if (trimmed.startsWith("!")) {
+      const prop = trimmed.slice(1).trim();
+      return !state[prop];
+    }
+    const eqMatch = trimmed.match(/^(\w+)\s*={2,3}\s*(.+)$/);
+    if (eqMatch) {
+      const [, prop, value] = eqMatch;
+      const propVal = state[prop];
+      const compareVal = value === "true" ? true : value === "false" ? false : value.startsWith('"') || value.startsWith("'") ? value.slice(1, -1) : Number(value);
+      return propVal === compareVal;
+    }
+    const neqMatch = trimmed.match(/^(\w+)\s*!=\s*(.+)$/);
+    if (neqMatch) {
+      const [, prop, value] = neqMatch;
+      const propVal = state[prop];
+      const compareVal = value === "true" ? true : value === "false" ? false : Number(value);
+      return propVal !== compareVal;
+    }
+    const gtMatch = trimmed.match(/^(\w+)\s*>\s*(\d+)$/);
+    if (gtMatch) {
+      return state[gtMatch[1]] > Number(gtMatch[2]);
+    }
+    const ltMatch = trimmed.match(/^(\w+)\s*<\s*(\d+)$/);
+    if (ltMatch) {
+      return state[ltMatch[1]] < Number(ltMatch[2]);
+    }
+    return void 0;
+  }
+  function executeAssignment(expr, state, event, element) {
+    const trimmed = expr.trim();
+    const methodMatch = trimmed.match(/^(\w+)\.(\w+)\((.*)\)$/);
+    if (methodMatch) {
+      const [, moduleName, methodName, argsStr] = methodMatch;
+      const module = modules[moduleName];
+      if (!module || typeof module[methodName] !== "function") {
+        console.warn(`[Surf] Unknown module method: ${moduleName}.${methodName}`);
+        return {};
+      }
+      const args = parseArguments(argsStr, state, event, element);
+      const result = module[methodName](...args);
+      return typeof result === "object" ? result : {};
+    }
+    const match = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (!match)
+      return {};
+    const [, prop, valueExpr] = match;
+    const valueExprTrimmed = valueExpr.trim();
+    if (valueExprTrimmed === `!${prop}`) {
+      return { [prop]: !state[prop] };
+    }
+    if (valueExprTrimmed === "true") {
+      return { [prop]: true };
+    }
+    if (valueExprTrimmed === "false") {
+      return { [prop]: false };
+    }
+    const addMatch = valueExprTrimmed.match(/^(\w+)\s*\+\s*(\d+)$/);
+    if (addMatch) {
+      const [, srcProp, num] = addMatch;
+      return { [prop]: (state[srcProp] || 0) + Number(num) };
+    }
+    const subMatch = valueExprTrimmed.match(/^(\w+)\s*-\s*(\d+)$/);
+    if (subMatch) {
+      const [, srcProp, num] = subMatch;
+      return { [prop]: (state[srcProp] || 0) - Number(num) };
+    }
+    const maxMatch = valueExprTrimmed.match(/^Math\.max\((\w+)\s*-\s*(\d+),\s*(\d+)\)$/);
+    if (maxMatch) {
+      const [, srcProp, delta, min] = maxMatch;
+      const newVal = (state[srcProp] || 0) - Number(delta);
+      return { [prop]: Math.max(newVal, Number(min)) };
+    }
+    const minMatch = valueExprTrimmed.match(/^Math\.min\((\w+)\s*\+\s*(\d+),\s*(\d+)\)$/);
+    if (minMatch) {
+      const [, srcProp, delta, max] = minMatch;
+      const newVal = (state[srcProp] || 0) + Number(delta);
+      return { [prop]: Math.min(newVal, Number(max)) };
+    }
+    if (valueExprTrimmed.startsWith('"') || valueExprTrimmed.startsWith("'")) {
+      return { [prop]: valueExprTrimmed.slice(1, -1) };
+    }
+    if (/^\d+$/.test(valueExprTrimmed)) {
+      return { [prop]: Number(valueExprTrimmed) };
+    }
+    if (valueExprTrimmed in state) {
+      return { [prop]: state[valueExprTrimmed] };
+    }
+    return {};
+  }
+  function parseArguments(argsStr, state, event, element) {
+    if (argsStr.trim() === "")
+      return [];
+    return argsStr.split(",").map((arg) => {
+      const a = arg.trim();
+      if (a === "")
+        return void 0;
+      if (a === "true")
+        return true;
+      if (a === "false")
+        return false;
+      if (a === "event")
+        return event;
+      if (a === "this")
+        return element;
+      if (a.startsWith("'") || a.startsWith('"'))
+        return a.slice(1, -1);
+      if (!isNaN(a) && a !== "")
+        return Number(a);
+      if (a.startsWith("this.")) {
+        return resolvePath(element, a.slice(5));
+      }
+      return resolvePath(state, a);
+    }).filter((a) => a !== void 0 && a !== "");
+  }
+  function resolvePath(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current === void 0 || current === null)
+        return void 0;
+      current = current[part];
+    }
+    return current;
+  }
+  function updateBindings(cellElement) {
+    const state = getState(cellElement);
+    const textElements = cellElement.querySelectorAll(`[${TEXT_ATTR}]`);
+    textElements.forEach((el) => {
+      const prop = el.getAttribute(TEXT_ATTR);
+      const value = evaluate(prop, state);
+      if (value !== void 0) {
+        el.textContent = String(value);
+      }
+    });
+    const showElements = cellElement.querySelectorAll(`[${SHOW_ATTR}]`);
+    showElements.forEach((el) => {
+      const expr = el.getAttribute(SHOW_ATTR);
+      const visible = evaluate(expr, state);
+      el.style.display = visible ? "" : "none";
+    });
+    const attrElements = cellElement.querySelectorAll(`[${ATTR_ATTR}]`);
+    attrElements.forEach((el) => {
+      const attrExpr = el.getAttribute(ATTR_ATTR);
+      const classMatch = attrExpr.match(/^class\.([\\w-]+):\\s*(.+)$/);
+      if (classMatch) {
+        const [, className, expr2] = classMatch;
+        const shouldAdd = evaluate(expr2.trim(), state);
+        if (shouldAdd) {
+          el.classList.add(className);
+        } else {
+          el.classList.remove(className);
+        }
+        return;
+      }
+      const match = attrExpr.match(/^(\\w+):(.+)$/);
+      if (!match)
+        return;
+      const [, attrName, expr] = match;
+      const value = evaluate(expr.trim(), state);
+      if (value === void 0)
+        return;
+      if (typeof value !== "boolean") {
+        el.setAttribute(attrName, String(value));
+        return;
+      }
+      if (value) {
+        el.setAttribute(attrName, "");
+      } else {
+        el.removeAttribute(attrName);
+      }
+    });
+  }
+  function bindSignalElement(element) {
+    const signalExpr = element.getAttribute(SIGNAL_ATTR);
+    if (!signalExpr)
+      return;
+    const match = signalExpr.match(/^(\w+):\s*(.+)$/);
+    if (!match) {
+      console.warn(`[Surf] Invalid signal expression: ${signalExpr}`);
+      return;
+    }
+    const [, eventName, actionExpr] = match;
+    const cellElement = findParentCell(element);
+    if (!cellElement) {
+      console.warn("[Surf] Signal element has no parent cell:", element);
+      return;
+    }
+    const existing = boundListeners.get(element);
+    if (existing) {
+      element.removeEventListener(existing.event, existing.handler);
+    }
+    const handler = (e) => {
+      const state = getState(cellElement);
+      const changes = executeAssignment(actionExpr, state, e, element);
+      if (Object.keys(changes).length > 0) {
+        setState(cellElement, changes);
+        updateBindings(cellElement);
+      }
+    };
+    element.addEventListener(eventName, handler);
+    boundListeners.set(element, { event: eventName, handler });
+  }
+  function initAll2(container = document) {
+    const signalElements = container.querySelectorAll(`[${SIGNAL_ATTR}]`);
+    signalElements.forEach((el) => bindSignalElement(el));
+    const cells = findAll2(container);
+    cells.forEach((cell) => updateBindings(cell));
+  }
+  function cleanup(container) {
+    const signalElements = container.querySelectorAll(`[${SIGNAL_ATTR}]`);
+    signalElements.forEach((el) => {
+      const existing = boundListeners.get(el);
+      if (existing) {
+        el.removeEventListener(existing.event, existing.handler);
+        boundListeners.delete(el);
+      }
+    });
+  }
+  var signal_default = {
+    updateBindings,
+    initAll: initAll2,
+    cleanup,
+    evaluate,
+    executeAssignment,
+    register
+  };
+
+  // src/pulse.js
+  var pulse_exports = {};
+  __export(pulse_exports, {
+    action: () => action,
+    commit: () => commit,
+    default: () => pulse_default,
+    go: () => go,
+    init: () => init3,
+    navigate: () => navigate,
+    off: () => off,
+    on: () => on,
+    refresh: () => refresh
+  });
+
+  // src/patch.js
+  var patch_exports = {};
+  __export(patch_exports, {
+    create: () => create,
+    default: () => patch_default,
+    isPatch: () => isPatch,
+    parse: () => parse
+  });
+  function parse(html) {
+    const patches = [];
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(html, "text/html");
+    const patchElement = doc.querySelector("d-patch");
+    if (!patchElement) {
+      console.warn("[Surf] No <d-patch> element found in response");
+      return patches;
+    }
+    const surfaceElements = patchElement.querySelectorAll("surface");
+    surfaceElements.forEach((surface) => {
+      const target = surface.getAttribute("target");
+      if (!target) {
+        console.warn("[Surf] Surface element missing target attribute");
+        return;
+      }
+      patches.push({
+        target,
+        content: surface.innerHTML
+      });
+    });
+    return patches;
+  }
+  function isPatch(html) {
+    return html.includes("<d-patch>") || html.includes("<d-patch ");
+  }
+  function create(surfaces) {
+    const surfaceHtml = surfaces.map((s) => `  <surface target="${s.target}">${s.content}</surface>`).join("\n");
+    return `<d-patch>
+${surfaceHtml}
+</d-patch>`;
+  }
+  var patch_default = {
+    parse,
+    isPatch,
+    create
+  };
+
+  // src/echo.js
+  var echo_exports = {};
+  __export(echo_exports, {
+    after: () => after,
+    before: () => before,
+    default: () => echo_default,
+    withPreservation: () => withPreservation
+  });
+  init_cell();
+  function before(surface) {
+    cleanup(surface);
+    return snapshot(surface);
+  }
+  function after(surface, snapshot2) {
+    restore(snapshot2);
+    initAll(surface);
+    initAll2(surface);
+  }
+  function withPreservation(surface, newContent, replaceFn) {
+    const snapshot2 = before(surface);
+    replaceFn();
+    after(surface, snapshot2);
+  }
+  var echo_default = {
+    before,
+    after,
+    withPreservation
+  };
+
+  // src/pulse.js
+  var PULSE_ATTR = "d-pulse";
+  var TARGET_ATTR = "d-target";
+  var ACTION_ATTR = "d-action";
+  var listeners = {
+    "before:pulse": [],
+    "after:patch": [],
+    "error:network": []
+  };
+  function emit(event, detail) {
+    if (listeners[event]) {
+      listeners[event].forEach((cb) => {
+        try {
+          cb(detail);
+        } catch (e) {
+          console.error(`[Surf] Error in ${event} listener:`, e);
+        }
+      });
+    }
+  }
+  function on(event, callback) {
+    if (listeners[event]) {
+      listeners[event].push(callback);
+    }
+  }
+  function off(event, callback) {
+    if (listeners[event]) {
+      const index = listeners[event].indexOf(callback);
+      if (index > -1) {
+        listeners[event].splice(index, 1);
+      }
+    }
+  }
+  function applyPatches(patches) {
+    patches.forEach(({ target, content }) => {
+      const surface = getBySelector(target) || document.querySelector(target);
+      if (!surface) {
+        console.warn(`[Surf] Target not found for patch: ${target}`);
+        return;
+      }
+      withPreservation(surface, content, () => {
+        replace(target, content);
+      });
+    });
+  }
+  async function sendPulse(url, options, targetSelector) {
+    emit("before:pulse", { url, options, target: targetSelector });
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "Accept": "text/html",
+          "X-Surf-Request": "true",
+          ...options.headers
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const html = await response.text();
+      if (isPatch(html)) {
+        const patches = parse(html);
+        applyPatches(patches);
+      } else {
+        if (targetSelector) {
+          const surface = getBySelector(targetSelector) || document.querySelector(targetSelector);
+          if (surface) {
+            const swapMode = options.swap || surface.getAttribute("d-swap") || "inner";
+            withPreservation(surface, html, () => {
+              if (swapMode === "append") {
+                append(surface, html);
+              } else if (swapMode === "prepend") {
+                prepend(surface, html);
+              } else {
+                replace(surface, html);
+              }
+            });
+          }
+        }
+      }
+      emit("after:patch", { url, target: targetSelector });
+    } catch (error) {
+      console.error("[Surf] Pulse error:", error);
+      emit("error:network", { url, error });
+    }
+  }
+  async function navigate(url, targetSelector, options = {}) {
+    await sendPulse(url, { method: "GET", ...options }, targetSelector);
+    if (targetSelector) {
+      history.pushState({ surf: true, url, target: targetSelector }, "", url);
+    }
+  }
+  async function commit(form, targetSelector) {
+    const method = form.method?.toUpperCase() || "POST";
+    let url = form.action || window.location.href;
+    const formData = new FormData(form);
+    const swap = form.getAttribute("d-swap");
+    const options = swap ? { swap } : {};
+    const params = new URLSearchParams();
+    formData.forEach((value, key) => params.append(key, value));
+    if (method === "GET") {
+      const separator = url.includes("?") ? "&" : "?";
+      url = url + separator + params.toString();
+      await sendPulse(url, { method: "GET", ...options }, targetSelector);
+    } else {
+      await sendPulse(url, {
+        method,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: params.toString(),
+        ...options
+      }, targetSelector);
+    }
+  }
+  async function refresh(targetSelector) {
+    const url = window.location.href;
+    const surface = getBySelector(targetSelector) || document.querySelector(targetSelector);
+    const swap = surface?.getAttribute("d-swap");
+    await sendPulse(url, { method: "GET", swap }, targetSelector);
+  }
+  async function action(url, data = {}, targetSelector, options = {}) {
+    await sendPulse(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(data),
+      ...options
+    }, targetSelector);
+  }
+  async function handleClick(event) {
+    const element = event.target.closest(`[${PULSE_ATTR}]`);
+    if (!element)
+      return;
+    const pulseType = element.getAttribute(PULSE_ATTR);
+    const targetSelector = element.getAttribute(TARGET_ATTR);
+    const actionUrl = element.getAttribute(ACTION_ATTR);
+    const swap = element.getAttribute("d-swap");
+    const options = swap ? { swap } : {};
+    if (element.tagName === "A" && pulseType === "navigate") {
+      event.preventDefault();
+      const url = element.href;
+      navigate(url, targetSelector, options);
+      return;
+    }
+    if (pulseType === "refresh") {
+      event.preventDefault();
+      refresh(targetSelector);
+      return;
+    }
+    if (pulseType === "action" && actionUrl) {
+      event.preventDefault();
+      const data = {};
+      for (const attr of element.attributes) {
+        if (attr.name.startsWith("data-") && attr.name !== "data-surf-ready") {
+          const key = attr.name.slice(5);
+          data[key] = attr.value;
+        }
+      }
+      const parentCell = element.closest("[d-cell]");
+      if (parentCell) {
+        const Cell = await Promise.resolve().then(() => (init_cell(), cell_exports));
+        const cellState = Cell.default ? Cell.default.getState(parentCell) : Cell.getState(parentCell);
+        if (cellState) {
+          Object.assign(data, cellState);
+        }
+      }
+      action(actionUrl, data, targetSelector, options);
+      return;
+    }
+  }
+  function handleSubmit(event) {
+    const form = event.target;
+    if (!form.hasAttribute(PULSE_ATTR))
+      return;
+    const pulseType = form.getAttribute(PULSE_ATTR);
+    const targetSelector = form.getAttribute(TARGET_ATTR);
+    if (pulseType === "commit") {
+      event.preventDefault();
+      commit(form, targetSelector);
+    }
+  }
+  function handlePopState(event) {
+    if (event.state?.surf) {
+      sendPulse(event.state.url, { method: "GET" }, event.state.target);
+    }
+  }
+  function init3() {
+    document.addEventListener("click", handleClick);
+    document.addEventListener("submit", handleSubmit);
+    window.addEventListener("popstate", handlePopState);
+    window.addEventListener("popstate", handlePopState);
+  }
+  async function go(url, options = {}) {
+    const target = options.target || "body";
+    await navigate(url, target, options);
+  }
+  var pulse_default = {
+    on,
+    off,
+    navigate,
+    commit,
+    refresh,
+    action,
+    go,
+    init: init3
+  };
+
+  // src/surf.js
+  var Surf = {
+    /**
+     * Framework version
+     */
+    version: "0.1.0",
+    /**
+     * Navigate to a URL
+     * @param {string} url - The URL to navigate to
+     * @param {Object} options - Optional settings (target, swap, etc)
+     */
+    go(url, options = {}) {
+      return go(url, options);
+    },
+    /**
+     * Refresh a surface's content from the server
+     * @param {string} selector - The surface selector to refresh
+     */
+    refresh(selector) {
+      return refresh(selector);
+    },
+    /**
+     * Subscribe to framework events
+     * @param {string} event - Event name: 'before:pulse', 'after:patch', 'error:network'
+     * @param {function} callback - Event handler
+     */
+    on(event, callback) {
+      on(event, callback);
+    },
+    /**
+     * Unsubscribe from framework events
+     * @param {string} event - Event name
+     * @param {function} callback - Event handler to remove
+     */
+    off(event, callback) {
+      off(event, callback);
+    },
+    /**
+     * Get cell state for an element
+     * @param {Element|string} cellOrSelector - Cell element or selector
+     * @returns {Object} The cell's current state
+     */
+    getState(cellOrSelector) {
+      const cell = typeof cellOrSelector === "string" ? document.querySelector(cellOrSelector) : cellOrSelector;
+      return getState(cell);
+    },
+    /**
+     * Set cell state for an element
+     * @param {Element|string} cellOrSelector - Cell element or selector
+     * @param {Object} state - State to merge
+     */
+    setState(cellOrSelector, state) {
+      const cell = typeof cellOrSelector === "string" ? document.querySelector(cellOrSelector) : cellOrSelector;
+      setState(cell, state);
+      updateBindings(cell);
+    },
+    /**
+     * Manually apply a patch response
+     * @param {string} patchHtml - The patch HTML string
+     */
+    applyPatch(patchHtml) {
+      const patches = parse(patchHtml);
+      patches.forEach(({ target, content }) => {
+        const surface = getBySelector(target) || document.querySelector(target);
+        if (surface) {
+          withPreservation(surface, content, () => {
+            replace(target, content);
+          });
+        }
+      });
+    },
+    /**
+     * Register a module for signal expressions
+     * @param {string} name - Module namespace
+     * @param {Object} module - Object with methods
+     */
+    register(name, module) {
+      register(name, module);
+    },
+    // Expose modules for advanced usage
+    _modules: {
+      Surface: surface_exports,
+      Cell: cell_exports,
+      Signal: signal_exports,
+      Pulse: pulse_exports,
+      Patch: patch_exports,
+      Echo: echo_exports
+    }
+  };
+  function init4() {
+    init();
+    initAll();
+    initAll2();
+    init3();
+    console.log(`[Surf] Initialized v${Surf.version}`);
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init4);
+  } else {
+    init4();
+  }
+  var surf_default = Surf;
+  if (typeof window !== "undefined") {
+    window.Surf = Surf;
+  }
+  return __toCommonJS(surf_exports);
+})();
+window.Surf=SurfModule.default