@fenglimg/fabric-shared 2.0.0 → 2.0.1

package/dist/node/atomic-write.d.ts

@@ -8,6 +8,22 @@ declare function atomicWriteText(path: string, content: string, opts?: AtomicWri
 declare function atomicWriteJson(path: string, value: unknown, opts?: AtomicWriteJsonOptions): Promise<void>;
 interface LedgerWriteQueue {
     append(path: string, line: string): Promise<void>;
+    /**
+     * Run `fn` with exclusive access to `path` against all other queue operations
+     * (other `runExclusive` calls and `append` calls) on the same path within
+     * this LedgerWriteQueue instance.
+     *
+     * Scope: per-path, in-process (same Node process, same queue instance).
+     * Does NOT provide cross-process locking — separate concern.
+     *
+     * Error semantics: a rejection from `fn` is propagated to the returned
+     * Promise but does NOT poison the chain — subsequent `runExclusive` /
+     * `append` calls on the same path will still acquire and run.
+     *
+     * Ordering: submission-order FIFO. Calls on different paths run independently
+     * (in parallel where possible).
+     */
+    runExclusive<T>(path: string, fn: () => Promise<T>): Promise<T>;
 }
 declare function createLedgerWriteQueue(): LedgerWriteQueue;
 

package/dist/node/atomic-write.js

@@ -38,18 +38,27 @@ function createLedgerWriteQueue() {
     const normalized = line.endsWith("\n") ? line : line + "\n";
     await appendFile(path, normalized, "utf8");
   }
+  function enqueue(path, work) {
+    const prev = chains.get(path) ?? Promise.resolve();
+    const result = prev.catch(() => void 0).then(() => work());
+    const chainSlot = result.then(
+      () => void 0,
+      () => void 0
+    );
+    chains.set(path, chainSlot);
+    chainSlot.finally(() => {
+      if (chains.get(path) === chainSlot) {
+        chains.delete(path);
+      }
+    });
+    return result;
+  }
   return {
     append(path, line) {
-      const prev = chains.get(path) ?? Promise.resolve();
-      const next = prev.catch(() => void 0).then(() => doAppend(path, line));
-      chains.set(path, next);
-      const guarded = next.catch(() => void 0);
-      guarded.finally(() => {
-        if (chains.get(path) === next) {
-          chains.delete(path);
-        }
-      });
-      return next;
+      return enqueue(path, () => doAppend(path, line));
+    },
+    runExclusive(path, fn) {
+      return enqueue(path, fn);
     }
   };
 }

package/dist/node/mcp-payload-guard.d.ts

@@ -11,6 +11,8 @@ interface PayloadGuardResult {
         threshold: number;
     };
 }
+declare const PAYLOAD_LIMIT_DEFAULT_WARN_BYTES = 16384;
+declare const PAYLOAD_LIMIT_DEFAULT_HARD_BYTES = 65536;
 declare function enforcePayloadLimit(serializedPayload: string, opts?: PayloadGuardOptions): PayloadGuardResult;
 
-export { type PayloadGuardOptions, type PayloadGuardResult, enforcePayloadLimit };
+export { PAYLOAD_LIMIT_DEFAULT_HARD_BYTES, PAYLOAD_LIMIT_DEFAULT_WARN_BYTES, type PayloadGuardOptions, type PayloadGuardResult, enforcePayloadLimit };

package/dist/node/mcp-payload-guard.js

@@ -7,8 +7,10 @@ var McpPayloadTooLargeError = class extends MCPError {
   code = "MCP_PAYLOAD_TOO_LARGE";
   httpStatus = 413;
 };
-var DEFAULT_WARN = 16384;
-var DEFAULT_HARD = 65536;
+var PAYLOAD_LIMIT_DEFAULT_WARN_BYTES = 16384;
+var PAYLOAD_LIMIT_DEFAULT_HARD_BYTES = 65536;
+var DEFAULT_WARN = PAYLOAD_LIMIT_DEFAULT_WARN_BYTES;
+var DEFAULT_HARD = PAYLOAD_LIMIT_DEFAULT_HARD_BYTES;
 function enforcePayloadLimit(serializedPayload, opts) {
   const warnAt = opts?.warnBytes ?? DEFAULT_WARN;
   const hardAt = opts?.hardBytes ?? DEFAULT_HARD;
@@ -36,5 +38,7 @@ function enforcePayloadLimit(serializedPayload, opts) {
   return { bytes };
 }
 export {
+  PAYLOAD_LIMIT_DEFAULT_HARD_BYTES,
+  PAYLOAD_LIMIT_DEFAULT_WARN_BYTES,
   enforcePayloadLimit
 };