@vibesdotdev/runtime-environment-bun 0.0.0

package/dist/services/workspace-resolve.js

@@ -0,0 +1,107 @@
+/**
+ * Unified Workspace Root Resolution
+ *
+ * Single source of truth for resolving the workspace root path.
+ * This consolidates the various fallback patterns used across the codebase.
+ *
+ * Priority order (highest to lowest):
+ * 1. Explicit override (e.g., MCP request header)
+ * 2. Runtime context workspacePath
+ * 3. Environment config workspacePath
+ * 4. CLI invocation cwd
+ * 5. process.cwd() fallback
+ *
+ * NOTE: This module lives in @vibesdotdev/runtime (not workspace) to avoid
+ * a circular dependency between runtime and workspace. The workspace package
+ * re-exports from here for backward compatibility.
+ */
+function normalizeCandidate(path) {
+    if (typeof path !== 'string')
+        return undefined;
+    const trimmed = path.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function readStringField(value, key) {
+    if (!value)
+        return undefined;
+    const candidate = value[key];
+    return typeof candidate === 'string' ? candidate : undefined;
+}
+const RESOLUTION_ORDER = [
+    'override',
+    'runtimeContext',
+    'environment',
+    'cliCwd',
+    'cwd'
+];
+/**
+ * Resolve workspace root path from multiple sources with priority fallback.
+ *
+ * @param sources - Object containing potential workspace path sources
+ * @returns The resolved workspace path (never undefined)
+ *
+ * @example
+ * ```ts
+ * const workspace = resolveWorkspaceRoot({
+ *   override: request.workspacePath,
+ *   runtimeContext: context.workspacePath,
+ *   environment: context.environment?.workspacePath,
+ *   cliCwd: context.cli?.cwd
+ * });
+ * ```
+ */
+export function resolveWorkspaceRoot(sources = {}) {
+    const { path } = resolveWorkspaceRootWithSource(sources);
+    return path;
+}
+/**
+ * Resolve workspace root path with source information for debugging.
+ *
+ * @param sources - Object containing potential workspace path sources
+ * @returns Object with resolved path and source that provided it
+ */
+export function resolveWorkspaceRootWithSource(sources = {}) {
+    for (const source of RESOLUTION_ORDER) {
+        const path = normalizeCandidate(sources[source]);
+        if (path) {
+            return { path, source };
+        }
+    }
+    const fallback = sources.cwd || process.cwd();
+    return { path: fallback, source: 'processCwd' };
+}
+// Context Extraction Helpers
+/**
+ * Extract workspace sources from a RuntimeContext-like object.
+ * Handles the various shapes of context objects in the codebase.
+ *
+ * @param context - Runtime context object with optional workspace-related fields
+ * @param override - Optional explicit override (e.g., from MCP request)
+ * @returns WorkspaceSources for use with resolveWorkspaceRoot
+ */
+export function extractWorkspaceSources(context, override) {
+    return {
+        override: normalizeCandidate(override),
+        runtimeContext: normalizeCandidate(context.workspacePath),
+        environment: normalizeCandidate(readStringField(context.environment, 'workspacePath')),
+        cliCwd: normalizeCandidate(readStringField(context.cli, 'cwd'))
+    };
+}
+/**
+ * Convenience function: Extract sources and resolve in one step.
+ *
+ * @param context - Runtime context object
+ * @param override - Optional explicit override
+ * @returns Resolved workspace path
+ */
+export function resolveWorkspaceFromContext(context, override) {
+    return resolveWorkspaceRoot(extractWorkspaceSources(context, override));
+}
+/**
+ * Resolve the current workspace as an object with rootPath.
+ * Convenience wrapper for callers that expect `{ rootPath: string }`.
+ */
+export function resolveCurrentWorkspace() {
+    return { rootPath: resolveWorkspaceRoot() };
+}
+//# sourceMappingURL=workspace-resolve.js.map

package/dist/services/workspace-resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-resolve.js","sourceRoot":"","sources":["../../src/services/workspace-resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,SAAS,kBAAkB,CAAC,IAAwB;IACnD,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAC/C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5B,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;AACjD,CAAC;AAED,SAAS,eAAe,CACvB,KAAgC,EAChC,GAA4B;IAE5B,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,MAAM,SAAS,GAAI,KAA6D,CAAC,GAAG,CAAC,CAAC;IACtF,OAAO,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AAC9D,CAAC;AAqBD,MAAM,gBAAgB,GAAkC;IACvD,UAAU;IACV,gBAAgB;IAChB,aAAa;IACb,QAAQ;IACR,KAAK;CACL,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAA4B,EAAE;IAClE,MAAM,EAAE,IAAI,EAAE,GAAG,8BAA8B,CAAC,OAAO,CAAC,CAAC;IACzD,OAAO,IAAI,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,8BAA8B,CAC7C,UAA4B,EAAE;IAE9B,KAAK,MAAM,MAAM,IAAI,gBAAgB,EAAE,CAAC;QACvC,MAAM,IAAI,GAAG,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QACjD,IAAI,IAAI,EAAE,CAAC;YACV,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QACzB,CAAC;IACF,CAAC;IAED,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IAC9C,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC;AACjD,CAAC;AAED,6BAA6B;AAE7B;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CACtC,OAAmC,EACnC,QAAiB;IAEjB,OAAO;QACN,QAAQ,EAAE,kBAAkB,CAAC,QAAQ,CAAC;QACtC,cAAc,EAAE,kBAAkB,CAAC,OAAO,CAAC,aAAa,CAAC;QACzD,WAAW,EAAE,kBAAkB,CAAC,eAAe,CAAC,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;QACtF,MAAM,EAAE,kBAAkB,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KAC/D,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAC1C,OAAmC,EACnC,QAAiB;IAEjB,OAAO,oBAAoB,CAAC,uBAAuB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB;IACtC,OAAO,EAAE,QAAQ,EAAE,oBAAoB,EAAE,EAAE,CAAC;AAC7C,CAAC"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@vibesdotdev/runtime-environment-bun",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./loader": {
+      "types": "./dist/bun-loader.impl.d.ts",
+      "bun": "./src/bun-loader.impl.ts",
+      "import": "./dist/bun-loader.impl.js",
+      "default": "./dist/bun-loader.impl.js"
+    },
+    "./loaders/fallback-loader.impl.consumer": {
+      "types": "./dist/loaders/fallback-loader.impl.consumer.d.ts",
+      "bun": "./src/loaders/fallback-loader.impl.consumer.ts",
+      "import": "./dist/loaders/fallback-loader.impl.consumer.js",
+      "default": "./dist/loaders/fallback-loader.impl.consumer.js"
+    }
+  },
+  "dependencies": {
+    "@vibesdotdev/runtime": "0.0.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "bun --bun tsc -p tsconfig.json --noEmit"
+  },
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src",
+    "bin",
+    "README.md",
+    "SPEC.md",
+    "LICENSE",
+    "!src/**/__tests__/**",
+    "!src/**/__stubs__/**",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.spec.ts",
+    "!src/**/*.spec.tsx",
+    "!dist/**/__tests__/**",
+    "!dist/**/__stubs__/**",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.d.ts.map",
+    "!dist/**/*.spec.js",
+    "!dist/**/*.spec.js.map",
+    "!dist/**/*.spec.d.ts",
+    "!dist/**/*.spec.d.ts.map"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "vibes": {
+    "visibility": "public-framework"
+  }
+}

package/src/bun-environment.impl.ts

@@ -0,0 +1,179 @@
+/**
+ * Bun Runtime Environment Implementation
+ *
+ * Captures environment at construction and provides Bun-specific
+ * implementations for scope, env access, secrets, and module loading.
+ */
+
+import type {
+	RuntimeDiscoveryConfig,
+	RuntimeDiscoveryProvider,
+	RuntimeEnvironmentImplementation,
+	RuntimeLoaderImplementation
+} from '@vibesdotdev/runtime';
+import type { RuntimeScope, TenancyConfig } from '@vibesdotdev/runtime';
+import { BunLoader } from './bun-loader.impl';
+import { bunRuntimePath } from './services/runtime-path.impl';
+
+export interface BunEnvironmentOptions {
+	/** Surface override (default: detected from env) */
+	surface?: string;
+	/** Hardware override (default: detected from env) */
+	hardware?: string;
+	/** Purpose override (default: detected from env) */
+	purpose?: string;
+	/** Tenancy configuration */
+	tenancy?: TenancyConfig;
+	/** Dev mode flag */
+	dev?: boolean;
+	/** Whether daemon endpoints/process features should be enabled for this runtime */
+	daemon?: boolean;
+	/** Optional discovery defaults for this environment capability */
+	discoveryDefaults?: RuntimeDiscoveryConfig;
+	/** Optional discovery provider override for this environment capability */
+	discoveryProvider?: RuntimeDiscoveryProvider;
+}
+
+export class BunEnvironment implements RuntimeEnvironmentImplementation {
+	readonly id: string;
+	readonly description: string;
+	readonly capabilities: Record<string, boolean>;
+	readonly scope: RuntimeScope;
+	readonly loader: RuntimeLoaderImplementation;
+	readonly discovery: {
+		readonly defaults: RuntimeDiscoveryConfig;
+		readonly provider?: RuntimeDiscoveryProvider;
+	};
+
+	private _envSnapshot: Record<string, string> | undefined;
+
+	constructor(options: BunEnvironmentOptions = {}) {
+		this.id = 'bun';
+		this.description = 'Bun runtime environment';
+
+		// Capture env snapshot FIRST - required for any _detect* methods below
+		this._envSnapshot = this._captureEnv();
+
+		const daemon = this._detectDaemonCapability(options);
+		this.capabilities = {
+			esm: true,
+			typescript: true,
+			nativeLoader: true,
+			secrets: false,
+			daemon
+		};
+
+		// Build scope from captured env + options
+		this.scope = this._buildScope(options);
+
+		// Create Bun-specific loader
+		this.loader = new BunLoader();
+		this.discovery = {
+			defaults: options.discoveryDefaults ?? {
+				basePaths: [process.cwd()],
+				skipPlugins: false,
+				respectGitignore: true
+			},
+			...(options.discoveryProvider ? { provider: options.discoveryProvider } : {})
+		};
+	}
+
+	/**
+	 * Capture environment variables at construction time.
+	 * This is the ONLY place process.env is accessed.
+	 */
+	private _captureEnv(): Record<string, string> {
+		const captured: Record<string, string> = {};
+		if (typeof process !== 'undefined' && process.env) {
+			for (const [key, value] of Object.entries(process.env)) {
+				if (typeof value === 'string') {
+					captured[key] = value;
+				}
+			}
+		}
+		return captured;
+	}
+
+	/**
+	 * Return the env snapshot, healing it if a cross-module or partially
+	 * initialized BunEnvironment instance was attached to the runtime.
+	 * This makes `dev mcp serve` (and other heavy CLI commands) robust when
+	 * reusing the runtime created by createVibesCliApp.
+	 */
+	private _getSnapshot(): Record<string, string> {
+		if (!this._envSnapshot) {
+			this._envSnapshot = this._captureEnv();
+		}
+		return this._envSnapshot;
+	}
+
+	/**
+	 * Build runtime scope from captured environment.
+	 */
+	private _buildScope(options: BunEnvironmentOptions): RuntimeScope {
+		const surface = options.surface ?? this._detectSurface();
+		const hardware = options.hardware ?? this._detectHardware();
+		const purpose = options.purpose ?? this._detectPurpose();
+		const snap = this._getSnapshot();
+		const dev = options.dev ?? (snap.NODE_ENV !== 'production');
+		const daemon = this._detectDaemonCapability(options, surface, hardware);
+
+		return {
+			surface,
+			hardware,
+			purpose,
+			capabilities: {
+				daemon
+			},
+			qualifiers: {
+				dev,
+				...(options.tenancy?.teamId && { teamId: options.tenancy.teamId })
+			},
+			tenancy: options.tenancy
+		};
+	}
+
+	private _detectDaemonCapability(
+		options: BunEnvironmentOptions,
+		surface?: string,
+		hardware?: string
+	): boolean {
+		if (typeof options.daemon === 'boolean') return options.daemon;
+		const snap = this._getSnapshot();
+		if (snap.VIBES_RUNTIME_DAEMON === '1' || snap.VIBES_DAEMON === '1') {
+			return true;
+		}
+		const resolvedSurface = surface ?? options.surface ?? this._detectSurface();
+		const resolvedHardware = hardware ?? options.hardware ?? this._detectHardware();
+		return resolvedSurface === 'daemon' || resolvedHardware === 'consumer';
+	}
+
+	private _detectSurface(): string {
+		return this._getSnapshot().VIBES_SURFACE ?? 'ssr';
+	}
+
+	private _detectHardware(): string {
+		return this._getSnapshot().VIBES_HARDWARE ?? 'consumer';
+	}
+
+	private _detectPurpose(): string {
+		return this._getSnapshot().VIBES_PURPOSE ?? 'direct';
+	}
+
+	/**
+	 * Get environment variable from captured snapshot.
+	 * No direct process.env access.
+	 */
+	getEnv(key: string): string | undefined {
+		return this._getSnapshot()[key];
+	}
+
+	/**
+	 * Get secret value.
+	 * Bun doesn't have a secrets API, so this falls back to env.
+	 * Cloudflare environment will use CF Secrets Store.
+	 */
+	async getSecret(key: string): Promise<string | undefined> {
+		return this._getSnapshot()[key];
+	}
+}

package/src/bun-loader.impl.ts

@@ -0,0 +1,102 @@
+/**
+ * Bun Loader Implementation
+ *
+ * Uses Bun.import() for module loading with native ESM support.
+ */
+
+import type {
+	RuntimeLoaderImplementation,
+	RuntimeLoaderModuleMaps,
+	RuntimeLoaderOptions,
+	RuntimeLoaderKindDiscoveryOptions
+} from '@vibesdotdev/runtime';
+import type { RuntimeDescriptor } from '@vibesdotdev/runtime';
+import { Glob } from 'bun';
+import { join, basename } from 'path';
+
+export class BunLoader implements RuntimeLoaderImplementation {
+	async loadModules(options: RuntimeLoaderOptions): Promise<RuntimeLoaderModuleMaps> {
+		const { scope, discovery } = options;
+		const basePaths = discovery?.basePaths ?? [process.cwd()];
+		const patterns = discovery?.patterns ?? {
+			plugin: '**/*.plugin.ts',
+			descriptor: '**/*.descriptor*.ts',
+			implementation: '**/*.impl*.ts*'
+		};
+
+		const result: RuntimeLoaderModuleMaps = {
+			plugins: {},
+			descriptors: {},
+			implementations: {}
+		};
+
+		for (const basePath of basePaths) {
+			// Load plugins
+			const pluginGlob = new Glob(patterns.plugin ?? '**/*.plugin.ts');
+			const pluginFiles: string[] = [];
+			for await (const file of pluginGlob.scan({ cwd: basePath, absolute: true } as never)) {
+				if (file) pluginFiles.push(file);
+			}
+			for (const file of pluginFiles) {
+				const fullPath = join(basePath, file);
+				result.plugins[fullPath] = () => import(fullPath);
+			}
+
+			// Load descriptors
+			const descriptorGlob = new Glob(patterns.descriptor ?? '**/*.descriptor*.ts');
+			const descriptorFiles: string[] = [];
+			for await (const file of descriptorGlob.scan({ cwd: basePath, absolute: true } as never)) {
+				if (file) descriptorFiles.push(file);
+			}
+			for (const file of descriptorFiles) {
+				const fullPath = join(basePath, file);
+				result.descriptors[fullPath] = () => import(fullPath);
+			}
+
+			// Load implementations
+			const implGlob = new Glob(patterns.implementation ?? '**/*.impl*.ts*');
+			const implFiles: string[] = [];
+			for await (const file of implGlob.scan({ cwd: basePath, absolute: true } as never)) {
+				if (file) implFiles.push(file);
+			}
+			for (const file of implFiles) {
+				const fullPath = join(basePath, file);
+				result.implementations[fullPath] = () => import(fullPath);
+			}
+		}
+
+		return result;
+	}
+
+	async discoverKindDescriptors(
+		options: RuntimeLoaderKindDiscoveryOptions
+	): Promise<RuntimeDescriptor[]> {
+		const { scope, discovery, kindPatterns } = options;
+		const basePaths = discovery?.basePaths ?? [process.cwd()];
+		const descriptors: RuntimeDescriptor[] = [];
+
+		for (const kindPattern of kindPatterns) {
+			const glob = new Glob(kindPattern.pattern);
+			for (const basePath of basePaths) {
+				for await (const file of glob.scan({ cwd: basePath, absolute: true } as never)) {
+					const fullPath = join(basePath, file!);
+					try {
+						const module = await import(fullPath);
+						if (module.default) {
+							const descriptor = module.default as RuntimeDescriptor;
+							if (descriptor.kind === kindPattern.kindId) {
+								descriptors.push(descriptor);
+							}
+						}
+					} catch (error) {
+						if (discovery?.debug) {
+							console.warn(`Failed to load descriptor ${fullPath}:`, error);
+						}
+					}
+				}
+			}
+		}
+
+		return descriptors;
+	}
+}

package/src/discovery/discovery.assets.consumer.ts

@@ -0,0 +1,135 @@
+/**
+ * Plugin Asset Discovery
+ *
+ * Scans the filesystem for descriptor and implementation files,
+ * registers descriptors eagerly, and implementations as lazy loaders.
+ * Consumer/Bun-only helper for plugin-local asset discovery.
+ */
+
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import type { RuntimeRef } from '@vibesdotdev/runtime/factory/plugin';
+import { extractDescriptorStem, parseImplFilename } from '@vibesdotdev/runtime/discovery/scope-parser';
+
+type FsGlobModule = {
+	globSync?: (pattern: string, options: { cwd: string }) => string[];
+};
+
+type ProcessWithBuiltinModule = typeof process & {
+	getBuiltinModule?: (id: 'node:fs') => FsGlobModule | undefined;
+};
+
+export async function discoverAssets(
+	runtime: RuntimeRef,
+	baseUrl: string | undefined,
+	kindPatterns: Record<string, string | string[]>
+): Promise<{ descriptors: number; loaders: number }> {
+	// Filesystem asset discovery requires a real `file://` base URL. In workerd
+	// and other non-filesystem runtimes `import.meta.url` is undefined, so
+	// the caller can't give us a baseUrl. Short-circuit instead of throwing.
+	if (typeof baseUrl !== 'string' || baseUrl.length === 0) {
+		return { descriptors: 0, loaders: 0 };
+	}
+	if (baseUrl.includes('/$bunfs/') || baseUrl.includes('/$bun/')) {
+		return { descriptors: 0, loaders: 0 };
+	}
+
+	const baseDir = dirname(fileURLToPath(baseUrl));
+	let descriptors = 0;
+	let loaders = 0;
+
+	for (const [kind, rawPatterns] of Object.entries(kindPatterns)) {
+		const patterns = Array.isArray(rawPatterns) ? rawPatterns : [rawPatterns];
+		const files = scanPatterns(patterns, baseDir);
+
+		const descriptorFiles = files.filter((f) => f.includes('.descriptor.'));
+		const implFiles = files.filter((f) => f.includes('.impl.'));
+
+		for (const file of descriptorFiles) {
+			try {
+				const absPath = resolve(baseDir, file);
+				const mod = await import(absPath);
+				const desc = mod.default;
+				if (!desc || !desc.id) continue;
+
+				const descKind = desc.kind ?? kind;
+				runtime.registerDescriptor(descKind, desc);
+				descriptors++;
+
+				const stem = extractDescriptorStem(file)?.stem;
+				if (!stem) continue;
+				const matchingImpl = implFiles.find((candidate) => {
+					try {
+						return parseImplFilename(candidate).stem === stem;
+					} catch {
+						return false;
+					}
+				});
+				if (!matchingImpl) continue;
+
+				const implPath = resolve(baseDir, matchingImpl);
+				runtime.registerLoader(descKind, desc.id, async () => {
+					const exported = (await import(implPath)).default;
+					if (
+						exported &&
+						typeof exported === 'object' &&
+						'impl' in exported &&
+						'meta' in exported
+					) {
+						return exported;
+					}
+					return {
+						meta: {
+							id: desc.id,
+							kind: descKind,
+							priority: 0
+						},
+						impl: exported
+					};
+				});
+				loaders++;
+			} catch {
+				// Descriptor may have unresolvable imports in this environment — skip
+			}
+		}
+	}
+
+	return { descriptors, loaders };
+}
+
+function scanPatterns(patterns: string[], cwd: string): string[] {
+	const results: string[] = [];
+	for (const pattern of patterns) {
+		for (const expanded of expandScopedPattern(pattern)) {
+			results.push(...scanGlob(expanded, cwd));
+		}
+	}
+	return results;
+}
+
+function expandScopedPattern(pattern: string): string[] {
+	if (!pattern.includes('{descriptor,impl}')) return [pattern];
+	return [
+		pattern.replace('{descriptor,impl}', 'descriptor*'),
+		pattern.replace('{descriptor,impl}', 'impl*')
+	];
+}
+
+function scanGlob(pattern: string, cwd: string): string[] {
+	if (typeof globalThis !== 'undefined' && 'Bun' in globalThis) {
+		const BunGlob = (globalThis as Record<string, unknown>).Bun as {
+			Glob: new (p: string) => {
+				scanSync: (o: { cwd: string; onlyFiles: boolean }) => Iterable<string>;
+			};
+		};
+		return [...new BunGlob.Glob(pattern).scanSync({ cwd, onlyFiles: true })];
+	}
+
+	const builtinProcess = process as ProcessWithBuiltinModule;
+	const fsModule = builtinProcess.getBuiltinModule?.('node:fs');
+	if (typeof fsModule?.globSync === 'function') {
+		return fsModule.globSync(pattern, { cwd });
+	}
+
+	return [];
+}

package/src/host/host.consumer.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal RuntimeHost interface (duplicated here to avoid export map changes in runtime core).
+ * Matches the contract in packages/runtime/src/env/host.contracts.ts.
+ */
+interface RuntimeHost {
+	kind: 'browser' | 'node' | 'cloud';
+	cwd(): string | null;
+	readTextFile(path: string): Promise<string>;
+}
+
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+export const host: RuntimeHost = {
+	kind: 'node',
+	cwd(): string {
+		return process.cwd();
+	},
+	async readTextFile(path: string): Promise<string> {
+		const absolute = resolve(process.cwd(), path);
+		return await readFile(absolute, 'utf8');
+	}
+};