@gobing-ai/ts-runtime 0.2.7 → 0.2.9

package/dist/schema-validation.js

@@ -0,0 +1,304 @@
+import { parse as parseYaml } from 'yaml';
+import { getFs } from './fs.js';
+import { dirnamePath, isAbsolutePath, joinPath } from './path.js';
+/** Default time budget for a single remote schema fetch. */
+const REMOTE_SCHEMA_FETCH_TIMEOUT_MS = 5_000;
+/** Upper bound on a remote schema body. A timeout alone lets a slow multi-GB drip exhaust memory. */
+const REMOTE_SCHEMA_MAX_BYTES = 5 * 1024 * 1024;
+export class StructuredConfigSchemaError extends Error {
+    violations;
+    constructor(message, violations = []) {
+        super(message);
+        this.violations = violations;
+        this.name = 'StructuredConfigSchemaError';
+    }
+}
+export async function loadStructuredConfig(path, options = {}) {
+    const content = await getFs().readFile(path);
+    return await parseStructuredConfig(content, path, options);
+}
+export async function parseStructuredConfig(content, source, options = {}) {
+    const parsed = source.endsWith('.json') ? JSON.parse(content) : parseYaml(content);
+    if (options.validateSchema !== false) {
+        await validateDeclaredJsonSchema(parsed, source, options);
+    }
+    return parsed;
+}
+export async function validateDeclaredJsonSchema(value, source, options = {}) {
+    if (!isObject(value))
+        return;
+    const schemaRef = value.$schema;
+    if (typeof schemaRef !== 'string' || schemaRef.length === 0)
+        return;
+    const schemaLocation = resolveSchemaRef(schemaRef, source, options.resolve);
+    const schemaText = await readSchema(schemaLocation, options);
+    let schema;
+    try {
+        schema = JSON.parse(schemaText);
+    }
+    catch (error) {
+        throw new StructuredConfigSchemaError(`Invalid JSON schema "${schemaLocation}" referenced by "${source}": ${errorMessage(error)}`);
+    }
+    if (!isObject(schema)) {
+        throw new StructuredConfigSchemaError(`JSON schema "${schemaLocation}" referenced by "${source}" must be an object`);
+    }
+    const violations = validateJsonSchema(value, schema, '', (schema.$defs ?? {}));
+    if (violations.length > 0) {
+        throw new StructuredConfigSchemaError(`Configuration "${source}" failed JSON schema validation against "${schemaLocation}": ${violations
+            .map((violation) => `${violation.path}: ${violation.message}`)
+            .join('; ')}`, violations);
+    }
+}
+export function validateJsonSchema(value, schema, path = '', defs = {}, seenRefs = new Set()) {
+    const violations = [];
+    // Applicator keywords compose with their siblings (logical AND), per JSON Schema 2020-12 —
+    // a node may carry `$ref`/`oneOf`/`anyOf` *and* `type`/`properties`/... and all apply.
+    if (schema.$ref !== undefined) {
+        // Cyclic `$ref` (A→B→A) would recurse until stack overflow — a DoS surface for untrusted
+        // schemas. Following a ref already on the current path is a no-op: that branch is being
+        // validated higher up the stack, so re-entering adds nothing but unbounded depth.
+        if (!seenRefs.has(schema.$ref)) {
+            const resolved = resolveRef(schema.$ref, defs, schema.$defs);
+            if (resolved !== undefined) {
+                const nextSeen = new Set(seenRefs).add(schema.$ref);
+                violations.push(...validateJsonSchema(value, resolved, path, defs, nextSeen));
+            }
+        }
+    }
+    if (schema.oneOf !== undefined) {
+        violations.push(...validateCombinator(value, schema.oneOf, path, defs, 'oneOf', seenRefs));
+    }
+    if (schema.anyOf !== undefined) {
+        violations.push(...validateCombinator(value, schema.anyOf, path, defs, 'anyOf', seenRefs));
+    }
+    if (schema.const !== undefined && !jsonEqual(value, schema.const)) {
+        violations.push({ path: path || '(root)', message: `expected constant ${JSON.stringify(schema.const)}` });
+    }
+    if (schema.enum !== undefined && !schema.enum.some((entry) => jsonEqual(value, entry))) {
+        violations.push({ path: path || '(root)', message: `expected one of ${schema.enum.map(String).join(', ')}` });
+    }
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (!types.some((type) => matchesType(value, type))) {
+            violations.push({
+                path: path || '(root)',
+                message: `expected ${types.join(' or ')}, got ${typeName(value)}`,
+            });
+            return violations;
+        }
+    }
+    const hasObjectKeywords = schema.properties !== undefined || schema.required !== undefined || schema.additionalProperties !== undefined;
+    if (schema.type === 'object' || (hasObjectKeywords && isObject(value))) {
+        violations.push(...validateObject(value, schema, path, defs, seenRefs));
+    }
+    if (schema.type === 'array' || (schema.items !== undefined && Array.isArray(value))) {
+        violations.push(...validateArray(value, schema, path, defs, seenRefs));
+    }
+    return violations;
+}
+function validateObject(value, schema, path, defs, seenRefs) {
+    if (!isObject(value))
+        return [{ path: path || '(root)', message: `expected object, got ${typeName(value)}` }];
+    const violations = [];
+    for (const key of schema.required ?? []) {
+        if (!(key in value)) {
+            violations.push({ path: path ? `${path}.${key}` : key, message: `missing required field "${key}"` });
+        }
+    }
+    const properties = schema.properties ?? {};
+    for (const [key, childSchema] of Object.entries(properties)) {
+        if (key in value) {
+            violations.push(...validateJsonSchema(value[key], childSchema, path ? `${path}.${key}` : key, defs, seenRefs));
+        }
+    }
+    if (schema.additionalProperties === false) {
+        const allowed = new Set(Object.keys(properties));
+        for (const key of Object.keys(value)) {
+            if (!allowed.has(key)) {
+                violations.push({ path: path ? `${path}.${key}` : key, message: `unknown field "${key}"` });
+            }
+        }
+    }
+    else if (isObject(schema.additionalProperties)) {
+        for (const [key, child] of Object.entries(value)) {
+            if (!(key in properties)) {
+                violations.push(...validateJsonSchema(child, schema.additionalProperties, path ? `${path}.${key}` : key, defs, seenRefs));
+            }
+        }
+    }
+    return violations;
+}
+function validateArray(value, schema, path, defs, seenRefs) {
+    if (!Array.isArray(value))
+        return [{ path: path || '(root)', message: `expected array, got ${typeName(value)}` }];
+    if (schema.items === undefined)
+        return [];
+    return value.flatMap((entry, index) => validateJsonSchema(entry, schema.items, `${path}[${index}]`, defs, seenRefs));
+}
+function validateCombinator(value, schemas, path, defs, mode, seenRefs) {
+    const branchViolations = schemas.map((schema) => validateJsonSchema(value, schema, path, defs, seenRefs));
+    const passing = branchViolations.filter((violations) => violations.length === 0).length;
+    if (mode === 'anyOf' && passing >= 1)
+        return [];
+    if (mode === 'oneOf' && passing === 1)
+        return [];
+    const at = path || '(root)';
+    // oneOf matching more than one branch is a failure, not a pass — report it explicitly.
+    if (mode === 'oneOf' && passing > 1) {
+        return [{ path: at, message: `expected to match exactly one oneOf branch, matched ${passing}` }];
+    }
+    // No branch matched: surface every branch's reason so the author sees all options, not just branch 0.
+    const detail = branchViolations
+        .map((branch, index) => `[${index}] ${branch.map((v) => `${v.path}: ${v.message}`).join(', ')}`)
+        .join(' | ');
+    return [
+        {
+            path: at,
+            message: `expected to match ${mode === 'oneOf' ? 'exactly one' : 'at least one'} branch — ${detail}`,
+        },
+    ];
+}
+function resolveRef(ref, defs, localDefs) {
+    if (!ref.startsWith('#/$defs/'))
+        return undefined;
+    const name = ref.slice('#/$defs/'.length);
+    return defs[name] ?? localDefs?.[name];
+}
+function resolveSchemaRef(schemaRef, source, resolve) {
+    if (isRemoteRef(schemaRef) || isAbsolutePath(schemaRef))
+        return schemaRef;
+    // Relative ref — resolve against the config file's directory.
+    if (schemaRef.startsWith('./') || schemaRef.startsWith('../')) {
+        return joinPath(isRemoteRef(source) ? '.' : dirnamePath(source), schemaRef);
+    }
+    // Bare package specifier (e.g. "@scope/pkg/schemas/x.json") — resolve through node_modules.
+    return resolvePackageSchema(schemaRef, source, resolve);
+}
+function resolvePackageSchema(specifier, source, resolve) {
+    const resolveFn = resolve ?? defaultResolve;
+    if (resolveFn === undefined) {
+        throw new StructuredConfigSchemaError(`Cannot resolve package schema "${specifier}" referenced by "${source}": no module resolver available`);
+    }
+    const { pkg, subpath } = splitPackageSpecifier(specifier);
+    if (subpath.length === 0) {
+        throw new StructuredConfigSchemaError(`Package schema ref "${specifier}" referenced by "${source}" must include a path within the package`);
+    }
+    const from = isRemoteRef(source) ? process.cwd() : dirnamePath(source);
+    try {
+        // Resolve the package root via its always-present package.json, then join the subpath.
+        // This sidesteps `exports` gating on arbitrary JSON subpaths.
+        const manifest = resolveFn(`${pkg}/package.json`, from);
+        return joinPath(dirnamePath(manifest), subpath);
+    }
+    catch (error) {
+        throw new StructuredConfigSchemaError(`Cannot resolve package schema "${specifier}" referenced by "${source}": ${errorMessage(error)}`);
+    }
+}
+function splitPackageSpecifier(specifier) {
+    const parts = specifier.split('/');
+    const segments = specifier.startsWith('@') ? 2 : 1;
+    return { pkg: parts.slice(0, segments).join('/'), subpath: parts.slice(segments).join('/') };
+}
+async function readSchema(schemaLocation, options) {
+    if (isRemoteRef(schemaLocation)) {
+        const fetchFn = options.fetch ?? (options.allowRemote ? boundedFetch : undefined);
+        if (fetchFn === undefined) {
+            throw new StructuredConfigSchemaError(`Refusing to fetch remote JSON schema "${schemaLocation}": pass { allowRemote: true } or a fetch implementation to opt in`);
+        }
+        const response = await fetchFn(schemaLocation);
+        if (!response.ok) {
+            throw new StructuredConfigSchemaError(`Failed to fetch JSON schema "${schemaLocation}": HTTP ${response.status}`);
+        }
+        return await readBoundedBody(response, schemaLocation);
+    }
+    return await getFs().readFile(schemaLocation);
+}
+/**
+ * Read a response body under a hard byte cap. `Content-Length` is a fast-path reject, but servers
+ * lie or omit it, so the stream is also tallied chunk-by-chunk — a multi-GB drip is aborted before
+ * it can exhaust memory. Falls back to `.text()` only when the body is not a readable stream.
+ */
+async function readBoundedBody(response, schemaLocation) {
+    const declared = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > REMOTE_SCHEMA_MAX_BYTES) {
+        throw new StructuredConfigSchemaError(`Remote JSON schema "${schemaLocation}" exceeds the ${REMOTE_SCHEMA_MAX_BYTES}-byte limit (Content-Length ${declared})`);
+    }
+    const body = response.body;
+    if (body === null)
+        return await response.text();
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > REMOTE_SCHEMA_MAX_BYTES) {
+                await reader.cancel();
+                throw new StructuredConfigSchemaError(`Remote JSON schema "${schemaLocation}" exceeds the ${REMOTE_SCHEMA_MAX_BYTES}-byte limit`);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(merged);
+}
+const defaultResolve = typeof Bun !== 'undefined' ? (specifier, from) => Bun.resolveSync(specifier, from) : undefined;
+/** Default remote fetch, time-bounded so a slow/hung schema host cannot stall config loading. */
+function boundedFetch(input) {
+    return globalThis.fetch(input, { signal: AbortSignal.timeout(REMOTE_SCHEMA_FETCH_TIMEOUT_MS) });
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function matchesType(value, type) {
+    if (type === 'object')
+        return isObject(value);
+    if (type === 'array')
+        return Array.isArray(value);
+    if (type === 'integer')
+        return typeof value === 'number' && Number.isInteger(value);
+    if (type === 'null')
+        return value === null;
+    return typeof value === type;
+}
+function typeName(value) {
+    if (Array.isArray(value))
+        return 'array';
+    if (value === null)
+        return 'null';
+    return typeof value;
+}
+function jsonEqual(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((entry, index) => jsonEqual(entry, right[index]));
+    }
+    if (isObject(left) && isObject(right)) {
+        const keys = Object.keys(left);
+        if (keys.length !== Object.keys(right).length)
+            return false;
+        // Object member order is insignificant in JSON — compare by key, not by serialization.
+        return keys.every((key) => key in right && jsonEqual(left[key], right[key]));
+    }
+    return false;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRemoteRef(ref) {
+    return /^https?:\/\//i.test(ref);
+}

package/dist/types.d.ts

@@ -1,6 +1,4 @@
 import type { Config } from './config';
-import type { RuntimeContext } from './context';
-import type { FileSystem } from './fs';
 export type RuntimeName = 'node-bun' | 'cloudflare-workers' | 'test';
 export interface RuntimeCapabilities {
     readonly hasFilesystem: boolean;
@@ -11,15 +9,6 @@ export interface LoadConfigOptions {
     overrides?: Partial<Config>;
     envBindings?: Record<string, unknown>;
 }
-export interface RuntimeFactory {
-    readonly runtimeName: RuntimeName;
-    readonly capabilities: RuntimeCapabilities;
-    createFileSystem(): FileSystem;
-    loadConfig(options?: LoadConfigOptions): Promise<Config>;
-    createContext?(options?: {
-        scope?: string;
-    }): RuntimeContext;
-}
 export interface SpanContext {
     traceId: string;
     spanId: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,oBAAoB,GAAG,MAAM,CAAC;AAErE,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;CAC1C;AAED,MAAM,WAAW,iBAAiB;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,gBAAgB,IAAI,UAAU,CAAC;IAC/B,UAAU,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzD,aAAa,CAAC,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,cAAc,CAAC;CAChE;AAED,MAAM,WAAW,WAAW;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CAC1D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,oBAAoB,GAAG,MAAM,CAAC;AAErE,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;CAC1C;AAED,MAAM,WAAW,iBAAiB;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,WAAW;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CAC1D"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/ts-runtime",
-    "version": "0.2.7",
+    "version": "0.2.9",
     "description": "@gobing-ai/ts-runtime — Runtime abstractions for Bun, Node, and Cloudflare Workers.",
     "keywords": [
         "typescript",
@@ -54,7 +54,7 @@
         "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-runtime-v<version> && git push --tags' && exit 1"
     },
     "dependencies": {
-        "@gobing-ai/ts-utils": "^0.2.7",
+        "@gobing-ai/ts-utils": "^0.2.9",
         "execa": "^9.5.0",
         "yaml": "^2.7.0",
         "zod": "^4.1.0"

package/src/config.ts

@@ -1,4 +1,5 @@
-import { parse as parseYaml } from 'yaml';
+import { deepMerge } from '@gobing-ai/ts-utils';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { type ZodIssue, z } from 'zod';
 
 export const configSchema = z.object({
@@ -29,6 +30,40 @@ export type Config = z.output<typeof configSchema>;
 
 const ENV_INTERPOLATION_RE = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
 
+/** Raised when a YAML text cannot be parsed as a plain object. */
+export class YamlParseError extends Error {
+    constructor(
+        message: string,
+        readonly innerError?: unknown,
+    ) {
+        super(message);
+        this.name = 'YamlParseError';
+    }
+}
+
+/** Parse YAML text into a plain object. Returns `{}` for null/undefined/empty input. */
+export function parseYamlObject(text: string): Record<string, unknown> {
+    let parsed: unknown;
+    try {
+        parsed = parseYaml(text);
+    } catch (error) {
+        throw new YamlParseError(
+            `YAML parsing failed: ${(error as Error).message}`,
+            error instanceof Error ? error : undefined,
+        );
+    }
+    if (parsed === null || parsed === undefined) return {};
+    if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new YamlParseError('YAML must parse to an object');
+    }
+    return parsed as Record<string, unknown>;
+}
+
+/** Serialize a plain object to a YAML string. */
+export function stringifyYamlObject(value: Record<string, unknown>): string {
+    return stringifyYaml(value);
+}
+
 export class ConfigLoadError extends Error {
     readonly issues: ZodIssue[];
 
@@ -39,6 +74,9 @@ export class ConfigLoadError extends Error {
     }
 }
 
+// These accessors read `process.env` directly and are node-bun only (ADR-008). On
+// `cloudflare-workers` there is no `process`; inject config explicitly rather than calling these.
+
 export function getNodeEnv(): string {
     return process.env.NODE_ENV ?? 'development';
 }
@@ -55,6 +93,7 @@ export function getDatabaseUrl(): string | undefined {
     return process.env.DATABASE_URL;
 }
 
+/** Node-bun only: interpolates `${VAR}` from `process.env` (see note above). */
 export function interpolateEnv(value: string): string {
     return value.replace(ENV_INTERPOLATION_RE, (_match, name: string) => process.env[name] ?? `\${${name}}`);
 }
@@ -68,48 +107,6 @@ export function interpolateTree(value: unknown): unknown {
     return value;
 }
 
-export function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown> {
-    const result = { ...target };
-    for (const [key, value] of Object.entries(source)) {
-        if (isPlainObject(value) && isPlainObject(result[key])) {
-            result[key] = deepMerge(result[key] as Record<string, unknown>, value);
-        } else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-export function flattenKeys(obj: Record<string, unknown>, prefix = ''): Record<string, string> {
-    const result: Record<string, string> = {};
-    for (const [key, value] of Object.entries(obj)) {
-        const fullKey = prefix ? `${prefix}.${key}` : key;
-        if (isPlainObject(value)) {
-            Object.assign(result, flattenKeys(value, fullKey));
-        } else {
-            result[fullKey] = JSON.stringify(value);
-        }
-    }
-    return result;
-}
-
-export function deFlattenKeys(entries: Record<string, string>): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-    for (const [key, rawValue] of Object.entries(entries)) {
-        const parts = key.split('.');
-        let current = result;
-        for (const part of parts.slice(0, -1)) {
-            if (!isPlainObject(current[part])) current[part] = {};
-            current = current[part] as Record<string, unknown>;
-        }
-
-        const last = parts.at(-1);
-        if (last === undefined) continue;
-        current[last] = parseConfigValue(rawValue);
-    }
-    return result;
-}
-
 export function buildConfigFromObject(
     raw: Record<string, unknown>,
     options: { overrides?: Partial<Config> } = {},
@@ -127,12 +124,7 @@ export function buildConfigFromObject(
 
 export function parseConfigYaml(yamlText: string): Record<string, unknown> {
     try {
-        const parsed = parseYaml(yamlText);
-        if (parsed === null || parsed === undefined) return {};
-        if (!isPlainObject(parsed)) {
-            throw new ConfigLoadError('Config YAML must parse to an object');
-        }
-        return parsed;
+        return parseYamlObject(yamlText);
     } catch (error) {
         if (error instanceof ConfigLoadError) throw error;
         throw new ConfigLoadError(`Config YAML parsing failed: ${(error as Error).message}`);
@@ -143,14 +135,6 @@ export function buildConfigFromYaml(yamlText: string, options: { overrides?: Par
     return buildConfigFromObject(parseConfigYaml(yamlText), options);
 }
 
-function parseConfigValue(value: string): unknown {
-    try {
-        return JSON.parse(value);
-    } catch {
-        return value;
-    }
-}
-
 function isPlainObject(value: unknown): value is Record<string, unknown> {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/src/context.ts

@@ -2,7 +2,7 @@ import type { Config } from './config';
 import { buildConfigFromObject } from './config';
 import type { FileSystem } from './fs';
 import { getFs } from './fs';
-import type { RuntimeCapabilities, RuntimeFactory, RuntimeName } from './types';
+import type { RuntimeCapabilities, RuntimeName } from './types';
 
 export type RuntimeScope = 'process' | 'server-request' | 'scheduled-event' | 'test';
 
@@ -17,7 +17,6 @@ export interface RuntimeContextOptions<TServices extends RuntimeServiceMap = Run
     runtimeName?: RuntimeName;
     capabilities?: RuntimeCapabilities;
     services?: Partial<TServices>;
-    factory?: RuntimeFactory;
 }
 
 export class RuntimeContext<TServices extends RuntimeServiceMap = RuntimeServiceMap> {
@@ -28,10 +27,9 @@ export class RuntimeContext<TServices extends RuntimeServiceMap = RuntimeService
 
     constructor(options: RuntimeContextOptions<TServices> = {}) {
         this.scope = options.scope ?? 'process';
-        this.runtimeName = options.runtimeName ?? options.factory?.runtimeName ?? 'node-bun';
+        this.runtimeName = options.runtimeName ?? 'node-bun';
         this.capabilities =
             options.capabilities ??
-            options.factory?.capabilities ??
             ({
                 hasFilesystem: true,
                 hasProcessExecution: true,