@undefineds.co/xpod 0.4.19 → 0.4.25

package/dist/storage/StorageVersion.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyStorageVersionError = exports.storageVersionReadContext = exports.STORAGE_ETAG_PATTERN = exports.storageVersionReceipts = void 0;
+exports.getStorageVersion = getStorageVersion;
+exports.stampStorageVersion = stampStorageVersion;
+exports.captureStorageVersion = captureStorageVersion;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = require("node:crypto");
+const community_server_1 = require("@solid/community-server");
+const n3_1 = require("n3");
+/** Write receipts captured only after the corresponding metadata has been persisted. */
+exports.storageVersionReceipts = new node_async_hooks_1.AsyncLocalStorage();
+exports.STORAGE_ETAG_PATTERN = /^"xpod-([a-f0-9]{32})-([A-Za-z0-9_-]+)"$/;
+/** Only locked representation reads request lazy initialization of legacy metadata. */
+exports.storageVersionReadContext = new node_async_hooks_1.AsyncLocalStorage();
+/** The locking store must release its read locks before running this callback under write locks. */
+class LegacyStorageVersionError extends Error {
+    constructor(identifier, initialize) {
+        super('Legacy resource metadata requires a persisted storage revision');
+        this.identifier = identifier;
+        this.initialize = initialize;
+    }
+}
+exports.LegacyStorageVersionError = LegacyStorageVersionError;
+function getStorageVersion(metadata) {
+    const value = metadata.get(community_server_1.HH.terms.etag)?.value;
+    return value && (/^[a-f0-9]{32}$/.test(value) ? value : exports.STORAGE_ETAG_PATTERN.exec(value)?.[1]);
+}
+function stampStorageVersion(metadata) {
+    // HTTP storage metadata, not a Pod business field. Never trust a supplied revision.
+    metadata.set(community_server_1.HH.terms.etag, n3_1.DataFactory.literal((0, node_crypto_1.randomUUID)().replaceAll('-', '')));
+}
+function captureStorageVersion(metadata) {
+    exports.storageVersionReceipts.getStore()?.set(metadata.identifier.value, new community_server_1.RepresentationMetadata(metadata));
+}
+//# sourceMappingURL=StorageVersion.js.map

package/dist/storage/accessors/MinioDataAccessor.js

@@ -185,7 +185,8 @@ class MinioDataAccessor {
      */
     async deleteResource(identifier) {
         const link = new URL(identifier.path);
-        await this.client.removeObject(this.bucketName, this.objectName(link));
+        const key = (0, community_server_1.isContainerIdentifier)(identifier) ? this.containerObjectName(link) : this.objectName(link);
+        await this.client.removeObject(this.bucketName, key);
     }
     /**
      * Reads and generates all metadata relevant for the given file,

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

@@ -25,6 +25,8 @@ export interface LocalRdfSyncOptions {
     workspace?: string;
     localPath?: string;
     sourceVersion?: string;
+    /** Physical input path, used to avoid copying an authority file onto itself. */
+    sourcePath?: string;
 }
 export interface LocalRdfMoveOptions extends LocalRdfSyncOptions {
     previousSource?: string;
@@ -42,6 +44,7 @@ export interface SourceScopedStructuredRdfAccessor {
 }
 export interface LocalRdfAuthorityJournalOperation {
     id: string;
+    afterHash?: string;
 }
 export interface LocalRdfAuthorityJournal {
     recordLocalCommitted(change: SolidFsChange, workspace: SolidFsManifest, txId?: string): Promise<LocalRdfAuthorityJournalOperation>;
@@ -94,7 +97,11 @@ export declare class MixDataAccessor implements DataAccessor, LocalRdfIndexAcces
     writeContainer(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
     writeDocument(identifier: ResourceIdentifier, data: Guarded<Readable>, metadata: RepresentationMetadata): Promise<void>;
     writeMetadata(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
+    /** Sweep graph-only provisioning facts after resource/source lifecycle deletion. */
+    deletePodRdfGraphs(identifier: ResourceIdentifier): Promise<void>;
     deleteResource(identifier: ResourceIdentifier): Promise<void>;
+    /** Whether this document can commit a direct native source-file update. */
+    supportsSparqlUpdate(identifier: ResourceIdentifier): boolean;
     /**
      * Execute SPARQL UPDATE.
      *

package/dist/storage/accessors/MixDataAccessor.js

@@ -20,6 +20,7 @@ const RdfXmlSerializer_1 = require("../rdf/RdfXmlSerializer");
 const RdfAccessScope_1 = require("../rdf/RdfAccessScope");
 const MetadataRequestContext_1 = require("../MetadataRequestContext");
 const ResourceReadContext_1 = require("../ResourceReadContext");
+const StorageVersion_1 = require("../StorageVersion");
 /**
  * MixDataAccessor - Routes data to appropriate storage based on content type
  *
@@ -85,9 +86,21 @@ class MixDataAccessor {
         }
         if (this.isByLineRdfIdentifier(identifier)) {
             try {
+                let sourceMetadata = new community_server_1.RepresentationMetadata(identifier);
+                if (StorageVersion_1.storageVersionReadContext.getStore()) {
+                    try {
+                        sourceMetadata = await this.getMetadata(identifier);
+                    }
+                    catch (error) {
+                        if (!community_server_1.NotFoundHttpError.isInstance(error))
+                            throw error;
+                        // A file awaiting indexing remains readable, but cannot supply a storage revision.
+                    }
+                }
+                const metadata = await this.getLocalRdfMetadata(identifier, sourceMetadata);
                 return {
                     data: await this.rdfFileDataAccessor.getData(identifier),
-                    metadata: await this.getExistingLocalRdfMetadata(identifier),
+                    metadata,
                 };
             }
             catch (error) {
@@ -167,12 +180,26 @@ class MixDataAccessor {
         await this.structuredDataAccessor.writeMetadata(identifier, metadata);
         this.invalidateMetadataCache(identifier);
     }
+    /** Sweep graph-only provisioning facts after resource/source lifecycle deletion. */
+    async deletePodRdfGraphs(identifier) {
+        const accessor = this.structuredDataAccessor;
+        if (!accessor.deletePodRdfGraphs) {
+            throw new Error('Structured accessor does not support Pod-scoped graph cleanup');
+        }
+        await accessor.deletePodRdfGraphs(identifier);
+        this.invalidateMetadataCache(identifier);
+    }
     async deleteResource(identifier) {
         const metadata = await this.getMetadata(identifier);
         // 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);
+            // Blob writes may have created a separate object-store container marker,
+            // even though the container's authoritative metadata is RDF.
+            if ((0, community_server_1.isContainerIdentifier)(identifier) && this.unstructuredDataAccessor !== this.rdfFileDataAccessor) {
+                await this.deleteUnstructuredResourceIfPresent(identifier);
+            }
             await this.deleteSearchIndexes(identifier);
         }
         else if (this.isUnstructured(metadata)) {
@@ -183,6 +210,10 @@ class MixDataAccessor {
         await this.structuredDataAccessor.deleteResource(identifier);
         this.invalidateMetadataCache(identifier);
     }
+    /** Whether this document can commit a direct native source-file update. */
+    supportsSparqlUpdate(identifier) {
+        return this.isByLineRdfIdentifier(identifier);
+    }
     /**
      * Execute SPARQL UPDATE.
      *
@@ -348,7 +379,6 @@ class MixDataAccessor {
             type: patch.previousExists ? 'updated' : 'created',
         })));
         return mapped.map(({ patch, link }) => ({
-            patch,
             workspace,
             txId,
             change: {
@@ -465,16 +495,33 @@ class MixDataAccessor {
         const source = data ?? await this.rdfFileDataAccessor.getData(identifier);
         const localContentType = contentType ?? this.localRdfContentType(identifier);
         const text = await this.readStreamText(source);
-        if (data) {
+        const targetPath = data && options?.sourcePath && this.rdfFileMapper
+            ? (await this.rdfFileMapper.mapUrlToFilePath(identifier, false, localContentType)).filePath
+            : undefined;
+        const readsAuthority = targetPath && node_path_1.default.resolve(targetPath) === node_path_1.default.resolve(options.sourcePath);
+        if (data && !readsAuthority) {
             await this.ensureRdfFileParentContainers(identifier);
             const localMetadata = this.createLocalRdfMetadata(identifier, new community_server_1.RepresentationMetadata(identifier));
             localMetadata.contentType = localContentType;
             await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([text])), localMetadata);
         }
         const quads = await this.parseLocalRdf(identifier, text, localContentType);
-        await this.writeStructuredRdfIndex(identifier, quads, new community_server_1.RepresentationMetadata(identifier), {
+        let metadata;
+        try {
+            metadata = await this.structuredDataAccessor.getMetadata(identifier);
+        }
+        catch (error) {
+            if (!community_server_1.NotFoundHttpError.isInstance(error))
+                throw error;
+            metadata = new community_server_1.RepresentationMetadata(identifier);
+        }
+        const fileMetadata = await this.getExistingLocalRdfMetadata(identifier);
+        const modified = fileMetadata.get(community_server_1.DC.terms.modified)?.value;
+        const modifiedAt = modified ? new Date(modified) : undefined;
+        await this.writeStructuredRdfIndex(identifier, quads, metadata, {
             ...options,
             contentType: localContentType,
+            ...(modifiedAt && Number.isFinite(modifiedAt.getTime()) ? { modifiedAt } : {}),
         });
         await this.syncTextSearchIndex(identifier, text, {
             ...options,
@@ -520,21 +567,55 @@ class MixDataAccessor {
         (0, community_server_1.updateModifiedDate)(structuredMetadata);
         await this.ensureRdfFileParentContainers(identifier);
         const text = await this.serializeQuadsForLocalFile(identifier, quads);
+        let journalDraft;
+        if (this.localRdfAuthorityJournal && this.rdfFileMapper) {
+            let previousExists = false;
+            try {
+                await this.structuredDataAccessor.getMetadata(identifier);
+                previousExists = true;
+            }
+            catch (error) {
+                if (!community_server_1.NotFoundHttpError.isInstance(error))
+                    throw error;
+            }
+            [journalDraft] = await this.prepareLocalRdfAuthorityJournalPatches([{ identifier, previousExists }]);
+        }
         await this.rdfFileDataAccessor.writeDocument(identifier, (0, community_server_1.guardStream)(stream_1.Readable.from([text])), this.createLocalRdfMetadata(identifier, metadata));
+        let operation;
         try {
+            operation = await this.recordLocalRdfAuthorityJournalPatch(journalDraft);
+            if (operation && !operation.afterHash?.endsWith(`:${(0, node_crypto_1.createHash)('sha256').update(text).digest('hex')}`)) {
+                throw new Error('Local RDF authority changed before its index write');
+            }
             await this.writeStructuredRdfIndex(identifier, quads, structuredMetadata);
             await this.syncTextSearchIndex(identifier, text, {}, quads);
+            if (operation)
+                await this.localRdfAuthorityJournal.markDone(operation.id);
         }
         catch (error) {
-            await this.deleteRdfFileResourceIfPresent(identifier);
-            await this.deleteSearchIndexes(identifier);
+            if (this.localRdfAuthorityJournal) {
+                // The authority is durable even if journal insertion failed. Bootstrap can
+                // discover it without a receipt; never delete committed data in this case.
+                if (operation) {
+                    try {
+                        await this.localRdfAuthorityJournal.markRetryableFailure(operation.id, error);
+                    }
+                    catch (journalError) {
+                        this.logger.error(`Failed to record RDF authority recovery failure: ${String(journalError)}`);
+                    }
+                }
+            }
+            else {
+                await this.deleteRdfFileResourceIfPresent(identifier);
+                await this.deleteSearchIndexes(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);
+        (0, community_server_1.updateModifiedDate)(structuredMetadata, options.modifiedAt);
         const sourceScopedAccessor = this.sourceScopedStructuredAccessor();
         if (sourceScopedAccessor) {
             await sourceScopedAccessor.writeRdfSourceDocument(identifier, quads, structuredMetadata, this.rdfSourceInput(identifier, options));
@@ -565,15 +646,23 @@ class MixDataAccessor {
         await this.syncTextSearchIndex(identifier, text, {}, quads);
     }
     async getLocalRdfMetadata(identifier, sourceMetadata) {
+        let metadata;
         try {
-            return await this.getExistingLocalRdfMetadata(identifier);
+            metadata = await this.getExistingLocalRdfMetadata(identifier);
         }
         catch (error) {
             if (!community_server_1.NotFoundHttpError.isInstance(error)) {
                 throw error;
             }
-            return this.createLocalRdfMetadata(identifier, sourceMetadata);
-        }
+            metadata = this.createLocalRdfMetadata(identifier, sourceMetadata);
+        }
+        // File bytes/content type remain file-owned; conditional versions always come from
+        // the structured metadata read under the same resource lock, never a stale sidecar.
+        metadata.removeAll(community_server_1.HH.terms.etag);
+        const revision = (0, StorageVersion_1.getStorageVersion)(sourceMetadata);
+        if (revision)
+            metadata.set(community_server_1.HH.terms.etag, n3_1.DataFactory.literal(revision));
+        return metadata;
     }
     async getExistingLocalRdfMetadata(identifier) {
         try {

package/dist/storage/accessors/MixDataAccessor.jsonld

@@ -246,10 +246,18 @@
           "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_writeMetadata",
           "memberFieldName": "writeMetadata"
         },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_deletePodRdfGraphs",
+          "memberFieldName": "deletePodRdfGraphs"
+        },
         {
           "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_deleteResource",
           "memberFieldName": "deleteResource"
         },
+        {
+          "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_supportsSparqlUpdate",
+          "memberFieldName": "supportsSparqlUpdate"
+        },
         {
           "@id": "undefineds:dist/storage/accessors/MixDataAccessor.jsonld#MixDataAccessor__member_executeSparqlUpdate",
           "memberFieldName": "executeSparqlUpdate"

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

@@ -25,6 +25,7 @@ export declare class SolidRdfDataAccessor implements DataAccessor {
     canHandle(representation: Representation): Promise<void>;
     getData(identifier: ResourceIdentifier): Promise<Guarded<Readable>>;
     getMetadata(identifier: ResourceIdentifier): Promise<RepresentationMetadata>;
+    private initializeStorageVersion;
     getChildren(identifier: ResourceIdentifier): AsyncIterableIterator<RepresentationMetadata>;
     writeContainer(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
     writeDocument(identifier: ResourceIdentifier, data: Guarded<Readable>, metadata: RepresentationMetadata): Promise<void>;
@@ -39,6 +40,8 @@ export declare class SolidRdfDataAccessor implements DataAccessor {
     deleteRdfSourceDocument(identifier: ResourceIdentifier): Promise<void>;
     writeMetadata(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
     deleteResource(identifier: ResourceIdentifier): Promise<void>;
+    /** Final lifecycle sweep for Pod facts not reachable through LDP containment. */
+    deletePodRdfGraphs(identifier: ResourceIdentifier): Promise<void>;
     getDataByGraphPrefix(prefix: string): Promise<Quint[]>;
     prepareSparqlUpdate(query: string, baseIri: string, accessScope?: RdfNativeSparqlAccessScope, options?: {
         timeoutMs?: number;

package/dist/storage/accessors/SolidRdfDataAccessor.js

@@ -13,6 +13,7 @@ const community_server_1 = require("@solid/community-server");
 const RdfAccessScope_1 = require("../rdf/RdfAccessScope");
 const RdfSparqlBoundary_1 = require("../rdf/RdfSparqlBoundary");
 const RdfSparqlAdapter_1 = require("../rdf/RdfSparqlAdapter");
+const StorageVersion_1 = require("../StorageVersion");
 const { defaultGraph, namedNode, quad } = n3_1.DataFactory;
 exports.PREPARED_UPDATE_MEDIA_TYPE = 'application/vnd.xpod.rdf-prepared-delta+json;version=1';
 function preparedTerm(value) {
@@ -181,8 +182,25 @@ class SolidRdfDataAccessor {
         if (!(0, community_server_1.isContainerIdentifier)(identifier) && !metadata.contentType) {
             metadata.contentType = community_server_1.INTERNAL_QUADS;
         }
+        if (StorageVersion_1.storageVersionReadContext.getStore() && !(0, StorageVersion_1.getStorageVersion)(metadata)) {
+            throw new StorageVersion_1.LegacyStorageVersionError(identifier, () => this.initializeStorageVersion(identifier));
+        }
         return metadata;
     }
+    async initializeStorageVersion(identifier) {
+        // Invoked by HierarchyLockingResourceStore under the same write locks as all resource mutations.
+        // Re-read after acquiring the locks: another reader or writer may already have initialized it.
+        const metadata = await this.getMetadata(identifier);
+        if ((0, StorageVersion_1.getStorageVersion)(metadata))
+            return;
+        (0, StorageVersion_1.stampStorageVersion)(metadata);
+        const name = namedNode(identifier.path);
+        const graph = this.getMetadataNode(name);
+        // Only the server's operational revision changes; preserve business data and modification time.
+        await this.rdfEngine.delete({ graph, subject: name, predicate: community_server_1.HH.terms.etag });
+        await this.rdfEngine.put([quad(name, community_server_1.HH.terms.etag, n3_1.DataFactory.literal(metadata.get(community_server_1.HH.terms.etag).value), graph)]);
+        (0, StorageVersion_1.captureStorageVersion)(metadata);
+    }
     async *getChildren(identifier) {
         await this.initialize();
         const name = namedNode(identifier.path);
@@ -305,13 +323,7 @@ class SolidRdfDataAccessor {
     async writeMetadata(identifier, metadata) {
         await this.initialize();
         const { name, parent } = this.getRelatedNames(identifier);
-        const metaName = this.getMetadataNode(name);
-        await this.rdfEngine.delete({ graph: metaName });
-        const inserts = this.toGraphQuads(metaName, metadata.quads());
-        if (parent) {
-            inserts.push(quad(parent, community_server_1.LDP.terms.contains, name, parent));
-        }
-        await this.rdfEngine.put(inserts);
+        await this.replaceMetadata(name, metadata, parent);
     }
     async deleteResource(identifier) {
         await this.initialize();
@@ -327,6 +339,15 @@ class SolidRdfDataAccessor {
             });
         }
     }
+    /** Final lifecycle sweep for Pod facts not reachable through LDP containment. */
+    async deletePodRdfGraphs(identifier) {
+        if (!identifier.path.endsWith('/')) {
+            throw new Error('Pod graph cleanup requires a container identifier');
+        }
+        await this.initialize();
+        await this.rdfEngine.delete({ graph: { $startsWith: identifier.path } });
+        await this.rdfEngine.delete({ graph: { $startsWith: `meta:${identifier.path}` } });
+    }
     async getDataByGraphPrefix(prefix) {
         await this.initialize();
         const scan = await this.rdfEngine.scan({
@@ -425,6 +446,7 @@ class SolidRdfDataAccessor {
         return identifier.path.startsWith('meta:');
     }
     async replaceMetadata(name, metadata, parent) {
+        (0, StorageVersion_1.stampStorageVersion)(metadata);
         const metaName = this.getMetadataNode(name);
         await this.rdfEngine.delete({ graph: metaName });
         const inserts = this.toGraphQuads(metaName, metadata.quads());
@@ -432,6 +454,7 @@ class SolidRdfDataAccessor {
             inserts.push(quad(parent, community_server_1.LDP.terms.contains, name, parent));
         }
         await this.rdfEngine.put(inserts);
+        (0, StorageVersion_1.captureStorageVersion)(metadata);
     }
     async putGraphQuads(graph, triples) {
         await this.rdfEngine.put(this.toGraphQuads(graph, triples));

package/dist/storage/accessors/SolidRdfDataAccessor.jsonld

@@ -75,6 +75,10 @@
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_getMetadata",
           "memberFieldName": "getMetadata"
         },
+        {
+          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_initializeStorageVersion",
+          "memberFieldName": "initializeStorageVersion"
+        },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_getChildren",
           "memberFieldName": "getChildren"
@@ -131,6 +135,10 @@
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_deleteResource",
           "memberFieldName": "deleteResource"
         },
+        {
+          "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_deletePodRdfGraphs",
+          "memberFieldName": "deletePodRdfGraphs"
+        },
         {
           "@id": "undefineds:dist/storage/accessors/SolidRdfDataAccessor.jsonld#SolidRdfDataAccessor__member_getDataByGraphPrefix",
           "memberFieldName": "getDataByGraphPrefix"

package/dist/storage/conditions/StorageETagHandler.d.ts

@@ -0,0 +1,9 @@
+import { type ETagHandler, type RepresentationMetadata } from '@solid/community-server';
+/** Render an operational storage revision for the negotiated representation. */
+export declare function getStorageETag(metadata: RepresentationMetadata): string | undefined;
+/** Persisted revision authority for reads, conditional mutations and notifications. */
+export declare class StorageETagHandler implements ETagHandler {
+    getETag(metadata: RepresentationMetadata): string | undefined;
+    matchesETag(metadata: RepresentationMetadata, eTag: string, strict: boolean): boolean;
+    sameResourceState(eTag1: string, eTag2: string): boolean;
+}

package/dist/storage/conditions/StorageETagHandler.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageETagHandler = void 0;
+exports.getStorageETag = getStorageETag;
+const StorageVersion_1 = require("../StorageVersion");
+/** Render an operational storage revision for the negotiated representation. */
+function getStorageETag(metadata) {
+    const revision = (0, StorageVersion_1.getStorageVersion)(metadata);
+    if (revision && metadata.contentType) {
+        return `"xpod-${revision}-${Buffer.from(metadata.contentType).toString('base64url')}"`;
+    }
+    // Uninitialized metadata cannot establish a safe write baseline.
+    return undefined;
+}
+/** Persisted revision authority for reads, conditional mutations and notifications. */
+class StorageETagHandler {
+    getETag(metadata) {
+        return getStorageETag(metadata);
+    }
+    matchesETag(metadata, eTag, strict) {
+        const parsed = StorageVersion_1.STORAGE_ETAG_PATTERN.exec(eTag);
+        return Boolean(parsed && parsed[1] === (0, StorageVersion_1.getStorageVersion)(metadata) &&
+            (!strict || eTag === this.getETag(metadata)));
+    }
+    sameResourceState(eTag1, eTag2) {
+        const first = StorageVersion_1.STORAGE_ETAG_PATTERN.exec(eTag1);
+        const second = StorageVersion_1.STORAGE_ETAG_PATTERN.exec(eTag2);
+        return Boolean(first && second && first[1] === second[1]);
+    }
+}
+exports.StorageETagHandler = StorageETagHandler;
+//# sourceMappingURL=StorageETagHandler.js.map

package/dist/storage/conditions/StorageETagHandler.jsonld

@@ -0,0 +1,34 @@
+{
+  "@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/storage/conditions/StorageETagHandler.jsonld#StorageETagHandler",
+      "@type": "Class",
+      "requireElement": "StorageETagHandler",
+      "extends": [
+        "css:dist/storage/conditions/ETagHandler.jsonld#ETagHandler"
+      ],
+      "comment": "Persisted revision authority for reads, conditional mutations and notifications.",
+      "parameters": [],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/conditions/StorageETagHandler.jsonld#StorageETagHandler__member_getETag",
+          "memberFieldName": "getETag"
+        },
+        {
+          "@id": "undefineds:dist/storage/conditions/StorageETagHandler.jsonld#StorageETagHandler__member_matchesETag",
+          "memberFieldName": "matchesETag"
+        },
+        {
+          "@id": "undefineds:dist/storage/conditions/StorageETagHandler.jsonld#StorageETagHandler__member_sameResourceState",
+          "memberFieldName": "sameResourceState"
+        }
+      ],
+      "constructorArguments": []
+    }
+  ]
+}

package/dist/storage/locking/PodLifecycleLocker.d.ts

@@ -0,0 +1,8 @@
+import type { ExpiringReadWriteLocker, PromiseOrValue, ReadWriteLocker, ResourceIdentifier } from '@solid/community-server';
+/** Adapts a non-expiring local locker without releasing live callbacks on a timer. */
+export declare class PodLifecycleLocker implements ExpiringReadWriteLocker {
+    private readonly source;
+    constructor(source: ReadWriteLocker);
+    withReadLock<T>(identifier: ResourceIdentifier, action: (maintainLock: () => void) => PromiseOrValue<T>): Promise<T>;
+    withWriteLock<T>(identifier: ResourceIdentifier, action: (maintainLock: () => void) => PromiseOrValue<T>): Promise<T>;
+}

package/dist/storage/locking/PodLifecycleLocker.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodLifecycleLocker = void 0;
+/** Adapts a non-expiring local locker without releasing live callbacks on a timer. */
+class PodLifecycleLocker {
+    constructor(source) {
+        this.source = source;
+    }
+    async withReadLock(identifier, action) {
+        return this.source.withReadLock(identifier, () => action(() => { }));
+    }
+    async withWriteLock(identifier, action) {
+        return this.source.withWriteLock(identifier, () => action(() => { }));
+    }
+}
+exports.PodLifecycleLocker = PodLifecycleLocker;
+//# sourceMappingURL=PodLifecycleLocker.js.map

package/dist/storage/locking/PodLifecycleLocker.jsonld

@@ -0,0 +1,47 @@
+{
+  "@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/storage/locking/PodLifecycleLocker.jsonld#PodLifecycleLocker",
+      "@type": "Class",
+      "requireElement": "PodLifecycleLocker",
+      "extends": [
+        "css:dist/util/locking/ExpiringReadWriteLocker.jsonld#ExpiringReadWriteLocker"
+      ],
+      "comment": "Adapts a non-expiring local locker without releasing live callbacks on a timer.",
+      "parameters": [
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleLocker.jsonld#PodLifecycleLocker_source",
+          "range": "css:dist/util/locking/ReadWriteLocker.jsonld#ReadWriteLocker"
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleLocker.jsonld#PodLifecycleLocker__member_source",
+          "memberFieldName": "source"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleLocker.jsonld#PodLifecycleLocker__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleLocker.jsonld#PodLifecycleLocker__member_withReadLock",
+          "memberFieldName": "withReadLock"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleLocker.jsonld#PodLifecycleLocker__member_withWriteLock",
+          "memberFieldName": "withWriteLock"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleLocker.jsonld#PodLifecycleLocker_source"
+        }
+      ]
+    }
+  ]
+}

package/dist/storage/locking/PodLifecycleRedisLocker.d.ts

@@ -0,0 +1,19 @@
+import type { ExpiringReadWriteLocker, PromiseOrValue, ResourceIdentifier } from '@solid/community-server';
+import { UrlAwareRedisLocker, type UrlAwareRedisLockerOptions } from './UrlAwareRedisLocker';
+/**
+ * Destructive lifecycle barriers must outlive their actual writer callbacks.
+ * Keys never expire and startup/shutdown never clears another process's locks.
+ * After a crash, operators must stop/reconcile all writers before removing a
+ * stranded key. Automatic expiry or stealing would permit overlapping writes.
+ */
+export declare class PodLifecycleRedisLocker extends UrlAwareRedisLocker implements ExpiringReadWriteLocker {
+    private readonly active;
+    private closing;
+    private shutdown?;
+    constructor(options?: UrlAwareRedisLockerOptions);
+    initialize(): Promise<void>;
+    withReadLock<T>(identifier: ResourceIdentifier, action: (maintainLock: () => void) => PromiseOrValue<T>): Promise<T>;
+    withWriteLock<T>(identifier: ResourceIdentifier, action: (maintainLock: () => void) => PromiseOrValue<T>): Promise<T>;
+    finalize(): Promise<void>;
+    private track;
+}

package/dist/storage/locking/PodLifecycleRedisLocker.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodLifecycleRedisLocker = void 0;
+const UrlAwareRedisLocker_1 = require("./UrlAwareRedisLocker");
+/**
+ * Destructive lifecycle barriers must outlive their actual writer callbacks.
+ * Keys never expire and startup/shutdown never clears another process's locks.
+ * After a crash, operators must stop/reconcile all writers before removing a
+ * stranded key. Automatic expiry or stealing would permit overlapping writes.
+ */
+class PodLifecycleRedisLocker extends UrlAwareRedisLocker_1.UrlAwareRedisLocker {
+    constructor(options = {}) {
+        super({ ...options, namespacePrefix: `${options.namespacePrefix ?? ''}pod-lifecycle:` });
+        this.active = new Set();
+        this.closing = false;
+    }
+    async initialize() {
+        if (this.closing) {
+            throw new Error('Pod lifecycle locker is closing');
+        }
+        await super.initialize();
+    }
+    async withReadLock(identifier, action) {
+        return this.track(() => super.withReadLock(identifier, action));
+    }
+    async withWriteLock(identifier, action) {
+        return this.track(() => super.withWriteLock(identifier, action));
+    }
+    async finalize() {
+        this.closing = true;
+        this.shutdown ??= (async () => {
+            await Promise.allSettled([...this.active]);
+            await super.finalize();
+        })();
+        return this.shutdown;
+    }
+    async track(run) {
+        if (this.closing) {
+            throw new Error('Pod lifecycle locker is closing');
+        }
+        const pending = run();
+        this.active.add(pending);
+        try {
+            return await pending;
+        }
+        finally {
+            this.active.delete(pending);
+        }
+    }
+}
+exports.PodLifecycleRedisLocker = PodLifecycleRedisLocker;
+//# sourceMappingURL=PodLifecycleRedisLocker.js.map