raktajs 0.1.0

package/dist/index.js

@@ -0,0 +1,3872 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.bun/react@19.2.7/node_modules/react/cjs/react.development.js
+var require_react_development = __commonJS((exports, module) => {
+  (function() {
+    function defineDeprecationWarning(methodName, info) {
+      Object.defineProperty(Component.prototype, methodName, {
+        get: function() {
+          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+        }
+      });
+    }
+    function getIteratorFn(maybeIterable) {
+      if (maybeIterable === null || typeof maybeIterable !== "object")
+        return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return typeof maybeIterable === "function" ? maybeIterable : null;
+    }
+    function warnNoop(publicInstance, callerName) {
+      publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+      var warningKey = publicInstance + "." + callerName;
+      didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
+    }
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function ComponentDummy() {}
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function noop() {}
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getComponentNameFromType(type) {
+      if (type == null)
+        return null;
+      if (typeof type === "function")
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if (typeof type === "string")
+        return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if (typeof type === "object")
+        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {}
+        }
+      return null;
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE)
+        return "<>";
+      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return dispatcher === null ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning)
+          return false;
+      }
+      return config.key !== undefined;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return componentName !== undefined ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function cloneAndReplaceKey(oldElement, newKey) {
+      newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask);
+      oldElement._store && (newKey._store.validated = oldElement._store.validated);
+      return newKey;
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function escape(key) {
+      var escaperLookup = { "=": "=0", ":": "=2" };
+      return "$" + key.replace(/[=:]/g, function(match) {
+        return escaperLookup[match];
+      });
+    }
+    function getElementKey(element, index) {
+      return typeof element === "object" && element !== null && element.key != null ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
+    }
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch (typeof thenable.status === "string" ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
+            thenable.status === "pending" && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+          }, function(error) {
+            thenable.status === "pending" && (thenable.status = "rejected", thenable.reason = error);
+          })), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if (type === "undefined" || type === "boolean")
+        children = null;
+      var invokeCallback = false;
+      if (children === null)
+        invokeCallback = true;
+      else
+        switch (type) {
+          case "bigint":
+          case "string":
+          case "number":
+            invokeCallback = true;
+            break;
+          case "object":
+            switch (children.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_PORTAL_TYPE:
+                invokeCallback = true;
+                break;
+              case REACT_LAZY_TYPE:
+                return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+            }
+        }
+      if (invokeCallback) {
+        invokeCallback = children;
+        callback = callback(invokeCallback);
+        var childKey = nameSoFar === "" ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+        isArrayImpl(callback) ? (escapedPrefix = "", childKey != null && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
+          return c;
+        })) : callback != null && (isValidElement(callback) && (callback.key != null && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (callback.key == null || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), nameSoFar !== "" && invokeCallback != null && isValidElement(invokeCallback) && invokeCallback.key == null && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
+        return 1;
+      }
+      invokeCallback = 0;
+      childKey = nameSoFar === "" ? "." : nameSoFar + ":";
+      if (isArrayImpl(children))
+        for (var i = 0;i < children.length; i++)
+          nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (i = getIteratorFn(children), typeof i === "function")
+        for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = true), children = i.call(children), i = 0;!(nameSoFar = children.next()).done; )
+          nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+      else if (type === "object") {
+        if (typeof children.then === "function")
+          return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+        array = String(children);
+        throw Error("Objects are not valid as a React child (found: " + (array === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+      }
+      return invokeCallback;
+    }
+    function mapChildren(children, func, context) {
+      if (children == null)
+        return children;
+      var result = [], count = 0;
+      mapIntoArray(children, result, "", "", function(child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    function lazyInitializer(payload) {
+      if (payload._status === -1) {
+        var ioInfo = payload._ioInfo;
+        ioInfo != null && (ioInfo.start = ioInfo.end = performance.now());
+        ioInfo = payload._result;
+        var thenable = ioInfo();
+        thenable.then(function(moduleObject) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 1;
+            payload._result = moduleObject;
+            var _ioInfo = payload._ioInfo;
+            _ioInfo != null && (_ioInfo.end = performance.now());
+            thenable.status === undefined && (thenable.status = "fulfilled", thenable.value = moduleObject);
+          }
+        }, function(error) {
+          if (payload._status === 0 || payload._status === -1) {
+            payload._status = 2;
+            payload._result = error;
+            var _ioInfo2 = payload._ioInfo;
+            _ioInfo2 != null && (_ioInfo2.end = performance.now());
+            thenable.status === undefined && (thenable.status = "rejected", thenable.reason = error);
+          }
+        });
+        ioInfo = payload._ioInfo;
+        if (ioInfo != null) {
+          ioInfo.value = thenable;
+          var displayName = thenable.displayName;
+          typeof displayName === "string" && (ioInfo.name = displayName);
+        }
+        payload._status === -1 && (payload._status = 0, payload._result = thenable);
+      }
+      if (payload._status === 1)
+        return ioInfo = payload._result, ioInfo === undefined && console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`, ioInfo), "default" in ioInfo || console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`, ioInfo), ioInfo.default;
+      throw payload._result;
+    }
+    function resolveDispatcher() {
+      var dispatcher = ReactSharedInternals.H;
+      dispatcher === null && console.error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`);
+      return dispatcher;
+    }
+    function releaseAsyncTransition() {
+      ReactSharedInternals.asyncTransitions--;
+    }
+    function enqueueTask(task) {
+      if (enqueueTaskImpl === null)
+        try {
+          var requireString = ("require" + Math.random()).slice(0, 7);
+          enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
+        } catch (_err) {
+          enqueueTaskImpl = function(callback) {
+            didWarnAboutMessageChannel === false && (didWarnAboutMessageChannel = true, typeof MessageChannel === "undefined" && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+            var channel = new MessageChannel;
+            channel.port1.onmessage = callback;
+            channel.port2.postMessage(undefined);
+          };
+        }
+      return enqueueTaskImpl(task);
+    }
+    function aggregateErrors(errors) {
+      return 1 < errors.length && typeof AggregateError === "function" ? new AggregateError(errors) : errors[0];
+    }
+    function popActScope(prevActQueue, prevActScopeDepth) {
+      prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
+      actScopeDepth = prevActScopeDepth;
+    }
+    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+      var queue = ReactSharedInternals.actQueue;
+      if (queue !== null)
+        if (queue.length !== 0)
+          try {
+            flushActQueue(queue);
+            enqueueTask(function() {
+              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+            });
+            return;
+          } catch (error) {
+            ReactSharedInternals.thrownErrors.push(error);
+          }
+        else
+          ReactSharedInternals.actQueue = null;
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+    }
+    function flushActQueue(queue) {
+      if (!isFlushing) {
+        isFlushing = true;
+        var i = 0;
+        try {
+          for (;i < queue.length; i++) {
+            var callback = queue[i];
+            do {
+              ReactSharedInternals.didUsePromise = false;
+              var continuation = callback(false);
+              if (continuation !== null) {
+                if (ReactSharedInternals.didUsePromise) {
+                  queue[i] = callback;
+                  queue.splice(0, i);
+                  return;
+                }
+                callback = continuation;
+              } else
+                break;
+            } while (1);
+          }
+          queue.length = 0;
+        } catch (error) {
+          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+        } finally {
+          isFlushing = false;
+        }
+      }
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
+      isMounted: function() {
+        return false;
+      },
+      enqueueForceUpdate: function(publicInstance) {
+        warnNoop(publicInstance, "forceUpdate");
+      },
+      enqueueReplaceState: function(publicInstance) {
+        warnNoop(publicInstance, "replaceState");
+      },
+      enqueueSetState: function(publicInstance) {
+        warnNoop(publicInstance, "setState");
+      }
+    }, assign = Object.assign, emptyObject = {};
+    Object.freeze(emptyObject);
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function(partialState, callback) {
+      if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null)
+        throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, partialState, callback, "setState");
+    };
+    Component.prototype.forceUpdate = function(callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    var deprecatedAPIs = {
+      isMounted: [
+        "isMounted",
+        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+      ],
+      replaceState: [
+        "replaceState",
+        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+      ]
+    };
+    for (fnName in deprecatedAPIs)
+      deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+    ComponentDummy.prototype = Component.prototype;
+    deprecatedAPIs = PureComponent.prototype = new ComponentDummy;
+    deprecatedAPIs.constructor = PureComponent;
+    assign(deprecatedAPIs, Component.prototype);
+    deprecatedAPIs.isPureReactComponent = true;
+    var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
+      H: null,
+      A: null,
+      T: null,
+      S: null,
+      actQueue: null,
+      asyncTransitions: 0,
+      isBatchingLegacy: false,
+      didScheduleLegacyUpdate: false,
+      didUsePromise: false,
+      thrownErrors: [],
+      getCurrentStack: null,
+      recentlyCreatedOwnerStacks: 0
+    }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    deprecatedAPIs = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = typeof reportError === "function" ? reportError : function(error) {
+      if (typeof window === "object" && typeof window.ErrorEvent === "function") {
+        var event = new window.ErrorEvent("error", {
+          bubbles: true,
+          cancelable: true,
+          message: typeof error === "object" && error !== null && typeof error.message === "string" ? String(error.message) : String(error),
+          error
+        });
+        if (!window.dispatchEvent(event))
+          return;
+      } else if (typeof process === "object" && typeof process.emit === "function") {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      console.error(error);
+    }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = typeof queueMicrotask === "function" ? function(callback) {
+      queueMicrotask(function() {
+        return queueMicrotask(callback);
+      });
+    } : enqueueTask;
+    deprecatedAPIs = Object.freeze({
+      __proto__: null,
+      c: function(size) {
+        return resolveDispatcher().useMemoCache(size);
+      }
+    });
+    var fnName = {
+      map: mapChildren,
+      forEach: function(children, forEachFunc, forEachContext) {
+        mapChildren(children, function() {
+          forEachFunc.apply(this, arguments);
+        }, forEachContext);
+      },
+      count: function(children) {
+        var n = 0;
+        mapChildren(children, function() {
+          n++;
+        });
+        return n;
+      },
+      toArray: function(children) {
+        return mapChildren(children, function(child) {
+          return child;
+        }) || [];
+      },
+      only: function(children) {
+        if (!isValidElement(children))
+          throw Error("React.Children.only expected to receive a single React element child.");
+        return children;
+      }
+    };
+    exports.Activity = REACT_ACTIVITY_TYPE;
+    exports.Children = fnName;
+    exports.Component = Component;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.PureComponent = PureComponent;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = deprecatedAPIs;
+    exports.act = function(callback) {
+      var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
+      actScopeDepth++;
+      var queue = ReactSharedInternals.actQueue = prevActQueue !== null ? prevActQueue : [], didAwaitActCall = false;
+      try {
+        var result = callback();
+      } catch (error) {
+        ReactSharedInternals.thrownErrors.push(error);
+      }
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      if (result !== null && typeof result === "object" && typeof result.then === "function") {
+        var thenable = result;
+        queueSeveralMicrotasks(function() {
+          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+        });
+        return {
+          then: function(resolve, reject) {
+            didAwaitActCall = true;
+            thenable.then(function(returnValue) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              if (prevActScopeDepth === 0) {
+                try {
+                  flushActQueue(queue), enqueueTask(function() {
+                    return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                  });
+                } catch (error$0) {
+                  ReactSharedInternals.thrownErrors.push(error$0);
+                }
+                if (0 < ReactSharedInternals.thrownErrors.length) {
+                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+                  ReactSharedInternals.thrownErrors.length = 0;
+                  reject(_thrownError);
+                }
+              } else
+                resolve(returnValue);
+            }, function(error) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+            });
+          }
+        };
+      }
+      var returnValue$jscomp$0 = result;
+      popActScope(prevActQueue, prevActScopeDepth);
+      prevActScopeDepth === 0 && (flushActQueue(queue), queue.length !== 0 && queueSeveralMicrotasks(function() {
+        didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
+      }), ReactSharedInternals.actQueue = null);
+      if (0 < ReactSharedInternals.thrownErrors.length)
+        throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      return {
+        then: function(resolve, reject) {
+          didAwaitActCall = true;
+          prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
+          })) : resolve(returnValue$jscomp$0);
+        }
+      };
+    };
+    exports.cache = function(fn) {
+      return function() {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.cacheSignal = function() {
+      return null;
+    };
+    exports.captureOwnerStack = function() {
+      var getCurrentStack = ReactSharedInternals.getCurrentStack;
+      return getCurrentStack === null ? null : getCurrentStack();
+    };
+    exports.cloneElement = function(element, config, children) {
+      if (element === null || element === undefined)
+        throw Error("The argument must be a React element, but you passed " + element + ".");
+      var props = assign({}, element.props), key = element.key, owner = element._owner;
+      if (config != null) {
+        var JSCompiler_inline_result;
+        a: {
+          if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) {
+            JSCompiler_inline_result = false;
+            break a;
+          }
+          JSCompiler_inline_result = config.ref !== undefined;
+        }
+        JSCompiler_inline_result && (owner = getOwner());
+        hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+        for (propName in config)
+          !hasOwnProperty.call(config, propName) || propName === "key" || propName === "__self" || propName === "__source" || propName === "ref" && config.ref === undefined || (props[propName] = config[propName]);
+      }
+      var propName = arguments.length - 2;
+      if (propName === 1)
+        props.children = children;
+      else if (1 < propName) {
+        JSCompiler_inline_result = Array(propName);
+        for (var i = 0;i < propName; i++)
+          JSCompiler_inline_result[i] = arguments[i + 2];
+        props.children = JSCompiler_inline_result;
+      }
+      props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask);
+      for (key = 2;key < arguments.length; key++)
+        validateChildKeys(arguments[key]);
+      return props;
+    };
+    exports.createContext = function(defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      defaultValue._currentRenderer = null;
+      defaultValue._currentRenderer2 = null;
+      return defaultValue;
+    };
+    exports.createElement = function(type, config, children) {
+      for (var i = 2;i < arguments.length; i++)
+        validateChildKeys(arguments[i]);
+      i = {};
+      var key = null;
+      if (config != null)
+        for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
+          hasOwnProperty.call(config, propName) && propName !== "key" && propName !== "__self" && propName !== "__source" && (i[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (childrenLength === 1)
+        i.children = children;
+      else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), _i = 0;_i < childrenLength; _i++)
+          childArray[_i] = arguments[_i + 2];
+        Object.freeze && Object.freeze(childArray);
+        i.children = childArray;
+      }
+      if (type && type.defaultProps)
+        for (propName in childrenLength = type.defaultProps, childrenLength)
+          i[propName] === undefined && (i[propName] = childrenLength[propName]);
+      key && defineKeyPropWarningGetter(i, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
+      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    exports.createRef = function() {
+      var refObject = { current: null };
+      Object.seal(refObject);
+      return refObject;
+    };
+    exports.forwardRef = function(render) {
+      render != null && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof render !== "function" ? console.error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render) : render.length !== 0 && render.length !== 2 && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+      render != null && render.defaultProps != null && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
+      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
+      Object.defineProperty(elementType, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+        }
+      });
+      return elementType;
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function(ctor) {
+      ctor = { _status: -1, _result: ctor };
+      var lazyType = {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: ctor,
+        _init: lazyInitializer
+      }, ioInfo = {
+        name: "lazy",
+        start: -1,
+        end: -1,
+        value: null,
+        owner: null,
+        debugStack: Error("react-stack-top-frame"),
+        debugTask: console.createTask ? console.createTask("lazy()") : null
+      };
+      ctor._ioInfo = ioInfo;
+      lazyType._debugInfo = [{ awaited: ioInfo }];
+      return lazyType;
+    };
+    exports.memo = function(type, compare) {
+      type == null && console.error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
+      compare = {
+        $$typeof: REACT_MEMO_TYPE,
+        type,
+        compare: compare === undefined ? null : compare
+      };
+      var ownName;
+      Object.defineProperty(compare, "displayName", {
+        enumerable: false,
+        configurable: true,
+        get: function() {
+          return ownName;
+        },
+        set: function(name) {
+          ownName = name;
+          type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+        }
+      });
+      return compare;
+    };
+    exports.startTransition = function(scope) {
+      var prevTransition = ReactSharedInternals.T, currentTransition = {};
+      currentTransition._updatedFibers = new Set;
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+        onStartTransitionFinish !== null && onStartTransitionFinish(currentTransition, returnValue);
+        typeof returnValue === "object" && returnValue !== null && typeof returnValue.then === "function" && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        prevTransition === null && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), prevTransition !== null && currentTransition.types !== null && (prevTransition.types !== null && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function() {
+      return resolveDispatcher().useCacheRefresh();
+    };
+    exports.use = function(usable) {
+      return resolveDispatcher().use(usable);
+    };
+    exports.useActionState = function(action, initialState, permalink) {
+      return resolveDispatcher().useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function(callback, deps) {
+      return resolveDispatcher().useCallback(callback, deps);
+    };
+    exports.useContext = function(Context) {
+      var dispatcher = resolveDispatcher();
+      Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
+      return dispatcher.useContext(Context);
+    };
+    exports.useDebugValue = function(value, formatterFn) {
+      return resolveDispatcher().useDebugValue(value, formatterFn);
+    };
+    exports.useDeferredValue = function(value, initialValue) {
+      return resolveDispatcher().useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function(create, deps) {
+      create == null && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useEffect(create, deps);
+    };
+    exports.useEffectEvent = function(callback) {
+      return resolveDispatcher().useEffectEvent(callback);
+    };
+    exports.useId = function() {
+      return resolveDispatcher().useId();
+    };
+    exports.useImperativeHandle = function(ref, create, deps) {
+      return resolveDispatcher().useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function(create, deps) {
+      create == null && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function(create, deps) {
+      create == null && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function(create, deps) {
+      return resolveDispatcher().useMemo(create, deps);
+    };
+    exports.useOptimistic = function(passthrough, reducer) {
+      return resolveDispatcher().useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function(reducer, initialArg, init) {
+      return resolveDispatcher().useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function(initialValue) {
+      return resolveDispatcher().useRef(initialValue);
+    };
+    exports.useState = function(initialState) {
+      return resolveDispatcher().useState(initialState);
+    };
+    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    };
+    exports.useTransition = function() {
+      return resolveDispatcher().useTransition();
+    };
+    exports.version = "19.2.7";
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })();
+});
+
+// ../../node_modules/.bun/react@19.2.7/node_modules/react/index.js
+var require_react = __commonJS((exports, module) => {
+  if (false) {} else {
+    module.exports = require_react_development();
+  }
+});
+
+// ../../node_modules/.bun/react@19.2.7/node_modules/react/cjs/react-jsx-dev-runtime.development.js
+var require_react_jsx_dev_runtime_development = __commonJS((exports) => {
+  var React2 = __toESM(require_react());
+  (function() {
+    function getComponentNameFromType(type) {
+      if (type == null)
+        return null;
+      if (typeof type === "function")
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if (typeof type === "string")
+        return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if (typeof type === "object")
+        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {}
+        }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE)
+        return "<>";
+      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return dispatcher === null ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning)
+          return false;
+      }
+      return config.key !== undefined;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return componentName !== undefined ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+      var children = config.children;
+      if (children !== undefined)
+        if (isStaticChildren)
+          if (isArrayImpl(children)) {
+            for (isStaticChildren = 0;isStaticChildren < children.length; isStaticChildren++)
+              validateChildKeys(children[isStaticChildren]);
+            Object.freeze && Object.freeze(children);
+          } else
+            console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+        else
+          validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return k !== "key";
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      maybeKey !== undefined && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          propName !== "key" && (maybeKey[propName] = config[propName]);
+      } else
+        maybeKey = config;
+      children && defineKeyPropWarningGetter(maybeKey, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
+      return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React2.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    React2 = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React2.react_stack_bottom_frame.bind(React2, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.jsxDEV = function(type, config, maybeKey, isStaticChildren) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, isStaticChildren, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+  })();
+});
+
+// ../../node_modules/.bun/react@19.2.7/node_modules/react/jsx-dev-runtime.js
+var require_jsx_dev_runtime = __commonJS((exports, module) => {
+  if (false) {} else {
+    module.exports = require_react_jsx_dev_runtime_development();
+  }
+});
+
+// src/auto-import/generator.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/auto-import/scanner.ts
+import { existsSync, readdirSync } from "fs";
+import { basename, extname, join, relative } from "path";
+var DEFAULT_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx"
+];
+function detectKind(filePath) {
+  const lower = filePath.replace(/\\/g, "/").toLowerCase();
+  if (lower.includes("/stores/") || lower.endsWith(".store.ts") || lower.endsWith(".store.tsx")) {
+    return "store";
+  }
+  if (lower.includes("/schemas/") || lower.endsWith(".schema.ts") || lower.endsWith(".schema.tsx")) {
+    return "schema";
+  }
+  if (lower.includes("/components/")) {
+    return "component";
+  }
+  const fileName = basename(lower);
+  if (fileName.startsWith("use")) {
+    return "hook";
+  }
+  if (lower.includes("/lib/") || lower.includes("/utils/") || lower.includes("/helpers/")) {
+    return "utils";
+  }
+  return "unknown";
+}
+function toPascalCase(text) {
+  return text.replace(/[-_.]/g, " ").replace(/\s+(.)/g, (_match, char) => char.toUpperCase()).replace(/^(.)/, (_match, char) => char.toUpperCase());
+}
+function deriveExportName(filePath, dirPath) {
+  const relativePath = relative(dirPath, filePath).replace(/\\/g, "/");
+  const withoutExtension = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "").replace(/\/index$/, "");
+  return toPascalCase(withoutExtension.replace(/\//g, "_"));
+}
+function walkDirectory(dirPath, extensions) {
+  if (!existsSync(dirPath)) {
+    return [];
+  }
+  const collected = [];
+  function walk(currentPath) {
+    const entries = readdirSync(currentPath, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const fullPath = join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      if (entry.isFile() && extensions.includes(extname(entry.name))) {
+        collected.push(fullPath);
+      }
+    }
+  }
+  walk(dirPath);
+  return collected;
+}
+function scanForExports(options) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const discovered = [];
+  const outputAbs = join(options.frontendRoot, options.outputDirectory);
+  for (const directory of options.directories) {
+    const directoryAbs = join(options.frontendRoot, directory);
+    const files = walkDirectory(directoryAbs, extensions);
+    for (const filePath of files) {
+      const relativeFromOutput = relative(outputAbs, filePath).replace(/\\/g, "/").replace(/\.(ts|tsx)$/, "");
+      const importPath = relativeFromOutput.startsWith(".") ? relativeFromOutput : `./${relativeFromOutput}`;
+      discovered.push({
+        name: deriveExportName(filePath, directoryAbs),
+        filePath: relative(options.frontendRoot, filePath).replace(/\\/g, "/"),
+        importPath,
+        kind: detectKind(filePath)
+      });
+    }
+  }
+  return discovered;
+}
+
+// src/auto-import/generator.ts
+var GENERATED_HEADER = `// This file is auto-generated by: bun rakta imports:generate
+// Do not edit manually. Re-generate whenever you add or remove files.
+// Note: Rakta Auto Import v0.1.0 produces a typed re-export layer.
+// Import from this file in your app code:
+//   import { useCounterStore, http } from "./.rakta/auto-imports";
+`;
+function buildImportLines(exports) {
+  if (exports.length === 0) {
+    return `// No exports discovered. Check your autoImport.directories config.
+`;
+  }
+  return exports.map((discoveredExport) => `export * from "${discoveredExport.importPath}";`).join(`
+`);
+}
+function generateAutoImports(options) {
+  const exports = scanForExports({
+    frontendRoot: options.frontendRoot,
+    directories: options.directories,
+    outputDirectory: options.outputDirectory,
+    ...options.extensions ? {
+      extensions: options.extensions
+    } : {}
+  });
+  const outputDir = join2(options.frontendRoot, options.outputDirectory);
+  mkdirSync(outputDir, {
+    recursive: true
+  });
+  const tsContent = `${GENERATED_HEADER}
+${buildImportLines(exports)}
+`;
+  writeFileSync(join2(outputDir, "auto-imports.ts"), tsContent, "utf-8");
+  if (options.generateDts) {
+    const dtsContent = tsContent.replace("// This file is auto-generated by: bun rakta imports:generate", "// Type declarations \u2014 auto-generated by: bun rakta imports:generate");
+    writeFileSync(join2(outputDir, "auto-imports.d.ts"), dtsContent, "utf-8");
+  }
+  return {
+    generatedAt: new Date().toISOString(),
+    sourceDirectories: options.directories,
+    exports
+  };
+}
+function printAutoImportSummary(manifest) {
+  console.log(`
+  Rakta Auto Import`);
+  console.log(`  ${"\u2500".repeat(50)}`);
+  console.log(`Generated: ${manifest.generatedAt}`);
+  console.log(`Exports:   ${manifest.exports.length}`);
+  if (manifest.exports.length > 0) {
+    console.log("");
+    for (const discoveredExport of manifest.exports) {
+      console.log(`[${discoveredExport.kind.padEnd(10)}] ${discoveredExport.name}  <-  ${discoveredExport.filePath}`);
+    }
+  }
+  console.log(`  ${"\u2500".repeat(50)}
+`);
+}
+// src/components/Click.tsx
+var import_react = __toESM(require_react(), 1);
+function isModifiedEvent(event) {
+  return event.metaKey || event.altKey || event.ctrlKey || event.shiftKey;
+}
+function isExternalTo(to) {
+  return to.startsWith("http://") || to.startsWith("https://") || to.startsWith("//") || to.startsWith("mailto:") || to.startsWith("tel:");
+}
+function getCurrentPathname() {
+  if (typeof window === "undefined") {
+    return "/";
+  }
+  return window.location.pathname;
+}
+function getCleanPathname(to) {
+  const [pathname] = to.split(/[?#]/);
+  if (pathname && pathname.length > 0) {
+    return pathname;
+  }
+  return "/";
+}
+function getPathnameFromTo(to) {
+  const cleanPathname = getCleanPathname(to);
+  if (typeof window === "undefined") {
+    return cleanPathname;
+  }
+  try {
+    return new URL(to, window.location.origin).pathname;
+  } catch {
+    return cleanPathname;
+  }
+}
+function createNavigationState(to) {
+  return {
+    source: "rakta-click",
+    to
+  };
+}
+function navigate(to, shouldReplace) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const navigationState = createNavigationState(to);
+  if (shouldReplace) {
+    window.history.replaceState(navigationState, "", to);
+  } else {
+    window.history.pushState(navigationState, "", to);
+  }
+  window.dispatchEvent(new PopStateEvent("popstate", {
+    state: navigationState
+  }));
+}
+function openExternalTo(to, target) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (target === "_blank") {
+    window.open(to, "_blank", "noopener,noreferrer");
+    return;
+  }
+  window.location.assign(to);
+}
+function prefetchPage(to) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return;
+  }
+  const targetUrl = new URL(to, window.location.origin).href;
+  const existingLinks = Array.from(document.querySelectorAll('link[rel="prefetch"]'));
+  const alreadyPrefetched = existingLinks.some((link2) => link2.href === targetUrl);
+  if (alreadyPrefetched) {
+    return;
+  }
+  const link = document.createElement("link");
+  link.rel = "prefetch";
+  link.href = targetUrl;
+  link.as = "document";
+  document.head.appendChild(link);
+}
+function mergeClassNames(className, activeClassName, isActive) {
+  const classNames = [];
+  if (className && className.length > 0) {
+    classNames.push(className);
+  }
+  if (isActive && activeClassName && activeClassName.length > 0) {
+    classNames.push(activeClassName);
+  }
+  return classNames.join(" ");
+}
+function applyClassName(clickAttributes, className) {
+  if (className.length === 0) {
+    return;
+  }
+  clickAttributes.className = className;
+}
+function applyStyle(clickAttributes, style) {
+  if (!style) {
+    return;
+  }
+  clickAttributes.style = style;
+}
+function applyInternalAttributes(clickAttributes, target, rel, isActive) {
+  if (target) {
+    clickAttributes.target = target;
+  }
+  if (rel && rel.length > 0) {
+    clickAttributes.rel = rel;
+  }
+  if (isActive) {
+    clickAttributes["aria-current"] = "page";
+  }
+}
+function applyExternalAttributes(clickAttributes, target, rel) {
+  clickAttributes.target = target ?? "_blank";
+  clickAttributes.rel = rel && rel.length > 0 ? rel : "noopener noreferrer";
+}
+function renderClickElement(attributes, children) {
+  return import_react.default.createElement("click", attributes, children);
+}
+function Click({
+  to,
+  prefetch = false,
+  replace = false,
+  activeClassName,
+  className,
+  children,
+  onClick,
+  onKeyDown,
+  style,
+  target,
+  rel,
+  ...restAttributes
+}) {
+  const isExternal = isExternalTo(to);
+  const isActive = !isExternal && getCurrentPathname() === getPathnameFromTo(to);
+  const resolvedClassName = mergeClassNames(className, activeClassName, isActive);
+  import_react.useEffect(() => {
+    if (!prefetch || isExternal) {
+      return;
+    }
+    prefetchPage(to);
+  }, [prefetch, isExternal, to]);
+  const handleClick = import_react.useCallback((event) => {
+    onClick?.(event);
+    if (event.defaultPrevented || isModifiedEvent(event)) {
+      return;
+    }
+    if (isExternal) {
+      event.preventDefault();
+      openExternalTo(to, target ?? "_blank");
+      return;
+    }
+    if (target === "_blank") {
+      return;
+    }
+    event.preventDefault();
+    navigate(to, replace);
+  }, [isExternal, onClick, replace, target, to]);
+  const handleKeyDown = import_react.useCallback((event) => {
+    onKeyDown?.(event);
+    if (event.defaultPrevented || event.key !== "Enter") {
+      return;
+    }
+    if (isExternal) {
+      event.preventDefault();
+      openExternalTo(to, target ?? "_blank");
+      return;
+    }
+    if (target === "_blank") {
+      return;
+    }
+    event.preventDefault();
+    navigate(to, replace);
+  }, [isExternal, onKeyDown, replace, target, to]);
+  const clickAttributes = {
+    ...restAttributes,
+    to,
+    onClick: handleClick,
+    onKeyDown: handleKeyDown
+  };
+  applyClassName(clickAttributes, resolvedClassName);
+  applyStyle(clickAttributes, style);
+  if (isExternal) {
+    applyExternalAttributes(clickAttributes, target, rel);
+  } else {
+    applyInternalAttributes(clickAttributes, target, rel, isActive);
+  }
+  return renderClickElement(clickAttributes, children);
+}
+// src/components/Picture.tsx
+var import_react2 = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function Picture({
+  path,
+  alt,
+  title,
+  height,
+  width,
+  blurDataURL,
+  onLoadComplete,
+  onError,
+  className,
+  style,
+  loading = "lazy",
+  responsive = true,
+  objectFit = "cover",
+  priority = false,
+  ...rest
+}) {
+  const [isLoaded, setIsLoaded] = import_react2.useState(false);
+  const [hasError, setHasError] = import_react2.useState(false);
+  const imageRef = import_react2.useRef(null);
+  const pictureRef = import_react2.useRef(null);
+  const resolvedLoading = priority ? "eager" : loading === "auto" ? "lazy" : loading;
+  import_react2.useEffect(() => {
+    const imageElement = imageRef.current;
+    if (imageElement?.complete) {
+      setIsLoaded(true);
+      onLoadComplete?.();
+    }
+  }, [onLoadComplete]);
+  const handleLoad = import_react2.useCallback(() => {
+    setIsLoaded(true);
+    onLoadComplete?.();
+  }, [onLoadComplete]);
+  const handleError = import_react2.useCallback(() => {
+    setHasError(true);
+    onError?.();
+  }, [onError]);
+  const resolvedPath = hasError && blurDataURL ? blurDataURL : path;
+  const resolvedWidth = responsive ? "100%" : width ?? "auto";
+  const wrapperStyle = {
+    position: "relative",
+    display: "inline-block",
+    overflow: "hidden",
+    height: height ?? "auto",
+    width: resolvedWidth
+  };
+  const imageStyle = {
+    display: "block",
+    height: height ?? undefined,
+    width: resolvedWidth,
+    minHeight: height ?? undefined,
+    objectFit,
+    transition: blurDataURL ? "filter 0.3s ease" : undefined,
+    filter: blurDataURL && !isLoaded && !hasError ? "blur(12px) brightness(1.05)" : "none",
+    ...style
+  };
+  if (blurDataURL) {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("div", {
+      style: {
+        ...wrapperStyle,
+        backgroundImage: `url(${blurDataURL})`,
+        backgroundSize: "cover",
+        backgroundPosition: "center"
+      },
+      children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV("picture", {
+        ref: pictureRef,
+        className,
+        ...rest,
+        children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV("img", {
+          ref: imageRef,
+          src: resolvedPath,
+          alt,
+          "aria-label": alt,
+          title,
+          loading: resolvedLoading,
+          decoding: priority ? "sync" : "async",
+          style: imageStyle,
+          onLoad: handleLoad,
+          onError: handleError
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("picture", {
+    ref: pictureRef,
+    className,
+    ...rest,
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV("img", {
+      ref: imageRef,
+      src: resolvedPath,
+      alt,
+      "aria-label": alt,
+      title,
+      loading: resolvedLoading,
+      decoding: priority ? "sync" : "async",
+      style: imageStyle,
+      onLoad: handleLoad,
+      onError: handleError
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+// src/config/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+var defineRaktaConfig = defineConfig;
+var defaultConfig = {
+  appName: "Rakta.js App",
+  appDir: "app",
+  publicDir: "public",
+  port: 3000,
+  css: {
+    framework: "tailwind"
+  },
+  seo: {
+    defaultTitle: "Rakta.js App",
+    titleTemplate: "%s | Rakta.js App",
+    defaultDescription: "Built with Rakta.js",
+    siteUrl: "http://localhost:3000"
+  },
+  server: {
+    port: 3000,
+    hostname: "0.0.0.0",
+    cors: true,
+    compression: false,
+    trustProxy: false
+  },
+  build: {
+    entryPoint: "entry.client.tsx",
+    outDir: "dist",
+    sourcemap: false,
+    minify: true,
+    splitting: false,
+    target: "browser"
+  },
+  autoImport: {
+    enabled: false,
+    directories: ["components", "lib", "stores", "schemas"],
+    outputDirectory: ".rakta",
+    extensions: [".ts", ".tsx", ".js", ".jsx"],
+    dts: true
+  },
+  rpc: {
+    enabled: false,
+    basePath: "/rpc",
+    maxBodySize: 1048576
+  },
+  render: {
+    defaultMode: "csr",
+    routes: {}
+  }
+};
+// src/config/loadConfig.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join3, resolve } from "path";
+var CONFIG_FILENAMES = [
+  "rakta.config.ts",
+  "rakta.config.js",
+  "rakta.config.mts",
+  "rakta.config.mjs"
+];
+async function loadConfig(cwd = process.cwd()) {
+  const resolvedCwd = resolve(cwd);
+  for (const filename of CONFIG_FILENAMES) {
+    const configPath = join3(resolvedCwd, filename);
+    if (!existsSync2(configPath)) {
+      continue;
+    }
+    const configModule = await import(configPath);
+    const userConfig = configModule.default ?? {};
+    return mergeConfig(defaultConfig, userConfig);
+  }
+  return defaultConfig;
+}
+function mergeConfig(baseConfig, overrideConfig) {
+  return {
+    appName: overrideConfig.appName ?? baseConfig.appName,
+    appDir: overrideConfig.appDir ?? baseConfig.appDir,
+    publicDir: overrideConfig.publicDir ?? baseConfig.publicDir,
+    port: overrideConfig.port ?? baseConfig.port,
+    css: overrideConfig.css !== undefined ? { ...baseConfig.css, ...overrideConfig.css } : baseConfig.css,
+    seo: overrideConfig.seo !== undefined ? { ...baseConfig.seo, ...overrideConfig.seo } : baseConfig.seo,
+    server: overrideConfig.server !== undefined ? { ...baseConfig.server, ...overrideConfig.server } : baseConfig.server,
+    build: overrideConfig.build !== undefined ? { ...baseConfig.build, ...overrideConfig.build } : baseConfig.build,
+    autoImport: overrideConfig.autoImport !== undefined ? { ...baseConfig.autoImport, ...overrideConfig.autoImport } : baseConfig.autoImport,
+    rpc: overrideConfig.rpc !== undefined ? { ...baseConfig.rpc, ...overrideConfig.rpc } : baseConfig.rpc,
+    render: overrideConfig.render !== undefined ? {
+      defaultMode: overrideConfig.render.defaultMode ?? baseConfig.render.defaultMode,
+      routes: {
+        ...baseConfig.render.routes,
+        ...overrideConfig.render.routes
+      }
+    } : baseConfig.render
+  };
+}
+// src/forge/build.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, resolve as resolve2 } from "path";
+
+// src/router/manifest.ts
+import { existsSync as existsSync4, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+
+// src/router/scanner.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join4, relative as relative2 } from "path";
+var FILE_TO_KIND = {
+  "page.tsx": "page",
+  "page.ts": "page",
+  "page.jsx": "page",
+  "page.js": "page",
+  "layout.tsx": "layout",
+  "layout.ts": "layout",
+  "layout.jsx": "layout",
+  "layout.js": "layout",
+  "loading.tsx": "loading",
+  "loading.ts": "loading",
+  "loading.jsx": "loading",
+  "loading.js": "loading",
+  "notFound.tsx": "notFound",
+  "notFound.ts": "notFound",
+  "notFound.jsx": "notFound",
+  "notFound.js": "notFound",
+  "error.tsx": "error",
+  "error.ts": "error",
+  "error.jsx": "error",
+  "error.js": "error",
+  "route.ts": "api",
+  "route.js": "api"
+};
+function parseSegment(raw) {
+  const isDynamic = raw.startsWith("[") && raw.endsWith("]");
+  const paramName = isDynamic ? raw.slice(1, -1) : "";
+  return { raw, isDynamic, paramName };
+}
+function collectParamNames(segments) {
+  return segments.filter((segment) => segment.isDynamic && segment.paramName.length > 0).map((segment) => segment.paramName);
+}
+function segmentsToUrlPattern(segments) {
+  if (segments.length === 0)
+    return "/";
+  const parts = segments.map((segment) => segment.isDynamic && segment.paramName ? `:${segment.paramName}` : segment.raw);
+  return `/${parts.join("/")}`;
+}
+function scanDirectory(dirPath, appRoot, results) {
+  if (!existsSync3(dirPath))
+    return;
+  const entries = readdirSync2(dirPath);
+  for (const entryName of entries) {
+    const fullPath = join4(dirPath, entryName);
+    const stats = statSync(fullPath);
+    if (stats.isDirectory()) {
+      scanDirectory(fullPath, appRoot, results);
+      continue;
+    }
+    if (!stats.isFile())
+      continue;
+    const kind = FILE_TO_KIND[entryName];
+    if (!kind)
+      continue;
+    const relativePath = relative2(appRoot, fullPath).replace(/\\/g, "/");
+    const dirRelative = relative2(appRoot, dirPath).replace(/\\/g, "/");
+    const rawSegments = dirRelative === "" ? [] : dirRelative.split("/");
+    const segments = rawSegments.map(parseSegment);
+    const urlPattern = segmentsToUrlPattern(segments);
+    const paramNames = collectParamNames(segments);
+    const isDynamic = paramNames.length > 0;
+    results.push({
+      filePath: relativePath,
+      urlPattern,
+      kind,
+      segments,
+      isDynamic,
+      paramNames
+    });
+  }
+}
+function scanRoutes(options) {
+  const results = [];
+  scanDirectory(options.appDir, options.appDir, results);
+  results.sort((routeA, routeB) => {
+    if (routeA.isDynamic !== routeB.isDynamic) {
+      return routeA.isDynamic ? 1 : -1;
+    }
+    return routeA.urlPattern.localeCompare(routeB.urlPattern);
+  });
+  return results;
+}
+
+// src/router/manifest.ts
+function generateManifest(appDir) {
+  const routes = scanRoutes({ appDir });
+  const manifest = {
+    version: "1",
+    generatedAt: new Date().toISOString(),
+    routes
+  };
+  return manifest;
+}
+function writeManifest(manifest, outputPath) {
+  writeFileSync2(outputPath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+function readManifest(manifestPath) {
+  if (!existsSync4(manifestPath))
+    return null;
+  const raw = readFileSync(manifestPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || !("routes" in parsed)) {
+    return null;
+  }
+  return parsed;
+}
+function printManifest(manifest) {
+  const pageRoutes = manifest.routes.filter((route) => route.kind === "page");
+  const apiRoutes = manifest.routes.filter((route) => route.kind === "api");
+  const layoutRoutes = manifest.routes.filter((route) => route.kind === "layout");
+  const specialRoutes = manifest.routes.filter((route) => ["loading", "not-found", "error"].includes(route.kind));
+  const line = "\u2500".repeat(56);
+  console.log(`
+  Rakta.js Route Manifest`);
+  console.log(`  ${line}`);
+  console.log(`  Generated: ${manifest.generatedAt}`);
+  console.log(`  Total:     ${manifest.routes.length} routes
+`);
+  if (pageRoutes.length > 0) {
+    console.log("  Pages:");
+    for (const route of pageRoutes) {
+      const dynamic = route.isDynamic ? `  [params: ${route.paramNames.join(", ")}]` : "";
+      console.log(`    GET  ${route.urlPattern}${dynamic}`);
+    }
+    console.log("");
+  }
+  if (apiRoutes.length > 0) {
+    console.log("  API Routes:");
+    for (const route of apiRoutes) {
+      const dynamic = route.isDynamic ? `  [params: ${route.paramNames.join(", ")}]` : "";
+      console.log(`    ANY  ${route.urlPattern}${dynamic}`);
+    }
+    console.log("");
+  }
+  if (layoutRoutes.length > 0) {
+    console.log("  Layouts:");
+    for (const route of layoutRoutes) {
+      console.log(`    ${route.urlPattern === "/" ? "root" : route.urlPattern}`);
+    }
+    console.log("");
+  }
+  if (specialRoutes.length > 0) {
+    console.log("  Special:");
+    for (const route of specialRoutes) {
+      console.log(`    [${route.kind}]  ${route.filePath}`);
+    }
+    console.log("");
+  }
+  console.log(`  ${line}
+`);
+}
+
+// src/forge/build.ts
+async function buildProject(options) {
+  const startMs = Date.now();
+  const artifacts = [];
+  const errors = [];
+  mkdirSync2(resolve2(options.outDir), { recursive: true });
+  const manifest = generateManifest(options.appDir);
+  const manifestPath = join5(options.outDir, "route-manifest.json");
+  writeManifest(manifest, manifestPath);
+  const manifestContent = JSON.stringify(manifest);
+  artifacts.push({
+    outputPath: manifestPath,
+    sizeBytes: new TextEncoder().encode(manifestContent).byteLength,
+    kind: "manifest"
+  });
+  const buildResult = await Bun.build({
+    entrypoints: [options.entryPoint],
+    outdir: options.outDir,
+    target: options.target,
+    minify: options.minify,
+    sourcemap: options.sourcemap ? "external" : "none",
+    splitting: options.splitting,
+    naming: {
+      entry: "[name].[ext]",
+      chunk: "chunks/[name]-[hash].[ext]",
+      asset: "assets/[name]-[hash].[ext]"
+    }
+  });
+  if (!buildResult.success) {
+    for (const log of buildResult.logs) {
+      errors.push(log.message);
+    }
+    return {
+      success: false,
+      artifacts,
+      manifest,
+      buildMs: Date.now() - startMs,
+      errors
+    };
+  }
+  for (const output of buildResult.outputs) {
+    artifacts.push({
+      outputPath: output.path,
+      sizeBytes: output.size,
+      kind: output.path.endsWith(".css") ? "stylesheet" : "script"
+    });
+  }
+  return {
+    success: true,
+    artifacts,
+    manifest,
+    buildMs: Date.now() - startMs,
+    errors: []
+  };
+}
+// src/forge/devServer.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
+
+// src/render/modes.ts
+var RENDER_MODE_DESCRIPTORS = {
+  csr: {
+    mode: "csr",
+    label: "Client-Side Rendering",
+    shortLabel: "CSR",
+    description: "React renders entirely in the browser. The server sends a minimal HTML shell with a JS bundle. No server required at runtime.",
+    serverRequired: false,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: false
+  },
+  ssr: {
+    mode: "ssr",
+    label: "Server-Side Rendering",
+    shortLabel: "SSR",
+    description: "React renders to HTML on the server per request. The client receives full HTML and then hydrates. Requires a running Node/Bun server.",
+    serverRequired: true,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: true
+  },
+  ssg: {
+    mode: "ssg",
+    label: "Static Site Generation",
+    shortLabel: "SSG",
+    description: "Pages are fully rendered at build time. Output is static HTML files. No server required at runtime.",
+    serverRequired: false,
+    buildTimeGenerated: true,
+    clientHydration: false,
+    roadmap: true
+  },
+  csg: {
+    mode: "csg",
+    label: "Client-Side Generation",
+    shortLabel: "CSG",
+    description: "A static shell is generated at build time, data is fetched and rendered on the client. Combines SSG speed with dynamic data.",
+    serverRequired: false,
+    buildTimeGenerated: true,
+    clientHydration: true,
+    roadmap: true
+  },
+  spa: {
+    mode: "spa",
+    label: "Single Page Application",
+    shortLabel: "SPA",
+    description: "A single HTML entry point is served for all routes. React handles all routing client-side. Equivalent to a standard Vite SPA.",
+    serverRequired: false,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: false
+  },
+  hybrid: {
+    mode: "hybrid",
+    label: "Hybrid Rendering",
+    shortLabel: "Hybrid",
+    description: "Different routes use different render modes. Configured via the `render.routes` map in rakta.config.ts. The top-level mode is the fallback.",
+    serverRequired: false,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: false
+  }
+};
+function pathMatchesPattern(pathname, pattern) {
+  if (pattern === pathname)
+    return true;
+  const patternParts = pattern.split("/");
+  const pathParts = pathname.split("/");
+  if (patternParts.length !== pathParts.length)
+    return false;
+  for (let i = 0;i < patternParts.length; i++) {
+    const pp = patternParts[i];
+    const path = pathParts[i];
+    if (pp === undefined || path === undefined)
+      return false;
+    if (pp.startsWith(":"))
+      continue;
+    if (pp !== path)
+      return false;
+  }
+  return true;
+}
+function resolveRouteMode(pathname, config) {
+  const patterns = Object.keys(config.routes).sort((a, b) => b.length - a.length);
+  for (const pattern of patterns) {
+    const overrideMode = config.routes[pattern];
+    if (overrideMode !== undefined && pathMatchesPattern(pathname, pattern)) {
+      return {
+        routePath: pathname,
+        mode: overrideMode,
+        source: "route-override"
+      };
+    }
+  }
+  return {
+    routePath: pathname,
+    mode: config.defaultMode,
+    source: "default"
+  };
+}
+function getModeDescriptor(mode) {
+  return RENDER_MODE_DESCRIPTORS[mode];
+}
+function isRoadmapMode(mode) {
+  return RENDER_MODE_DESCRIPTORS[mode].roadmap;
+}
+function requiresServer(mode) {
+  return RENDER_MODE_DESCRIPTORS[mode].serverRequired;
+}
+function isBuildTimeMode(mode) {
+  return RENDER_MODE_DESCRIPTORS[mode].buildTimeGenerated;
+}
+
+// src/render/renderer.ts
+function buildHtmlShell(options) {
+  return `
+  <!DOCTYPE html>
+    <html lang="${options.lang}">
+        <head>
+            <meta charset="UTF-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+            <title>
+                ${options.appName}
+            </title>
+            <link rel="stylesheet" href="${options.cssPath}" />
+        </head>
+        <body>
+            <div id="rakta-root"></div>
+            <script type="module" src="${options.scriptPath}"></script>
+        </body>
+    </html>`;
+}
+function makeSuccess(html, mode, renderMs, httpStatus = 200, fromCache = false) {
+  return {
+    kind: "success",
+    html,
+    mode,
+    httpStatus,
+    responseHeaders: { "Content-Type": "text/html; charset=utf-8" },
+    fromCache,
+    renderMs
+  };
+}
+function makeFailure(reason, mode, httpStatus = 500) {
+  return { kind: "failure", reason, mode, httpStatus };
+}
+async function render(context, options) {
+  const startMs = Date.now();
+  if (isRoadmapMode(context.mode)) {
+    console.warn(`[Rakta.js] Render mode "${context.mode}" is a roadmap feature (v0.2.0). ` + `Falling back to CSR for: ${context.routePath}`);
+    return makeSuccess(buildHtmlShell(options), "csr", Date.now() - startMs);
+  }
+  switch (context.mode) {
+    case "csr":
+    case "spa":
+      return makeSuccess(buildHtmlShell(options), context.mode, Date.now() - startMs);
+    case "hybrid":
+      return makeSuccess(buildHtmlShell(options), "csr", Date.now() - startMs);
+    case "ssr":
+    case "ssg":
+    case "csg":
+      return makeFailure(`Render mode "${context.mode}" is not yet implemented.`, context.mode, 501);
+  }
+}
+function renderNotFound(options) {
+  return makeSuccess(buildHtmlShell(options), "csr", 0, 404);
+}
+function renderServerError(reason, mode) {
+  return makeFailure(reason, mode, 500);
+}
+
+// src/router/matcher.ts
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildPatternRegex(segments) {
+  const paramNames = [];
+  const parts = segments.map((segment) => {
+    if (segment.isDynamic && segment.paramName) {
+      paramNames.push(segment.paramName);
+      return "([^/]+)";
+    }
+    return escapeRegex(segment.raw);
+  });
+  const pattern = parts.length === 0 ? "" : `/${parts.join("/")}`;
+  const regex = new RegExp(`^${pattern || "/"}$`);
+  return { regex, paramNames };
+}
+function matchRoute(pathname, routes) {
+  const normalized = pathname !== "/" && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+  for (const entry of routes) {
+    if (entry.kind !== "page" && entry.kind !== "api")
+      continue;
+    const { regex, paramNames } = buildPatternRegex(entry.segments);
+    const match = regex.exec(normalized);
+    if (!match)
+      continue;
+    const params = {};
+    paramNames.forEach((name, index) => {
+      const captured = match[index + 1];
+      if (captured !== undefined) {
+        params[name] = decodeURIComponent(captured);
+      }
+    });
+    return { entry, params };
+  }
+  return null;
+}
+function findLayoutsForPathname(pathname, routes) {
+  const layoutRoutes = routes.filter((route) => route.kind === "layout");
+  return layoutRoutes.filter((layout) => {
+    if (layout.urlPattern === "/")
+      return true;
+    return pathname === layout.urlPattern || pathname.startsWith(`${layout.urlPattern}/`);
+  });
+}
+function findSpecialRoute(kind, pathname, routes) {
+  const candidates = routes.filter((route) => route.kind === kind);
+  let best = null;
+  let bestLength = -1;
+  for (const candidate of candidates) {
+    const prefix = candidate.urlPattern === "/" ? "" : candidate.urlPattern;
+    if (pathname.startsWith(prefix) && prefix.length > bestLength) {
+      best = candidate;
+      bestLength = prefix.length;
+    }
+  }
+  return best;
+}
+
+// src/forge/devServer.ts
+var DEFAULT_DEV_PORT = 3000;
+var MIME_MAP = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function resolveMime(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return MIME_MAP[ext] ?? "application/octet-stream";
+}
+function resolveDevPort(port) {
+  return port > 0 ? port : DEFAULT_DEV_PORT;
+}
+function startDevServer(options) {
+  const manifest = generateManifest(options.appDir);
+  const resolvedPort = resolveDevPort(options.port);
+  const server = Bun.serve({
+    port: resolvedPort,
+    hostname: options.host,
+    async fetch(request) {
+      const url = new URL(request.url);
+      const { pathname } = url;
+      const publicPath = join6(options.publicDir, pathname);
+      if (existsSync5(publicPath) && !publicPath.endsWith("/")) {
+        return new Response(readFileSync2(publicPath), {
+          headers: { "Content-Type": resolveMime(pathname) }
+        });
+      }
+      const apiMatch = matchRoute(pathname, manifest.routes.filter((route) => route.kind === "api"));
+      if (apiMatch) {
+        const modulePath = join6(options.appDir, apiMatch.entry.filePath);
+        const routeModule = await import(modulePath);
+        const method = request.method.toUpperCase();
+        const handler = routeModule[method];
+        if (typeof handler !== "function") {
+          return new Response("Method not allowed", { status: 405 });
+        }
+        return await handler(request);
+      }
+      const resolved = resolveRouteMode(pathname, options.renderConfig);
+      const searchParams = {};
+      url.searchParams.forEach((value, key) => {
+        searchParams[key] = value;
+      });
+      const requestHeaders = {};
+      request.headers.forEach((value, key) => {
+        requestHeaders[key] = value;
+      });
+      const result = await render({
+        routePath: pathname,
+        mode: resolved.mode,
+        params: {},
+        searchParams,
+        requestHeaders,
+        timestampMs: Date.now()
+      }, {
+        appName: options.appName,
+        scriptPath: "/app.js",
+        cssPath: "/globals.css",
+        lang: "en"
+      });
+      if (result.kind === "failure") {
+        return new Response(result.reason, { status: result.httpStatus });
+      }
+      return new Response(result.html, {
+        status: result.httpStatus,
+        headers: result.responseHeaders
+      });
+    }
+  });
+  const serverPort = typeof server.port === "number" ? server.port : resolvedPort;
+  return {
+    port: serverPort,
+    host: options.host,
+    url: `http://${options.host}:${serverPort}`,
+    stop: () => server.stop()
+  };
+}
+// src/forge/inspect.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join7 } from "path";
+function detectArtifactKind(filename) {
+  if (filename === "route-manifest.json")
+    return "manifest";
+  if (filename.endsWith(".css"))
+    return "stylesheet";
+  if (filename.endsWith(".js") || filename.endsWith(".mjs"))
+    return "script";
+  return "asset";
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1048576).toFixed(2)} MB`;
+}
+function scanDirectory2(dirPath) {
+  if (!existsSync6(dirPath))
+    return [];
+  const collected = [];
+  function walk(current) {
+    const entries = readdirSync3(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join7(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        collected.push({
+          outputPath: full,
+          sizeBytes: statSync2(full).size,
+          kind: detectArtifactKind(entry.name)
+        });
+      }
+    }
+  }
+  walk(dirPath);
+  return collected;
+}
+function inspectBuild(options) {
+  const artifacts = scanDirectory2(options.outDir);
+  const manifestPath = join7(options.outDir, "route-manifest.json");
+  const manifest = readManifest(manifestPath);
+  const emptyManifest = {
+    version: "1",
+    generatedAt: new Date().toISOString(),
+    routes: []
+  };
+  const routeModes = (manifest ?? emptyManifest).routes.filter((r) => r.kind === "page" || r.kind === "api").map((r) => {
+    const resolved = resolveRouteMode(r.urlPattern, options.renderConfig);
+    return {
+      pattern: r.urlPattern,
+      mode: resolved.mode,
+      source: resolved.source
+    };
+  });
+  return {
+    buildDir: options.outDir,
+    artifacts,
+    manifest: manifest ?? emptyManifest,
+    routeModes,
+    totalSizeBytes: artifacts.reduce((sum, a) => sum + a.sizeBytes, 0),
+    inspectedAt: new Date().toISOString()
+  };
+}
+function printInspectReport(report) {
+  const sep = "\u2500".repeat(58);
+  console.log(`
+        
+ Rakta.js Forge - Build Inspection
+    `);
+  console.log(`
+        ${sep}
+    `);
+  console.log(`
+        Directory:  ${report.buildDir}
+    `);
+  console.log(`
+        Inspected:  ${report.inspectedAt}
+    `);
+  console.log(`
+        Total size: ${formatBytes(report.totalSizeBytes)}
+
+    `);
+  if (report.artifacts.length > 0) {
+    console.log("Artifacts:");
+    for (const artifact of report.artifacts) {
+      const rel = artifact.outputPath.replace(report.buildDir, ".").replace(/\\/g, "/");
+      console.log(`
+        [${artifact.kind.padEnd(10)}]  
+        ${rel.padEnd(38)}  
+        ${formatBytes(artifact.sizeBytes)}`);
+    }
+    console.log("");
+  }
+  if (report.routeModes.length > 0) {
+    console.log("Route Render Modes:");
+    for (const rm of report.routeModes) {
+      const src = rm.source === "route-override" ? "(override)" : "(default) ";
+      console.log(`
+        ${rm.mode.toUpperCase().padEnd(8)}  
+        ${rm.pattern.padEnd(36)}  ${src}`);
+    }
+    console.log("");
+  }
+  console.log(`${sep}
+`);
+}
+// src/http/errors.ts
+class HttpResponseError extends Error {
+  status;
+  statusText;
+  url;
+  constructor(response) {
+    super(`HTTP ${response.status} ${response.statusText} - ${response.url}`);
+    this.name = "HttpResponseError";
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.url = response.url;
+  }
+}
+
+class HttpTimeoutError extends Error {
+  url;
+  timeoutMs;
+  constructor(url, timeoutMs) {
+    super(`Request to ${url} timed out after ${timeoutMs}ms`);
+    this.name = "HttpTimeoutError";
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class HttpNetworkError extends Error {
+  url;
+  originalError;
+  constructor(url, originalError) {
+    super(`Network error for ${url}: ${originalError.message}`);
+    this.name = "HttpNetworkError";
+    this.url = url;
+    this.originalError = originalError;
+  }
+}
+// src/http/panturaFetch.ts
+function buildUrl(baseUrl, path, params) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const fullUrl = path.startsWith("http") ? path : `${base}${path}`;
+  const parsedUrl = new URL(fullUrl);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      parsedUrl.searchParams.set(key, String(value));
+    }
+  }
+  return parsedUrl.toString();
+}
+function canSendBody(method) {
+  return method !== "GET" && method !== "HEAD";
+}
+function createRequestInit(method, headers, body) {
+  const requestInit = {
+    method,
+    headers
+  };
+  if (body !== undefined && canSendBody(method)) {
+    requestInit.body = JSON.stringify(body);
+  }
+  return requestInit;
+}
+
+class RaktaHttpClient {
+  clientConfig;
+  requestInterceptors = [];
+  responseInterceptors = [];
+  constructor(config) {
+    this.clientConfig = {
+      baseUrl: config.baseUrl,
+      headers: config.headers ?? {
+        "Content-Type": "application/json"
+      },
+      timeout: config.timeout ?? 30000
+    };
+  }
+  addRequestInterceptor(interceptorFn) {
+    this.requestInterceptors.push(interceptorFn);
+    return this;
+  }
+  addResponseInterceptor(interceptorFn) {
+    const wrappedInterceptor = async (response, data) => {
+      return await Promise.resolve(interceptorFn(response, data));
+    };
+    this.responseInterceptors.push(wrappedInterceptor);
+    return this;
+  }
+  async execute(method, path, body, requestConfig) {
+    let resolvedUrl = buildUrl(this.clientConfig.baseUrl, path, requestConfig?.params);
+    let requestInit = createRequestInit(method, {
+      ...this.clientConfig.headers,
+      ...requestConfig?.headers ?? {}
+    }, body);
+    for (const interceptorFn of this.requestInterceptors) {
+      [resolvedUrl, requestInit] = await Promise.resolve(interceptorFn(resolvedUrl, requestInit));
+    }
+    const timeoutMs = requestConfig?.timeout ?? this.clientConfig.timeout;
+    const abortController = new AbortController;
+    const timeoutHandle = setTimeout(() => abortController.abort(), timeoutMs);
+    requestInit = { ...requestInit, signal: abortController.signal };
+    let response;
+    try {
+      response = await fetch(resolvedUrl, requestInit);
+    } catch (caughtError) {
+      clearTimeout(timeoutHandle);
+      if (caughtError instanceof DOMException && caughtError.name === "AbortError") {
+        throw new HttpTimeoutError(resolvedUrl, timeoutMs);
+      }
+      throw new HttpNetworkError(resolvedUrl, caughtError instanceof Error ? caughtError : new Error(String(caughtError)));
+    }
+    clearTimeout(timeoutHandle);
+    if (!response.ok) {
+      throw new HttpResponseError(response);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    let responseData;
+    if (contentType.includes("application/json")) {
+      responseData = await response.json();
+    } else {
+      responseData = await response.text();
+    }
+    let interceptedData = responseData;
+    for (const interceptorFn of this.responseInterceptors) {
+      interceptedData = await Promise.resolve(interceptorFn(response, interceptedData));
+    }
+    return interceptedData;
+  }
+  get(path, config) {
+    return this.execute("GET", path, undefined, config);
+  }
+  post(path, body, config) {
+    return this.execute("POST", path, body, config);
+  }
+  put(path, body, config) {
+    return this.execute("PUT", path, body, config);
+  }
+  patch(path, body, config) {
+    return this.execute("PATCH", path, body, config);
+  }
+  delete(path, config) {
+    return this.execute("DELETE", path, undefined, config);
+  }
+}
+function createRaktaHttp(config) {
+  return new RaktaHttpClient(config);
+}
+// src/pwa/cache.ts
+function buildCacheName(cacheName, cacheVersion) {
+  const sanitizedName = cacheName.trim().toLowerCase().replace(/\s+/g, "-");
+  const sanitizedVersion = cacheVersion.trim().toLowerCase();
+  return `${sanitizedName}-${sanitizedVersion}`;
+}
+function resolvePrecacheList(options) {
+  const uniqueUrls = new Set(options.precacheUrls);
+  uniqueUrls.add(options.offlineFallbackUrl);
+  return Array.from(uniqueUrls);
+}
+// src/pwa/manifest.ts
+function generateManifest2(options) {
+  const manifestObject = {
+    name: options.name,
+    short_name: options.shortName,
+    start_url: options.startUrl ?? "/",
+    scope: options.scope ?? "/",
+    display: options.display ?? "standalone",
+    background_color: options.backgroundColor ?? "#050505",
+    theme_color: options.themeColor ?? "#dc2626",
+    icons: options.icons.map((icon) => {
+      const manifestIcon = {
+        src: icon.src,
+        sizes: icon.sizes,
+        type: icon.type
+      };
+      if (icon.purpose !== undefined) {
+        return {
+          ...manifestIcon,
+          purpose: icon.purpose
+        };
+      }
+      return manifestIcon;
+    })
+  };
+  if (options.description !== undefined) {
+    return {
+      ...manifestObject,
+      description: options.description
+    };
+  }
+  return manifestObject;
+}
+function generateManifestJson(options) {
+  return JSON.stringify(generateManifest2(options), undefined, 2);
+}
+function createManifestHandler(options) {
+  return () => {
+    const manifestJson = generateManifestJson(options);
+    return new Response(manifestJson, {
+      status: 200,
+      headers: {
+        "Content-Type": "application/manifest+json; charset=utf-8",
+        "Cache-Control": "public, max-age=3600"
+      }
+    });
+  };
+}
+// src/pwa/serviceWorker.ts
+function toJsStringArray(values) {
+  return `[${values.map((value) => JSON.stringify(value)).join(", ")}]`;
+}
+function generateServiceWorkerSource(options) {
+  const cacheName = buildCacheName(options.cacheName, options.cacheVersion);
+  const precacheList = resolvePrecacheList(options);
+  const offlineFallbackUrl = options.offlineFallbackUrl;
+  return `// Generated by Rakta.js ShrimpHarbor - do not edit manually.
+// Re-run "bun rakta pwa:generate" to regenerate this file.
+
+const CACHE_NAME = ${JSON.stringify(cacheName)};
+const OFFLINE_FALLBACK_URL = ${JSON.stringify(offlineFallbackUrl)};
+const PRECACHE_URLS = ${toJsStringArray(precacheList)};
+
+self.addEventListener("install", (installEvent) => {
+  installEvent.waitUntil(
+    caches.open(CACHE_NAME).then((cache) => cache.addAll(PRECACHE_URLS)),
+  );
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (activateEvent) => {
+  activateEvent.waitUntil(
+    caches.keys().then((cacheKeys) =>
+      Promise.all(
+        cacheKeys
+          .filter((cacheKey) => cacheKey !== CACHE_NAME)
+          .map((staleCacheKey) => caches.delete(staleCacheKey)),
+      ),
+    ),
+  );
+  self.clients.claim();
+});
+
+self.addEventListener("fetch", (fetchEvent) => {
+  if (fetchEvent.request.method !== "GET") {
+    return;
+  }
+
+  fetchEvent.respondWith(
+    caches.match(fetchEvent.request).then((cachedResponse) => {
+      if (cachedResponse) {
+        return cachedResponse;
+      }
+
+      return fetch(fetchEvent.request)
+        .then((networkResponse) => {
+          const responseClone = networkResponse.clone();
+          caches
+            .open(CACHE_NAME)
+            .then((cache) => cache.put(fetchEvent.request, responseClone));
+          return networkResponse;
+        })
+        .catch(() => {
+          if (fetchEvent.request.mode === "navigate") {
+            return caches.match(OFFLINE_FALLBACK_URL);
+          }
+
+          return caches.match(fetchEvent.request);
+        });
+    }),
+  );
+});
+`;
+}
+// src/rpc/client.ts
+class RaktaRpcError extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.name = "RaktaRpcError";
+    this.code = code;
+    if (details !== undefined) {
+      this.details = details;
+    }
+  }
+}
+async function callProcedure(clientConfig, procedureName, procedureInput) {
+  const abortController = new AbortController;
+  const timeoutMs = clientConfig.timeout ?? 30000;
+  const timeoutHandle = setTimeout(() => abortController.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(clientConfig.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...clientConfig.headers ?? {}
+      },
+      body: JSON.stringify({
+        procedure: procedureName,
+        input: procedureInput
+      }),
+      signal: abortController.signal
+    });
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+  const responseEnvelope = await response.json();
+  if (!responseEnvelope.ok) {
+    throw new RaktaRpcError(responseEnvelope.error, responseEnvelope.code, responseEnvelope.details);
+  }
+  return responseEnvelope.data;
+}
+function createRaktaClient(clientConfig) {
+  return new Proxy({}, {
+    get(_target, procedureName) {
+      return {
+        query: (procedureInput) => callProcedure(clientConfig, procedureName, procedureInput),
+        mutate: (procedureInput) => callProcedure(clientConfig, procedureName, procedureInput)
+      };
+    }
+  });
+}
+// src/rpc/procedure.ts
+class ProcedureBuilder {
+  inputSchema;
+  constructor(inputSchema) {
+    if (inputSchema !== undefined) {
+      this.inputSchema = inputSchema;
+    }
+  }
+  input(schema) {
+    return new ProcedureBuilder(schema);
+  }
+  query(handler) {
+    return this.build("query", handler);
+  }
+  mutation(handler) {
+    return this.build("mutation", handler);
+  }
+  build(kind, handler) {
+    if (this.inputSchema !== undefined) {
+      return {
+        kind,
+        inputSchema: this.inputSchema,
+        handler
+      };
+    }
+    return {
+      kind,
+      handler
+    };
+  }
+}
+var publicProcedure = new ProcedureBuilder;
+// src/schema/errors.ts
+class RaktaSchemaError extends Error {
+  errors;
+  constructor(errors) {
+    const first = errors[0];
+    const prefix = first ? `[${first.path.join(".") || "root"}] ${first.message}` : "Validation failed";
+    super(`Rakta Schema: ${prefix}${errors.length > 1 ? ` (and ${errors.length - 1} more)` : ""}`);
+    this.name = "RaktaSchemaError";
+    this.errors = errors;
+  }
+}
+function prefixErrors(errors, key) {
+  return errors.map((error) => ({
+    ...error,
+    path: [key, ...error.path]
+  }));
+}
+var preFixErrors = prefixErrors;
+
+// src/rpc/router.ts
+function createRaktaRouter(procedures) {
+  return procedures;
+}
+function createRpcHandler(router) {
+  return async (request) => {
+    if (request.method !== "POST") {
+      return buildJsonResponse({
+        ok: false,
+        error: "Only POST requests are accepted",
+        code: "method_not_allowed"
+      }, 405);
+    }
+    let rpcPayload;
+    try {
+      rpcPayload = await request.json();
+    } catch {
+      return buildJsonResponse({ ok: false, error: "Invalid JSON body", code: "parse_error" }, 400);
+    }
+    if (typeof rpcPayload.procedure !== "string") {
+      return buildJsonResponse({
+        ok: false,
+        error: "Missing procedure name",
+        code: "invalid_request"
+      }, 400);
+    }
+    const selectedProcedure = router[rpcPayload.procedure];
+    if (selectedProcedure === undefined) {
+      return buildJsonResponse({
+        ok: false,
+        error: `Procedure "${rpcPayload.procedure}" not found`,
+        code: "not_found"
+      }, 404);
+    }
+    let validatedInput = rpcPayload.input;
+    if (selectedProcedure.inputSchema !== undefined) {
+      const validationErrors = selectedProcedure.inputSchema._run(rpcPayload.input);
+      if (validationErrors.length > 0) {
+        return buildJsonResponse({
+          ok: false,
+          error: "Input validation failed",
+          code: "validation_error",
+          details: validationErrors.map((validationError) => ({
+            path: validationError.path,
+            message: validationError.message
+          }))
+        }, 422);
+      }
+      validatedInput = selectedProcedure.inputSchema.parse(rpcPayload.input);
+    }
+    try {
+      const procedureOutput = await selectedProcedure.handler({
+        input: validatedInput
+      });
+      return buildJsonResponse({ ok: true, data: procedureOutput }, 200);
+    } catch (caughtError) {
+      if (caughtError instanceof RaktaSchemaError) {
+        return buildJsonResponse({
+          ok: false,
+          error: caughtError.message,
+          code: "schema_error"
+        }, 422);
+      }
+      const errorMessage = caughtError instanceof Error ? caughtError.message : "Internal server error";
+      return buildJsonResponse({ ok: false, error: errorMessage, code: "internal_error" }, 500);
+    }
+  };
+}
+function buildJsonResponse(responseEnvelope, statusCode) {
+  return new Response(JSON.stringify(responseEnvelope), {
+    status: statusCode,
+    headers: { "Content-Type": "application/json; charset=utf-8" }
+  });
+}
+// src/schema/types.ts
+class RaktaType {
+  parse(value) {
+    const result = this.safeParse(value);
+    if (result.kind === "failure") {
+      throw new RaktaSchemaError(result.errors);
+    }
+    return result.data;
+  }
+  safeParse(value) {
+    const errors = this._run(value);
+    if (errors.length > 0) {
+      return {
+        kind: "failure",
+        errors
+      };
+    }
+    return {
+      kind: "success",
+      data: value
+    };
+  }
+  optional() {
+    return new OptionalType(this);
+  }
+}
+
+class OptionalType extends RaktaType {
+  inner;
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  _run(value) {
+    if (typeof value === "undefined") {
+      return [];
+    }
+    return this.inner._run(value);
+  }
+}
+
+// src/schema/array.ts
+class ArrayType extends RaktaType {
+  itemSchema;
+  minLength;
+  maxLength;
+  constructor(itemSchema, minLength, maxLength) {
+    super();
+    this.itemSchema = itemSchema;
+    if (typeof minLength === "number") {
+      this.minLength = minLength;
+    }
+    if (typeof maxLength === "number") {
+      this.maxLength = maxLength;
+    }
+  }
+  clone(minLength, maxLength) {
+    return new ArrayType(this.itemSchema, minLength, maxLength);
+  }
+  min(length) {
+    return this.clone(length, this.maxLength);
+  }
+  max(length) {
+    return this.clone(this.minLength, length);
+  }
+  nonempty() {
+    return this.min(1);
+  }
+  _run(value) {
+    if (!Array.isArray(value)) {
+      return [
+        {
+          path: [],
+          message: "Expected an array",
+          code: "invalid_type"
+        }
+      ];
+    }
+    const errors = [];
+    if (typeof this.minLength === "number" && value.length < this.minLength) {
+      errors.push({
+        path: [],
+        message: `Array must contain at least ${this.minLength} item(s)`,
+        code: "too_small"
+      });
+    }
+    if (typeof this.maxLength === "number" && value.length > this.maxLength) {
+      errors.push({
+        path: [],
+        message: `Array must contain at most ${this.maxLength} item(s)`,
+        code: "too_big"
+      });
+    }
+    for (let index = 0;index < value.length; index += 1) {
+      const itemValue = value[index];
+      const itemErrors = this.itemSchema._run(itemValue);
+      errors.push(...itemErrors.map((error) => ({
+        ...error,
+        path: [String(index), ...error.path]
+      })));
+    }
+    return errors;
+  }
+}
+function array(itemSchema) {
+  return new ArrayType(itemSchema);
+}
+// src/schema/boolean.ts
+class BooleanType extends RaktaType {
+  _run(value) {
+    if (typeof value !== "boolean") {
+      return [
+        {
+          path: [],
+          message: "Expected a boolean",
+          code: "invalid_type"
+        }
+      ];
+    }
+    return [];
+  }
+}
+function boolean() {
+  return new BooleanType;
+}
+// src/schema/number.ts
+class NumberType extends RaktaType {
+  rules;
+  constructor(rules = []) {
+    super();
+    this.rules = rules;
+  }
+  addRule(rule) {
+    return new NumberType([...this.rules, rule]);
+  }
+  _run(value) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      return [
+        {
+          path: [],
+          message: "Expected a number",
+          code: "invalid_type"
+        }
+      ];
+    }
+    const errors = [];
+    for (const rule of this.rules) {
+      const result = rule(value);
+      if (result) {
+        errors.push(result);
+      }
+    }
+    return errors;
+  }
+  min(threshold) {
+    return this.addRule((value) => value < threshold ? {
+      path: [],
+      message: `Must be at least ${threshold}`,
+      code: "too_small"
+    } : undefined);
+  }
+  max(threshold) {
+    return this.addRule((value) => value > threshold ? {
+      path: [],
+      message: `Must be at most ${threshold}`,
+      code: "too_big"
+    } : undefined);
+  }
+  int() {
+    return this.addRule((value) => !Number.isInteger(value) ? {
+      path: [],
+      message: "Expected an integer",
+      code: "not_integer"
+    } : undefined);
+  }
+  positive() {
+    return this.addRule((value) => value <= 0 ? {
+      path: [],
+      message: "Must be a positive number",
+      code: "not_positive"
+    } : undefined);
+  }
+  nonnegative() {
+    return this.addRule((value) => value < 0 ? {
+      path: [],
+      message: "Must be zero or positive",
+      code: "not_nonnegative"
+    } : undefined);
+  }
+}
+function number() {
+  return new NumberType;
+}
+// src/schema/object.ts
+class ObjectType extends RaktaType {
+  shape;
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  _run(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return [
+        {
+          path: [],
+          message: "Expected an object",
+          code: "invalid_type"
+        }
+      ];
+    }
+    const errors = [];
+    const record = value;
+    for (const key of Object.keys(this.shape)) {
+      const fieldSchema = this.shape[key];
+      if (typeof fieldSchema === "undefined") {
+        continue;
+      }
+      const fieldValue = record[key];
+      const fieldErrors = fieldSchema._run(fieldValue);
+      errors.push(...prefixErrors(fieldErrors, key));
+    }
+    return errors;
+  }
+  extend(extension) {
+    return new ObjectType({
+      ...this.shape,
+      ...extension
+    });
+  }
+  pick(keys) {
+    const picked = {};
+    for (const key of keys) {
+      if (key in this.shape) {
+        picked[key] = this.shape[key];
+      }
+    }
+    return new ObjectType(picked);
+  }
+  omit(keys) {
+    const result = { ...this.shape };
+    for (const key of keys) {
+      delete result[key];
+    }
+    return new ObjectType(result);
+  }
+}
+function object(shape) {
+  return new ObjectType(shape);
+}
+// src/schema/string.ts
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+var URL_PATTERN = /^https?:\/\/[^\s$.?#].[^\s]*$/i;
+
+class StringType extends RaktaType {
+  rules;
+  constructor(rules = []) {
+    super();
+    this.rules = rules;
+  }
+  addRule(rule) {
+    return new StringType([...this.rules, rule]);
+  }
+  _run(value) {
+    if (typeof value !== "string") {
+      return [
+        {
+          path: [],
+          message: "Expected a string",
+          code: "invalid_type"
+        }
+      ];
+    }
+    const errors = [];
+    for (const rule of this.rules) {
+      errors.push(...rule(value));
+    }
+    return errors;
+  }
+  min(length) {
+    return this.addRule((value) => {
+      if (value.length >= length) {
+        return [];
+      }
+      return [
+        {
+          path: [],
+          message: `Must be at least ${length} character(s)`,
+          code: "too_small"
+        }
+      ];
+    });
+  }
+  max(length) {
+    return this.addRule((value) => {
+      if (value.length <= length) {
+        return [];
+      }
+      return [
+        {
+          path: [],
+          message: `Must be at most ${length} character(s)`,
+          code: "too_big"
+        }
+      ];
+    });
+  }
+  email() {
+    return this.addRule((value) => {
+      if (EMAIL_PATTERN.test(value)) {
+        return [];
+      }
+      return [
+        {
+          path: [],
+          message: "Invalid email address",
+          code: "invalid_email"
+        }
+      ];
+    });
+  }
+  url() {
+    return this.addRule((value) => {
+      if (URL_PATTERN.test(value)) {
+        return [];
+      }
+      return [
+        {
+          path: [],
+          message: "Invalid URL",
+          code: "invalid_url"
+        }
+      ];
+    });
+  }
+  regex(pattern, customMessage) {
+    return this.addRule((value) => {
+      if (pattern.test(value)) {
+        return [];
+      }
+      return [
+        {
+          path: [],
+          message: customMessage ?? `Did not match pattern ${pattern.toString()}`,
+          code: "invalid_pattern"
+        }
+      ];
+    });
+  }
+  nonempty() {
+    return this.min(1);
+  }
+}
+function string() {
+  return new StringType;
+}
+// src/seo/metadata.ts
+function resolveTitle(metadata) {
+  if (!metadata.title && metadata.defaultTitle) {
+    return metadata.defaultTitle;
+  }
+  if (!metadata.title) {
+    return "";
+  }
+  if (metadata.titleTemplate) {
+    return metadata.titleTemplate.replace("%s", metadata.title);
+  }
+  return metadata.title;
+}
+function resolveRobotsContent(robots) {
+  if (typeof robots === "string") {
+    return robots;
+  }
+  const directives = [];
+  if (robots.index === false) {
+    directives.push("noindex");
+  } else {
+    directives.push("index");
+  }
+  if (robots.follow === false) {
+    directives.push("nofollow");
+  } else {
+    directives.push("follow");
+  }
+  if (robots.nocache) {
+    directives.push("nocache");
+  }
+  return directives.join(", ");
+}
+function mergeMetadata(base, override) {
+  const mergedMetadata = {
+    ...base,
+    ...override
+  };
+  if (base.openGraph || override.openGraph) {
+    mergedMetadata.openGraph = {
+      ...base.openGraph,
+      ...override.openGraph
+    };
+  }
+  if (base.twitter || override.twitter) {
+    mergedMetadata.twitter = {
+      ...base.twitter,
+      ...override.twitter
+    };
+  }
+  if (base.alternates || override.alternates) {
+    mergedMetadata.alternates = {
+      ...base.alternates,
+      ...override.alternates
+    };
+  }
+  if (base.icons || override.icons) {
+    mergedMetadata.icons = {
+      ...base.icons,
+      ...override.icons
+    };
+  }
+  if (base.other || override.other) {
+    mergedMetadata.other = {
+      ...base.other,
+      ...override.other
+    };
+  }
+  return mergedMetadata;
+}
+
+// src/seo/head.tsx
+var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+function KeywordsContent(keywords) {
+  return Array.isArray(keywords) ? keywords.join(", ") : keywords;
+}
+function getAuthorKey(authorName) {
+  return `author-${authorName}`;
+}
+function getIconKey(prefix, iconUrl, iconSizes) {
+  if (iconSizes && iconSizes.length > 0) {
+    return `${prefix}-${iconUrl}-${iconSizes}`;
+  }
+  return `${prefix}-${iconUrl}`;
+}
+function getOpenGraphImageKey(image) {
+  const width = image.width ? String(image.width) : "auto-width";
+  const height = image.height ? String(image.height) : "auto-height";
+  return `og-image-${image.url}-${width}-${height}`;
+}
+function getJsonLdKey(schema) {
+  return `jsonld-${JSON.stringify(schema)}`;
+}
+function RaktaHead({ metadata }) {
+  const resolvedTitle = resolveTitle(metadata);
+  const robotsContent = metadata.robots ? resolveRobotsContent(metadata.robots) : "";
+  const jsonLdArray = metadata.jsonLd ? Array.isArray(metadata.jsonLd) ? metadata.jsonLd : [metadata.jsonLd] : [];
+  const canonical = metadata.canonical ?? metadata.alternates?.canonical ?? "";
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(jsx_dev_runtime2.Fragment, {
+    children: [
+      resolvedTitle && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("title", {
+        children: resolvedTitle
+      }, undefined, false, undefined, this),
+      metadata.description && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "description",
+        content: metadata.description
+      }, undefined, false, undefined, this),
+      metadata.keywords && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "keywords",
+        content: KeywordsContent(metadata.keywords)
+      }, undefined, false, undefined, this),
+      metadata.applicationName && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "application-name",
+        content: metadata.applicationName
+      }, undefined, false, undefined, this),
+      metadata.creator && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "author",
+        content: metadata.creator
+      }, undefined, false, undefined, this),
+      metadata.publisher && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "publisher",
+        content: metadata.publisher
+      }, undefined, false, undefined, this),
+      metadata.colorScheme && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "color-scheme",
+        content: metadata.colorScheme
+      }, undefined, false, undefined, this),
+      robotsContent && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "robots",
+        content: robotsContent
+      }, undefined, false, undefined, this),
+      metadata.viewport && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "viewport",
+        content: metadata.viewport
+      }, undefined, false, undefined, this),
+      metadata.authors?.map((author) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+        name: "author",
+        content: author.name
+      }, getAuthorKey(author.name), false, undefined, this)),
+      canonical && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "canonical",
+        href: canonical
+      }, undefined, false, undefined, this),
+      metadata.alternates?.languages && Object.entries(metadata.alternates.languages).map(([lang, url]) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "alternate",
+        hrefLang: lang,
+        href: url
+      }, lang, false, undefined, this)),
+      metadata.manifest && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "manifest",
+        href: metadata.manifest
+      }, undefined, false, undefined, this),
+      metadata.icons?.icon && (typeof metadata.icons.icon === "string" ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "icon",
+        href: metadata.icons.icon
+      }, undefined, false, undefined, this) : metadata.icons.icon.map((icon) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "icon",
+        href: icon.url,
+        sizes: icon.sizes,
+        type: icon.type
+      }, getIconKey("icon", icon.url, icon.sizes), false, undefined, this))),
+      metadata.icons?.shortcut && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "shortcut icon",
+        href: metadata.icons.shortcut
+      }, undefined, false, undefined, this),
+      metadata.icons?.apple && (typeof metadata.icons.apple === "string" ? /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "apple-touch-icon",
+        href: metadata.icons.apple
+      }, undefined, false, undefined, this) : metadata.icons.apple.map((icon) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("link", {
+        rel: "apple-touch-icon",
+        href: icon.url,
+        sizes: icon.sizes
+      }, getIconKey("apple", icon.url, icon.sizes), false, undefined, this))),
+      metadata.openGraph && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(jsx_dev_runtime2.Fragment, {
+        children: [
+          (metadata.openGraph.title ?? resolvedTitle) && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            property: "og:title",
+            content: metadata.openGraph.title ?? resolvedTitle
+          }, undefined, false, undefined, this),
+          (metadata.openGraph.description ?? metadata.description) && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            property: "og:description",
+            content: metadata.openGraph.description ?? metadata.description ?? ""
+          }, undefined, false, undefined, this),
+          metadata.openGraph.type && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            property: "og:type",
+            content: metadata.openGraph.type
+          }, undefined, false, undefined, this),
+          metadata.openGraph.url && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            property: "og:url",
+            content: metadata.openGraph.url
+          }, undefined, false, undefined, this),
+          metadata.openGraph.siteName && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            property: "og:site_name",
+            content: metadata.openGraph.siteName
+          }, undefined, false, undefined, this),
+          metadata.openGraph.locale && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            property: "og:locale",
+            content: metadata.openGraph.locale
+          }, undefined, false, undefined, this),
+          metadata.openGraph.images?.map((image) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(jsx_dev_runtime2.Fragment, {
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+                property: "og:image",
+                content: image.url
+              }, undefined, false, undefined, this),
+              image.width && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+                property: "og:image:width",
+                content: String(image.width)
+              }, undefined, false, undefined, this),
+              image.height && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+                property: "og:image:height",
+                content: String(image.height)
+              }, undefined, false, undefined, this),
+              image.alt && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+                property: "og:image:alt",
+                content: image.alt
+              }, undefined, false, undefined, this),
+              image.type && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+                property: "og:image:type",
+                content: image.type
+              }, undefined, false, undefined, this)
+            ]
+          }, getOpenGraphImageKey(image), true, undefined, this))
+        ]
+      }, undefined, true, undefined, this),
+      metadata.twitter && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(jsx_dev_runtime2.Fragment, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            name: "twitter:card",
+            content: metadata.twitter.card ?? "summary"
+          }, undefined, false, undefined, this),
+          metadata.twitter.site && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            name: "twitter:site",
+            content: metadata.twitter.site
+          }, undefined, false, undefined, this),
+          metadata.twitter.creator && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            name: "twitter:creator",
+            content: metadata.twitter.creator
+          }, undefined, false, undefined, this),
+          (metadata.twitter.title ?? resolvedTitle) && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            name: "twitter:title",
+            content: metadata.twitter.title ?? resolvedTitle
+          }, undefined, false, undefined, this),
+          (metadata.twitter.description ?? metadata.description) && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            name: "twitter:description",
+            content: metadata.twitter.description ?? metadata.description ?? ""
+          }, undefined, false, undefined, this),
+          metadata.twitter.image && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            name: "twitter:image",
+            content: metadata.twitter.image
+          }, undefined, false, undefined, this),
+          metadata.twitter.imageAlt && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+            name: "twitter:image:alt",
+            content: metadata.twitter.imageAlt
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      metadata.other && Object.entries(metadata.other).map(([name, content]) => {
+        const contentValue = Array.isArray(content) ? content.join(", ") : content;
+        return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("meta", {
+          name,
+          content: contentValue
+        }, name, false, undefined, this);
+      }),
+      jsonLdArray.map((schema) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV("script", {
+        type: "application/ld+json",
+        children: JSON.stringify(schema)
+      }, getJsonLdKey(schema), false, undefined, this))
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/seo/robots.ts
+function generateRobotsTxt(options) {
+  const lines = [];
+  for (const rule of options.rules) {
+    const agents = Array.isArray(rule.userAgent) ? rule.userAgent : [rule.userAgent];
+    for (const agent of agents) {
+      lines.push(`User-agent: ${agent}`);
+    }
+    if (rule.allow) {
+      const allowPaths = Array.isArray(rule.allow) ? rule.allow : [rule.allow];
+      for (const allowPath of allowPaths) {
+        lines.push(`Allow: ${allowPath}`);
+      }
+    }
+    if (rule.disAllow) {
+      const disAllowPaths = Array.isArray(rule.disAllow) ? rule.disAllow : [rule.disAllow];
+      for (const disAllowPath of disAllowPaths) {
+        lines.push(`Disallow: ${disAllowPath}`);
+      }
+    }
+    if (rule.crawlDelay !== undefined) {
+      lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+    }
+    lines.push("");
+  }
+  if (options.sitemap) {
+    const sitemaps = Array.isArray(options.sitemap) ? options.sitemap : [options.sitemap];
+    for (const sitemapUrl of sitemaps) {
+      lines.push(`Sitemap: ${sitemapUrl}`);
+    }
+    lines.push("");
+  }
+  if (options.host) {
+    lines.push(`Host: ${options.host}`);
+  }
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function createRobotsHandler(options) {
+  return () => {
+    const robotsTxt = generateRobotsTxt(options);
+    return new Response(robotsTxt, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "public, max-age=3600, s-maxage=86400"
+      }
+    });
+  };
+}
+// src/seo/sitemap.ts
+function encodeRaktaXmlValue(text) {
+  return text.replace(/&/g, "&amp;").replace(/'/g, "&apos;").replace(/"/g, "&quot;").replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/\r/g, "").replace(/\n/g, "").replace(/\t/g, " ").trim();
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+function createAbsoluteUrl(baseUrl, loc) {
+  if (loc.startsWith("http://") || loc.startsWith("https://")) {
+    return loc;
+  }
+  if (loc.startsWith("/")) {
+    return `${baseUrl}${loc}`;
+  }
+  return `${baseUrl}/${loc}`;
+}
+function normalizePriority(priority) {
+  if (priority < 0) {
+    return "0.0";
+  }
+  if (priority > 1) {
+    return "1.0";
+  }
+  return priority.toFixed(1);
+}
+function generateSitemapXml(options) {
+  const { baseUrl, entries, xslUrl } = options;
+  const normalizedBase = normalizeBaseUrl(baseUrl);
+  const xmlParts = [];
+  xmlParts.push(`
+    <?xml 
+        version="1.0" 
+        encoding="UTF-8"?
+    >
+`);
+  if (xslUrl) {
+    xmlParts.push(`<?xml-stylesheet 
+        type="text/xsl"
+        href="${encodeRaktaXmlValue(xslUrl)}"?
+      >`);
+  }
+  xmlParts.push(`<urlset ` + `xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ` + `xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" ` + `xmlns:xhtml="http://www.w3.org/1999/xhtml">`);
+  for (const entry of entries) {
+    const fullLoc = createAbsoluteUrl(normalizedBase, entry.loc);
+    xmlParts.push(`<url>`);
+    xmlParts.push(`
+        <loc>
+            ${encodeRaktaXmlValue(fullLoc)}
+        </loc>
+    `);
+    if (entry.lastmod) {
+      xmlParts.push(`
+        <lastmod>
+            ${encodeRaktaXmlValue(entry.lastmod)}
+        </lastmod>
+    `);
+    }
+    if (entry.changefreq) {
+      xmlParts.push(`
+        <changefreq>
+            ${entry.changefreq}
+        </changefreq>
+    `);
+    }
+    if (typeof entry.priority === "number") {
+      xmlParts.push(`
+        <priority>
+            ${normalizePriority(entry.priority)}
+        </priority>
+    `);
+    }
+    if (entry.alternates) {
+      for (const [lang, url] of Object.entries(entry.alternates)) {
+        const fullAlt = createAbsoluteUrl(normalizedBase, url);
+        xmlParts.push(`<xhtml:link 
+            rel="alternate" 
+            hreflang="${encodeRaktaXmlValue(lang)}" 
+            href="${encodeRaktaXmlValue(fullAlt)}"
+          />`);
+      }
+    }
+    if (entry.images) {
+      for (const image of entry.images) {
+        const imageLoc = createAbsoluteUrl(normalizedBase, image.loc);
+        xmlParts.push(`<image:image>`);
+        xmlParts.push(`
+            <image:loc>
+                ${encodeRaktaXmlValue(imageLoc)}
+            </image:loc>
+        `);
+        if (image.caption) {
+          xmlParts.push(`
+            <image:caption>
+                ${encodeRaktaXmlValue(image.caption)}
+            </image:caption>
+          `);
+        }
+        if (image.title) {
+          xmlParts.push(`
+            <image:title>
+                ${encodeRaktaXmlValue(image.title)}
+            </image:title>
+          `);
+        }
+        xmlParts.push(`</image:image>`);
+      }
+    }
+    xmlParts.push(`</url>`);
+  }
+  xmlParts.push(`</urlset>`);
+  return xmlParts.join(`
+`);
+}
+function createSitemapHandler(options) {
+  return () => {
+    const xml = generateSitemapXml(options);
+    return new Response(xml, {
+      status: 200,
+      headers: {
+        "Content-Type": "application/xml; charset=utf-8",
+        "Cache-Control": "public, max-age=3600, s-maxage=86400"
+      }
+    });
+  };
+}
+function generateSitemapIndexXml(baseUrl, sitemaps) {
+  const normalizedBase = normalizeBaseUrl(baseUrl);
+  const xmlParts = [];
+  xmlParts.push(`
+        <?xml 
+            version="1.0" 
+            encoding="UTF-8"?
+        >
+    `);
+  xmlParts.push(`
+        <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+    `);
+  for (const entry of sitemaps) {
+    const fullLoc = createAbsoluteUrl(normalizedBase, entry.loc);
+    xmlParts.push(`<sitemap>`);
+    xmlParts.push(`
+        <loc>
+            ${encodeRaktaXmlValue(fullLoc)}
+        </loc>
+    `);
+    if (entry.lastmod) {
+      xmlParts.push(`
+        <lastmod>
+            ${encodeRaktaXmlValue(entry.lastmod)}
+        </lastmod>
+      `);
+    }
+    xmlParts.push(`</sitemap>`);
+  }
+  xmlParts.push(`</sitemapindex>`);
+  return xmlParts.join(`
+`);
+}
+// src/store/createStore.ts
+var import_react3 = __toESM(require_react(), 1);
+function createStoreApi(creator) {
+  const listeners = new Set;
+  let currentState;
+  const getState = () => currentState;
+  const emitChange = (nextState, previousState) => {
+    if (Object.is(previousState, nextState)) {
+      return;
+    }
+    for (const listenerFn of listeners) {
+      listenerFn(nextState, previousState);
+    }
+  };
+  const setState = (arg) => {
+    const previousState = currentState;
+    const partialUpdate = typeof arg === "function" ? arg(currentState) : arg;
+    currentState = {
+      ...currentState,
+      ...partialUpdate
+    };
+    emitChange(currentState, previousState);
+  };
+  const subscribe = (listenerFn) => {
+    listeners.add(listenerFn);
+    return () => {
+      listeners.delete(listenerFn);
+    };
+  };
+  currentState = creator(setState, getState);
+  const initialState = currentState;
+  const reset = () => {
+    const previousState = currentState;
+    currentState = initialState;
+    emitChange(currentState, previousState);
+  };
+  return {
+    getState,
+    setState,
+    subscribe,
+    reset
+  };
+}
+function createRaktaStore(creator) {
+  const storeApi = createStoreApi(creator);
+  function useStore(selector) {
+    const getSnapshot = () => {
+      const state = storeApi.getState();
+      if (selector !== undefined) {
+        return selector(state);
+      }
+      return state;
+    };
+    return import_react3.useSyncExternalStore(storeApi.subscribe, getSnapshot, getSnapshot);
+  }
+  return Object.assign(useStore, storeApi);
+}
+// src/tide/adapter.ts
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { join as join8 } from "path";
+
+// src/tide/runtime.ts
+function createRuntimeContext(request, url, params, resolvedMode) {
+  const searchParams = {};
+  url.searchParams.forEach((value, key) => {
+    searchParams[key] = value;
+  });
+  const requestHeaders = {};
+  request.headers.forEach((value, key) => {
+    requestHeaders[key] = value;
+  });
+  return {
+    url,
+    params,
+    request,
+    searchParams,
+    resolvedMode,
+    requestHeaders,
+    pathname: url.pathname,
+    timestampMs: Date.now(),
+    method: request.method.toUpperCase()
+  };
+}
+function buildTextResponse(body, status, headers) {
+  return new Response(body, { status, headers });
+}
+function buildHtmlResponse(html, status = 200) {
+  return buildTextResponse(html, status, {
+    "Content-Type": "text/html; charset=utf-8"
+  });
+}
+function buildJsonResponse2(responseData, status = 200) {
+  return buildTextResponse(JSON.stringify(responseData), status, {
+    "Content-Type": "application/json; charset=utf-8"
+  });
+}
+function buildErrorResponse(errorMessage, status = 500) {
+  return buildJsonResponse2({ error: errorMessage }, status);
+}
+
+// src/tide/adapter.ts
+var STATIC_MIME_TYPES = {
+  ".js": "application/javascript; charset=utf-8",
+  ".ts": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function mimeForPath(filePath) {
+  const extensionIndex = filePath.lastIndexOf(".");
+  if (extensionIndex < 0) {
+    return "application/octet-stream";
+  }
+  const extension = filePath.slice(extensionIndex).toLowerCase();
+  return STATIC_MIME_TYPES[extension] ?? "application/octet-stream";
+}
+function normalizeStaticPath(pathname) {
+  const pathnameWithoutLeadingSlash = pathname.replace(/^\/+/, "");
+  if (pathnameWithoutLeadingSlash.length > 0) {
+    return pathnameWithoutLeadingSlash;
+  }
+  return "index.html";
+}
+function isApiRouteExports(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return true;
+}
+function getApiRouteHandler(routeExports, method) {
+  if (method === "GET") {
+    return routeExports.GET;
+  }
+  if (method === "POST") {
+    return routeExports.POST;
+  }
+  if (method === "PUT") {
+    return routeExports.PUT;
+  }
+  if (method === "PATCH") {
+    return routeExports.PATCH;
+  }
+  if (method === "DELETE") {
+    return routeExports.DELETE;
+  }
+  if (method === "HEAD") {
+    return routeExports.HEAD;
+  }
+  if (method === "OPTIONS") {
+    return routeExports.OPTIONS;
+  }
+  return;
+}
+function createBunAdapter(adapterConfig, renderConfig) {
+  const manifest = generateManifest(adapterConfig.appDir);
+  const searchDirectories = [adapterConfig.publicDir, adapterConfig.outDir];
+  let serverInstance;
+  async function handle(request) {
+    const url = new URL(request.url);
+    const { pathname } = url;
+    const staticPathname = normalizeStaticPath(pathname);
+    for (const searchDirectory of searchDirectories) {
+      const filePath = join8(searchDirectory, staticPathname);
+      if (existsSync7(filePath) && !filePath.endsWith("/")) {
+        return new Response(readFileSync3(filePath), {
+          headers: {
+            "Content-Type": mimeForPath(filePath),
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        });
+      }
+    }
+    const apiRoutes = manifest.routes.filter((route) => route.kind === "api");
+    const apiMatch = matchRoute(pathname, apiRoutes);
+    if (apiMatch) {
+      const modulePath = join8(adapterConfig.appDir, apiMatch.entry.filePath);
+      const routeModule = await import(modulePath);
+      if (!isApiRouteExports(routeModule)) {
+        return new Response("Invalid API route module", {
+          status: 500
+        });
+      }
+      const handler = getApiRouteHandler(routeModule, request.method.toUpperCase());
+      if (!handler) {
+        return new Response("Method not allowed", {
+          status: 405
+        });
+      }
+      return await handler(request);
+    }
+    const resolvedRouteMode = resolveRouteMode(pathname, renderConfig);
+    const runtimeContext = createRuntimeContext(request, url, {}, resolvedRouteMode.mode);
+    const renderResult = await render({
+      routePath: runtimeContext.pathname,
+      mode: runtimeContext.resolvedMode,
+      params: runtimeContext.params,
+      searchParams: runtimeContext.searchParams,
+      requestHeaders: runtimeContext.requestHeaders,
+      timestampMs: runtimeContext.timestampMs
+    }, {
+      appName: adapterConfig.appName,
+      scriptPath: "/app.js",
+      cssPath: "/globals.css",
+      lang: "en"
+    });
+    if (renderResult.kind === "failure") {
+      return buildErrorResponse(renderResult.reason, renderResult.httpStatus);
+    }
+    return buildHtmlResponse(renderResult.html, renderResult.httpStatus);
+  }
+  return {
+    kind: "bun",
+    handle,
+    start: async () => {
+      serverInstance = Bun.serve({
+        port: adapterConfig.port,
+        hostname: adapterConfig.host,
+        fetch: handle
+      });
+      console.log(`[Rakta.js Tide] Running at http://${adapterConfig.host}:${serverInstance.port}`);
+    },
+    stop: () => {
+      if (!serverInstance) {
+        return;
+      }
+      serverInstance.stop();
+    }
+  };
+}
+// src/index.ts
+var RAKTA_NAME = "Rakta.js";
+var RAKTA_VERSION = "0.1.0";
+var RAKTA_TAGLINE = "Small in size. Fierce in speed. Alive in every route.";
+export {
+  writeManifest,
+  string,
+  startDevServer,
+  scanRoutes,
+  scanForExports,
+  resolveTitle,
+  resolveRouteMode,
+  resolveRobotsContent,
+  resolvePrecacheList,
+  requiresServer,
+  renderServerError,
+  renderNotFound,
+  render,
+  readManifest,
+  publicProcedure,
+  printManifest,
+  printInspectReport,
+  printAutoImportSummary,
+  preFixErrors,
+  object,
+  number,
+  mergeMetadata,
+  mergeConfig,
+  matchRoute,
+  loadConfig,
+  isRoadmapMode,
+  isBuildTimeMode,
+  inspectBuild,
+  getModeDescriptor,
+  generateSitemapXml,
+  generateSitemapIndexXml,
+  generateServiceWorkerSource,
+  generateRobotsTxt,
+  generateManifest2 as generatePwaManifest,
+  generateManifestJson,
+  generateManifest,
+  generateAutoImports,
+  findSpecialRoute,
+  findLayoutsForPathname,
+  defineRaktaConfig,
+  defineConfig,
+  defaultConfig,
+  createSitemapHandler,
+  createRuntimeContext,
+  createRpcHandler,
+  createRobotsHandler,
+  createRaktaStore,
+  createRaktaRouter,
+  createRaktaHttp,
+  createRaktaClient,
+  createManifestHandler,
+  createBunAdapter,
+  buildTextResponse,
+  buildProject,
+  buildJsonResponse2 as buildJsonResponse,
+  buildHtmlResponse,
+  buildErrorResponse,
+  buildCacheName,
+  boolean,
+  array,
+  StringType,
+  RaktaType,
+  RaktaSchemaError,
+  RaktaRpcError,
+  RaktaHttpClient,
+  RaktaHead,
+  RENDER_MODE_DESCRIPTORS,
+  RAKTA_VERSION,
+  RAKTA_TAGLINE,
+  RAKTA_NAME,
+  ProcedureBuilder,
+  Picture,
+  Picture as Photo,
+  OptionalType,
+  ObjectType,
+  NumberType,
+  HttpTimeoutError,
+  HttpResponseError,
+  HttpNetworkError,
+  Click,
+  BooleanType,
+  ArrayType
+};
+
+//# debugId=3BC1F83A70EC3DAC64756E2164756E21