@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.41

package/src/services/module-loading/server-module-transpiler.service.js

@@ -1,64 +1,67 @@
-import { PageModuleImportService } from "./page-module-import.service.js";
-class ServerModuleTranspiler {
-  pageModuleImportService;
-  getRootDir;
-  getBuildExecutor;
-  getInvalidationVersion;
-  invalidateModules;
-  getDefaultPlugins;
-  /**
-   * Creates one explicit server-transpiler boundary for a given execution
-   * context.
-   */
-  constructor(args) {
-    this.pageModuleImportService = args.pageModuleImportService ?? new PageModuleImportService({
-      canLoadSourceModuleFromHost: args.canLoadSourceModuleFromHost,
-      getHostModuleLoader: args.getHostModuleLoader
-    });
-    this.getRootDir = () => args.rootDir;
-    this.getBuildExecutor = args.getBuildExecutor ?? (() => void 0);
-    this.getInvalidationVersion = () => args.getInvalidationVersion?.();
-    this.getDefaultPlugins = args.getDefaultPlugins ?? (() => []);
-    this.invalidateModules = (changedFiles) => {
-      if (args.invalidateModules) {
-        args.invalidateModules(changedFiles);
+import { PageModuleImportService } from './page-module-import.service.js';
+/**
+ * App-owned boundary for server-side source module loading.
+ *
+ * @remarks
+ * This service centralizes server-side module transpilation and import behind
+ * an explicit caller-owned root and build executor.
+ */
+export class ServerModuleTranspiler {
+    pageModuleImportService;
+    getRootDir;
+    getBuildExecutor;
+    invalidateModules;
+    getDefaultPlugins;
+    /**
+     * Creates one explicit server-transpiler boundary for a given execution
+     * context.
+     */
+    constructor(args) {
+        this.pageModuleImportService =
+            args.pageModuleImportService ??
+                new PageModuleImportService(undefined, {
+                    canLoadSourceModuleFromHost: args.canLoadSourceModuleFromHost,
+                    getHostModuleLoader: args.getHostModuleLoader,
+                });
+        this.getRootDir = () => args.rootDir;
+        this.getBuildExecutor = args.getBuildExecutor ?? (() => undefined);
+        this.getDefaultPlugins = args.getDefaultPlugins ?? (() => []);
+        this.invalidateModules = (changedFiles) => {
+            if (args.invalidateModules) {
+                args.invalidateModules(changedFiles);
+                return;
+            }
+            this.pageModuleImportService.invalidateDevelopmentGraph();
+        };
+    }
+    /**
+     * Loads a server-side source module through the caller-owned transpile
+     * context.
+     */
+    async importModule(options) {
+        const mergedPlugins = [...this.getDefaultPlugins(), ...(options.plugins ?? [])];
+        const { plugins: _plugins, ...baseOptions } = options;
+        return await this.pageModuleImportService.importModule({
+            ...baseOptions,
+            ...(mergedPlugins.length > 0 ? { plugins: mergedPlugins } : {}),
+            rootDir: this.getRootDir(),
+            buildExecutor: this.getBuildExecutor(),
+        });
+    }
+    /**
+     * Invalidates cached module state for development reloads.
+     */
+    invalidate(changedFiles) {
+        this.invalidateModules(changedFiles);
+    }
+    /**
+     * Releases transpiler-owned resources.
+     *
+     * @remarks
+     * The current implementation delegates cache ownership to lower-level module
+     * loading services, so disposal is intentionally a no-op for now.
+     */
+    async dispose() {
         return;
-      }
-      this.pageModuleImportService.invalidateDevelopmentGraph();
-    };
-  }
-  /**
-   * Loads a server-side source module through the caller-owned transpile
-   * context.
-   */
-  async importModule(options) {
-    const mergedPlugins = [...this.getDefaultPlugins(), ...options.plugins ?? []];
-    const { plugins: _plugins, ...baseOptions } = options;
-    return await this.pageModuleImportService.importModule({
-      ...baseOptions,
-      ...mergedPlugins.length > 0 ? { plugins: mergedPlugins } : {},
-      rootDir: this.getRootDir(),
-      buildExecutor: this.getBuildExecutor(),
-      invalidationVersion: this.getInvalidationVersion()
-    });
-  }
-  /**
-   * Invalidates cached module state for development reloads.
-   */
-  invalidate(changedFiles) {
-    this.invalidateModules(changedFiles);
-  }
-  /**
-   * Releases transpiler-owned resources.
-   *
-   * @remarks
-   * The current implementation delegates cache ownership to lower-level module
-   * loading services, so disposal is intentionally a no-op for now.
-   */
-  async dispose() {
-    return;
-  }
+    }
 }
-export {
-  ServerModuleTranspiler
-};

package/src/services/module-loading/source-module-support.js

@@ -1,8 +1,16 @@
-import path from "node:path";
-function supportsSourceModuleLoading(filePath) {
-  const extension = path.extname(filePath);
-  return extension === ".js" || extension === ".jsx" || extension === ".ts" || extension === ".tsx" || extension === ".mjs" || extension === ".mts" || extension === ".cjs" || extension === ".cts";
+import path from 'node:path';
+/**
+ * Returns whether a source module can be loaded directly by the host runtime without
+ * first going through the transpile/import pipeline.
+ */
+export function supportsSourceModuleLoading(filePath) {
+    const extension = path.extname(filePath);
+    return (extension === '.js' ||
+        extension === '.jsx' ||
+        extension === '.ts' ||
+        extension === '.tsx' ||
+        extension === '.mjs' ||
+        extension === '.mts' ||
+        extension === '.cjs' ||
+        extension === '.cts');
 }
-export {
-  supportsSourceModuleLoading
-};

package/src/services/runtime-state/dev-graph.service.js

@@ -1,162 +1,170 @@
-import {
-  CounterServerInvalidationState,
-  getAppServerInvalidationState,
-  setAppServerInvalidationState
-} from "./server-invalidation-state.service.js";
-import {
-  getAppEntrypointDependencyGraph,
-  InMemoryEntrypointDependencyGraph,
-  NoopEntrypointDependencyGraph,
-  setAppEntrypointDependencyGraph
-} from "./entrypoint-dependency-graph.service.js";
-class NoopDevGraphService {
-  invalidationState = new CounterServerInvalidationState();
-  dependencyGraph = new NoopEntrypointDependencyGraph();
-  /**
-   * Returns the current coarse invalidation version.
-   */
-  getServerInvalidationVersion() {
-    return this.invalidationState.getServerInvalidationVersion();
-  }
-  /**
-   * Invalidates all server-side module state by incrementing the shared version.
-   */
-  invalidateServerModules(changedFiles) {
-    this.invalidationState.invalidateServerModules(changedFiles);
-  }
-  /**
-   * Indicates that this graph cannot target invalidation to one entrypoint set.
-   */
-  supportsSelectiveInvalidation() {
-    return this.dependencyGraph.supportsSelectiveInvalidation();
-  }
-  /**
-   * Returns an empty entrypoint set because this implementation stores no
-   * dependency graph metadata.
-   */
-  getDependencyEntrypoints(filePath) {
-    return this.dependencyGraph.getDependencyEntrypoints(filePath);
-  }
-  /**
-   * Accepts dependency updates to preserve interface compatibility, but stores no
-   * graph state in the noop implementation.
-   */
-  setEntrypointDependencies(entrypointPath, dependencies) {
-    this.dependencyGraph.setEntrypointDependencies(entrypointPath, dependencies);
-  }
-  /**
-   * Clears one entrypoint from the graph.
-   *
-   * @remarks
-   * There is no stored graph state in this implementation, so this is a no-op.
-   */
-  clearEntrypointDependencies(entrypointPath) {
-    this.dependencyGraph.clearEntrypointDependencies(entrypointPath);
-  }
-  /**
-   * Resets graph-owned state for a fresh runtime cycle.
-   */
-  reset() {
-    this.invalidationState.reset();
-    this.dependencyGraph.reset();
-  }
+import { CounterServerInvalidationState, getAppServerInvalidationState, setAppServerInvalidationState, } from './server-invalidation-state.service.js';
+import { getAppEntrypointDependencyGraph, InMemoryEntrypointDependencyGraph, NoopEntrypointDependencyGraph, setAppEntrypointDependencyGraph, } from './entrypoint-dependency-graph.service.js';
+/**
+ * Minimal dev-graph implementation used when an app has no selective graph
+ * metadata available.
+ *
+ * @remarks
+ * This preserves correct behavior by using coarse invalidation version bumps.
+ * Callers still pass changed-file information through the interface now so a
+ * richer graph can become more selective later without changing call sites.
+ */
+export class NoopDevGraphService {
+    invalidationState = new CounterServerInvalidationState();
+    dependencyGraph = new NoopEntrypointDependencyGraph();
+    /**
+     * Returns the current coarse invalidation version.
+     */
+    getServerInvalidationVersion() {
+        return this.invalidationState.getServerInvalidationVersion();
+    }
+    /**
+     * Invalidates all server-side module state by incrementing the shared version.
+     */
+    invalidateServerModules(changedFiles) {
+        this.invalidationState.invalidateServerModules(changedFiles);
+    }
+    /**
+     * Indicates that this graph cannot target invalidation to one entrypoint set.
+     */
+    supportsSelectiveInvalidation() {
+        return this.dependencyGraph.supportsSelectiveInvalidation();
+    }
+    /**
+     * Returns an empty entrypoint set because this implementation stores no
+     * dependency graph metadata.
+     */
+    getDependencyEntrypoints(filePath) {
+        return this.dependencyGraph.getDependencyEntrypoints(filePath);
+    }
+    /**
+     * Accepts dependency updates to preserve interface compatibility, but stores no
+     * graph state in the noop implementation.
+     */
+    setEntrypointDependencies(entrypointPath, dependencies) {
+        this.dependencyGraph.setEntrypointDependencies(entrypointPath, dependencies);
+    }
+    /**
+     * Clears one entrypoint from the graph.
+     *
+     * @remarks
+     * There is no stored graph state in this implementation, so this is a no-op.
+     */
+    clearEntrypointDependencies(entrypointPath) {
+        this.dependencyGraph.clearEntrypointDependencies(entrypointPath);
+    }
+    /**
+     * Resets graph-owned state for a fresh runtime cycle.
+     */
+    reset() {
+        this.invalidationState.reset();
+        this.dependencyGraph.reset();
+    }
 }
-class InMemoryDevGraphService {
-  invalidationState = new CounterServerInvalidationState();
-  dependencyGraph = new InMemoryEntrypointDependencyGraph();
-  /**
-   * Returns the current app-local server invalidation version.
-   */
-  getServerInvalidationVersion() {
-    return this.invalidationState.getServerInvalidationVersion();
-  }
-  /**
-   * Invalidates the current server-module cache generation.
-   *
-   * @remarks
-   * The current implementation still uses a coarse generation bump for server
-   * modules. Selective dependency lookups are used by callers that need to limit
-   * browser rebuild work.
-   */
-  invalidateServerModules(changedFiles) {
-    this.invalidationState.invalidateServerModules(changedFiles);
-  }
-  /**
-   * Indicates that this graph can answer dependency-to-entrypoint lookups.
-   */
-  supportsSelectiveInvalidation() {
-    return this.dependencyGraph.supportsSelectiveInvalidation();
-  }
-  /**
-   * Returns all known entrypoints that currently depend on the given file.
-   */
-  getDependencyEntrypoints(filePath) {
-    return this.dependencyGraph.getDependencyEntrypoints(filePath);
-  }
-  /**
-   * Replaces the stored dependency set for one entrypoint.
-   *
-   * @remarks
-   * The entrypoint itself is always included in its own dependency set so reverse
-   * lookups can map a changed entry file back to that same entrypoint.
-   */
-  setEntrypointDependencies(entrypointPath, dependencies) {
-    this.dependencyGraph.setEntrypointDependencies(entrypointPath, dependencies);
-  }
-  /**
-   * Removes one entrypoint and all of its reverse dependency edges.
-   */
-  clearEntrypointDependencies(entrypointPath) {
-    this.dependencyGraph.clearEntrypointDependencies(entrypointPath);
-  }
-  /**
-   * Clears all graph state and starts a fresh invalidation generation.
-   */
-  reset() {
-    this.invalidationState.reset();
-    this.dependencyGraph.reset();
-  }
+/**
+ * In-memory development graph with entrypoint-to-dependency reverse lookups.
+ *
+ * @remarks
+ * This is the current selective graph implementation used by development flows
+ * that need to answer which entrypoints depend on a changed file while still
+ * keeping invalidation state app-local.
+ */
+export class InMemoryDevGraphService {
+    invalidationState = new CounterServerInvalidationState();
+    dependencyGraph = new InMemoryEntrypointDependencyGraph();
+    /**
+     * Returns the current app-local server invalidation version.
+     */
+    getServerInvalidationVersion() {
+        return this.invalidationState.getServerInvalidationVersion();
+    }
+    /**
+     * Invalidates the current server-module cache generation.
+     *
+     * @remarks
+     * The current implementation still uses a coarse generation bump for server
+     * modules. Selective dependency lookups are used by callers that need to limit
+     * browser rebuild work.
+     */
+    invalidateServerModules(changedFiles) {
+        this.invalidationState.invalidateServerModules(changedFiles);
+    }
+    /**
+     * Indicates that this graph can answer dependency-to-entrypoint lookups.
+     */
+    supportsSelectiveInvalidation() {
+        return this.dependencyGraph.supportsSelectiveInvalidation();
+    }
+    /**
+     * Returns all known entrypoints that currently depend on the given file.
+     */
+    getDependencyEntrypoints(filePath) {
+        return this.dependencyGraph.getDependencyEntrypoints(filePath);
+    }
+    /**
+     * Replaces the stored dependency set for one entrypoint.
+     *
+     * @remarks
+     * The entrypoint itself is always included in its own dependency set so reverse
+     * lookups can map a changed entry file back to that same entrypoint.
+     */
+    setEntrypointDependencies(entrypointPath, dependencies) {
+        this.dependencyGraph.setEntrypointDependencies(entrypointPath, dependencies);
+    }
+    /**
+     * Removes one entrypoint and all of its reverse dependency edges.
+     */
+    clearEntrypointDependencies(entrypointPath) {
+        this.dependencyGraph.clearEntrypointDependencies(entrypointPath);
+    }
+    /**
+     * Clears all graph state and starts a fresh invalidation generation.
+     */
+    reset() {
+        this.invalidationState.reset();
+        this.dependencyGraph.reset();
+    }
 }
-function getAppDevGraphService(appConfig) {
-  if (appConfig.runtime?.devGraphService) {
-    return appConfig.runtime.devGraphService;
-  }
-  const serverInvalidationState = getAppServerInvalidationState(appConfig);
-  const entrypointDependencyGraph = getAppEntrypointDependencyGraph(appConfig);
-  return {
-    getServerInvalidationVersion: () => serverInvalidationState.getServerInvalidationVersion(),
-    invalidateServerModules: (changedFiles) => serverInvalidationState.invalidateServerModules(changedFiles),
-    supportsSelectiveInvalidation: () => entrypointDependencyGraph.supportsSelectiveInvalidation(),
-    getDependencyEntrypoints: (filePath) => entrypointDependencyGraph.getDependencyEntrypoints(filePath),
-    setEntrypointDependencies: (entrypointPath, dependencies) => entrypointDependencyGraph.setEntrypointDependencies(entrypointPath, dependencies),
-    clearEntrypointDependencies: (entrypointPath) => entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath),
-    reset: () => {
-      serverInvalidationState.reset();
-      entrypointDependencyGraph.reset();
+/**
+ * Returns the dev-graph service owned by one app instance.
+ */
+export function getAppDevGraphService(appConfig) {
+    if (appConfig.runtime?.devGraphService) {
+        return appConfig.runtime.devGraphService;
     }
-  };
+    const serverInvalidationState = getAppServerInvalidationState(appConfig);
+    const entrypointDependencyGraph = getAppEntrypointDependencyGraph(appConfig);
+    return {
+        getServerInvalidationVersion: () => serverInvalidationState.getServerInvalidationVersion(),
+        invalidateServerModules: (changedFiles) => serverInvalidationState.invalidateServerModules(changedFiles),
+        supportsSelectiveInvalidation: () => entrypointDependencyGraph.supportsSelectiveInvalidation(),
+        getDependencyEntrypoints: (filePath) => entrypointDependencyGraph.getDependencyEntrypoints(filePath),
+        setEntrypointDependencies: (entrypointPath, dependencies) => entrypointDependencyGraph.setEntrypointDependencies(entrypointPath, dependencies),
+        clearEntrypointDependencies: (entrypointPath) => entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath),
+        reset: () => {
+            serverInvalidationState.reset();
+            entrypointDependencyGraph.reset();
+        },
+    };
 }
-function setAppDevGraphService(appConfig, devGraphService) {
-  setAppServerInvalidationState(appConfig, {
-    getServerInvalidationVersion: () => devGraphService.getServerInvalidationVersion(),
-    invalidateServerModules: (changedFiles) => devGraphService.invalidateServerModules(changedFiles),
-    reset: () => devGraphService.reset()
-  });
-  setAppEntrypointDependencyGraph(appConfig, {
-    supportsSelectiveInvalidation: () => devGraphService.supportsSelectiveInvalidation(),
-    getDependencyEntrypoints: (filePath) => devGraphService.getDependencyEntrypoints(filePath),
-    setEntrypointDependencies: (entrypointPath, dependencies) => devGraphService.setEntrypointDependencies(entrypointPath, dependencies),
-    clearEntrypointDependencies: (entrypointPath) => devGraphService.clearEntrypointDependencies(entrypointPath),
-    reset: () => devGraphService.reset()
-  });
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    devGraphService
-  };
+/**
+ * Installs the dev-graph service that should back one app/runtime instance.
+ */
+export function setAppDevGraphService(appConfig, devGraphService) {
+    setAppServerInvalidationState(appConfig, {
+        getServerInvalidationVersion: () => devGraphService.getServerInvalidationVersion(),
+        invalidateServerModules: (changedFiles) => devGraphService.invalidateServerModules(changedFiles),
+        reset: () => devGraphService.reset(),
+    });
+    setAppEntrypointDependencyGraph(appConfig, {
+        supportsSelectiveInvalidation: () => devGraphService.supportsSelectiveInvalidation(),
+        getDependencyEntrypoints: (filePath) => devGraphService.getDependencyEntrypoints(filePath),
+        setEntrypointDependencies: (entrypointPath, dependencies) => devGraphService.setEntrypointDependencies(entrypointPath, dependencies),
+        clearEntrypointDependencies: (entrypointPath) => devGraphService.clearEntrypointDependencies(entrypointPath),
+        reset: () => devGraphService.reset(),
+    });
+    appConfig.runtime = {
+        ...(appConfig.runtime ?? {}),
+        devGraphService,
+    };
 }
-export {
-  InMemoryDevGraphService,
-  NoopDevGraphService,
-  getAppDevGraphService,
-  setAppDevGraphService
-};

package/src/services/runtime-state/entrypoint-dependency-graph.service.js

@@ -1,85 +1,94 @@
-import path from "node:path";
-class NoopEntrypointDependencyGraph {
-  supportsSelectiveInvalidation() {
-    return false;
-  }
-  getDependencyEntrypoints(_filePath) {
-    return /* @__PURE__ */ new Set();
-  }
-  setEntrypointDependencies(_entrypointPath, _dependencies) {
-  }
-  clearEntrypointDependencies(_entrypointPath) {
-  }
-  reset() {
-  }
+import path from 'node:path';
+/**
+ * Graph implementation for runtimes that rebuild every watched entrypoint.
+ */
+export class NoopEntrypointDependencyGraph {
+    supportsSelectiveInvalidation() {
+        return false;
+    }
+    getDependencyEntrypoints(_filePath) {
+        return new Set();
+    }
+    setEntrypointDependencies(_entrypointPath, _dependencies) { }
+    clearEntrypointDependencies(_entrypointPath) { }
+    reset() { }
 }
-class InMemoryEntrypointDependencyGraph {
-  dependencyEntrypoints = /* @__PURE__ */ new Map();
-  entrypointDependencies = /* @__PURE__ */ new Map();
-  supportsSelectiveInvalidation() {
-    return true;
-  }
-  getDependencyEntrypoints(filePath) {
-    return new Set(this.dependencyEntrypoints.get(path.resolve(filePath)) ?? []);
-  }
-  setEntrypointDependencies(entrypointPath, dependencies) {
-    const normalizedEntrypoint = path.resolve(entrypointPath);
-    this.clearEntrypointDependencies(normalizedEntrypoint);
-    const normalizedDependencies = /* @__PURE__ */ new Set([
-      normalizedEntrypoint,
-      ...dependencies.map((dependencyPath) => path.resolve(dependencyPath))
-    ]);
-    this.entrypointDependencies.set(normalizedEntrypoint, normalizedDependencies);
-    for (const dependencyPath of normalizedDependencies) {
-      const entrypoints = this.dependencyEntrypoints.get(dependencyPath) ?? /* @__PURE__ */ new Set();
-      entrypoints.add(normalizedEntrypoint);
-      this.dependencyEntrypoints.set(dependencyPath, entrypoints);
+/**
+ * In-memory entrypoint-to-dependency graph with reverse dependency lookups.
+ */
+export class InMemoryEntrypointDependencyGraph {
+    dependencyEntrypoints = new Map();
+    entrypointDependencies = new Map();
+    supportsSelectiveInvalidation() {
+        return true;
+    }
+    getDependencyEntrypoints(filePath) {
+        return new Set(this.dependencyEntrypoints.get(path.resolve(filePath)) ?? []);
     }
-  }
-  clearEntrypointDependencies(entrypointPath) {
-    const normalizedEntrypoint = path.resolve(entrypointPath);
-    const previousDependencies = this.entrypointDependencies.get(normalizedEntrypoint);
-    if (!previousDependencies) {
-      return;
+    setEntrypointDependencies(entrypointPath, dependencies) {
+        const normalizedEntrypoint = path.resolve(entrypointPath);
+        this.clearEntrypointDependencies(normalizedEntrypoint);
+        const normalizedDependencies = new Set([
+            normalizedEntrypoint,
+            ...dependencies.map((dependencyPath) => path.resolve(dependencyPath)),
+        ]);
+        this.entrypointDependencies.set(normalizedEntrypoint, normalizedDependencies);
+        for (const dependencyPath of normalizedDependencies) {
+            const entrypoints = this.dependencyEntrypoints.get(dependencyPath) ?? new Set();
+            entrypoints.add(normalizedEntrypoint);
+            this.dependencyEntrypoints.set(dependencyPath, entrypoints);
+        }
     }
-    for (const dependencyPath of previousDependencies) {
-      const entrypoints = this.dependencyEntrypoints.get(dependencyPath);
-      if (!entrypoints) {
-        continue;
-      }
-      entrypoints.delete(normalizedEntrypoint);
-      if (entrypoints.size === 0) {
-        this.dependencyEntrypoints.delete(dependencyPath);
-      }
+    clearEntrypointDependencies(entrypointPath) {
+        const normalizedEntrypoint = path.resolve(entrypointPath);
+        const previousDependencies = this.entrypointDependencies.get(normalizedEntrypoint);
+        if (!previousDependencies) {
+            return;
+        }
+        for (const dependencyPath of previousDependencies) {
+            const entrypoints = this.dependencyEntrypoints.get(dependencyPath);
+            if (!entrypoints) {
+                continue;
+            }
+            entrypoints.delete(normalizedEntrypoint);
+            if (entrypoints.size === 0) {
+                this.dependencyEntrypoints.delete(dependencyPath);
+            }
+        }
+        this.entrypointDependencies.delete(normalizedEntrypoint);
+    }
+    reset() {
+        this.dependencyEntrypoints.clear();
+        this.entrypointDependencies.clear();
     }
-    this.entrypointDependencies.delete(normalizedEntrypoint);
-  }
-  reset() {
-    this.dependencyEntrypoints.clear();
-    this.entrypointDependencies.clear();
-  }
 }
 function isLegacyEntrypointDependencyGraph(value) {
-  return Boolean(value) && typeof value === "object" && typeof value.supportsSelectiveInvalidation === "function" && typeof value.getDependencyEntrypoints === "function" && typeof value.setEntrypointDependencies === "function" && typeof value.clearEntrypointDependencies === "function" && typeof value.reset === "function";
+    return (Boolean(value) &&
+        typeof value === 'object' &&
+        typeof value.supportsSelectiveInvalidation === 'function' &&
+        typeof value.getDependencyEntrypoints === 'function' &&
+        typeof value.setEntrypointDependencies === 'function' &&
+        typeof value.clearEntrypointDependencies === 'function' &&
+        typeof value.reset === 'function');
 }
-function getAppEntrypointDependencyGraph(appConfig) {
-  if (appConfig.runtime?.entrypointDependencyGraph) {
-    return appConfig.runtime.entrypointDependencyGraph;
-  }
-  if (isLegacyEntrypointDependencyGraph(appConfig.runtime?.devGraphService)) {
-    return appConfig.runtime.devGraphService;
-  }
-  return new NoopEntrypointDependencyGraph();
+/**
+ * Returns the app-owned entrypoint dependency graph.
+ */
+export function getAppEntrypointDependencyGraph(appConfig) {
+    if (appConfig.runtime?.entrypointDependencyGraph) {
+        return appConfig.runtime.entrypointDependencyGraph;
+    }
+    if (isLegacyEntrypointDependencyGraph(appConfig.runtime?.devGraphService)) {
+        return appConfig.runtime.devGraphService;
+    }
+    return new NoopEntrypointDependencyGraph();
 }
-function setAppEntrypointDependencyGraph(appConfig, entrypointDependencyGraph) {
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    entrypointDependencyGraph
-  };
+/**
+ * Installs the dependency graph used by one app instance.
+ */
+export function setAppEntrypointDependencyGraph(appConfig, entrypointDependencyGraph) {
+    appConfig.runtime = {
+        ...(appConfig.runtime ?? {}),
+        entrypointDependencyGraph,
+    };
 }
-export {
-  InMemoryEntrypointDependencyGraph,
-  NoopEntrypointDependencyGraph,
-  getAppEntrypointDependencyGraph,
-  setAppEntrypointDependencyGraph
-};