@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/storage/accessors/SolidRdfDataAccessor.jsonld

@@ -18,18 +18,6 @@
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor_rdfEngine",
           "range": "undefineds:dist/storage/rdf/types.jsonld#RdfEngineLike"
         },
-        {
-          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor_legacyIndex",
-          "range": {
-            "@type": "ParameterRangeUnion",
-            "parameterRangeElements": [
-              "undefineds:dist/storage/rdf/ShadowRdfQuintStore.jsonld#ShadowRdfQuintStore",
-              {
-                "@type": "ParameterRangeUndefined"
-              }
-            ]
-          }
-        },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor_identifierStrategy",
           "range": "css:dist/util/identifiers/IdentifierStrategy.jsonld#IdentifierStrategy"
@@ -44,10 +32,6 @@
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_identifierStrategy",
           "memberFieldName": "identifierStrategy"
         },
-        {
-          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_legacyIndex",
-          "memberFieldName": "legacyIndex"
-        },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_logger",
           "memberFieldName": "logger",
@@ -56,8 +40,8 @@
           }
         },
         {
-          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_adapter",
-          "memberFieldName": "adapter"
+          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_sparqlAdapter",
+          "memberFieldName": "sparqlAdapter"
         },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_initialized",
@@ -115,6 +99,10 @@
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_deleteTextSource",
           "memberFieldName": "deleteTextSource"
         },
+        {
+          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_moveTextSource",
+          "memberFieldName": "moveTextSource"
+        },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_moveRdfSourceDocument",
           "memberFieldName": "moveRdfSourceDocument"
@@ -127,6 +115,10 @@
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_deleteVectorSource",
           "memberFieldName": "deleteVectorSource"
         },
+        {
+          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_moveVectorSource",
+          "memberFieldName": "moveVectorSource"
+        },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_deleteRdfSourceDocument",
           "memberFieldName": "deleteRdfSourceDocument"
@@ -144,16 +136,12 @@
           "memberFieldName": "getDataByGraphPrefix"
         },
         {
-          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_executeSparqlUpdate",
-          "memberFieldName": "executeSparqlUpdate"
+          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_prepareSparqlUpdate",
+          "memberFieldName": "prepareSparqlUpdate"
         },
         {
-          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_applyUpdateOperation",
-          "memberFieldName": "applyUpdateOperation"
-        },
-        {
-          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_deleteMaterialized",
-          "memberFieldName": "deleteMaterialized"
+          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_prepareEmbeddedSparqlUpdate",
+          "memberFieldName": "prepareEmbeddedSparqlUpdate"
         },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_getRelatedNames",
@@ -190,9 +178,6 @@
         },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor_identifierStrategy"
-        },
-        {
-          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor_legacyIndex"
         }
       ]
     }

package/dist/storage/rdf/LocalQleverNativeSparqlClient.d.ts

@@ -0,0 +1,55 @@
+import type { RdfNativeSparqlQueryOptions, RdfNativeSparqlResult } from './types';
+export type LocalQleverRuntimeErrorCode = 'qlever_runtime_unavailable' | 'qlever_runtime_protocol_error' | 'qlever_runtime_closed' | 'qlever_request_timeout' | 'qlever_request_aborted' | 'qlever_remote_error';
+export declare class LocalQleverRuntimeError extends Error {
+    readonly code: LocalQleverRuntimeErrorCode | string;
+    readonly cause?: unknown;
+    constructor(code: LocalQleverRuntimeErrorCode | string, message: string, cause?: unknown);
+}
+export interface LocalQleverNativeSparqlClientOptions {
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    expectedNativeSparqlAbiVersion?: number;
+    expectedPhysicalBackendAbiVersion?: number;
+    startupTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    maxStderrBytes?: number;
+}
+export declare function resolveLocalQleverRuntimeCommand(env?: NodeJS.ProcessEnv): string;
+export declare function requiresWindowsCommandShell(command: string, platform?: NodeJS.Platform): boolean;
+/**
+ * Persistent JSONL transport for the packaged Local QLever runtime.
+ *
+ * The runtime owns QLever and the SQLite physical provider. This client owns
+ * only process lifecycle, request correlation, cancellation, and native result
+ * envelope validation. It never parses or evaluates SPARQL.
+ */
+export declare class LocalQleverNativeSparqlClient {
+    private readonly options;
+    private child?;
+    private reader?;
+    private startup?;
+    private startPromise?;
+    private readonly pending;
+    private nextRequestId;
+    private stderrTail;
+    private ready;
+    private closed;
+    private failedProcessCleanup?;
+    constructor(options?: LocalQleverNativeSparqlClientOptions);
+    start(): Promise<void>;
+    query(sparql: string, options: RdfNativeSparqlQueryOptions): Promise<RdfNativeSparqlResult>;
+    close(): Promise<void>;
+    private waitForStart;
+    private handleLine;
+    private failProcess;
+    private awaitFailedProcessCleanup;
+    private cleanupPending;
+    private writeMessage;
+    private cancelRequest;
+    private appendStderr;
+    private runtimeUnavailable;
+    private startupTimeoutMs;
+    private requestTimeoutMs;
+}

package/dist/storage/rdf/LocalQleverNativeSparqlClient.js

@@ -0,0 +1,519 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalQleverNativeSparqlClient = exports.LocalQleverRuntimeError = void 0;
+exports.resolveLocalQleverRuntimeCommand = resolveLocalQleverRuntimeCommand;
+exports.requiresWindowsCommandShell = requiresWindowsCommandShell;
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = require("node:readline");
+class LocalQleverRuntimeError extends Error {
+    constructor(code, message, cause) {
+        super(message);
+        this.name = 'LocalQleverRuntimeError';
+        this.code = code;
+        this.cause = cause;
+    }
+}
+exports.LocalQleverRuntimeError = LocalQleverRuntimeError;
+const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_STDERR_BYTES = 64 * 1024;
+const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5_000;
+const FORCED_SHUTDOWN_TIMEOUT_MS = 5_000;
+const NATIVE_SPARQL_ABI_VERSION = 1;
+const PHYSICAL_BACKEND_ABI_VERSION = 7;
+const DEFAULT_LOCAL_QLEVER_RUNTIME_COMMAND = '/opt/xpod/qlever/bin/xpod_qlever_local_runtime';
+function resolveLocalQleverRuntimeCommand(env = process.env) {
+    const configured = env.XPOD_QLEVER_LOCAL_RUNTIME_COMMAND?.trim();
+    return configured || DEFAULT_LOCAL_QLEVER_RUNTIME_COMMAND;
+}
+function requiresWindowsCommandShell(command, platform = process.platform) {
+    return platform === 'win32' && /\.(?:cmd|bat)$/iu.test(command);
+}
+/**
+ * Persistent JSONL transport for the packaged Local QLever runtime.
+ *
+ * The runtime owns QLever and the SQLite physical provider. This client owns
+ * only process lifecycle, request correlation, cancellation, and native result
+ * envelope validation. It never parses or evaluates SPARQL.
+ */
+class LocalQleverNativeSparqlClient {
+    constructor(options = {}) {
+        this.pending = new Map();
+        this.nextRequestId = 1;
+        this.stderrTail = '';
+        this.ready = false;
+        this.closed = false;
+        this.options = {
+            ...options,
+            command: options.command?.trim() || resolveLocalQleverRuntimeCommand({
+                ...process.env,
+                ...options.env,
+            }),
+        };
+        if (!isPositiveInteger(options.expectedNativeSparqlAbiVersion ?? NATIVE_SPARQL_ABI_VERSION)) {
+            throw new TypeError('Local QLever native SPARQL ABI version must be a positive integer');
+        }
+        if (!isPositiveInteger(options.expectedPhysicalBackendAbiVersion ?? PHYSICAL_BACKEND_ABI_VERSION)) {
+            throw new TypeError('Local QLever physical backend ABI version must be a positive integer');
+        }
+    }
+    start() {
+        if (this.closed) {
+            return Promise.reject(new LocalQleverRuntimeError('qlever_runtime_closed', 'Local QLever runtime client is closed'));
+        }
+        if (this.ready && this.child) {
+            return Promise.resolve();
+        }
+        if (this.startPromise) {
+            return this.startPromise;
+        }
+        this.stderrTail = '';
+        this.startPromise = new Promise((resolve, reject) => {
+            let child;
+            try {
+                child = (0, node_child_process_1.spawn)(this.options.command, this.options.args ?? [], {
+                    cwd: this.options.cwd,
+                    env: this.options.env ? { ...process.env, ...this.options.env } : process.env,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    windowsHide: true,
+                    shell: requiresWindowsCommandShell(this.options.command),
+                });
+            }
+            catch (error) {
+                this.startPromise = undefined;
+                reject(this.runtimeUnavailable('Failed to start Local QLever runtime', error));
+                return;
+            }
+            this.child = child;
+            this.reader = (0, node_readline_1.createInterface)({ input: child.stdout });
+            const timeout = setTimeout(() => {
+                this.failProcess(child, this.runtimeUnavailable(`Local QLever runtime did not become ready within ${this.startupTimeoutMs()}ms`));
+            }, this.startupTimeoutMs());
+            this.startup = { child, resolve, reject, timeout };
+            this.reader.on('line', (line) => this.handleLine(child, line));
+            child.stderr.setEncoding('utf8');
+            child.stderr.on('data', (chunk) => this.appendStderr(chunk));
+            child.stdin.on('error', (error) => {
+                this.failProcess(child, this.runtimeUnavailable('Local QLever runtime stdin failed', error));
+            });
+            child.once('error', (error) => {
+                this.failProcess(child, this.runtimeUnavailable('Local QLever runtime process failed', error));
+            });
+            // `close` fires after stdio has drained. Waiting for it preserves the
+            // runtime's final stderr diagnostics in the error returned to callers.
+            child.once('close', (code, signal) => {
+                const detail = signal ? `signal ${signal}` : `code ${String(code)}`;
+                this.failProcess(child, this.runtimeUnavailable(`Local QLever runtime exited with ${detail}`));
+            });
+        });
+        return this.startPromise;
+    }
+    async query(sparql, options) {
+        if (options.signal?.aborted) {
+            throw abortError(options.signal);
+        }
+        validateNativeSparqlQueryOptions(options);
+        await this.waitForStart(options.signal);
+        if (options.signal?.aborted) {
+            throw abortError(options.signal);
+        }
+        const child = this.child;
+        if (!child || !this.ready) {
+            throw this.runtimeUnavailable('Local QLever runtime is unavailable');
+        }
+        const id = String(this.nextRequestId++);
+        const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs();
+        const wireOptions = {
+            basePath: options.basePath,
+            ...(options.sourceUri === undefined ? {} : { sourceUri: options.sourceUri }),
+            ...(options.defaultDataset === undefined ? {} : { defaultDataset: options.defaultDataset }),
+            ...(options.operation === undefined ? {} : { operation: options.operation }),
+            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+            ...(options.acceptMediaType === undefined ? {} : { acceptMediaType: options.acceptMediaType }),
+            ...(options.loadDocument === undefined ? {} : { loadDocument: options.loadDocument }),
+            ...(options.accessScope === undefined ? {} : { accessScope: options.accessScope }),
+            ...(options.vectorQuery === undefined ? {} : { vectorQuery: options.vectorQuery }),
+        };
+        return new Promise((resolve, reject) => {
+            const pending = { resolve, reject };
+            if (timeoutMs > 0) {
+                pending.timeout = setTimeout(() => {
+                    if (!this.pending.delete(id)) {
+                        return;
+                    }
+                    this.cleanupPending(pending);
+                    this.cancelRequest(child, id);
+                    reject(new LocalQleverRuntimeError('qlever_request_timeout', `Local QLever request ${id} timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }
+            if (options.signal) {
+                pending.signal = options.signal;
+                pending.abortHandler = () => {
+                    if (!this.pending.delete(id)) {
+                        return;
+                    }
+                    this.cleanupPending(pending);
+                    this.cancelRequest(child, id);
+                    reject(abortError(options.signal));
+                };
+                options.signal.addEventListener('abort', pending.abortHandler, { once: true });
+            }
+            this.pending.set(id, pending);
+            try {
+                this.writeMessage(child, {
+                    id,
+                    type: 'query',
+                    sparql,
+                    options: wireOptions,
+                });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                this.cleanupPending(pending);
+                reject(this.runtimeUnavailable('Failed to write Local QLever request', error));
+            }
+        });
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        const child = this.child;
+        if (!child) {
+            await this.awaitFailedProcessCleanup();
+            return;
+        }
+        try {
+            this.writeMessage(child, { type: 'shutdown' });
+            child.stdin.end();
+        }
+        catch {
+            // Closing is best-effort; failProcess below owns deterministic cleanup.
+        }
+        const closed = waitForChildClose(child);
+        this.failProcess(child, new LocalQleverRuntimeError('qlever_runtime_closed', 'Local QLever runtime client closed'), false);
+        if (await waitForCloseOrTimeout(closed, GRACEFUL_SHUTDOWN_TIMEOUT_MS)) {
+            return;
+        }
+        if (child.exitCode === null && child.signalCode === null) {
+            child.kill('SIGTERM');
+        }
+        if (await waitForCloseOrTimeout(closed, FORCED_SHUTDOWN_TIMEOUT_MS)) {
+            return;
+        }
+        await forceCloseChild(child, closed);
+    }
+    async waitForStart(signal) {
+        const started = this.start();
+        if (!signal) {
+            return started;
+        }
+        if (signal.aborted) {
+            throw abortError(signal);
+        }
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                cleanup();
+                reject(abortError(signal));
+            };
+            const cleanup = () => signal.removeEventListener('abort', onAbort);
+            signal.addEventListener('abort', onAbort, { once: true });
+            started.then(() => {
+                cleanup();
+                resolve();
+            }, (error) => {
+                cleanup();
+                reject(error);
+            });
+        });
+    }
+    handleLine(child, line) {
+        if (child !== this.child) {
+            return;
+        }
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch (error) {
+            this.failProcess(child, new LocalQleverRuntimeError('qlever_runtime_protocol_error', `Local QLever runtime emitted malformed JSON: ${formatOffendingStdoutLine(line)}`, error));
+            return;
+        }
+        if (!this.ready) {
+            const expectedNativeAbi = this.options.expectedNativeSparqlAbiVersion ?? NATIVE_SPARQL_ABI_VERSION;
+            const expectedBackendAbi = this.options.expectedPhysicalBackendAbiVersion ?? PHYSICAL_BACKEND_ABI_VERSION;
+            if (!isReadyMessage(message)
+                || message.abiVersion !== expectedNativeAbi
+                || message.physicalBackendAbiVersion !== expectedBackendAbi) {
+                this.failProcess(child, new LocalQleverRuntimeError('qlever_runtime_protocol_error', `Local QLever runtime ready contract mismatch; expected native SPARQL ABI ${expectedNativeAbi} and physical backend ABI ${expectedBackendAbi}`));
+                return;
+            }
+            this.ready = true;
+            const startup = this.startup;
+            if (startup?.child === child) {
+                clearTimeout(startup.timeout);
+                this.startup = undefined;
+                startup.resolve();
+            }
+            return;
+        }
+        if (isResultMessage(message)) {
+            const pending = this.pending.get(message.id);
+            if (!pending) {
+                return;
+            }
+            this.pending.delete(message.id);
+            this.cleanupPending(pending);
+            pending.resolve(message.result);
+            return;
+        }
+        if (isErrorMessage(message)) {
+            const pending = this.pending.get(message.id);
+            if (!pending) {
+                return;
+            }
+            this.pending.delete(message.id);
+            this.cleanupPending(pending);
+            pending.reject(new LocalQleverRuntimeError(message.code || 'qlever_remote_error', message.message || 'Local QLever runtime rejected the request'));
+            return;
+        }
+        this.failProcess(child, new LocalQleverRuntimeError('qlever_runtime_protocol_error', `Local QLever runtime emitted an invalid protocol message: ${formatOffendingStdoutLine(line)}`));
+    }
+    failProcess(child, error, terminate = true) {
+        if (child !== this.child) {
+            return;
+        }
+        this.child = undefined;
+        const closed = reapChild(child);
+        this.failedProcessCleanup = terminate ? terminateChild(child, closed) : closed;
+        this.ready = false;
+        this.startPromise = undefined;
+        this.reader?.close();
+        this.reader = undefined;
+        const startup = this.startup;
+        if (startup?.child === child) {
+            clearTimeout(startup.timeout);
+            this.startup = undefined;
+            startup.reject(error);
+        }
+        for (const [id, pending] of this.pending) {
+            this.pending.delete(id);
+            this.cleanupPending(pending);
+            pending.reject(error);
+        }
+        void this.failedProcessCleanup;
+    }
+    async awaitFailedProcessCleanup() {
+        const failedProcessCleanup = this.failedProcessCleanup;
+        if (!failedProcessCleanup) {
+            return;
+        }
+        try {
+            await failedProcessCleanup;
+        }
+        finally {
+            if (this.failedProcessCleanup === failedProcessCleanup) {
+                this.failedProcessCleanup = undefined;
+            }
+        }
+    }
+    cleanupPending(pending) {
+        if (pending.timeout) {
+            clearTimeout(pending.timeout);
+        }
+        if (pending.signal && pending.abortHandler) {
+            pending.signal.removeEventListener('abort', pending.abortHandler);
+        }
+    }
+    writeMessage(child, value) {
+        if (child !== this.child || child.stdin.destroyed || !child.stdin.writable) {
+            throw this.runtimeUnavailable('Local QLever runtime stdin is unavailable');
+        }
+        child.stdin.write(`${JSON.stringify(value)}\n`, 'utf8');
+    }
+    cancelRequest(child, id) {
+        try {
+            this.writeMessage(child, { type: 'cancel', id });
+        }
+        catch {
+            // The process lifecycle handler rejects every remaining request when the
+            // runtime is gone. Cancellation must not mask the caller's own outcome.
+        }
+    }
+    appendStderr(chunk) {
+        this.stderrTail += chunk;
+        const maxBytes = this.options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES;
+        while (Buffer.byteLength(this.stderrTail, 'utf8') > maxBytes && this.stderrTail.length > 0) {
+            this.stderrTail = this.stderrTail.slice(Math.max(1, Math.floor(this.stderrTail.length / 8)));
+        }
+    }
+    runtimeUnavailable(message, cause) {
+        const stderr = this.stderrTail.trim();
+        return new LocalQleverRuntimeError('qlever_runtime_unavailable', stderr ? `${message}: ${stderr}` : message, cause);
+    }
+    startupTimeoutMs() {
+        return this.options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+    }
+    requestTimeoutMs() {
+        return this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    }
+}
+exports.LocalQleverNativeSparqlClient = LocalQleverNativeSparqlClient;
+function reapChild(child) {
+    const closed = waitForChildClose(child);
+    closed.then(undefined, () => undefined);
+    return closed;
+}
+async function terminateChild(child, closed) {
+    if (child.exitCode === null && child.signalCode === null) {
+        child.kill('SIGTERM');
+    }
+    if (await waitForCloseOrTimeout(closed, GRACEFUL_SHUTDOWN_TIMEOUT_MS)) {
+        return;
+    }
+    await forceCloseChild(child, closed);
+}
+async function forceCloseChild(child, closed) {
+    if (child.exitCode === null && child.signalCode === null) {
+        child.kill('SIGKILL');
+    }
+    if (await waitForCloseOrTimeout(closed, FORCED_SHUTDOWN_TIMEOUT_MS)) {
+        return;
+    }
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.stderr.destroy();
+}
+function waitForChildClose(child) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => child.once('close', () => resolve()));
+}
+async function waitForCloseOrTimeout(closed, timeoutMs) {
+    let timeout;
+    const expired = new Promise((resolve) => {
+        timeout = setTimeout(() => resolve(false), timeoutMs);
+        timeout.unref?.();
+    });
+    const didClose = await Promise.race([closed.then(() => true), expired]);
+    if (timeout) {
+        clearTimeout(timeout);
+    }
+    return didClose;
+}
+function formatOffendingStdoutLine(line) {
+    const normalized = line.replace(/[\r\n]/gu, ' ');
+    const maxLength = 240;
+    return normalized.length <= maxLength
+        ? JSON.stringify(normalized)
+        : JSON.stringify(`${normalized.slice(0, maxLength)}…`);
+}
+function isReadyMessage(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const message = value;
+    return message.type === 'ready'
+        && message.backend === 'sqlite'
+        && isPositiveInteger(message.abiVersion)
+        && isPositiveInteger(message.physicalBackendAbiVersion);
+}
+function isResultMessage(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const message = value;
+    return typeof message.id === 'string'
+        && message.type === 'result'
+        && isNativeResult(message.result);
+}
+function isErrorMessage(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const message = value;
+    return typeof message.id === 'string'
+        && message.type === 'error'
+        && (message.code === undefined || typeof message.code === 'string')
+        && (message.message === undefined || typeof message.message === 'string');
+}
+function isNativeResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const result = value;
+    return (result.status === 'ok' || result.status === 'unsupported' || result.status === 'error')
+        && typeof result.mediaType === 'string'
+        && typeof result.body === 'string'
+        && (result.error === undefined || typeof result.error === 'string');
+}
+function abortError(signal) {
+    return signal.reason ?? new LocalQleverRuntimeError('qlever_request_aborted', 'Local QLever request was aborted');
+}
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function validateNativeSparqlQueryOptions(options) {
+    if (options.sourceUri !== undefined && !nonEmptyString(options.sourceUri)) {
+        throw new TypeError('Native SPARQL sourceUri must be a non-empty string when provided');
+    }
+    if (options.defaultDataset !== undefined &&
+        options.defaultDataset !== 'physical' &&
+        options.defaultDataset !== 'exactSource' &&
+        options.defaultDataset !== 'scopedUnion') {
+        throw new TypeError('Native SPARQL defaultDataset must be physical, exactSource, or scopedUnion');
+    }
+    if (options.defaultDataset === 'exactSource' && options.sourceUri === undefined) {
+        throw new TypeError('Native SPARQL exactSource defaultDataset requires sourceUri');
+    }
+    if (options.defaultDataset === 'scopedUnion' && options.sourceUri !== undefined) {
+        throw new TypeError('Native SPARQL scopedUnion defaultDataset cannot use sourceUri');
+    }
+    if (options.vectorQuery !== undefined) {
+        validateVectorQuery(options.vectorQuery);
+    }
+}
+function validateVectorQuery(vectorQuery) {
+    if (!Array.isArray(vectorQuery.embedding) || vectorQuery.embedding.length === 0) {
+        throw new TypeError('Native SPARQL vectorQuery.embedding must be a non-empty finite number array');
+    }
+    if (!vectorQuery.embedding.every((value) => typeof value === 'number' && Number.isFinite(value))) {
+        throw new TypeError('Native SPARQL vectorQuery.embedding must contain only finite numbers');
+    }
+    if (!isVectorMetric(vectorQuery.metric)) {
+        throw new TypeError('Native SPARQL vectorQuery.metric must be cosine, dot, or euclidean');
+    }
+    for (const field of ['provider', 'model', 'modelVersion', 'inputKind', 'projectionPolicyVersion']) {
+        if (!nonEmptyString(vectorQuery[field])) {
+            throw new TypeError(`Native SPARQL vectorQuery.${field} is required`);
+        }
+    }
+    if (!isPositiveInteger(vectorQuery.limit)) {
+        throw new TypeError('Native SPARQL vectorQuery.limit must be a positive integer');
+    }
+    if (vectorQuery.threshold !== undefined &&
+        (typeof vectorQuery.threshold !== 'number' || !Number.isFinite(vectorQuery.threshold))) {
+        throw new TypeError('Native SPARQL vectorQuery.threshold must be finite when provided');
+    }
+    if (vectorQuery.retrievalPointVariable !== undefined &&
+        !nonEmptyString(vectorQuery.retrievalPointVariable)) {
+        throw new TypeError('Native SPARQL vectorQuery.retrievalPointVariable must be non-empty when provided');
+    }
+    if (vectorQuery.resourceVariable !== undefined &&
+        !nonEmptyString(vectorQuery.resourceVariable)) {
+        throw new TypeError('Native SPARQL vectorQuery.resourceVariable must be non-empty when provided');
+    }
+    if (vectorQuery.retrievalPointVariable === undefined &&
+        vectorQuery.resourceVariable === undefined) {
+        throw new TypeError('Native SPARQL vectorQuery requires retrievalPointVariable or resourceVariable');
+    }
+}
+function isVectorMetric(value) {
+    return value === 'cosine' || value === 'dot' || value === 'euclidean';
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+//# sourceMappingURL=LocalQleverNativeSparqlClient.js.map