taurusdb-core 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# taurusdb-core
+
+Shared TaurusDB data-plane engine for:
+
+- schema discovery
+- readonly and mutation SQL execution
+- SQL guardrails and confirmation flow
+- TaurusDB capability detection
+- diagnostics workflows
+
+## Install
+
+```bash
+npm install taurusdb-core
+```
+
+## Notes
+
+- Requires Node.js `>= 20`
+- This is the shared engine package
+- Most end users should install `taurusdb-mcp` instead

package/dist/auth/secret-resolver.d.ts

@@ -0,0 +1,16 @@
+import type { CredentialRef } from "./sql-profile-loader.js";
+export interface SecretResolver {
+    resolve(ref: CredentialRef): Promise<string>;
+}
+export type UriSecretResolver = (uri: string) => Promise<string>;
+export type SecretResolverOptions = {
+    env?: NodeJS.ProcessEnv;
+    uriResolvers?: Record<string, UriSecretResolver>;
+};
+export declare class DefaultSecretResolver implements SecretResolver {
+    private readonly env;
+    private readonly uriResolvers;
+    constructor(options?: SecretResolverOptions);
+    resolve(ref: CredentialRef): Promise<string>;
+}
+export declare function createSecretResolver(options?: SecretResolverOptions): SecretResolver;

package/dist/auth/secret-resolver.js

@@ -0,0 +1,64 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function resolveFilePath(rawPath) {
+    if (rawPath === "~") {
+        return os.homedir();
+    }
+    if (rawPath.startsWith("~/")) {
+        return path.join(os.homedir(), rawPath.slice(2));
+    }
+    if (path.isAbsolute(rawPath)) {
+        return rawPath;
+    }
+    return path.resolve(process.cwd(), rawPath);
+}
+function sanitizeFileSecret(raw) {
+    return raw.replace(/\uFEFF/g, "").replace(/\r?\n$/, "");
+}
+function parseUri(input) {
+    const trimmed = input.trim();
+    const normalizedUri = trimmed.startsWith("uri:") ? trimmed.slice("uri:".length) : trimmed;
+    const match = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(normalizedUri);
+    if (!match) {
+        throw new Error(`Invalid URI credential ref: "${input}".`);
+    }
+    return {
+        scheme: match[1].toLowerCase(),
+        normalizedUri,
+    };
+}
+export class DefaultSecretResolver {
+    env;
+    uriResolvers;
+    constructor(options = {}) {
+        this.env = options.env ?? process.env;
+        this.uriResolvers = options.uriResolvers ?? {};
+    }
+    async resolve(ref) {
+        if (ref.type === "plain") {
+            return ref.value;
+        }
+        if (ref.type === "env") {
+            const value = this.env[ref.key];
+            if (value === undefined) {
+                throw new Error(`Environment variable not found for credential ref: ${ref.key}`);
+            }
+            return value;
+        }
+        if (ref.type === "file") {
+            const targetPath = resolveFilePath(ref.path);
+            const raw = await readFile(targetPath, "utf-8");
+            return sanitizeFileSecret(raw);
+        }
+        const { scheme, normalizedUri } = parseUri(ref.uri);
+        const resolver = this.uriResolvers[scheme];
+        if (!resolver) {
+            throw new Error(`Unsupported credential URI scheme: ${scheme}. Add a uri resolver for "${scheme}" in SecretResolver.`);
+        }
+        return resolver(normalizedUri);
+    }
+}
+export function createSecretResolver(options) {
+    return new DefaultSecretResolver(options);
+}

package/dist/auth/sql-profile-loader/env-source.d.ts

@@ -0,0 +1,3 @@
+import type { DataSourceProfile, DatabaseEngine } from "./types.js";
+export declare function parseEngineFromDsnProtocol(protocol: string): DatabaseEngine;
+export declare function parseEnvProfile(env: NodeJS.ProcessEnv): DataSourceProfile | undefined;

package/dist/auth/sql-profile-loader/env-source.js

@@ -0,0 +1,94 @@
+import { asInteger, asString, defaultPortForEngine, parseCredentialRef, parseEngine, withRedactedToString } from "./parsing.js";
+export function parseEngineFromDsnProtocol(protocol) {
+    const normalized = protocol.replace(/:$/, "").toLowerCase();
+    if (normalized === "mysql" || normalized === "mysql2") {
+        return "mysql";
+    }
+    if (normalized === "postgres" || normalized === "postgresql") {
+        return "postgresql";
+    }
+    throw new Error(`Unsupported DSN protocol: ${protocol}`);
+}
+export function parseEnvProfile(env) {
+    const dsn = asString(env.TAURUSDB_SQL_DSN);
+    const explicitHost = asString(env.TAURUSDB_SQL_HOST);
+    const profileName = asString(env.TAURUSDB_SQL_DATASOURCE) ?? "taurus_mcp";
+    let engine;
+    let host;
+    let port;
+    let database;
+    let readonlyUsername;
+    let readonlyPasswordRef;
+    if (dsn) {
+        const url = new URL(dsn);
+        engine = parseEngineFromDsnProtocol(url.protocol);
+        host = url.hostname;
+        port = url.port ? Number.parseInt(url.port, 10) : defaultPortForEngine(engine);
+        database = asString(url.pathname.replace(/^\//, ""));
+        readonlyUsername = asString(decodeURIComponent(url.username));
+        const dsnPassword = asString(decodeURIComponent(url.password));
+        if (dsnPassword) {
+            readonlyPasswordRef = parseCredentialRef(dsnPassword, "TAURUSDB_SQL_DSN.password");
+        }
+    }
+    else {
+        engine = parseEngine(asString(env.TAURUSDB_SQL_ENGINE) ?? "mysql", "TAURUSDB_SQL_ENGINE");
+        host = explicitHost;
+        const explicitPort = asInteger(env.TAURUSDB_SQL_PORT);
+        port = explicitPort ?? defaultPortForEngine(engine);
+        database = asString(env.TAURUSDB_SQL_DATABASE);
+    }
+    const mutationUserName = asString(env.TAURUSDB_SQL_MUTATION_USER);
+    const mutationPasswordRaw = asString(env.TAURUSDB_SQL_MUTATION_PASSWORD);
+    if (!dsn &&
+        !explicitHost &&
+        !asString(env.TAURUSDB_SQL_USER) &&
+        !asString(env.TAURUSDB_SQL_PASSWORD) &&
+        !database &&
+        !mutationUserName &&
+        !mutationPasswordRaw) {
+        return undefined;
+    }
+    if (!port || !Number.isFinite(port) || port <= 0) {
+        throw new Error("Failed to resolve SQL port from environment.");
+    }
+    readonlyUsername = readonlyUsername ?? asString(env.TAURUSDB_SQL_USER);
+    if (!readonlyUsername) {
+        throw new Error("Missing readonly username in environment. Set TAURUSDB_SQL_USER or include it in DSN.");
+    }
+    readonlyPasswordRef =
+        readonlyPasswordRef ??
+            (Object.hasOwn(env, "TAURUSDB_SQL_PASSWORD")
+                ? parseCredentialRef(env.TAURUSDB_SQL_PASSWORD, "TAURUSDB_SQL_PASSWORD")
+                : undefined);
+    if (!readonlyPasswordRef) {
+        throw new Error("Missing readonly password in environment. Set TAURUSDB_SQL_PASSWORD or include it in DSN.");
+    }
+    let mutationUser;
+    if (mutationUserName || mutationPasswordRaw) {
+        if (!mutationUserName || !mutationPasswordRaw) {
+            throw new Error("Invalid mutation credentials in environment: TAURUSDB_SQL_MUTATION_USER and TAURUSDB_SQL_MUTATION_PASSWORD must be set together.");
+        }
+        mutationUser = {
+            username: mutationUserName,
+            password: parseCredentialRef(mutationPasswordRaw, "TAURUSDB_SQL_MUTATION_PASSWORD"),
+        };
+    }
+    const poolSize = asInteger(env.TAURUSDB_SQL_POOL_SIZE);
+    if (poolSize !== undefined && poolSize <= 0) {
+        throw new Error("Invalid TAURUSDB_SQL_POOL_SIZE: must be positive.");
+    }
+    return withRedactedToString({
+        name: profileName,
+        engine,
+        host,
+        port,
+        database,
+        readonlyUser: {
+            username: readonlyUsername,
+            password: readonlyPasswordRef,
+        },
+        mutationUser,
+        poolSize,
+    });
+}

package/dist/auth/sql-profile-loader/file-source.d.ts

@@ -0,0 +1,6 @@
+import type { DataSourceProfile } from "./types.js";
+export type FileProfilesPayload = {
+    profiles: Map<string, DataSourceProfile>;
+    defaultDatasource?: string;
+};
+export declare function parseProfilesFile(raw: string, filePath: string): FileProfilesPayload;

package/dist/auth/sql-profile-loader/file-source.js

@@ -0,0 +1,40 @@
+import { asString, isObject, parseProfileRecord } from "./parsing.js";
+export function parseProfilesFile(raw, filePath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in profiles file: ${filePath}`, { cause: error });
+    }
+    if (!isObject(parsed)) {
+        throw new Error(`Invalid profiles file root in ${filePath}: expected object.`);
+    }
+    const root = parsed;
+    const defaultDatasource = asString(root.defaultDatasource ?? root.default);
+    const profileNode = root.dataSources ?? root.datasources ?? root.profiles;
+    const profiles = new Map();
+    if (profileNode === undefined) {
+        return { profiles, defaultDatasource };
+    }
+    if (Array.isArray(profileNode)) {
+        for (const item of profileNode) {
+            if (!isObject(item)) {
+                throw new Error(`Invalid profile item in ${filePath}: expected object.`);
+            }
+            const name = asString(item.name);
+            if (!name) {
+                throw new Error(`Invalid profile item in ${filePath}: missing name.`);
+            }
+            profiles.set(name, parseProfileRecord(name, item, filePath));
+        }
+        return { profiles, defaultDatasource };
+    }
+    if (!isObject(profileNode)) {
+        throw new Error(`Invalid profiles node in ${filePath}: expected object or array.`);
+    }
+    for (const [name, profileValue] of Object.entries(profileNode)) {
+        profiles.set(name, parseProfileRecord(name, profileValue, filePath));
+    }
+    return { profiles, defaultDatasource };
+}

package/dist/auth/sql-profile-loader/loader.d.ts

@@ -0,0 +1,16 @@
+import type { Config } from "../../config/index.js";
+import type { DataSourceProfile, ProfileLoader, SqlProfileLoaderOptions } from "./types.js";
+export declare function resolveDefaultProfilePath(config: Config): string;
+export declare class SqlProfileLoader implements ProfileLoader {
+    private readonly config;
+    private readonly env;
+    private cache;
+    private pending;
+    constructor(options: SqlProfileLoaderOptions);
+    load(): Promise<Map<string, DataSourceProfile>>;
+    getDefault(): Promise<string | undefined>;
+    get(name: string): Promise<DataSourceProfile | undefined>;
+    private ensureLoaded;
+    private loadInternal;
+}
+export declare function createSqlProfileLoader(options: SqlProfileLoaderOptions): ProfileLoader;

package/dist/auth/sql-profile-loader/loader.js

@@ -0,0 +1,81 @@
+import { access, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { parseEnvProfile } from "./env-source.js";
+import { parseProfilesFile } from "./file-source.js";
+export function resolveDefaultProfilePath(config) {
+    if (config.profilesPath) {
+        return config.profilesPath;
+    }
+    return path.join(os.homedir(), ".config", "taurusdb-mcp", "profiles.json");
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class SqlProfileLoader {
+    config;
+    env;
+    cache;
+    pending;
+    constructor(options) {
+        this.config = options.config;
+        this.env = options.env ?? process.env;
+    }
+    async load() {
+        const loaded = await this.ensureLoaded();
+        return new Map(loaded.profiles);
+    }
+    async getDefault() {
+        const loaded = await this.ensureLoaded();
+        return loaded.defaultDatasource;
+    }
+    async get(name) {
+        const loaded = await this.ensureLoaded();
+        return loaded.profiles.get(name);
+    }
+    async ensureLoaded() {
+        if (this.cache) {
+            return this.cache;
+        }
+        if (!this.pending) {
+            this.pending = this.loadInternal();
+        }
+        const loaded = await this.pending;
+        this.cache = loaded;
+        this.pending = undefined;
+        return loaded;
+    }
+    async loadInternal() {
+        const mergedProfiles = new Map();
+        const envProfile = parseEnvProfile(this.env);
+        if (envProfile) {
+            mergedProfiles.set(envProfile.name, envProfile);
+        }
+        const profilePath = resolveDefaultProfilePath(this.config);
+        let fileDefaultDatasource;
+        if (await exists(profilePath)) {
+            const content = await readFile(profilePath, "utf-8");
+            const parsed = parseProfilesFile(content, profilePath);
+            fileDefaultDatasource = parsed.defaultDatasource;
+            for (const [name, profile] of parsed.profiles.entries()) {
+                mergedProfiles.set(name, profile);
+            }
+        }
+        const defaultDatasource = this.config.defaultDatasource ??
+            fileDefaultDatasource ??
+            (mergedProfiles.size === 1 ? mergedProfiles.keys().next().value : undefined);
+        return {
+            profiles: mergedProfiles,
+            defaultDatasource,
+        };
+    }
+}
+export function createSqlProfileLoader(options) {
+    return new SqlProfileLoader(options);
+}

package/dist/auth/sql-profile-loader/parsing.d.ts

@@ -0,0 +1,14 @@
+import type { CredentialRef, DataSourceProfile, DatabaseEngine, TlsOptions, UserCredential } from "./types.js";
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function asString(value: unknown): string | undefined;
+export declare function asInteger(value: unknown): number | undefined;
+export declare function asBoolean(value: unknown): boolean | undefined;
+export declare function defaultPortForEngine(engine: DatabaseEngine): number;
+export declare function parseEngine(value: unknown, context: string): DatabaseEngine;
+export declare function parseCredentialRef(value: unknown, context: string): CredentialRef;
+export declare function parseUserCredential(value: unknown, context: string): UserCredential;
+export declare function parseTlsOptions(value: unknown, context: string): TlsOptions | undefined;
+export declare function deepRedact(value: unknown): unknown;
+export declare function redactDataSourceProfile(profile: DataSourceProfile): Record<string, unknown>;
+export declare function withRedactedToString(profile: Omit<DataSourceProfile, "toString">): DataSourceProfile;
+export declare function parseProfileRecord(name: string, value: unknown, context: string): DataSourceProfile;

package/dist/auth/sql-profile-loader/parsing.js

@@ -0,0 +1,216 @@
+const CREDENTIAL_URI_PREFIXES = ["aws-sm:", "hw-kms:", "uri:"];
+const SENSITIVE_KEY_PATTERN = /(password|secret|token|credential|apikey|api_key)/i;
+export function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function asString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+export function asInteger(value) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return value;
+    }
+    if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+        return Number.parseInt(value, 10);
+    }
+    return undefined;
+}
+export function asBoolean(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (["1", "true", "yes", "on"].includes(normalized)) {
+            return true;
+        }
+        if (["0", "false", "no", "off"].includes(normalized)) {
+            return false;
+        }
+    }
+    return undefined;
+}
+export function defaultPortForEngine(engine) {
+    return engine === "postgresql" ? 5432 : 3306;
+}
+export function parseEngine(value, context) {
+    const normalized = asString(value)?.toLowerCase();
+    if (normalized === "mysql") {
+        return "mysql";
+    }
+    if (normalized === "postgresql" || normalized === "postgres" || normalized === "pg") {
+        return "postgresql";
+    }
+    throw new Error(`Invalid engine in ${context}. Expected mysql or postgresql.`);
+}
+export function parseCredentialRef(value, context) {
+    if (typeof value === "string") {
+        if (value.startsWith("env:")) {
+            const key = value.slice("env:".length).trim();
+            if (!key) {
+                throw new Error(`Invalid env credential ref in ${context}: missing key.`);
+            }
+            return { type: "env", key };
+        }
+        if (value.startsWith("file:")) {
+            const filePath = value.slice("file:".length).trim();
+            if (!filePath) {
+                throw new Error(`Invalid file credential ref in ${context}: missing path.`);
+            }
+            return { type: "file", path: filePath };
+        }
+        if (CREDENTIAL_URI_PREFIXES.some((prefix) => value.startsWith(prefix))) {
+            return { type: "uri", uri: value };
+        }
+        return { type: "plain", value };
+    }
+    if (!isObject(value)) {
+        throw new Error(`Invalid credential ref in ${context}: expected string or object.`);
+    }
+    const type = asString(value.type);
+    if (type === "plain") {
+        const plain = asString(value.value);
+        if (!plain) {
+            throw new Error(`Invalid plain credential ref in ${context}: missing value.`);
+        }
+        return { type: "plain", value: plain };
+    }
+    if (type === "env") {
+        const key = asString(value.key);
+        if (!key) {
+            throw new Error(`Invalid env credential ref in ${context}: missing key.`);
+        }
+        return { type: "env", key };
+    }
+    if (type === "file") {
+        const filePath = asString(value.path);
+        if (!filePath) {
+            throw new Error(`Invalid file credential ref in ${context}: missing path.`);
+        }
+        return { type: "file", path: filePath };
+    }
+    if (type === "uri") {
+        const uri = asString(value.uri);
+        if (!uri) {
+            throw new Error(`Invalid uri credential ref in ${context}: missing uri.`);
+        }
+        return { type: "uri", uri };
+    }
+    throw new Error(`Invalid credential ref type in ${context}.`);
+}
+export function parseUserCredential(value, context) {
+    if (!isObject(value)) {
+        throw new Error(`Invalid user credential in ${context}: expected object.`);
+    }
+    const username = asString(value.username ?? value.user);
+    if (!username) {
+        throw new Error(`Invalid user credential in ${context}: missing username.`);
+    }
+    if (!Object.hasOwn(value, "password") && !Object.hasOwn(value, "pass")) {
+        throw new Error(`Invalid user credential in ${context}: missing password.`);
+    }
+    const password = parseCredentialRef(value.password ?? value.pass, `${context}.password`);
+    return { username, password };
+}
+export function parseTlsOptions(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "boolean") {
+        return { enabled: value };
+    }
+    if (!isObject(value)) {
+        throw new Error(`Invalid tls config in ${context}: expected boolean or object.`);
+    }
+    const parsed = {};
+    const enabled = asBoolean(value.enabled);
+    if (enabled !== undefined) {
+        parsed.enabled = enabled;
+    }
+    const rejectUnauthorized = asBoolean(value.rejectUnauthorized);
+    if (rejectUnauthorized !== undefined) {
+        parsed.rejectUnauthorized = rejectUnauthorized;
+    }
+    const servername = asString(value.servername);
+    if (servername) {
+        parsed.servername = servername;
+    }
+    if (Object.hasOwn(value, "ca")) {
+        parsed.ca = parseCredentialRef(value.ca, `${context}.ca`);
+    }
+    if (Object.hasOwn(value, "cert")) {
+        parsed.cert = parseCredentialRef(value.cert, `${context}.cert`);
+    }
+    if (Object.hasOwn(value, "key")) {
+        parsed.key = parseCredentialRef(value.key, `${context}.key`);
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+}
+export function deepRedact(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => deepRedact(entry));
+    }
+    if (isObject(value)) {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            output[key] = SENSITIVE_KEY_PATTERN.test(key) ? "[REDACTED]" : deepRedact(nested);
+        }
+        return output;
+    }
+    return value;
+}
+export function redactDataSourceProfile(profile) {
+    return deepRedact(profile);
+}
+export function withRedactedToString(profile) {
+    const instance = profile;
+    Object.defineProperty(instance, "toString", {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value() {
+            return JSON.stringify(redactDataSourceProfile(instance));
+        },
+    });
+    return instance;
+}
+export function parseProfileRecord(name, value, context) {
+    if (!isObject(value)) {
+        throw new Error(`Invalid datasource profile ${name} in ${context}: expected object.`);
+    }
+    const engine = parseEngine(value.engine ?? "mysql", `${context}.${name}.engine`);
+    const host = asString(value.host ?? value.hostname);
+    const parsedPort = asInteger(value.port);
+    const port = parsedPort ?? defaultPortForEngine(engine);
+    if (port <= 0) {
+        throw new Error(`Invalid datasource profile ${name} in ${context}: port must be positive.`);
+    }
+    const database = asString(value.database);
+    const poolSize = asInteger(value.poolSize);
+    if (poolSize !== undefined && poolSize <= 0) {
+        throw new Error(`Invalid datasource profile ${name} in ${context}: poolSize must be positive.`);
+    }
+    const readonlyRaw = value.readonlyUser ?? value.readonly ?? value.readOnlyUser;
+    if (readonlyRaw === undefined) {
+        throw new Error(`Invalid datasource profile ${name} in ${context}: missing readonlyUser.`);
+    }
+    const readonlyUser = parseUserCredential(readonlyRaw, `${context}.${name}.readonlyUser`);
+    const mutationRaw = value.mutationUser ?? value.writeUser ?? value.rwUser;
+    const mutationUser = mutationRaw !== undefined ? parseUserCredential(mutationRaw, `${context}.${name}.mutationUser`) : undefined;
+    const tls = parseTlsOptions(value.tls, `${context}.${name}.tls`);
+    return withRedactedToString({
+        name,
+        engine,
+        host,
+        port,
+        database,
+        readonlyUser,
+        mutationUser,
+        tls,
+        poolSize,
+    });
+}

package/dist/auth/sql-profile-loader/runtime-override.d.ts

@@ -0,0 +1,14 @@
+import type { DataSourceProfile, ProfileLoader, RuntimeDataSourceTarget, RuntimeTargetProfileLoader } from "./types.js";
+export declare function applyRuntimeTarget(profile: DataSourceProfile, target: RuntimeDataSourceTarget | undefined): DataSourceProfile;
+export declare class RuntimeOverrideProfileLoader implements RuntimeTargetProfileLoader {
+    private readonly base;
+    private readonly runtimeTargets;
+    constructor(base: ProfileLoader);
+    setRuntimeTarget(name: string, target: RuntimeDataSourceTarget): void;
+    clearRuntimeTarget(name: string): void;
+    clearAllRuntimeTargets(): void;
+    getRuntimeTarget(name: string): RuntimeDataSourceTarget | undefined;
+    load(): Promise<Map<string, DataSourceProfile>>;
+    getDefault(): Promise<string | undefined>;
+    get(name: string): Promise<DataSourceProfile | undefined>;
+}

package/dist/auth/sql-profile-loader/runtime-override.js

@@ -0,0 +1,52 @@
+import { withRedactedToString } from "./parsing.js";
+export function applyRuntimeTarget(profile, target) {
+    if (!target) {
+        return profile;
+    }
+    return withRedactedToString({
+        ...profile,
+        host: target.host,
+        port: target.port ?? profile.port,
+    });
+}
+export class RuntimeOverrideProfileLoader {
+    base;
+    runtimeTargets = new Map();
+    constructor(base) {
+        this.base = base;
+    }
+    setRuntimeTarget(name, target) {
+        this.runtimeTargets.set(name, {
+            host: target.host,
+            port: target.port,
+            instanceId: target.instanceId,
+            nodeId: target.nodeId,
+        });
+    }
+    clearRuntimeTarget(name) {
+        this.runtimeTargets.delete(name);
+    }
+    clearAllRuntimeTargets() {
+        this.runtimeTargets.clear();
+    }
+    getRuntimeTarget(name) {
+        return this.runtimeTargets.get(name);
+    }
+    async load() {
+        const loaded = await this.base.load();
+        return new Map([...loaded.entries()].map(([name, profile]) => [
+            name,
+            applyRuntimeTarget(profile, this.runtimeTargets.get(name)),
+        ]));
+    }
+    async getDefault() {
+        return this.base.getDefault();
+    }
+    async get(name) {
+        const profile = await this.base.get(name);
+        if (!profile) {
+            return undefined;
+        }
+        return applyRuntimeTarget(profile, this.runtimeTargets.get(name));
+    }
+}