veryfront 0.0.3 → 0.0.5

package/dist/data.js

@@ -0,0 +1,1132 @@
+// src/core/utils/cache/stores/memory/lru-list-manager.ts
+var LRUListManager = class {
+  constructor() {
+    this.head = null;
+    this.tail = null;
+  }
+  getHead() {
+    return this.head;
+  }
+  getTail() {
+    return this.tail;
+  }
+  moveToFront(node) {
+    if (node === this.head) {
+      node.entry.lastAccessed = Date.now();
+      return;
+    }
+    this.removeNode(node);
+    this.addToFront(node);
+  }
+  addToFront(node) {
+    node.next = this.head;
+    node.prev = null;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+      this.tail = node;
+    }
+    node.entry.lastAccessed = Date.now();
+  }
+  removeNode(node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+    if (node === this.head) {
+      this.head = node.next;
+    }
+    if (node === this.tail) {
+      this.tail = node.prev;
+    }
+  }
+  clear() {
+    this.head = null;
+    this.tail = null;
+  }
+};
+
+// src/core/utils/cache/eviction/eviction-manager.ts
+var EvictionManager = class {
+  constructor(options = {}) {
+    this.onEvict = options.onEvict;
+  }
+  evictIfNeeded(cache, lruTracker, newEntrySize, maxSize, maxMemory) {
+    while (cache.size >= maxSize) {
+      this.evictLRU(cache, lruTracker);
+    }
+    let memoryUsed = Array.from(cache.values()).reduce((sum, entry) => sum + entry.size, 0);
+    while (memoryUsed + newEntrySize > maxMemory && cache.size > 0) {
+      const evictedSize = this.evictLRU(cache, lruTracker);
+      memoryUsed -= evictedSize;
+    }
+  }
+  evictLRU(cache, lruTracker) {
+    const keyToEvict = lruTracker.getLRU();
+    if (!keyToEvict) {
+      return 0;
+    }
+    const entry = cache.get(keyToEvict);
+    const size = entry?.size || 0;
+    const value = entry?.value;
+    cache.delete(keyToEvict);
+    lruTracker.remove(keyToEvict);
+    if (this.onEvict && entry) {
+      this.onEvict(keyToEvict, value);
+    }
+    return size;
+  }
+  evictLRUFromList(listManager, store, tagIndex, currentSize) {
+    const tail = listManager.getTail();
+    if (!tail)
+      return currentSize;
+    const node = tail;
+    listManager.removeNode(node);
+    store.delete(node.key);
+    const newSize = currentSize - node.entry.size;
+    if (node.entry.tags) {
+      this.cleanupTags(node.entry.tags, node.key, tagIndex);
+    }
+    if (this.onEvict) {
+      this.onEvict(node.key, node.entry.value);
+    }
+    return newSize;
+  }
+  enforceMemoryLimits(listManager, store, tagIndex, currentSize, maxEntries, maxSizeBytes) {
+    let size = currentSize;
+    while ((store.size > maxEntries || size > maxSizeBytes) && listManager.getTail()) {
+      size = this.evictLRUFromList(listManager, store, tagIndex, size);
+    }
+    return size;
+  }
+  cleanupTags(tags, key, tagIndex) {
+    for (const tag of tags) {
+      const set = tagIndex.get(tag);
+      if (set) {
+        set.delete(key);
+        if (set.size === 0) {
+          tagIndex.delete(tag);
+        }
+      }
+    }
+  }
+  evictExpired(cache, lruTracker, ttl) {
+    const now = Date.now();
+    let evicted = 0;
+    for (const [key, entry] of cache.entries()) {
+      if (this.isExpired(entry, ttl, now)) {
+        cache.delete(key);
+        lruTracker.remove(key);
+        evicted++;
+      }
+    }
+    return evicted;
+  }
+  isExpired(entry, ttl, now = Date.now()) {
+    if (typeof entry.expiry === "number") {
+      return now > entry.expiry;
+    }
+    if (typeof entry.timestamp === "number" && typeof ttl === "number") {
+      const age = now - entry.timestamp;
+      return age > ttl;
+    }
+    return false;
+  }
+};
+
+// src/core/utils/cache/stores/memory/lru-node.ts
+var LRUNode = class {
+  constructor(key, entry, prev = null, next = null) {
+    this.key = key;
+    this.entry = entry;
+    this.prev = prev;
+    this.next = next;
+  }
+};
+
+// src/core/utils/cache/stores/memory/entry-manager.ts
+var EntryManager = class {
+  constructor(estimateSizeOf) {
+    this.estimateSizeOf = estimateSizeOf;
+  }
+  updateExistingEntry(node, value, ttlMs, tags, defaultTtlMs, listManager, tagIndex, key) {
+    const oldSize = node.entry.size;
+    const newSize = this.estimateSizeOf(value);
+    const expiry = this.calculateExpiry(ttlMs, defaultTtlMs);
+    if (node.entry.tags) {
+      this.cleanupTags(node.entry.tags, key, tagIndex);
+    }
+    node.entry = {
+      value,
+      size: newSize,
+      expiry,
+      tags,
+      lastAccessed: Date.now()
+    };
+    listManager.moveToFront(node);
+    return newSize - oldSize;
+  }
+  createNewEntry(key, value, ttlMs, tags, defaultTtlMs, listManager, store) {
+    const size = this.estimateSizeOf(value);
+    const expiry = this.calculateExpiry(ttlMs, defaultTtlMs);
+    const entry = {
+      value,
+      size,
+      expiry,
+      tags,
+      lastAccessed: Date.now()
+    };
+    const node = new LRUNode(key, entry);
+    store.set(key, node);
+    listManager.addToFront(node);
+    return [node, size];
+  }
+  updateTagIndex(tags, key, tagIndex) {
+    for (const tag of tags) {
+      if (!tagIndex.has(tag)) {
+        tagIndex.set(tag, /* @__PURE__ */ new Set());
+      }
+      tagIndex.get(tag)?.add(key);
+    }
+  }
+  cleanupTags(tags, key, tagIndex) {
+    for (const tag of tags) {
+      const set = tagIndex.get(tag);
+      if (set) {
+        set.delete(key);
+        if (set.size === 0) {
+          tagIndex.delete(tag);
+        }
+      }
+    }
+  }
+  calculateExpiry(ttlMs, defaultTtlMs) {
+    if (typeof ttlMs === "number") {
+      return Date.now() + ttlMs;
+    }
+    if (defaultTtlMs) {
+      return Date.now() + defaultTtlMs;
+    }
+    return void 0;
+  }
+};
+
+// src/core/utils/cache/stores/memory/lru-cache-adapter.ts
+function defaultSizeEstimator(value) {
+  if (value === null || value === void 0)
+    return 0;
+  if (typeof value === "string")
+    return value.length * 2;
+  if (typeof value === "number" || typeof value === "bigint")
+    return 8;
+  if (typeof value === "boolean")
+    return 4;
+  if (value instanceof Uint8Array || ArrayBuffer.isView(value))
+    return value.byteLength;
+  if (value instanceof ArrayBuffer)
+    return value.byteLength;
+  if (typeof Blob !== "undefined" && value instanceof Blob)
+    return value.size;
+  try {
+    return JSON.stringify(value).length * 2;
+  } catch {
+    return 0;
+  }
+}
+var LRUCacheAdapter = class {
+  constructor(options = {}) {
+    this.store = /* @__PURE__ */ new Map();
+    this.tagIndex = /* @__PURE__ */ new Map();
+    this.listManager = new LRUListManager();
+    this.currentSize = 0;
+    this.maxEntries = options.maxEntries || 1e3;
+    this.maxSizeBytes = options.maxSizeBytes || 50 * 1024 * 1024;
+    this.defaultTtlMs = options.ttlMs;
+    this.onEvict = options.onEvict;
+    const estimateSizeOf = options.estimateSizeOf || defaultSizeEstimator;
+    this.evictionManager = new EvictionManager({
+      onEvict: this.onEvict,
+      loggerContext: "MemoryCache"
+    });
+    this.entryManager = new EntryManager(estimateSizeOf);
+  }
+  get(key) {
+    const node = this.store.get(key);
+    if (!node)
+      return void 0;
+    if (this.evictionManager.isExpired(node.entry)) {
+      this.delete(key);
+      return void 0;
+    }
+    this.listManager.moveToFront(node);
+    return node.entry.value;
+  }
+  set(key, value, ttlMs, tags) {
+    const existingNode = this.store.get(key);
+    if (existingNode) {
+      const sizeDelta = this.entryManager.updateExistingEntry(
+        existingNode,
+        value,
+        ttlMs,
+        tags,
+        this.defaultTtlMs,
+        this.listManager,
+        this.tagIndex,
+        key
+      );
+      this.currentSize += sizeDelta;
+    } else {
+      const [_node, size] = this.entryManager.createNewEntry(
+        key,
+        value,
+        ttlMs,
+        tags,
+        this.defaultTtlMs,
+        this.listManager,
+        this.store
+      );
+      this.currentSize += size;
+    }
+    if (tags && tags.length > 0) {
+      this.entryManager.updateTagIndex(tags, key, this.tagIndex);
+    }
+    this.currentSize = this.evictionManager.enforceMemoryLimits(
+      this.listManager,
+      this.store,
+      this.tagIndex,
+      this.currentSize,
+      this.maxEntries,
+      this.maxSizeBytes
+    );
+  }
+  delete(key) {
+    const node = this.store.get(key);
+    if (!node)
+      return;
+    this.listManager.removeNode(node);
+    this.store.delete(key);
+    this.currentSize -= node.entry.size;
+    if (node.entry.tags) {
+      this.entryManager.cleanupTags(node.entry.tags, key, this.tagIndex);
+    }
+    if (this.onEvict) {
+      this.onEvict(key, node.entry.value);
+    }
+  }
+  invalidateTag(tag) {
+    const set = this.tagIndex.get(tag);
+    if (!set)
+      return 0;
+    let count = 0;
+    for (const key of set) {
+      this.delete(key);
+      count++;
+    }
+    this.tagIndex.delete(tag);
+    return count;
+  }
+  clear() {
+    if (this.onEvict) {
+      for (const [key, node] of this.store) {
+        this.onEvict(key, node.entry.value);
+      }
+    }
+    this.store.clear();
+    this.tagIndex.clear();
+    this.listManager.clear();
+    this.currentSize = 0;
+  }
+  getStats() {
+    return {
+      entries: this.store.size,
+      sizeBytes: this.currentSize,
+      maxEntries: this.maxEntries,
+      maxSizeBytes: this.maxSizeBytes,
+      tags: this.tagIndex.size
+    };
+  }
+  cleanupExpired() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, node] of this.store) {
+      if (typeof node.entry.expiry === "number" && now > node.entry.expiry) {
+        this.delete(key);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  keys() {
+    return this.store.keys();
+  }
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+};
+
+// src/core/utils/runtime-guards.ts
+function hasDenoRuntime(global) {
+  return typeof global === "object" && global !== null && "Deno" in global && typeof global.Deno?.env?.get === "function";
+}
+function hasNodeProcess(global) {
+  return typeof global === "object" && global !== null && "process" in global && typeof global.process?.env === "object";
+}
+
+// src/core/utils/logger/env.ts
+function getEnvironmentVariable(name) {
+  try {
+    if (typeof Deno !== "undefined" && hasDenoRuntime(globalThis)) {
+      const value = globalThis.Deno?.env.get(name);
+      return value === "" ? void 0 : value;
+    }
+    if (hasNodeProcess(globalThis)) {
+      const value = globalThis.process?.env[name];
+      return value === "" ? void 0 : value;
+    }
+  } catch (error) {
+    console.debug(`Failed to get environment variable ${name}:`, error);
+    return void 0;
+  }
+  return void 0;
+}
+
+// src/core/utils/logger/logger.ts
+var cachedLogLevel;
+function resolveLogLevel(force = false) {
+  if (force || cachedLogLevel === void 0) {
+    cachedLogLevel = getDefaultLevel();
+  }
+  return cachedLogLevel;
+}
+var ConsoleLogger = class {
+  constructor(prefix, level = resolveLogLevel()) {
+    this.prefix = prefix;
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.debug(`[${this.prefix}] DEBUG: ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`[${this.prefix}] ${message}`, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(`[${this.prefix}] WARN: ${message}`, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(`[${this.prefix}] ERROR: ${message}`, ...args);
+    }
+  }
+  async time(label, fn) {
+    const start = performance.now();
+    try {
+      const result = await fn();
+      const end = performance.now();
+      this.debug(`${label} completed in ${(end - start).toFixed(2)}ms`);
+      return result;
+    } catch (_error) {
+      const end = performance.now();
+      this.error(`${label} failed after ${(end - start).toFixed(2)}ms`, _error);
+      throw _error;
+    }
+  }
+};
+function parseLogLevel(levelString) {
+  if (!levelString)
+    return void 0;
+  const upper = levelString.toUpperCase();
+  switch (upper) {
+    case "DEBUG":
+      return 0 /* DEBUG */;
+    case "WARN":
+      return 2 /* WARN */;
+    case "ERROR":
+      return 3 /* ERROR */;
+    case "INFO":
+      return 1 /* INFO */;
+    default:
+      return void 0;
+  }
+}
+var getDefaultLevel = () => {
+  const envLevel = getEnvironmentVariable("LOG_LEVEL");
+  const parsedLevel = parseLogLevel(envLevel);
+  if (parsedLevel !== void 0)
+    return parsedLevel;
+  const debugFlag = getEnvironmentVariable("VERYFRONT_DEBUG");
+  if (debugFlag === "1" || debugFlag === "true")
+    return 0 /* DEBUG */;
+  return 1 /* INFO */;
+};
+var trackedLoggers = /* @__PURE__ */ new Set();
+function createLogger(prefix) {
+  const logger2 = new ConsoleLogger(prefix);
+  trackedLoggers.add(logger2);
+  return logger2;
+}
+var cliLogger = createLogger("CLI");
+var serverLogger = createLogger("SERVER");
+var rendererLogger = createLogger("RENDERER");
+var bundlerLogger = createLogger("BUNDLER");
+var agentLogger = createLogger("AGENT");
+var logger = createLogger("VERYFRONT");
+
+// src/core/utils/constants/cache.ts
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var MS_PER_SECOND = 1e3;
+var DEFAULT_LRU_MAX_ENTRIES = 100;
+var COMPONENT_LOADER_TTL_MS = 10 * MINUTES_PER_HOUR * MS_PER_SECOND;
+var MDX_RENDERER_TTL_MS = 10 * MINUTES_PER_HOUR * MS_PER_SECOND;
+var RENDERER_CORE_TTL_MS = 5 * MINUTES_PER_HOUR * MS_PER_SECOND;
+var TSX_LAYOUT_TTL_MS = 10 * MINUTES_PER_HOUR * MS_PER_SECOND;
+var DATA_FETCHING_MAX_ENTRIES = 200;
+var DATA_FETCHING_TTL_MS = 10 * MINUTES_PER_HOUR * MS_PER_SECOND;
+var MDX_CACHE_TTL_PRODUCTION_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var MDX_CACHE_TTL_DEVELOPMENT_MS = 5 * MINUTES_PER_HOUR * MS_PER_SECOND;
+var BUNDLE_CACHE_TTL_PRODUCTION_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var BUNDLE_CACHE_TTL_DEVELOPMENT_MS = 5 * MINUTES_PER_HOUR * MS_PER_SECOND;
+var BUNDLE_MANIFEST_PROD_TTL_MS = 7 * HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var BUNDLE_MANIFEST_DEV_TTL_MS = MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var SERVER_ACTION_DEFAULT_TTL_SEC = MINUTES_PER_HOUR * SECONDS_PER_MINUTE;
+var ONE_DAY_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var LRU_DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
+
+// src/core/utils/constants/http.ts
+var KB_IN_BYTES = 1024;
+var PREFETCH_MAX_SIZE_BYTES = 200 * KB_IN_BYTES;
+
+// src/core/utils/constants/hmr.ts
+var HMR_MAX_MESSAGE_SIZE_BYTES = 1024 * KB_IN_BYTES;
+
+// src/core/utils/constants/network.ts
+var BYTES_PER_MB = 1024 * 1024;
+
+// deno.json
+var deno_default = {
+  name: "veryfront",
+  version: "0.1.0",
+  nodeModulesDir: "auto",
+  workspace: [
+    "./examples/async-worker-redis",
+    "./examples/knowledge-base",
+    "./examples/form-handling",
+    "./examples/middleware-demo",
+    "./examples/coding-agent",
+    "./examples/durable-workflows"
+  ],
+  exports: {
+    ".": "./src/index.ts",
+    "./cli": "./src/cli/main.ts",
+    "./server": "./src/server/index.ts",
+    "./middleware": "./src/middleware/index.ts",
+    "./components": "./src/react/components/index.ts",
+    "./data": "./src/data/index.ts",
+    "./config": "./src/core/config/index.ts",
+    "./ai": "./src/ai/index.ts",
+    "./ai/client": "./src/ai/client.ts",
+    "./ai/react": "./src/ai/react/index.ts",
+    "./ai/primitives": "./src/ai/react/primitives/index.ts",
+    "./ai/components": "./src/ai/react/components/index.ts",
+    "./ai/production": "./src/ai/production/index.ts",
+    "./ai/dev": "./src/ai/dev/index.ts",
+    "./ai/workflow": "./src/ai/workflow/index.ts",
+    "./ai/workflow/react": "./src/ai/workflow/react/index.ts"
+  },
+  imports: {
+    "@veryfront": "./src/index.ts",
+    "@veryfront/": "./src/",
+    "@veryfront/ai": "./src/ai/index.ts",
+    "@veryfront/ai/": "./src/ai/",
+    "@veryfront/platform": "./src/platform/index.ts",
+    "@veryfront/platform/": "./src/platform/",
+    "@veryfront/types": "./src/core/types/index.ts",
+    "@veryfront/types/": "./src/core/types/",
+    "@veryfront/utils": "./src/core/utils/index.ts",
+    "@veryfront/utils/": "./src/core/utils/",
+    "@veryfront/middleware": "./src/middleware/index.ts",
+    "@veryfront/middleware/": "./src/middleware/",
+    "@veryfront/errors": "./src/core/errors/index.ts",
+    "@veryfront/errors/": "./src/core/errors/",
+    "@veryfront/config": "./src/core/config/index.ts",
+    "@veryfront/config/": "./src/core/config/",
+    "@veryfront/observability": "./src/observability/index.ts",
+    "@veryfront/observability/": "./src/observability/",
+    "@veryfront/routing": "./src/routing/index.ts",
+    "@veryfront/routing/": "./src/routing/",
+    "@veryfront/transforms": "./src/build/transforms/index.ts",
+    "@veryfront/transforms/": "./src/build/transforms/",
+    "@veryfront/data": "./src/data/index.ts",
+    "@veryfront/data/": "./src/data/",
+    "@veryfront/security": "./src/security/index.ts",
+    "@veryfront/security/": "./src/security/",
+    "@veryfront/components": "./src/react/components/index.ts",
+    "@veryfront/react": "./src/react/index.ts",
+    "@veryfront/react/": "./src/react/",
+    "@veryfront/html": "./src/html/index.ts",
+    "@veryfront/html/": "./src/html/",
+    "@veryfront/rendering": "./src/rendering/index.ts",
+    "@veryfront/rendering/": "./src/rendering/",
+    "@veryfront/build": "./src/build/index.ts",
+    "@veryfront/build/": "./src/build/",
+    "@veryfront/server": "./src/server/index.ts",
+    "@veryfront/server/": "./src/server/",
+    "@veryfront/modules": "./src/module-system/index.ts",
+    "@veryfront/modules/": "./src/module-system/",
+    "@veryfront/compat/console": "./src/platform/compat/console/index.ts",
+    "@veryfront/compat/": "./src/platform/compat/",
+    "std/": "https://deno.land/std@0.220.0/",
+    "@std/path": "https://deno.land/std@0.220.0/path/mod.ts",
+    "@std/testing/bdd.ts": "https://deno.land/std@0.220.0/testing/bdd.ts",
+    "@std/expect": "https://deno.land/std@0.220.0/expect/mod.ts",
+    csstype: "https://esm.sh/csstype@3.2.3",
+    "@types/react": "https://esm.sh/@types/react@18.3.27?deps=csstype@3.2.3",
+    "@types/react-dom": "https://esm.sh/@types/react-dom@18.3.7?deps=csstype@3.2.3",
+    react: "https://esm.sh/react@18.3.1",
+    "react-dom": "https://esm.sh/react-dom@18.3.1",
+    "react-dom/server": "https://esm.sh/react-dom@18.3.1/server",
+    "react-dom/client": "https://esm.sh/react-dom@18.3.1/client",
+    "react/jsx-runtime": "https://esm.sh/react@18.3.1/jsx-runtime",
+    "react/jsx-dev-runtime": "https://esm.sh/react@18.3.1/jsx-dev-runtime",
+    "@mdx-js/mdx": "https://esm.sh/@mdx-js/mdx@3.0.0?deps=react@18.3.1,react-dom@18.3.1",
+    "@mdx-js/react": "https://esm.sh/@mdx-js/react@3.0.0?deps=react@18.3.1,react-dom@18.3.1",
+    "unist-util-visit": "https://esm.sh/unist-util-visit@5.0.0",
+    "mdast-util-to-string": "https://esm.sh/mdast-util-to-string@4.0.0",
+    "github-slugger": "https://esm.sh/github-slugger@2.0.0",
+    "remark-gfm": "https://esm.sh/remark-gfm@4.0.1",
+    "remark-frontmatter": "https://esm.sh/remark-frontmatter@5.0.0",
+    "rehype-highlight": "https://esm.sh/rehype-highlight@7.0.2",
+    "rehype-slug": "https://esm.sh/rehype-slug@6.0.0",
+    esbuild: "https://deno.land/x/esbuild@v0.20.1/wasm.js",
+    "esbuild/mod.js": "https://deno.land/x/esbuild@v0.20.1/mod.js",
+    "es-module-lexer": "https://esm.sh/es-module-lexer@1.5.0",
+    zod: "https://esm.sh/zod@3.22.0",
+    "mime-types": "https://esm.sh/mime-types@2.1.35",
+    mdast: "https://esm.sh/@types/mdast@4.0.3",
+    hast: "https://esm.sh/@types/hast@3.0.3",
+    unist: "https://esm.sh/@types/unist@3.0.2",
+    unified: "https://esm.sh/unified@11.0.5?dts",
+    ai: "https://esm.sh/ai@5.0.76",
+    "ai/react": "https://esm.sh/@ai-sdk/react@2.0.59",
+    "@ai-sdk/openai": "https://esm.sh/@ai-sdk/openai@2.0.1",
+    "@ai-sdk/anthropic": "https://esm.sh/@ai-sdk/anthropic@2.0.4",
+    unocss: "https://esm.sh/unocss@0.59.0",
+    "@unocss/core": "https://esm.sh/@unocss/core@0.59.0",
+    "@unocss/preset-wind": "https://esm.sh/@unocss/preset-wind@0.59.0"
+  },
+  compilerOptions: {
+    jsx: "react-jsx",
+    jsxImportSource: "react",
+    strict: true,
+    noImplicitAny: true,
+    noUncheckedIndexedAccess: true,
+    types: [],
+    lib: [
+      "deno.window",
+      "dom",
+      "dom.iterable",
+      "dom.asynciterable",
+      "deno.ns"
+    ]
+  },
+  tasks: {
+    setup: "deno run --allow-all scripts/setup.ts",
+    dev: "deno run --allow-all --no-lock --unstable-net --unstable-worker-options src/cli/main.ts dev",
+    build: "deno compile --allow-all --output ../../bin/veryfront src/cli/main.ts",
+    "build:npm": "deno run -A scripts/build-npm.ts",
+    test: "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
+    "test:unit": "DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests --unstable-worker-options --unstable-net",
+    "test:integration": "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
+    "test:batches": "deno run --allow-all scripts/test-batches.ts",
+    "test:unsafe": "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --unstable-worker-options --unstable-net",
+    "test:coverage": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --unstable-worker-options --unstable-net || exit 1",
+    "test:coverage:unit": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --ignore=tests --unstable-worker-options --unstable-net || exit 1",
+    "test:coverage:integration": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage tests --unstable-worker-options --unstable-net || exit 1",
+    "coverage:report": "deno coverage coverage --include=src/ --exclude=tests --exclude=src/**/*_test.ts --exclude=src/**/*_test.tsx --exclude=src/**/*.test.ts --exclude=src/**/*.test.tsx --lcov > coverage/lcov.info && deno run --allow-read scripts/check-coverage.ts 80",
+    "coverage:html": "deno coverage coverage --include=src/ --exclude=tests --exclude=src/**/*_test.ts --exclude=src/**/*_test.tsx --exclude=src/**/*.test.ts --exclude=src/**/*.test.tsx --html",
+    lint: "deno lint src/",
+    fmt: "deno fmt src/",
+    typecheck: "deno check src/index.ts src/cli/main.ts src/server/index.ts src/routing/api/index.ts src/rendering/index.ts src/platform/index.ts src/platform/adapters/index.ts src/build/index.ts src/build/production-build/index.ts src/build/transforms/index.ts src/core/config/index.ts src/core/utils/index.ts src/data/index.ts src/security/index.ts src/middleware/index.ts src/server/handlers/dev/index.ts src/server/handlers/request/api/index.ts src/rendering/cache/index.ts src/rendering/cache/stores/index.ts src/rendering/rsc/actions/index.ts src/html/index.ts src/module-system/index.ts",
+    "docs:check-links": "deno run -A scripts/check-doc-links.ts",
+    "lint:ban-console": "deno run --allow-read scripts/ban-console.ts",
+    "lint:ban-deep-imports": "deno run --allow-read scripts/ban-deep-imports.ts",
+    "lint:ban-internal-root-imports": "deno run --allow-read scripts/ban-internal-root-imports.ts",
+    "lint:check-awaits": "deno run --allow-read scripts/check-unawaited-promises.ts",
+    "check:circular": "deno run -A jsr:@cunarist/deno-circular-deps src/index.ts"
+  },
+  lint: {
+    include: [
+      "src/**/*.ts",
+      "src/**/*.tsx"
+    ],
+    exclude: [
+      "dist/",
+      "coverage/"
+    ],
+    rules: {
+      tags: [
+        "recommended"
+      ],
+      include: [
+        "ban-untagged-todo"
+      ],
+      exclude: [
+        "no-explicit-any",
+        "no-process-global",
+        "no-console"
+      ]
+    }
+  },
+  fmt: {
+    include: [
+      "src/**/*.ts",
+      "src/**/*.tsx"
+    ],
+    exclude: [
+      "dist/",
+      "coverage/"
+    ],
+    options: {
+      useTabs: false,
+      lineWidth: 100,
+      indentWidth: 2,
+      semiColons: true,
+      singleQuote: false,
+      proseWrap: "preserve"
+    }
+  }
+};
+
+// src/core/utils/version.ts
+var VERSION = typeof deno_default.version === "string" ? deno_default.version : "0.0.0";
+
+// src/core/utils/bundle-manifest.ts
+var InMemoryBundleManifestStore = class {
+  constructor() {
+    this.metadata = /* @__PURE__ */ new Map();
+    this.code = /* @__PURE__ */ new Map();
+    this.sourceIndex = /* @__PURE__ */ new Map();
+  }
+  getBundleMetadata(key) {
+    const entry = this.metadata.get(key);
+    if (!entry)
+      return Promise.resolve(void 0);
+    if (entry.expiry && Date.now() > entry.expiry) {
+      this.metadata.delete(key);
+      return Promise.resolve(void 0);
+    }
+    return Promise.resolve(entry.value);
+  }
+  setBundleMetadata(key, metadata, ttlMs) {
+    const expiry = ttlMs ? Date.now() + ttlMs : void 0;
+    this.metadata.set(key, { value: metadata, expiry });
+    if (!this.sourceIndex.has(metadata.source)) {
+      this.sourceIndex.set(metadata.source, /* @__PURE__ */ new Set());
+    }
+    this.sourceIndex.get(metadata.source).add(key);
+    return Promise.resolve();
+  }
+  getBundleCode(hash) {
+    const entry = this.code.get(hash);
+    if (!entry)
+      return Promise.resolve(void 0);
+    if (entry.expiry && Date.now() > entry.expiry) {
+      this.code.delete(hash);
+      return Promise.resolve(void 0);
+    }
+    return Promise.resolve(entry.value);
+  }
+  setBundleCode(hash, code, ttlMs) {
+    const expiry = ttlMs ? Date.now() + ttlMs : void 0;
+    this.code.set(hash, { value: code, expiry });
+    return Promise.resolve();
+  }
+  async deleteBundle(key) {
+    const metadata = await this.getBundleMetadata(key);
+    this.metadata.delete(key);
+    if (metadata) {
+      this.code.delete(metadata.codeHash);
+      const sourceKeys = this.sourceIndex.get(metadata.source);
+      if (sourceKeys) {
+        sourceKeys.delete(key);
+        if (sourceKeys.size === 0) {
+          this.sourceIndex.delete(metadata.source);
+        }
+      }
+    }
+  }
+  async invalidateSource(source) {
+    const keys = this.sourceIndex.get(source);
+    if (!keys)
+      return 0;
+    let count = 0;
+    for (const key of Array.from(keys)) {
+      await this.deleteBundle(key);
+      count++;
+    }
+    this.sourceIndex.delete(source);
+    return count;
+  }
+  clear() {
+    this.metadata.clear();
+    this.code.clear();
+    this.sourceIndex.clear();
+    return Promise.resolve();
+  }
+  isAvailable() {
+    return Promise.resolve(true);
+  }
+  getStats() {
+    let totalSize = 0;
+    let oldest;
+    let newest;
+    for (const { value } of this.metadata.values()) {
+      totalSize += value.size;
+      if (!oldest || value.compiledAt < oldest)
+        oldest = value.compiledAt;
+      if (!newest || value.compiledAt > newest)
+        newest = value.compiledAt;
+    }
+    return Promise.resolve({
+      totalBundles: this.metadata.size,
+      totalSize,
+      oldestBundle: oldest,
+      newestBundle: newest
+    });
+  }
+};
+var manifestStore = new InMemoryBundleManifestStore();
+
+// src/core/utils/lru-wrapper.ts
+var LRUCache = class {
+  adapter;
+  cleanupTimer;
+  cleanupIntervalMs;
+  ttlMs;
+  constructor(options = {}) {
+    const adapterOptions = {
+      maxEntries: options.maxEntries ?? DEFAULT_LRU_MAX_ENTRIES,
+      ttlMs: options.ttlMs
+    };
+    this.adapter = new LRUCacheAdapter(adapterOptions);
+    this.ttlMs = options.ttlMs;
+    this.cleanupIntervalMs = options.cleanupIntervalMs ?? 6e4;
+    if (this.ttlMs && this.ttlMs > 0) {
+      this.startPeriodicCleanup();
+    }
+  }
+  startPeriodicCleanup() {
+    if (shouldDisableInterval()) {
+      return;
+    }
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+    const timer = setInterval(() => {
+      this.adapter.cleanupExpired();
+    }, this.cleanupIntervalMs);
+    this.cleanupTimer = timer;
+  }
+  toStringKey(key) {
+    if (typeof key === "string") {
+      return key;
+    }
+    return String(key);
+  }
+  get size() {
+    return this.adapter.getStats().entries;
+  }
+  has(key) {
+    return this.adapter.get(this.toStringKey(key)) !== void 0;
+  }
+  get(key) {
+    return this.adapter.get(this.toStringKey(key));
+  }
+  set(key, value) {
+    this.adapter.set(this.toStringKey(key), value);
+  }
+  delete(key) {
+    const stringKey = this.toStringKey(key);
+    const had = this.adapter.get(stringKey) !== void 0;
+    this.adapter.delete(stringKey);
+    return had;
+  }
+  clear() {
+    this.adapter.clear();
+  }
+  cleanup() {
+    this.adapter.cleanupExpired();
+  }
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+    this.adapter.clear();
+  }
+  keys() {
+    return this.adapter.keys();
+  }
+};
+function shouldDisableInterval() {
+  if (globalThis.__vfDisableLruInterval === true) {
+    return true;
+  }
+  try {
+    return process.env("VF_DISABLE_LRU_INTERVAL") === "1";
+  } catch (_error) {
+    return false;
+  }
+}
+
+// src/data/data-fetching-cache.ts
+function isLruIntervalDisabled() {
+  if (globalThis.__vfDisableLruInterval === true) {
+    return true;
+  }
+  try {
+    return process.env.VF_DISABLE_LRU_INTERVAL === "1";
+  } catch (_error) {
+    return false;
+  }
+}
+var CacheManager = class {
+  constructor() {
+    this.cache = new LRUCache({
+      maxEntries: DATA_FETCHING_MAX_ENTRIES,
+      ttlMs: isLruIntervalDisabled() ? void 0 : DATA_FETCHING_TTL_MS
+    });
+    this.cacheKeys = /* @__PURE__ */ new Set();
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    return entry ?? null;
+  }
+  set(key, entry) {
+    this.cache.set(key, entry);
+    this.cacheKeys.add(key);
+  }
+  delete(key) {
+    this.cache.delete(key);
+    this.cacheKeys.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+    this.cacheKeys.clear();
+  }
+  clearPattern(pattern) {
+    for (const key of this.cacheKeys) {
+      if (key.includes(pattern)) {
+        this.delete(key);
+      }
+    }
+  }
+  shouldRevalidate(entry) {
+    if (entry.revalidate === false) {
+      return false;
+    }
+    if (typeof entry.revalidate === "number") {
+      const age = Date.now() - entry.timestamp;
+      return age > entry.revalidate * 1e3;
+    }
+    return false;
+  }
+  createCacheKey(context) {
+    const params = JSON.stringify(context.params);
+    const pathname = context.url.pathname;
+    return `${pathname}::${params}`;
+  }
+};
+
+// src/data/server-data-fetcher.ts
+var ServerDataFetcher = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  async fetch(pageModule, context) {
+    if (!pageModule.getServerData) {
+      return { props: {} };
+    }
+    try {
+      const result = await pageModule.getServerData(context);
+      if (result.redirect) {
+        return { redirect: result.redirect };
+      }
+      if (result.notFound) {
+        return { notFound: true };
+      }
+      return {
+        props: result.props ?? {},
+        revalidate: result.revalidate
+      };
+    } catch (error) {
+      this.logError("Error in getServerData:", error);
+      throw error;
+    }
+  }
+  logError(message, error) {
+    const debugEnabled = this.adapter?.env.get("VERYFRONT_DEBUG");
+    if (debugEnabled) {
+      serverLogger.error(message, error);
+    }
+  }
+};
+
+// src/data/static-data-fetcher.ts
+var StaticDataFetcher = class {
+  constructor(cacheManager, adapter) {
+    this.cacheManager = cacheManager;
+    this.adapter = adapter;
+    this.pendingRevalidations = /* @__PURE__ */ new Map();
+  }
+  async fetch(pageModule, context) {
+    if (!pageModule.getStaticData) {
+      return { props: {} };
+    }
+    const cacheKey = this.cacheManager.createCacheKey(context);
+    const cached = this.cacheManager.get(cacheKey);
+    if (cached && !this.cacheManager.shouldRevalidate(cached)) {
+      return cached.data;
+    }
+    if (cached && this.cacheManager.shouldRevalidate(cached)) {
+      if (!this.pendingRevalidations.has(cacheKey)) {
+        this.pendingRevalidations.set(
+          cacheKey,
+          this.revalidateInBackground(pageModule, context, cacheKey)
+        );
+      }
+      return cached.data;
+    }
+    return await this.fetchFresh(pageModule, context, cacheKey);
+  }
+  async fetchFresh(pageModule, context, cacheKey) {
+    if (!pageModule.getStaticData) {
+      return { props: {} };
+    }
+    try {
+      const result = await pageModule.getStaticData({
+        params: context.params,
+        url: context.url
+      });
+      this.cacheManager.set(cacheKey, {
+        data: result,
+        timestamp: Date.now(),
+        revalidate: result.revalidate
+      });
+      return result;
+    } catch (error) {
+      this.logError("Error in getStaticData:", error);
+      throw error;
+    }
+  }
+  async revalidateInBackground(pageModule, context, cacheKey) {
+    try {
+      if (!pageModule.getStaticData) {
+        return;
+      }
+      const result = await pageModule.getStaticData({
+        params: context.params,
+        url: context.url
+      });
+      this.cacheManager.set(cacheKey, {
+        data: result,
+        timestamp: Date.now(),
+        revalidate: result.revalidate
+      });
+    } catch (error) {
+      this.logError("Error revalidating data:", error);
+    } finally {
+      this.pendingRevalidations.delete(cacheKey);
+    }
+  }
+  logError(message, error) {
+    const debugEnabled = this.adapter?.env.get("VERYFRONT_DEBUG");
+    if (debugEnabled) {
+      serverLogger.error(message, error);
+    }
+  }
+};
+
+// src/data/static-paths-fetcher.ts
+var StaticPathsFetcher = class {
+  async fetch(pageModule) {
+    if (!pageModule.getStaticPaths) {
+      return null;
+    }
+    try {
+      return await pageModule.getStaticPaths();
+    } catch (error) {
+      this.logError("Error in getStaticPaths:", error);
+      throw error;
+    }
+  }
+  logError(message, error) {
+    serverLogger.error(message, error);
+  }
+};
+
+// src/data/data-fetcher.ts
+var DataFetcher = class {
+  constructor(adapter) {
+    this.cacheManager = new CacheManager();
+    this.serverFetcher = new ServerDataFetcher(adapter);
+    this.staticFetcher = new StaticDataFetcher(this.cacheManager, adapter);
+    this.pathsFetcher = new StaticPathsFetcher();
+  }
+  async fetchData(pageModule, context, mode = "development") {
+    if (!pageModule.getServerData && !pageModule.getStaticData) {
+      return { props: {} };
+    }
+    if (mode === "development" && pageModule.getServerData) {
+      return await this.serverFetcher.fetch(pageModule, context);
+    }
+    if (pageModule.getStaticData) {
+      return await this.staticFetcher.fetch(pageModule, context);
+    }
+    if (pageModule.getServerData) {
+      return await this.serverFetcher.fetch(pageModule, context);
+    }
+    return { props: {} };
+  }
+  async getStaticPaths(pageModule) {
+    return await this.pathsFetcher.fetch(pageModule);
+  }
+  clearCache(pattern) {
+    if (pattern) {
+      this.cacheManager.clearPattern(pattern);
+    } else {
+      this.cacheManager.clear();
+    }
+  }
+};
+
+// src/data/helpers.ts
+var redirect = (destination, permanent = false) => ({
+  redirect: { destination, permanent }
+});
+var notFound = () => ({
+  notFound: true
+});
+export {
+  DataFetcher,
+  notFound,
+  redirect
+};
+//# sourceMappingURL=data.js.map