@undefineds.co/xpod 0.3.5 → 0.3.14

package/dist/storage/accessors/MixDataAccessor.js

@@ -1,23 +1,39 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MixDataAccessor = void 0;
+const stream_1 = require("stream");
 const global_logger_factory_1 = require("global-logger-factory");
+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 community_server_1 = require("@solid/community-server");
+const RdfSparqlAdapter_1 = require("../rdf/RdfSparqlAdapter");
+const RdfContentTypes_1 = require("../rdf/RdfContentTypes");
+const RdfQuadIndex_1 = require("../rdf/RdfQuadIndex");
+const RdfXmlSerializer_1 = require("../rdf/RdfXmlSerializer");
+const SolidRdfEngine_1 = require("../rdf/SolidRdfEngine");
 const MetadataRequestContext_1 = require("../MetadataRequestContext");
 /**
  * MixDataAccessor - Routes data to appropriate storage based on content type
  *
  * - RDF data (internal/quads) -> structuredDataAccessor (Quadstore or QuintStore)
+ * - RDF file mirrors (.ttl/.jsonld) -> rdfFileDataAccessor (local FileSystem)
  * - Other data (binary, text, etc.) -> unstructuredDataAccessor (FileSystem, Minio, etc.)
  *
  * This uses composition instead of inheritance, allowing any DataAccessor
  * to be used as the RDF storage backend.
  */
 class MixDataAccessor {
-    constructor(structuredDataAccessor, unstructuredDataAccessor, presignedRedirectEnabled = false, mirrorContainersToUnstructured = true) {
+    constructor(structuredDataAccessor, unstructuredDataAccessor, presignedRedirectEnabled = false, mirrorContainersToUnstructured = true, rdfFileDataAccessor = unstructuredDataAccessor) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.rdfSparqlAdapter = new RdfSparqlAdapter_1.RdfSparqlAdapter();
         this.structuredDataAccessor = structuredDataAccessor;
         this.unstructuredDataAccessor = unstructuredDataAccessor;
+        this.rdfFileDataAccessor = rdfFileDataAccessor;
         this.presignedRedirectEnabled = presignedRedirectEnabled;
         this.mirrorContainersToUnstructured = mirrorContainersToUnstructured;
     }
@@ -50,6 +66,51 @@ class MixDataAccessor {
         }
         return await this.structuredDataAccessor.getData(identifier);
     }
+    /**
+     * Read the local RDF file mirror used by SolidFS/local-first HTTP reads.
+     *
+     * `getData()` intentionally keeps returning the structured quad stream for
+     * CSS internals. This method is the explicit file-content path for callers
+     * that need a real Turtle/JSON-LD byte stream.
+     */
+    async getLocalRdfDocument(identifier) {
+        if ((0, community_server_1.isContainerIdentifier)(identifier)) {
+            throw new community_server_1.NotFoundHttpError();
+        }
+        if (this.isByLineRdfIdentifier(identifier)) {
+            try {
+                return {
+                    data: await this.rdfFileDataAccessor.getData(identifier),
+                    metadata: await this.getExistingLocalRdfMetadata(identifier),
+                };
+            }
+            catch (error) {
+                if (!community_server_1.NotFoundHttpError.isInstance(error)) {
+                    throw error;
+                }
+            }
+        }
+        const metadata = await this.getMetadata(identifier);
+        if (!this.isLocalMirroredRdf(identifier, metadata)) {
+            throw new community_server_1.NotFoundHttpError();
+        }
+        try {
+            return {
+                data: await this.rdfFileDataAccessor.getData(identifier),
+                metadata: await this.getLocalRdfMetadata(identifier, metadata),
+            };
+        }
+        catch (error) {
+            if (!community_server_1.NotFoundHttpError.isInstance(error)) {
+                throw error;
+            }
+        }
+        await this.refreshLocalRdfMirror(identifier);
+        return {
+            data: await this.rdfFileDataAccessor.getData(identifier),
+            metadata: await this.getLocalRdfMetadata(identifier, metadata),
+        };
+    }
     async getMetadata(identifier) {
         const cache = MetadataRequestContext_1.metadataRequestContext.getStore()?.metadataCache;
         const cacheKey = identifier.path;
@@ -92,7 +153,7 @@ class MixDataAccessor {
             this.invalidateMetadataCache(identifier);
             return;
         }
-        await this.structuredDataAccessor.writeDocument(identifier, data, metadata);
+        await this.writeRdfDocument(identifier, data, metadata);
         this.invalidateMetadataCache(identifier);
     }
     async writeMetadata(identifier, metadata) {
@@ -102,32 +163,388 @@ class MixDataAccessor {
     }
     async deleteResource(identifier) {
         const metadata = await this.getMetadata(identifier);
-        // Try to delete from unstructured storage if applicable
-        if (this.isUnstructured(metadata)) {
-            try {
-                await this.unstructuredDataAccessor.deleteResource(identifier);
-            }
-            catch (error) {
-                // Ignore file not found errors
-                if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') {
-                    throw error;
-                }
-            }
+        // RDF by-line resources are mirrored to local file storage so shell tools
+        // can operate on real files; remove that mirror together with the index.
+        if (this.isLocalMirroredRdf(identifier, metadata)) {
+            await this.deleteRdfFileResourceIfPresent(identifier);
+        }
+        else if (this.isUnstructured(metadata)) {
+            await this.deleteUnstructuredResourceIfPresent(identifier);
         }
         // Always delete from structured storage (contains metadata)
         await this.structuredDataAccessor.deleteResource(identifier);
         this.invalidateMetadataCache(identifier);
     }
     /**
-     * Execute SPARQL UPDATE on structured data accessor.
-     * Delegates to the underlying structuredDataAccessor if it supports SPARQL.
+     * Execute SPARQL UPDATE.
+     *
+     * Supported embedded deltas patch the local RDF authority file first and then
+     * rebuild the structured RDF index. Unsupported shapes keep using the
+     * compatibility accessor until the embedded engine covers them.
      */
     async executeSparqlUpdate(query, baseIri) {
+        if (baseIri) {
+            const identifier = { path: baseIri };
+            if (this.isByLineRdfIdentifier(identifier)) {
+                try {
+                    await this.executeLocalRdfSparqlUpdate(query, identifier);
+                    this.invalidateMetadataCache(identifier);
+                    return;
+                }
+                catch (error) {
+                    if (!(error instanceof RdfSparqlAdapter_1.UnsupportedSparqlQueryError)) {
+                        throw error;
+                    }
+                }
+            }
+        }
         const accessor = this.structuredDataAccessor;
         if (typeof accessor.executeSparqlUpdate !== 'function') {
             throw new Error('Structured data accessor does not support SPARQL UPDATE');
         }
-        return accessor.executeSparqlUpdate(query, baseIri);
+        await accessor.executeSparqlUpdate(query, baseIri);
+        if (baseIri) {
+            const identifier = { path: baseIri };
+            await this.refreshLocalRdfMirror(identifier);
+            this.invalidateMetadataCache(identifier);
+        }
+    }
+    async executeLocalRdfSparqlUpdate(query, identifier) {
+        const delta = this.rdfSparqlAdapter.compileUpdateDelta(query, identifier.path);
+        this.assertLocalRdfDeltaTargetsGraph(delta.operations, identifier.path);
+        const existingText = await this.readLocalRdfTextOrEmpty(identifier);
+        const graph = n3_1.DataFactory.namedNode(identifier.path);
+        const existingQuads = existingText.length > 0
+            ? await this.parseLocalRdf(identifier, existingText, this.localRdfContentType(identifier))
+                .then((quads) => quads.map((quad) => this.toGraphQuad(quad, graph)))
+            : [];
+        const nextQuads = this.applyLocalRdfDelta(existingQuads, delta.operations);
+        const authorityQuads = nextQuads.map((quad) => this.toDefaultGraphQuad(quad));
+        await this.writeLocalRdfAuthority(identifier, authorityQuads);
+        await this.writeStructuredRdfIndex(identifier, authorityQuads, new community_server_1.RepresentationMetadata(identifier));
+    }
+    applyLocalRdfDelta(quads, operations) {
+        const byKey = new Map(quads.map((quad) => [this.quadKey(quad), quad]));
+        for (const operation of operations) {
+            if (operation.type === 'insert') {
+                for (const quad of operation.quads) {
+                    byKey.set(this.quadKey(quad), quad);
+                }
+                continue;
+            }
+            if (operation.type === 'delete') {
+                for (const quad of operation.quads) {
+                    byKey.delete(this.quadKey(quad));
+                }
+                continue;
+            }
+            if (operation.type === 'insertDeleteWhere') {
+                const rows = this.queryLocalUpdateBindings([...byKey.values()], operation.query);
+                for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.deletes, rows)) {
+                    byKey.delete(this.quadKey(quad));
+                }
+                for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows)) {
+                    byKey.set(this.quadKey(quad), quad);
+                }
+                continue;
+            }
+            if (operation.type === 'insertWhere') {
+                const rows = this.queryLocalUpdateBindings([...byKey.values()], operation.query);
+                for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.inserts, rows)) {
+                    byKey.set(this.quadKey(quad), quad);
+                }
+                continue;
+            }
+            const rows = this.queryLocalUpdateBindings([...byKey.values()], operation.query);
+            for (const quad of this.rdfSparqlAdapter.materializeDeleteWhere(operation.template, rows)) {
+                byKey.delete(this.quadKey(quad));
+            }
+        }
+        return [...byKey.values()];
+    }
+    assertLocalRdfDeltaTargetsGraph(operations, graphIri) {
+        for (const operation of operations) {
+            const graphTerms = operation.type === 'deleteWhere'
+                ? operation.template.map((item) => item.graph)
+                : 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) {
+                if (!('termType' in graph) || graph.termType !== 'NamedNode' || graph.value !== graphIri) {
+                    throw new RdfSparqlAdapter_1.UnsupportedSparqlQueryError('Embedded local RDF update only supports the target document graph');
+                }
+            }
+        }
+    }
+    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 patterns = [...query.patterns];
+        for (const optional of query.optional ?? []) {
+            patterns.push(...(Array.isArray(optional) ? optional : optional.patterns));
+        }
+        for (const union of query.unions ?? []) {
+            for (const branch of union.branches) {
+                patterns.push(...branch.patterns);
+                for (const optional of branch.optional ?? []) {
+                    patterns.push(...(Array.isArray(optional) ? optional : optional.patterns));
+                }
+            }
+        }
+        return patterns.flatMap((pattern) => pattern.graph ? [pattern.graph] : []);
+    }
+    async readLocalRdfTextOrEmpty(identifier) {
+        try {
+            return await this.readStreamText(await this.rdfFileDataAccessor.getData(identifier));
+        }
+        catch (error) {
+            if (community_server_1.NotFoundHttpError.isInstance(error)) {
+                await this.refreshLocalRdfMirror(identifier);
+                try {
+                    return await this.readStreamText(await this.rdfFileDataAccessor.getData(identifier));
+                }
+                catch (retryError) {
+                    if (community_server_1.NotFoundHttpError.isInstance(retryError)) {
+                        return '';
+                    }
+                    throw retryError;
+                }
+            }
+            throw error;
+        }
+    }
+    async writeLocalRdfAuthority(identifier, quads) {
+        await this.ensureRdfFileParentContainers(identifier);
+        await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([await this.serializeQuadsForLocalFile(identifier, quads)])), this.createLocalRdfMetadata(identifier, new community_server_1.RepresentationMetadata(identifier)));
+    }
+    toDefaultGraphQuad(quad) {
+        return n3_1.DataFactory.quad(quad.subject, quad.predicate, quad.object);
+    }
+    toGraphQuad(quad, graph) {
+        return n3_1.DataFactory.quad(quad.subject, quad.predicate, quad.object, graph);
+    }
+    quadKey(quad) {
+        return [quad.graph, quad.subject, quad.predicate, quad.object]
+            .map((term) => (0, n3_1.termToId)(term))
+            .join('\u001f');
+    }
+    /**
+     * Rebuild the structured RDF index from an already-written local RDF file.
+     *
+     * SolidFS uses this after tools edit `.ttl`/`.jsonld` files directly. The
+     * local file remains the content authority; the structured accessor is only
+     * refreshed as query/index state.
+     */
+    async syncLocalRdfDocument(identifier, data, contentType, options) {
+        if (!this.isRdfDocumentIdentifier(identifier)) {
+            throw new Error(`Cannot sync non RDF document into RDF index: ${identifier.path}`);
+        }
+        const source = data ?? await this.rdfFileDataAccessor.getData(identifier);
+        const localContentType = contentType ?? this.localRdfContentType(identifier);
+        const text = await this.readStreamText(source);
+        if (data) {
+            await this.ensureRdfFileParentContainers(identifier);
+            await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([text])), this.createLocalRdfMetadata(identifier, new community_server_1.RepresentationMetadata(identifier)));
+        }
+        const quads = await this.parseLocalRdf(identifier, text, localContentType);
+        await this.writeStructuredRdfIndex(identifier, quads, new community_server_1.RepresentationMetadata(identifier), {
+            ...options,
+            contentType: localContentType,
+        });
+        this.invalidateMetadataCache(identifier);
+    }
+    async deleteLocalRdfIndex(identifier) {
+        try {
+            const sourceScopedAccessor = this.sourceScopedStructuredAccessor();
+            if (sourceScopedAccessor) {
+                await sourceScopedAccessor.deleteRdfSourceDocument(identifier);
+            }
+            else {
+                await this.structuredDataAccessor.deleteResource(identifier);
+            }
+            this.invalidateMetadataCache(identifier);
+        }
+        catch (error) {
+            if (!community_server_1.NotFoundHttpError.isInstance(error)) {
+                throw error;
+            }
+        }
+    }
+    async writeRdfDocument(identifier, data, metadata) {
+        const quads = await (0, arrayify_stream_1.default)(data);
+        const structuredMetadata = new community_server_1.RepresentationMetadata(metadata);
+        (0, community_server_1.addResourceMetadata)(structuredMetadata, false);
+        (0, community_server_1.updateModifiedDate)(structuredMetadata);
+        await this.ensureRdfFileParentContainers(identifier);
+        await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([await this.serializeQuadsForLocalFile(identifier, quads)])), this.createLocalRdfMetadata(identifier, metadata));
+        try {
+            await this.writeStructuredRdfIndex(identifier, quads, structuredMetadata);
+        }
+        catch (error) {
+            await this.deleteRdfFileResourceIfPresent(identifier);
+            throw error;
+        }
+    }
+    async writeStructuredRdfIndex(identifier, quads, metadata, options = {}) {
+        const structuredMetadata = new community_server_1.RepresentationMetadata(metadata);
+        (0, community_server_1.addResourceMetadata)(structuredMetadata, false);
+        (0, community_server_1.updateModifiedDate)(structuredMetadata);
+        const sourceScopedAccessor = this.sourceScopedStructuredAccessor();
+        if (sourceScopedAccessor) {
+            await sourceScopedAccessor.writeRdfSourceDocument(identifier, quads, structuredMetadata, this.rdfSourceInput(identifier, options));
+            return;
+        }
+        await this.structuredDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from(quads)), structuredMetadata);
+    }
+    async refreshLocalRdfMirror(identifier) {
+        let metadata;
+        let quads;
+        try {
+            metadata = await this.structuredDataAccessor.getMetadata(identifier);
+            if (!this.isLocalMirroredRdf(identifier, metadata)) {
+                return;
+            }
+            quads = await (0, arrayify_stream_1.default)(await this.structuredDataAccessor.getData(identifier));
+        }
+        catch (error) {
+            if (community_server_1.NotFoundHttpError.isInstance(error)) {
+                await this.deleteRdfFileResourceIfPresent(identifier);
+                return;
+            }
+            throw error;
+        }
+        await this.ensureRdfFileParentContainers(identifier);
+        await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([await this.serializeQuadsForLocalFile(identifier, quads)])), this.createLocalRdfMetadata(identifier, metadata));
+    }
+    async getLocalRdfMetadata(identifier, sourceMetadata) {
+        try {
+            return await this.getExistingLocalRdfMetadata(identifier);
+        }
+        catch (error) {
+            if (!community_server_1.NotFoundHttpError.isInstance(error)) {
+                throw error;
+            }
+            return this.createLocalRdfMetadata(identifier, sourceMetadata);
+        }
+    }
+    async getExistingLocalRdfMetadata(identifier) {
+        const metadata = await this.rdfFileDataAccessor.getMetadata(identifier);
+        metadata.contentType = this.localRdfContentType(identifier);
+        return metadata;
+    }
+    createLocalRdfMetadata(identifier, metadata) {
+        const localMetadata = new community_server_1.RepresentationMetadata(metadata);
+        localMetadata.contentType = this.localRdfContentType(identifier);
+        return localMetadata;
+    }
+    localRdfContentType(identifier) {
+        return (0, RdfContentTypes_1.rdfContentTypeForPath)(identifier.path) ?? 'text/turtle';
+    }
+    sourceScopedStructuredAccessor() {
+        const accessor = this.structuredDataAccessor;
+        if (typeof accessor.writeRdfSourceDocument === 'function'
+            && typeof accessor.deleteRdfSourceDocument === 'function') {
+            return accessor;
+        }
+        return undefined;
+    }
+    rdfSourceInput(identifier, options) {
+        const workspace = options.workspace ?? this.parentContainer(identifier).path;
+        return {
+            source: options.source ?? identifier.path,
+            workspace,
+            localPath: options.localPath ?? this.relativePathFromWorkspace(identifier.path, workspace),
+            contentType: options.contentType ?? this.localRdfContentType(identifier),
+            sourceVersion: options.sourceVersion,
+        };
+    }
+    relativePathFromWorkspace(identifierPath, workspaceValue) {
+        try {
+            const resource = new URL(identifierPath);
+            const workspace = new URL(workspaceValue.endsWith('/') ? workspaceValue : `${workspaceValue}/`);
+            if (resource.origin !== workspace.origin || !resource.pathname.startsWith(workspace.pathname)) {
+                return undefined;
+            }
+            return decodeURIComponent(resource.pathname.slice(workspace.pathname.length));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    isByLineRdfIdentifier(identifier) {
+        return (0, RdfContentTypes_1.isLineAddressableRdfPath)(identifier.path);
+    }
+    isRdfDocumentIdentifier(identifier) {
+        return (0, RdfContentTypes_1.isRdfDocumentPath)(identifier.path);
+    }
+    isLocalMirroredRdf(identifier, metadata) {
+        return metadata.contentType === community_server_1.INTERNAL_QUADS || this.isRdfDocumentIdentifier(identifier);
+    }
+    async serializeQuadsForLocalFile(identifier, quads) {
+        if (this.localRdfContentType(identifier) === 'application/ld+json') {
+            const nquads = await this.serializeNQuads(quads);
+            const document = await jsonld_1.default.fromRDF(nquads, { format: 'application/n-quads' });
+            return `${JSON.stringify(document, null, 2)}\n`;
+        }
+        if (this.localRdfContentType(identifier) === 'application/rdf+xml') {
+            return (0, RdfXmlSerializer_1.serializeRdfXml)(quads);
+        }
+        const writer = new n3_1.Writer({ format: this.localRdfContentType(identifier) });
+        return writer.quadsToString(quads);
+    }
+    async serializeNQuads(quads) {
+        return new Promise((resolve, reject) => {
+            const writer = new n3_1.Writer({ format: 'application/n-quads' });
+            writer.addQuads(quads);
+            writer.end((error, result) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+    }
+    async parseLocalRdf(identifier, text, contentType) {
+        if (contentType === 'application/ld+json') {
+            const nquads = await jsonld_1.default.toRDF(JSON.parse(text), {
+                base: identifier.path,
+                format: 'application/n-quads',
+            });
+            return new n3_1.Parser({ format: 'application/n-quads', baseIRI: identifier.path }).parse(nquads);
+        }
+        if (contentType === 'application/rdf+xml') {
+            return (0, arrayify_stream_1.default)(rdf_parse_1.rdfParser.parse(stream_1.Readable.from([text]), {
+                contentType,
+                baseIRI: identifier.path,
+            }));
+        }
+        return new n3_1.Parser({ format: contentType, baseIRI: identifier.path }).parse(text);
+    }
+    async readStreamText(data) {
+        const chunks = await (0, arrayify_stream_1.default)(data);
+        return chunks
+            .map((chunk) => typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'))
+            .join('');
     }
     /**
      * Write unstructured document: store data in unstructured accessor,
@@ -162,6 +579,84 @@ class MixDataAccessor {
             throw error;
         }
     }
+    async deleteUnstructuredResourceIfPresent(identifier) {
+        try {
+            await this.unstructuredDataAccessor.deleteResource(identifier);
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR' && !community_server_1.NotFoundHttpError.isInstance(error)) {
+                throw error;
+            }
+        }
+    }
+    async deleteRdfFileResourceIfPresent(identifier) {
+        try {
+            await this.rdfFileDataAccessor.deleteResource(identifier);
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR' && !community_server_1.NotFoundHttpError.isInstance(error)) {
+                throw error;
+            }
+        }
+    }
+    async ensureUnstructuredParentContainers(identifier) {
+        await this.ensureParentContainers(identifier, this.unstructuredDataAccessor);
+    }
+    async ensureRdfFileParentContainers(identifier) {
+        await this.ensureParentContainers(identifier, this.rdfFileDataAccessor);
+    }
+    async ensureParentContainers(identifier, accessor) {
+        const containers = [];
+        let current = this.parentContainer(identifier);
+        while (!this.sameIdentifier(current, identifier)) {
+            containers.push(current);
+            const next = this.parentContainer(current);
+            if (this.sameIdentifier(next, current)) {
+                break;
+            }
+            current = next;
+        }
+        for (const container of containers.reverse()) {
+            await this.writeContainerIfMissing(accessor, container);
+        }
+    }
+    async writeContainerIfMissing(accessor, identifier) {
+        try {
+            await accessor.getMetadata(identifier);
+            return;
+        }
+        catch (error) {
+            if (!community_server_1.NotFoundHttpError.isInstance(error)) {
+                throw error;
+            }
+        }
+        await accessor.writeContainer(identifier, new community_server_1.RepresentationMetadata(identifier));
+    }
+    sameIdentifier(left, right) {
+        return left.path === right.path;
+    }
+    parentContainer(identifier) {
+        try {
+            const url = new URL(identifier.path);
+            if (url.pathname === '/' || url.pathname === '') {
+                return { path: url.href.endsWith('/') ? url.href : `${url.href}/` };
+            }
+            const segments = url.pathname.replace(/\/+$/u, '').split('/');
+            segments.pop();
+            url.pathname = `${segments.join('/') || '/'}`.replace(/\/?$/u, '/');
+            url.search = '';
+            url.hash = '';
+            return { path: url.href };
+        }
+        catch {
+            const trimmed = identifier.path.replace(/\/+$/u, '');
+            const slashIndex = trimmed.lastIndexOf('/');
+            if (slashIndex < 0) {
+                return identifier;
+            }
+            return { path: `${trimmed.slice(0, slashIndex + 1)}` };
+        }
+    }
     invalidateMetadataCache(identifier) {
         const cache = MetadataRequestContext_1.metadataRequestContext.getStore()?.metadataCache;
         if (!cache) {