@ecopages/core 0.2.0-alpha.9 → 0.2.1

package/src/services/module-loading/page-module-import.service.ts

@@ -1,200 +0,0 @@
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { fileSystem } from '@ecopages/file-system';
-import { build, type BuildExecutor, type BuildResult } from '../../build/build-adapter.ts';
-import type { EcoBuildPlugin } from '../../build/build-types.ts';
-
-export interface PageModuleImportOptions {
-	filePath: string;
-	rootDir: string;
-	outdir: string;
-	buildExecutor?: BuildExecutor;
-	invalidationVersion?: number;
-	splitting?: boolean;
-	externalPackages?: boolean;
-	plugins?: EcoBuildPlugin[];
-	transpileErrorMessage?: (details: string) => string;
-	noOutputMessage?: (filePath: string) => string;
-}
-
-/**
- * Minimal runtime dependencies required to load page modules.
- *
- * @remarks
- * This service owns cache and runtime import policy. Hashing and build
- * execution are injected so tests can provide explicit fakes without module
- * interception.
- */
-export interface PageModuleImportDependencies {
-	hashFile(filePath: string): string;
-	buildModule(options: Parameters<typeof build>[0], buildExecutor?: BuildExecutor): Promise<BuildResult>;
-}
-
-/**
- * Loads source page modules in a runtime-agnostic way.
- *
- * This service centralizes the Bun-vs-Node import strategy used by route
- * scanning, page data loading, and request-time page inspection. In Bun it can
- * import source files directly; in Node it transpiles the file into a dedicated
- * output directory first and then imports the generated module.
- *
- * Keeping this logic in one place prevents subtle drift in cache-busting,
- * transpilation settings, and error semantics across the different callers.
- */
-export class PageModuleImportService {
-	private readonly dependencies: PageModuleImportDependencies;
-	private readonly importCache = new Map<string, Promise<unknown>>();
-	private developmentInvalidationVersion = 0;
-
-	constructor(dependencies?: Partial<PageModuleImportDependencies>) {
-		this.dependencies = {
-			hashFile: dependencies?.hashFile ?? ((filePath) => fileSystem.hash(filePath)),
-			buildModule: dependencies?.buildModule ?? ((options, buildExecutor) => build(options, buildExecutor)),
-		};
-	}
-
-	/**
-	 * Clears the shared import cache used by framework-owned page-module loads.
-	 */
-	clearImportCache(): void {
-		this.importCache.clear();
-	}
-
-	/**
-	 * Invalidates all previously imported modules in development by clearing the
-	 * import cache and incrementing the invalidation version included in cache keys.
-	 *
-	 * This forces all modules to be reloaded on the next import, even if their
-	 * source content hasn't changed. This is necessary to ensure that changes to
-	 * non-content aspects of modules (e.g. dependencies, transpilation output)
-	 * are picked up during development.
-	 */
-	invalidateDevelopmentGraph(): void {
-		this.clearImportCache();
-		this.developmentInvalidationVersion += 1;
-	}
-
-	/**
-	 * Imports a page-like module from source.
-	 *
-	 * The caller controls the output directory and error wording so different
-	 * subsystems can reuse the same loading mechanism while preserving their
-	 * current diagnostics. Module identities stay stable for unchanged files and
-	 * roll forward automatically when the source hash changes during watch mode.
-	 *
-	 * @typeParam T Expected module shape.
-	 * @param options Runtime-specific import settings.
-	 * @returns The loaded module.
-	 */
-	async importModule<T = unknown>(options: PageModuleImportOptions): Promise<T> {
-		const { filePath, rootDir, externalPackages, splitting } = options;
-		const invalidationVersion = options.invalidationVersion ?? this.developmentInvalidationVersion;
-
-		const fileHash = this.dependencies.hashFile(filePath);
-		const runtime = typeof Bun !== 'undefined' ? 'bun' : 'node';
-		const cacheKey = [
-			runtime,
-			filePath,
-			rootDir,
-			splitting ?? 'default',
-			externalPackages ?? 'default',
-			fileHash,
-			invalidationVersion,
-		].join('::');
-		const cachedModule = this.importCache.get(cacheKey);
-
-		if (cachedModule) {
-			return (await cachedModule) as T;
-		}
-
-		const importPromise = this.loadModule<T>({
-			...options,
-			fileHash,
-		});
-
-		this.importCache.set(cacheKey, importPromise);
-
-		try {
-			return await importPromise;
-		} catch (error) {
-			this.importCache.delete(cacheKey);
-			throw error;
-		}
-	}
-
-	private async loadModule<T = unknown>(
-		options: PageModuleImportOptions & {
-			fileHash: string;
-		},
-	): Promise<T> {
-		/**
-		 * Runtime-specific module loading stays centralized here so callers can share
-		 * one cache-key and invalidation model while still diverging between Bun's
-		 * direct source imports and Node's transpile-then-import path.
-		 */
-		const {
-			filePath,
-			rootDir,
-			outdir,
-			invalidationVersion = this.developmentInvalidationVersion,
-			splitting,
-			externalPackages,
-			transpileErrorMessage = (details) => `Error transpiling page module: ${details}`,
-			noOutputMessage = (targetFilePath) => `No transpiled output generated for page module: ${targetFilePath}`,
-			fileHash,
-		} = options;
-
-		if (typeof Bun !== 'undefined') {
-			const moduleUrl = pathToFileURL(filePath);
-
-			if (process.env.NODE_ENV === 'development') {
-				moduleUrl.searchParams.set('update', `${fileHash}-${invalidationVersion}`);
-			}
-
-			return (await import(moduleUrl.href)) as T;
-		}
-
-		const fileBaseName = path.basename(filePath, path.extname(filePath));
-		const outputFileName = `${fileBaseName}-${fileHash}.js`;
-
-		const buildResult = await this.dependencies.buildModule(
-			{
-				entrypoints: [filePath],
-				root: rootDir,
-				outdir,
-				target: 'node',
-				format: 'esm',
-				sourcemap: 'none',
-				splitting: splitting ?? true,
-				minify: false,
-				naming: outputFileName,
-				externalPackages: true,
-				plugins: options.plugins,
-				...(externalPackages !== undefined ? { externalPackages } : {}),
-			},
-			options.buildExecutor,
-		);
-
-		if (!buildResult.success) {
-			const details = buildResult.logs.map((log) => log.message).join(' | ');
-			throw new Error(transpileErrorMessage(details));
-		}
-
-		const preferredOutputPath = path.join(outdir, outputFileName);
-		const compiledOutput =
-			buildResult.outputs.find((output) => output.path === preferredOutputPath)?.path ??
-			buildResult.outputs.find((output) => output.path.endsWith('.js'))?.path;
-
-		if (!compiledOutput) {
-			throw new Error(noOutputMessage(filePath));
-		}
-
-		const compiledOutputUrl = pathToFileURL(compiledOutput);
-
-		if (process.env.NODE_ENV === 'development') {
-			compiledOutputUrl.searchParams.set('update', `${fileHash}-${invalidationVersion}`);
-		}
-
-		return (await import(compiledOutputUrl.href)) as T;
-	}
-}

package/src/services/module-loading/server-loader.service.d.ts

@@ -1,96 +0,0 @@
-import type { EcoBuildPlugin } from '../../build/build-types.js';
-import { type ServerModuleTranspilerBootstrapArgs, type ServerModuleTranspilerOptions } from './server-module-transpiler.service.js';
-/**
- * High-level module-loading options owned by the framework loader boundary.
- *
- * @remarks
- * These are the same shape the lower-level transpiler needs, minus the
- * root/build-executor ownership that the loader keeps internally.
- */
-export interface ServerLoaderModuleOptions extends ServerModuleTranspilerOptions {
-    plugins?: EcoBuildPlugin[];
-}
-/**
- * Mutable app-phase server-loading context.
- *
- * @remarks
- * The loader starts with bootstrap config-loading context. Once a real built
- * app config is available, the runtime adapter rebinds the loader so app-entry
- * and downstream server modules load through the app-owned executor.
- */
-export interface ServerLoaderAppContext extends ServerModuleTranspilerBootstrapArgs {
-}
-/**
- * Minimal transpiler dependency required by the server loader.
- *
- * @remarks
- * The loader owns orchestration between bootstrap and app phases, so tests only
- * need this narrow import/invalidate/dispose surface rather than the concrete
- * transpiler class.
- */
-export interface ServerLoaderTranspilerDependency {
-    importModule<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-    invalidate(changedFiles?: string[]): void;
-    dispose(): Promise<void>;
-}
-/**
- * Factory dependency used by the loader to create phase-specific transpilers.
- */
-export interface ServerLoaderDependencyFactory {
-    createTranspiler(context: ServerModuleTranspilerBootstrapArgs): ServerLoaderTranspilerDependency;
-}
-/**
- * Framework-owned server loading boundary.
- *
- * @remarks
- * This abstraction owns config loading, app-entry loading, and cache lifecycle
- * for the Node thin-host runtime path. Hosts and runtime adapters should depend
- * on this boundary rather than coordinating raw transpiler instances directly.
- */
-export interface ServerLoader {
-    /**
-     * Loads the bootstrap config module through the bootstrap server-loading
-     * context.
-     */
-    loadConfig<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-    /**
-     * Loads the app entry module through the currently active app context.
-     *
-     * @remarks
-     * Until app context is rebound, this falls back to the bootstrap context so a
-     * caller can still load through one boundary during early bootstrap.
-     */
-    loadApp<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-    /**
-     * Rebinds the app-phase loading context after a real app config has been
-     * loaded and app-owned build services are available.
-     */
-    rebindAppContext(context: ServerLoaderAppContext): void;
-    /**
-     * Invalidates cached server module state for development reloads.
-     */
-    invalidate(changedFiles?: string[]): void;
-    /**
-     * Releases loader-owned resources.
-     */
-    dispose(): Promise<void>;
-}
-/**
- * `ServerLoader` implementation backed by `ServerModuleTranspiler` instances.
- *
- * @remarks
- * This is the first named loader abstraction for Workstream 3. It keeps the
- * lower-level transpiler as the implementation detail while moving ownership of
- * config/app entry orchestration into one service boundary.
- */
-export declare class TranspilerServerLoader implements ServerLoader {
-    private readonly createTranspiler;
-    private readonly configTranspiler;
-    private appTranspiler;
-    constructor(configContext: ServerModuleTranspilerBootstrapArgs, dependencies?: ServerLoaderDependencyFactory);
-    loadConfig<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-    loadApp<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-    rebindAppContext(context: ServerLoaderAppContext): void;
-    invalidate(changedFiles?: string[]): void;
-    dispose(): Promise<void>;
-}

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

@@ -1,32 +0,0 @@
-import {
-  ServerModuleTranspiler
-} from "./server-module-transpiler.service.js";
-class TranspilerServerLoader {
-  createTranspiler;
-  configTranspiler;
-  appTranspiler = null;
-  constructor(configContext, dependencies) {
-    this.createTranspiler = dependencies?.createTranspiler ?? ((context) => new ServerModuleTranspiler(context));
-    this.configTranspiler = this.createTranspiler(configContext);
-  }
-  async loadConfig(options) {
-    return await this.configTranspiler.importModule(options);
-  }
-  async loadApp(options) {
-    return await (this.appTranspiler ?? this.configTranspiler).importModule(options);
-  }
-  rebindAppContext(context) {
-    this.appTranspiler = this.createTranspiler(context);
-  }
-  invalidate(changedFiles) {
-    this.configTranspiler.invalidate(changedFiles);
-    this.appTranspiler?.invalidate(changedFiles);
-  }
-  async dispose() {
-    await this.appTranspiler?.dispose();
-    await this.configTranspiler.dispose();
-  }
-}
-export {
-  TranspilerServerLoader
-};

package/src/services/module-loading/server-loader.service.ts

@@ -1,130 +0,0 @@
-import type { EcoBuildPlugin } from '../../build/build-types.js';
-import {
-	ServerModuleTranspiler,
-	type ServerModuleTranspilerBootstrapArgs,
-	type ServerModuleTranspilerOptions,
-} from './server-module-transpiler.service.ts';
-
-/**
- * High-level module-loading options owned by the framework loader boundary.
- *
- * @remarks
- * These are the same shape the lower-level transpiler needs, minus the
- * root/build-executor ownership that the loader keeps internally.
- */
-export interface ServerLoaderModuleOptions extends ServerModuleTranspilerOptions {
-	plugins?: EcoBuildPlugin[];
-}
-
-/**
- * Mutable app-phase server-loading context.
- *
- * @remarks
- * The loader starts with bootstrap config-loading context. Once a real built
- * app config is available, the runtime adapter rebinds the loader so app-entry
- * and downstream server modules load through the app-owned executor.
- */
-export interface ServerLoaderAppContext extends ServerModuleTranspilerBootstrapArgs {}
-
-/**
- * Minimal transpiler dependency required by the server loader.
- *
- * @remarks
- * The loader owns orchestration between bootstrap and app phases, so tests only
- * need this narrow import/invalidate/dispose surface rather than the concrete
- * transpiler class.
- */
-export interface ServerLoaderTranspilerDependency {
-	importModule<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-	invalidate(changedFiles?: string[]): void;
-	dispose(): Promise<void>;
-}
-
-/**
- * Factory dependency used by the loader to create phase-specific transpilers.
- */
-export interface ServerLoaderDependencyFactory {
-	createTranspiler(context: ServerModuleTranspilerBootstrapArgs): ServerLoaderTranspilerDependency;
-}
-
-/**
- * Framework-owned server loading boundary.
- *
- * @remarks
- * This abstraction owns config loading, app-entry loading, and cache lifecycle
- * for the Node thin-host runtime path. Hosts and runtime adapters should depend
- * on this boundary rather than coordinating raw transpiler instances directly.
- */
-export interface ServerLoader {
-	/**
-	 * Loads the bootstrap config module through the bootstrap server-loading
-	 * context.
-	 */
-	loadConfig<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-
-	/**
-	 * Loads the app entry module through the currently active app context.
-	 *
-	 * @remarks
-	 * Until app context is rebound, this falls back to the bootstrap context so a
-	 * caller can still load through one boundary during early bootstrap.
-	 */
-	loadApp<T = unknown>(options: ServerLoaderModuleOptions): Promise<T>;
-
-	/**
-	 * Rebinds the app-phase loading context after a real app config has been
-	 * loaded and app-owned build services are available.
-	 */
-	rebindAppContext(context: ServerLoaderAppContext): void;
-
-	/**
-	 * Invalidates cached server module state for development reloads.
-	 */
-	invalidate(changedFiles?: string[]): void;
-
-	/**
-	 * Releases loader-owned resources.
-	 */
-	dispose(): Promise<void>;
-}
-
-/**
- * `ServerLoader` implementation backed by `ServerModuleTranspiler` instances.
- *
- * @remarks
- * This is the first named loader abstraction for Workstream 3. It keeps the
- * lower-level transpiler as the implementation detail while moving ownership of
- * config/app entry orchestration into one service boundary.
- */
-export class TranspilerServerLoader implements ServerLoader {
-	private readonly createTranspiler: ServerLoaderDependencyFactory['createTranspiler'];
-	private readonly configTranspiler: ServerLoaderTranspilerDependency;
-	private appTranspiler: ServerLoaderTranspilerDependency | null = null;
-
-	constructor(configContext: ServerModuleTranspilerBootstrapArgs, dependencies?: ServerLoaderDependencyFactory) {
-		this.createTranspiler = dependencies?.createTranspiler ?? ((context) => new ServerModuleTranspiler(context));
-		this.configTranspiler = this.createTranspiler(configContext);
-	}
-
-	async loadConfig<T = unknown>(options: ServerLoaderModuleOptions): Promise<T> {
-		return await this.configTranspiler.importModule<T>(options);
-	}
-
-	async loadApp<T = unknown>(options: ServerLoaderModuleOptions): Promise<T> {
-		return await (this.appTranspiler ?? this.configTranspiler).importModule<T>(options);
-	}
-
-	rebindAppContext(context: ServerLoaderAppContext): void {
-		this.appTranspiler = this.createTranspiler(context);
-	}
-
-	invalidate(changedFiles?: string[]): void {
-		this.configTranspiler.invalidate(changedFiles);
-		this.appTranspiler?.invalidate(changedFiles);
-	}
-
-	async dispose(): Promise<void> {
-		await this.appTranspiler?.dispose();
-		await this.configTranspiler.dispose();
-	}
-}

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

@@ -1,105 +0,0 @@
-import type { BuildExecutor } from '../../build/build-adapter.js';
-import type { EcoBuildPlugin } from '../../build/build-types.ts';
-import { PageModuleImportService, type PageModuleImportOptions } from './page-module-import.service.ts';
-
-export type ServerModuleTranspilerOptions = Omit<PageModuleImportOptions, 'rootDir' | 'buildExecutor'>;
-
-/**
- * Minimal import-service dependency required by the server module transpiler.
- *
- * @remarks
- * This keeps the transpiler boundary testable without module-level mocking and
- * lets callers provide an app-owned import implementation when needed.
- */
-export interface ServerModuleImportDependency {
-	importModule<T = unknown>(options: PageModuleImportOptions): Promise<T>;
-	invalidateDevelopmentGraph(): void;
-}
-
-/**
- * Immutable execution context for one server-transpiler instance.
- *
- * @remarks
- * Callers own when and why a new transpiler is created. This service only owns
- * applying the supplied root/build-executor pair consistently to every module
- * load that passes through it.
- */
-export type ServerModuleTranspilerBootstrapArgs = {
-	rootDir: string;
-	getBuildExecutor: () => BuildExecutor | undefined;
-	getInvalidationVersion?: () => number;
-	invalidateModules?: (changedFiles?: string[]) => void;
-	pageModuleImportService?: ServerModuleImportDependency;
-	/** Factory evaluated on each importModule call to produce plugins applied to every load. */
-	getDefaultPlugins?: () => EcoBuildPlugin[];
-};
-
-/**
- * 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 {
-	private readonly pageModuleImportService: ServerModuleImportDependency;
-	private readonly getRootDir: () => string;
-	private readonly getBuildExecutor: () => BuildExecutor | undefined;
-	private readonly getInvalidationVersion: () => number | undefined;
-	private readonly invalidateModules: (changedFiles?: string[]) => void;
-	private readonly getDefaultPlugins: () => EcoBuildPlugin[];
-
-	/**
-	 * Creates one explicit server-transpiler boundary for a given execution
-	 * context.
-	 */
-	constructor(args: ServerModuleTranspilerBootstrapArgs) {
-		this.pageModuleImportService = args.pageModuleImportService ?? new PageModuleImportService();
-		this.getRootDir = () => args.rootDir;
-		this.getBuildExecutor = args.getBuildExecutor;
-		this.getInvalidationVersion = () => args.getInvalidationVersion?.();
-		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<T = unknown>(options: ServerModuleTranspilerOptions): Promise<T> {
-		const mergedPlugins = [...this.getDefaultPlugins(), ...(options.plugins ?? [])];
-		const { plugins: _plugins, ...baseOptions } = options;
-		return await this.pageModuleImportService.importModule<T>({
-			...baseOptions,
-			...(mergedPlugins.length > 0 ? { plugins: mergedPlugins } : {}),
-			rootDir: this.getRootDir(),
-			buildExecutor: this.getBuildExecutor(),
-			invalidationVersion: this.getInvalidationVersion(),
-		});
-	}
-
-	/**
-	 * Invalidates cached module state for development reloads.
-	 */
-	invalidate(changedFiles?: string[]): void {
-		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(): Promise<void> {
-		return;
-	}
-}

package/src/services/runtime-manifest/node-runtime-manifest.service.d.ts

@@ -1,35 +0,0 @@
-import type { EcoPagesAppConfig } from '../../internal-types.js';
-export interface NodeRuntimeManifest {
-    runtime: 'node';
-    appRootDir: string;
-    sourceRootDir: string;
-    distDir: string;
-    workDir?: string;
-    modulePaths: {
-        config: string;
-        entry?: string;
-    };
-}
-/**
- * Returns the default file handoff location for the Node runtime manifest.
- */
-export declare function getNodeRuntimeManifestPath(appConfig: EcoPagesAppConfig): string;
-export declare function createNodeRuntimeManifest(appConfig: EcoPagesAppConfig, options?: {
-    entryModulePath?: string;
-}): NodeRuntimeManifest;
-/**
- * Serializes a Node runtime manifest to the file boundary used by the thin host.
- */
-export declare function writeNodeRuntimeManifestFile(manifest: NodeRuntimeManifest, manifestFilePath: string): string;
-/**
- * Derives the app-owned Node manifest and writes it to the runtime handoff path.
- */
-export declare function writeAppNodeRuntimeManifest(appConfig: EcoPagesAppConfig, options?: {
-    entryModulePath?: string;
-    manifestFilePath?: string;
-}): {
-    manifest: NodeRuntimeManifest;
-    manifestFilePath: string;
-};
-export declare function getAppNodeRuntimeManifest(appConfig: EcoPagesAppConfig): NodeRuntimeManifest;
-export declare function setAppNodeRuntimeManifest(appConfig: EcoPagesAppConfig, nodeRuntimeManifest: NodeRuntimeManifest): void;

package/src/services/runtime-manifest/node-runtime-manifest.service.js

@@ -1,60 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { DEFAULT_ECOPAGES_WORK_DIR } from "../../constants.js";
-const NODE_RUNTIME_MANIFEST_DIRNAME = "runtime";
-const NODE_RUNTIME_MANIFEST_FILENAME = "node-runtime-manifest.json";
-function getNodeRuntimeManifestPath(appConfig) {
-  return path.join(resolveWorkDir(appConfig), NODE_RUNTIME_MANIFEST_DIRNAME, NODE_RUNTIME_MANIFEST_FILENAME);
-}
-function resolveWorkDir(appConfig) {
-  return appConfig.absolutePaths?.workDir ?? path.join(appConfig.rootDir, appConfig.workDir ?? DEFAULT_ECOPAGES_WORK_DIR);
-}
-function createNodeRuntimeManifest(appConfig, options) {
-  return {
-    runtime: "node",
-    appRootDir: appConfig.rootDir,
-    sourceRootDir: appConfig.absolutePaths.srcDir,
-    distDir: appConfig.absolutePaths.distDir,
-    workDir: resolveWorkDir(appConfig),
-    modulePaths: {
-      config: appConfig.absolutePaths.config,
-      ...options?.entryModulePath ? { entry: options.entryModulePath } : {}
-    }
-  };
-}
-function writeNodeRuntimeManifestFile(manifest, manifestFilePath) {
-  mkdirSync(path.dirname(manifestFilePath), { recursive: true });
-  writeFileSync(manifestFilePath, `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-  return manifestFilePath;
-}
-function writeAppNodeRuntimeManifest(appConfig, options) {
-  const manifest = createNodeRuntimeManifest(appConfig, {
-    entryModulePath: options?.entryModulePath
-  });
-  const manifestFilePath = writeNodeRuntimeManifestFile(
-    manifest,
-    options?.manifestFilePath ?? getNodeRuntimeManifestPath(appConfig)
-  );
-  return {
-    manifest,
-    manifestFilePath
-  };
-}
-function getAppNodeRuntimeManifest(appConfig) {
-  return appConfig.runtime?.nodeRuntimeManifest ?? createNodeRuntimeManifest(appConfig);
-}
-function setAppNodeRuntimeManifest(appConfig, nodeRuntimeManifest) {
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    nodeRuntimeManifest
-  };
-}
-export {
-  createNodeRuntimeManifest,
-  getAppNodeRuntimeManifest,
-  getNodeRuntimeManifestPath,
-  setAppNodeRuntimeManifest,
-  writeAppNodeRuntimeManifest,
-  writeNodeRuntimeManifestFile
-};