@fenglimg/fabric-shared 2.1.0-rc.2 → 2.2.0-rc.10

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

@@ -6,6 +6,31 @@ interface AtomicWriteJsonOptions extends AtomicWriteOptions {
 }
 declare function atomicWriteText(path: string, content: string, opts?: AtomicWriteOptions): Promise<void>;
 declare function atomicWriteJson(path: string, value: unknown, opts?: AtomicWriteJsonOptions): Promise<void>;
+interface FileLockOptions {
+    /** A held lock older than this (ms, by lock-file mtime) is presumed stale —
+     * left by a crashed holder — and reclaimed. Default 10s. */
+    staleMs?: number;
+    /** Poll interval (ms) between acquire attempts while contended. Default 20ms. */
+    retryDelayMs?: number;
+    /** Give up acquiring after this long (ms) and throw. Default 10s. */
+    maxWaitMs?: number;
+}
+/**
+ * Run `fn` while holding a cross-process advisory lock at `lockPath`.
+ *
+ * Unlike the hook-side `appendLockedLine` (which DROPS on contention, fine for
+ * best-effort telemetry), this WAITS for the lock — the critical section it
+ * guards (e.g. a read-modify-write of a shared counter file) must not be
+ * skipped. The lock is a `wx` (O_CREAT|O_EXCL) lock file, so acquisition is
+ * atomic across processes; a crashed holder leaves the file behind, so any
+ * holder older than `staleMs` is reclaimed. The lock is always released in a
+ * `finally`, even if `fn` throws.
+ *
+ * Scope: cross-process AND in-process. Two concurrent callers on the same
+ * `lockPath` (same process or not) serialize, because both race the same
+ * O_EXCL create.
+ */
+declare function withFileLock<T>(lockPath: string, fn: () => Promise<T>, opts?: FileLockOptions): Promise<T>;
 interface LedgerWriteQueue {
     append(path: string, line: string): Promise<void>;
     /**
@@ -27,4 +52,4 @@ interface LedgerWriteQueue {
 }
 declare function createLedgerWriteQueue(): LedgerWriteQueue;
 
-export { type AtomicWriteJsonOptions, type AtomicWriteOptions, type LedgerWriteQueue, atomicWriteJson, atomicWriteText, createLedgerWriteQueue };
+export { type AtomicWriteJsonOptions, type AtomicWriteOptions, type FileLockOptions, type LedgerWriteQueue, atomicWriteJson, atomicWriteText, createLedgerWriteQueue, withFileLock };

package/dist/node/atomic-write.js

@@ -1,69 +1,12 @@
-// src/node/atomic-write.ts
-import { appendFile, open, rename, unlink, writeFile } from "fs/promises";
-function makeTmpSuffix() {
-  const rand = Math.floor(Math.random() * 65535).toString(16).padStart(4, "0");
-  return `.${process.pid}.${Date.now()}.${rand}.tmp`;
-}
-async function atomicWriteText(path, content, opts) {
-  const tmpPath = path + makeTmpSuffix();
-  try {
-    if (opts?.fsync) {
-      const fd = await open(tmpPath, "w");
-      try {
-        await fd.writeFile(content, "utf8");
-        await fd.datasync();
-      } finally {
-        await fd.close();
-      }
-    } else {
-      await writeFile(tmpPath, content, "utf8");
-    }
-    await rename(tmpPath, path);
-  } catch (err) {
-    try {
-      await unlink(tmpPath);
-    } catch {
-    }
-    throw err;
-  }
-}
-async function atomicWriteJson(path, value, opts) {
-  const indent = opts?.indent ?? 2;
-  const content = JSON.stringify(value, null, indent) + "\n";
-  await atomicWriteText(path, content, { fsync: opts?.fsync });
-}
-function createLedgerWriteQueue() {
-  const chains = /* @__PURE__ */ new Map();
-  async function doAppend(path, line) {
-    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) {
-      return enqueue(path, () => doAppend(path, line));
-    },
-    runExclusive(path, fn) {
-      return enqueue(path, fn);
-    }
-  };
-}
+import {
+  atomicWriteJson,
+  atomicWriteText,
+  createLedgerWriteQueue,
+  withFileLock
+} from "../chunk-C7WZPYZE.js";
 export {
   atomicWriteJson,
   atomicWriteText,
-  createLedgerWriteQueue
+  createLedgerWriteQueue,
+  withFileLock
 };

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

@@ -14,5 +14,36 @@ interface PayloadGuardResult {
 declare const PAYLOAD_LIMIT_DEFAULT_WARN_BYTES = 16384;
 declare const PAYLOAD_LIMIT_DEFAULT_HARD_BYTES = 65536;
 declare function enforcePayloadLimit(serializedPayload: string, opts?: PayloadGuardOptions): PayloadGuardResult;
+interface PayloadBudgetTrimResult<T> {
+    /** The retained head of `items` (the ranked tail was dropped to fit). */
+    items: T[];
+    /** How many trailing items were dropped to fit the hard budget. */
+    dropped: number;
+    /** Serialized byte size of the envelope built from the retained items. */
+    bytes: number;
+    /**
+     * True when even `minKeep` items still overflow the hard budget — the caller
+     * must surface this (a single oversized entry) rather than assume it fit.
+     */
+    overBudget: boolean;
+}
+/**
+ * v2.2 MC4-payload-budget (W1-T4): the byte-budget tail of the unified
+ * truncation chain (CJK → BM25 → top_k → payload). Rather than hard-throwing
+ * when a response overflows the hard limit, callers trim the LEAST-relevant
+ * items off the tail of an already-ranked list until the serialized envelope
+ * fits — turning a 413 crash into graceful degradation.
+ *
+ * `serialize` builds the FULL response envelope from a candidate slice (so the
+ * byte count includes warnings / metadata, not just the list). Trimming drops
+ * from the END, which is correct ONLY when the list is pre-ranked best-first
+ * (plan_context sorts by BM25 before calling this). `minKeep` (default 1)
+ * guarantees a non-empty result even under a pathological oversized head; in
+ * that case `overBudget` is returned true so the caller can warn instead of
+ * silently shipping an over-limit payload.
+ */
+declare function trimToPayloadBudget<T>(items: T[], serialize: (items: T[]) => string, opts?: PayloadGuardOptions & {
+    minKeep?: number;
+}): PayloadBudgetTrimResult<T>;
 
-export { PAYLOAD_LIMIT_DEFAULT_HARD_BYTES, PAYLOAD_LIMIT_DEFAULT_WARN_BYTES, type PayloadGuardOptions, type PayloadGuardResult, enforcePayloadLimit };
+export { PAYLOAD_LIMIT_DEFAULT_HARD_BYTES, PAYLOAD_LIMIT_DEFAULT_WARN_BYTES, type PayloadBudgetTrimResult, type PayloadGuardOptions, type PayloadGuardResult, enforcePayloadLimit, trimToPayloadBudget };

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

@@ -1,6 +1,6 @@
 import {
   MCPError
-} from "../chunk-3SZRB42B.js";
+} from "../chunk-O6GIHZF3.js";
 
 // src/node/mcp-payload-guard.ts
 var McpPayloadTooLargeError = class extends MCPError {
@@ -37,8 +37,22 @@ function enforcePayloadLimit(serializedPayload, opts) {
   }
   return { bytes };
 }
+function trimToPayloadBudget(items, serialize, opts) {
+  const hardAt = opts?.hardBytes ?? DEFAULT_HARD;
+  const minKeep = Math.max(0, opts?.minKeep ?? 1);
+  let kept = items;
+  let bytes = Buffer.byteLength(serialize(kept), "utf8");
+  let dropped = 0;
+  while (bytes > hardAt && kept.length > minKeep) {
+    kept = kept.slice(0, -1);
+    dropped += 1;
+    bytes = Buffer.byteLength(serialize(kept), "utf8");
+  }
+  return { items: kept, dropped, bytes, overBudget: bytes > hardAt };
+}
 export {
   PAYLOAD_LIMIT_DEFAULT_HARD_BYTES,
   PAYLOAD_LIMIT_DEFAULT_WARN_BYTES,
-  enforcePayloadLimit
+  enforcePayloadLimit,
+  trimToPayloadBudget
 };

package/dist/node.d.ts

@@ -11,4 +11,13 @@ type FrameworkInfo = {
 type TechProfile = FrameworkInfo;
 declare function detectFramework(root: string): FrameworkInfo;
 
-export { type FrameworkInfo, type TechProfile, detectFramework };
+interface ServeLockState {
+    pid: number;
+    acquiredAt: number;
+    host?: string;
+}
+declare function serveLockPath(projectRoot: string): string;
+declare function isAlive(pid: number): boolean;
+declare function readServeLockState(projectRoot: string): ServeLockState | null;
+
+export { type FrameworkInfo, type ServeLockState, type TechProfile, detectFramework, isAlive, readServeLockState, serveLockPath };

package/dist/node.js

@@ -170,6 +170,37 @@ function collectProjectFileEvidence(root, relativePaths) {
 function compactStrings(values) {
   return [...new Set(values.filter((value) => value !== null && value !== void 0 && value.length > 0))];
 }
+
+// src/node/serve-lock.ts
+import fs from "fs";
+import path from "path";
+var SERVE_LOCK_FILENAME = ".serve.lock";
+function serveLockPath(projectRoot) {
+  return path.join(projectRoot, ".fabric", SERVE_LOCK_FILENAME);
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    const err = e;
+    if (err.code === "ESRCH") return false;
+    if (err.code === "EPERM") return true;
+    throw e;
+  }
+}
+function readServeLockState(projectRoot) {
+  const p = serveLockPath(projectRoot);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
 export {
-  detectFramework
+  detectFramework,
+  isAlive,
+  readServeLockState,
+  serveLockPath
 };