@naylence/runtime 0.3.5-test.6 → 0.3.5-test.8

package/dist/browser/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 var core = require('@naylence/core');
+var zod = require('zod');
 var factory = require('@naylence/factory');
 var fs = require('fs');
-var zod = require('zod');
 var yaml = require('yaml');
 var sha2_js = require('@noble/hashes/sha2.js');
 var utils_js = require('@noble/hashes/utils.js');
@@ -847,7 +847,7 @@ function coerceNumber(value) {
     }
     return undefined;
 }
-function coerceBoolean(value) {
+function coerceBoolean$1(value) {
     if (typeof value === 'boolean') {
         return value;
     }
@@ -871,7 +871,7 @@ function normalizeTaskSpawnerConfig(config = {}) {
         0;
     const defaultTimeout = coerceNumber(firstDefined(source, ['defaultTimeout', 'default_timeout'])) ??
         0;
-    const autoCleanup = coerceBoolean(firstDefined(source, ['autoCleanup', 'auto_cleanup'])) ??
+    const autoCleanup = coerceBoolean$1(firstDefined(source, ['autoCleanup', 'auto_cleanup'])) ??
         true;
     return {
         maxConcurrent,
@@ -894,7 +894,7 @@ function normalizeSpawnOptions(options = {}) {
 function normalizeShutdownOptions(options = {}) {
     const source = options;
     const gracePeriod = coerceNumber(firstDefined(source, ['gracePeriod', 'grace_period'])) ?? 2000;
-    const cancelHanging = coerceBoolean(firstDefined(source, ['cancelHanging', 'cancel_hanging'])) ??
+    const cancelHanging = coerceBoolean$1(firstDefined(source, ['cancelHanging', 'cancel_hanging'])) ??
         true;
     const joinTimeout = coerceNumber(firstDefined(source, ['joinTimeout', 'join_timeout'])) ?? 1000;
     return {
@@ -2946,6 +2946,211 @@ class StorageProviderFactory extends factory.AbstractResourceFactory {
         return instance;
     }
 }
+function registerStorageProviderFactory(type, factory$1) {
+    factory.registerFactory(STORAGE_PROVIDER_FACTORY_BASE_TYPE, type, factory$1);
+}
+
+const inMemoryStorageProviderConfigSchema = zod.z
+    .object({
+    type: zod.z
+        .literal('InMemoryStorageProvider')
+        .default('InMemoryStorageProvider'),
+})
+    .passthrough();
+class InMemoryStorageProviderFactory extends StorageProviderFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'InMemoryStorageProvider';
+    }
+    async create(config) {
+        // Validate configuration and ensure correct type information
+        const candidate = config ?? { type: 'InMemoryStorageProvider' };
+        inMemoryStorageProviderConfigSchema.parse({
+            type: candidate.type,
+            ...candidate,
+        });
+        return new InMemoryStorageProvider();
+    }
+}
+registerStorageProviderFactory('InMemoryStorageProvider', InMemoryStorageProviderFactory);
+
+const CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE = 'CredentialProviderFactory';
+class CredentialProviderFactory extends factory.AbstractResourceFactory {
+    static async createCredentialProvider(config, options = {}) {
+        const instance = config
+            ? await factory.createResource(CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE, config, options)
+            : await factory.createDefaultResource(CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE, null, options);
+        if (!instance) {
+            throw new Error('Failed to create credential provider from configuration');
+        }
+        return instance;
+    }
+}
+
+function normalizeEnvConfig(config) {
+    if (!config) {
+        return {
+            type: 'EnvCredentialProvider',
+            varName: 'DEFAULT_VAR',
+        };
+    }
+    if ('varName' in config &&
+        typeof config.varName === 'string' &&
+        config.varName.length > 0) {
+        return {
+            type: 'EnvCredentialProvider',
+            varName: config.varName,
+        };
+    }
+    const rawName = config.varName ??
+        config.var_name;
+    if (typeof rawName !== 'string' || rawName.length === 0) {
+        throw new Error('EnvCredentialProvider requires a non-empty "varName"');
+    }
+    return {
+        type: 'EnvCredentialProvider',
+        varName: rawName,
+    };
+}
+
+function normalizePromptConfig(config) {
+    if (!config) {
+        return {
+            type: 'PromptCredentialProvider',
+            credentialName: 'credential',
+        };
+    }
+    const credentialName = config.credentialName ??
+        config.credential_name ??
+        'credential';
+    if (typeof credentialName !== 'string' || credentialName.length === 0) {
+        throw new Error('PromptCredentialProvider requires a non-empty "credentialName"');
+    }
+    return {
+        type: 'PromptCredentialProvider',
+        credentialName,
+    };
+}
+
+function normalizeSecretStoreConfig(config) {
+    if (!config) {
+        return {
+            type: 'SecretStoreCredentialProvider',
+            secretName: 'default',
+        };
+    }
+    if ('secretName' in config &&
+        typeof config.secretName === 'string' &&
+        config.secretName.length > 0) {
+        return {
+            type: 'SecretStoreCredentialProvider',
+            secretName: config.secretName,
+        };
+    }
+    const rawName = config.secretName ??
+        config.secret_name;
+    if (typeof rawName !== 'string' || rawName.length === 0) {
+        throw new Error('SecretStoreCredentialProvider requires a non-empty "secretName"');
+    }
+    return {
+        type: 'SecretStoreCredentialProvider',
+        secretName: rawName,
+    };
+}
+
+function normalizeStaticConfig(config) {
+    if (!config) {
+        return {
+            type: 'StaticCredentialProvider',
+            credentialValue: '',
+        };
+    }
+    if ('credentialValue' in config &&
+        typeof config.credentialValue === 'string') {
+        return {
+            type: 'StaticCredentialProvider',
+            credentialValue: config.credentialValue,
+        };
+    }
+    const rawValue = config.credentialValue ??
+        config.credential_value;
+    if (typeof rawValue !== 'string') {
+        throw new Error('StaticCredentialProvider requires a "credentialValue" string');
+    }
+    return {
+        type: 'StaticCredentialProvider',
+        credentialValue: rawValue,
+    };
+}
+
+function isCredentialProviderConfig(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        'type' in value);
+}
+class SecretSource {
+    static normalize(value) {
+        if (value === null || value === undefined) {
+            throw new TypeError('Secret source cannot be null or undefined');
+        }
+        if (isCredentialProviderConfig(value)) {
+            switch (value.type) {
+                case 'EnvCredentialProvider':
+                    return normalizeEnvConfig(value);
+                case 'SecretStoreCredentialProvider':
+                    return normalizeSecretStoreConfig(value);
+                case 'StaticCredentialProvider':
+                    return normalizeStaticConfig(value);
+                case 'PromptCredentialProvider':
+                    return normalizePromptConfig(value);
+                default:
+                    return { ...value };
+            }
+        }
+        if (typeof value === 'string') {
+            if (value.startsWith('env://')) {
+                const varName = value.slice('env://'.length);
+                if (!varName) {
+                    throw new Error("Environment variable name cannot be empty in 'env://' URI");
+                }
+                return normalizeEnvConfig({ type: 'EnvCredentialProvider', varName });
+            }
+            if (value.startsWith('secret://')) {
+                const secretName = value.slice('secret://'.length);
+                if (!secretName) {
+                    throw new Error("Secret name cannot be empty in 'secret://' URI");
+                }
+                return normalizeSecretStoreConfig({
+                    type: 'SecretStoreCredentialProvider',
+                    secretName,
+                });
+            }
+            return normalizeStaticConfig({
+                type: 'StaticCredentialProvider',
+                credentialValue: value,
+            });
+        }
+        if (typeof value === 'object') {
+            const recordValue = value;
+            if (!('type' in recordValue) || typeof recordValue.type !== 'string') {
+                throw new TypeError("Secret source dict inputs must include a string 'type' field");
+            }
+            switch (recordValue.type) {
+                case 'EnvCredentialProvider':
+                    return normalizeEnvConfig(recordValue);
+                case 'SecretStoreCredentialProvider':
+                    return normalizeSecretStoreConfig(recordValue);
+                case 'StaticCredentialProvider':
+                    return normalizeStaticConfig(recordValue);
+                case 'PromptCredentialProvider':
+                    return normalizePromptConfig(recordValue);
+                default:
+                    return { ...recordValue };
+            }
+        }
+        throw new TypeError(`Unsupported secret source type: ${typeof value}. Expected string, dict with 'type' field, or CredentialProviderConfig instance.`);
+    }
+}
 
 function isModuleNotFoundError(error) {
     if (!(error instanceof Error)) {
@@ -2967,8 +3172,9 @@ function isModuleNotFoundError(error) {
  * Wraps a dynamic import loader and enriches "module not found" failures with an actionable error message.
  */
 async function safeImport(loader, dependencyNameOrOptions, maybeOptions) {
-    const options = { dependencyName: dependencyNameOrOptions, ...(maybeOptions ?? {}) }
-        ;
+    const options = typeof dependencyNameOrOptions === 'string'
+        ? { dependencyName: dependencyNameOrOptions, ...(maybeOptions ?? {}) }
+        : dependencyNameOrOptions;
     const dependencyName = options.dependencyName;
     try {
         return await loader();
@@ -2990,6 +3196,219 @@ async function safeImport(loader, dependencyNameOrOptions, maybeOptions) {
     }
 }
 
+const indexedDBConfigSchema = zod.z
+    .object({
+    type: zod.z
+        .literal('IndexedDBStorageProvider')
+        .default('IndexedDBStorageProvider'),
+    mode: zod.z
+        .union([zod.z.literal('dx'), zod.z.literal('hardened'), zod.z.string()])
+        .optional()
+        .default('dx'),
+    dbName: zod.z.string().min(1).default('naylence'),
+    version: zod.z.union([zod.z.number().int().positive(), zod.z.string()]).default(1),
+    namespacePrefix: zod.z.string().optional().default('kv'),
+    enableCaching: zod.z.union([zod.z.boolean(), zod.z.string()]).optional(),
+    isEncrypted: zod.z.union([zod.z.boolean(), zod.z.string()]).optional(),
+    masterKey: zod.z
+        .union([zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown()), zod.z.null()])
+        .optional()
+        .default(null),
+})
+    .passthrough();
+const TRUE_VALUES = new Set(['true', '1', 'yes', 'on']);
+const FALSE_VALUES = new Set(['false', '0', 'no', 'off', '']);
+function coerceBoolean(value, fieldName, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (TRUE_VALUES.has(normalized)) {
+            return true;
+        }
+        if (FALSE_VALUES.has(normalized)) {
+            return false;
+        }
+    }
+    throw new Error(`Expected a boolean-like value for '${fieldName}' but received '${String(value)}'`);
+}
+function normalizeIndexedDBConfig(config) {
+    const candidate = {
+        ...config,
+    };
+    if (candidate.dbName === undefined && typeof candidate.db_name === 'string') {
+        candidate.dbName = candidate.db_name;
+    }
+    if (candidate.namespacePrefix === undefined &&
+        typeof candidate.namespace_prefix === 'string') {
+        candidate.namespacePrefix = candidate.namespace_prefix;
+    }
+    if (candidate.enableCaching === undefined &&
+        candidate.enable_caching !== undefined) {
+        candidate.enableCaching = candidate.enable_caching;
+    }
+    if (candidate.isEncrypted === undefined &&
+        candidate.is_encrypted !== undefined) {
+        candidate.isEncrypted = candidate.is_encrypted;
+    }
+    if (candidate.masterKey === undefined && candidate.master_key !== undefined) {
+        candidate.masterKey = candidate.master_key;
+    }
+    const parsed = indexedDBConfigSchema.parse({
+        ...candidate,
+        type: 'IndexedDBStorageProvider',
+    });
+    const normalizedMode = (typeof parsed.mode === 'string' ? parsed.mode : 'dx').toLowerCase();
+    if (normalizedMode !== 'dx' && normalizedMode !== 'hardened') {
+        throw new Error("mode must be either 'dx' or 'hardened'");
+    }
+    const versionValue = typeof parsed.version === 'string'
+        ? parseInt(parsed.version, 10)
+        : parsed.version;
+    if (!Number.isInteger(versionValue) || versionValue <= 0) {
+        throw new Error('version must be a positive integer');
+    }
+    const enableCaching = coerceBoolean(parsed.enableCaching, 'enableCaching', normalizedMode === 'dx');
+    const isEncrypted = coerceBoolean(parsed.isEncrypted, 'isEncrypted', true);
+    let masterKeyConfig = null;
+    if (parsed.masterKey !== null && parsed.masterKey !== undefined) {
+        masterKeyConfig = SecretSource.normalize(parsed.masterKey);
+    }
+    if (normalizedMode === 'hardened' && !masterKeyConfig) {
+        throw new Error('hardened mode requires a masterKey configuration');
+    }
+    return {
+        type: 'IndexedDBStorageProvider',
+        mode: normalizedMode,
+        dbName: parsed.dbName,
+        version: versionValue,
+        namespacePrefix: parsed.namespacePrefix ?? 'kv',
+        enableCaching,
+        isEncrypted,
+        masterKey: masterKeyConfig,
+    };
+}
+class IndexedDBStorageProviderFactory extends StorageProviderFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'IndexedDBStorageProvider';
+        this.isDefault = true;
+        this.priority = 50;
+    }
+    async create(config) {
+        const normalized = normalizeIndexedDBConfig(config);
+        const { IndexedDBStorageProvider } = await getIndexedDbStorageProviderModule();
+        let masterKeyProvider = null;
+        if (normalized.masterKey) {
+            masterKeyProvider =
+                await CredentialProviderFactory.createCredentialProvider(normalized.masterKey);
+        }
+        return new IndexedDBStorageProvider({
+            mode: normalized.mode,
+            dbName: normalized.dbName,
+            version: normalized.version,
+            namespacePrefix: normalized.namespacePrefix,
+            enableCaching: normalized.enableCaching,
+            isEncrypted: normalized.isEncrypted,
+            masterKeyProvider,
+        });
+    }
+}
+let indexedDbStorageProviderModulePromise = null;
+function getIndexedDbStorageProviderModule() {
+    if (!indexedDbStorageProviderModulePromise) {
+        indexedDbStorageProviderModulePromise = safeImport(() => Promise.resolve().then(function () { return indexeddbStorageProvider; }), 'IndexedDBStorageProvider', {
+            helpMessage: 'Failed to load the IndexedDB storage provider. Ensure IndexedDB is available or install the required polyfills.',
+        });
+    }
+    return indexedDbStorageProviderModulePromise;
+}
+registerStorageProviderFactory('IndexedDBStorageProvider', IndexedDBStorageProviderFactory);
+
+const ENV_VAR_STORAGE_DB_DIRECTORY = 'FAME_STORAGE_DB_DIRECTORY';
+const ENV_VAR_STORAGE_MASTER_KEY = 'FAME_STORAGE_MASTER_KEY';
+const ENV_VAR_STORAGE_ENCRYPTED = 'FAME_STORAGE_ENCRYPTED';
+const PROFILE_NAME_MEMORY = 'memory';
+const PROFILE_NAME_INDEXEDDB = 'indexeddb';
+const PROFILE_NAME_SQLITE = 'sqlite';
+const PROFILE_NAME_ENCRYPTED_SQLITE = 'encrypted-sqlite';
+const storageProfileSchema = zod.z
+    .object({
+    type: zod.z.literal('StorageProfile').default('StorageProfile'),
+    profile: zod.z
+        .string()
+        .optional()
+        .describe('Storage profile name (memory | indexeddb | sqlite | encrypted-sqlite)'),
+})
+    .passthrough();
+const MEMORY_PROFILE_CONFIG = {
+    type: 'InMemoryStorageProvider',
+};
+const INDEXEDDB_PROFILE_CONFIG = {
+    type: 'IndexedDBStorageProvider',
+};
+const SQLITE_PROFILE_CONFIG = {
+    type: 'SQLiteStorageProvider',
+    dbDirectory: factory.Expressions.env(ENV_VAR_STORAGE_DB_DIRECTORY, './data/sqlite'),
+    isEncrypted: factory.Expressions.env(ENV_VAR_STORAGE_ENCRYPTED, 'false'),
+    masterKey: factory.Expressions.env(ENV_VAR_STORAGE_MASTER_KEY, ''),
+    isCached: true,
+};
+const ENCRYPTED_SQLITE_PROFILE_CONFIG = {
+    type: 'SQLiteStorageProvider',
+    dbDirectory: factory.Expressions.env(ENV_VAR_STORAGE_DB_DIRECTORY, './data/sqlite'),
+    isEncrypted: 'true',
+    masterKey: factory.Expressions.env(ENV_VAR_STORAGE_MASTER_KEY),
+    isCached: true,
+};
+// Base profile map with browser-safe options
+const BASE_PROFILE_MAP = {
+    [PROFILE_NAME_MEMORY]: MEMORY_PROFILE_CONFIG,
+    [PROFILE_NAME_INDEXEDDB]: INDEXEDDB_PROFILE_CONFIG,
+};
+// Extended profile map - can be augmented by Node.js environment
+const PROFILE_MAP$1 = {
+    ...BASE_PROFILE_MAP,
+};
+// Register SQLite profiles if we're in Node.js environment
+// This check allows the code to work in both browser and Node.js
+if (typeof process !== 'undefined' && process.versions?.node) {
+    PROFILE_MAP$1[PROFILE_NAME_SQLITE] = SQLITE_PROFILE_CONFIG;
+    PROFILE_MAP$1[PROFILE_NAME_ENCRYPTED_SQLITE] = ENCRYPTED_SQLITE_PROFILE_CONFIG;
+}
+class StorageProfileFactory extends StorageProviderFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'StorageProfile';
+    }
+    async create(config, options) {
+        const candidate = config ?? { type: 'StorageProfile' };
+        const parsed = storageProfileSchema.parse({
+            ...candidate,
+            type: 'StorageProfile',
+        });
+        const profileName = (parsed.profile ?? PROFILE_NAME_MEMORY).toLowerCase();
+        const profileConfig = PROFILE_MAP$1[profileName];
+        if (!profileConfig) {
+            throw new Error(`Unknown storage profile '${profileName}'. Supported profiles: ${Object.keys(PROFILE_MAP$1).join(', ')}`);
+        }
+        const createOptions = {
+            ...options,
+            validate: options?.validate ?? true,
+        };
+        const provider = await factory.createResource(STORAGE_PROVIDER_FACTORY_BASE_TYPE, profileConfig, createOptions);
+        if (!provider) {
+            throw new Error(`Failed to create storage provider for profile '${profileName}'`);
+        }
+        return provider;
+    }
+}
+registerStorageProviderFactory('StorageProfile', StorageProfileFactory);
+
 const DEFAULT_DB_NAME$3 = 'naylence-secrets';
 const DEFAULT_STORE_NAME$1 = 'auto-master-key';
 const DEFAULT_KEY_ID$2 = 'master';
@@ -3738,6 +4157,11 @@ class IndexedDBStorageProvider extends EncryptedStorageProviderBase {
 }
 IndexedDBStorageProvider.supportedModes = new Set(['dx', 'hardened']);
 
+var indexeddbStorageProvider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    IndexedDBStorageProvider: IndexedDBStorageProvider
+});
+
 const globalScope$1 = globalThis;
 const nodeStack = globalScope$1.__naylenceNodeStack__ ?? (globalScope$1.__naylenceNodeStack__ = []);
 function getCurrentNode() {