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

package/dist/storage/accessors/MixDataAccessor.js

@@ -12,14 +12,11 @@ const arrayify_stream_1 = __importDefault(require("arrayify-stream"));
 const n3_1 = require("n3");
 const jsonld_1 = __importDefault(require("jsonld"));
 const rdf_parse_1 = require("rdf-parse");
-const sparqljs_1 = require("sparqljs");
 const community_server_1 = require("@solid/community-server");
-const RdfSparqlAdapter_1 = require("../rdf/RdfSparqlAdapter");
+const RdfSparqlBoundary_1 = require("../rdf/RdfSparqlBoundary");
 const RdfContentTypes_1 = require("../rdf/RdfContentTypes");
 const RdfTextProjection_1 = require("../rdf/RdfTextProjection");
-const RdfQuadIndex_1 = require("../rdf/RdfQuadIndex");
 const RdfXmlSerializer_1 = require("../rdf/RdfXmlSerializer");
-const SolidRdfEngine_1 = require("../rdf/SolidRdfEngine");
 const RdfAccessScope_1 = require("../rdf/RdfAccessScope");
 const MetadataRequestContext_1 = require("../MetadataRequestContext");
 const ResourceReadContext_1 = require("../ResourceReadContext");
@@ -34,9 +31,8 @@ const ResourceReadContext_1 = require("../ResourceReadContext");
  * to be used as the RDF storage backend.
  */
 class MixDataAccessor {
-    constructor(structuredDataAccessor, unstructuredDataAccessor, presignedRedirectEnabled = false, mirrorContainersToUnstructured = true, rdfFileDataAccessor = unstructuredDataAccessor, textSearchIndexingEnabled = false, rdfFileMapper, localRdfAuthorityJournal) {
+    constructor(structuredDataAccessor, unstructuredDataAccessor, presignedRedirectEnabled = false, mirrorContainersToUnstructured = true, rdfFileDataAccessor = unstructuredDataAccessor, textSearchIndexingEnabled = false, rdfFileMapper, localRdfAuthorityJournal, rdfSearchIntentSink) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
-        this.rdfSparqlAdapter = new RdfSparqlAdapter_1.RdfSparqlAdapter();
         this.structuredDataAccessor = structuredDataAccessor;
         this.unstructuredDataAccessor = unstructuredDataAccessor;
         this.rdfFileDataAccessor = rdfFileDataAccessor;
@@ -45,6 +41,7 @@ class MixDataAccessor {
         this.presignedRedirectEnabled = presignedRedirectEnabled;
         this.mirrorContainersToUnstructured = mirrorContainersToUnstructured;
         this.textSearchIndexingEnabled = textSearchIndexingEnabled;
+        this.rdfSearchIntentSink = rdfSearchIntentSink;
     }
     /**
      * This accessor supports all types of data.
@@ -180,6 +177,7 @@ class MixDataAccessor {
         }
         else if (this.isUnstructured(metadata)) {
             await this.deleteUnstructuredResourceIfPresent(identifier);
+            await this.deleteSearchIndexes(identifier);
         }
         // Always delete from structured storage (contains metadata)
         await this.structuredDataAccessor.deleteResource(identifier);
@@ -188,409 +186,88 @@ class MixDataAccessor {
     /**
      * 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.
      */
-    async executeSparqlUpdate(query, baseIri, accessScope) {
-        if (baseIri) {
-            const identifier = { path: baseIri };
-            if (await this.shouldApplyLocalRdfSparqlUpdate(identifier)) {
-                try {
-                    const writtenIdentifiers = await this.executeLocalRdfSparqlUpdate(query, identifier, new Set([identifier.path]), accessScope);
-                    for (const writtenIdentifier of writtenIdentifiers) {
-                        this.invalidateMetadataCache(writtenIdentifier);
-                    }
-                    return;
-                }
-                catch (error) {
-                    if (!(error instanceof RdfSparqlAdapter_1.UnsupportedSparqlQueryError)) {
-                        throw error;
-                    }
-                }
-            }
+    async executeSparqlUpdate(query, baseIri, accessScope, options) {
+        if (!baseIri) {
+            throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Pod SPARQL UPDATE requires a server-owned base IRI', { code: 'rdf.sparql.update_authority_required' });
         }
-        const accessor = this.structuredDataAccessor;
-        if (typeof accessor.executeSparqlUpdate !== 'function') {
-            throw new Error('Structured data accessor does not support SPARQL UPDATE');
-        }
-        await accessor.executeSparqlUpdate(query, baseIri);
-        if (baseIri) {
-            const identifier = { path: baseIri };
-            await this.refreshLocalRdfMirror(identifier);
-            this.invalidateMetadataCache(identifier);
+        const prepared = await this.prepareNativeRdfSparqlUpdate(query, baseIri, accessScope, options);
+        const writtenIdentifiers = await this.executePreparedRdfSparqlUpdate(prepared, baseIri, accessScope);
+        for (const writtenIdentifier of writtenIdentifiers) {
+            this.invalidateMetadataCache(writtenIdentifier);
         }
     }
-    async shouldApplyLocalRdfSparqlUpdate(identifier) {
-        if (this.isByLineRdfIdentifier(identifier)) {
-            return true;
-        }
-        try {
-            return this.isLocalMirroredRdf(identifier, await this.getMetadata(identifier));
+    async prepareNativeRdfSparqlUpdate(query, baseIri, accessScope, options) {
+        const accessor = this.structuredDataAccessor;
+        if (typeof accessor.prepareSparqlUpdate !== 'function') {
+            throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Native QLever prepared-update support is required for Pod SPARQL UPDATE', {
+                code: 'rdf.sparql.update_authority_required',
+                capability: 'sparql.update.authority',
+            });
         }
-        catch (error) {
-            if (community_server_1.NotFoundHttpError.isInstance(error)) {
-                return true;
-            }
-            throw error;
+        const prepareOptions = options
+            ? {
+                ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                ...(options.signal ? { signal: options.signal } : {}),
+            }
+            : undefined;
+        const prepared = await accessor.prepareSparqlUpdate(query, baseIri, accessScope, prepareOptions);
+        if (!prepared) {
+            throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Native QLever did not return a prepared update delta', {
+                code: 'rdf.sparql.update_authority_required',
+                capability: 'sparql.update.authority',
+            });
         }
+        return prepared;
     }
-    async executeLocalRdfSparqlUpdate(query, identifier, localRdfAuthorityIris, accessScope) {
-        const parsed = new sparqljs_1.Parser({ baseIRI: identifier.path }).parse(query);
-        const delta = this.rdfSparqlAdapter.compileUpdateDelta(parsed, this.parentContainer(identifier).path, {
-            defaultGraph: identifier.path,
-        });
-        const writableGraphIris = this.localRdfDeltaWriteGraphIris(delta.operations, localRdfAuthorityIris);
-        const graphStates = await this.loadLocalRdfDeltaGraphs(delta.operations, writableGraphIris, localRdfAuthorityIris);
-        const graphQuads = new Map([...graphStates].map(([graphIri, state]) => [graphIri, state.quads]));
-        const nextQuadsByGraph = this.applyLocalRdfDelta(graphQuads, delta.operations, writableGraphIris, accessScope);
-        const patches = writableGraphIris.map((graphIri) => {
-            const previous = graphStates.get(graphIri);
-            return {
-                identifier: { path: graphIri },
-                previousQuads: previous?.quads ?? [],
-                previousExists: previous?.existed ?? false,
-                nextQuads: nextQuadsByGraph.get(graphIri) ?? [],
-            };
-        });
-        await this.writeLocalRdfAuthorityPatches(patches);
-        return patches.map((patch) => patch.identifier);
-    }
-    applyLocalRdfDelta(graphQuads, operations, writableGraphIris, accessScope) {
-        const writableGraphs = new Set(writableGraphIris);
-        const byGraph = new Map();
-        for (const [graphIri, quads] of graphQuads) {
-            byGraph.set(graphIri, new Map(quads.map((quad) => [this.quadKey(quad), quad])));
-        }
-        const currentQuads = () => [...byGraph.entries()]
-            .filter(([graphIri]) => !accessScope || (0, RdfAccessScope_1.rdfAccessGraphAllowed)(graphIri, accessScope))
-            .flatMap(([, quads]) => [...quads.values()]);
-        const writableQuads = (graphIri) => {
-            let quads = byGraph.get(graphIri);
-            if (!quads) {
-                quads = new Map();
-                byGraph.set(graphIri, quads);
+    async executePreparedRdfSparqlUpdate(delta, baseIri, accessScope) {
+        const patches = [];
+        for (const graphDelta of delta.graphs) {
+            if (graphDelta.graphIri !== graphDelta.sourceUri) {
+                throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Native prepared update v1 requires the graph IRI to equal its local RDF source URI');
             }
-            return quads;
-        };
-        const deleteQuads = (quads) => {
-            for (const quad of quads) {
-                const target = writableQuads(this.localRdfWriteGraphIri(quad.graph, writableGraphs));
-                target.delete(this.quadKey(quad));
+            const serverOwnedBase = accessScope?.basePath ?? this.parentContainer({ path: baseIri }).path;
+            if (!graphDelta.graphIri.startsWith(serverOwnedBase)) {
+                throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Native prepared update cannot write outside the server-owned Pod scope');
             }
-        };
-        const insertQuads = (quads) => {
-            for (const quad of quads) {
-                const target = writableQuads(this.localRdfWriteGraphIri(quad.graph, writableGraphs));
-                target.set(this.quadKey(quad), quad);
-            }
-        };
-        for (const operation of operations) {
-            if (operation.type === 'insert') {
-                insertQuads(operation.quads);
-                continue;
+            if (accessScope && !(0, RdfAccessScope_1.rdfAccessGraphAllowed)(graphDelta.graphIri, accessScope)) {
+                throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Native prepared update cannot write an RDF graph denied by the current access scope');
             }
-            if (operation.type === 'delete') {
-                deleteQuads(operation.quads);
-                continue;
+            const identifier = { path: graphDelta.sourceUri };
+            if (!this.isByLineRdfIdentifier(identifier)) {
+                throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Native prepared update only supports by-line local RDF graph documents');
             }
-            if (operation.type === 'insertDeleteWhere') {
-                const rows = this.queryLocalUpdateBindings(currentQuads(), operation.query);
-                deleteQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.deletes, rows));
-                insertQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows));
-                continue;
-            }
-            if (operation.type === 'insertWhere') {
-                const rows = this.queryLocalUpdateBindings(currentQuads(), operation.query);
-                insertQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows));
-                continue;
-            }
-            const rows = this.queryLocalUpdateBindings(currentQuads(), operation.query);
-            deleteQuads(this.rdfSparqlAdapter.materializeDeleteWhere(operation.template, rows));
-        }
-        return new Map(writableGraphIris.map((graphIri) => [graphIri, [...(byGraph.get(graphIri)?.values() ?? [])]]));
-    }
-    async loadLocalRdfDeltaGraphs(operations, writableGraphIris, localRdfAuthorityIris) {
-        const graphIris = this.localRdfDeltaGraphIris(operations, writableGraphIris);
-        const graphStates = new Map();
-        for (const graphIri of graphIris) {
-            const graphIdentifier = { path: graphIri };
-            if (!this.isLocalRdfAuthorityIdentifier(graphIdentifier, localRdfAuthorityIris)) {
-                throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports by-line local RDF graph documents');
-            }
-            const existing = await this.readLocalRdfState(graphIdentifier);
-            const graph = n3_1.DataFactory.namedNode(graphIri);
-            const quads = existing.text.length > 0
-                ? await this.parseLocalRdf(graphIdentifier, existing.text, this.localRdfContentType(graphIdentifier))
-                    .then((items) => items.map((quad) => this.toGraphQuad(quad, graph)))
+            const previous = await this.readLocalRdfState(identifier);
+            const graph = n3_1.DataFactory.namedNode(graphDelta.graphIri);
+            const previousQuads = previous.text.length > 0
+                ? await this.parseLocalRdf(identifier, previous.text, this.localRdfContentType(identifier))
+                    .then((items) => items.map((item) => this.toGraphQuad(item, graph)))
                 : [];
-            graphStates.set(graphIri, { quads, existed: existing.existed });
-        }
-        return graphStates;
-    }
-    localRdfDeltaGraphIris(operations, writableGraphIris) {
-        const graphIris = new Set(writableGraphIris);
-        for (const operation of operations) {
-            const graphTerms = operation.type === 'deleteWhere'
-                ? [
-                    ...operation.template.map((item) => item.graph),
-                    ...this.queryGraphTerms(operation.query),
-                ]
-                : operation.type === 'insertDeleteWhere'
-                    ? [
-                        ...operation.deletes.map((item) => item.graph),
-                        ...operation.inserts.map((item) => item.graph),
-                        ...this.queryGraphTerms(operation.query),
-                    ]
-                    : operation.type === 'insertWhere'
-                        ? [
-                            ...operation.inserts.map((item) => item.graph),
-                            ...this.queryGraphTerms(operation.query),
-                        ]
-                        : operation.quads.map((quad) => quad.graph);
-            for (const graph of graphTerms) {
-                this.addNamedGraphIris(graph, graphIris);
-            }
-        }
-        return [...graphIris];
-    }
-    localRdfDeltaWriteGraphIris(operations, localRdfAuthorityIris) {
-        const graphIris = new Set();
-        for (const operation of operations) {
-            if (operation.type === 'deleteWhere') {
-                this.addWritableTemplateGraphIris(operation.template.map((item) => item.graph), operation.query, graphIris, localRdfAuthorityIris);
-                continue;
-            }
-            if (operation.type === 'insertDeleteWhere') {
-                this.addWritableTemplateGraphIris([
-                    ...operation.deletes.map((item) => item.graph),
-                    ...operation.inserts.map((item) => item.graph),
-                ], operation.query, graphIris, localRdfAuthorityIris);
-                continue;
-            }
-            if (operation.type === 'insertWhere') {
-                this.addWritableTemplateGraphIris(operation.inserts.map((item) => item.graph), operation.query, graphIris, localRdfAuthorityIris);
-                continue;
-            }
-            const graphTerms = operation.quads.map((quad) => quad.graph);
-            for (const graph of graphTerms) {
-                this.addWritableNamedGraphIri(graph, graphIris, localRdfAuthorityIris);
-            }
-        }
-        if (graphIris.size === 0) {
-            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update requires explicit local RDF graph write targets');
-        }
-        return [...graphIris];
-    }
-    addWritableTemplateGraphIris(graphs, query, graphIris, localRdfAuthorityIris) {
-        for (const graph of graphs) {
-            if (this.isQueryVariable(graph)) {
-                this.addWritableGraphVariableIris(query, graph.variable, graphIris, localRdfAuthorityIris);
-                continue;
-            }
-            this.addWritableNamedGraphIri(graph, graphIris, localRdfAuthorityIris);
-        }
-    }
-    addWritableGraphVariableIris(query, variable, graphIris, localRdfAuthorityIris) {
-        const values = new Set();
-        this.collectGraphVariableFilterIris(query, variable, values);
-        if (values.size === 0) {
-            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports finite GRAPH variable write targets');
-        }
-        for (const value of values) {
-            this.addWritableNamedGraphIri(n3_1.DataFactory.namedNode(value), graphIris, localRdfAuthorityIris);
-        }
-    }
-    localRdfWriteGraphIri(graph, writableGraphs) {
-        if (graph.termType !== 'NamedNode' || !writableGraphs.has(graph.value)) {
-            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update can only write declared local RDF graph documents');
-        }
-        return graph.value;
-    }
-    queryLocalUpdateBindings(quads, query) {
-        const index = new RdfQuadIndex_1.RdfQuadIndex({ path: ':memory:' });
-        index.open();
-        try {
-            const engine = new SolidRdfEngine_1.SolidRdfEngine({ index });
-            engine.put(quads);
-            return engine.query(query).bindings;
-        }
-        finally {
-            index.close();
-        }
-    }
-    queryGraphTerms(query) {
-        const graphTerms = [];
-        const graphVariables = new Set();
-        this.collectQueryGraphTerms(query, graphTerms, graphVariables);
-        this.collectGraphVariableFilterTerms(query, graphVariables, graphTerms);
-        return graphTerms;
-    }
-    collectQueryGraphTerms(query, graphTerms, graphVariables) {
-        for (const pattern of query.patterns) {
-            if (!pattern.graph) {
-                continue;
-            }
-            graphTerms.push(pattern.graph);
-            if (this.isQueryVariable(pattern.graph)) {
-                graphVariables.add(pattern.graph.variable);
-            }
-        }
-        for (const optional of query.optional ?? []) {
-            this.collectQueryGraphTerms(Array.isArray(optional) ? { patterns: optional } : optional, graphTerms, graphVariables);
-        }
-        for (const union of query.unions ?? []) {
-            for (const branch of union.branches) {
-                this.collectQueryGraphTerms(branch, graphTerms, graphVariables);
-            }
-        }
-        for (const minus of query.minus ?? []) {
-            this.collectQueryGraphTerms(minus, graphTerms, graphVariables);
-        }
-        for (const exists of query.exists ?? []) {
-            this.collectQueryGraphTerms(exists, graphTerms, graphVariables);
-        }
-    }
-    collectGraphVariableFilterTerms(query, graphVariables, graphTerms) {
-        for (const filter of query.filters ?? []) {
-            if (!graphVariables.has(filter.variable)) {
-                continue;
-            }
-            if (filter.value && this.isRdfTerm(filter.value)) {
-                graphTerms.push(filter.value);
-            }
-            for (const value of filter.values ?? []) {
-                if (this.isRdfTerm(value)) {
-                    graphTerms.push(value);
-                }
-            }
-        }
-        this.collectGraphVariableValueTerms(query.values ?? [], graphVariables, graphTerms);
-        for (const optional of query.optional ?? []) {
-            if (!Array.isArray(optional)) {
-                this.collectGraphVariableFilterTerms(optional, graphVariables, graphTerms);
-            }
-        }
-        for (const union of query.unions ?? []) {
-            for (const branch of union.branches) {
-                this.collectGraphVariableFilterTerms(branch, graphVariables, graphTerms);
-            }
-        }
-        for (const minus of query.minus ?? []) {
-            this.collectGraphVariableFilterTerms(minus, graphVariables, graphTerms);
-        }
-        for (const exists of query.exists ?? []) {
-            this.collectGraphVariableFilterTerms(exists, graphVariables, graphTerms);
-        }
-    }
-    collectGraphVariableFilterIris(query, variable, values) {
-        for (const filter of query.filters ?? []) {
-            if (filter.variable !== variable) {
-                continue;
-            }
-            if ((filter.operator === '$eq' || filter.operator === '$sameTerm') && filter.value && this.isRdfTerm(filter.value)) {
-                this.addGraphFilterValueIri(filter.value, values);
-            }
-            if (filter.operator === '$in') {
-                for (const value of filter.values ?? []) {
-                    if (this.isRdfTerm(value)) {
-                        this.addGraphFilterValueIri(value, values);
-                    }
-                }
-            }
-        }
-        this.collectGraphVariableValueIris(query.values ?? [], variable, values);
-        for (const optional of query.optional ?? []) {
-            if (!Array.isArray(optional)) {
-                this.collectGraphVariableFilterIris(optional, variable, values);
-            }
-        }
-        for (const union of query.unions ?? []) {
-            for (const branch of union.branches) {
-                this.collectGraphVariableFilterIris(branch, variable, values);
-            }
-        }
-        for (const minus of query.minus ?? []) {
-            this.collectGraphVariableFilterIris(minus, variable, values);
-        }
-        for (const exists of query.exists ?? []) {
-            this.collectGraphVariableFilterIris(exists, variable, values);
-        }
-    }
-    collectGraphVariableValueTerms(sources, graphVariables, graphTerms) {
-        for (const source of sources) {
-            for (const variable of source.variables) {
-                if (!graphVariables.has(variable)) {
-                    continue;
-                }
-                for (const row of source.rows) {
-                    const value = row[variable];
-                    if (value) {
-                        graphTerms.push(value);
-                    }
-                }
-            }
-        }
-    }
-    collectGraphVariableValueIris(sources, variable, values) {
-        for (const source of sources) {
-            if (!source.variables.includes(variable)) {
-                continue;
-            }
-            for (const row of source.rows) {
-                const value = row[variable];
-                if (value) {
-                    this.addGraphFilterValueIri(value, values);
-                }
-            }
-        }
-    }
-    addGraphFilterValueIri(value, values) {
-        if (value.termType !== 'NamedNode') {
-            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update GRAPH variable write targets must be named graph documents');
-        }
-        values.add(value.value);
-    }
-    addNamedGraphIris(graph, graphIris) {
-        if (this.isRdfTerm(graph)) {
-            if (graph.termType !== 'NamedNode') {
-                throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports named graph documents');
-            }
-            graphIris.add(graph.value);
-            return;
-        }
-        const values = graph.$in;
-        if (Array.isArray(values) && values.every((value) => this.isRdfTerm(value))) {
-            for (const value of values) {
-                if (value.termType !== 'NamedNode') {
-                    throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports named graph documents');
-                }
-                graphIris.add(value.value);
-            }
-            return;
-        }
-        if (this.isQueryVariable(graph)) {
-            return;
+            const next = new Map(previousQuads.map((item) => [this.quadKey(item), item]));
+            for (const item of graphDelta.deletes) {
+                this.assertPreparedDeltaQuadGraph(item, graphDelta.graphIri);
+                next.delete(this.quadKey(item));
+            }
+            for (const item of graphDelta.inserts) {
+                this.assertPreparedDeltaQuadGraph(item, graphDelta.graphIri);
+                next.set(this.quadKey(item), item);
+            }
+            patches.push({
+                identifier,
+                previousQuads,
+                previousExists: previous.existed,
+                nextQuads: [...next.values()],
+            });
         }
-        throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports explicit local RDF graph documents');
+        await this.writeLocalRdfAuthorityPatches(patches);
+        return patches.map((patch) => patch.identifier);
     }
-    addWritableNamedGraphIri(graph, graphIris, localRdfAuthorityIris) {
-        if (!this.isRdfTerm(graph) || graph.termType !== 'NamedNode') {
-            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports explicit local RDF graph write targets');
+    assertPreparedDeltaQuadGraph(quad, graphIri) {
+        if (quad.graph.termType !== 'NamedNode' || quad.graph.value !== graphIri) {
+            throw new RdfSparqlBoundary_1.UnsupportedSparqlQueryError('Native prepared update contains a quad outside its declared writable graph');
         }
-        if (!this.isLocalRdfAuthorityIdentifier({ path: graph.value }, localRdfAuthorityIris)) {
-            throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports by-line local RDF graph write targets');
-        }
-        graphIris.add(graph.value);
-    }
-    isLocalRdfAuthorityIdentifier(identifier, localRdfAuthorityIris) {
-        return this.isByLineRdfIdentifier(identifier) || localRdfAuthorityIris.has(identifier.path);
-    }
-    isQueryVariable(value) {
-        return Boolean(value && typeof value === 'object' && 'variable' in value);
-    }
-    isRdfTerm(value) {
-        return Boolean(value && typeof value === 'object' && 'termType' in value);
     }
     async readLocalRdfState(identifier) {
         try {
@@ -648,7 +325,10 @@ class MixDataAccessor {
         }
         catch (error) {
             await this.markLocalRdfAuthorityJournalFailure(journalPatches, error);
-            await this.rollbackLocalRdfAuthorityPatches(applied);
+            const rollbackFailures = await this.rollbackLocalRdfAuthorityPatches(applied);
+            if (rollbackFailures.length === 0) {
+                await this.markLocalRdfAuthorityRollbackComplete(journalPatches, error);
+            }
             throw error;
         }
     }
@@ -703,6 +383,20 @@ class MixDataAccessor {
             }
         }
     }
+    async markLocalRdfAuthorityRollbackComplete(journalPatches, error) {
+        if (!this.localRdfAuthorityJournal || journalPatches.length === 0) {
+            return;
+        }
+        const message = `Local RDF authority patch failed and was rolled back: ${error instanceof Error ? error.message : String(error)}`;
+        for (const journalPatch of journalPatches) {
+            try {
+                await this.localRdfAuthorityJournal.markFailedPermanent(journalPatch.operation.id, message);
+            }
+            catch (journalError) {
+                this.logger.warn(`Failed to finalize rolled-back local RDF authority journal for ${journalPatch.patch.identifier.path}: ${journalError instanceof Error ? journalError.message : String(journalError)}`);
+            }
+        }
+    }
     localRdfPatchWorkspace(resourcePaths, filePaths) {
         const workspace = commonHttpContainer(resourcePaths) ?? this.parentContainer({ path: resourcePaths[0] }).path;
         const cwd = commonDirectory(filePaths);
@@ -742,6 +436,7 @@ class MixDataAccessor {
         if (failures.length > 0) {
             this.logger.warn(`Failed to fully roll back local RDF authority patch: ${failures.join('; ')}`);
         }
+        return failures;
     }
     toDefaultGraphQuad(quad) {
         return n3_1.DataFactory.quad(quad.subject, quad.predicate, quad.object);
@@ -808,6 +503,7 @@ class MixDataAccessor {
         }
         const moved = await sourceScopedAccessor.moveRdfSourceDocument(options.previousSource ?? previousIdentifier.path, this.rdfSourceInput(nextIdentifier, options));
         if (moved > 0) {
+            await this.moveSearchIndexes(previousIdentifier, nextIdentifier, options, sourceScopedAccessor);
             this.invalidateMetadataCache(previousIdentifier);
             this.invalidateMetadataCache(nextIdentifier);
         }
@@ -916,15 +612,72 @@ class MixDataAccessor {
         if (!accessor?.indexTextSource) {
             return;
         }
-        const source = this.rdfSourceInput(identifier, options);
+        await this.deleteVectorIndexIfPresent(accessor, identifier);
+        const source = this.rdfTextSourceInput(identifier, text, options);
         await accessor.indexTextSource(source, text, quads ? (0, RdfTextProjection_1.createRdfEntityTextChunks)(source, quads) : undefined);
+        await this.rdfSearchIntentSink?.recordTextCommitted(source);
+    }
+    async syncUnstructuredTextSearchIndex(identifier, text, metadata) {
+        if (!this.textSearchIndexingEnabled || !this.isSearchableUnstructuredText(identifier, metadata)) {
+            return;
+        }
+        const accessor = this.sourceScopedStructuredAccessor();
+        if (!accessor?.indexTextSource) {
+            return;
+        }
+        await this.deleteVectorIndexIfPresent(accessor, identifier);
+        const source = this.rdfTextSourceInput(identifier, text, { contentType: metadata.contentType });
+        await accessor.indexTextSource(source, text);
+        await this.rdfSearchIntentSink?.recordTextCommitted(source);
     }
     async deleteSearchIndexes(identifier) {
-        if (!this.textSearchIndexingEnabled || !this.isByLineRdfIdentifier(identifier)) {
+        if (!this.textSearchIndexingEnabled) {
             return;
         }
         const accessor = this.sourceScopedStructuredAccessor();
         await accessor?.deleteTextSource?.(identifier.path);
+        if (accessor) {
+            await this.deleteVectorIndexIfPresent(accessor, identifier);
+        }
+        await this.rdfSearchIntentSink?.recordSourceDeleted(identifier.path);
+    }
+    async moveSearchIndexes(previousIdentifier, nextIdentifier, options, accessor) {
+        if (!this.textSearchIndexingEnabled || !this.isByLineRdfIdentifier(nextIdentifier)) {
+            return;
+        }
+        const previousSource = options.previousSource ?? previousIdentifier.path;
+        const nextSource = this.rdfSourceInput(nextIdentifier, options);
+        let movedText = 0;
+        if (accessor.moveTextSource) {
+            movedText = await accessor.moveTextSource(previousSource, nextSource);
+        }
+        await this.moveVectorIndexIfPresent(accessor, previousSource, nextSource);
+        if (movedText > 0) {
+            await this.rdfSearchIntentSink?.recordTextCommitted(nextSource);
+        }
+    }
+    async moveVectorIndexIfPresent(accessor, previousSource, nextSource) {
+        try {
+            return await accessor.moveVectorSource?.(previousSource, nextSource) ?? 0;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/vector index is not configured/i.test(message)) {
+                throw error;
+            }
+            return 0;
+        }
+    }
+    async deleteVectorIndexIfPresent(accessor, identifier) {
+        try {
+            await accessor.deleteVectorSource?.(identifier.path);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/vector index is not configured/i.test(message)) {
+                throw error;
+            }
+        }
     }
     rdfSourceInput(identifier, options) {
         const workspace = options.workspace ?? this.parentContainer(identifier).path;
@@ -936,6 +689,12 @@ class MixDataAccessor {
             sourceVersion: options.sourceVersion,
         };
     }
+    rdfTextSourceInput(identifier, text, options) {
+        return {
+            ...this.rdfSourceInput(identifier, options),
+            sourceHash: `sha256:${(0, node_crypto_1.createHash)('sha256').update(text).digest('hex')}`,
+        };
+    }
     relativePathFromWorkspace(identifierPath, workspaceValue) {
         try {
             const resource = new URL(identifierPath);
@@ -955,6 +714,21 @@ class MixDataAccessor {
     isRdfDocumentIdentifier(identifier) {
         return (0, RdfContentTypes_1.isRdfDocumentPath)(identifier.path);
     }
+    isSearchableUnstructuredText(identifier, metadata) {
+        const contentType = (0, RdfContentTypes_1.normalizeContentType)(metadata.contentType);
+        if (contentType === 'text/plain' || contentType === 'text/markdown' || contentType === 'text/x-markdown') {
+            return true;
+        }
+        const pathname = (() => {
+            try {
+                return new URL(identifier.path).pathname;
+            }
+            catch {
+                return identifier.path;
+            }
+        })().toLowerCase();
+        return pathname.endsWith('.md') || pathname.endsWith('.markdown') || pathname.endsWith('.mdown');
+    }
     isLocalMirroredRdf(identifier, metadata) {
         return metadata.contentType === community_server_1.INTERNAL_QUADS || this.isRdfDocumentIdentifier(identifier);
     }
@@ -1010,9 +784,12 @@ class MixDataAccessor {
      * then save metadata in structured accessor.
      */
     async writeUnstructuredDocument(identifier, data, metadata) {
-        await this.ensureUnstructuredParentContainers(identifier);
+        const indexableText = this.textSearchIndexingEnabled && this.isSearchableUnstructuredText(identifier, metadata)
+            ? await this.readStreamText(data)
+            : undefined;
+        const writeData = indexableText === undefined ? data : (0, community_server_1.guardStream)(stream_1.Readable.from([indexableText]));
         // Write the actual data to unstructured storage
-        await this.unstructuredDataAccessor.writeDocument(identifier, data, metadata);
+        await this.unstructuredDataAccessor.writeDocument(identifier, writeData, metadata);
         let updatedMetadata;
         if (typeof metadata.contentLength === 'number') {
             updatedMetadata = new community_server_1.RepresentationMetadata(metadata);
@@ -1031,11 +808,17 @@ class MixDataAccessor {
         // Save metadata to structured storage
         try {
             await this.structuredDataAccessor.writeMetadata(identifier, updatedMetadata);
+            if (indexableText !== undefined) {
+                await this.syncUnstructuredTextSearchIndex(identifier, indexableText, updatedMetadata);
+            }
         }
         catch (error) {
             this.logger.error(`Error writing metadata for ${identifier.path}: ${error}`);
             // Rollback: delete the unstructured data
             await this.unstructuredDataAccessor.deleteResource(identifier);
+            if (indexableText !== undefined) {
+                await this.deleteSearchIndexes(identifier);
+            }
             throw error;
         }
     }