@zq-silk/yui 2.0.0 → 2.2.0

package/dist/nativeAgent/session/store.js

@@ -0,0 +1,248 @@
+import { digest } from './backends.js';
+import { copyEvent, identity, immutable, inspectDocument, revision, SessionError, sessionLimits } from './format.js';
+import { metadataRevision, normalizeTitle, queryBounds } from './catalog.js';
+import { copyLocation } from './location.js';
+export class SessionSaveError extends SessionError {
+    sessionId;
+    expectedRevision;
+    event;
+    location;
+    /** Conservative: a thrown backend write is not proof that no commit occurred. */
+    effect = 'unknown';
+    constructor(sessionId, expectedRevision, event, cause, location) {
+        super('save_failed', 'Necessary Session save failed; stop new effects and inspect exact saved facts', { cause });
+        this.sessionId = sessionId;
+        this.expectedRevision = expectedRevision;
+        this.event = event;
+        this.location = location;
+        this.name = 'SessionSaveError';
+    }
+}
+export class SessionMetadataSaveError extends SessionError {
+    sessionId;
+    title;
+    expectedMetadataRevision;
+    effect = 'unknown';
+    constructor(sessionId, title, expectedMetadataRevision, cause) {
+        super('metadata_save_failed', 'Metadata save confirmation failed; inspect exact title/revision before another write', { cause });
+        this.sessionId = sessionId;
+        this.title = title;
+        this.expectedMetadataRevision = expectedMetadataRevision;
+        this.name = 'SessionMetadataSaveError';
+    }
+}
+export function createSessionStore(backend) {
+    identity(backend.source.id);
+    const source = immutable(structuredClone(backend.source));
+    if (!['volatile', 'persistent'].includes(source.durability)) {
+        throw new SessionError('invalid_backend', 'Backend must advertise its persistence boundary');
+    }
+    let closed = false;
+    let backendClosed = false;
+    const observers = new Set();
+    const check = () => { if (closed)
+        throw new SessionError('closed', 'Session store is closed'); };
+    const catalog = () => {
+        check();
+        if (!backend.catalog)
+            throw new SessionError('unsupported_catalog', 'Backend does not implement the bounded SessionCatalog port');
+        return backend.catalog;
+    };
+    const read = async (operation) => {
+        check();
+        try {
+            const value = await operation();
+            check();
+            return immutable(value);
+        }
+        catch (cause) {
+            if (cause instanceof SessionError)
+                throw cause;
+            throw new SessionError('read_failed', 'Session query failed; no empty-page fallback', { cause });
+        }
+    };
+    const receipt = (document) => immutable({
+        sessionId: document.sessionId, revision: revision(document), digest: digest(document), source,
+    });
+    const dispatch = (observer) => {
+        if (observer.busy || !observer.active || !observer.pending)
+            return;
+        observer.busy = true;
+        queueMicrotask(() => {
+            const next = observer.pending;
+            observer.pending = undefined;
+            if (!observer.active || !next) {
+                observer.busy = false;
+                return;
+            }
+            // An observer has at most one in-flight callback and one coalesced receipt.
+            // A hung UI never blocks a commit or creates an unbounded notification queue.
+            void Promise.resolve().then(() => {
+                if (observer.active)
+                    return observer.callback(next);
+            }).catch(() => {
+                observer.active = false;
+                observers.delete(observer);
+            }).finally(() => {
+                observer.busy = false;
+                dispatch(observer);
+            });
+        });
+    };
+    const notify = (saved) => {
+        for (const observer of observers) {
+            if (observer.sessionId === saved.sessionId) {
+                observer.pending = saved;
+                dispatch(observer);
+            }
+        }
+    };
+    const save = async (document, expected, location) => {
+        check();
+        try {
+            if (location === undefined)
+                await backend.write(immutable(document), expected);
+            else
+                await backend.createWithLocation(immutable(document), location);
+        }
+        catch (cause) {
+            throw new SessionSaveError(document.sessionId, expected, document.events.at(-1), cause, location);
+        }
+        const saved = receipt(document);
+        notify(saved);
+        return saved;
+    };
+    const store = {
+        async listSessions(options = {}) { return read(() => catalog().listSessions(options)); },
+        async getSessionInfo(sessionId) {
+            identity(sessionId);
+            return read(() => catalog().getSessionInfo(sessionId));
+        },
+        async readHistory(sessionId, options = {}) {
+            identity(sessionId);
+            return read(() => catalog().readHistory(sessionId, options));
+        },
+        async renameSession(sessionId, title, expected) {
+            check();
+            identity(sessionId);
+            const normalized = normalizeTitle(title);
+            metadataRevision(expected);
+            const port = catalog();
+            try {
+                return immutable(await port.renameSession(sessionId, normalized, expected));
+            }
+            catch (cause) {
+                // These port errors are confirmed precondition refusals, not ambiguous saves.
+                if (cause instanceof SessionError && ['revision_conflict', 'not_found', 'closed'].includes(cause.code))
+                    throw cause;
+                throw new SessionMetadataSaveError(sessionId, normalized, expected, cause);
+            }
+        },
+        async create(sessionId, location) {
+            check();
+            identity(sessionId);
+            const selected = location === undefined ? undefined : immutable(copyLocation(location));
+            if (selected !== undefined && (!backend.createWithLocation || !backend.catalog)) {
+                throw new SessionError('unsupported_location', 'Backend lacks atomic location creation and bounded detail reconciliation');
+            }
+            return save({ schemaVersion: 2, sessionId, events: [] }, null, selected);
+        },
+        async load(sessionId) {
+            check();
+            identity(sessionId);
+            const raw = await backend.read(sessionId);
+            check();
+            if (raw === null)
+                throw new SessionError('not_found', 'Session not found');
+            const state = inspectDocument(raw);
+            if (state.document.sessionId !== sessionId)
+                throw new SessionError('invalid_session', 'Backend returned another Session');
+            return immutable({ ...receipt(state.document), ...state });
+        },
+        async append(event, expectedRevision) {
+            check();
+            if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
+                throw new SessionError('revision_conflict', 'Expected revision must be a nonnegative integer');
+            }
+            const next = copyEvent(event);
+            const previous = await store.load(next.sessionId);
+            if (previous.revision !== expectedRevision) {
+                throw new SessionError('revision_conflict', 'Session revision conflict; read current facts');
+            }
+            const state = inspectDocument({ ...previous.document, events: [...previous.document.events, next] });
+            return save(state.document, expectedRevision);
+        },
+        async query(sessionId, options = {}) {
+            const after = options.after ?? 0;
+            const limit = options.limit ?? 50;
+            queryBounds(after, limit);
+            if (backend.query) {
+                identity(sessionId);
+                return read(() => backend.query(sessionId, { after, limit }));
+            }
+            const loaded = await store.load(sessionId);
+            if (after > loaded.revision)
+                throw new SessionError('invalid_query', 'Cursor exceeds the saved revision');
+            const end = Math.min(after + limit, loaded.revision);
+            return immutable({ ...receipt(loaded.document),
+                records: loaded.document.events.slice(after, end).map((event, offset) => ({ revision: after + offset + 1, event })),
+                nextCursor: end < loaded.revision ? end : null,
+            });
+        },
+        subscribe(sessionId, callback) {
+            check();
+            identity(sessionId);
+            if (typeof callback !== 'function' || observers.size >= sessionLimits.subscribers) {
+                throw new SessionError('invalid_subscription', 'Expected observer within subscription limit');
+            }
+            const observer = { sessionId, callback, active: true, busy: false };
+            observers.add(observer);
+            return () => { observer.active = false; observer.pending = undefined; observers.delete(observer); };
+        },
+        async recorder(sessionId) {
+            const saved = await store.load(sessionId);
+            if (saved.recovery.disposition !== 'ready') {
+                throw new SessionError('recovery_required', 'Session requires explicit recovery; automatic replay is forbidden');
+            }
+            let lastReceipt = receipt(saved.document);
+            let failure;
+            let busy = false;
+            return {
+                get lastReceipt() { return lastReceipt; },
+                get failure() { return failure; },
+                async record(event) {
+                    if (failure)
+                        throw new SessionError('recorder_failed', 'Session recorder is stopped after failure', { cause: failure });
+                    if (busy)
+                        throw new SessionError('recorder_busy', 'Session recorder requires sequential facts');
+                    busy = true;
+                    try {
+                        if (event.sessionId !== sessionId)
+                            throw new SessionError('invalid_session', 'Recorder Session mismatch');
+                        lastReceipt = await store.append(event, lastReceipt.revision);
+                    }
+                    catch (cause) {
+                        failure = cause instanceof Error ? cause : new Error(String(cause));
+                        throw failure;
+                    }
+                    finally {
+                        busy = false;
+                    }
+                },
+            };
+        },
+        async close() {
+            if (backendClosed)
+                return;
+            closed = true;
+            for (const observer of observers) {
+                observer.active = false;
+                observer.pending = undefined;
+            }
+            observers.clear();
+            await backend.close();
+            backendClosed = true;
+        },
+    };
+    return store;
+}

package/dist/nativeAgent/textTools.js

@@ -0,0 +1,293 @@
+import { open, rename, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { FileFault, bounded, workspaceRoot, validPath, checkPath, readSnapshot, digest, fits, cursor, readCursor, replace, diff, assertText } from './fileToolsSupport.js';
+const fail = (code, message) => ({ code, message, effect: 'none' });
+const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+/** Controlled directories only. Queues are same-pack, not cross-process CAS or a multi-file transaction. */
+export function createTextTools(options) {
+    const root = workspaceRoot(options.root);
+    const maxBytes = bounded(options.maxBytes, 8 * 1024 * 1024, 'maxBytes');
+    const maxOutputBytes = bounded(options.maxOutputBytes, 64 * 1024, 'maxOutputBytes');
+    const writers = new Map();
+    const targetsFor = (args, name) => name === 'patch'
+        ? args.files : name === 'edit' ? [{
+            path: args.path, expectedSha256: args.expectedSha256,
+            edits: [{ oldText: args.oldText, newText: args.newText }],
+        }] : [args];
+    const validate = (args, name) => {
+        if (!object(args))
+            return fail('invalid_arguments', 'Expected an argument object');
+        const keys = name === 'patch' ? ['files'] : name === 'read' ? ['path', 'startLine', 'limit', 'cursor']
+            : name === 'edit' ? ['path', 'expectedSha256', 'oldText', 'newText'] : ['path', 'content', 'expectedSha256'];
+        if (Object.keys(args).some(key => !keys.includes(key)))
+            return fail('invalid_arguments', 'Unexpected tool fields');
+        if (Buffer.byteLength(JSON.stringify(args)) > 64 * 1024)
+            return fail('too_large', 'Arguments exceed 64 KiB');
+        if (name === 'read') {
+            if (!validPath(args.path))
+                return fail(typeof args.path === 'string' && (path.isAbsolute(args.path)
+                    || args.path.split(/[\\/]/).includes('..')) ? 'path_out_of_scope' : 'invalid_arguments', 'Expected a bounded relative file path');
+            if (['startLine', 'limit'].some(key => args[key] !== undefined && (typeof args[key] !== 'number'
+                || !Number.isSafeInteger(args[key]) || args[key] < 1 || args[key] > 1_000_000))
+                || (args.cursor !== undefined && (typeof args.cursor !== 'string' || !args.cursor || args.cursor.length > 2048))) {
+                return fail('invalid_arguments', 'Expected positive startLine/limit and an optional cursor');
+            }
+            return null;
+        }
+        if (name === 'patch' && (!Array.isArray(args.files) || !args.files.length || args.files.length > 16
+            || !args.files.every(object)))
+            return fail('invalid_arguments', 'patch expects 1..16 existing files');
+        const targets = targetsFor(args, name);
+        for (const target of targets) {
+            if (!validPath(target.path))
+                return fail(typeof target.path === 'string' && (path.isAbsolute(target.path)
+                    || target.path.split(/[\\/]/).includes('..')) ? 'path_out_of_scope' : 'invalid_arguments', 'Expected bounded relative file paths');
+            if (name === 'patch' && Object.keys(target).some(key => !['path', 'expectedSha256', 'edits'].includes(key))) {
+                return fail('invalid_arguments', 'Unexpected patch file fields');
+            }
+            if (target.expectedSha256 !== undefined && (typeof target.expectedSha256 !== 'string'
+                || !/^[a-f0-9]{64}$/.test(target.expectedSha256)))
+                return fail('invalid_arguments', 'Expected lowercase SHA-256');
+            if (name === 'write') {
+                if (typeof target.content !== 'string')
+                    return fail('invalid_arguments', 'Expected content');
+                if (Buffer.byteLength(target.content) > maxBytes)
+                    return fail('too_large', 'Text exceeds byte limit');
+            }
+            else {
+                if (typeof target.expectedSha256 !== 'string' || !Array.isArray(target.edits) || !target.edits.length
+                    || target.edits.length > 32 || target.edits.some(edit => !object(edit)
+                    || Object.keys(edit).some(key => !['oldText', 'newText'].includes(key))
+                    || typeof edit.oldText !== 'string' || !edit.oldText || typeof edit.newText !== 'string')) {
+                    return fail('invalid_arguments', 'Expected 1..32 exact edits and a SHA-256 precondition');
+                }
+                if (target.edits.some(edit => [edit.oldText, edit.newText].some(text => Buffer.byteLength(text) > maxBytes))) {
+                    return fail('too_large', 'Text exceeds byte limit');
+                }
+            }
+        }
+        return null;
+    };
+    const editSchema = { type: 'object', properties: { oldText: { type: 'string' }, newText: { type: 'string' } },
+        required: ['oldText', 'newText'], additionalProperties: false };
+    return ['read', 'write', 'edit', 'patch'].map(name => ({
+        definition: {
+            name,
+            description: name === 'read' ? 'Read UTF-8 pages with full-file SHA-256, exact byte offsets and request-bound cursor'
+                : name === 'patch' ? 'Unique nonoverlapping original-text edits to existing files; preflight all, sequential commits, bounded actual diffs; partial failures stop'
+                    : name === 'edit' ? 'Replace one unique literal match with expected SHA-256 and actual diff'
+                        : 'Create or replace UTF-8 text with SHA-256 precondition and actual diff',
+            inputSchema: { type: 'object', properties: name === 'patch' ? { files: { type: 'array', minItems: 1, maxItems: 16,
+                        items: { type: 'object', properties: { path: { type: 'string' }, expectedSha256: { type: 'string' },
+                                edits: { type: 'array', minItems: 1, maxItems: 32, items: editSchema } },
+                            required: ['path', 'expectedSha256', 'edits'], additionalProperties: false } } }
+                    : { path: { type: 'string' }, ...(name === 'read' ? { startLine: { type: 'integer' },
+                            limit: { type: 'integer' }, cursor: { type: 'string' } } : { expectedSha256: { type: 'string' },
+                            ...(name === 'edit' ? editSchema.properties : { content: { type: 'string' } }) }) },
+                required: name === 'patch' ? ['files'] : name === 'read' ? ['path'] : name === 'edit'
+                    ? ['path', 'expectedSha256', 'oldText', 'newText'] : ['path', 'content'], additionalProperties: false },
+        },
+        validate: args => validate(args, name),
+        async execute(args, scope, signal) {
+            const invalid = validate(args, name);
+            if (invalid)
+                return { ok: false, error: invalid };
+            const outcome = (value) => ({ ok: true, content: JSON.stringify(value) });
+            const fit = (result) => fits(result, maxOutputBytes, name, scope.toolCallId);
+            const readText = async (target) => {
+                const snapshot = await readSnapshot(target, maxBytes, signal);
+                assertText(snapshot.text);
+                return snapshot;
+            };
+            const held = [];
+            const receipts = [];
+            let temporary;
+            let committing = false;
+            let index = 0;
+            try {
+                signal.throwIfAborted();
+                if (name === 'read') {
+                    const request = args;
+                    const snapshot = await readText(await checkPath(root, request.path));
+                    const binding = digest(JSON.stringify([request.path, request.startLine ?? 1, request.limit ?? 200, maxBytes, maxOutputBytes]));
+                    const fingerprint = snapshot.sha256 + ':' + snapshot.identity;
+                    let start = readCursor(request.cursor, binding, fingerprint, snapshot.text.length);
+                    if (!request.cursor) {
+                        for (let line = 1; line < (request.startLine ?? 1); line++) {
+                            const offset = snapshot.text.indexOf('\n', start);
+                            if (offset < 0)
+                                throw new FileFault('line_out_of_range', 'startLine is beyond EOF');
+                            start = offset + 1;
+                        }
+                    }
+                    if (start > 0 && /[\uDC00-\uDFFF]/.test(snapshot.text[start] ?? ''))
+                        throw new FileFault('invalid_cursor', 'Cursor splits a code point');
+                    let end = start;
+                    for (let count = 0; count < (request.limit ?? 200) && end < snapshot.text.length; count++) {
+                        const offset = snapshot.text.indexOf('\n', end);
+                        end = offset < 0 ? snapshot.text.length : offset + 1;
+                    }
+                    const requestedEnd = end;
+                    const lineAt = (offset) => {
+                        let line = 1;
+                        for (let i = 0; i < offset; i++)
+                            if (snapshot.text[i] === '\n')
+                                line++;
+                        return line;
+                    };
+                    const make = (stop) => outcome({ path: request.path, text: snapshot.text.slice(start, stop),
+                        bytes: Buffer.byteLength(snapshot.text.slice(start, stop)), fileBytes: snapshot.bytes, sha256: snapshot.sha256,
+                        byteStart: Buffer.byteLength(snapshot.text.slice(0, start)), byteEnd: Buffer.byteLength(snapshot.text.slice(0, stop)),
+                        startLine: lineAt(start), endLine: lineAt(Math.max(start, stop - 1)),
+                        complete: stop === snapshot.text.length, nextCursor: stop === snapshot.text.length ? null : cursor(binding, fingerprint, stop),
+                        truncationReason: stop < requestedEnd ? 'output_bytes' : stop < snapshot.text.length ? 'line_limit' : null });
+                    if (!fit(make(end))) {
+                        let low = start;
+                        let high = end;
+                        while (low < high) {
+                            let middle = Math.ceil((low + high) / 2);
+                            if (/[\uDC00-\uDFFF]/.test(snapshot.text[middle] ?? ''))
+                                middle--;
+                            if (middle <= low)
+                                break;
+                            if (fit(make(middle)))
+                                low = middle;
+                            else
+                                high = middle - 1;
+                        }
+                        end = low;
+                    }
+                    if ((end === start && start < snapshot.text.length) || !fit(make(end))) {
+                        throw new FileFault('output_limit', 'Budget cannot hold one code point and metadata');
+                    }
+                    return make(end);
+                }
+                const targets = targetsFor(args, name);
+                const keys = targets.map(target => path.resolve(root, target.path));
+                if (new Set(keys).size !== keys.length)
+                    throw new FileFault('edit_conflict', 'Duplicate target paths');
+                for (const key of [...keys].sort()) {
+                    const previous = writers.get(key);
+                    let release;
+                    const promise = new Promise(resolve => { release = resolve; });
+                    writers.set(key, promise);
+                    held.push({ key, promise, release });
+                    await previous;
+                    signal.throwIfAborted();
+                }
+                const snapshots = [];
+                const candidates = [];
+                const snapshot = async (target) => {
+                    const absolute = await checkPath(root, target.path, name === 'write');
+                    if (absolute === root)
+                        throw new FileFault('not_regular_file', 'Expected a file');
+                    try {
+                        return await readText(absolute);
+                    }
+                    catch (error) {
+                        if (name === 'write' && error.code === 'ENOENT')
+                            return undefined;
+                        throw error;
+                    }
+                };
+                let totalBytes = 0;
+                for (const target of targets) {
+                    signal.throwIfAborted();
+                    const before = await snapshot(target);
+                    if (target.expectedSha256 === undefined ? before !== undefined : before?.sha256 !== target.expectedSha256) {
+                        throw new FileFault('edit_conflict', 'File changed or exists without an expected SHA-256');
+                    }
+                    const edits = target.edits ? target.edits.map(edit => {
+                        const start = before.text.indexOf(edit.oldText);
+                        if (start < 0 || before.text.indexOf(edit.oldText, start + 1) >= 0) {
+                            throw new FileFault('edit_conflict', 'oldText must match exactly once, including overlapping matches');
+                        }
+                        return { start, end: start + edit.oldText.length, text: edit.newText };
+                    }).sort((a, b) => a.start - b.start) : [{ start: 0, end: before?.text.length ?? 0, text: target.content }];
+                    if (edits.some((edit, i) => i > 0 && edit.start < edits[i - 1].end))
+                        throw new FileFault('edit_conflict', 'Edits overlap in original text');
+                    const next = replace(before?.text ?? '', edits);
+                    assertText(next);
+                    const bytes = Buffer.byteLength(next);
+                    totalBytes += bytes + (before?.bytes ?? 0);
+                    if (bytes > maxBytes || totalBytes > 32 * 1024 * 1024)
+                        throw new FileFault('too_large', 'Mutation snapshot byte budget exceeded');
+                    snapshots.push(before);
+                    candidates.push(next);
+                    receipts.push({ path: target.path, status: 'not_attempted', beforeSha256: before?.sha256 ?? null,
+                        sha256: null, candidateSha256: digest(next), bytes,
+                        diff: diff(target.path, before?.text ?? '', edits, next, before === undefined) });
+                }
+                const success = () => outcome(name === 'patch' ? { files: receipts, complete: true } : receipts[0]);
+                const cleanupPath = targets.reduce((longest, target) => {
+                    const candidate = path.join(path.dirname(target.path), `.agent-${'0'.repeat(36)}.tmp`);
+                    return Buffer.byteLength(JSON.stringify(JSON.stringify(candidate))) > Buffer.byteLength(JSON.stringify(JSON.stringify(longest)))
+                        ? candidate : longest;
+                }, '');
+                const reserved = receipts.map(receipt => ({ ...receipt, status: 'not_attempted', sha256: receipt.candidateSha256 }));
+                const partial = { ok: false, error: { code: 'cancelled_before_commit', effect: 'unknown',
+                        message: JSON.stringify({ complete: false, files: reserved, failedIndex: targets.length, cause: 'cancelled_before_commit',
+                            temporary: cleanupPath }) + ' '.repeat(256) } };
+                // Include the most expensive doubly encoded cleanup path BEFORE touching any file.
+                if (!fit(outcome(name === 'patch' ? { files: reserved, complete: true } : reserved[0])) || !fit(partial)) {
+                    throw new FileFault('output_limit', 'Encoded diff/receipt exceeds budget; no writes attempted');
+                }
+                committing = true;
+                for (index = 0; index < targets.length; index++) {
+                    const target = targets[index];
+                    signal.throwIfAborted();
+                    const absolute = await checkPath(root, target.path, name === 'write');
+                    const candidate = path.join(path.dirname(absolute), `.agent-${randomUUID()}.tmp`);
+                    const file = await open(candidate, 'wx', 0o600);
+                    temporary = candidate;
+                    try {
+                        await file.writeFile(candidates[index], { encoding: 'utf8', signal });
+                    }
+                    finally {
+                        await file.close();
+                    }
+                    const after = await snapshot(target);
+                    if (snapshots[index]?.identity !== after?.identity || snapshots[index]?.sha256 !== after?.sha256) {
+                        throw new FileFault('edit_conflict', 'File changed before commit; no replacement was made');
+                    }
+                    signal.throwIfAborted();
+                    await rename(temporary, absolute);
+                    temporary = undefined;
+                    receipts[index].status = 'committed';
+                    receipts[index].sha256 = receipts[index].candidateSha256;
+                }
+                return success();
+            }
+            catch (error) {
+                const code = error instanceof FileFault ? error.code : signal.aborted ? 'cancelled_before_commit'
+                    : error.code === 'ENOENT' ? 'not_found' : 'io_error';
+                let cleanupFailed = false;
+                if (temporary) {
+                    try {
+                        await unlink(temporary);
+                        temporary = undefined;
+                    }
+                    catch {
+                        cleanupFailed = true;
+                    }
+                }
+                const committed = receipts.some(receipt => receipt.status === 'committed');
+                if (committing && index < receipts.length)
+                    receipts[index].status = 'rejected';
+                if (committed || cleanupFailed)
+                    return { ok: false, error: { code: cleanupFailed ? 'cleanup_failed' : code, effect: 'unknown',
+                            message: JSON.stringify({ complete: false, files: receipts, failedIndex: index, cause: code,
+                                temporary: temporary ? path.relative(root, temporary) : null }) } };
+                return { ok: false, error: fail(code, error instanceof FileFault ? error.message : `File operation failed (${code})`) };
+            }
+            finally {
+                for (const lock of held.reverse()) {
+                    lock.release();
+                    if (writers.get(lock.key) === lock.promise)
+                        writers.delete(lock.key);
+                }
+            }
+        },
+    }));
+}