@ereo/data 0.1.6

package/dist/index.js

@@ -0,0 +1,1587 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/cache.ts
+var exports_cache = {};
+__export(exports_cache, {
+  setCache: () => setCache,
+  parseCacheControl: () => parseCacheControl,
+  getCache: () => getCache,
+  generateCacheKey: () => generateCacheKey,
+  createDataCacheAdapter: () => createDataCacheAdapter,
+  cached: () => cached,
+  cacheKey: () => cacheKey,
+  buildCacheControl: () => buildCacheControl,
+  MemoryCache: () => MemoryCache,
+  Cached: () => Cached
+});
+
+class MemoryCache {
+  cache = new Map;
+  tagIndex = new Map;
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry)
+      return null;
+    const age = Date.now() - entry.timestamp;
+    const isStale = age > entry.maxAge * 1000;
+    const isExpired = isStale && (!entry.staleWhileRevalidate || age > (entry.maxAge + entry.staleWhileRevalidate) * 1000);
+    if (isExpired) {
+      await this.delete(key);
+      return null;
+    }
+    return entry;
+  }
+  async set(key, entry) {
+    if (this.cache.has(key)) {
+      await this.delete(key);
+    }
+    this.cache.set(key, entry);
+    for (const tag of entry.tags) {
+      if (!this.tagIndex.has(tag)) {
+        this.tagIndex.set(tag, new Set);
+      }
+      this.tagIndex.get(tag).add(key);
+    }
+  }
+  async delete(key) {
+    const entry = this.cache.get(key);
+    if (entry) {
+      for (const tag of entry.tags) {
+        const tagSet = this.tagIndex.get(tag);
+        if (tagSet) {
+          tagSet.delete(key);
+          if (tagSet.size === 0) {
+            this.tagIndex.delete(tag);
+          }
+        }
+      }
+      this.cache.delete(key);
+      return true;
+    }
+    return false;
+  }
+  async deleteByTag(tag) {
+    const keys = this.tagIndex.get(tag);
+    if (keys) {
+      const keysCopy = [...keys];
+      for (const key of keysCopy) {
+        await this.delete(key);
+      }
+    }
+  }
+  async clear() {
+    this.cache.clear();
+    this.tagIndex.clear();
+  }
+  async keys() {
+    return Array.from(this.cache.keys());
+  }
+  getStats() {
+    return {
+      size: this.cache.size,
+      tags: this.tagIndex.size
+    };
+  }
+  async getValue(key) {
+    const entry = await this.get(key);
+    return entry?.value;
+  }
+  async setValue(key, value, options) {
+    const entry = {
+      value,
+      timestamp: Date.now(),
+      maxAge: options?.ttl ?? 60,
+      tags: options?.tags ?? []
+    };
+    await this.set(key, entry);
+  }
+  async has(key) {
+    const entry = await this.get(key);
+    return entry !== null;
+  }
+  async invalidateTag(tag) {
+    return this.deleteByTag(tag);
+  }
+  async invalidateTags(tags) {
+    for (const tag of tags) {
+      await this.invalidateTag(tag);
+    }
+  }
+  async getByTag(tag) {
+    const keys = this.tagIndex.get(tag);
+    if (!keys) {
+      return [];
+    }
+    const validKeys = [];
+    for (const key of keys) {
+      if (await this.has(key)) {
+        validKeys.push(key);
+      }
+    }
+    return validKeys;
+  }
+  asCacheAdapter() {
+    return {
+      get: (key) => this.getValue(key),
+      set: (key, value, options) => this.setValue(key, value, options),
+      delete: (key) => this.delete(key),
+      has: (key) => this.has(key),
+      clear: () => this.clear(),
+      invalidateTag: (tag) => this.invalidateTag(tag),
+      invalidateTags: (tags) => this.invalidateTags(tags),
+      getByTag: (tag) => this.getByTag(tag)
+    };
+  }
+}
+function createDataCacheAdapter() {
+  const memoryCache = new MemoryCache;
+  return memoryCache.asCacheAdapter();
+}
+function getCache() {
+  if (!globalCache) {
+    globalCache = new MemoryCache;
+  }
+  return globalCache;
+}
+function setCache(storage) {
+  globalCache = storage;
+}
+async function cached(key, fn, options) {
+  const cache = getCache();
+  const entry = await cache.get(key);
+  if (entry) {
+    const age = Date.now() - entry.timestamp;
+    const isStale = age > entry.maxAge * 1000;
+    if (!isStale) {
+      return entry.value;
+    }
+    if (entry.staleWhileRevalidate) {
+      revalidate(key, fn, options);
+      return entry.value;
+    }
+  }
+  const value = await fn();
+  await cache.set(key, {
+    value,
+    timestamp: Date.now(),
+    maxAge: options.maxAge ?? 60,
+    staleWhileRevalidate: options.staleWhileRevalidate,
+    tags: options.tags ?? []
+  });
+  return value;
+}
+async function revalidate(key, fn, options) {
+  try {
+    const value = await fn();
+    const cache = getCache();
+    await cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      maxAge: options.maxAge ?? 60,
+      staleWhileRevalidate: options.staleWhileRevalidate,
+      tags: options.tags ?? []
+    });
+  } catch (error2) {
+    console.error(`Failed to revalidate cache key: ${key}`, error2);
+  }
+}
+function generateCacheKey(request) {
+  const url = new URL(request.url);
+  return `${request.method}:${url.pathname}${url.search}`;
+}
+function cacheKey(prefix, ...parts) {
+  return `${prefix}:${parts.join(":")}`;
+}
+function buildCacheControl(options) {
+  const parts = [];
+  if (options.private) {
+    parts.push("private");
+  } else {
+    parts.push("public");
+  }
+  if (options.maxAge !== undefined) {
+    parts.push(`max-age=${options.maxAge}`);
+  }
+  if (options.staleWhileRevalidate !== undefined) {
+    parts.push(`stale-while-revalidate=${options.staleWhileRevalidate}`);
+  }
+  return parts.join(", ");
+}
+function parseCacheControl(header) {
+  const options = {};
+  const directives = header.split(",").map((d) => d.trim().toLowerCase());
+  for (const directive of directives) {
+    if (directive === "private") {
+      options.private = true;
+    } else if (directive.startsWith("max-age=")) {
+      options.maxAge = parseInt(directive.slice(8), 10);
+    } else if (directive.startsWith("stale-while-revalidate=")) {
+      options.staleWhileRevalidate = parseInt(directive.slice(23), 10);
+    }
+  }
+  return options;
+}
+function Cached(options) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const key = cacheKey(propertyKey, JSON.stringify(args));
+      return cached(key, () => originalMethod.apply(this, args), options);
+    };
+    return descriptor;
+  };
+}
+var globalCache = null;
+
+// src/loader.ts
+function createLoader(options) {
+  return async (args) => {
+    const { context } = args;
+    if (options.cache) {
+      context.cache.set(options.cache);
+    }
+    try {
+      const rawData = await options.load(args);
+      if (options.transform) {
+        const transformed = await options.transform(rawData, args);
+        return transformed;
+      }
+      return rawData;
+    } catch (error) {
+      if (options.onError && error instanceof Error) {
+        const result = await options.onError(error, args);
+        if (result instanceof Response) {
+          throw result;
+        }
+        return result;
+      }
+      throw error;
+    }
+  };
+}
+function defer(promise) {
+  const deferred = {
+    promise,
+    status: "pending"
+  };
+  promise.then((value) => {
+    deferred.status = "resolved";
+    deferred.value = value;
+  }).catch((error) => {
+    deferred.status = "rejected";
+    deferred.error = error;
+  });
+  return deferred;
+}
+function isDeferred(value) {
+  return typeof value === "object" && value !== null && "promise" in value && "status" in value;
+}
+async function resolveDeferred(deferred) {
+  return deferred.promise;
+}
+async function fetchData(input, init) {
+  const response = await fetch(input, init);
+  if (!response.ok) {
+    throw new FetchError(`Fetch failed: ${response.status} ${response.statusText}`, response);
+  }
+  const contentType = response.headers.get("Content-Type");
+  if (contentType?.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+
+class FetchError extends Error {
+  response;
+  constructor(message, response) {
+    super(message);
+    this.response = response;
+    this.name = "FetchError";
+  }
+  get status() {
+    return this.response.status;
+  }
+  get statusText() {
+    return this.response.statusText;
+  }
+}
+function serializeLoaderData(data) {
+  const json = JSON.stringify(data);
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/'/g, "\\u0027");
+}
+function parseLoaderData(serialized) {
+  return JSON.parse(serialized);
+}
+function combineLoaders(loaders) {
+  return async (args) => {
+    const entries = Object.entries(loaders);
+    const results = await Promise.all(entries.map(async ([key, loader]) => [key, await loader(args)]));
+    return Object.fromEntries(results);
+  };
+}
+function clientLoader(load) {
+  return async ({ params }) => {
+    return load(params);
+  };
+}
+// src/action.ts
+function createAction(options) {
+  return async (args) => {
+    const { request } = args;
+    const formData = await request.formData();
+    if (options.validate) {
+      const validation = await options.validate(formData);
+      if (!validation.success) {
+        return {
+          success: false,
+          errors: validation.errors
+        };
+      }
+    }
+    try {
+      const data = await options.handler({ ...args, formData });
+      return { success: true, data };
+    } catch (error) {
+      if (options.onError && error instanceof Error) {
+        const result = await options.onError(error, args);
+        if (result instanceof Response) {
+          throw result;
+        }
+        return { success: true, data: result };
+      }
+      throw error;
+    }
+  };
+}
+function action(handler) {
+  return createAction({ handler });
+}
+function typedAction(options) {
+  return async (args) => {
+    const { request } = args;
+    try {
+      const { body: rawBody, formData, contentType } = await parseRequestBody(request);
+      let body;
+      if (options.transform) {
+        body = options.transform(rawBody);
+      } else if (options.schema) {
+        if (options.schema.safeParse) {
+          const result = options.schema.safeParse(rawBody);
+          if (!result.success) {
+            const errors = {};
+            for (const err of result.error.errors) {
+              const path = err.path.join(".") || "_root";
+              if (!errors[path])
+                errors[path] = [];
+              errors[path].push(err.message);
+            }
+            return { success: false, errors };
+          }
+          body = result.data;
+        } else {
+          body = options.schema.parse(rawBody);
+        }
+      } else {
+        body = rawBody;
+      }
+      if (options.validate) {
+        const validation = await options.validate(body);
+        if (!validation.success) {
+          return { success: false, errors: validation.errors };
+        }
+      }
+      const typedArgs = {
+        ...args,
+        body,
+        formData,
+        contentType
+      };
+      const data = await options.handler(typedArgs);
+      return { success: true, data };
+    } catch (error) {
+      if (options.onError && error instanceof Error) {
+        const result = await options.onError(error, args);
+        if (result instanceof Response) {
+          throw result;
+        }
+        return { success: true, data: result };
+      }
+      throw error;
+    }
+  };
+}
+async function parseRequestBody(request) {
+  const contentType = request.headers.get("Content-Type") || "";
+  if (contentType.includes("application/json")) {
+    const body = await request.json();
+    return { body, contentType: "json" };
+  }
+  if (contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded")) {
+    const formData = await request.formData();
+    const body = formDataToObject(formData);
+    return { body, formData, contentType: "form" };
+  }
+  if (contentType.includes("text/")) {
+    const body = await request.text();
+    return { body, contentType: "text" };
+  }
+  try {
+    const text = await request.text();
+    const body = JSON.parse(text);
+    return { body, contentType: "json" };
+  } catch {
+    return { body: null, contentType: "unknown" };
+  }
+}
+function formDataToObject(formData, options = {}) {
+  const { coerce = true } = options;
+  const result = {};
+  for (const [key, value] of formData.entries()) {
+    if (typeof value === "object" && value !== null && "name" in value && "size" in value) {
+      setNestedValue(result, key, value);
+      continue;
+    }
+    const coercedValue = coerce ? coerceValue(value) : value;
+    setNestedValue(result, key, coercedValue);
+  }
+  return result;
+}
+function setNestedValue(obj, path, value) {
+  if (path.endsWith("[]")) {
+    const arrayPath = path.slice(0, -2);
+    const existing = getNestedValue(obj, arrayPath);
+    if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      setNestedValueDirect(obj, arrayPath, [value]);
+    }
+    return;
+  }
+  const segments = parsePath(path);
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const nextSegment = segments[i + 1];
+    const isNextArray = typeof nextSegment === "number";
+    if (current[segment] === undefined) {
+      current[segment] = isNextArray ? [] : {};
+    }
+    current = current[segment];
+  }
+  const lastSegment = segments[segments.length - 1];
+  if (current[lastSegment] !== undefined && !Array.isArray(current[lastSegment])) {
+    current[lastSegment] = [current[lastSegment], value];
+  } else if (Array.isArray(current[lastSegment]) && typeof lastSegment === "string") {
+    current[lastSegment].push(value);
+  } else {
+    current[lastSegment] = value;
+  }
+}
+function parsePath(path) {
+  const segments = [];
+  let current = "";
+  for (let i = 0;i < path.length; i++) {
+    const char = path[i];
+    if (char === ".") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+    } else if (char === "[") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+      const closeBracket = path.indexOf("]", i);
+      if (closeBracket !== -1) {
+        const indexStr = path.slice(i + 1, closeBracket);
+        const index = parseInt(indexStr, 10);
+        if (!isNaN(index)) {
+          segments.push(index);
+        } else if (indexStr) {
+          segments.push(indexStr);
+        }
+        i = closeBracket;
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    segments.push(current);
+  }
+  return segments;
+}
+function getNestedValue(obj, path) {
+  const segments = parsePath(path);
+  let current = obj;
+  for (const segment of segments) {
+    if (current == null || typeof current !== "object") {
+      return;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function setNestedValueDirect(obj, path, value) {
+  const segments = parsePath(path);
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    const nextSegment = segments[i + 1];
+    const isNextArray = typeof nextSegment === "number";
+    if (current[segment] === undefined) {
+      current[segment] = isNextArray ? [] : {};
+    }
+    current = current[segment];
+  }
+  current[segments[segments.length - 1]] = value;
+}
+function coerceValue(value) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "null")
+    return null;
+  if (value === "undefined")
+    return;
+  if (value !== "" && !isNaN(Number(value)) && isFinite(Number(value))) {
+    return Number(value);
+  }
+  if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/.test(value)) {
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  if (value.startsWith("{") && value.endsWith("}") || value.startsWith("[") && value.endsWith("]")) {
+    try {
+      return JSON.parse(value);
+    } catch {}
+  }
+  return value;
+}
+function jsonAction(options) {
+  return async (args) => {
+    const { request } = args;
+    const contentType = request.headers.get("Content-Type") || "";
+    if (options.strict && !contentType.includes("application/json")) {
+      return {
+        success: false,
+        errors: { _request: ["Content-Type must be application/json"] }
+      };
+    }
+    return typedAction(options)(args);
+  };
+}
+function redirect(url, status = 302) {
+  return new Response(null, {
+    status,
+    headers: { Location: url }
+  });
+}
+function json(data, init) {
+  return new Response(JSON.stringify(data), {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      ...init?.headers
+    }
+  });
+}
+function error(message, status = 500) {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function parseFormData(formData) {
+  const result = {};
+  for (const [key, value] of formData.entries()) {
+    if (key.endsWith("[]")) {
+      const arrayKey = key.slice(0, -2);
+      if (!result[arrayKey]) {
+        result[arrayKey] = [];
+      }
+      result[arrayKey].push(value);
+    } else if (result[key] !== undefined) {
+      if (!Array.isArray(result[key])) {
+        result[key] = [result[key]];
+      }
+      result[key].push(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function validateRequired(formData, fields) {
+  const errors = {};
+  for (const field of fields) {
+    const value = formData.get(field);
+    if (!value || typeof value === "string" && value.trim() === "") {
+      errors[field] = [`${field} is required`];
+    }
+  }
+  return {
+    success: Object.keys(errors).length === 0,
+    errors: Object.keys(errors).length > 0 ? errors : undefined
+  };
+}
+function combineValidators(...validators) {
+  return async (formData) => {
+    const allErrors = {};
+    for (const validator of validators) {
+      const result = await validator(formData);
+      if (!result.success && result.errors) {
+        for (const [field, fieldErrors] of Object.entries(result.errors)) {
+          if (!allErrors[field]) {
+            allErrors[field] = [];
+          }
+          allErrors[field].push(...fieldErrors);
+        }
+      }
+    }
+    return {
+      success: Object.keys(allErrors).length === 0,
+      errors: Object.keys(allErrors).length > 0 ? allErrors : undefined
+    };
+  };
+}
+// src/revalidate.ts
+async function revalidateTag(...tags) {
+  const cache = getCache();
+  const revalidatedTags = [];
+  for (const tag of tags) {
+    await cache.deleteByTag(tag);
+    revalidatedTags.push(tag);
+  }
+  return {
+    success: true,
+    revalidated: {
+      tags: revalidatedTags,
+      paths: []
+    },
+    timestamp: Date.now()
+  };
+}
+async function revalidatePath(...paths) {
+  const cache = getCache();
+  const revalidatedPaths = [];
+  const allKeys = await cache.keys();
+  for (const path of paths) {
+    for (const key of allKeys) {
+      if (key.includes(`:${path}`) || key.endsWith(path)) {
+        await cache.delete(key);
+        revalidatedPaths.push(path);
+      }
+    }
+  }
+  return {
+    success: true,
+    revalidated: {
+      tags: [],
+      paths: [...new Set(revalidatedPaths)]
+    },
+    timestamp: Date.now()
+  };
+}
+async function revalidate2(options) {
+  const cache = getCache();
+  if (options.all) {
+    await cache.clear();
+    return {
+      success: true,
+      revalidated: { tags: ["*"], paths: ["*"] },
+      timestamp: Date.now()
+    };
+  }
+  const tagResult = options.tags ? await revalidateTag(...options.tags) : null;
+  const pathResult = options.paths ? await revalidatePath(...options.paths) : null;
+  return {
+    success: true,
+    revalidated: {
+      tags: tagResult?.revalidated.tags ?? [],
+      paths: pathResult?.revalidated.paths ?? []
+    },
+    timestamp: Date.now()
+  };
+}
+function unstable_cache(fn, keyParts, options = {}) {
+  return async (...args) => {
+    const { cached: cached2, cacheKey: cacheKey2 } = await Promise.resolve().then(() => exports_cache);
+    const key = cacheKey2(keyParts.join(":"), JSON.stringify(args));
+    return cached2(key, () => fn(...args), {
+      maxAge: options.revalidate ?? 3600,
+      tags: options.tags ?? []
+    });
+  };
+}
+function createRevalidationHandler(secret) {
+  return async (request) => {
+    if (secret) {
+      const authHeader = request.headers.get("Authorization");
+      if (authHeader !== `Bearer ${secret}`) {
+        return new Response(JSON.stringify({ error: "Unauthorized" }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    try {
+      const body = await request.json();
+      const result = await revalidate2(body);
+      return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (error2) {
+      return new Response(JSON.stringify({
+        error: error2 instanceof Error ? error2.message : "Unknown error"
+      }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+}
+var tags = {
+  resource: (type, id) => `${type}:${id}`,
+  collection: (type) => type,
+  userScoped: (userId, type) => `user:${userId}:${type}`
+};
+async function onDemandRevalidate(...tagsOrPaths) {
+  const tags2 = [];
+  const paths = [];
+  for (const item of tagsOrPaths) {
+    if (item.startsWith("/")) {
+      paths.push(item);
+    } else {
+      tags2.push(item);
+    }
+  }
+  return revalidate2({ tags: tags2, paths });
+}
+// src/pipeline.ts
+function createPipeline(config) {
+  const { loaders, dependencies = {}, onError, metrics: enableMetrics = false } = config;
+  const graph = buildDependencyGraph(loaders, dependencies);
+  return {
+    async execute(args) {
+      const startTime = performance.now();
+      const results = new Map;
+      const errors = new Map;
+      const loaderMetrics = new Map;
+      const executionOrder = [];
+      const completed = new Set;
+      const inProgress = new Map;
+      const executeLoader = async (key) => {
+        if (completed.has(key) || inProgress.has(key)) {
+          return inProgress.get(key);
+        }
+        const deps = graph.get(key) || [];
+        const waitingFor = [];
+        for (const dep of deps) {
+          if (!completed.has(dep)) {
+            waitingFor.push(dep);
+            await executeLoader(dep);
+          }
+        }
+        const loaderStartTime = performance.now() - startTime;
+        executionOrder.push({ time: loaderStartTime, type: "start", loader: key });
+        const promise = (async () => {
+          const loader = loaders[key];
+          try {
+            const extendedArgs = {
+              ...args,
+              data: Object.fromEntries(results)
+            };
+            const result = await loader.load(extendedArgs);
+            results.set(key, result);
+          } catch (error2) {
+            const err = error2 instanceof Error ? error2 : new Error(String(error2));
+            if (loader.fallback !== undefined) {
+              results.set(key, loader.fallback);
+            } else if (loader.required !== false) {
+              errors.set(key, err);
+            }
+            onError?.(err, key);
+          }
+          const loaderEndTime = performance.now() - startTime;
+          executionOrder.push({ time: loaderEndTime, type: "end", loader: key });
+          loaderMetrics.set(key, {
+            key,
+            startTime: loaderStartTime,
+            endTime: loaderEndTime,
+            duration: loaderEndTime - loaderStartTime,
+            cacheHit: false,
+            waitingFor
+          });
+          completed.add(key);
+        })();
+        inProgress.set(key, promise);
+        return promise;
+      };
+      const roots = Object.keys(loaders).filter((key) => {
+        const deps = graph.get(key) || [];
+        return deps.length === 0;
+      });
+      await Promise.all(roots.map(executeLoader));
+      await Promise.all(Object.keys(loaders).map(executeLoader));
+      const totalTime = performance.now() - startTime;
+      const waterfalls = detectWaterfalls(loaderMetrics, graph);
+      const parallelEfficiency = calculateParallelEfficiency(loaderMetrics, totalTime);
+      return {
+        data: Object.fromEntries(results),
+        metrics: {
+          total: totalTime,
+          loaders: loaderMetrics,
+          executionOrder,
+          parallelEfficiency,
+          waterfalls
+        },
+        errors
+      };
+    },
+    toLoader() {
+      return async (args) => {
+        const result = await this.execute(args);
+        if (result.errors.size > 0) {
+          const [key, error2] = result.errors.entries().next().value;
+          throw new Error(`Loader '${String(key)}' failed: ${error2.message}`);
+        }
+        if (enableMetrics && args.context) {
+          args.context.set("__pipeline_metrics", result.metrics);
+        }
+        return result.data;
+      };
+    },
+    getDependencyGraph() {
+      return graph;
+    }
+  };
+}
+function buildDependencyGraph(loaders, dependencies) {
+  const graph = new Map;
+  for (const key of Object.keys(loaders)) {
+    graph.set(key, dependencies[key] || []);
+  }
+  for (const [key, deps] of graph) {
+    for (const dep of deps) {
+      if (!loaders[dep]) {
+        throw new Error(`Loader '${key}' depends on '${dep}' which does not exist`);
+      }
+    }
+  }
+  const visited = new Set;
+  const recursionStack = new Set;
+  const hasCycle = (node) => {
+    visited.add(node);
+    recursionStack.add(node);
+    const deps = graph.get(node) || [];
+    for (const dep of deps) {
+      if (!visited.has(dep)) {
+        if (hasCycle(dep))
+          return true;
+      } else if (recursionStack.has(dep)) {
+        return true;
+      }
+    }
+    recursionStack.delete(node);
+    return false;
+  };
+  for (const key of graph.keys()) {
+    if (!visited.has(key) && hasCycle(key)) {
+      throw new Error(`Circular dependency detected involving '${key}'`);
+    }
+  }
+  return graph;
+}
+function detectWaterfalls(metrics, graph) {
+  const waterfalls = [];
+  for (const [key, metric] of metrics) {
+    if (metric.waitingFor.length > 0) {
+      const deps = graph.get(key) || [];
+      const necessary = metric.waitingFor.every((w) => deps.includes(w));
+      if (!necessary) {
+        waterfalls.push({
+          loader: key,
+          waitedFor: metric.waitingFor,
+          necessary: false,
+          suggestion: `'${key}' waited for ${metric.waitingFor.join(", ")} but doesn't depend on them. Consider running in parallel.`
+        });
+      } else if (metric.waitingFor.length > 1) {
+        waterfalls.push({
+          loader: key,
+          waitedFor: metric.waitingFor,
+          necessary: true,
+          suggestion: `'${key}' waited for multiple loaders. Consider if all dependencies are necessary.`
+        });
+      }
+    }
+  }
+  return waterfalls;
+}
+function calculateParallelEfficiency(metrics, totalTime) {
+  if (metrics.size === 0)
+    return 1;
+  let sequentialTime = 0;
+  for (const metric of metrics.values()) {
+    sequentialTime += metric.duration;
+  }
+  if (totalTime === 0)
+    return 1;
+  return Math.min(1, sequentialTime / (totalTime * metrics.size));
+}
+function dataSource(load, options = {}) {
+  return { load, ...options };
+}
+function cachedSource(load, options) {
+  return {
+    load,
+    tags: options.tags,
+    ttl: options.ttl
+  };
+}
+function optionalSource(load, fallback) {
+  return {
+    load,
+    fallback,
+    required: false
+  };
+}
+function combinePipelines(pipelines) {
+  return {
+    async execute(args) {
+      const results = await Promise.all(Object.entries(pipelines).map(async ([key, pipeline]) => {
+        const result = await pipeline.execute(args);
+        return [key, result.data];
+      }));
+      return Object.fromEntries(results);
+    }
+  };
+}
+function formatMetrics(metrics) {
+  const lines = [
+    `Pipeline completed in ${metrics.total.toFixed(1)}ms`,
+    `Parallel efficiency: ${(metrics.parallelEfficiency * 100).toFixed(0)}%`,
+    "",
+    "Loader Timings:"
+  ];
+  const sorted = Array.from(metrics.loaders.values()).sort((a, b) => a.startTime - b.startTime);
+  for (const loader of sorted) {
+    const bar = generateTimeBar(loader.startTime, loader.endTime, metrics.total);
+    const cacheIndicator = loader.cacheHit ? " \x1B[32m(cache)\x1B[0m" : "";
+    lines.push(`  ${loader.key.padEnd(20)} ${bar} ${loader.duration.toFixed(1)}ms${cacheIndicator}`);
+  }
+  if (metrics.waterfalls.length > 0) {
+    lines.push("");
+    lines.push("\u26A0\uFE0F Detected Waterfalls:");
+    for (const waterfall of metrics.waterfalls) {
+      lines.push(`  - ${waterfall.loader}: ${waterfall.suggestion}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function generateTimeBar(start, end, total, width = 40) {
+  if (total === 0)
+    return "\u2501".repeat(width);
+  const startPos = Math.floor(start / total * width);
+  const endPos = Math.ceil(end / total * width);
+  let bar = "";
+  for (let i = 0;i < width; i++) {
+    if (i < startPos) {
+      bar += "\u2500";
+    } else if (i < endPos) {
+      bar += "\u2501";
+    } else {
+      bar += "\u2500";
+    }
+  }
+  return bar;
+}
+function generateMetricsVisualization(metrics) {
+  const timeline = Array.from(metrics.loaders.values()).sort((a, b) => a.startTime - b.startTime).map((m) => ({
+    key: m.key,
+    start: m.startTime,
+    end: m.endTime,
+    duration: m.duration,
+    cacheHit: m.cacheHit,
+    waitingFor: m.waitingFor
+  }));
+  return {
+    timeline,
+    total: metrics.total,
+    efficiency: metrics.parallelEfficiency,
+    waterfalls: metrics.waterfalls
+  };
+}
+// src/define-route.ts
+function defineRoute(path) {
+  const state = {
+    path,
+    middleware: []
+  };
+  const createBuilder = () => ({
+    [Symbol()]: path,
+    loader(fn) {
+      state.loader = fn;
+      return createBuilderWithLoader();
+    },
+    searchParams(schema) {
+      state.searchParamsSchema = schema;
+      return createBuilder();
+    },
+    hashParams(schema) {
+      state.hashParamsSchema = schema;
+      return createBuilder();
+    },
+    middleware(...handlers) {
+      state.middleware = [...state.middleware || [], ...handlers];
+      return createBuilder();
+    },
+    configure(config) {
+      state.config = config;
+      return createBuilder();
+    },
+    build() {
+      return {
+        path,
+        middleware: state.middleware,
+        config: state.config,
+        searchParamsSchema: state.searchParamsSchema,
+        hashParamsSchema: state.hashParamsSchema,
+        _types: {}
+      };
+    }
+  });
+  const createBuilderWithLoader = () => ({
+    [Symbol()]: path,
+    [Symbol()]: {},
+    action(fn, options) {
+      state.action = fn;
+      if (options?.schema) {
+        state.actionBodySchema = options.schema;
+      }
+      return createBuilderWithLoaderAndAction();
+    },
+    head(fn) {
+      state.head = fn;
+      return createBuilderWithLoader();
+    },
+    meta(fn) {
+      state.meta = fn;
+      return createBuilderWithLoader();
+    },
+    cache(options) {
+      state.cache = options;
+      return createBuilderWithLoader();
+    },
+    middleware(...handlers) {
+      state.middleware = [...state.middleware || [], ...handlers];
+      return createBuilderWithLoader();
+    },
+    configure(config) {
+      state.config = config;
+      return createBuilderWithLoader();
+    },
+    build() {
+      return {
+        path,
+        loader: createWrappedLoader(),
+        head: state.head,
+        meta: state.meta,
+        middleware: state.middleware,
+        config: state.config,
+        cache: state.cache,
+        searchParamsSchema: state.searchParamsSchema,
+        hashParamsSchema: state.hashParamsSchema,
+        _types: {}
+      };
+    }
+  });
+  const createBuilderWithLoaderAndAction = () => ({
+    [Symbol()]: path,
+    [Symbol()]: {},
+    [Symbol()]: {},
+    head(fn) {
+      state.head = fn;
+      return createBuilderWithLoaderAndAction();
+    },
+    meta(fn) {
+      state.meta = fn;
+      return createBuilderWithLoaderAndAction();
+    },
+    cache(options) {
+      state.cache = options;
+      return createBuilderWithLoaderAndAction();
+    },
+    middleware(...handlers) {
+      state.middleware = [...state.middleware || [], ...handlers];
+      return createBuilderWithLoaderAndAction();
+    },
+    configure(config) {
+      state.config = config;
+      return createBuilderWithLoaderAndAction();
+    },
+    build() {
+      return {
+        path,
+        loader: createWrappedLoader(),
+        action: createWrappedAction(),
+        head: state.head,
+        meta: state.meta,
+        middleware: state.middleware,
+        config: state.config,
+        cache: state.cache,
+        searchParamsSchema: state.searchParamsSchema,
+        hashParamsSchema: state.hashParamsSchema,
+        actionBodySchema: state.actionBodySchema,
+        _types: {}
+      };
+    }
+  });
+  const createWrappedLoader = () => {
+    return async (args) => {
+      if (state.cache) {
+        args.context.cache.set(state.cache);
+      }
+      let searchParams;
+      if (state.searchParamsSchema) {
+        const url = new URL(args.request.url);
+        const rawParams = {};
+        url.searchParams.forEach((value, key) => {
+          if (rawParams[key]) {
+            const existing = rawParams[key];
+            rawParams[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+          } else {
+            rawParams[key] = value;
+          }
+        });
+        searchParams = state.searchParamsSchema.parse(rawParams);
+      }
+      let hashParams;
+      if (state.hashParamsSchema) {
+        const url = new URL(args.request.url);
+        if (url.hash) {
+          const hashSearchParams = new URLSearchParams(url.hash.slice(1));
+          const rawParams = {};
+          hashSearchParams.forEach((value, key) => {
+            rawParams[key] = value;
+          });
+          hashParams = state.hashParamsSchema.parse(rawParams);
+        }
+      }
+      const typedArgs = {
+        ...args,
+        searchParams,
+        hashParams
+      };
+      return state.loader(typedArgs);
+    };
+  };
+  const createWrappedAction = () => {
+    return async (args) => {
+      const { request } = args;
+      const contentType = request.headers.get("Content-Type") || "";
+      let body;
+      let formData;
+      if (contentType.includes("application/json")) {
+        const rawBody = await request.json();
+        body = state.actionBodySchema ? state.actionBodySchema.parse(rawBody) : rawBody;
+      } else if (contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded")) {
+        formData = await request.formData();
+        const rawBody = formDataToObject2(formData);
+        body = state.actionBodySchema ? state.actionBodySchema.parse(rawBody) : rawBody;
+      } else {
+        try {
+          const text = await request.text();
+          const rawBody = JSON.parse(text);
+          body = state.actionBodySchema ? state.actionBodySchema.parse(rawBody) : rawBody;
+        } catch {
+          body = {};
+        }
+      }
+      const typedArgs = {
+        ...args,
+        body,
+        formData
+      };
+      return state.action(typedArgs);
+    };
+  };
+  return createBuilder();
+}
+function formDataToObject2(formData) {
+  const result = {};
+  for (const [key, value] of formData.entries()) {
+    if (key.endsWith("[]")) {
+      const arrayKey = key.slice(0, -2);
+      if (!result[arrayKey]) {
+        result[arrayKey] = [];
+      }
+      result[arrayKey].push(value);
+    } else if (result[key] !== undefined) {
+      if (!Array.isArray(result[key])) {
+        result[key] = [result[key]];
+      }
+      result[key].push(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+// src/schema-adapters.ts
+function ereoSchema(schema) {
+  return {
+    parse: (data) => {
+      return schema.parse(data);
+    },
+    safeParse: (data) => {
+      const result = schema.safeParse(data);
+      if (result.success) {
+        return { success: true, data: result.data };
+      }
+      return {
+        success: false,
+        error: {
+          errors: result.error.errors.map((err) => ({
+            path: err.path,
+            message: err.message
+          }))
+        }
+      };
+    },
+    _original: schema,
+    _ereoSchema: true,
+    _output: {}
+  };
+}
+function isEreoSchema(value) {
+  return typeof value === "object" && value !== null && "_ereoSchema" in value && value._ereoSchema === true;
+}
+function createPaginationParser(options = {}) {
+  const { defaultPage = 1, defaultLimit = 10, maxLimit = 100 } = options;
+  return {
+    parse: (data) => {
+      const input = data;
+      const page = parseNumber(input.page, defaultPage);
+      const limit = Math.min(parseNumber(input.limit, defaultLimit), maxLimit);
+      const offset = parseNumber(input.offset, undefined);
+      return {
+        page: page > 0 ? page : defaultPage,
+        limit: limit > 0 ? limit : defaultLimit,
+        offset: offset !== undefined && offset >= 0 ? offset : undefined
+      };
+    },
+    safeParse: (data) => {
+      try {
+        const result = createPaginationParser(options).parse(data);
+        return { success: true, data: result };
+      } catch (error2) {
+        return {
+          success: false,
+          error: {
+            errors: [
+              {
+                path: [],
+                message: error2 instanceof Error ? error2.message : "Invalid pagination params"
+              }
+            ]
+          }
+        };
+      }
+    }
+  };
+}
+function createSortParser(allowedFields, defaultField, defaultOrder = "asc") {
+  return {
+    parse: (data) => {
+      const input = data;
+      const sortBy = allowedFields.includes(input.sortBy) ? input.sortBy : defaultField;
+      const sortOrder = input.sortOrder === "asc" || input.sortOrder === "desc" ? input.sortOrder : defaultOrder;
+      return { sortBy, sortOrder };
+    },
+    safeParse: (data) => {
+      try {
+        const result = createSortParser(allowedFields, defaultField, defaultOrder).parse(data);
+        return { success: true, data: result };
+      } catch (error2) {
+        return {
+          success: false,
+          error: {
+            errors: [
+              {
+                path: [],
+                message: error2 instanceof Error ? error2.message : "Invalid sort params"
+              }
+            ]
+          }
+        };
+      }
+    }
+  };
+}
+function createFilterParser(allowedFilters) {
+  return {
+    parse: (data) => {
+      const input = data;
+      const result = {};
+      for (const [key, allowedValues] of Object.entries(allowedFilters)) {
+        const value = input[key];
+        if (value === undefined)
+          continue;
+        if (Array.isArray(value)) {
+          const validValues = value.filter((v) => allowedValues.includes(String(v)));
+          if (validValues.length > 0) {
+            result[key] = validValues;
+          }
+        } else if (allowedValues.includes(String(value))) {
+          result[key] = value;
+        }
+      }
+      return result;
+    },
+    safeParse: (data) => {
+      try {
+        const res = createFilterParser(allowedFilters).parse(data);
+        return { success: true, data: res };
+      } catch (error2) {
+        return {
+          success: false,
+          error: {
+            errors: [
+              {
+                path: [],
+                message: error2 instanceof Error ? error2.message : "Invalid filter params"
+              }
+            ]
+          }
+        };
+      }
+    }
+  };
+}
+function parseNumber(value, fallback) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  const num = Number(value);
+  return isNaN(num) ? fallback : num;
+}
+function parseBoolean(value, fallback = false) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  const str = String(value).toLowerCase();
+  if (str === "true" || str === "1" || str === "yes") {
+    return true;
+  }
+  if (str === "false" || str === "0" || str === "no") {
+    return false;
+  }
+  return fallback;
+}
+function parseStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.map(String);
+  }
+  if (typeof value === "string") {
+    if (value.includes(",")) {
+      return value.split(",").map((s) => s.trim());
+    }
+    return [value];
+  }
+  return [];
+}
+function parseDate(value, fallback) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? fallback : value;
+  }
+  const date = new Date(String(value));
+  return isNaN(date.getTime()) ? fallback : date;
+}
+function parseEnum(value, allowedValues, fallback) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  const str = String(value);
+  return allowedValues.includes(str) ? str : fallback;
+}
+function schemaBuilder() {
+  return new SchemaBuilderImpl({});
+}
+
+class SchemaBuilderImpl {
+  fields;
+  constructor(fields) {
+    this.fields = fields;
+  }
+  string(key, options) {
+    return new SchemaBuilderImpl({
+      ...this.fields,
+      [key]: { type: "string", ...options }
+    });
+  }
+  number(key, options) {
+    return new SchemaBuilderImpl({
+      ...this.fields,
+      [key]: { type: "number", ...options }
+    });
+  }
+  boolean(key, options) {
+    return new SchemaBuilderImpl({
+      ...this.fields,
+      [key]: { type: "boolean", ...options }
+    });
+  }
+  enum(key, values, options) {
+    return new SchemaBuilderImpl({
+      ...this.fields,
+      [key]: { type: "enum", values: [...values], ...options }
+    });
+  }
+  array(key, options) {
+    return new SchemaBuilderImpl({
+      ...this.fields,
+      [key]: { type: "array", ...options }
+    });
+  }
+  build() {
+    const fields = this.fields;
+    return {
+      parse: (data) => {
+        const input = data || {};
+        const result = {};
+        for (const [key, config] of Object.entries(fields)) {
+          const value = input[key];
+          switch (config.type) {
+            case "string":
+              result[key] = value !== undefined ? String(value) : config.default;
+              break;
+            case "number": {
+              const num = parseNumber(value, config.default);
+              if (config.min !== undefined && num !== undefined && num < config.min) {
+                result[key] = config.min;
+              } else if (config.max !== undefined && num !== undefined && num > config.max) {
+                result[key] = config.max;
+              } else {
+                result[key] = num;
+              }
+              break;
+            }
+            case "boolean":
+              result[key] = parseBoolean(value, config.default);
+              break;
+            case "enum":
+              result[key] = parseEnum(value, config.values, config.default);
+              break;
+            case "array": {
+              const arr = parseStringArray(value);
+              result[key] = config.of === "number" ? arr.map(Number).filter((n) => !isNaN(n)) : arr;
+              break;
+            }
+          }
+        }
+        return result;
+      },
+      safeParse: (data) => {
+        try {
+          const result = schemaBuilder().build().parse(data);
+          return { success: true, data: result };
+        } catch (error2) {
+          return {
+            success: false,
+            error: {
+              errors: [
+                {
+                  path: [],
+                  message: error2 instanceof Error ? error2.message : "Validation failed"
+                }
+              ]
+            }
+          };
+        }
+      }
+    };
+  }
+}
+export {
+  validateRequired,
+  unstable_cache,
+  typedAction,
+  tags,
+  setCache,
+  serializeLoaderData,
+  schemaBuilder,
+  revalidateTag,
+  revalidatePath,
+  revalidate2 as revalidate,
+  resolveDeferred,
+  redirect,
+  parseStringArray,
+  parseRequestBody,
+  parseLoaderData,
+  parseFormData,
+  parseEnum,
+  parseDate,
+  parseCacheControl,
+  parseBoolean,
+  optionalSource,
+  onDemandRevalidate,
+  jsonAction,
+  json,
+  isEreoSchema,
+  isDeferred,
+  getCache,
+  generateMetricsVisualization,
+  generateCacheKey,
+  formatMetrics,
+  formDataToObject,
+  fetchData,
+  error,
+  ereoSchema,
+  defineRoute,
+  defer,
+  dataSource,
+  createSortParser,
+  createRevalidationHandler,
+  createPipeline,
+  createPaginationParser,
+  createLoader,
+  createFilterParser,
+  createDataCacheAdapter,
+  createAction,
+  combineValidators,
+  combinePipelines,
+  combineLoaders,
+  coerceValue,
+  clientLoader,
+  cachedSource,
+  cached,
+  cacheKey,
+  buildCacheControl,
+  action,
+  MemoryCache,
+  FetchError,
+  Cached
+};