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

package/dist/solidfs/LocalRdfAuthorityRecoveryInitializer.d.ts

@@ -0,0 +1,15 @@
+import { Initializer, type FileIdentifierMapper, type Finalizable } from '@solid/community-server';
+import type { LocalRdfIndexAccessor } from '../storage/accessors/MixDataAccessor';
+import { RootedSolidFsSyncJournal } from './SolidFsSyncJournal';
+/** Restores the derived Local RDF index from its authority files before workers start. */
+export declare class LocalRdfAuthorityRecoveryInitializer extends Initializer implements Finalizable {
+    private readonly journal;
+    private readonly index;
+    private readonly resourceMapper;
+    private readonly baseUrl;
+    private readonly rootFilePath;
+    protected readonly logger: import("global-logger-factory").Logger<unknown>;
+    constructor(journal: RootedSolidFsSyncJournal, index: LocalRdfIndexAccessor, resourceMapper: FileIdentifierMapper, baseUrl: string, rootFilePath: string);
+    handle(): Promise<void>;
+    finalize(): Promise<void>;
+}

package/dist/solidfs/LocalRdfAuthorityRecoveryInitializer.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRdfAuthorityRecoveryInitializer = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const global_logger_factory_1 = require("global-logger-factory");
+const community_server_1 = require("@solid/community-server");
+const RdfContentTypes_1 = require("../storage/rdf/RdfContentTypes");
+const RdfIndexSolidFsSyncer_1 = require("./RdfIndexSolidFsSyncer");
+/** Restores the derived Local RDF index from its authority files before workers start. */
+class LocalRdfAuthorityRecoveryInitializer extends community_server_1.Initializer {
+    constructor(journal, index, resourceMapper, baseUrl, rootFilePath) {
+        super();
+        this.journal = journal;
+        this.index = index;
+        this.resourceMapper = resourceMapper;
+        this.baseUrl = baseUrl;
+        this.rootFilePath = rootFilePath;
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+    }
+    async handle() {
+        const root = node_path_1.default.resolve(this.rootFilePath);
+        const syncer = new RdfIndexSolidFsSyncer_1.RdfIndexSolidFsSyncer({ index: this.index });
+        await this.journal.bootstrapWorkspace({
+            workspace: this.baseUrl,
+            cwd: root,
+            projection: 'direct',
+            source: 'filesystem',
+            shouldTrackPath: RdfContentTypes_1.isLineAddressableRdfPath,
+            resolveResource: async (absolutePath) => (await this.resourceMapper.mapFilePathToUrl(absolutePath, false)).identifier.path,
+        });
+        const replay = await this.journal.replayPending(syncer);
+        const retryable = this.journal.listOperations(['failed_retryable']).length;
+        const reconcileRequired = this.journal.listOperations(['reconcile_required']).length;
+        if (retryable > 0 || reconcileRequired > 0) {
+            throw new Error(`Local RDF authority recovery left ${retryable} retryable and ${reconcileRequired} reconcile-required operations`);
+        }
+        await this.journal.compact();
+        this.logger.info(`Recovered local RDF authority index: ${replay.completed} completed, ${replay.attempted} attempted.`);
+    }
+    async finalize() {
+        this.journal.close();
+    }
+}
+exports.LocalRdfAuthorityRecoveryInitializer = LocalRdfAuthorityRecoveryInitializer;
+//# sourceMappingURL=LocalRdfAuthorityRecoveryInitializer.js.map

package/dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld

@@ -0,0 +1,99 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^8.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@undefineds.co/xpod",
+  "components": [
+    {
+      "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer",
+      "@type": "Class",
+      "requireElement": "LocalRdfAuthorityRecoveryInitializer",
+      "extends": [
+        "css:dist/init/Initializer.jsonld#Initializer",
+        "css:dist/init/final/Finalizable.jsonld#Finalizable"
+      ],
+      "comment": "Restores the derived Local RDF index from its authority files before workers start.",
+      "parameters": [
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_baseUrl",
+          "range": "xsd:string"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_rootFilePath",
+          "range": "xsd:string"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_journal",
+          "range": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#RootedSolidFsSyncJournal"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_index",
+          "range": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#LocalRdfIndexAccessor"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_resourceMapper",
+          "range": "css:dist/storage/mapping/FileIdentifierMapper.jsonld#FileIdentifierMapper"
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_journal",
+          "memberFieldName": "journal"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_index",
+          "memberFieldName": "index"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_resourceMapper",
+          "memberFieldName": "resourceMapper"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_baseUrl",
+          "memberFieldName": "baseUrl"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_rootFilePath",
+          "memberFieldName": "rootFilePath"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_logger",
+          "memberFieldName": "logger",
+          "range": {
+            "@type": "ParameterRangeWildcard"
+          }
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_handle",
+          "memberFieldName": "handle"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer__member_finalize",
+          "memberFieldName": "finalize"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_journal"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_index"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_resourceMapper"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_baseUrl"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/LocalRdfAuthorityRecoveryInitializer.jsonld#LocalRdfAuthorityRecoveryInitializer_rootFilePath"
+        }
+      ]
+    }
+  ]
+}

package/dist/solidfs/RdfIndexSolidFsSyncer.js

@@ -284,25 +284,43 @@ class RdfIndexSolidFsSyncer {
         if (!this.textIndex && !this.vectorIndex) {
             return;
         }
+        let shouldIndexText = options.nextTextSearchIndexable;
+        let shouldIndexVector = options.nextVectorIndexable;
         let text;
         if (previousSource) {
             if (this.textIndex) {
-                if (options.previousTextSearchIndexable) {
+                if (options.previousTextSearchIndexable && options.nextTextSearchIndexable) {
+                    const moved = await this.textIndex.moveSource(previousSource, nextSource);
+                    shouldIndexText = moved === 0;
+                    if (shouldIndexText) {
+                        await this.textIndex.deleteSource(previousSource);
+                    }
+                }
+                if (options.previousTextSearchIndexable && !options.nextTextSearchIndexable) {
                     await this.textIndex.deleteSource(previousSource);
                 }
             }
             if (this.vectorIndex && options.previousVectorIndexable) {
-                await this.vectorIndex.deleteSource(previousSource);
+                if (options.nextVectorIndexable) {
+                    const moved = await this.vectorIndex.moveSource(previousSource, nextSource);
+                    shouldIndexVector = moved === 0;
+                    if (shouldIndexVector) {
+                        await this.vectorIndex.deleteSource(previousSource);
+                    }
+                }
+                else {
+                    await this.vectorIndex.deleteSource(previousSource);
+                }
             }
         }
         if (!options.nextTextSearchIndexable && !options.nextVectorIndexable) {
             return;
         }
-        if (this.textIndex && options.nextTextSearchIndexable) {
+        if (this.textIndex && shouldIndexText) {
             text ??= await (0, promises_1.readFile)(change.sourcePath, 'utf8');
             await this.textIndex.indexText(nextSource, text, isRdfChange(change) ? await (0, RdfTextProjection_1.createRdfEntityTextChunksFromText)(nextSource, text) : undefined);
         }
-        if (this.vectorIndex && this.vectorizeText && options.nextVectorIndexable) {
+        if (this.vectorIndex && this.vectorizeText && shouldIndexVector) {
             text ??= await (0, promises_1.readFile)(change.sourcePath, 'utf8');
             const chunks = await this.vectorizeText({ ...nextSource, text });
             await this.vectorIndex.indexVector(nextSource, chunks);

package/dist/solidfs/SolidFsSyncJournal.d.ts

@@ -1,3 +1,4 @@
+import type { LocalRdfAuthorityJournal } from '../storage/accessors/MixDataAccessor';
 import type { SolidFsChange, SolidFsEntrySource, SolidFsManifest, SolidFsPrepareInput, SolidFsProjection, SolidFsSyncer } from './types';
 export type SolidFsSyncJournalStage = 'local_committed' | 'failed_retryable' | 'failed_permanent' | 'reconcile_required' | 'done';
 export interface SolidFsSyncJournalOptions {
@@ -26,6 +27,7 @@ export interface SolidFsJournalBootstrapInput {
     projection?: SolidFsProjection;
     source?: SolidFsEntrySource;
     shouldTrackPath?: (relativePath: string) => boolean;
+    resolveResource?: (absolutePath: string, relativePath: string) => string | Promise<string>;
 }
 export interface SolidFsJournalBootstrapResult {
     scanned: number;
@@ -48,7 +50,7 @@ export interface SolidFsJournalCompactResult {
  * committed. It stores enough metadata to replay index/remote refreshes, but
  * never stores file bodies.
  */
-export declare class SqliteSolidFsSyncJournal {
+export declare class SqliteSolidFsSyncJournal implements LocalRdfAuthorityJournal {
     private readonly db;
     private readonly now;
     private readonly doneRetentionMs;
@@ -73,6 +75,9 @@ export declare class SqliteSolidFsSyncJournal {
     private upsertCheckpoint;
     private initializeSchema;
 }
+export declare class RootedSolidFsSyncJournal extends SqliteSolidFsSyncJournal {
+    constructor(rootFilePath: string, cwd?: string);
+}
 export interface JournaledSolidFsSyncerOptions {
     syncer: SolidFsSyncer;
     journal: SqliteSolidFsSyncJournal;
@@ -115,3 +120,4 @@ export declare class WorkspaceJournaledSolidFsSyncer implements SolidFsSyncer {
     private journalFor;
 }
 export declare function resolveSolidFsJournalPath(workspace: SolidFsManifest, journalRoot?: string): string;
+export declare function resolveLocalRdfAuthorityJournalPath(rootFilePath: string, cwd?: string): string;

package/dist/solidfs/SolidFsSyncJournal.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkspaceJournaledSolidFsSyncer = exports.JournaledSolidFsSyncer = exports.SqliteSolidFsSyncJournal = void 0;
+exports.WorkspaceJournaledSolidFsSyncer = exports.JournaledSolidFsSyncer = exports.RootedSolidFsSyncJournal = exports.SqliteSolidFsSyncJournal = void 0;
 exports.resolveSolidFsJournalPath = resolveSolidFsJournalPath;
+exports.resolveLocalRdfAuthorityJournalPath = resolveLocalRdfAuthorityJournalPath;
 const node_crypto_1 = require("node:crypto");
 const node_path_1 = __importDefault(require("node:path"));
 const SqliteRuntime_1 = require("../storage/SqliteRuntime");
@@ -202,7 +203,9 @@ class SqliteSolidFsSyncJournal {
             }
             const op = await this.recordLocalCommitted({
                 path: snapshot.relativePath,
-                resource: (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, snapshot.relativePath),
+                resource: input.resolveResource
+                    ? await input.resolveResource(node_path_1.default.resolve(snapshot.absolutePath), snapshot.relativePath)
+                    : (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, snapshot.relativePath),
                 source,
                 sourcePath: snapshot.absolutePath,
                 contentType: (0, SolidFsPathUtils_1.contentTypeForPath)(snapshot.relativePath),
@@ -218,7 +221,9 @@ class SqliteSolidFsSyncJournal {
             }
             const op = await this.recordLocalCommitted({
                 path: checkpoint.path,
-                resource: (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, checkpoint.path),
+                resource: input.resolveResource
+                    ? await input.resolveResource(node_path_1.default.resolve(input.cwd, checkpoint.path), checkpoint.path)
+                    : (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, checkpoint.path),
                 source,
                 sourcePath: node_path_1.default.join(input.cwd, checkpoint.path),
                 contentType: (0, SolidFsPathUtils_1.contentTypeForPath)(checkpoint.path),
@@ -371,6 +376,12 @@ class SqliteSolidFsSyncJournal {
     }
 }
 exports.SqliteSolidFsSyncJournal = SqliteSolidFsSyncJournal;
+class RootedSolidFsSyncJournal extends SqliteSolidFsSyncJournal {
+    constructor(rootFilePath, cwd = process.cwd()) {
+        super({ path: resolveLocalRdfAuthorityJournalPath(rootFilePath, cwd) });
+    }
+}
+exports.RootedSolidFsSyncJournal = RootedSolidFsSyncJournal;
 class JournaledSolidFsSyncer {
     constructor(options) {
         this.syncer = options.syncer;
@@ -494,6 +505,10 @@ function resolveSolidFsJournalPath(workspace, journalRoot) {
         .slice(0, 16);
     return node_path_1.default.join(root, `${basename}-${key}`, 'sync-journal.sqlite');
 }
+function resolveLocalRdfAuthorityJournalPath(rootFilePath, cwd = process.cwd()) {
+    const root = node_path_1.default.resolve(cwd, rootFilePath);
+    return node_path_1.default.join(node_path_1.default.dirname(root), '.xpod-control', 'rdf-authority', 'sync-journal.sqlite');
+}
 function rowToOperation(row) {
     return {
         id: row.id,
@@ -520,8 +535,8 @@ function journalWorkspaceSnapshot(workspace) {
 function normalizeChange(change) {
     return {
         ...change,
-        path: change.path.split(/[\\/]+/u).join(node_path_1.default.sep),
-        previousPath: change.previousPath?.split(/[\\/]+/u).join(node_path_1.default.sep),
+        path: (0, SolidFsPathUtils_1.safeRelativePath)(change.path),
+        previousPath: change.previousPath ? (0, SolidFsPathUtils_1.safeRelativePath)(change.previousPath) : undefined,
     };
 }
 function operationId(workspace, change, afterHash) {

package/dist/solidfs/SolidFsSyncJournal.jsonld

@@ -8,6 +8,9 @@
       "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#SqliteSolidFsSyncJournal",
       "@type": "Class",
       "requireElement": "SqliteSolidFsSyncJournal",
+      "extends": [
+        "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#LocalRdfAuthorityJournal"
+      ],
       "comment": "Per-Pod SolidFS recovery journal.  This is an outbox for derived work after the authority file is already committed. It stores enough metadata to replay index/remote refreshes, but never stores file bodies.",
       "parameters": [
         {
@@ -114,6 +117,46 @@
           "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#SqliteSolidFsSyncJournal_options"
         }
       ]
+    },
+    {
+      "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#RootedSolidFsSyncJournal",
+      "@type": "Class",
+      "requireElement": "RootedSolidFsSyncJournal",
+      "extends": [
+        "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#SqliteSolidFsSyncJournal"
+      ],
+      "parameters": [
+        {
+          "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#RootedSolidFsSyncJournal_rootFilePath",
+          "range": "xsd:string"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#RootedSolidFsSyncJournal_cwd",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#RootedSolidFsSyncJournal__member_constructor",
+          "memberFieldName": "constructor"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#RootedSolidFsSyncJournal_rootFilePath"
+        },
+        {
+          "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#RootedSolidFsSyncJournal_cwd"
+        }
+      ]
     }
   ]
 }

package/dist/solidfs/index.d.ts

@@ -7,5 +7,6 @@ export * from './PodSolidFsSyncer';
 export * from './CompositeSolidFsSyncer';
 export * from './LocalFirstRdfRepresentationResolver';
 export * from './SolidFsSyncJournal';
+export * from './LocalRdfAuthorityRecoveryInitializer';
 export * from './SolidFsMetaNotes';
 export * from './WorkspacePrompt';

package/dist/solidfs/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./PodSolidFsSyncer"), exports);
 __exportStar(require("./CompositeSolidFsSyncer"), exports);
 __exportStar(require("./LocalFirstRdfRepresentationResolver"), exports);
 __exportStar(require("./SolidFsSyncJournal"), exports);
+__exportStar(require("./LocalRdfAuthorityRecoveryInitializer"), exports);
 __exportStar(require("./SolidFsMetaNotes"), exports);
 __exportStar(require("./WorkspacePrompt"), exports);
 //# sourceMappingURL=index.js.map

package/dist/storage/SparqlUpdateResourceStore.js

@@ -7,7 +7,7 @@ const community_server_1 = require("@solid/community-server");
 const StreamUtil_1 = require("@solid/community-server/dist/util/StreamUtil");
 const global_logger_factory_1 = require("global-logger-factory");
 const LocalFirstRdfRepresentationResolver_1 = require("../solidfs/LocalFirstRdfRepresentationResolver");
-const RdfSparqlAdapter_1 = require("./rdf/RdfSparqlAdapter");
+const RdfSparqlBoundary_1 = require("./rdf/RdfSparqlBoundary");
 /**
  * ResourceStore that short-circuits PATCH into direct SPARQL UPDATE
  * when the underlying DataAccessor supports it.
@@ -71,10 +71,10 @@ class SparqlUpdateResourceStore extends community_server_1.DataAccessorBasedStor
             await accessor.executeSparqlUpdate(sparqlUpdate, identifier.path);
         }
         catch (error) {
-            if (error instanceof RdfSparqlAdapter_1.DisabledSparqlFeatureError) {
+            if (error instanceof RdfSparqlBoundary_1.DisabledSparqlFeatureError) {
                 throw new community_server_1.ForbiddenHttpError(error.message, { cause: error });
             }
-            if (error instanceof RdfSparqlAdapter_1.UnsupportedSparqlQueryError) {
+            if (error instanceof RdfSparqlBoundary_1.UnsupportedSparqlQueryError) {
                 throw new community_server_1.BadRequestHttpError(error.message, { cause: error });
             }
             throw error;

package/dist/storage/accessors/MixDataAccessor.d.ts

@@ -4,7 +4,9 @@ import { RepresentationMetadata } from '@solid/community-server';
 import type { Representation, ResourceIdentifier, Guarded, DataAccessor, FileIdentifierMapper } from '@solid/community-server';
 import { type RdfAccessScope } from '../rdf/RdfAccessScope';
 import type { RdfSourceInput, RdfTextChunkInput, RdfTextSourceInput, RdfTermRewriteInput, RdfTermRewriteResult, RdfVectorChunkInput, RdfVectorSourceInput } from '../rdf/types';
+import type { SparqlVoidOptions } from '../sparql/SubgraphQueryEngine';
 import type { SolidFsChange, SolidFsManifest } from '../../solidfs/types';
+import type { RdfSearchReconciliationIntentSink } from '../../search/RdfSearchIntentSink';
 export interface LocalRdfDocument {
     data: Guarded<Readable>;
     metadata: RepresentationMetadata;
@@ -32,8 +34,10 @@ export interface SourceScopedStructuredRdfAccessor {
     deleteRdfSourceDocument(identifier: ResourceIdentifier): Promise<void>;
     moveRdfSourceDocument?(oldSource: string, next: RdfSourceInput): Promise<number>;
     indexTextSource?(source: RdfTextSourceInput, text: string, chunks?: RdfTextChunkInput[]): Promise<void>;
+    moveTextSource?(oldSource: string, next: RdfTextSourceInput): Promise<number>;
     deleteTextSource?(source: string): Promise<number>;
     indexVectorSource?(source: RdfVectorSourceInput, chunks: RdfVectorChunkInput[]): Promise<void>;
+    moveVectorSource?(oldSource: string, next: RdfVectorSourceInput): Promise<number>;
     deleteVectorSource?(source: string): Promise<number>;
 }
 export interface LocalRdfAuthorityJournalOperation {
@@ -44,6 +48,7 @@ export interface LocalRdfAuthorityJournal {
     markDone(id: string): Promise<void>;
     markRetryableFailure(id: string, error: unknown): Promise<void>;
     markReconcileRequired(id: string, reason: string): Promise<void>;
+    markFailedPermanent(id: string, error: unknown): Promise<void>;
 }
 /**
  * MixDataAccessor - Routes data to appropriate storage based on content type
@@ -55,9 +60,8 @@ export interface LocalRdfAuthorityJournal {
  * This uses composition instead of inheritance, allowing any DataAccessor
  * to be used as the RDF storage backend.
  */
-export declare class MixDataAccessor implements DataAccessor {
+export declare class MixDataAccessor implements DataAccessor, LocalRdfIndexAccessor {
     protected readonly logger: import("global-logger-factory").Logger<unknown>;
-    private readonly rdfSparqlAdapter;
     private readonly structuredDataAccessor;
     private readonly unstructuredDataAccessor;
     private readonly rdfFileDataAccessor;
@@ -66,7 +70,8 @@ export declare class MixDataAccessor implements DataAccessor {
     private readonly presignedRedirectEnabled;
     private readonly mirrorContainersToUnstructured;
     private readonly textSearchIndexingEnabled;
-    constructor(structuredDataAccessor: DataAccessor, unstructuredDataAccessor: DataAccessor, presignedRedirectEnabled?: boolean, mirrorContainersToUnstructured?: boolean, rdfFileDataAccessor?: DataAccessor, textSearchIndexingEnabled?: boolean, rdfFileMapper?: FileIdentifierMapper, localRdfAuthorityJournal?: LocalRdfAuthorityJournal);
+    private readonly rdfSearchIntentSink?;
+    constructor(structuredDataAccessor: DataAccessor, unstructuredDataAccessor: DataAccessor, presignedRedirectEnabled?: boolean, mirrorContainersToUnstructured?: boolean, rdfFileDataAccessor?: DataAccessor, textSearchIndexingEnabled?: boolean, rdfFileMapper?: FileIdentifierMapper, localRdfAuthorityJournal?: LocalRdfAuthorityJournal, rdfSearchIntentSink?: RdfSearchReconciliationIntentSink);
     /**
      * This accessor supports all types of data.
      */
@@ -93,39 +98,20 @@ export declare class MixDataAccessor implements DataAccessor {
     /**
      * Execute SPARQL UPDATE.
      *
-     * Supported embedded deltas patch the local RDF authority file first and then
-     * rebuild the structured RDF index. The structured accessor decides whether
-     * unsupported shapes have an explicitly configured compatibility path.
+     * Native QLever prepares an exact graph delta. The accessor validates its
+     * write scope, patches the local RDF authority files, and rebuilds the index.
      */
-    executeSparqlUpdate(query: string, baseIri?: string, accessScope?: RdfAccessScope): Promise<void>;
-    private shouldApplyLocalRdfSparqlUpdate;
-    private executeLocalRdfSparqlUpdate;
-    private applyLocalRdfDelta;
-    private loadLocalRdfDeltaGraphs;
-    private localRdfDeltaGraphIris;
-    private localRdfDeltaWriteGraphIris;
-    private addWritableTemplateGraphIris;
-    private addWritableGraphVariableIris;
-    private localRdfWriteGraphIri;
-    private queryLocalUpdateBindings;
-    private queryGraphTerms;
-    private collectQueryGraphTerms;
-    private collectGraphVariableFilterTerms;
-    private collectGraphVariableFilterIris;
-    private collectGraphVariableValueTerms;
-    private collectGraphVariableValueIris;
-    private addGraphFilterValueIri;
-    private addNamedGraphIris;
-    private addWritableNamedGraphIri;
-    private isLocalRdfAuthorityIdentifier;
-    private isQueryVariable;
-    private isRdfTerm;
+    executeSparqlUpdate(query: string, baseIri?: string, accessScope?: RdfAccessScope, options?: SparqlVoidOptions): Promise<void>;
+    private prepareNativeRdfSparqlUpdate;
+    private executePreparedRdfSparqlUpdate;
+    private assertPreparedDeltaQuadGraph;
     private readLocalRdfState;
     private writeLocalRdfAuthority;
     private writeLocalRdfAuthorityPatches;
     private prepareLocalRdfAuthorityJournalPatches;
     private recordLocalRdfAuthorityJournalPatch;
     private markLocalRdfAuthorityJournalFailure;
+    private markLocalRdfAuthorityRollbackComplete;
     private localRdfPatchWorkspace;
     private localRdfPatchRelativePath;
     private rollbackLocalRdfAuthorityPatches;
@@ -151,11 +137,17 @@ export declare class MixDataAccessor implements DataAccessor {
     private localRdfContentType;
     private sourceScopedStructuredAccessor;
     private syncTextSearchIndex;
+    private syncUnstructuredTextSearchIndex;
     private deleteSearchIndexes;
+    private moveSearchIndexes;
+    private moveVectorIndexIfPresent;
+    private deleteVectorIndexIfPresent;
     private rdfSourceInput;
+    private rdfTextSourceInput;
     private relativePathFromWorkspace;
     private isByLineRdfIdentifier;
     private isRdfDocumentIdentifier;
+    private isSearchableUnstructuredText;
     private isLocalMirroredRdf;
     private serializeQuadsForLocalFile;
     private serializeNQuads;