@ecopages/core 0.2.0-alpha.24 → 0.2.0-alpha.26

package/src/services/assets/asset-processing-service/processors/script/node-module-script.processor.js

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { getAppBuildAdapter } from "../../../../../build/build-adapter.js";
+import { BaseScriptProcessor } from "../base/base-script-processor.js";
+class NodeModuleScriptProcessor extends BaseScriptProcessor {
+  async process(dep) {
+    const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
+    const moduleName = path.basename(modulePath);
+    const filename = dep.name ?? `nm-${moduleName}`;
+    const configHash = this.generateHash(
+      JSON.stringify({ inline: dep.inline, minify: !dep.inline && this.isProduction, opts: dep.bundleOptions })
+    );
+    const cachekey = `${this.buildCacheKey(filename, this.generateHash(modulePath), dep)}:${configHash}`;
+    return this.getOrProcess(cachekey, async () => {
+      if (dep.inline) {
+        const content = fileSystem.readFileAsBuffer(modulePath).toString();
+        return {
+          content,
+          kind: dep.kind,
+          position: dep.position,
+          attributes: dep.attributes,
+          inline: true,
+          excludeFromHtml: dep.excludeFromHtml,
+          packageRole: dep.packageRole
+        };
+      }
+      const outdir = path.join(this.getAssetsDir(), "vendors");
+      const bundlerOptions = this.getBundlerOptions(dep);
+      const filePath = await this.bundleScript({
+        entrypoint: modulePath,
+        outdir,
+        minify: this.isProduction,
+        naming: bundlerOptions.naming ?? (dep.name ? `${dep.name}-[hash].[ext]` : "[name]-[hash].[ext]"),
+        ...bundlerOptions
+      });
+      return {
+        filepath: filePath,
+        kind: dep.kind,
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline,
+        excludeFromHtml: dep.excludeFromHtml,
+        packageRole: dep.packageRole
+      };
+    });
+  }
+  resolveModulePath(importPath, rootDir) {
+    if (path.isAbsolute(importPath) && fileSystem.exists(importPath)) {
+      return importPath;
+    }
+    try {
+      return getAppBuildAdapter(this.appConfig).resolve(importPath, rootDir);
+    } catch {
+      return this.resolveModulePathFallback(importPath, rootDir);
+    }
+  }
+  resolveModulePathFallback(importPath, rootDir, maxDepth = 5) {
+    let currentDir = rootDir;
+    let remainingDepth = maxDepth;
+    while (remainingDepth >= 0) {
+      const modulePath = path.join(currentDir, "node_modules", importPath);
+      if (fileSystem.exists(modulePath)) {
+        return modulePath;
+      }
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+      remainingDepth -= 1;
+    }
+    throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
+  }
+}
+export {
+  NodeModuleScriptProcessor
+};

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.d.ts

@@ -0,0 +1,8 @@
+import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
+import { BaseProcessor } from '../base/base-processor.js';
+export declare class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
+    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
+    private isProcessableStylesheet;
+    private applyStylesheetProcessors;
+    process(dep: ContentStylesheetAsset): Promise<ProcessedAsset>;
+}

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { BaseProcessor } from "../base/base-processor.js";
+class ContentStylesheetProcessor extends BaseProcessor {
+  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
+  isProcessableStylesheet(filepath) {
+    return ContentStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
+  }
+  async applyStylesheetProcessors(content, filepath) {
+    if (!this.isProcessableStylesheet(filepath)) {
+      return content;
+    }
+    let transformedContent = content;
+    const processors = this.appConfig.processors ? Array.from(this.appConfig.processors.values()) : [];
+    for (const processor of processors) {
+      const hasCapabilities = processor.getAssetCapabilities().length > 0;
+      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
+      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
+        continue;
+      }
+      if (!processor.matchesFileFilter(filepath)) {
+        continue;
+      }
+      const result = await processor.process(transformedContent, filepath);
+      if (typeof result === "string") {
+        transformedContent = result;
+        continue;
+      }
+      if (result instanceof Buffer) {
+        transformedContent = result.toString();
+      }
+    }
+    return transformedContent;
+  }
+  async process(dep) {
+    const virtualFilepath = path.join(this.appConfig.absolutePaths.distDir, "styles", "page-bundle.css");
+    const processedContent = await this.applyStylesheetProcessors(dep.content, virtualFilepath);
+    const hash = this.generateHash(processedContent);
+    const filename = `style-${hash}.css`;
+    const cachekey = this.buildCacheKey(filename, hash, dep);
+    return this.getOrProcess(cachekey, () => {
+      const filepath = path.join(this.getAssetsDir(), "styles", filename);
+      if (!dep.inline) fileSystem.write(filepath, processedContent);
+      return {
+        filepath: dep.inline ? void 0 : filepath,
+        content: dep.inline ? processedContent : void 0,
+        kind: "stylesheet",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline,
+        packageRole: dep.packageRole
+      };
+    });
+  }
+}
+export {
+  ContentStylesheetProcessor
+};

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.d.ts

@@ -0,0 +1,9 @@
+import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
+import { BaseProcessor } from '../base/base-processor.js';
+export declare class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset> {
+    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
+    getStyleContent: (srcUrl: string) => Buffer;
+    private isProcessableStylesheet;
+    private applyStylesheetProcessors;
+    process(dep: FileStylesheetAsset): Promise<ProcessedAsset>;
+}

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { BaseProcessor } from "../base/base-processor.js";
+class FileStylesheetProcessor extends BaseProcessor {
+  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
+  getStyleContent = (srcUrl) => {
+    return fileSystem.readFileAsBuffer(srcUrl);
+  };
+  isProcessableStylesheet(filepath) {
+    return FileStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
+  }
+  async applyStylesheetProcessors(content, filepath) {
+    if (!this.isProcessableStylesheet(filepath)) {
+      return content;
+    }
+    let transformedContent = content;
+    for (const processor of this.appConfig.processors.values()) {
+      const hasCapabilities = processor.getAssetCapabilities().length > 0;
+      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
+      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
+        continue;
+      }
+      if (!processor.matchesFileFilter(filepath)) {
+        continue;
+      }
+      const result = await processor.process(transformedContent, filepath);
+      if (typeof result === "string") {
+        transformedContent = result;
+        continue;
+      }
+      if (result instanceof Buffer) {
+        transformedContent = result.toString();
+      }
+    }
+    return transformedContent;
+  }
+  async process(dep) {
+    const buffer = this.getStyleContent(dep.filepath);
+    const rawContent = buffer.toString();
+    const processedContent = await this.applyStylesheetProcessors(rawContent, dep.filepath);
+    const hash = this.generateHash(processedContent);
+    const cachekey = this.buildCacheKey(dep.filepath, hash, dep);
+    return this.getOrProcess(cachekey, () => {
+      const filepath = path.join(
+        this.getAssetsDir(),
+        path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath)
+      );
+      const outputBuffer = Buffer.from(processedContent);
+      if (!dep.inline) {
+        fileSystem.ensureDir(path.dirname(filepath));
+        fileSystem.write(filepath, outputBuffer);
+      }
+      return {
+        filepath,
+        content: dep.inline ? processedContent : void 0,
+        kind: "stylesheet",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline,
+        packageRole: dep.packageRole
+      };
+    });
+  }
+}
+export {
+  FileStylesheetProcessor
+};

package/src/services/assets/asset-processing-service/ungrouped-dependency-processing.d.ts

@@ -0,0 +1,18 @@
+import type { AssetProcessor } from './processor.interface.js';
+import type { AssetDefinition, ProcessedAsset } from './assets.types.js';
+type ProcessUngroupedDependencyOptions = {
+    dep: AssetDefinition;
+    key: string;
+    depKey: string;
+    getCachedAsset: (dep: AssetDefinition, depKey: string) => ProcessedAsset | null;
+    getProcessor: (dep: AssetDefinition) => AssetProcessor | undefined;
+    resolveProcessedAssetSrcUrl: (processed: ProcessedAsset) => string | undefined;
+    setCachedAsset: (dep: AssetDefinition, depKey: string, processed: ProcessedAsset) => void;
+    logMissingProcessor: (dep: AssetDefinition) => void;
+    logMissingFile: (dep: AssetDefinition & {
+        filepath: string;
+    }) => void;
+    logProcessingError: (dep: AssetDefinition, error: unknown) => void;
+};
+export declare function processUngroupedDependency(options: ProcessUngroupedDependencyOptions): Promise<ProcessedAsset | null>;
+export {};

package/src/services/assets/asset-processing-service/ungrouped-dependency-processing.js

@@ -0,0 +1,45 @@
+import { fileSystem } from "@ecopages/file-system";
+async function processUngroupedDependency(options) {
+  const {
+    dep,
+    key,
+    depKey,
+    getCachedAsset,
+    getProcessor,
+    resolveProcessedAssetSrcUrl,
+    setCachedAsset,
+    logMissingProcessor,
+    logMissingFile,
+    logProcessingError
+  } = options;
+  const cached = getCachedAsset(dep, depKey);
+  if (cached) {
+    return { key, ...cached };
+  }
+  const processor = getProcessor(dep);
+  if (!processor) {
+    logMissingProcessor(dep);
+    return null;
+  }
+  if (dep.source === "file" && "filepath" in dep && !fileSystem.exists(dep.filepath)) {
+    logMissingFile(dep);
+    return null;
+  }
+  try {
+    const processed = await processor.process(dep);
+    const srcUrl = resolveProcessedAssetSrcUrl(processed);
+    const processedWithKey = {
+      key,
+      ...processed,
+      srcUrl
+    };
+    setCachedAsset(dep, depKey, processedWithKey);
+    return processedWithKey;
+  } catch (error) {
+    logProcessingError(dep, error);
+    return null;
+  }
+}
+export {
+  processUngroupedDependency
+};

package/src/services/assets/browser-bundle.service.d.ts

@@ -0,0 +1,73 @@
+import type { BuildResult, BuildTranspileProfile } from '../../build/build-adapter.js';
+import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+export type BrowserBundleOptions = {
+    entrypoints: string[];
+    outdir?: string;
+    outbase?: string;
+    naming?: string;
+    conditions?: string[];
+    define?: Record<string, string>;
+    minify?: boolean;
+    treeshaking?: boolean;
+    splitting?: boolean;
+    root?: string;
+    bundle?: boolean;
+    externalPackages?: boolean;
+    external?: string[];
+    plugins?: EcoBuildPlugin[];
+    [key: string]: unknown;
+    profile: BuildTranspileProfile;
+    excludeAppBuildPlugins?: string[];
+};
+type BrowserBundleGroupedOptions = {
+    outdir?: string;
+    outbase?: string;
+    naming?: string;
+    conditions?: string[];
+    define?: Record<string, string>;
+    minify?: boolean;
+    treeshaking?: boolean;
+    splitting?: boolean;
+    root?: string;
+    bundle?: boolean;
+    externalPackages?: boolean;
+    external?: string[];
+    plugins?: EcoBuildPlugin[];
+    [key: string]: unknown;
+    profile: BuildTranspileProfile;
+    excludeAppBuildPlugins?: string[];
+};
+export interface BrowserBundleExecutor {
+    bundle(options: BrowserBundleOptions): Promise<BuildResult>;
+}
+export type BrowserBundleGroupedEntry = {
+    entrypoint: string;
+    entryName: string;
+};
+/**
+ * App-owned boundary for browser-oriented bundle work.
+ *
+ * @remarks
+ * This service owns the shared browser transpile defaults and ensures browser
+ * builds always run through the app-owned executor rather than direct backend
+ * calls scattered across HMR and asset processing paths.
+ */
+export declare class BrowserBundleService implements BrowserBundleExecutor {
+    private readonly appConfig;
+    /**
+     * Creates the browser bundle boundary for one finalized app instance.
+     */
+    constructor(appConfig: EcoPagesAppConfig);
+    /**
+     * Runs one browser-targeted build through the app-owned executor.
+     *
+     * @remarks
+     * Browser defaults and app-owned browser build plugins are applied here so HMR
+     * and runtime asset generation do not have to recreate that policy at each call
+     * site.
+     */
+    bundle(options: BrowserBundleOptions): Promise<BuildResult>;
+    bundleGroupedEntries(entries: BrowserBundleGroupedEntry[], options: BrowserBundleGroupedOptions): Promise<BuildResult>;
+}
+export {};

package/src/services/assets/browser-bundle.service.js

@@ -0,0 +1,41 @@
+import { getAppBrowserBuildPlugins, getAppBuildExecutor, getAppTranspileOptions } from "../../build/build-adapter.js";
+import { mergeEcoBuildPlugins } from "../../build/build-manifest.js";
+class BrowserBundleService {
+  appConfig;
+  /**
+   * Creates the browser bundle boundary for one finalized app instance.
+   */
+  constructor(appConfig) {
+    this.appConfig = appConfig;
+  }
+  /**
+   * Runs one browser-targeted build through the app-owned executor.
+   *
+   * @remarks
+   * Browser defaults and app-owned browser build plugins are applied here so HMR
+   * and runtime asset generation do not have to recreate that policy at each call
+   * site.
+   */
+  async bundle(options) {
+    const { profile, excludeAppBuildPlugins, plugins, ...rawBuildOptions } = options;
+    const appBrowserPlugins = getAppBrowserBuildPlugins(this.appConfig);
+    const filteredAppBrowserPlugins = excludeAppBuildPlugins && excludeAppBuildPlugins.length > 0 ? appBrowserPlugins.filter((plugin) => !excludeAppBuildPlugins.includes(plugin.name)) : appBrowserPlugins;
+    const request = {
+      ...rawBuildOptions,
+      entrypoints: options.entrypoints,
+      ...getAppTranspileOptions(this.appConfig, profile),
+      plugins: mergeEcoBuildPlugins(plugins, filteredAppBrowserPlugins)
+    };
+    return await getAppBuildExecutor(this.appConfig).build(request);
+  }
+  async bundleGroupedEntries(entries, options) {
+    const request = {
+      ...options,
+      entrypoints: entries.map((entry) => entry.entrypoint)
+    };
+    return this.bundle(request);
+  }
+}
+export {
+  BrowserBundleService
+};

package/src/services/cache/cache.types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Cache types and interfaces for page caching and ISR
+ * @module
+ */
+/**
+ * Result from rendering a page, including HTML and cache strategy.
+ */
+export interface RenderResult {
+    html: string;
+    strategy: CacheStrategy;
+}
+/**
+ * Render strategy configuration for pages.
+ * - `'static'`: Render once, cache indefinitely
+ * - `'dynamic'`: No caching, render on every request
+ * - `{ revalidate, tags }`: Cache with time-based revalidation and optional tags
+ */
+export type CacheStrategy = 'static' | 'dynamic' | {
+    /** Seconds until cache is considered stale */
+    revalidate: number;
+    /** Tags for on-demand invalidation */
+    tags?: string[];
+};
+/**
+ * Cache entry stored in the cache store.
+ */
+export interface CacheEntry {
+    /** The rendered HTML content */
+    html: string;
+    /** Timestamp when the entry was created */
+    createdAt: number;
+    /** Timestamp when the entry should be revalidated (null = never stale) */
+    revalidateAfter: number | null;
+    /** Tags associated with this entry for invalidation */
+    tags: string[];
+    /** The cache strategy used (for generating headers on HIT) */
+    strategy: CacheStrategy;
+}
+/**
+ * Cache statistics for debugging and monitoring.
+ */
+export interface CacheStats {
+    /** Number of entries in the cache */
+    entries: number;
+    /** Memory usage in bytes (if available) */
+    memoryUsage?: number;
+    /** Cache hit rate (if tracked) */
+    hitRate?: number;
+}
+/**
+ * Abstract interface for cache storage backends.
+ * Implementations must handle serialization/deserialization internally.
+ */
+export interface CacheStore {
+    /** Retrieve an entry by key */
+    get(key: string): Promise<CacheEntry | null>;
+    /** Store an entry */
+    set(key: string, entry: CacheEntry): Promise<void>;
+    /** Delete a specific entry */
+    delete(key: string): Promise<boolean>;
+    /** Delete all entries matching any of the provided tags */
+    invalidateByTags(tags: string[]): Promise<number>;
+    /** Delete entries by exact path */
+    invalidateByPaths(paths: string[]): Promise<number>;
+    /** Clear all entries */
+    clear(): Promise<void>;
+    /** Get cache statistics (optional, for debugging) */
+    stats?(): Promise<CacheStats>;
+}
+/**
+ * Configuration for the cache system.
+ */
+export interface CacheConfig {
+    /**
+     * Cache store implementation.
+     * @default 'memory'
+     */
+    store?: 'memory' | CacheStore;
+    /**
+     * Default cache strategy for pages that don't specify one.
+     * @default 'static'
+     */
+    defaultStrategy?: CacheStrategy;
+    /**
+     * Whether caching is enabled.
+     * Automatically disabled in dev mode unless explicitly set.
+     * @default true (production), false (development)
+     */
+    enabled?: boolean;
+    /**
+     * Maximum number of entries in the memory cache before LRU eviction.
+     * Only applies when using the built-in memory store.
+     * @default 1000
+     */
+    maxEntries?: number;
+}
+/**
+ * Result of a cache lookup operation.
+ */
+export interface CacheResult {
+    /** The cached HTML content */
+    html: string;
+    /** Cache status for X-Cache header */
+    status: 'hit' | 'miss' | 'stale';
+    /** The cache strategy (for generating Cache-Control headers) */
+    strategy: CacheStrategy;
+}

package/src/services/cache/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Cache services exports
+ * @module
+ */
+export type { CacheConfig, CacheEntry, CacheResult, CacheStats, CacheStore, CacheStrategy, RenderResult, } from './cache.types.js';
+export { MemoryCacheStore, type MemoryCacheStoreOptions } from './memory-cache-store.js';
+export { getCacheControlHeader, PageCacheService, type PageCacheServiceOptions } from './page-cache-service.js';

package/src/services/cache/index.js

@@ -0,0 +1,7 @@
+import { MemoryCacheStore } from "./memory-cache-store.js";
+import { getCacheControlHeader, PageCacheService } from "./page-cache-service.js";
+export {
+  MemoryCacheStore,
+  PageCacheService,
+  getCacheControlHeader
+};

package/src/services/cache/memory-cache-store.d.ts

@@ -0,0 +1,42 @@
+/**
+ * In-memory cache store with LRU eviction.
+ * Suitable for single-instance deployments and development.
+ * @module
+ */
+import type { CacheEntry, CacheStats, CacheStore } from './cache.types.js';
+export interface MemoryCacheStoreOptions {
+    /** Maximum number of entries before LRU eviction. @default 1000 */
+    maxEntries?: number;
+}
+/**
+ * Simple in-memory cache store with LRU eviction.
+ * Uses Map insertion order for LRU tracking.
+ */
+export declare class MemoryCacheStore implements CacheStore {
+    private cache;
+    private tagIndex;
+    private readonly maxEntries;
+    constructor(options?: MemoryCacheStoreOptions);
+    /**
+     * Retrieve an entry by key.
+     * Uses Map's insertion order for LRU tracking - accessed entries are
+     * deleted and re-inserted to move them to the "most recently used" position.
+     */
+    get(key: string): Promise<CacheEntry | null>;
+    /**
+     * Store an entry, evicting the oldest if at capacity.
+     * When maxEntries is reached and a new key is added, the first key in
+     * the Map (oldest/least-recently-used) is evicted to make room.
+     * Updating an existing key refreshes its LRU position.
+     */
+    set(key: string, entry: CacheEntry): Promise<void>;
+    /**
+     * Delete an entry and clean up its tag index references.
+     * Removes empty tag sets to prevent memory leaks from accumulated tags.
+     */
+    delete(key: string): Promise<boolean>;
+    invalidateByTags(tags: string[]): Promise<number>;
+    invalidateByPaths(paths: string[]): Promise<number>;
+    clear(): Promise<void>;
+    stats(): Promise<CacheStats>;
+}

package/src/services/cache/memory-cache-store.js

@@ -0,0 +1,98 @@
+class MemoryCacheStore {
+  cache = /* @__PURE__ */ new Map();
+  tagIndex = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(options = {}) {
+    this.maxEntries = options.maxEntries ?? 1e3;
+  }
+  /**
+   * Retrieve an entry by key.
+   * Uses Map's insertion order for LRU tracking - accessed entries are
+   * deleted and re-inserted to move them to the "most recently used" position.
+   */
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry;
+  }
+  /**
+   * Store an entry, evicting the oldest if at capacity.
+   * When maxEntries is reached and a new key is added, the first key in
+   * the Map (oldest/least-recently-used) is evicted to make room.
+   * Updating an existing key refreshes its LRU position.
+   */
+  async set(key, entry) {
+    const existingEntry = this.cache.get(key);
+    if (existingEntry) {
+      for (const tag of existingEntry.tags) {
+        this.tagIndex.get(tag)?.delete(key);
+        if (this.tagIndex.get(tag)?.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxEntries) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) await this.delete(oldestKey);
+    }
+    this.cache.set(key, entry);
+    for (const tag of entry.tags) {
+      if (!this.tagIndex.has(tag)) {
+        this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+      }
+      this.tagIndex.get(tag).add(key);
+    }
+  }
+  /**
+   * Delete an entry and clean up its tag index references.
+   * Removes empty tag sets to prevent memory leaks from accumulated tags.
+   */
+  async delete(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    for (const tag of entry.tags) {
+      this.tagIndex.get(tag)?.delete(key);
+      if (this.tagIndex.get(tag)?.size === 0) {
+        this.tagIndex.delete(tag);
+      }
+    }
+    return this.cache.delete(key);
+  }
+  async invalidateByTags(tags) {
+    let count = 0;
+    const keysToDelete = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        for (const key of keys) {
+          keysToDelete.add(key);
+        }
+      }
+    }
+    for (const key of keysToDelete) {
+      if (await this.delete(key)) count++;
+    }
+    return count;
+  }
+  async invalidateByPaths(paths) {
+    let count = 0;
+    for (const path of paths) {
+      if (await this.delete(path)) count++;
+    }
+    return count;
+  }
+  async clear() {
+    this.cache.clear();
+    this.tagIndex.clear();
+  }
+  async stats() {
+    return {
+      entries: this.cache.size
+    };
+  }
+}
+export {
+  MemoryCacheStore
+};