@undefineds.co/xpod 0.4.19 → 0.4.25

package/dist/storage/locking/PodLifecycleRedisLocker.jsonld

@@ -0,0 +1,156 @@
+{
+  "@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/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker",
+      "@type": "Class",
+      "requireElement": "PodLifecycleRedisLocker",
+      "extends": [
+        "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker",
+        "css:dist/util/locking/ExpiringReadWriteLocker.jsonld#ExpiringReadWriteLocker"
+      ],
+      "comment": "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.",
+      "parameters": [
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_redisClient",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_attemptSettings_retryCount",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:number",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_attemptSettings_retryDelay",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:number",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_attemptSettings_retryJitter",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:number",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_namespacePrefix",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "xsd:string",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          }
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_active",
+          "memberFieldName": "active"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_closing",
+          "memberFieldName": "closing"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_shutdown",
+          "memberFieldName": "shutdown"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_initialize",
+          "memberFieldName": "initialize"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_withReadLock",
+          "memberFieldName": "withReadLock"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_withWriteLock",
+          "memberFieldName": "withWriteLock"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_finalize",
+          "memberFieldName": "finalize"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker__member_track",
+          "memberFieldName": "track"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "redisClient",
+              "value": {
+                "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_redisClient"
+              }
+            },
+            {
+              "keyRaw": "attemptSettings_retryCount",
+              "value": {
+                "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_attemptSettings_retryCount"
+              }
+            },
+            {
+              "keyRaw": "attemptSettings_retryDelay",
+              "value": {
+                "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_attemptSettings_retryDelay"
+              }
+            },
+            {
+              "keyRaw": "attemptSettings_retryJitter",
+              "value": {
+                "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_attemptSettings_retryJitter"
+              }
+            },
+            {
+              "keyRaw": "namespacePrefix",
+              "value": {
+                "@id": "undefineds:dist/storage/locking/PodLifecycleRedisLocker.jsonld#PodLifecycleRedisLocker_options_namespacePrefix"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

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

@@ -1,22 +1,34 @@
-import { RedisLocker } from '@solid/community-server';
+import { Initializer, type ExpiringReadWriteLocker, type Finalizable, type PromiseOrValue, type ResourceIdentifier } from '@solid/community-server';
 export interface UrlAwareRedisLockerOptions {
     redisClient?: string;
     attemptSettings_retryCount?: number;
     attemptSettings_retryDelay?: number;
     attemptSettings_retryJitter?: number;
     namespacePrefix?: string;
-    /** TTL backstop (seconds) for Redis lock/count keys; guards against crash-leaked locks. */
-    lockKeyTtlSeconds?: number;
 }
 /**
- * 扩展 CSS RedisLocker，支持 redis:// 和 rediss:// URL 格式。
- *
- * CSS 原生 RedisLocker.createRedisClient 是 private 的，无法 override。
- * 这里在构造函数中检测 URL 格式，如果是 URL 则用 ioredis 直接创建连接，
- * 替换掉父类构造函数中创建的（会报错的）连接。
+ * Shared owner-checked locks. Never expire an active writer without storage fencing.
+ * A crashed owner remains locked until an operator proves it is stopped and repairs that key.
+ * Initialize/finalize never clear the namespace or another instance's locks.
  */
-export declare class UrlAwareRedisLocker extends RedisLocker {
+export declare class UrlAwareRedisLocker extends Initializer implements ExpiringReadWriteLocker, Finalizable {
+    protected readonly logger: import("global-logger-factory").Logger<unknown>;
+    private readonly redis;
+    private readonly namespace;
+    private readonly retryCount;
+    private readonly retryDelay;
+    private readonly retryJitter;
+    private readonly resourceOwners;
     private shuttingDown;
     constructor(options?: UrlAwareRedisLockerOptions);
+    handle(): Promise<void>;
+    initialize(): Promise<void>;
+    withReadLock<T>(id: ResourceIdentifier, action: (maintainLock: () => void) => PromiseOrValue<T>): Promise<T>;
+    withWriteLock<T>(id: ResourceIdentifier, action: (maintainLock: () => void) => PromiseOrValue<T>): Promise<T>;
+    acquire(id: ResourceIdentifier): Promise<void>;
+    release(id: ResourceIdentifier): Promise<void>;
     finalize(): Promise<void>;
+    private withLock;
+    private claim;
+    private releaseOwner;
 }

package/dist/storage/locking/UrlAwareRedisLocker.js

@@ -4,142 +4,101 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UrlAwareRedisLocker = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:timers/promises");
 const ioredis_1 = __importDefault(require("ioredis"));
 const community_server_1 = require("@solid/community-server");
+const global_logger_factory_1 = require("global-logger-factory");
 const RedisClientLifecycle_1 = require("../redis/RedisClientLifecycle");
-const REDIS_LUA_SCRIPTS = (() => {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        return require('@solid/community-server/dist/util/locking/scripts/RedisLuaScripts').REDIS_LUA_SCRIPTS;
-    }
-    catch {
-        return {};
-    }
-})();
-/**
- * CSS 原生 Lua 脚本创建的 lock/count key 都不带 TTL：
- * 进程在 acquire 与 release 之间崩溃时 key 永久残留，资源被永久死锁（只能手工清 Redis）。
- * 这里在相同语义上加 TTL 兜底，并在读计数归零时主动删除 key。
- */
-function buildTtlLuaScripts(ttlSeconds) {
-    const ttl = Math.max(1, Math.floor(ttlSeconds));
-    return {
-        acquireReadLock: `
-    -- Return 0 if an entry already exists.
-    local lockKey = KEYS[1]..".wlock"
-    if redis.call("exists", lockKey) == 1 then
-      return 0
-    end
-
-    -- Increment the counter and arm the TTL backstop
-    local countKey = KEYS[1]..".count"
-    local count = redis.call("incr", countKey)
-    redis.call("expire", countKey, ${ttl})
-    return count > 0
-    `,
-        acquireWriteLock: `
-    -- Return 0 if a lock entry already exists or read count is > 0
-    local lockKey = KEYS[1]..".wlock"
-    local countKey = KEYS[1]..".count"
-    local count = tonumber(redis.call("get", countKey))
-    if ((redis.call("exists", lockKey) == 1) or (count ~= nil and count > 0)) then
-      return 0
-    end
-
-    -- Set lock with a TTL backstop and respond with 'OK' if succeeded (otherwise null)
-    return redis.call("set", lockKey, "locked", "EX", ${ttl});
-    `,
-        releaseReadLock: `
-      -- Return 1 after decreasing the counter, if counter is < 0 now: return '-ERR'
-      local countKey = KEYS[1]..".count"
-      local result = redis.call("decr", countKey)
-      if result > 0 then
-        redis.call("expire", countKey, ${ttl})
-        return 1
-      elseif result == 0 then
-        redis.call("del", countKey)
-        return 1
-      else
-        return redis.error_reply("Error trying to release readlock when read count was 0.")
-      end
-    `,
-        acquireLock: `
-      -- Return 0 if lock entry already exists, or 'OK' if it succeeds in setting the lock entry.
-      local key = KEYS[1]..".lock"
-      if redis.call("exists", key) == 1 then
-        return 0
-      end
-
-      -- Return 'OK' if succeeded setting entry (with a TTL backstop)
-      return redis.call("set", key, "locked", "EX", ${ttl});
-      `,
-    };
-}
+const ACQUIRE = `
+  local mode = ARGV[1]
+  if mode == 'write' and redis.call('hget', KEYS[1], 'writer') == ARGV[2] then return 1 end
+  if mode == 'read' and redis.call('hget', KEYS[1], 'reader:'..ARGV[2]) == ARGV[2] then return 1 end
+  if mode == 'write' and redis.call('hlen', KEYS[1]) > 0 then return 0 end
+  if mode == 'read' and redis.call('hexists', KEYS[1], 'writer') == 1 then return 0 end
+  if mode == 'write' then redis.call('hset', KEYS[1], 'writer', ARGV[2])
+  else redis.call('hset', KEYS[1], 'reader:'..ARGV[2], ARGV[2]) end
+  return 1
+`;
+const RELEASE = `
+  local field = ARGV[1] == 'write' and 'writer' or 'reader:'..ARGV[2]
+  if redis.call('hexists', KEYS[1], field) == 0 then return 1 end
+  if redis.call('hget', KEYS[1], field) ~= ARGV[2] then return 0 end
+  redis.call('hdel', KEYS[1], field)
+  if redis.call('hlen', KEYS[1]) == 0 then redis.call('del', KEYS[1]) end
+  return 1
+`;
 /**
- * 扩展 CSS RedisLocker，支持 redis:// 和 rediss:// URL 格式。
- *
- * CSS 原生 RedisLocker.createRedisClient 是 private 的，无法 override。
- * 这里在构造函数中检测 URL 格式，如果是 URL 则用 ioredis 直接创建连接，
- * 替换掉父类构造函数中创建的（会报错的）连接。
+ * Shared owner-checked locks. Never expire an active writer without storage fencing.
+ * A crashed owner remains locked until an operator proves it is stopped and repairs that key.
+ * Initialize/finalize never clear the namespace or another instance's locks.
  */
-class UrlAwareRedisLocker extends community_server_1.RedisLocker {
+class UrlAwareRedisLocker extends community_server_1.Initializer {
     constructor(options = {}) {
-        const redisClient = options.redisClient ?? '127.0.0.1:6379';
-        const attemptSettings = {
-            retryCount: options.attemptSettings_retryCount ?? -1,
-            retryDelay: options.attemptSettings_retryDelay ?? 50,
-            retryJitter: options.attemptSettings_retryJitter ?? 30,
-        };
-        const redisSettings = {
-            namespacePrefix: options.namespacePrefix ?? '',
-        };
-        const isUrl = redisClient.startsWith('redis://') || redisClient.startsWith('rediss://');
-        if (isUrl) {
-            // 传一个合法的 host:port 给父类，避免它报错
-            super('127.0.0.1:6379', attemptSettings, redisSettings);
-            // 关闭父类创建的无用连接
-            const oldRedis = this.redis;
-            oldRedis.disconnect(false);
-            // 用 URL 创建真正的连接
-            const redis = new ioredis_1.default(redisClient);
-            // 注册 Lua 脚本
-            for (const [name, script] of Object.entries(REDIS_LUA_SCRIPTS)) {
-                redis.defineCommand(name, { numberOfKeys: 1, lua: script });
-            }
-            // 替换父类的 redis 实例
-            this.redis = redis;
-            this.redisRw = redis;
-            this.redisLock = redis;
-        }
-        else {
-            super(redisClient, attemptSettings, redisSettings);
-        }
-        // 用带 TTL 的脚本覆盖 CSS 原生实现，兜底崩溃泄漏的锁
-        const ttlScripts = buildTtlLuaScripts(options.lockKeyTtlSeconds ?? 60);
-        const liveRedis = this.redis;
-        for (const [name, script] of Object.entries(ttlScripts)) {
-            liveRedis.defineCommand(name, { numberOfKeys: 1, lua: script });
-        }
+        super();
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.resourceOwners = new Map();
         this.shuttingDown = false;
+        const address = options.redisClient ?? '127.0.0.1:6379';
+        this.redis = new ioredis_1.default(address.startsWith('redis://') || address.startsWith('rediss://')
+            ? address : `redis://${address.includes(':') ? address : `127.0.0.1:${address}`}`);
+        this.namespace = `${options.namespacePrefix ?? ''}__XPOD_OWNER_LOCK__`;
+        this.retryCount = options.attemptSettings_retryCount ?? -1;
+        this.retryDelay = options.attemptSettings_retryDelay ?? 50;
+        this.retryJitter = options.attemptSettings_retryJitter ?? 30;
         (0, RedisClientLifecycle_1.attachRedisClientErrorHandler)(this.redis, {
-            logger: this.logger,
-            label: 'UrlAwareRedisLocker',
-            isShuttingDown: () => this.shuttingDown,
+            logger: this.logger, label: 'UrlAwareRedisLocker', isShuttingDown: () => this.shuttingDown,
         });
     }
+    async handle() { await this.initialize(); }
+    async initialize() { await this.redis.ping(); }
+    async withReadLock(id, action) {
+        return this.withLock(id, 'read', action);
+    }
+    async withWriteLock(id, action) {
+        return this.withLock(id, 'write', action);
+    }
+    async acquire(id) {
+        const owner = (0, node_crypto_1.randomUUID)();
+        await this.claim(`resource:${id.path}`, 'write', owner);
+        this.resourceOwners.set(id.path, owner);
+    }
+    async release(id) {
+        const owner = this.resourceOwners.get(id.path);
+        if (!owner)
+            throw new Error('This Redis locker does not own the resource lock');
+        this.resourceOwners.delete(id.path);
+        await this.releaseOwner(`resource:${id.path}`, 'write', owner);
+    }
     async finalize() {
         this.shuttingDown = true;
-        const redis = this.redis;
+        // A premature shutdown preserves held locks; it cannot allow an in-flight writer to race.
+        this.redis.disconnect(false);
+    }
+    async withLock(id, mode, action) {
+        const owner = (0, node_crypto_1.randomUUID)();
+        await this.claim(`rw:${id.path}`, mode, owner);
         try {
-            await super.finalize();
-        }
-        catch (error) {
-            if (!(0, RedisClientLifecycle_1.isIgnorableRedisShutdownError)(error)) {
-                throw error;
-            }
+            return await action(() => undefined);
         }
         finally {
-            redis.disconnect(false);
+            await this.releaseOwner(`rw:${id.path}`, mode, owner);
+        }
+    }
+    async claim(path, mode, owner) {
+        for (let attempt = 0;; attempt += 1) {
+            if (this.shuttingDown)
+                throw new Error('Redis locker is shutting down');
+            if (await this.redis.eval(ACQUIRE, 1, `${this.namespace}${path}`, mode, owner) === 1)
+                return;
+            if (this.retryCount >= 0 && attempt >= this.retryCount)
+                throw new Error('Redis lock acquisition exhausted');
+            await (0, promises_1.setTimeout)(this.retryDelay + Math.floor(Math.random() * this.retryJitter));
+        }
+    }
+    async releaseOwner(path, mode, owner) {
+        if (await this.redis.eval(RELEASE, 1, `${this.namespace}${path}`, mode, owner) !== 1) {
+            throw new Error('Redis lock ownership lost; refusing to release another owner');
         }
     }
 }

package/dist/storage/locking/UrlAwareRedisLocker.jsonld

@@ -10,9 +10,11 @@
       "@type": "Class",
       "requireElement": "UrlAwareRedisLocker",
       "extends": [
-        "css:dist/util/locking/RedisLocker.jsonld#RedisLocker"
+        "css:dist/init/Initializer.jsonld#Initializer",
+        "css:dist/util/locking/ExpiringReadWriteLocker.jsonld#ExpiringReadWriteLocker",
+        "css:dist/init/final/Finalizable.jsonld#Finalizable"
       ],
-      "comment": "扩展 CSS RedisLocker，支持 redis:// 和 rediss:// URL 格式。  CSS 原生 RedisLocker.createRedisClient 是 private 的，无法 override。 这里在构造函数中检测 URL 格式，如果是 URL 则用 ioredis 直接创建连接， 替换掉父类构造函数中创建的（会报错的）连接。",
+      "comment": "Shared owner-checked locks. Never expire an active writer without storage fencing. A crashed owner remains locked until an operator proves it is stopped and repairs that key. Initialize/finalize never clear the namespace or another instance's locks.",
       "parameters": [
         {
           "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker_options_redisClient",
@@ -73,22 +75,40 @@
               }
             ]
           }
-        },
-        {
-          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker_options_lockKeyTtlSeconds",
-          "range": {
-            "@type": "ParameterRangeUnion",
-            "parameterRangeElements": [
-              "xsd:number",
-              {
-                "@type": "ParameterRangeUndefined"
-              }
-            ]
-          },
-          "comment": "TTL backstop (seconds) for Redis lock/count keys; guards against crash-leaked locks."
         }
       ],
       "memberFields": [
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_logger",
+          "memberFieldName": "logger",
+          "range": {
+            "@type": "ParameterRangeWildcard"
+          }
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_redis",
+          "memberFieldName": "redis"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_namespace",
+          "memberFieldName": "namespace"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_retryCount",
+          "memberFieldName": "retryCount"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_retryDelay",
+          "memberFieldName": "retryDelay"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_retryJitter",
+          "memberFieldName": "retryJitter"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_resourceOwners",
+          "memberFieldName": "resourceOwners"
+        },
         {
           "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_shuttingDown",
           "memberFieldName": "shuttingDown"
@@ -97,9 +117,45 @@
           "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_constructor",
           "memberFieldName": "constructor"
         },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_handle",
+          "memberFieldName": "handle"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_initialize",
+          "memberFieldName": "initialize"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_withReadLock",
+          "memberFieldName": "withReadLock"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_withWriteLock",
+          "memberFieldName": "withWriteLock"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_acquire",
+          "memberFieldName": "acquire"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_release",
+          "memberFieldName": "release"
+        },
         {
           "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_finalize",
           "memberFieldName": "finalize"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_withLock",
+          "memberFieldName": "withLock"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_claim",
+          "memberFieldName": "claim"
+        },
+        {
+          "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker__member_releaseOwner",
+          "memberFieldName": "releaseOwner"
         }
       ],
       "constructorArguments": [
@@ -135,12 +191,6 @@
               "value": {
                 "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker_options_namespacePrefix"
               }
-            },
-            {
-              "keyRaw": "lockKeyTtlSeconds",
-              "value": {
-                "@id": "undefineds:dist/storage/locking/UrlAwareRedisLocker.jsonld#UrlAwareRedisLocker_options_lockKeyTtlSeconds"
-              }
             }
           ]
         }

package/dist/storage/rdf/PostgresRdfEngine.d.ts

@@ -1,7 +1,7 @@
 import type { Quad } from '@rdfjs/types';
 import { type PostgresRdfTextIndexOptions } from './PostgresRdfTextIndex';
 import { type PostgresRdfVectorIndexOptions } from './PostgresRdfVectorIndex';
-import type { RdfDerivedIndexMaintenanceResult, RdfDerivedIndexRefreshOptions, RdfDerivedIndexRefreshResult, RdfEngineLike, RdfEngineStorageStats, RdfStorageStatsOptions, RdfIndexPutOptions, RdfBoundedPathSearchOptions, RdfBoundedPathSearchResult, RdfMaterializedViewActivationInput, RdfMaterializedViewActivationResult, RdfMaterializedViewBindingSource, RdfMaterializedViewBuildInput, RdfMaterializedViewBuildResult, RdfMaterializedViewReadResult, RdfSchemaExplorerOptions, RdfSchemaExplorerResult, RdfTextChunkInput, RdfTextIndexLike, RdfTextIndexOptions, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceInput, RdfQuery, RdfQueryResult, RdfPgAccelerationProfile, RdfPatternQuery, RdfQueryCacheScope, RdfQuadIndexScanResult, RdfSourceInput, RdfVectorChunkInput, RdfVectorIndexLike, RdfVectorIndexOptions, RdfVectorSearchOptions, RdfVectorSearchResult, RdfVectorSourceInput, RdfTermRewriteInput, RdfTermRewriteResult, RdfNativeSparqlQueryOptions, RdfNativeSparqlResult } from './types';
+import type { RdfDerivedIndexMaintenanceResult, RdfDerivedIndexRefreshOptions, RdfDerivedIndexRefreshResult, RdfEngineLike, RdfEngineStorageStats, RdfStorageStatsOptions, RdfIndexPutOptions, RdfBoundedPathSearchOptions, RdfBoundedPathSearchResult, RdfMaterializedViewActivationInput, RdfMaterializedViewActivationResult, RdfMaterializedViewBindingSource, RdfMaterializedViewBuildInput, RdfMaterializedViewBuildResult, RdfMaterializedViewReadResult, RdfSchemaExplorerOptions, RdfSchemaExplorerResult, RdfTextChunkInput, RdfTextIndexLike, RdfTextIndexOptions, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceInput, RdfTextSourceListOptions, RdfTextSourceMetadata, RdfQuery, RdfQueryResult, RdfPgAccelerationProfile, RdfPatternQuery, RdfQueryCacheScope, RdfQuadIndexScanResult, RdfSourceInput, RdfVectorChunkInput, RdfVectorIndexLike, RdfVectorIndexOptions, RdfVectorSearchOptions, RdfVectorSearchResult, RdfVectorSourceInput, RdfTermRewriteInput, RdfTermRewriteResult, RdfNativeSparqlQueryOptions, RdfNativeSparqlResult } from './types';
 import type { QuintPattern } from '../quint/types';
 type RdfTextIndexInput = PostgresRdfTextIndexOptions | RdfTextIndexOptions | RdfTextIndexLike;
 type RdfVectorIndexInput = PostgresRdfVectorIndexOptions | RdfVectorIndexOptions | RdfVectorIndexLike;
@@ -104,6 +104,7 @@ export declare class PostgresRdfEngine implements RdfEngineLike {
     deleteTextSource(source: string): Promise<number>;
     moveTextSource(oldSource: string, next: RdfTextSourceInput): Promise<number>;
     searchText(options: RdfTextSearchOptions | string): Promise<RdfTextSearchResult[]>;
+    listTextSources(options?: RdfTextSourceListOptions): Promise<RdfTextSourceMetadata[]>;
     indexVectorSource(source: RdfVectorSourceInput, chunks: RdfVectorChunkInput[]): Promise<void>;
     deleteVectorSource(source: string): Promise<number>;
     moveVectorSource(oldSource: string, next: RdfVectorSourceInput): Promise<number>;

package/dist/storage/rdf/PostgresRdfEngine.js

@@ -1565,6 +1565,9 @@ class PostgresRdfEngine {
     async searchText(options) {
         return await this.requireTextIndex().search(typeof options === 'string' ? { query: options } : options);
     }
+    async listTextSources(options) {
+        return await this.requireTextIndex().listSources(options);
+    }
     async indexVectorSource(source, chunks) {
         await this.requireVectorIndex().indexVector(source, chunks);
     }

package/dist/storage/rdf/PostgresRdfEngine.jsonld

@@ -868,6 +868,10 @@
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_searchText",
           "memberFieldName": "searchText"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_listTextSources",
+          "memberFieldName": "listTextSources"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_indexVectorSource",
           "memberFieldName": "indexVectorSource"