@undefineds.co/xpod 0.4.20 → 0.4.25

package/dist/solidfs/SolidFsSyncJournal.js

@@ -89,26 +89,61 @@ class SqliteSolidFsSyncJournal {
                  last_error, created_at, updated_at, done_at
           FROM sync_ops
           WHERE stage IN (${stages.map(() => '?').join(', ')})
-          ORDER BY created_at ASC, id ASC
+          ORDER BY created_at ASC, rowid ASC
         `).all(...stages)
             : this.db.prepare(`
           SELECT id, tx_id, workspace_json, change_json, stage, after_hash, retry_count,
                  last_error, created_at, updated_at, done_at
           FROM sync_ops
-          ORDER BY created_at ASC, id ASC
+          ORDER BY created_at ASC, rowid ASC
         `).all();
         return rows.map(rowToOperation);
     }
     listPending() {
         return this.listOperations(['local_committed', 'failed_retryable']);
     }
+    /**
+     * Rebase the operation's expected hash to the file version its own sync produced.
+     *
+     * A direct-projection Pod sync PUTs a resource whose local file is the same
+     * authority file CSS serves, so the write itself moves the file version (mtime,
+     * possibly inode) without changing the bytes. Only that same-bytes timestamp
+     * drift may be rebased. When the content identity (size and digest) differs,
+     * a concurrent writer changed the authority bytes during the sync, so the
+     * original guard must stand and the operation is left for reconciliation.
+     */
+    async recordSyncedSourceHash(id, afterHash) {
+        if (!afterHash) {
+            return;
+        }
+        const op = this.getOperation(id);
+        if (!op || op.stage === 'done' || op.stage === 'failed_permanent') {
+            return;
+        }
+        if (!sameFileContent(op.afterHash, afterHash)) {
+            return;
+        }
+        this.db.prepare(`
+      UPDATE sync_ops
+      SET after_hash = ?, updated_at = ?
+      WHERE id = ? AND stage NOT IN ('done', 'failed_permanent')
+    `).run(afterHash, this.now(), id);
+    }
     async markDone(id) {
         const op = this.getOperation(id);
-        if (!op) {
+        if (!op || op.stage === 'done' || op.stage === 'failed_permanent') {
             return;
         }
+        const validation = await this.validateOperationForReplay(op);
+        if (validation) {
+            await this.markRetryableFailure(id, validation);
+            throw new Error(validation);
+        }
         const now = this.now();
         this.db.transaction(() => {
+            const current = this.getOperation(id);
+            if (!current || current.stage === 'done' || current.stage === 'failed_permanent')
+                return;
             this.db.prepare(`
         UPDATE sync_ops
         SET stage = 'done',
@@ -118,7 +153,16 @@ class SqliteSolidFsSyncJournal {
             tombstone_confirmed_at = CASE WHEN op_type = 'deleted' THEN ? ELSE tombstone_confirmed_at END
         WHERE id = ?
       `).run(now, now, now, id);
-            this.upsertCheckpoint(op, now);
+            this.upsertCheckpoint(current, now);
+            // A successfully indexed newer version supersedes older failed work for this
+            // same authority. Otherwise a recovered/retried PUT would poison the next startup.
+            this.db.prepare(`
+        UPDATE sync_ops SET stage = 'failed_permanent',
+          last_error = 'Superseded by a newer completed authority version', updated_at = ?
+        WHERE source_path = ? AND resource IS ?
+          AND rowid < (SELECT rowid FROM sync_ops WHERE id = ?)
+          AND stage IN ('local_committed', 'failed_retryable', 'reconcile_required')
+      `).run(now, op.change.sourcePath, op.change.resource ?? null, op.id);
         })();
     }
     async markRetryableFailure(id, error) {
@@ -129,7 +173,7 @@ class SqliteSolidFsSyncJournal {
           retry_count = retry_count + 1,
           last_error = ?,
           updated_at = ?
-      WHERE id = ?
+      WHERE id = ? AND stage NOT IN ('done', 'failed_permanent')
     `).run(errorMessage(error), now, id);
     }
     async markReconcileRequired(id, reason) {
@@ -139,7 +183,7 @@ class SqliteSolidFsSyncJournal {
       SET stage = 'reconcile_required',
           last_error = ?,
           updated_at = ?
-      WHERE id = ?
+      WHERE id = ? AND stage NOT IN ('done', 'failed_permanent')
     `).run(reason, now, id);
     }
     async markFailedPermanent(id, error) {
@@ -149,7 +193,7 @@ class SqliteSolidFsSyncJournal {
       SET stage = 'failed_permanent',
           last_error = ?,
           updated_at = ?
-      WHERE id = ?
+      WHERE id = ? AND stage NOT IN ('done', 'failed_permanent')
     `).run(errorMessage(error), now, id);
     }
     async replayPending(syncer, context) {
@@ -159,7 +203,11 @@ class SqliteSolidFsSyncJournal {
             failed: 0,
             reconcileRequired: 0,
         };
-        for (const op of this.listPending()) {
+        for (const snapshot of this.listPending()) {
+            // Earlier work or a concurrent writer may have completed/superseded this entry.
+            const op = this.getOperation(snapshot.id);
+            if (!op || (op.stage !== 'local_committed' && op.stage !== 'failed_retryable'))
+                continue;
             result.attempted += 1;
             const validation = await this.validateOperationForReplay(op);
             if (validation) {
@@ -167,8 +215,12 @@ class SqliteSolidFsSyncJournal {
                 result.reconcileRequired += 1;
                 continue;
             }
+            const current = this.getOperation(op.id);
+            if (!current || (current.stage !== 'local_committed' && current.stage !== 'failed_retryable'))
+                continue;
             try {
                 await syncer.sync(op.change, op.workspace, context);
+                await this.recordSyncedSourceHash(op.id, await (0, SolidFsPathUtils_1.maybeFileVersion)(op.change.sourcePath));
                 await this.markDone(op.id);
                 result.completed += 1;
             }
@@ -196,16 +248,37 @@ class SqliteSolidFsSyncJournal {
             skipped: 0,
         };
         for (const snapshot of snapshots) {
+            const resource = input.resolveResource
+                ? await input.resolveResource(node_path_1.default.resolve(snapshot.absolutePath), snapshot.relativePath)
+                : (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, snapshot.relativePath);
             const checkpoint = this.getCheckpoint(input.workspace, snapshot.relativePath);
-            if (checkpoint?.source_version === snapshot.version && !checkpoint.deleted_at) {
+            if (checkpoint?.resource === (resource ?? null) &&
+                checkpoint.source_version === snapshot.version && !checkpoint.deleted_at) {
+                result.skipped += 1;
+                continue;
+            }
+            // CSS writes and tool patches may use a child workspace in this same journal.
+            // Reuse their exact completed authority receipt, bound to both file and resource.
+            const existing = this.db.prepare(`
+        SELECT id, stage, after_hash FROM sync_ops
+        WHERE source_path = ? AND resource = ?
+        ORDER BY created_at DESC, rowid DESC LIMIT 1
+      `).get(snapshot.absolutePath, resource ?? null);
+            if (existing?.stage === 'done' && existing.after_hash === snapshot.version) {
+                // Preserve root-level deletion detection even when completion was recorded
+                // under a child workspace. This checkpoint references the same completed op.
+                const op = this.getOperation(existing.id);
+                this.upsertCheckpoint({
+                    ...op,
+                    workspace: manifest,
+                    change: { ...op.change, path: snapshot.relativePath },
+                }, this.now());
                 result.skipped += 1;
                 continue;
             }
             const op = await this.recordLocalCommitted({
                 path: snapshot.relativePath,
-                resource: input.resolveResource
-                    ? await input.resolveResource(node_path_1.default.resolve(snapshot.absolutePath), snapshot.relativePath)
-                    : (0, SolidFsPathUtils_1.resolveWorkspaceResource)(input.workspace, snapshot.relativePath),
+                resource,
                 source,
                 sourcePath: snapshot.absolutePath,
                 contentType: (0, SolidFsPathUtils_1.contentTypeForPath)(snapshot.relativePath),
@@ -289,21 +362,21 @@ class SqliteSolidFsSyncJournal {
         if (!currentHash) {
             return `SolidFS journal source is missing: ${op.change.sourcePath}`;
         }
-        if (op.afterHash && currentHash !== op.afterHash) {
+        if (!op.afterHash || currentHash !== op.afterHash) {
             return `SolidFS journal source changed before replay: ${op.change.path}`;
         }
         return undefined;
     }
     getCheckpoint(workspace, relativePath) {
         return this.db.prepare(`
-      SELECT source_version, deleted_at
+      SELECT resource, source_version, deleted_at
       FROM sync_checkpoints
       WHERE workspace = ? AND path = ?
     `).get(workspace, relativePath);
     }
     listCheckpoints(workspace) {
         return this.db.prepare(`
-      SELECT path, source_version, deleted_at
+      SELECT path, resource, source_version, deleted_at
       FROM sync_checkpoints
       WHERE workspace = ?
       ORDER BY path ASC
@@ -312,25 +385,27 @@ class SqliteSolidFsSyncJournal {
     upsertCheckpoint(op, now) {
         if (op.change.type === 'deleted') {
             this.db.prepare(`
-        INSERT INTO sync_checkpoints (workspace, path, source_version, deleted_at, updated_at, last_op_id)
-        VALUES (?, ?, NULL, ?, ?, ?)
+        INSERT INTO sync_checkpoints (workspace, path, resource, source_version, deleted_at, updated_at, last_op_id)
+        VALUES (?, ?, ?, NULL, ?, ?, ?)
         ON CONFLICT(workspace, path) DO UPDATE SET
+          resource = excluded.resource,
           source_version = NULL,
           deleted_at = excluded.deleted_at,
           updated_at = excluded.updated_at,
           last_op_id = excluded.last_op_id
-      `).run(op.workspace.workspace, op.change.path, now, now, op.id);
+      `).run(op.workspace.workspace, op.change.path, op.change.resource ?? null, now, now, op.id);
             return;
         }
         this.db.prepare(`
-      INSERT INTO sync_checkpoints (workspace, path, source_version, deleted_at, updated_at, last_op_id)
-      VALUES (?, ?, ?, NULL, ?, ?)
+      INSERT INTO sync_checkpoints (workspace, path, resource, source_version, deleted_at, updated_at, last_op_id)
+      VALUES (?, ?, ?, ?, NULL, ?, ?)
       ON CONFLICT(workspace, path) DO UPDATE SET
+        resource = excluded.resource,
         source_version = excluded.source_version,
         deleted_at = NULL,
         updated_at = excluded.updated_at,
         last_op_id = excluded.last_op_id
-    `).run(op.workspace.workspace, op.change.path, op.afterHash ?? null, now, op.id);
+    `).run(op.workspace.workspace, op.change.path, op.change.resource ?? null, op.afterHash ?? null, now, op.id);
     }
     initializeSchema() {
         this.db.exec(`
@@ -366,6 +441,7 @@ class SqliteSolidFsSyncJournal {
       CREATE TABLE IF NOT EXISTS sync_checkpoints (
         workspace TEXT NOT NULL,
         path TEXT NOT NULL,
+        resource TEXT,
         source_version TEXT,
         deleted_at INTEGER,
         updated_at INTEGER NOT NULL,
@@ -373,6 +449,19 @@ class SqliteSolidFsSyncJournal {
         PRIMARY KEY (workspace, path)
       );
     `);
+        const columns = this.db.prepare('PRAGMA table_info(sync_checkpoints)').all();
+        if (!columns.some((column) => column.name === 'resource')) {
+            this.db.transaction(() => {
+                this.db.exec('ALTER TABLE sync_checkpoints ADD COLUMN resource TEXT');
+                // A compacted historical operation cannot prove its resource binding;
+                // leave that checkpoint unbound so bootstrap conservatively replays it.
+                this.db.exec(`
+          UPDATE sync_checkpoints SET resource = (
+            SELECT resource FROM sync_ops WHERE id = sync_checkpoints.last_op_id
+          )
+        `);
+            })();
+        }
     }
 }
 exports.SqliteSolidFsSyncJournal = SqliteSolidFsSyncJournal;
@@ -400,6 +489,7 @@ class JournaledSolidFsSyncer {
         }
         try {
             await this.syncer.sync(change, workspace, context);
+            await this.journal.recordSyncedSourceHash(op.id, await (0, SolidFsPathUtils_1.maybeFileVersion)(change.sourcePath));
             await this.journal.markDone(op.id);
         }
         catch (error) {
@@ -453,6 +543,7 @@ class WorkspaceJournaledSolidFsSyncer {
         }
         try {
             await this.syncer.sync(change, workspace, context);
+            await journal.recordSyncedSourceHash(op.id, await (0, SolidFsPathUtils_1.maybeFileVersion)(change.sourcePath));
             await journal.markDone(op.id);
         }
         catch (error) {
@@ -570,4 +661,22 @@ function errorMessage(error) {
     }
     return String(error);
 }
+/**
+ * Compare two `size:mtimeMs:sha256` file versions by content identity.
+ *
+ * Only the size and digest parts describe the bytes; mtime legitimately moves
+ * when the sync's own write lands on the same authority file. A missing or
+ * malformed version is treated as content-different so the guard is retained.
+ */
+function sameFileContent(expected, current) {
+    if (!expected || !current) {
+        return false;
+    }
+    const expectedParts = expected.split(':');
+    const currentParts = current.split(':');
+    if (expectedParts.length < 3 || currentParts.length < 3) {
+        return false;
+    }
+    return expectedParts[0] === currentParts[0] && expectedParts[2] === currentParts[2];
+}
 //# sourceMappingURL=SolidFsSyncJournal.js.map

package/dist/solidfs/SolidFsSyncJournal.jsonld

@@ -63,6 +63,10 @@
           "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#SqliteSolidFsSyncJournal__member_listPending",
           "memberFieldName": "listPending"
         },
+        {
+          "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#SqliteSolidFsSyncJournal__member_recordSyncedSourceHash",
+          "memberFieldName": "recordSyncedSourceHash"
+        },
         {
           "@id": "undefineds:dist/solidfs/SolidFsSyncJournal.jsonld#SqliteSolidFsSyncJournal__member_markDone",
           "memberFieldName": "markDone"

package/dist/storage/HierarchyLockingResourceStore.d.ts

@@ -0,0 +1,17 @@
+import { LockingResourceStore, type AuxiliaryIdentifierStrategy, type ChangeMap, type Conditions, type ExpiringReadWriteLocker, type IdentifierStrategy, type Patch, type Representation, type ResourceIdentifier, type ResourceStore } from '@solid/community-server';
+/** Root-first ancestor locks protect parent membership and empty-container deletion. */
+export declare class HierarchyLockingResourceStore extends LockingResourceStore {
+    private readonly mutationSource;
+    private readonly hierarchyLocks;
+    private readonly identifierStrategy;
+    constructor(mutationSource: ResourceStore, hierarchyLocks: ExpiringReadWriteLocker, auxiliaryStrategy: AuxiliaryIdentifierStrategy, identifierStrategy: IdentifierStrategy);
+    setRepresentation(id: ResourceIdentifier, body: Representation, conditions?: Conditions): Promise<ChangeMap>;
+    addResource(id: ResourceIdentifier, body: Representation, conditions?: Conditions): Promise<ChangeMap>;
+    deleteResource(id: ResourceIdentifier, conditions?: Conditions): Promise<ChangeMap>;
+    modifyResource(id: ResourceIdentifier, patch: Patch, conditions?: Conditions): Promise<ChangeMap>;
+    protected lockedRepresentationRun(id: ResourceIdentifier, action: () => Promise<Representation>): Promise<Representation>;
+    private withPreparingReadLock;
+    private withFreshMetadata;
+    withMutationLocks<T>(identifier: ResourceIdentifier, action: () => Promise<T>): Promise<T>;
+    private ancestors;
+}

package/dist/storage/HierarchyLockingResourceStore.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HierarchyLockingResourceStore = void 0;
+const community_server_1 = require("@solid/community-server");
+const MetadataRequestContext_1 = require("./MetadataRequestContext");
+const StorageVersion_1 = require("./StorageVersion");
+/** Root-first ancestor locks protect parent membership and empty-container deletion. */
+class HierarchyLockingResourceStore extends community_server_1.LockingResourceStore {
+    constructor(mutationSource, hierarchyLocks, auxiliaryStrategy, identifierStrategy) {
+        super(mutationSource, hierarchyLocks, auxiliaryStrategy);
+        this.mutationSource = mutationSource;
+        this.hierarchyLocks = hierarchyLocks;
+        this.identifierStrategy = identifierStrategy;
+    }
+    async setRepresentation(id, body, conditions) {
+        return this.withMutationLocks(id, () => this.mutationSource.setRepresentation(id, body, conditions));
+    }
+    async addResource(id, body, conditions) {
+        return this.withMutationLocks(id, () => this.mutationSource.addResource(id, body, conditions));
+    }
+    async deleteResource(id, conditions) {
+        return this.withMutationLocks(id, () => this.mutationSource.deleteResource(id, conditions));
+    }
+    async modifyResource(id, patch, conditions) {
+        return this.withMutationLocks(id, () => this.mutationSource.modifyResource(id, patch, conditions));
+    }
+    async lockedRepresentationRun(id, action) {
+        const identifiers = [...this.ancestors(id), id];
+        for (;;) {
+            const state = { active: true };
+            const renewals = new Set();
+            // Preparing a response can wait on an inner lock or a bounded backend
+            // query. Once delivered, CSS's stream-read renewal and idle expiry apply.
+            const timer = setInterval(() => { for (const renew of renewals)
+                renew(); }, 1000);
+            const acquire = async (index) => {
+                if (!state.active)
+                    throw new Error('Resource read lock expired');
+                return index === identifiers.length
+                    ? this.withFreshMetadata(() => StorageVersion_1.storageVersionReadContext.run(true, action))
+                    : this.withPreparingReadLock(identifiers[index], () => acquire(index + 1), state, renewals);
+            };
+            try {
+                return await acquire(0);
+            }
+            catch (error) {
+                state.active = false;
+                if (!(error instanceof StorageVersion_1.LegacyStorageVersionError))
+                    throw error;
+                // acquire() has rejected only after every read lock was released. Never upgrade a held lock.
+                await this.withMutationLocks(error.identifier, error.initialize);
+            }
+            finally {
+                clearInterval(timer);
+            }
+        }
+    }
+    withPreparingReadLock(identifier, action, state, renewals) {
+        // Preserve CSS's split lifetime: return the representation immediately,
+        // while its read lock remains held until the source stream ends or fails.
+        return new Promise((resolve, reject) => {
+            let representation;
+            this.hierarchyLocks.withReadLock(identifier, async (maintainLock) => {
+                if (!state.active)
+                    throw new Error('Resource read lock expired');
+                renewals.add(maintainLock);
+                try {
+                    representation = await action();
+                }
+                finally {
+                    renewals.delete(maintainLock);
+                }
+                if (!state.active) {
+                    representation.data.destroy();
+                    throw new Error('Resource read lock expired');
+                }
+                resolve(this.createExpiringRepresentation(representation, maintainLock));
+                await this.waitForStreamToEnd(representation.data);
+            }).catch((error) => {
+                state.active = false;
+                renewals.clear();
+                representation?.data.destroy(error instanceof Error ? error : new Error(String(error)));
+                reject(error);
+            });
+        });
+    }
+    async withFreshMetadata(action) {
+        // Permission/existence checks may have cached an older version before the lock was acquired.
+        MetadataRequestContext_1.metadataRequestContext.getStore()?.metadataCache.clear();
+        return MetadataRequestContext_1.metadataRequestContext.run({ metadataCache: new Map() }, action);
+    }
+    async withMutationLocks(identifier, action) {
+        const target = this.getLockIdentifier(identifier);
+        const ancestors = this.ancestors(target);
+        const identifiers = [...ancestors, target];
+        const renewals = new Set();
+        let active = true;
+        // Existing Local wrappers use leases of at least 6s; Cloud owner locks do not expire.
+        const timer = setInterval(() => { for (const renew of renewals)
+            renew(); }, 1000);
+        const acquire = async (index) => {
+            if (!active)
+                throw new Error('Resource mutation lock expired');
+            if (index === identifiers.length)
+                return this.withFreshMetadata(() => StorageVersion_1.storageVersionReadContext.run(false, action));
+            const callback = async (renew) => {
+                if (!active)
+                    throw new Error('Resource mutation lock expired');
+                renewals.add(renew);
+                try {
+                    return await acquire(index + 1);
+                }
+                finally {
+                    renewals.delete(renew);
+                }
+            };
+            try {
+                // PUT may create every missing ancestor. Conservatively serialize those metadata writes too.
+                return await this.hierarchyLocks.withWriteLock(identifiers[index], callback);
+            }
+            catch (error) {
+                active = false;
+                throw error;
+            }
+        };
+        try {
+            return await acquire(0);
+        }
+        finally {
+            active = false;
+            clearInterval(timer);
+        }
+    }
+    ancestors(target) {
+        const ancestors = [];
+        if (this.identifierStrategy.supportsIdentifier(target)) {
+            let current = target;
+            while (!this.identifierStrategy.isRootContainer(current)) {
+                current = this.identifierStrategy.getParentContainer(current);
+                ancestors.unshift(current);
+            }
+        }
+        return ancestors;
+    }
+}
+exports.HierarchyLockingResourceStore = HierarchyLockingResourceStore;
+//# sourceMappingURL=HierarchyLockingResourceStore.js.map

package/dist/storage/HierarchyLockingResourceStore.jsonld

@@ -0,0 +1,104 @@
+{
+  "@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/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore",
+      "@type": "Class",
+      "requireElement": "HierarchyLockingResourceStore",
+      "extends": [
+        "css:dist/storage/LockingResourceStore.jsonld#LockingResourceStore"
+      ],
+      "comment": "Root-first ancestor locks protect parent membership and empty-container deletion.",
+      "parameters": [
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_mutationSource",
+          "range": "css:dist/storage/ResourceStore.jsonld#ResourceStore"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_hierarchyLocks",
+          "range": "css:dist/util/locking/ExpiringReadWriteLocker.jsonld#ExpiringReadWriteLocker"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_auxiliaryStrategy",
+          "range": "css:dist/http/auxiliary/AuxiliaryIdentifierStrategy.jsonld#AuxiliaryIdentifierStrategy"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_identifierStrategy",
+          "range": "css:dist/util/identifiers/IdentifierStrategy.jsonld#IdentifierStrategy"
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_mutationSource",
+          "memberFieldName": "mutationSource"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_hierarchyLocks",
+          "memberFieldName": "hierarchyLocks"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_identifierStrategy",
+          "memberFieldName": "identifierStrategy"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_setRepresentation",
+          "memberFieldName": "setRepresentation"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_addResource",
+          "memberFieldName": "addResource"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_deleteResource",
+          "memberFieldName": "deleteResource"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_modifyResource",
+          "memberFieldName": "modifyResource"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_lockedRepresentationRun",
+          "memberFieldName": "lockedRepresentationRun"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_withPreparingReadLock",
+          "memberFieldName": "withPreparingReadLock"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_withFreshMetadata",
+          "memberFieldName": "withFreshMetadata"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_withMutationLocks",
+          "memberFieldName": "withMutationLocks"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore__member_ancestors",
+          "memberFieldName": "ancestors"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_mutationSource"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_hierarchyLocks"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_auxiliaryStrategy"
+        },
+        {
+          "@id": "undefineds:dist/storage/HierarchyLockingResourceStore.jsonld#HierarchyLockingResourceStore_identifierStrategy"
+        }
+      ]
+    }
+  ]
+}

package/dist/storage/RepresentationPartialConvertingStore.js

@@ -4,6 +4,7 @@ exports.RepresentationPartialConvertingStore = void 0;
 const global_logger_factory_1 = require("global-logger-factory");
 const community_server_1 = require("@solid/community-server");
 const RdfContentTypes_1 = require("./rdf/RdfContentTypes");
+const StorageETagHandler_1 = require("./conditions/StorageETagHandler");
 /**
  * A store that converts representations based on their content type.
  */
@@ -46,11 +47,19 @@ class RepresentationPartialConvertingStore extends community_server_1.Passthroug
         }
     }
     async getRepresentation(identifier, preferences, conditions) {
-        let representation = await super.getRepresentation(identifier, preferences, conditions);
+        const source = await super.getRepresentation(identifier, preferences, conditions);
+        let representation = new community_server_1.BasicRepresentation(source.data, new community_server_1.RepresentationMetadata(source.metadata), source.binary);
         if (await this.shouldConvert(identifier, representation, preferences)) {
             representation = await this.outConverter.handleSafe({ identifier, representation, preferences });
         }
-        return representation;
+        // CSS merges representation metadata into a 304's HTTP ETag. Expose only the
+        // negotiated HTTP tag so its raw storage revision cannot become a second value.
+        // Keep source and converter-owned metadata isolated from HTTP response mutation.
+        const metadata = new community_server_1.RepresentationMetadata(representation.metadata);
+        const eTag = (0, StorageETagHandler_1.getStorageETag)(metadata);
+        if (eTag)
+            metadata.set(community_server_1.HH.terms.etag, eTag);
+        return new community_server_1.BasicRepresentation(representation.data, metadata, representation.binary);
     }
     async addResource(identifier, representation, conditions) {
         // In case of containers, no content-type is required and the representation is not used.

package/dist/storage/SparqlUpdateResourceStore.js

@@ -61,6 +61,11 @@ class SparqlUpdateResourceStore extends community_server_1.DataAccessorBasedStor
             this.logger.debug(`Metadata PATCH for ${identifier.path} falls back to CSS metadata patcher`);
             throw new community_server_1.NotImplementedHttpError('Metadata resources must be patched by the CSS metadata patcher');
         }
+        // Decline per-resource authority gaps before consuming the stream: CSS's
+        // patcher needs the original algebra and data, under the same outer lock.
+        if (typeof accessor.supportsSparqlUpdate === 'function' && !await accessor.supportsSparqlUpdate(identifier)) {
+            throw new community_server_1.NotImplementedHttpError('Direct SPARQL UPDATE not supported for this resource');
+        }
         const sparqlUpdate = await this.toSparqlUpdate(patch, identifier);
         if (!sparqlUpdate) {
             this.logger.debug(`toSparqlUpdate returned undefined for ${identifier.path}, falling back to CSS handler`);

package/dist/storage/StorageVersion.d.ts

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { RepresentationMetadata, type ResourceIdentifier } from '@solid/community-server';
+/** Write receipts captured only after the corresponding metadata has been persisted. */
+export declare const storageVersionReceipts: AsyncLocalStorage<Map<string, RepresentationMetadata>>;
+export declare const STORAGE_ETAG_PATTERN: RegExp;
+/** Only locked representation reads request lazy initialization of legacy metadata. */
+export declare const storageVersionReadContext: AsyncLocalStorage<boolean>;
+/** The locking store must release its read locks before running this callback under write locks. */
+export declare class LegacyStorageVersionError extends Error {
+    readonly identifier: ResourceIdentifier;
+    readonly initialize: () => Promise<void>;
+    constructor(identifier: ResourceIdentifier, initialize: () => Promise<void>);
+}
+export declare function getStorageVersion(metadata: RepresentationMetadata): string | undefined;
+export declare function stampStorageVersion(metadata: RepresentationMetadata): void;
+export declare function captureStorageVersion(metadata: RepresentationMetadata): void;