@nestos/kanban 0.5.1 → 0.5.2

package/dist/{chunk-T7P5EIC4.cjs → chunk-VMRDXOLX.cjs}

@@ -17,10 +17,10 @@
 
 
 
-var _chunkL44TM4EEcjs = require('./chunk-L44TM4EE.cjs');
+var _chunkEYTVC2H5cjs = require('./chunk-EYTVC2H5.cjs');
 
 
-var _chunk2YFPV5GFcjs = require('./chunk-2YFPV5GF.cjs');
+var _chunkRSH6QSECcjs = require('./chunk-RSH6QSEC.cjs');
 
 // src/store.ts
 var _vfscore = require('@nestos/vfs-core');
@@ -31,14 +31,14 @@ var SeqKanbanStore = class _SeqKanbanStore {
     this.bodies = _nullishCoalesce(bodies, () => ( { read: async (hash) => {
       const body = await fs.meta.assets.getAsset(path, `${hash}.json`);
       if (body === null || body instanceof ArrayBuffer) return body;
-      throw new (0, _chunk2YFPV5GFcjs.KanbanError)("BODY_INTEGRITY");
+      throw new (0, _chunkRSH6QSECcjs.KanbanError)("BODY_INTEGRITY");
     }, write: async (hash, bytes) => {
       await fs.meta.assets.putAsset(path, `${hash}.json`, bytes);
     } }));
   }
   
   static async open(fs, directory = "/kanban", bodies) {
-    if (!_optionalChain([fs, 'access', _2 => _2.meta, 'access', _3 => _3.seq, 'optionalAccess', _4 => _4.transaction])) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("TRANSACTION_REQUIRED");
+    if (!_optionalChain([fs, 'access', _2 => _2.meta, 'access', _3 => _3.seq, 'optionalAccess', _4 => _4.transaction])) throw new (0, _chunkRSH6QSECcjs.KanbanError)("TRANSACTION_REQUIRED");
     try {
       await fs.driver.createFile({ parentPath: directory, name: "boards.seq", type: "seqfile", recursive: true });
     } catch (error) {
@@ -47,7 +47,7 @@ var SeqKanbanStore = class _SeqKanbanStore {
     return new _SeqKanbanStore(fs, `${directory}/boards.seq`, bodies);
   }
   async boardId(number) {
-    return this.fs.meta.seq.getEntry(this.path, _chunkL44TM4EEcjs.boardNumberKey.call(void 0, number));
+    return this.fs.meta.seq.getEntry(this.path, _chunkEYTVC2H5cjs.boardNumberKey.call(void 0, number));
   }
   async ids() {
     return JSON.parse(await _asyncNullishCoalesce(await this.fs.meta.seq.getEntry(this.path, "index"), async () => ( "[]")));
@@ -60,61 +60,61 @@ var SeqKanbanStore = class _SeqKanbanStore {
     return keys.filter((key) => rows[key] !== void 0).map((key) => JSON.parse(rows[key]));
   }
   async archived(boardId, itemId) {
-    const raw = await this.fs.meta.seq.getEntry(this.path, _chunkL44TM4EEcjs.archiveKey.call(void 0, boardId, itemId));
+    const raw = await this.fs.meta.seq.getEntry(this.path, _chunkEYTVC2H5cjs.archiveKey.call(void 0, boardId, itemId));
     if (!raw) return null;
-    const record = await _chunkL44TM4EEcjs.decodeRow.call(void 0, raw, this.bodies);
+    const record = await _chunkEYTVC2H5cjs.decodeRow.call(void 0, raw, this.bodies);
     record.item.number ??= await _asyncOptionalChain([(await this.view(boardId)), 'optionalAccess', async _5 => _5.state, 'access', async _6 => _6.archiveIndex, 'optionalAccess', async _7 => _7.find, 'call', async _8 => _8((item) => item.id === itemId), 'optionalAccess', async _9 => _9.number]);
     return record;
   }
   async load(id, receiptKey) {
     return this.fs.meta.seq.transaction(async (tx) => {
-      const raw = await tx.getEntry(this.path, _chunkL44TM4EEcjs.boardKey.call(void 0, id));
-      return { raw, rows: await tx.getEntries(this.path, _chunkL44TM4EEcjs.rowKeys.call(void 0, raw)), receipt: receiptKey ? await tx.getEntry(this.path, receiptKey) : void 0 };
+      const raw = await tx.getEntry(this.path, _chunkEYTVC2H5cjs.boardKey.call(void 0, id));
+      return { raw, rows: await tx.getEntries(this.path, _chunkEYTVC2H5cjs.rowKeys.call(void 0, raw)), receipt: receiptKey ? await tx.getEntry(this.path, receiptKey) : void 0 };
     });
   }
   async view(id) {
-    const raw = await this.fs.meta.seq.getEntry(this.path, _chunkL44TM4EEcjs.boardKey.call(void 0, id));
-    const indexed = _chunkL44TM4EEcjs.indexedView.call(void 0, raw);
+    const raw = await this.fs.meta.seq.getEntry(this.path, _chunkEYTVC2H5cjs.boardKey.call(void 0, id));
+    const indexed = _chunkEYTVC2H5cjs.indexedView.call(void 0, raw);
     if (indexed) return indexed;
     const state = await this.read(id);
-    return state ? _chunkL44TM4EEcjs.viewFromState.call(void 0, state) : null;
+    return state ? _chunkEYTVC2H5cjs.viewFromState.call(void 0, state) : null;
   }
   async read(id) {
-    return _chunkL44TM4EEcjs.hydrate.call(void 0, await this.load(id), this.bodies);
+    return _chunkEYTVC2H5cjs.hydrate.call(void 0, await this.load(id), this.bodies);
   }
   async update(id, operationId, fingerprint, change) {
     const receiptKey = `receipt/${encodeURIComponent(id)}/${encodeURIComponent(operationId)}`;
-    const before = await this.load(id, receiptKey), current = await _chunkL44TM4EEcjs.hydrate.call(void 0, before, this.bodies), receipt = before.receipt;
+    const before = await this.load(id, receiptKey), current = await _chunkEYTVC2H5cjs.hydrate.call(void 0, before, this.bodies), receipt = before.receipt;
     if (receipt) {
-      _chunkL44TM4EEcjs.verifyReceipt.call(void 0, receipt, fingerprint);
-      if (!current) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("CORRUPT_RECEIPT");
+      _chunkEYTVC2H5cjs.verifyReceipt.call(void 0, receipt, fingerprint);
+      if (!current) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CORRUPT_RECEIPT");
       return current;
     }
     const original = JSON.stringify(current), next = change(current);
-    _chunkL44TM4EEcjs.numberEntities.call(void 0, next);
+    _chunkEYTVC2H5cjs.numberEntities.call(void 0, next);
     if (JSON.stringify(next) === original) return next;
     return this.persist(id, receiptKey, fingerprint, before, next);
   }
   async persist(id, receiptKey, fingerprint, before, next) {
-    const events = [...next.events], archives = await Promise.all((_nullishCoalesce(next.archiveWrites, () => ( []))).map(async (write) => ({ key: _chunkL44TM4EEcjs.archiveKey.call(void 0, id, write.id), value: write.value ? await _chunkL44TM4EEcjs.encodeRow.call(void 0, write.value, this.bodies) : null })));
+    const events = [...next.events], archives = await Promise.all((_nullishCoalesce(next.archiveWrites, () => ( []))).map(async (write) => ({ key: _chunkEYTVC2H5cjs.archiveKey.call(void 0, id, write.id), value: write.value ? await _chunkEYTVC2H5cjs.encodeRow.call(void 0, write.value, this.bodies) : null })));
     delete next.archiveWrites;
     next.events = [];
-    const encoded = await _chunkL44TM4EEcjs.encodeBoard.call(void 0, next, this.bodies);
+    const encoded = await _chunkEYTVC2H5cjs.encodeBoard.call(void 0, next, this.bodies);
     const committed = await this.fs.meta.seq.transaction(async (tx) => {
       const latestReceipt = await tx.getEntry(this.path, receiptKey);
       if (latestReceipt) {
-        _chunkL44TM4EEcjs.verifyReceipt.call(void 0, latestReceipt, fingerprint);
+        _chunkEYTVC2H5cjs.verifyReceipt.call(void 0, latestReceipt, fingerprint);
         return null;
       }
-      if (await tx.getEntry(this.path, _chunkL44TM4EEcjs.boardKey.call(void 0, id)) !== before.raw) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("REVISION_CONFLICT");
+      if (await tx.getEntry(this.path, _chunkEYTVC2H5cjs.boardKey.call(void 0, id)) !== before.raw) throw new (0, _chunkRSH6QSECcjs.KanbanError)("REVISION_CONFLICT");
       await commitBoardNumber(tx, this.path, id, before, next, encoded);
       const eventRows = events.map((event) => ({ key: `event/${encodeURIComponent(id)}/${String(event.sequence).padStart(16, "0")}`, value: JSON.stringify(event) }));
       await writeRows(tx, this.path, [
         ...eventRows,
-        ..._chunkL44TM4EEcjs.rowChanges.call(void 0, before, encoded),
+        ..._chunkEYTVC2H5cjs.rowChanges.call(void 0, before, encoded),
         ...archives,
-        { key: _chunkL44TM4EEcjs.boardKey.call(void 0, id), value: encoded.raw },
-        { key: receiptKey, value: _chunkL44TM4EEcjs.receiptDigest.call(void 0, fingerprint) }
+        { key: _chunkEYTVC2H5cjs.boardKey.call(void 0, id), value: encoded.raw },
+        { key: receiptKey, value: _chunkEYTVC2H5cjs.receiptDigest.call(void 0, fingerprint) }
       ]);
       const ids = JSON.parse(await _asyncNullishCoalesce(await tx.getEntry(this.path, "index"), async () => ( "[]")));
       if (!ids.includes(id)) await tx.setEntry(this.path, "index", JSON.stringify([...ids, id]));
@@ -122,7 +122,7 @@ var SeqKanbanStore = class _SeqKanbanStore {
     });
     if (committed) return committed;
     const replay = await this.read(id);
-    if (!replay) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("CORRUPT_RECEIPT");
+    if (!replay) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CORRUPT_RECEIPT");
     return replay;
   }
 };
@@ -133,16 +133,16 @@ async function writeRows(tx, path, rows) {
   }
 }
 async function commitBoardNumber(tx, path, id, before, next, encoded) {
-  const previous = _chunkL44TM4EEcjs.counter.call(void 0, await tx.getEntry(path, _chunkL44TM4EEcjs.boardCounterKey));
-  next.board.number = _chunkL44TM4EEcjs.allocateBoardNumber.call(void 0, before.raw, previous);
-  const owner = await tx.getEntry(path, _chunkL44TM4EEcjs.boardNumberKey.call(void 0, next.board.number));
-  if (owner !== null && owner !== id) throw new (0, _chunk2YFPV5GFcjs.KanbanError)("INVALID_NUMBERING");
-  encoded.raw = _chunkL44TM4EEcjs.patchBoardNumber.call(void 0, encoded.raw, next.board.number);
-  await tx.setEntry(path, _chunkL44TM4EEcjs.boardCounterKey, String(Math.max(previous, next.board.number)));
-  await tx.setEntry(path, _chunkL44TM4EEcjs.boardNumberKey.call(void 0, next.board.number), id);
+  const previous = _chunkEYTVC2H5cjs.counter.call(void 0, await tx.getEntry(path, _chunkEYTVC2H5cjs.boardCounterKey));
+  next.board.number = _chunkEYTVC2H5cjs.allocateBoardNumber.call(void 0, before.raw, previous);
+  const owner = await tx.getEntry(path, _chunkEYTVC2H5cjs.boardNumberKey.call(void 0, next.board.number));
+  if (owner !== null && owner !== id) throw new (0, _chunkRSH6QSECcjs.KanbanError)("INVALID_NUMBERING");
+  encoded.raw = _chunkEYTVC2H5cjs.patchBoardNumber.call(void 0, encoded.raw, next.board.number);
+  await tx.setEntry(path, _chunkEYTVC2H5cjs.boardCounterKey, String(Math.max(previous, next.board.number)));
+  await tx.setEntry(path, _chunkEYTVC2H5cjs.boardNumberKey.call(void 0, next.board.number), id);
 }
 
 
 
 exports.SeqKanbanStore = SeqKanbanStore;
-//# sourceMappingURL=chunk-T7P5EIC4.cjs.map
+//# sourceMappingURL=chunk-VMRDXOLX.cjs.map

package/dist/chunk-VMRDXOLX.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/li/share/prj/x1/libraries/kanban/dist/chunk-VMRDXOLX.cjs","../src/store.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACF,wDAA6B;AAC7B;AACA;ACtBA,2CAA0C;AAKnC,IAAM,eAAA,EAAN,MAAM,gBAAsC;AAAA,EAEvC,WAAA,CAA6B,EAAA,EAAkC,IAAA,EAAc,MAAA,EAA0B;AAA1E,IAAA,IAAA,CAAA,GAAA,EAAA,EAAA;AAAkC,IAAA,IAAA,CAAA,KAAA,EAAA,IAAA;AACnE,IAAA,IAAA,CAAK,OAAA,mBAAS,MAAA,UAAU,EAAC,IAAA,EAAM,MAAA,CAAM,IAAA,EAAA,GAAQ;AACzC,MAAA,MAAM,KAAA,EAAO,MAAM,EAAA,CAAG,IAAA,CAAK,MAAA,CAAO,QAAA,CAAS,IAAA,EAAM,CAAA,EAAA;AACC,MAAA;AACZ,MAAA;AACT,IAAA;AAA4C,MAAA;AAAiB,IAAA;AAClG,EAAA;AAPiB,EAAA;AAQ4F,EAAA;AAChE,IAAA;AACrC,IAAA;AAA2C,MAAA;AACjC,IAAA;AAAoD,MAAA;AAAuB,IAAA;AAC/C,IAAA;AAC9C,EAAA;AACsD,EAAA;AAA8C,IAAA;AAAwB,EAAA;AAC7F,EAAA;AACwB,IAAA;AACvD,EAAA;AACgG,EAAA;AACjD,IAAA;AACQ,IAAA;AAEzB,IAAA;AAE2B,IAAA;AACF,IAAA;AACvD,EAAA;AAEoF,EAAA;AAC9B,IAAA;AACjC,IAAA;AAAyE,IAAA;AACvC,IAAA;AAAqE,IAAA;AAC5H,EAAA;AACsG,EAAA;AAChD,IAAA;AACD,MAAA;AACD,MAAA;AAC/C,IAAA;AACL,EAAA;AACuB,EAAA;AAC+B,IAAA;AACnB,IAAA;AAAuB,IAAA;AACtB,IAAA;AAAyC,IAAA;AAC7E,EAAA;AACoD,EAAA;AAAgD,IAAA;AAAE,EAAA;AAExB,EAAA;AACtB,IAAA;AACJ,IAAA;AACnC,IAAA;AAAmC,MAAA;AAAuC,MAAA;AAA2B,MAAA;AAAQ,IAAA;AACzE,IAAA;AAC9B,IAAA;AAC2B,IAAA;AACG,IAAA;AACrD,EAAA;AACgG,EAAA;AAC1C,IAAA;AAEtC,IAAA;AAA8B,IAAA;AAES,IAAA;AACT,IAAA;AACO,MAAA;AAC1B,MAAA;AAAyC,QAAA;AAAU,QAAA;AAAK,MAAA;AACnC,MAAA;AACG,MAAA;AACE,MAAA;AACd,MAAA;AAAI,QAAA;AAAwC,QAAA;AAAM,QAAA;AAC3C,QAAA;AAA0C,QAAA;AAAc,MAAA;AACtC,MAAA;AACV,MAAA;AACvC,MAAA;AACV,IAAA;AACqB,IAAA;AACW,IAAA;AAAuD,IAAA;AAAU,IAAA;AACtG,EAAA;AACJ;AAC4J;AAChI,EAAA;AAC+B,IAAA;AACJ,IAAA;AACnD,EAAA;AACJ;AAEoI;AAC/E,EAAA;AACG,EAAA;AACC,EAAA;AACP,EAAA;AACI,EAAA;AACG,EAAA;AACH,EAAA;AACtD;AD2CwD;AACA;AACA;AACA","file":"/home/li/share/prj/x1/libraries/kanban/dist/chunk-VMRDXOLX.cjs","sourcesContent":[null,"import {numberEntities, boardCounterKey, boardNumberKey, counter, allocateBoardNumber, patchBoardNumber} from './numbering';\nimport type { KanbanEvent, KanbanArchivedItem } from './contracts';\nimport { FSError, type IFileSystem } from '@nestos/vfs-core';\nimport { KanbanError, type KanbanState, type KanbanStore } from './ports';\nimport {indexedView, viewFromState, archiveKey, boardKey as key, rowKeys, hydrate, encodeBoard, rowChanges, encodeRow, decodeRow, receiptDigest, verifyReceipt, type StoredBoard, type KanbanBodyStore} from './storage-codec';\n\n/** One user-scoped journal, with atomic board/index/receipt commits. */\nexport class SeqKanbanStore implements KanbanStore {\n    private readonly bodies: KanbanBodyStore;\n    private constructor(private readonly fs: IFileSystem, private readonly path: string, bodies?: KanbanBodyStore) {\n        this.bodies = bodies ?? {read: async hash => {\n            const body = await fs.meta.assets.getAsset(path, `${hash}.json`);\n            if (body === null || body instanceof ArrayBuffer) return body;\n            throw new KanbanError('BODY_INTEGRITY');\n        }, write: async (hash, bytes) => {await fs.meta.assets.putAsset(path, `${hash}.json`, bytes);}};\n    }\n    static async open(fs: IFileSystem, directory = '/kanban', bodies?: KanbanBodyStore): Promise<SeqKanbanStore> {\n        if (!fs.meta.seq?.transaction) throw new KanbanError('TRANSACTION_REQUIRED');\n        try { await fs.driver.createFile({ parentPath: directory, name: 'boards.seq', type: 'seqfile', recursive: true }); }\n        catch (error) { if (!(error instanceof FSError) || error.code !== 'EEXIST') throw error; }\n        return new SeqKanbanStore(fs, `${directory}/boards.seq`, bodies);\n    }\n    async boardId(number: number): Promise<string | null> {return this.fs.meta.seq!.getEntry(this.path, boardNumberKey(number));}\n    async ids(): Promise<string[]> {\n        return JSON.parse(await this.fs.meta.seq!.getEntry(this.path, 'index') ?? '[]');\n    }\n    async events(id: string, after: number, limit: number, through: number): Promise<KanbanEvent[]> {\n        const end = Math.min(through, after + limit);\n        const keys = Array.from({length: Math.max(0, end - after)}, (_, index) =>\n            `event/${encodeURIComponent(id)}/${String(after + index + 1).padStart(16, '0')}`);\n        if (!keys.length) return [];\n        // The committed sequence freezes this immutable prefix; bulk key reads avoid history scans.\n        const rows = await this.fs.meta.seq!.getEntries(this.path, keys);\n        return keys.filter(key => rows[key] !== undefined).map(key => JSON.parse(rows[key]) as KanbanEvent);\n    }\n\n    async archived(boardId: string, itemId: string): Promise<KanbanArchivedItem | null> {\n        const raw = await this.fs.meta.seq!.getEntry(this.path, archiveKey(boardId, itemId));\n        if (!raw) return null; const record = await decodeRow<KanbanArchivedItem>(raw, this.bodies);\n        record.item.number ??= (await this.view(boardId))?.state.archiveIndex?.find(item => item.id === itemId)?.number; return record;\n    }\n    private async load(id: string, receiptKey?: string): Promise<StoredBoard & {receipt?: string | null}> {\n        return this.fs.meta.seq!.transaction!(async tx => {\n            const raw = await tx.getEntry(this.path, key(id));\n            return {raw, rows: await tx.getEntries(this.path, rowKeys(raw)), receipt: receiptKey ? await tx.getEntry(this.path, receiptKey) : undefined};\n        });\n    }\n    async view(id: string) {\n        const raw = await this.fs.meta.seq!.getEntry(this.path, key(id));\n        const indexed = indexedView(raw); if (indexed) return indexed;\n        const state = await this.read(id); return state ? viewFromState(state) : null;\n    }\n    async read(id: string): Promise<KanbanState | null> {return hydrate(await this.load(id), this.bodies);}\n    async update(id: string, operationId: string, fingerprint: string,\n        change: (state: KanbanState | null) => KanbanState): Promise<KanbanState> {\n        const receiptKey = `receipt/${encodeURIComponent(id)}/${encodeURIComponent(operationId)}`;\n        const before = await this.load(id, receiptKey), current = await hydrate(before, this.bodies), receipt = before.receipt;\n        if (receipt) {verifyReceipt(receipt, fingerprint); if (!current) throw new KanbanError('CORRUPT_RECEIPT'); return current;}\n        const original = JSON.stringify(current), next = change(current);\n        numberEntities(next);\n        if (JSON.stringify(next) === original) return next;\n        return this.persist(id, receiptKey, fingerprint, before, next);\n    }\n    private async persist(id: string, receiptKey: string, fingerprint: string, before: StoredBoard, next: KanbanState): Promise<KanbanState> {\n        const events = [...next.events], archives = await Promise.all((next.archiveWrites ?? []).map(async write =>\n            ({key: archiveKey(id, write.id), value: write.value ? await encodeRow(write.value, this.bodies) : null})));\n        delete next.archiveWrites; next.events = [];\n        // No asset I/O runs under the SeqFile transaction: it may use the same backend.\n        const encoded = await encodeBoard(next, this.bodies);\n        const committed = await this.fs.meta.seq!.transaction!(async tx => {\n            const latestReceipt = await tx.getEntry(this.path, receiptKey);\n            if (latestReceipt) {verifyReceipt(latestReceipt, fingerprint); return null;}\n            if (await tx.getEntry(this.path, key(id)) !== before.raw) throw new KanbanError('REVISION_CONFLICT');\n            await commitBoardNumber(tx, this.path, id, before, next, encoded);\n            const eventRows = events.map(event => ({key: `event/${encodeURIComponent(id)}/${String(event.sequence).padStart(16, '0')}`, value: JSON.stringify(event)}));\n            await writeRows(tx, this.path, [...eventRows, ...rowChanges(before, encoded), ...archives,\n                {key: key(id), value: encoded.raw!}, {key: receiptKey, value: receiptDigest(fingerprint)}]);\n            const ids: string[] = JSON.parse(await tx.getEntry(this.path, 'index') ?? '[]');\n            if (!ids.includes(id)) await tx.setEntry(this.path, 'index', JSON.stringify([...ids, id]));\n            return next;\n        });\n        if (committed) return committed;\n        const replay = await this.read(id); if (!replay) throw new KanbanError('CORRUPT_RECEIPT'); return replay;\n    }\n}\nasync function writeRows(tx: import('@nestos/vfs-core').ISeqFileTransaction, path: string, rows: Array<{key: string; value: string | null}>): Promise<void> {\n    for (const row of rows) {\n        if (row.value === null) await tx.deleteEntry(path, row.key);\n        else await tx.setEntry(path, row.key, row.value);\n    }\n}\n\nasync function commitBoardNumber(tx: import('@nestos/vfs-core').ISeqFileTransaction, path: string, id: string, before: StoredBoard, next: KanbanState, encoded: StoredBoard): Promise<void> {\n    const previous = counter(await tx.getEntry(path, boardCounterKey));\n    next.board.number = allocateBoardNumber(before.raw, previous);\n    const owner = await tx.getEntry(path, boardNumberKey(next.board.number));\n    if (owner !== null && owner !== id) throw new KanbanError('INVALID_NUMBERING');\n    encoded.raw = patchBoardNumber(encoded.raw!, next.board.number);\n    await tx.setEntry(path, boardCounterKey, String(Math.max(previous, next.board.number)));\n    await tx.setEntry(path, boardNumberKey(next.board.number), id);\n}\n"]}

package/dist/{chunk-5XKOCKY2.js → chunk-X4UHZX6F.js}

@@ -55,4 +55,4 @@ export {
   DEFAULT_KANBAN_SCAN_POLICY,
   sameAutomationBinding
 };
-//# sourceMappingURL=chunk-5XKOCKY2.js.map
+//# sourceMappingURL=chunk-X4UHZX6F.js.map

package/dist/chunk-XBSGUVCY.cjs

@@ -0,0 +1,382 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk4XF6LQSUcjs = require('./chunk-4XF6LQSU.cjs');
+
+
+
+
+var _chunkRSH6QSECcjs = require('./chunk-RSH6QSEC.cjs');
+
+
+
+var _chunkAOHQCX7Kcjs = require('./chunk-AOHQCX7K.cjs');
+
+// src/execution-bridge.ts
+async function createKanbanExecutionBridge(options) {
+  const path = `${options.directory}/executions.seq`;
+  try {
+    await options.fs.driver.createFile({ parentPath: options.directory, name: "executions.seq", type: "seqfile", recursive: true });
+  } catch (error) {
+    if (_optionalChain([error, 'optionalAccess', _ => _.code]) !== "EEXIST") throw error;
+  }
+  if (!_optionalChain([options, 'access', _2 => _2.fs, 'access', _3 => _3.meta, 'access', _4 => _4.seq, 'optionalAccess', _5 => _5.transaction])) throw new (0, _chunkRSH6QSECcjs.KanbanError)("TRANSACTION_REQUIRED");
+  let stopped = false, again = false, pending;
+  const writes = /* @__PURE__ */ new Set();
+  const failures = /* @__PURE__ */ new Map();
+  const track = (operation) => {
+    const tracked = operation.finally(() => {
+      writes.delete(tracked);
+    });
+    writes.add(tracked);
+    return tracked;
+  };
+  const active = () => !stopped;
+  const scan = async () => {
+    if (stopped) return;
+    if (pending) {
+      again = true;
+      return pending;
+    }
+    const started = Date.now();
+    pending = runBridge(options, path, active, track, failures).catch((error) => {
+      try {
+        options.log({ operationId: _chunkRSH6QSECcjs.randomUUID.call(void 0, ), stage: "bridge.scan", result: "failure", code: safeCode(error), durationMs: Date.now() - started });
+      } catch (e) {
+      }
+      throw error;
+    }).finally(() => {
+      pending = void 0;
+      if (again && !stopped) {
+        again = false;
+        void scan().catch(() => {
+        });
+      }
+    });
+    return pending;
+  };
+  const unsubscribe = _optionalChain([options, 'access', _6 => _6.subscribe, 'optionalCall', _7 => _7(() => {
+    void scan().catch(() => {
+    });
+  })]);
+  return { scan, tick: scan, async quiesce() {
+    stopped = true;
+    _optionalChain([unsubscribe, 'optionalCall', _8 => _8()]);
+    if (!pending) return;
+    let timer;
+    try {
+      await Promise.race([pending, new Promise((resolve) => {
+        timer = setTimeout(resolve, _nullishCoalesce(options.shutdownTimeoutMs, () => ( 5e3)));
+      })]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      await Promise.allSettled([...writes]);
+    }
+  } };
+}
+async function runBridge(options, path, active, track, failures) {
+  const workflow = await options.service.workflow(options.boardId);
+  const live = new Set(Object.values(workflow.dispatches).filter((dispatch) => ["prepared", "running", "unknown"].includes(dispatch.outcome)).map((dispatch) => dispatch.id));
+  for (const id of failures.keys()) if (!live.has(id)) failures.delete(id);
+  for (const dispatch of Object.values(workflow.dispatches)) {
+    if (!active()) return;
+    if (live.has(dispatch.id) && (_nullishCoalesce(_optionalChain([failures, 'access', _9 => _9.get, 'call', _10 => _10(dispatch.id), 'optionalAccess', _11 => _11.retryAt]), () => ( 0))) <= Date.now()) await runDispatch(options, path, dispatch, active, track, failures);
+  }
+  const automatic = typeof options.autoDispatch === "function" ? await options.autoDispatch() : options.autoDispatch;
+  if (!automatic || !active()) return;
+  for (const id of (await options.service.workflow(options.boardId)).ready) {
+    if (!active()) return;
+    const { item } = await options.service.item(options.boardId, id), owner = _optionalChain([item, 'access', _12 => _12.eligiblePrincipals, 'optionalAccess', _13 => _13[0]]);
+    if (!owner || !_chunkAOHQCX7Kcjs.taskDue.call(void 0, item, (_nullishCoalesce(options.now, () => ( Date.now)))())) continue;
+    const worker = await options.worker(owner), board = await worker.read(options.boardId);
+    if (!active()) return;
+    if (!_chunkAOHQCX7Kcjs.boardAllowsStart.call(void 0, board, item)) continue;
+    try {
+      const dispatchId = _chunkRSH6QSECcjs.randomUUID.call(void 0, );
+      const estimate = await _optionalChain([options, 'access', _14 => _14.estimate, 'optionalCall', _15 => _15(item, owner)]);
+      if (!active()) return;
+      await worker.execute(board.id, { operationId: "dispatch:" + dispatchId, expectedRevision: board.revision, command: { type: "prepare-dispatch", itemId: id, dispatchId, estimate, trigger: "automatic" } });
+      const dispatch = (await options.service.workflow(board.id)).dispatches[dispatchId];
+      if (active()) await runDispatch(options, path, dispatch, active, track, failures);
+    } catch (error) {
+      if (!["WIP_LIMIT", "ASSIGNEE_WIP_LIMIT", "READY_LIMIT", "REVISION_CONFLICT"].includes(safeCode(error))) throw error;
+    }
+  }
+}
+async function runDispatch(options, path, dispatch, active, track, failures) {
+  const start = Date.now();
+  let stage = "inspect", result;
+  const previousFailure = failures.has(dispatch.id);
+  try {
+    let record = await loadRecord(options, path, dispatch);
+    if (!active()) return;
+    const current = await options.service.item(options.boardId, dispatch.itemId);
+    if ((_optionalChain([current, 'access', _16 => _16.item, 'access', _17 => _17.control, 'optionalAccess', _18 => _18.action]) === "cancel" || (await options.service.read(options.boardId)).lifecycle) && await track(preventSubmission(options, path, dispatch))) {
+      await settle(options, dispatch, { outcome: "cancelled", code: "CANCELLED_BEFORE_START" });
+      return;
+    }
+    if ((!record || record.phase === "prepared") && (await _asyncOptionalChain([(await options.service.read(options.boardId)), 'access', async _19 => _19.executionControl, 'optionalAccess', async _20 => _20.paused]) || _optionalChain([current, 'access', _21 => _21.item, 'access', _22 => _22.control, 'optionalAccess', _23 => _23.action]) === "pause")) return;
+    if (!record) {
+      stage = "prepare";
+      await options.authorize(stage, dispatch);
+      if (!active()) return;
+      const item = (await options.service.item(options.boardId, dispatch.itemId)).item;
+      if (!active()) return;
+      const request = await prepareRequest(options, path, dispatch, item);
+      if (!active()) return;
+      record = await track(savePrepared(options, path, dispatch, request));
+    }
+    if (!active()) return;
+    const submit = record.phase === "prepared" && await track(claimSubmission(options, path, dispatch));
+    if (!submit && await options.fs.meta.seq.getEntry(path, "cancelled:" + dispatch.id)) {
+      await settle(options, dispatch, { outcome: "cancelled", code: "CANCELLED_BEFORE_START" });
+      return;
+    }
+    if (!active()) return;
+    stage = submit ? "start" : "inspect";
+    await options.authorize(stage, dispatch);
+    if (!active()) return;
+    result = await (submit ? options.executor.start(record.request) : options.executor.inspect(record.request));
+    failures.delete(dispatch.id);
+  } catch (error) {
+    const notStarted = _optionalChain([error, 'optionalAccess', _24 => _24.executionOutcome]) === "not-started" && error.retryable === true;
+    if (notStarted && stage === "start") await track(releaseUnstartedSubmission(options, path, dispatch));
+    result = { outcome: stage === "prepare" && !notStarted ? "failed" : "unknown", code: safeCode(error) };
+    if (stage === "inspect" || notStarted) {
+      const previous = failures.get(dispatch.id), count = previous && previous.code === result.code ? previous.count + 1 : 1;
+      failures.set(dispatch.id, { code: result.code, count, retryAt: Date.now() + Math.min(6e4, 1e3 * 2 ** Math.min(count - 1, 6)) });
+    }
+  }
+  if (stage !== "inspect" || _chunk4XF6LQSUcjs.executionObservationChanged.call(void 0, dispatch, result) || previousFailure && !failures.has(dispatch.id))
+    try {
+      options.log({ operationId: dispatch.id, stage: `bridge.${stage}`, result: ["unknown", "failed", "cancelled"].includes(result.outcome) ? "failure" : "success", code: result.code, ...failures.has(dispatch.id) ? { retryAfterMs: Math.max(0, failures.get(dispatch.id).retryAt - Date.now()) } : {}, durationMs: Date.now() - start });
+    } catch (e2) {
+    }
+  if (active()) try {
+    await linkSession(options, dispatch, result.executionSessionId);
+    if (active()) await settle(options, dispatch, result);
+  } catch (error) {
+    if (safeCode(error) !== "REVISION_CONFLICT") throw error;
+  }
+}
+async function releaseUnstartedSubmission(options, path, dispatch) {
+  await options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (!raw) throw new (0, _chunkRSH6QSECcjs.KanbanError)("EXECUTION_JOURNAL_MISSING");
+    const record = decodeRecord(raw, dispatch);
+    if (record.phase === "submitting") await tx.setEntry(path, dispatch.id, JSON.stringify({ ...record, phase: "prepared" }));
+  });
+}
+async function prepareRequest(options, path, dispatch, item) {
+  if (!dispatch.continuation) return options.executor.prepare(dispatch, item);
+  if (!options.executor.prepareContinuation) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CONTINUATION_UNSUPPORTED");
+  const previous = (await options.service.workflow(options.boardId)).dispatches[dispatch.continuation.previousDispatchId];
+  if (!previous || previous.itemId !== dispatch.itemId) throw new (0, _chunkRSH6QSECcjs.KanbanError)("CONTINUATION_SCOPE_MISMATCH");
+  const record = await loadRecord(options, path, previous);
+  if (!record) throw new (0, _chunkRSH6QSECcjs.KanbanError)("EXECUTION_JOURNAL_MISSING");
+  return options.executor.prepareContinuation(dispatch, item, record.request);
+}
+async function loadRecord(options, path, dispatch) {
+  const raw = await options.fs.meta.seq.getEntry(path, dispatch.id);
+  if (!raw) return;
+  return decodeRecord(raw, dispatch);
+}
+async function savePrepared(options, path, dispatch, request) {
+  const rawRequest = JSON.stringify(request);
+  if (typeof rawRequest !== "string" || new TextEncoder().encode(rawRequest).byteLength > 1024 * 1024) throw new (0, _chunkRSH6QSECcjs.KanbanError)("INVALID_EXECUTION_REQUEST");
+  return options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (raw) return decodeRecord(raw, dispatch);
+    const record = { schema: 1, fence: dispatch.fence, request: JSON.parse(rawRequest), digest: _chunkRSH6QSECcjs.sha256HexSync.call(void 0, rawRequest), phase: "prepared" };
+    await tx.setEntry(path, dispatch.id, JSON.stringify(record));
+    return record;
+  });
+}
+async function claimSubmission(options, path, dispatch) {
+  return options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (!raw) throw new (0, _chunkRSH6QSECcjs.KanbanError)("EXECUTION_JOURNAL_MISSING");
+    const record = decodeRecord(raw, dispatch);
+    if (record.phase !== "prepared" || await tx.getEntry(path, "cancelled:" + dispatch.id)) return false;
+    await tx.setEntry(path, dispatch.id, JSON.stringify({ ...record, phase: "submitting" }));
+    return true;
+  });
+}
+function decodeRecord(raw, dispatch) {
+  const record = JSON.parse(raw);
+  if (record.schema !== 1 || record.fence !== dispatch.fence || !["prepared", "submitting"].includes(record.phase) || record.digest !== _chunkRSH6QSECcjs.sha256HexSync.call(void 0, JSON.stringify(record.request))) throw new (0, _chunkRSH6QSECcjs.KanbanError)("INVALID_EXECUTION_JOURNAL");
+  return record;
+}
+async function settle(options, dispatch, result) {
+  const current = (await options.service.workflow(options.boardId)).dispatches[dispatch.id];
+  if (!current || !["prepared", "running", "unknown"].includes(current.outcome)) return;
+  const board = await options.service.read(options.boardId), item = board.items.find((item2) => item2.id === dispatch.itemId);
+  const renew = ["running", "unknown"].includes(result.outcome) && (_nullishCoalesce(_optionalChain([item, 'optionalAccess', _25 => _25.owner, 'optionalAccess', _26 => _26.leaseUntil]), () => ( 0))) <= Date.now() + board.policy.leaseMs / 2;
+  if (!renew && !_chunk4XF6LQSUcjs.executionObservationChanged.call(void 0, current, result)) return;
+  const { outcome, outputs, code, executionSessionId, controlCapabilities } = result, observation = { outcome, ...controlCapabilities ? { controlCapabilities } : {}, ...executionSessionId ? { executionSessionId } : {}, ...outputs ? { outputs } : {}, ...code ? { code } : {} };
+  const digest = _chunkRSH6QSECcjs.sha256HexSync.call(void 0, JSON.stringify(observation));
+  await options.service.execute(board.id, {
+    operationId: `settle:${dispatch.id}:${digest}:${board.revision}`,
+    expectedRevision: board.revision,
+    command: { type: "observe-execution", dispatchId: dispatch.id, fence: dispatch.fence, ...observation }
+  });
+}
+async function linkSession(options, dispatch, sessionId) {
+  if (!sessionId || !options.executionReference) return;
+  const reference = options.executionReference(sessionId, dispatch.id);
+  const board = await options.service.read(options.boardId), item = board.items.find((item2) => item2.id === dispatch.itemId);
+  if (_optionalChain([item, 'optionalAccess', _27 => _27.owner, 'optionalAccess', _28 => _28.token]) !== dispatch.fence) throw new (0, _chunkRSH6QSECcjs.KanbanError)("STALE_EXECUTION_RESULT");
+  const current = _optionalChain([item, 'access', _29 => _29.externalRefs, 'optionalAccess', _30 => _30.filter, 'call', _31 => _31((ref) => ref.system === reference.system), 'access', _32 => _32.at, 'call', _33 => _33(-1)]);
+  if (_optionalChain([current, 'optionalAccess', _34 => _34.id]) === reference.id && current.revision === reference.revision) return;
+  await options.service.execute(board.id, {
+    operationId: `execution-session:${dispatch.id}:${_chunkRSH6QSECcjs.sha256HexSync.call(void 0, sessionId)}:${board.revision}`,
+    expectedRevision: board.revision,
+    command: { type: "link-reference", itemId: dispatch.itemId, reference }
+  });
+}
+function safeCode(error) {
+  const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _35 => _35.reasonCode]), () => ( _optionalChain([error, 'optionalAccess', _36 => _36.code])));
+  return typeof code === "string" && /^[A-Z][A-Z0-9_]{0,79}$/.test(code) ? code : "EXECUTION_OBSERVATION_FAILED";
+}
+async function preventSubmission(options, path, dispatch) {
+  return options.fs.meta.seq.transaction(async (tx) => {
+    const raw = await tx.getEntry(path, dispatch.id);
+    if (raw && decodeRecord(raw, dispatch).phase === "submitting") return false;
+    await tx.setEntry(path, "cancelled:" + dispatch.id, dispatch.fence);
+    return true;
+  });
+}
+
+// src/monitor.ts
+function startKanbanMonitor(options) {
+  let stopped = false, pending;
+  const tick = () => {
+    if (stopped || pending) return;
+    pending = Promise.resolve().then(() => stopped ? void 0 : options.service.scan()).then(() => stopped ? void 0 : _optionalChain([options, 'access', _37 => _37.onSuccess, 'optionalCall', _38 => _38()])).catch(async (error) => {
+      if (stopped) return;
+      try {
+        await options.onError(error);
+      } catch (e3) {
+      }
+    }).finally(() => {
+      pending = void 0;
+    });
+  };
+  const unsubscribe = options.subscribeTick(tick), unwatch = _optionalChain([options, 'access', _39 => _39.subscribeChanges, 'optionalCall', _40 => _40(tick)]);
+  if (options.initialScan !== false) tick();
+  return { async dispose() {
+    if (stopped) {
+      await pending;
+      return;
+    }
+    stopped = true;
+    try {
+      unsubscribe();
+      _optionalChain([unwatch, 'optionalCall', _41 => _41()]);
+    } finally {
+      await pending;
+    }
+  } };
+}
+
+// src/work-messages.ts
+var _vfscore = require('@nestos/vfs-core');
+async function consumeWorkMessages(fs, directory, scope, journal, deliver, decode, publishReply) {
+  const publications = await readPublications(fs, directory, scope, decode), indexKey = "workspace-message-index:" + scope.attemptId;
+  const known = await _asyncNullishCoalesce(await journal.get(indexKey), async () => ( []));
+  if (known.some((id) => !publications.some((p) => p.message.id === id))) throw protocolError("WORK_MESSAGE_MISSING", "Published workspace message is missing", "ECONFLICT");
+  unresolvedWorkIssues(publications.map((p) => p.message));
+  publications.sort((a, b) => Number(a.message.type === "resolved") - Number(b.message.type === "resolved"));
+  for (const { message, bytes } of publications) {
+    const digest = _chunkRSH6QSECcjs.sha256HexSync.call(void 0, bytes);
+    const delivered = await deliverPublication(journal, indexKey, message, digest, deliver);
+    if (delivered) await publishReply(directory + "/outbox", "ack-" + message.id + ".yaml", JSON.stringify({ schema: "work-reply/1", ...scope, id: "ack-" + message.id, type: "accepted", replyTo: message.id, content: "Accepted", digest }));
+  }
+  return publications.map((p) => p.message);
+}
+async function readPublications(fs, directory, scope, decode) {
+  const files = await fs.driver.getChildren(directory + "/inbox", { fields: "entry" }), publications = [];
+  if (files.length > 200) throw protocolError("WORK_MESSAGE_COUNT_LIMIT", "Workspace inbox exceeds 200 entries");
+  for (const file of files.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (file.type !== "file" || !/^[a-zA-Z0-9_-]{1,128}\.(yaml|yml|json)$/.test(file.name)) continue;
+    const bytes = await readMessageBytes(fs, directory + "/inbox/" + file.name);
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes), envelope = decode(text);
+    if (_optionalChain([envelope, 'optionalAccess', _42 => _42.schema]) === "work-message/2" && Object.hasOwn(envelope, "scopeId")) continue;
+    const message = parseWorkMessage(text, scope, decode);
+    if (file.name.slice(0, file.name.lastIndexOf(".")) !== message.id) throw protocolError("WORK_MESSAGE_FILENAME_MISMATCH", "Workspace message filename does not match its identity");
+    publications.push({ message, bytes });
+  }
+  return publications;
+}
+async function deliverPublication(journal, indexKey, message, digest, deliver) {
+  const key = "workspace-message:" + message.attemptId + ":" + message.id;
+  const receipt = await journal.update(key, (old) => {
+    if (old && old.digest !== digest) throw protocolError("WORK_MESSAGE_CHANGED", "Published workspace message changed", "ECONFLICT");
+    return _nullishCoalesce(old, () => ( { digest, message, delivered: false }));
+  });
+  await journal.update(indexKey, (old) => _optionalChain([old, 'optionalAccess', _43 => _43.includes, 'call', _44 => _44(message.id)]) ? old : [..._nullishCoalesce(old, () => ( [])), message.id]);
+  if (receipt.delivered) return true;
+  const outcome = await deliver(receipt.message);
+  if (_optionalChain([outcome, 'optionalAccess', _45 => _45.pending])) return false;
+  await journal.update(key, (old) => ({ ...old, delivered: true }));
+  return true;
+}
+function parseWorkMessage(text, scope, decode) {
+  let value;
+  try {
+    value = decode(text);
+  } catch (e4) {
+    throw protocolError("WORK_MESSAGE_YAML_INVALID", "Workspace message is not valid bounded YAML");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw protocolError("WORK_MESSAGE_SCHEMA_INVALID", "Workspace message schema is invalid");
+  if ("body" in value) {
+    if (Object.hasOwn(value, "content")) throw protocolError("WORK_MESSAGE_FIELDS_INVALID", "Workspace message must not contain both body and content");
+    value = { ...value, content: value.body };
+  }
+  if (Object.keys(value).some((key) => !["schema", "runId", "itemId", "attemptId", "id", "type", "content", "body", "replyTo"].includes(key)))
+    throw protocolError("WORK_MESSAGE_FIELDS_INVALID", "Workspace message contains undeclared fields");
+  validateEnvelope(value, scope);
+  return value;
+}
+function validateEnvelope(value, scope) {
+  if (!["work-message/1", "work-message/2"].includes(value.schema)) throw protocolError("WORK_MESSAGE_SCHEMA_INVALID", "Workspace message schema is unsupported");
+  if (!["progress", "clarification", "error", "result", ...value.schema === "work-message/2" ? ["resolved"] : []].includes(value.type))
+    throw protocolError("WORK_MESSAGE_TYPE_INVALID", "Workspace message schema does not permit this type");
+  if (!validId(value.id)) throw protocolError("WORK_MESSAGE_ID_INVALID", "Workspace message identity is invalid");
+  if (["runId", "itemId", "attemptId"].some((key) => value[key] !== scope[key]))
+    throw protocolError("WORK_MESSAGE_SCOPE_MISMATCH", "Workspace message execution scope is invalid");
+  if (typeof value.content !== "string" || !value.content.trim() || value.content.length > 8e3) throw protocolError("WORK_MESSAGE_CONTENT_INVALID", "Workspace message content is invalid");
+  if (value.replyTo !== void 0 && !validId(value.replyTo) || value.type === "resolved" && !value.replyTo)
+    throw protocolError("WORK_MESSAGE_REPLY_INVALID", "Workspace message reply target is invalid");
+}
+function validId(value) {
+  return typeof value === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(value);
+}
+function protocolError(reasonCode, message, code = "EINVAL") {
+  return Object.assign(new (0, _vfscore.FSError)(code, message), { reasonCode });
+}
+async function readMessageBytes(fs, path) {
+  const before = await fs.driver.getNode(path);
+  if (_optionalChain([before, 'optionalAccess', _46 => _46.type]) !== "file" || !Number.isSafeInteger(before.size) || before.size < 1) throw protocolError("WORK_MESSAGE_FILE_INVALID", "Workspace message is not a nonempty regular file");
+  if (before.size > 65536) throw protocolError("WORK_MESSAGE_SIZE_LIMIT", "Workspace message exceeds 64 KiB");
+  const bytes = await fs.driver.readContent(path, { encoding: "binary", length: before.size });
+  const after = await fs.driver.getNode(path);
+  if (bytes.byteLength !== before.size || _optionalChain([after, 'optionalAccess', _47 => _47.type]) !== "file" || after.size !== before.size || after.revision !== before.revision || after.modifiedAt !== before.modifiedAt)
+    throw protocolError("WORK_MESSAGE_READ_CONFLICT", "Workspace message changed while reading", "ECONFLICT");
+  return bytes;
+}
+function unresolvedWorkIssues(messages) {
+  const issues = messages.filter((m) => m.type === "clarification" || m.type === "error");
+  for (const resolution of messages.filter((m) => m.type === "resolved")) {
+    if (!issues.some((issue) => issue.id === resolution.replyTo)) throw Object.assign(new Error("Resolution target is not an issue in this attempt"), { code: "WORKSPACE_RESOLUTION_INVALID" });
+  }
+  return issues.filter((issue) => !messages.some((m) => m.type === "resolved" && m.replyTo === issue.id));
+}
+
+
+
+
+
+
+
+exports.createKanbanExecutionBridge = createKanbanExecutionBridge; exports.startKanbanMonitor = startKanbanMonitor; exports.consumeWorkMessages = consumeWorkMessages; exports.parseWorkMessage = parseWorkMessage; exports.unresolvedWorkIssues = unresolvedWorkIssues;
+//# sourceMappingURL=chunk-XBSGUVCY.cjs.map