@zhin.js/runtime 1.0.0

package/lib/invalidation-planner.js

@@ -0,0 +1,106 @@
+import { basename, resolve } from 'node:path';
+import { rootPluginId } from '@zhin.js/plugin-runtime';
+const processFiles = new Set([
+    'pnpm-lock.yaml',
+    'pnpm-workspace.yaml',
+    'package-lock.json',
+    'yarn.lock',
+]);
+export class InvalidationPlanner {
+    ownership;
+    dependencies;
+    constructor(ownership, dependencies) {
+        this.ownership = ownership;
+        this.dependencies = dependencies;
+    }
+    plan(sources) {
+        const changed = unique(sources.map((source) => resolve(source)));
+        if (changed.some((source) => processFiles.has(basename(source)))) {
+            return Object.freeze({
+                kind: 'process',
+                changed,
+                reasons: Object.freeze(['workspace dependency state changed']),
+            });
+        }
+        const slots = new Map();
+        const subtrees = new Set();
+        const reasons = new Set();
+        const processReasons = new Set();
+        for (const source of changed) {
+            const affected = unique([source, ...(this.dependencies?.affectedSources(source) ?? [])].map((item) => resolve(item)));
+            let matched = false;
+            for (const item of affected) {
+                const records = this.ownership.recordsFor(item);
+                if (records.length > 0)
+                    matched = true;
+                for (const record of records) {
+                    if (requiresProcessRestart(record)) {
+                        processReasons.add(`Root ${record.role} source changed`);
+                    }
+                    else {
+                        applyRecord(record, slots, subtrees, reasons);
+                    }
+                }
+            }
+            // An untracked support module still belongs to the nearest mounted
+            // package. Without an owned importer, subtree replacement is safest.
+            if (!matched) {
+                for (const owner of this.ownership.ownersForPath(source)) {
+                    subtrees.add(owner);
+                    reasons.add(`untracked support source changed in ${owner}`);
+                }
+            }
+        }
+        if (processReasons.size > 0) {
+            return Object.freeze({
+                kind: 'process',
+                changed,
+                reasons: Object.freeze([...processReasons]),
+            });
+        }
+        const roots = collapseSubtrees(subtrees);
+        const retainedSlots = [...slots].flatMap(([capability, owner]) => roots.some((root) => isWithin(owner, root)) ? [] : [capability]);
+        if (roots.length === 0 && retainedSlots.length === 0) {
+            return Object.freeze({
+                kind: 'none',
+                changed,
+                reasons: Object.freeze([...reasons]),
+            });
+        }
+        return Object.freeze({
+            kind: 'generation',
+            changed,
+            slots: Object.freeze(retainedSlots),
+            subtrees: Object.freeze(roots),
+            reasons: Object.freeze([...reasons]),
+        });
+    }
+}
+function requiresProcessRestart(record) {
+    return (record.owner === rootPluginId()
+        && (record.role === 'plugin' || record.role === 'schema'));
+}
+function applyRecord(record, slots, subtrees, reasons) {
+    if (record.role === 'capability' && record.capability) {
+        slots.set(record.capability, record.owner);
+        reasons.add(`Capability source changed: ${record.capability}`);
+        return;
+    }
+    subtrees.add(record.owner);
+    reasons.add(`${record.role} source changed in ${record.owner}`);
+}
+function collapseSubtrees(values) {
+    const sorted = [...values].sort((left, right) => left.length - right.length);
+    const result = [];
+    for (const candidate of sorted) {
+        if (!result.some((root) => isWithin(candidate, root)))
+            result.push(candidate);
+    }
+    return result;
+}
+function isWithin(plugin, root) {
+    return plugin === root || plugin.startsWith(`${root}/`);
+}
+function unique(values) {
+    return Object.freeze([...new Set(values)]);
+}

package/lib/isolation.d.ts

@@ -0,0 +1,28 @@
+import type { Dispose, GenerationHandoffParticipant, PluginId, PluginMetadata, Token } from '@zhin.js/plugin-runtime';
+import type { RuntimeEnvironment } from './environment.js';
+export interface IsolatedPluginPrepareRequest {
+    readonly owner: PluginId;
+    readonly parent: PluginId;
+    readonly packageName: string;
+    readonly entry: string;
+    readonly config: unknown;
+    readonly environment: RuntimeEnvironment;
+}
+export interface IsolatedPluginDescriptor {
+    readonly name: string;
+    readonly metadata?: PluginMetadata;
+}
+export interface IsolatedResourceBinding<T = unknown> {
+    readonly token: Token<T>;
+    readonly value: T;
+}
+export interface PreparedIsolatedPlugin {
+    readonly descriptor: IsolatedPluginDescriptor;
+    readonly resources?: readonly IsolatedResourceBinding[];
+    readonly handoff?: GenerationHandoffParticipant;
+    readonly dispose: Dispose;
+}
+/** Adapter seam for child Plugin lifecycle that must not execute in the Host realm. */
+export interface IsolatedPluginRuntimePort {
+    prepare(request: IsolatedPluginPrepareRequest): Promise<PreparedIsolatedPlugin>;
+}

package/lib/isolation.js

@@ -0,0 +1 @@
+export {};

package/lib/manifest.d.ts

@@ -0,0 +1,45 @@
+export interface PackageReference {
+    readonly package: string;
+    readonly optional?: boolean;
+    readonly api?: string;
+}
+export interface ChildPluginReference extends PackageReference {
+    readonly instanceKey: string;
+}
+export interface ZhinPluginManifest {
+    readonly protocol: 1;
+    readonly type: 'plugin';
+    readonly entry: string;
+    readonly engine?: string;
+    readonly runtime?: 'trusted' | 'isolated';
+    readonly features: readonly PackageReference[];
+    readonly plugins: readonly ChildPluginReference[];
+}
+export interface ZhinFeatureManifest {
+    readonly protocol: 1;
+    readonly type: 'feature';
+    readonly entry: string;
+    readonly engine?: string;
+    readonly featureApi?: string;
+}
+export type ZhinPackageManifest = ZhinPluginManifest | ZhinFeatureManifest;
+export interface PackageJson {
+    readonly name: string;
+    readonly version?: string;
+    readonly type?: 'module' | 'commonjs';
+    readonly main?: string;
+    readonly exports?: unknown;
+    readonly imports?: unknown;
+    readonly private?: boolean;
+    readonly dependencies?: Readonly<Record<string, string>>;
+    readonly optionalDependencies?: Readonly<Record<string, string>>;
+    readonly peerDependencies?: Readonly<Record<string, string>>;
+    readonly devDependencies?: Readonly<Record<string, string>>;
+    readonly scripts?: Readonly<Record<string, string>>;
+    readonly zhin: ZhinPackageManifest;
+}
+export declare class ManifestValidationError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+export declare function parsePackageJson(value: unknown, source: string): PackageJson;

package/lib/manifest.js

@@ -0,0 +1,195 @@
+export class ManifestValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(`Invalid Zhin package manifest:\n${issues.map((issue) => `- ${issue}`).join('\n')}`);
+        this.issues = issues;
+        this.name = 'ManifestValidationError';
+    }
+}
+export function parsePackageJson(value, source) {
+    const issues = [];
+    const record = asRecord(value, source, issues);
+    const name = readString(record, 'name', source, issues);
+    if (name && !isPackageName(name))
+        issues.push(`${source}#name is not a valid package name`);
+    const zhin = parseZhinManifest(record.zhin, `${source}#zhin`, issues);
+    const version = optionalString(record.version, `${source}#version`, issues);
+    const moduleType = optionalModuleType(record.type, `${source}#type`, issues);
+    const main = optionalString(record.main, `${source}#main`, issues);
+    const packageExports = optionalPackageMap(record.exports, `${source}#exports`, issues);
+    const packageImports = optionalPackageMap(record.imports, `${source}#imports`, issues);
+    const isPrivate = optionalBoolean(record.private, `${source}#private`, issues);
+    const dependencies = stringRecord(record.dependencies, `${source}#dependencies`, issues);
+    const optionalDependencies = stringRecord(record.optionalDependencies, `${source}#optionalDependencies`, issues);
+    const peerDependencies = stringRecord(record.peerDependencies, `${source}#peerDependencies`, issues);
+    const devDependencies = stringRecord(record.devDependencies, `${source}#devDependencies`, issues);
+    const scripts = stringRecord(record.scripts, `${source}#scripts`, issues);
+    if (issues.length > 0 || !name || !zhin)
+        throw new ManifestValidationError(issues);
+    return Object.freeze({
+        name,
+        version,
+        type: moduleType,
+        main,
+        exports: packageExports,
+        imports: packageImports,
+        private: isPrivate,
+        dependencies,
+        optionalDependencies,
+        peerDependencies,
+        devDependencies,
+        scripts,
+        zhin,
+    });
+}
+function parseZhinManifest(value, source, issues) {
+    const record = asRecord(value, source, issues);
+    if (record.protocol !== 1)
+        issues.push(`${source}.protocol must be 1`);
+    const type = readString(record, 'type', source, issues);
+    const entry = readRelativeEntry(record.entry, `${source}.entry`, issues);
+    const engine = optionalString(record.engine, `${source}.engine`, issues);
+    if (!entry || (type !== 'plugin' && type !== 'feature')) {
+        if (type && type !== 'plugin' && type !== 'feature') {
+            issues.push(`${source}.type must be "plugin" or "feature"`);
+        }
+        return undefined;
+    }
+    if (type === 'feature') {
+        return Object.freeze({
+            protocol: 1,
+            type,
+            entry,
+            engine,
+            featureApi: optionalString(record.featureApi, `${source}.featureApi`, issues),
+        });
+    }
+    const runtime = record.runtime;
+    if (runtime !== undefined && runtime !== 'trusted' && runtime !== 'isolated') {
+        issues.push(`${source}.runtime must be "trusted" or "isolated"`);
+    }
+    return Object.freeze({
+        protocol: 1,
+        type,
+        entry,
+        engine,
+        runtime: runtime,
+        features: parseReferences(record.features, `${source}.features`, issues, false),
+        plugins: parseReferences(record.plugins, `${source}.plugins`, issues, true),
+    });
+}
+function parseReferences(value, source, issues, child) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        issues.push(`${source} must be an array`);
+        return [];
+    }
+    return value.flatMap((item, index) => {
+        const itemSource = `${source}[${index}]`;
+        const record = asRecord(item, itemSource, issues);
+        const packageName = readString(record, 'package', itemSource, issues);
+        const instanceKey = child
+            ? readString(record, 'instanceKey', itemSource, issues)
+            : undefined;
+        if (!packageName || (child && !instanceKey))
+            return [];
+        if (!isPackageName(packageName)) {
+            issues.push(`${itemSource}.package is not a valid package name`);
+            return [];
+        }
+        if (instanceKey && !/^[a-z0-9][a-z0-9-]*$/.test(instanceKey)) {
+            issues.push(`${itemSource}.instanceKey is invalid`);
+            return [];
+        }
+        return [{
+                package: packageName,
+                instanceKey: instanceKey ?? packageName,
+                optional: optionalBoolean(record.optional, `${itemSource}.optional`, issues),
+                api: optionalString(record.api, `${itemSource}.api`, issues),
+            }];
+    });
+}
+function readRelativeEntry(value, source, issues) {
+    if (typeof value !== 'string' || !value.startsWith('./')) {
+        issues.push(`${source} must be a package-relative path starting with ./`);
+        return undefined;
+    }
+    if (value.split('/').includes('..')) {
+        issues.push(`${source} must not escape the package root`);
+        return undefined;
+    }
+    return value;
+}
+function asRecord(value, source, issues) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        issues.push(`${source} must be an object`);
+        return {};
+    }
+    return value;
+}
+function readString(record, key, source, issues) {
+    const value = record[key];
+    if (typeof value !== 'string' || value.length === 0) {
+        issues.push(`${source}.${key} must be a non-empty string`);
+        return undefined;
+    }
+    return value;
+}
+function optionalString(value, source, issues) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string')
+        issues.push(`${source} must be a string`);
+    return typeof value === 'string' ? value : undefined;
+}
+function optionalBoolean(value, source, issues) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'boolean')
+        issues.push(`${source} must be a boolean`);
+    return typeof value === 'boolean' ? value : undefined;
+}
+function optionalModuleType(value, source, issues) {
+    if (value === undefined)
+        return undefined;
+    if (value !== 'module' && value !== 'commonjs') {
+        issues.push(`${source} must be "module" or "commonjs"`);
+        return undefined;
+    }
+    return value;
+}
+function optionalPackageMap(value, source, issues) {
+    if (value === undefined)
+        return undefined;
+    if (value === null || typeof value === 'string')
+        return value;
+    if (Array.isArray(value)) {
+        return Object.freeze(value.map((item, index) => optionalPackageMap(item, `${source}[${index}]`, issues)));
+    }
+    if (!value || typeof value !== 'object') {
+        issues.push(`${source} must be a string, null, array, or object`);
+        return undefined;
+    }
+    const entries = Object.entries(value).map(([key, item]) => [
+        key,
+        optionalPackageMap(item, `${source}.${key}`, issues),
+    ]);
+    return Object.freeze(Object.fromEntries(entries));
+}
+function stringRecord(value, source, issues) {
+    if (value === undefined)
+        return undefined;
+    const record = asRecord(value, source, issues);
+    const result = {};
+    for (const [key, item] of Object.entries(record)) {
+        if (typeof item !== 'string')
+            issues.push(`${source}.${key} must be a string`);
+        else
+            result[key] = item;
+    }
+    return Object.freeze(result);
+}
+function isPackageName(value) {
+    return /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(value);
+}

package/lib/module-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { Dispose } from '@zhin.js/plugin-runtime';
+import type { ClientModuleRequest } from '@zhin.js/feature-kit';
+export interface ModuleRuntime {
+    load<T = unknown>(source: string): Promise<T>;
+    /** Optional compiler/manifest adapter for browser modules such as Page and Layout. */
+    loadClientModule?<T = unknown>(source: string, request: ClientModuleRequest): Promise<T>;
+    invalidate?(source: string): Promise<void> | void;
+    affectedSources?(source: string): readonly string[];
+    /** True when this adapter cannot invalidate the complete importer closure safely. */
+    requiresProcessRestart?(source: string): boolean;
+    watch?(listener: (source: string) => void): Dispose;
+    close(): Promise<void>;
+}
+export declare class EsmModuleRuntime implements ModuleRuntime {
+    load<T>(source: string): Promise<T>;
+    close(): Promise<void>;
+}

package/lib/module-runtime.js

@@ -0,0 +1,7 @@
+import { pathToFileURL } from 'node:url';
+export class EsmModuleRuntime {
+    async load(source) {
+        return import(pathToFileURL(source).href);
+    }
+    async close() { }
+}

package/lib/native-development-runtime.d.ts

@@ -0,0 +1,22 @@
+import type { Dispose } from '@zhin.js/plugin-runtime';
+import type { ModuleRuntime } from './module-runtime.js';
+export interface NativeDevelopmentModuleRuntimeOptions {
+    readonly projectRoot: string;
+    readonly watch?: boolean;
+}
+/**
+ * Uses Node's native ESM/TypeScript loader and adds only cache busting and watch.
+ * It deliberately requests a process restart for support modules whose cached
+ * relative import closure cannot be invalidated without a custom loader.
+ */
+export declare class NativeDevelopmentModuleRuntime implements ModuleRuntime {
+    #private;
+    constructor(options: NativeDevelopmentModuleRuntimeOptions);
+    load<T = unknown>(source: string): Promise<T>;
+    invalidate(source: string): void;
+    requiresProcessRestart(source: string): boolean;
+    watch(listener: (source: string) => void): Dispose;
+    close(): Promise<void>;
+}
+export declare function supportsNativeTypeScript(version?: string, execArguments?: readonly string[], nodeOptions?: string): boolean;
+export declare function assertNativeTypeScriptSupport(): void;

package/lib/native-development-runtime.js

@@ -0,0 +1,190 @@
+import { readdirSync, statSync, watch as watchDirectory, } from 'node:fs';
+import { extname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const ignoredDirectories = new Set([
+    '.git', '.zhin', 'coverage', 'dist', 'lib', 'node_modules',
+]);
+const watchedExtensions = new Set([
+    '.cjs', '.js', '.json', '.md', '.mjs', '.ts', '.tsx', '.yaml', '.yml',
+]);
+const capabilityRoots = new Set([
+    'adapters', 'agents', 'commands', 'components', 'mcp', 'middlewares', 'pages', 'skills', 'tools',
+]);
+/**
+ * Uses Node's native ESM/TypeScript loader and adds only cache busting and watch.
+ * It deliberately requests a process restart for support modules whose cached
+ * relative import closure cannot be invalidated without a custom loader.
+ */
+export class NativeDevelopmentModuleRuntime {
+    #projectRoot;
+    #watchEnabled;
+    #revisions = new Map();
+    #watchers = new Set();
+    #closed = false;
+    constructor(options) {
+        this.#projectRoot = resolve(options.projectRoot);
+        this.#watchEnabled = options.watch ?? true;
+    }
+    async load(source) {
+        this.#assertOpen();
+        const normalized = resolve(source);
+        if (normalized.endsWith('.tsx')) {
+            throw new Error(`Node native TypeScript does not support TSX: ${normalized}`);
+        }
+        if (normalized.endsWith('.ts'))
+            assertNativeTypeScriptSupport();
+        const url = pathToFileURL(normalized);
+        url.searchParams.set('zhin-generation', String(this.#revisions.get(normalized) ?? 0));
+        return import(url.href);
+    }
+    invalidate(source) {
+        const normalized = resolve(source);
+        this.#revisions.set(normalized, (this.#revisions.get(normalized) ?? 0) + 1);
+    }
+    requiresProcessRestart(source) {
+        const normalized = resolve(source);
+        if (!isWithin(this.#projectRoot, normalized))
+            return true;
+        const parts = relative(this.#projectRoot, normalized).split(sep);
+        const capability = parts.findIndex((part) => capabilityRoots.has(part));
+        if (capability < 0)
+            return isExecutableSource(normalized);
+        const root = parts[capability];
+        if (root === 'pages')
+            return false;
+        if (root === 'skills' || root === 'agents')
+            return extname(normalized) !== '.md';
+        if (root === 'tools' || root === 'mcp')
+            return parts.length !== capability + 2;
+        return false;
+    }
+    watch(listener) {
+        this.#assertOpen();
+        if (!this.#watchEnabled)
+            return () => undefined;
+        const watcher = new PortableSourceWatcher(this.#projectRoot, listener);
+        this.#watchers.add(watcher);
+        return () => {
+            watcher.close();
+            this.#watchers.delete(watcher);
+        };
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const watcher of this.#watchers)
+            watcher.close();
+        this.#watchers.clear();
+    }
+    #assertOpen() {
+        if (this.#closed)
+            throw new Error('NativeDevelopmentModuleRuntime is closed');
+    }
+}
+export function supportsNativeTypeScript(version = process.versions.node, execArguments = process.execArgv, nodeOptions = process.env.NODE_OPTIONS ?? '') {
+    if (execArguments.includes('--experimental-strip-types')
+        || /(?:^|\s)--experimental-strip-types(?:\s|$)/u.test(nodeOptions))
+        return true;
+    const [major = 0, minor = 0] = version.split('.').map(Number);
+    return major > 23 || (major === 23 && minor >= 6) || (major === 22 && minor >= 18);
+}
+export function assertNativeTypeScriptSupport() {
+    if (supportsNativeTypeScript())
+        return;
+    throw new Error([
+        `Node ${process.versions.node} does not enable native TypeScript by default.`,
+        'Use Node >=22.18.0 or start Node with --experimental-strip-types.',
+    ].join(' '));
+}
+class PortableSourceWatcher {
+    root;
+    listener;
+    #watcher;
+    #pollTimer;
+    #snapshot;
+    #closed = false;
+    constructor(root, listener) {
+        this.root = root;
+        this.listener = listener;
+        this.#snapshot = sourceSnapshot(root);
+        this.#startNativeWatcher();
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#watcher?.close();
+        if (this.#pollTimer)
+            clearInterval(this.#pollTimer);
+    }
+    #startNativeWatcher() {
+        try {
+            this.#watcher = watchDirectory(this.root, { recursive: true }, (_event, name) => {
+                if (!name)
+                    return;
+                const source = resolve(this.root, name.toString());
+                if (isWatchedSource(source))
+                    this.listener(source);
+            });
+            this.#watcher.on('error', () => this.#startPolling());
+        }
+        catch {
+            this.#startPolling();
+        }
+    }
+    #startPolling() {
+        if (this.#closed || this.#pollTimer)
+            return;
+        this.#watcher?.close();
+        this.#watcher = undefined;
+        this.#pollTimer = setInterval(() => {
+            const next = sourceSnapshot(this.root);
+            const sources = new Set([...this.#snapshot.keys(), ...next.keys()]);
+            for (const source of sources) {
+                if (this.#snapshot.get(source) !== next.get(source))
+                    this.listener(source);
+            }
+            this.#snapshot = next;
+        }, 100);
+    }
+}
+function sourceSnapshot(root) {
+    const result = new Map();
+    const visit = (directory) => {
+        let entries;
+        try {
+            entries = readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory() && !ignoredDirectories.has(entry.name)) {
+                visit(resolve(directory, entry.name));
+            }
+            else if (entry.isFile()) {
+                const source = resolve(directory, entry.name);
+                if (!isWatchedSource(source))
+                    continue;
+                try {
+                    result.set(source, statSync(source).mtimeMs);
+                }
+                catch { /* The next poll reports a concurrent unlink. */ }
+            }
+        }
+    };
+    visit(root);
+    return result;
+}
+function isWatchedSource(source) {
+    const name = source.slice(source.lastIndexOf(sep) + 1);
+    return watchedExtensions.has(extname(source)) || name.startsWith('.env');
+}
+function isExecutableSource(source) {
+    return ['.cjs', '.js', '.mjs', '.ts', '.tsx'].includes(extname(source));
+}
+function isWithin(root, source) {
+    const child = relative(root, source);
+    return child === '' || (!child.startsWith('..') && !isAbsolute(child));
+}

package/lib/node-discovery-host.d.ts

@@ -0,0 +1,10 @@
+import type { ClientModuleRequest, DirectoryEntry, DiscoveryHost } from '@zhin.js/feature-kit';
+import type { ModuleRuntime } from './module-runtime.js';
+export declare class NodeDiscoveryHost implements DiscoveryHost {
+    private readonly modules;
+    constructor(modules: ModuleRuntime);
+    list(directory: string): Promise<readonly DirectoryEntry[]>;
+    loadModule<T = unknown>(source: string): Promise<T>;
+    loadClientModule<T = unknown>(source: string, request: ClientModuleRequest): Promise<T>;
+    readText(source: string): Promise<string>;
+}

package/lib/node-discovery-host.js

@@ -0,0 +1,37 @@
+import { readFile, readdir } from 'node:fs/promises';
+export class NodeDiscoveryHost {
+    modules;
+    constructor(modules) {
+        this.modules = modules;
+    }
+    async list(directory) {
+        try {
+            const entries = await readdir(directory, { withFileTypes: true });
+            const result = [];
+            for (const entry of entries) {
+                if (entry.isFile())
+                    result.push({ name: entry.name, kind: 'file' });
+                if (entry.isDirectory())
+                    result.push({ name: entry.name, kind: 'directory' });
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    loadModule(source) {
+        return this.modules.load(source);
+    }
+    loadClientModule(source, request) {
+        if (!this.modules.loadClientModule) {
+            throw new Error(`Client Module adapter is required to load ${request.feature}:${request.localName}`);
+        }
+        return this.modules.loadClientModule(source, request);
+    }
+    readText(source) {
+        return readFile(source, 'utf8');
+    }
+}