meta-log-db/dist/browser/canvasl-browser.d.ts

Native database package for Meta-Log (ProLog, DataLog, R5RS)

/**
 * CanvasL Metaverse Browser - Unified Browser API for CanvasL Operations
 *
 * Provides a unified interface for CanvasL metaverse browser functionality,
 * consolidating implementations from template-projector and ui packages.
 *
 * Features:
 * - CanvasL/JSONL file loading and parsing
 * - ProLog, DataLog, SPARQL query execution
 * - R5RS function execution
 * - SHACL validation
 * - CanvasL object execution (rdf-triple, r5rs-call, sparql-construct, etc.)
 * - Browser-native with IndexedDB caching
 */
import type { MetaLogDbBrowser, BrowserConfig } from './database.js';
import type { Fact, Canvas, PrologQueryResult, DatalogQueryResult, SparqlQueryResult, ShaclValidationReport } from '../types/index.js';
/**
 * Configuration for CanvasL Metaverse Browser
 */
export interface CanvasLBrowserConfig extends BrowserConfig {
    enableEncryption?: boolean;
    mnemonic?: string;
    indexedDBName?: string;
    cacheStrategy?: 'memory' | 'indexeddb' | 'both';
    r5rsEngineURL?: string;
}
/**
 * Options for CanvasL queries
 */
export interface CanvasLQueryOptions {
    canvasFile?: string;
    timeout?: number;
    facts?: Fact[];
}
/**
 * Result of CanvasL object execution
 */
export interface CanvasLExecutionResult {
    type: string;
    result?: any;
    error?: string;
    object?: any;
}
/**
 * Unified CanvasL Metaverse Browser
 */
export declare class CanvasLMetaverseBrowser {
    private db;
    private initialized;
    private initPromise;
    private config;
    constructor(config?: CanvasLBrowserConfig);
    /**
     * Initialize browser database
     * Uses lazy initialization with promise-based pattern to prevent race conditions
     */
    init(): Promise<void>;
    private _doInit;
    /**
     * Load CanvasL/JSONL file from URL or path
     * Standardized parameter order: path (identifier), url (optional fetch location)
     */
    loadCanvas(path: string, url?: string): Promise<void>;
    /**
     * Parse JSONL canvas from URL without loading into database
     */
    parseJsonlCanvas(path: string, url?: string): Promise<Canvas>;
    /**
     * Parse CanvasL file from URL without loading into database
     */
    parseCanvasL(path: string, url?: string): Promise<Canvas>;
    /**
     * Extract facts from loaded canvas
     */
    extractFacts(canvasFile?: string): Fact[];
    /**
     * Convert facts to RDF triples
     */
    jsonlToRdf(facts?: Fact[]): any[];
    /**
     * Execute ProLog query
     */
    prologQuery(query: string, options?: CanvasLQueryOptions): Promise<PrologQueryResult>;
    /**
     * Execute DataLog query
     */
    datalogQuery(goal: string, program?: any, options?: CanvasLQueryOptions): Promise<DatalogQueryResult>;
    /**
     * Execute SPARQL query
     */
    sparqlQuery(query: string, options?: CanvasLQueryOptions): Promise<SparqlQueryResult>;
    /**
     * Validate with SHACL
     */
    validateShacl(shapes?: any, triples?: any[]): Promise<ShaclValidationReport>;
    /**
     * Execute R5RS function
     */
    executeR5RS(functionName: string, args?: any[]): Promise<any>;
    /**
     * Get R5RS function (if available)
     */
    getR5RSFunction(name: string): Promise<any>;
    /**
     * List R5RS functions
     */
    listR5RSFunctions(pattern?: string): Promise<string[]>;
    /**
     * Invoke R5RS function (alias for executeR5RS)
     */
    invokeR5RSFunction(name: string, args: any[], context?: any): Promise<any>;
    /**
     * Add ProLog rule
     */
    addPrologRule(rule: string): void;
    /**
     * Add DataLog rule
     */
    addDatalogRule(rule: string): void;
    /**
     * Store RDF triples
     */
    storeTriples(triples: any[]): void;
    /**
     * Add ProLog facts
     */
    addPrologFacts(facts: Fact[]): void;
    /**
     * Add DataLog facts
     */
    addDatalogFacts(facts: Fact[]): void;
    /**
     * Clear all data
     */
    clear(): Promise<void>;
    /**
     * Check if browser is initialized
     */
    isInitialized(): boolean;
    /**
     * Get the underlying database instance (for advanced usage)
     */
    getDb(): MetaLogDbBrowser | null;
    /**
     * Execute a CanvasL object
     * Supports: rdf-triple, r5rs-call, sparql-construct, prolog-query, datalog-query, shacl-validate, slide
     */
    executeCanvasLObject(obj: any): Promise<CanvasLExecutionResult>;
    /**
     * Execute RDF triple
     */
    private executeRdfTriple;
    /**
     * Execute R5RS function call
     */
    private executeR5RSCall;
    /**
     * Execute SPARQL CONSTRUCT query
     */
    private executeSparqlConstruct;
    /**
     * Execute ProLog query
     */
    private executePrologQuery;
    /**
     * Execute DataLog query
     */
    private executeDatalogQuery;
    /**
     * Execute SHACL validation
     */
    private executeShaclValidate;
    /**
     * Execute multiple CanvasL objects
     */
    executeCanvasLObjects(objects: any[]): Promise<{
        triples: any[];
        slides: any[];
        objects: Map<string, any>;
        errors: Array<{
            object: any;
            error: string;
        }>;
    }>;
}
//# sourceMappingURL=canvasl-browser.d.ts.map