ai-database 2.1.1 → 2.3.0

package/dist/schema/index.js

@@ -30,23 +30,55 @@
  *
  * @packageDocumentation
  */
-import { DBPromise, wrapEntityOperations, setSchemaRelationInfo } from '../ai-promise-db.js';
+import { DBPromise, wrapEntityOperations, setSchemaRelationInfo, } from '../ai-promise-db.js';
+import { logError } from '../logger.js';
 // Re-export parse functions
 export { parseOperator, parseField, parseSchema, isPrimitiveType } from './parse.js';
-export { setProvider, resolveProvider, hasSemanticSearch, hasHybridSearch, hasEventsAPI, hasActionsAPI, hasArtifactsAPI, hasEmbeddingsConfig, } from './provider.js';
+// Re-export seed functions
+export { loadSeedData, fetchSeedData, parseDelimitedData, mapSeedDataToRecords } from './seed.js';
+export { setProvider, resolveProvider, hasSemanticSearch, hasHybridSearch, hasEventsAPI, hasActionsAPI, hasArtifactsAPI, hasEmbeddingsConfig, hasTransactionSupport, } from './provider.js';
+// Import resolve functions used internally
+import { isPromptField } from './resolve.js';
 // Re-export resolve functions
-export { isEntityId, inferTypeFromField, resolveContextPath, resolveInstructions, prefetchContext, isPromptField, resolveNestedPending, resolveReferenceSpec, hydrateEntity, } from './resolve.js';
+export { isEntityId, inferTypeFromField, resolveContextPath, resolveInstructions, prefetchContext, prefetchContextPaths, isPromptField, resolveNestedPending, resolveReferenceSpec, hydrateEntity, } from './resolve.js';
 // Re-export cascade functions
-export { generateContextAwareValue, generateAIFields, generateEntity, resolveForwardExact, generateNaturalLanguageContent, } from './cascade.js';
+export { generateContextAwareValue, generateAIFields, generateEntity, resolveForwardExact, generateNaturalLanguageContent, 
+// AI generation configuration
+configureAIGeneration, getAIGenerationConfig, 
+// Value generator configuration
+setValueGenerator, getValueGenerator, } from './cascade.js';
 // Re-export semantic functions
 export { resolveBackwardFuzzy, resolveForwardFuzzy } from './semantic.js';
+// Re-export NL query generator functions
+export { createDefaultNLQueryGenerator, matchesFilter, applyFilters } from './nl-query-generator.js';
+// Re-export entity operations
+export { createEntityOperations, createEdgeEntityOperations, createNounEntityOperations, createVerbEntityOperations, } from './entity-operations.js';
+// Re-export NL query functions
+export { buildNLQueryContext, executeNLQuery, createNLQueryFn, setNLQueryGenerator, getNLQueryGenerator, } from './nl-query.js';
+// Re-export dependency graph functions
+export { buildDependencyGraph, topologicalSort, detectCycles, getParallelGroups, getAllDependencies, hasCycles, visualizeGraph, CircularDependencyError, PRIMITIVE_TYPES, } from './dependency-graph.js';
+// Re-export union fallback functions
+export { parseUnionTypes, parseUnionThresholds, searchUnionTypes, createProviderSearcher, } from './union-fallback.js';
+// Re-export generation context
+export { GenerationContext, createGenerationContext, ContextOverflowError, } from './generation-context.js';
+// Re-export schema versioning functions
+export { computeSchemaHash, getSchemaVersion, setSchemaVersion, hasSchemaChanged, } from './version.js';
+// Re-export schema diff functions
+export { diffSchemas, describeDiff, } from './diff.js';
+// Re-export migration functions
+export { defineMigration, runMigrations, getPendingMigrations, rollbackLastMigration, } from './migration.js';
+// Re-export verb derivation functions
+export { FORWARD_TO_REVERSE, BIDIRECTIONAL_PAIRS, deriveReverseVerb, fieldNameToVerb, isPassiveVerb, registerVerbPair, registerBidirectionalPair, registerFieldVerb, } from './verb-derivation.js';
 import { Verbs, parseUrl } from '../types.js';
 import { inferNoun, getTypeMeta, conjugate } from '../linguistic.js';
 import { parseSchema } from './parse.js';
 import { resolveProvider, hasSemanticSearch, hasHybridSearch, hasEventsAPI, hasActionsAPI, hasArtifactsAPI, hasEmbeddingsConfig, } from './provider.js';
 import { hydrateEntity, resolveReferenceSpec } from './resolve.js';
-import { resolveForwardExact, generateAIFields, generateContextAwareValue, generateNaturalLanguageContent } from './cascade.js';
-import { resolveBackwardFuzzy, resolveForwardFuzzy } from './semantic.js';
+import { resolveForwardExact, generateAIFields, generateContextAwareValue, generateNaturalLanguageContent, generateEntity, setValueGenerator, } from './cascade.js';
+import { resolveBackwardFuzzy, resolveForwardFuzzy, getFuzzyThreshold } from './semantic.js';
+// Import from extracted modules for use in DB() factory
+import { createEntityOperations, createEdgeEntityOperations, createNounEntityOperations, createVerbEntityOperations, } from './entity-operations.js';
+import { createNLQueryFn } from './nl-query.js';
 // =============================================================================
 // Noun/Verb Helpers
 // =============================================================================
@@ -224,439 +256,8 @@ function schemaToProperties(schema) {
     }
     return properties;
 }
-// =============================================================================
-// Natural Language Query Implementation
-// =============================================================================
-let nlQueryGenerator = null;
-/**
- * Set the AI generator for natural language queries
- */
-export function setNLQueryGenerator(generator) {
-    nlQueryGenerator = generator;
-}
-function buildNLQueryContext(schema, targetType) {
-    const types = [];
-    for (const [name, entity] of schema.entities) {
-        const fields = [];
-        const relationships = [];
-        for (const [fieldName, field] of entity.fields) {
-            if (field.isRelation && field.relatedType) {
-                relationships.push({
-                    name: fieldName,
-                    to: field.relatedType,
-                    cardinality: field.isArray ? 'many' : 'one',
-                });
-            }
-            else {
-                fields.push(fieldName);
-            }
-        }
-        const meta = getTypeMeta(name);
-        types.push({
-            name,
-            singular: meta.singular,
-            plural: meta.plural,
-            fields,
-            relationships,
-        });
-    }
-    return { types, targetType };
-}
-async function executeNLQuery(question, schema, targetType) {
-    if (!nlQueryGenerator) {
-        const provider = await resolveProvider();
-        const results = [];
-        // Simple heuristic for common "list all" patterns in fallback mode
-        const lowerQuestion = question.toLowerCase().trim();
-        const isListAllQuery = /^(show|list|get|find|display)\s+(all|every|the)?\s*/i.test(lowerQuestion) ||
-            lowerQuestion === '' ||
-            /\ball\b/i.test(lowerQuestion);
-        if (targetType) {
-            if (isListAllQuery) {
-                // For "show all X" queries, just list everything
-                const listResults = await provider.list(targetType);
-                results.push(...listResults);
-            }
-            else {
-                const searchResults = await provider.search(targetType, question);
-                results.push(...searchResults);
-            }
-        }
-        else {
-            for (const [typeName] of schema.entities) {
-                if (isListAllQuery) {
-                    const listResults = await provider.list(typeName);
-                    results.push(...listResults);
-                }
-                else {
-                    const searchResults = await provider.search(typeName, question);
-                    results.push(...searchResults);
-                }
-            }
-        }
-        return {
-            interpretation: `Search for "${question}"`,
-            confidence: 0.5,
-            results,
-            explanation: 'Fallback to keyword search (no AI generator configured)',
-        };
-    }
-    const context = buildNLQueryContext(schema, targetType);
-    const plan = await nlQueryGenerator(question, context);
-    const provider = await resolveProvider();
-    const results = [];
-    for (const typeName of plan.types) {
-        let typeResults;
-        if (plan.search) {
-            typeResults = await provider.search(typeName, plan.search, {
-                where: plan.filters,
-            });
-        }
-        else {
-            typeResults = await provider.list(typeName, {
-                where: plan.filters,
-            });
-        }
-        results.push(...typeResults);
-    }
-    return {
-        interpretation: plan.interpretation,
-        confidence: plan.confidence,
-        results,
-        query: JSON.stringify({ types: plan.types, filters: plan.filters, search: plan.search }),
-    };
-}
-function createNLQueryFn(schema, typeName) {
-    return async (strings, ...values) => {
-        const question = strings.reduce((acc, str, i) => {
-            return acc + str + (values[i] !== undefined ? String(values[i]) : '');
-        }, '');
-        return executeNLQuery(question, schema, typeName);
-    };
-}
-// =============================================================================
-// Edge Entity Operations
-// =============================================================================
-function createEdgeEntityOperations(schemaEdgeRecords, getProvider) {
-    async function getRuntimeEdges() {
-        try {
-            const provider = await getProvider();
-            const runtimeEdges = await provider.list('Edge');
-            return runtimeEdges;
-        }
-        catch {
-            return [];
-        }
-    }
-    async function getAllEdges() {
-        const runtimeEdges = await getRuntimeEdges();
-        const runtimeEdgeKeys = new Set(runtimeEdges.map(e => `${e.from}:${e.name}`));
-        const filteredSchemaEdges = schemaEdgeRecords.filter(e => {
-            const key = `${e.from}:${e.name}`;
-            const hasRuntimeVersion = runtimeEdgeKeys.has(key);
-            if (hasRuntimeVersion && e.matchMode === 'fuzzy') {
-                return false;
-            }
-            return !hasRuntimeVersion;
-        });
-        return [...filteredSchemaEdges, ...runtimeEdges];
-    }
-    return {
-        async get(id) {
-            const runtimeEdges = await getRuntimeEdges();
-            const runtimeMatch = runtimeEdges.find(e => e.$id === id || `${e.from}:${e.name}` === id);
-            if (runtimeMatch)
-                return { ...runtimeMatch, $type: 'Edge' };
-            return schemaEdgeRecords.find(e => `${e.from}:${e.name}` === id) ?? null;
-        },
-        async list(options) {
-            let results = await getAllEdges();
-            if (options?.where) {
-                for (const [key, value] of Object.entries(options.where)) {
-                    results = results.filter(e => e[key] === value);
-                }
-            }
-            return results.map(e => ({
-                ...e,
-                $id: e.$id || `${e.from}:${e.name}`,
-                $type: 'Edge',
-            }));
-        },
-        async find(where) {
-            let results = await getAllEdges();
-            for (const [key, value] of Object.entries(where)) {
-                results = results.filter(e => e[key] === value);
-            }
-            return results.map(e => ({
-                ...e,
-                $id: e.$id || `${e.from}:${e.name}`,
-                $type: 'Edge',
-            }));
-        },
-        async search(query) {
-            const allEdges = await getAllEdges();
-            const queryLower = query.toLowerCase();
-            return allEdges
-                .filter(e => String(e.from).toLowerCase().includes(queryLower) ||
-                String(e.name).toLowerCase().includes(queryLower) ||
-                String(e.to).toLowerCase().includes(queryLower))
-                .map(e => ({
-                ...e,
-                $id: e.$id || `${e.from}:${e.name}`,
-                $type: 'Edge',
-            }));
-        },
-        async create() {
-            throw new Error('Cannot manually create Edge records - they are auto-generated');
-        },
-        async update() {
-            throw new Error('Cannot manually update Edge records - they are auto-generated');
-        },
-        async upsert() {
-            throw new Error('Cannot manually upsert Edge records - they are auto-generated');
-        },
-        async delete() {
-            throw new Error('Cannot manually delete Edge records - they are auto-generated');
-        },
-        async forEach(optionsOrCallback, maybeCallback) {
-            const options = typeof optionsOrCallback === 'function' ? undefined : optionsOrCallback;
-            const callback = typeof optionsOrCallback === 'function' ? optionsOrCallback : maybeCallback;
-            const items = await this.list(options);
-            for (const item of items) {
-                await callback(item);
-            }
-        },
-        async semanticSearch() {
-            return [];
-        },
-        async hybridSearch() {
-            return [];
-        },
-    };
-}
-// =============================================================================
-// Entity Operations Factory
-// =============================================================================
-function createEntityOperations(typeName, entity, schema) {
-    return {
-        async get(id) {
-            const provider = await resolveProvider();
-            const result = await provider.get(typeName, id);
-            if (!result)
-                return null;
-            return hydrateEntity(result, entity, schema, resolveProvider);
-        },
-        async list(options) {
-            const provider = await resolveProvider();
-            const results = await provider.list(typeName, options);
-            return Promise.all(results.map((r) => hydrateEntity(r, entity, schema, resolveProvider)));
-        },
-        async find(where) {
-            const provider = await resolveProvider();
-            const results = await provider.list(typeName, {
-                where: where,
-            });
-            return Promise.all(results.map((r) => hydrateEntity(r, entity, schema, resolveProvider)));
-        },
-        async search(query, options) {
-            const provider = await resolveProvider();
-            const results = await provider.search(typeName, query, options);
-            return Promise.all(results.map((r) => hydrateEntity(r, entity, schema, resolveProvider)));
-        },
-        async create(idOrData, maybeData) {
-            const provider = await resolveProvider();
-            const providedId = typeof idOrData === 'string' ? idOrData : undefined;
-            const data = typeof idOrData === 'string'
-                ? maybeData
-                : idOrData;
-            const entityId = providedId || crypto.randomUUID();
-            const { data: resolvedData, pendingRelations } = await resolveForwardExact(typeName, data, entity, schema, provider, entityId);
-            const { data: fuzzyResolvedData, pendingRelations: fuzzyPendingRelations } = await resolveForwardFuzzy(typeName, resolvedData, entity, schema, provider, entityId);
-            const backwardResolvedData = await resolveBackwardFuzzy(typeName, fuzzyResolvedData, entity, schema, provider);
-            const finalData = await generateAIFields(backwardResolvedData, typeName, entity, schema, provider);
-            const result = await provider.create(typeName, entityId, finalData);
-            for (const rel of pendingRelations) {
-                await provider.relate(typeName, entityId, rel.fieldName, rel.targetType, rel.targetId);
-            }
-            const createdEdgeIds = new Set();
-            for (const rel of fuzzyPendingRelations) {
-                await provider.relate(typeName, entityId, rel.fieldName, rel.targetType, rel.targetId, {
-                    matchMode: 'fuzzy',
-                    similarity: rel.similarity
-                });
-                const edgeId = `${typeName}:${rel.fieldName}:${entityId}:${rel.targetId}`;
-                if (!createdEdgeIds.has(edgeId)) {
-                    createdEdgeIds.add(edgeId);
-                    try {
-                        await provider.create('Edge', edgeId, {
-                            from: typeName,
-                            name: rel.fieldName,
-                            to: rel.targetType,
-                            direction: 'forward',
-                            matchMode: 'fuzzy',
-                            similarity: rel.similarity,
-                            fromId: entityId,
-                            toId: rel.targetId,
-                        });
-                    }
-                    catch {
-                        // Edge already exists
-                    }
-                }
-            }
-            return hydrateEntity(result, entity, schema, resolveProvider);
-        },
-        async update(id, data) {
-            const provider = await resolveProvider();
-            const result = await provider.update(typeName, id, data);
-            return hydrateEntity(result, entity, schema, resolveProvider);
-        },
-        async upsert(id, data) {
-            const provider = await resolveProvider();
-            const existing = await provider.get(typeName, id);
-            if (existing) {
-                const result = await provider.update(typeName, id, data);
-                return hydrateEntity(result, entity, schema, resolveProvider);
-            }
-            const result = await provider.create(typeName, id, data);
-            return hydrateEntity(result, entity, schema, resolveProvider);
-        },
-        async delete(id) {
-            const provider = await resolveProvider();
-            return provider.delete(typeName, id);
-        },
-        async forEach(optionsOrCallback, maybeCallback) {
-            const options = typeof optionsOrCallback === 'function' ? undefined : optionsOrCallback;
-            const callback = typeof optionsOrCallback === 'function'
-                ? optionsOrCallback
-                : maybeCallback;
-            const items = await this.list(options);
-            for (const item of items) {
-                await callback(item);
-            }
-        },
-        async semanticSearch(query, options) {
-            const provider = await resolveProvider();
-            if (hasSemanticSearch(provider)) {
-                const results = await provider.semanticSearch(typeName, query, options);
-                return Promise.all(results.map((r) => ({
-                    ...hydrateEntity(r, entity, schema, resolveProvider),
-                    $score: r.$score,
-                })));
-            }
-            return [];
-        },
-        async hybridSearch(query, options) {
-            const provider = await resolveProvider();
-            if (hasHybridSearch(provider)) {
-                const results = await provider.hybridSearch(typeName, query, options);
-                return Promise.all(results.map((r) => ({
-                    ...hydrateEntity(r, entity, schema, resolveProvider),
-                    $rrfScore: r.$rrfScore,
-                    $ftsRank: r.$ftsRank,
-                    $semanticRank: r.$semanticRank,
-                    $score: r.$score,
-                })));
-            }
-            return [];
-        },
-        async draft(data, options) {
-            const draftData = { ...data, $phase: 'draft' };
-            const refs = {};
-            for (const [fieldName, field] of entity.fields) {
-                if (draftData[fieldName] !== undefined && draftData[fieldName] !== null) {
-                    continue;
-                }
-                if (field.operator && field.relatedType) {
-                    const matchMode = field.matchMode ?? (field.operator.includes('~') ? 'fuzzy' : 'exact');
-                    if (field.isArray) {
-                        const generatedText = generateNaturalLanguageContent(fieldName, field.prompt, field.relatedType, data);
-                        draftData[fieldName] = generatedText;
-                        const refSpec = {
-                            field: fieldName,
-                            operator: field.operator,
-                            type: field.relatedType,
-                            matchMode,
-                            resolved: false,
-                            prompt: field.prompt,
-                            generatedText,
-                        };
-                        refs[fieldName] = [refSpec];
-                        if (options?.stream && options.onChunk) {
-                            options.onChunk(generatedText);
-                        }
-                    }
-                    else {
-                        const generatedText = generateNaturalLanguageContent(fieldName, field.prompt, field.relatedType, data);
-                        draftData[fieldName] = generatedText;
-                        refs[fieldName] = {
-                            field: fieldName,
-                            operator: field.operator,
-                            type: field.relatedType,
-                            matchMode,
-                            resolved: false,
-                            prompt: field.prompt,
-                            generatedText,
-                        };
-                        if (options?.stream && options.onChunk) {
-                            options.onChunk(generatedText);
-                        }
-                    }
-                }
-            }
-            draftData.$refs = refs;
-            return draftData;
-        },
-        async resolve(draft, options) {
-            // Draft<T> interface requires $phase: 'draft', so we can access it directly
-            if (draft.$phase !== 'draft') {
-                throw new Error('Cannot resolve entity: not a draft (missing $phase: "draft")');
-            }
-            const provider = await resolveProvider();
-            const resolved = { ...draft };
-            const errors = [];
-            delete resolved.$refs;
-            resolved.$phase = 'resolved';
-            const refs = draft.$refs;
-            for (const [fieldName, refSpec] of Object.entries(refs)) {
-                try {
-                    if (Array.isArray(refSpec)) {
-                        const resolvedIds = [];
-                        for (const spec of refSpec) {
-                            const resolvedId = await resolveReferenceSpec(spec, resolved, schema, provider, generateContextAwareValue);
-                            if (resolvedId) {
-                                resolvedIds.push(resolvedId);
-                                options?.onResolved?.(fieldName, resolvedId);
-                            }
-                        }
-                        resolved[fieldName] = resolvedIds;
-                    }
-                    else {
-                        const resolvedId = await resolveReferenceSpec(refSpec, resolved, schema, provider, generateContextAwareValue);
-                        if (resolvedId) {
-                            resolved[fieldName] = resolvedId;
-                            options?.onResolved?.(fieldName, resolvedId);
-                        }
-                    }
-                }
-                catch (err) {
-                    const errorMsg = err instanceof Error ? err.message : String(err);
-                    if (options?.onError === 'skip') {
-                        errors.push({ field: fieldName, error: errorMsg });
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-            }
-            if (errors.length > 0 || options?.onError === 'skip') {
-                // resolved is typed as Record<string, unknown>, so we can assign $errors directly
-                resolved.$errors = errors;
-            }
-            return resolved;
-        },
-    };
-}
+// Note: NL Query functions extracted to nl-query.ts
+// Note: Edge Entity Operations extracted to entity-operations.ts
 // =============================================================================
 // DB Factory
 // =============================================================================
@@ -665,23 +266,199 @@ function createEntityOperations(typeName, entity, schema) {
  */
 export function DB(schema, options) {
     const parsedSchema = parseSchema(schema);
-    // Add Edge entity to the parsed schema
+    // Add system entities to the parsed schema (Noun, Verb, Edge)
+    // Noun entity - represents type definitions
+    const nounEntity = {
+        name: 'Noun',
+        fields: new Map([
+            [
+                'name',
+                { name: 'name', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
+            [
+                'singular',
+                { name: 'singular', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
+            [
+                'plural',
+                { name: 'plural', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
+            [
+                'slug',
+                { name: 'slug', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
+            [
+                'slugPlural',
+                {
+                    name: 'slugPlural',
+                    type: 'string',
+                    isArray: false,
+                    isOptional: false,
+                    isRelation: false,
+                },
+            ],
+            [
+                'description',
+                {
+                    name: 'description',
+                    type: 'string',
+                    isArray: false,
+                    isOptional: true,
+                    isRelation: false,
+                },
+            ],
+            [
+                'properties',
+                { name: 'properties', type: 'json', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'relationships',
+                {
+                    name: 'relationships',
+                    type: 'json',
+                    isArray: false,
+                    isOptional: true,
+                    isRelation: false,
+                },
+            ],
+            [
+                'actions',
+                { name: 'actions', type: 'json', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'events',
+                { name: 'events', type: 'json', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'metadata',
+                { name: 'metadata', type: 'json', isArray: false, isOptional: true, isRelation: false },
+            ],
+        ]),
+    };
+    parsedSchema.entities.set('Noun', nounEntity);
+    // Verb entity - represents action definitions
+    const verbEntity = {
+        name: 'Verb',
+        fields: new Map([
+            [
+                'action',
+                { name: 'action', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
+            [
+                'actor',
+                { name: 'actor', type: 'string', isArray: false, isOptional: true, isRelation: false },
+            ],
+            ['act', { name: 'act', type: 'string', isArray: false, isOptional: true, isRelation: false }],
+            [
+                'activity',
+                { name: 'activity', type: 'string', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'result',
+                { name: 'result', type: 'string', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'reverse',
+                { name: 'reverse', type: 'json', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'inverse',
+                { name: 'inverse', type: 'string', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'description',
+                {
+                    name: 'description',
+                    type: 'string',
+                    isArray: false,
+                    isOptional: true,
+                    isRelation: false,
+                },
+            ],
+        ]),
+    };
+    parsedSchema.entities.set('Verb', verbEntity);
+    // Edge entity - represents relationships
     const edgeEntity = {
         name: 'Edge',
         fields: new Map([
-            ['from', { name: 'from', type: 'string', isArray: false, isOptional: false, isRelation: false }],
-            ['name', { name: 'name', type: 'string', isArray: false, isOptional: false, isRelation: false }],
+            [
+                'from',
+                { name: 'from', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
+            [
+                'name',
+                { name: 'name', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
             ['to', { name: 'to', type: 'string', isArray: false, isOptional: false, isRelation: false }],
-            ['backref', { name: 'backref', type: 'string', isArray: false, isOptional: true, isRelation: false }],
-            ['cardinality', { name: 'cardinality', type: 'string', isArray: false, isOptional: false, isRelation: false }],
-            ['direction', { name: 'direction', type: 'string', isArray: false, isOptional: false, isRelation: false }],
-            ['matchMode', { name: 'matchMode', type: 'string', isArray: false, isOptional: true, isRelation: false }],
+            [
+                'backref',
+                { name: 'backref', type: 'string', isArray: false, isOptional: true, isRelation: false },
+            ],
+            [
+                'cardinality',
+                {
+                    name: 'cardinality',
+                    type: 'string',
+                    isArray: false,
+                    isOptional: false,
+                    isRelation: false,
+                },
+            ],
+            [
+                'direction',
+                { name: 'direction', type: 'string', isArray: false, isOptional: false, isRelation: false },
+            ],
+            [
+                'matchMode',
+                { name: 'matchMode', type: 'string', isArray: false, isOptional: true, isRelation: false },
+            ],
         ]),
     };
     parsedSchema.entities.set('Edge', edgeEntity);
+    // Create local getProvider function for dependency injection
+    // If options.provider is provided, use it; otherwise fall back to global resolveProvider()
+    let cachedProvider = null;
+    let providerPromise = null;
+    async function getProvider() {
+        // Return cached provider if available
+        if (cachedProvider)
+            return cachedProvider;
+        // Return pending promise if resolution is in progress
+        if (providerPromise)
+            return providerPromise;
+        // Check if options.provider is provided (dependency injection)
+        if (options?.provider) {
+            providerPromise = (async () => {
+                const providerOption = options.provider;
+                if (typeof providerOption === 'function') {
+                    // It's a factory function - call it
+                    const result = providerOption();
+                    // Handle both sync and async factory functions
+                    cachedProvider = result instanceof Promise ? await result : result;
+                }
+                else {
+                    // It's a direct provider instance
+                    cachedProvider = providerOption;
+                }
+                return cachedProvider;
+            })();
+            return providerPromise;
+        }
+        // Fall back to global resolveProvider()
+        providerPromise = resolveProvider().then((p) => {
+            cachedProvider = p;
+            return p;
+        });
+        return providerPromise;
+    }
+    // Configure value generator if provided
+    if (options?.valueGenerator) {
+        setValueGenerator(options.valueGenerator);
+    }
     // Configure provider with embeddings settings if provided
     if (options?.embeddings) {
-        resolveProvider().then(provider => {
+        getProvider().then((provider) => {
             if (hasEmbeddingsConfig(provider)) {
                 provider.setEmbeddingsConfig(options.embeddings);
             }
@@ -690,11 +467,27 @@ export function DB(schema, options) {
     // Collect all edge records from the schema
     const allEdgeRecords = [];
     for (const [entityName, entity] of parsedSchema.entities) {
-        if (entityName !== 'Edge') {
+        // Only create edge records for user-defined entities (not system entities)
+        if (entityName !== 'Edge' && entityName !== 'Noun' && entityName !== 'Verb') {
             const edgeRecords = createEdgeRecords(entityName, schema[entityName] ?? {}, entity);
             allEdgeRecords.push(...edgeRecords);
         }
     }
+    // Collect all noun records from the schema (user-defined entities only)
+    const allNounRecords = [];
+    for (const [entityName, entity] of parsedSchema.entities) {
+        // Only create noun records for user-defined entities (not system entities)
+        if (entityName !== 'Edge' && entityName !== 'Noun' && entityName !== 'Verb') {
+            const nounRecord = createNounRecord(entityName, schema[entityName]);
+            allNounRecords.push(nounRecord);
+        }
+    }
+    // Collect all verb records from the standard verbs
+    const allVerbRecords = Object.values(Verbs).map((verb) => ({
+        ...verb,
+        $id: verb.action,
+        $type: 'Verb',
+    }));
     // Build and set schema relation info for batch loading
     // Maps entityType -> fieldName -> relatedType
     const relationInfo = new Map();
@@ -714,7 +507,7 @@ export function DB(schema, options) {
     // This API adapts DBAction to ForEachActionsAPI interface
     const actionsAPI = {
         async create(data) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 const action = await provider.createAction(data);
                 return { id: action.id };
@@ -722,35 +515,45 @@ export function DB(schema, options) {
             throw new Error('Provider does not support actions');
         },
         async get(id) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 const action = await provider.getAction(id);
                 if (!action)
                     return null;
                 // Adapt DBAction to ForEachActionState
-                return {
+                const state = {
                     id: action.id,
                     type: action.action ?? action.type ?? 'unknown',
                     status: action.status,
-                    progress: action.progress,
-                    total: action.total,
                     data: action.objectData ?? {},
-                    result: action.result,
-                    error: action.error,
                 };
+                if (action.progress !== undefined)
+                    state.progress = action.progress;
+                if (action.total !== undefined)
+                    state.total = action.total;
+                if (action.result !== undefined)
+                    state.result = action.result;
+                if (action.error !== undefined)
+                    state.error = action.error;
+                return state;
             }
             return null;
         },
         async update(id, updates) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
-                await provider.updateAction(id, {
-                    status: updates.status,
-                    progress: updates.progress,
-                    // ForEachResult needs to be converted to Record<string, unknown> for DBAction.result
-                    result: updates.result,
-                    error: updates.error,
-                });
+                const updatePayload = {};
+                if (updates.status !== undefined)
+                    updatePayload.status = updates.status;
+                if (updates.progress !== undefined)
+                    updatePayload.progress = updates.progress;
+                if (updates.error !== undefined)
+                    updatePayload.error = updates.error;
+                // ForEachResult needs to be converted to Record<string, unknown> for DBAction.result
+                if (updates.result !== undefined) {
+                    updatePayload.result = updates.result;
+                }
+                await provider.updateAction(id, updatePayload);
                 return;
             }
             throw new Error('Provider does not support actions');
@@ -771,12 +574,13 @@ export function DB(schema, options) {
     function emitInternalEventForOps(eventType, data) {
         const handlers = eventHandlersForOps.get(eventType);
         if (handlers) {
-            for (const handler of handlers) {
+            const snapshot = [...handlers];
+            for (const handler of snapshot) {
                 try {
                     handler(data);
                 }
                 catch (e) {
-                    console.error(`Error in event handler for ${eventType}:`, e);
+                    logError(`Error in event handler for ${eventType}:`, e);
                 }
             }
         }
@@ -798,10 +602,23 @@ export function DB(schema, options) {
     }
     for (const [entityName, entity] of parsedSchema.entities) {
         if (entityName === 'Edge') {
-            const edgeOps = createEdgeEntityOperations(allEdgeRecords, resolveProvider);
+            // Edge entity - auto-generated from schema relationships
+            const edgeOps = createEdgeEntityOperations(allEdgeRecords, getProvider);
             const wrappedEdgeOps = wrapEntityOperations(entityName, edgeOps, actionsAPI);
             entityOperations[entityName] = makeCallableEntityOps(wrappedEdgeOps, entityName);
         }
+        else if (entityName === 'Noun') {
+            // Noun entity - auto-generated from schema entity types
+            const nounOps = createNounEntityOperations(allNounRecords);
+            const wrappedNounOps = wrapEntityOperations(entityName, nounOps, actionsAPI);
+            entityOperations[entityName] = makeCallableEntityOps(wrappedNounOps, entityName);
+        }
+        else if (entityName === 'Verb') {
+            // Verb entity - standard verbs with conjugation forms
+            const verbOps = createVerbEntityOperations(allVerbRecords);
+            const wrappedVerbOps = wrapEntityOperations(entityName, verbOps, actionsAPI);
+            entityOperations[entityName] = makeCallableEntityOps(wrappedVerbOps, entityName);
+        }
         else {
             const baseOps = createEntityOperations(entityName, entity, parsedSchema);
             const wrappedOps = wrapEntityOperations(entityName, baseOps, actionsAPI);
@@ -813,7 +630,7 @@ export function DB(schema, options) {
                     throw new Error(`Draft method not available for ${entityName}`);
                 }
                 const draft = await draftMethod(data, options);
-                draft.$type = entityName;
+                draft['$type'] = entityName;
                 emitInternalEventForOps('draft', draft);
                 return draft;
             };
@@ -824,7 +641,8 @@ export function DB(schema, options) {
                 }
                 const resolved = await resolveMethod(draft, options);
                 if (resolved && typeof resolved === 'object') {
-                    resolved.$type = entityName;
+                    ;
+                    resolved['$type'] = entityName;
                 }
                 emitInternalEventForOps('resolve', resolved);
                 return resolved;
@@ -848,27 +666,57 @@ export function DB(schema, options) {
                     const draft = await draftFn(data);
                     return draft;
                 }
+                // Check if entity has reference fields that need two-phase processing
+                const entityDef = parsedSchema.entities.get(entityName);
                 const effectiveMaxDepth = options?.maxDepth ?? (options?.cascade ? 3 : 0);
+                // Disable auto-generation when:
+                // 1. cascade is explicitly set to false
+                // 2. cascade is true but maxDepth is 0 (depth exhausted)
+                // When cascade is undefined, single-level array generation is allowed
+                const cascadeExplicitlyDisabled = options?.cascade === false || (options?.cascade === true && effectiveMaxDepth === 0);
+                const hasReferenceFields = entityDef &&
+                    Array.from(entityDef.fields.values()).some((field) => {
+                        if (!field.operator || !field.relatedType)
+                            return false;
+                        // Exclude forward fuzzy (~>) - handled by resolveForwardFuzzy in the direct create path
+                        if (field.operator === '~>')
+                            return false;
+                        // For forward exact (->) array fields when cascade is explicitly disabled
+                        if (field.operator === '->' && field.isArray && cascadeExplicitlyDisabled) {
+                            return false;
+                        }
+                        return true;
+                    });
+                // Cascade takes priority over two-phase processing when enabled
+                // Cascade handles generating related entities through the graph
                 if (options?.cascade && effectiveMaxDepth > 0) {
-                    const provider = await resolveProvider();
+                    const provider = await getProvider();
                     const entityDef = parsedSchema.entities.get(entityName);
                     if (entityDef) {
                         // CreateEntityOptions now includes _cascadeState as an optional property
                         const cascadeState = options._cascadeState ?? {
                             totalEntitiesCreated: 0,
                             initialMaxDepth: effectiveMaxDepth,
-                            rootOnProgress: options.onProgress,
-                            rootOnError: options.onError,
-                            stopOnError: options.stopOnError,
-                            cascadeTypes: options.cascadeTypes,
+                            ...(options.onProgress !== undefined && { rootOnProgress: options.onProgress }),
+                            ...(options.onError !== undefined && { rootOnError: options.onError }),
+                            ...(options.stopOnError !== undefined && { stopOnError: options.stopOnError }),
+                            ...(options.cascadeTypes !== undefined && { cascadeTypes: options.cascadeTypes }),
                         };
                         const currentDepth = cascadeState.initialMaxDepth - effectiveMaxDepth;
                         const cascadeData = { ...data };
+                        // Emit progress for current entity being generated
+                        cascadeState.rootOnProgress?.({
+                            phase: 'generating',
+                            depth: currentDepth,
+                            currentType: entityName,
+                            totalEntitiesCreated: cascadeState.totalEntitiesCreated,
+                        });
                         for (const [fieldName, field] of entityDef.fields) {
                             if (cascadeData[fieldName] !== undefined)
                                 continue;
                             if (field.operator === '->' && field.relatedType) {
-                                if (cascadeState.cascadeTypes && !cascadeState.cascadeTypes.includes(field.relatedType)) {
+                                if (cascadeState.cascadeTypes &&
+                                    !cascadeState.cascadeTypes.includes(field.relatedType)) {
                                     continue;
                                 }
                                 const relatedEntity = parsedSchema.entities.get(field.relatedType);
@@ -882,39 +730,48 @@ export function DB(schema, options) {
                                         totalEntitiesCreated: cascadeState.totalEntitiesCreated,
                                     });
                                     const childEntityData = {};
-                                    const parentInstructions = entityDef.schema?.$instructions;
-                                    const childInstructions = relatedEntity.schema?.$instructions;
+                                    const parentInstructions = entityDef.schema?.['$instructions'];
+                                    const childInstructions = relatedEntity.schema?.['$instructions'];
                                     const contextParts = [];
                                     if (parentInstructions)
                                         contextParts.push(parentInstructions);
                                     if (childInstructions)
                                         contextParts.push(childInstructions);
                                     for (const [key, value] of Object.entries(cascadeData)) {
-                                        if (!key.startsWith('$') && !key.startsWith('_') && typeof value === 'string' && value) {
+                                        if (!key.startsWith('$') &&
+                                            !key.startsWith('_') &&
+                                            typeof value === 'string' &&
+                                            value) {
                                             contextParts.push(`${key}: ${value}`);
                                         }
                                     }
                                     const fullContext = contextParts.join(' | ');
                                     for (const [childFieldName, childField] of relatedEntity.fields) {
-                                        if (!childField.isRelation && childField.type === 'string') {
-                                            childEntityData[childFieldName] = generateContextAwareValue(childFieldName, field.relatedType, fullContext, undefined, cascadeData);
+                                        const isPrompt = isPromptField(childField);
+                                        if (!childField.isRelation && (childField.type === 'string' || isPrompt)) {
+                                            // Use field type as hint for prompt fields
+                                            const fieldHint = isPrompt ? childField.type : undefined;
+                                            childEntityData[childFieldName] = generateContextAwareValue(childFieldName, field.relatedType, fullContext, fieldHint, cascadeData);
                                         }
                                     }
                                     const childOptions = {
                                         ...options,
+                                        cascade: true, // Ensure cascade continues for child entities
                                         maxDepth: effectiveMaxDepth - 1,
                                         _cascadeState: cascadeState,
                                     };
                                     const relatedOps = entityOperations[field.relatedType];
-                                    const createFn = relatedOps?.create;
-                                    const childEntity = createFn ? await createFn(childEntityData, childOptions) : undefined;
-                                    if (childEntity?.$id) {
+                                    const createFn = relatedOps?.['create'];
+                                    const childEntity = createFn
+                                        ? await createFn(childEntityData, childOptions)
+                                        : undefined;
+                                    if (childEntity?.['$id']) {
                                         cascadeState.totalEntitiesCreated++;
                                         if (field.isArray) {
-                                            cascadeData[fieldName] = [childEntity.$id];
+                                            cascadeData[fieldName] = [childEntity['$id']];
                                         }
                                         else {
-                                            cascadeData[fieldName] = childEntity.$id;
+                                            cascadeData[fieldName] = childEntity['$id'];
                                         }
                                     }
                                 }
@@ -926,12 +783,13 @@ export function DB(schema, options) {
                                 }
                             }
                         }
+                        const createFn = originalCreate;
                         let result;
                         if (id) {
-                            result = await originalCreate.call(wrappedOps, id, cascadeData);
+                            result = await createFn.call(wrappedOps, id, cascadeData);
                         }
                         else {
-                            result = await originalCreate.call(wrappedOps, cascadeData);
+                            result = await createFn.call(wrappedOps, cascadeData);
                         }
                         cascadeState.totalEntitiesCreated++;
                         if (currentDepth === 0) {
@@ -944,8 +802,78 @@ export function DB(schema, options) {
                         return result;
                     }
                 }
-                return originalCreate.call(wrappedOps, ...args);
+                // Use two-phase draft/resolve pipeline when entity has reference fields (but cascade not enabled)
+                if (hasReferenceFields) {
+                    // Phase 1: Draft - create placeholder with natural language refs
+                    // Skip promptless refs when cascade is not explicitly enabled (default behavior = no auto-generation)
+                    const skipPromptless = options?.cascade !== true;
+                    const draft = await draftFn(data, { _skipPromptlessRefs: skipPromptless });
+                    // Phase 2: Resolve - convert refs to actual entity IDs
+                    const resolved = await resolveFn(draft);
+                    // Extract clean data for persistence (remove $phase, $refs, $errors)
+                    const { $phase, $refs, $errors, $type, ...cleanData } = resolved;
+                    // Phase 3: Generate AI fields for entities with $context dependencies
+                    // The draft phase skips prompt fields for entities with $context because
+                    // those fields need pre-fetched context data to generate properly.
+                    // generateAIFields handles this context pre-fetching and field generation.
+                    const provider = await getProvider();
+                    const entityDefForAI = parsedSchema.entities.get(entityName);
+                    let finalCleanData = cleanData;
+                    if (entityDefForAI) {
+                        finalCleanData = await generateAIFields(cleanData, entityName, entityDefForAI, parsedSchema, provider);
+                    }
+                    const createFn = originalCreate;
+                    let result;
+                    if (id) {
+                        result = await createFn.call(wrappedOps, id, finalCleanData);
+                    }
+                    else {
+                        result = await createFn.call(wrappedOps, finalCleanData);
+                    }
+                    return result;
+                }
+                // Pre-initialize empty arrays for ->Type[] fields when cascade is explicitly disabled
+                // This prevents resolveForwardExact from auto-generating entities for array fields
+                let processedData = data;
+                if (cascadeExplicitlyDisabled && entityDef) {
+                    processedData = { ...data };
+                    for (const [fieldName, field] of entityDef.fields) {
+                        if (processedData[fieldName] !== undefined)
+                            continue;
+                        if (field.isArray && field.operator === '->' && field.relatedType) {
+                            processedData[fieldName] = [];
+                        }
+                    }
+                }
+                // Call with properly typed arguments (already extracted above)
+                // Use type assertion for internal overload dispatch via .call()
+                const createFnFinal = originalCreate;
+                if (id) {
+                    return createFnFinal.call(wrappedOps, id, processedData, options);
+                }
+                return createFnFinal.call(wrappedOps, processedData, options);
             };
+            // Add seed method if entity has seed configuration
+            if (entity.seedConfig) {
+                const seedConfig = entity.seedConfig;
+                wrappedOps['seed'] = async () => {
+                    const { loadSeedData } = await import('./seed.js');
+                    const records = await loadSeedData(seedConfig);
+                    const provider = await getProvider();
+                    for (const record of records) {
+                        const { $id, ...data } = record;
+                        // Upsert: check if exists, then update or create
+                        const existing = await provider.get(entityName, $id);
+                        if (existing) {
+                            await provider.update(entityName, $id, data);
+                        }
+                        else {
+                            await provider.create(entityName, $id, data);
+                        }
+                    }
+                    return { count: records.length };
+                };
+            }
             // Make the entity operations callable as a tagged template literal
             entityOperations[entityName] = makeCallableEntityOps(wrappedOps, entityName);
         }
@@ -970,12 +898,12 @@ export function DB(schema, options) {
     const db = {
         $schema: parsedSchema,
         async get(url) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             const parsed = parseUrl(url);
             return provider.get(parsed.type, parsed.id);
         },
         async search(query, options) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             const results = [];
             for (const [typeName] of parsedSchema.entities) {
                 const typeResults = await provider.search(typeName, query, options);
@@ -984,7 +912,7 @@ export function DB(schema, options) {
             return results;
         },
         async semanticSearch(query, options) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             const results = [];
             if (hasSemanticSearch(provider)) {
                 for (const [typeName] of parsedSchema.entities) {
@@ -997,13 +925,19 @@ export function DB(schema, options) {
             return results.slice(0, limit);
         },
         async count(type, where) {
-            const provider = await resolveProvider();
-            const results = await provider.list(type, { where });
+            const provider = await getProvider();
+            const listOpts = {};
+            if (where !== undefined)
+                listOpts.where = where;
+            const results = await provider.list(type, listOpts);
             return results.length;
         },
         async forEach(options, callback) {
-            const provider = await resolveProvider();
-            const results = await provider.list(options.type, { where: options.where });
+            const provider = await getProvider();
+            const listOpts = {};
+            if (options.where !== undefined)
+                listOpts.where = options.where;
+            const results = await provider.list(options.type, listOpts);
             const concurrency = options.concurrency ?? 1;
             if (concurrency === 1) {
                 for (const entity of results) {
@@ -1017,7 +951,7 @@ export function DB(schema, options) {
             }
         },
         async set(type, id, data) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             const existing = await provider.get(type, id);
             if (existing) {
                 return provider.update(type, id, data);
@@ -1025,7 +959,7 @@ export function DB(schema, options) {
             return provider.create(type, id, data);
         },
         async generate(options) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (options.mode === 'background') {
                 const { createMemoryProvider } = await import('../memory-provider.js');
                 const memProvider = provider;
@@ -1047,7 +981,7 @@ export function DB(schema, options) {
     const events = {
         on(pattern, handler) {
             let unsubscribe = () => { };
-            resolveProvider().then((provider) => {
+            getProvider().then((provider) => {
                 if (hasEventsAPI(provider)) {
                     unsubscribe = provider.on(pattern, handler);
                 }
@@ -1055,7 +989,7 @@ export function DB(schema, options) {
             return () => unsubscribe();
         },
         async emit(optionsOrType, data) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasEventsAPI(provider)) {
                 // The provider.emit has overloads: (options: CreateEventOptions) or (type: string, data: unknown)
                 if (typeof optionsOrType === 'string') {
@@ -1065,36 +999,45 @@ export function DB(schema, options) {
             }
             const now = new Date();
             if (typeof optionsOrType === 'string') {
-                return {
+                const baseEvent = {
                     id: crypto.randomUUID(),
                     actor: 'system',
                     event: optionsOrType,
-                    objectData: data,
                     timestamp: now,
                 };
+                if (data !== undefined)
+                    baseEvent.objectData = data;
+                return baseEvent;
             }
-            return {
+            const baseEvent = {
                 id: crypto.randomUUID(),
                 actor: optionsOrType.actor,
-                actorData: optionsOrType.actorData,
                 event: optionsOrType.event,
-                object: optionsOrType.object,
-                objectData: optionsOrType.objectData,
-                result: optionsOrType.result,
-                resultData: optionsOrType.resultData,
-                meta: optionsOrType.meta,
                 timestamp: now,
             };
+            if (optionsOrType.actorData !== undefined)
+                baseEvent.actorData = optionsOrType.actorData;
+            if (optionsOrType.object !== undefined)
+                baseEvent.object = optionsOrType.object;
+            if (optionsOrType.objectData !== undefined)
+                baseEvent.objectData = optionsOrType.objectData;
+            if (optionsOrType.result !== undefined)
+                baseEvent.result = optionsOrType.result;
+            if (optionsOrType.resultData !== undefined)
+                baseEvent.resultData = optionsOrType.resultData;
+            if (optionsOrType.meta !== undefined)
+                baseEvent.meta = optionsOrType.meta;
+            return baseEvent;
         },
         async list(options) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasEventsAPI(provider)) {
                 return provider.listEvents(options);
             }
             return [];
         },
         async replay(options) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasEventsAPI(provider)) {
                 await provider.replayEvents(options);
             }
@@ -1103,42 +1046,42 @@ export function DB(schema, options) {
     // Create Actions API (public version with full DBAction types)
     const actions = {
         async create(options) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 return provider.createAction(options);
             }
             throw new Error('Provider does not support actions');
         },
         async get(id) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 return provider.getAction(id);
             }
             return null;
         },
         async update(id, updates) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 return provider.updateAction(id, updates);
             }
             throw new Error('Provider does not support actions');
         },
         async list(options) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 return provider.listActions(options);
             }
             return [];
         },
         async retry(id) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 return provider.retryAction(id);
             }
             throw new Error('Provider does not support actions');
         },
         async cancel(id) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasActionsAPI(provider)) {
                 await provider.cancelAction(id);
             }
@@ -1148,26 +1091,26 @@ export function DB(schema, options) {
     // Create Artifacts API
     const artifacts = {
         async get(url, type) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasArtifactsAPI(provider)) {
                 return provider.getArtifact(url, type);
             }
             return null;
         },
         async set(url, type, data) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasArtifactsAPI(provider)) {
                 await provider.setArtifact(url, type, data);
             }
         },
         async delete(url, type) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasArtifactsAPI(provider)) {
                 await provider.deleteArtifact(url, type);
             }
         },
         async list(url) {
-            const provider = await resolveProvider();
+            const provider = await getProvider();
             if (hasArtifactsAPI(provider)) {
                 return provider.listArtifacts(url);
             }