stitchkit 0.94.0 → 0.94.1

package/dist/entrypoints/application/diagnostic-journal.js

@@ -1,3 +1,6 @@
+import {
+  attemptExclusiveLock
+} from "../../index-8p52kd5p.js";
 import {
   DiagnosticJournalCloseResultSchema,
   DiagnosticJournalFrameSchema,
@@ -22,168 +25,25 @@ import { randomUUID } from "node:crypto";
 import { z } from "zod";
 
 // src/application/diagnostic-journal-storage.ts
-import { constants as constants2 } from "node:fs";
-import { lstat, open as open2, readdir, realpath, rename, unlink as unlink2 } from "node:fs/promises";
+import { constants } from "node:fs";
+import { lstat, open, readdir, realpath, rename, unlink } from "node:fs/promises";
 import { basename, dirname, isAbsolute, resolve } from "node:path";
 
 // src/application/diagnostic-journal-lock.ts
-import { execFile } from "node:child_process";
-import { constants } from "node:fs";
-import { open, readFile, unlink } from "node:fs/promises";
-import { hostname, platform } from "node:os";
-import { promisify } from "node:util";
-function isExisting(error) {
-  return isRecord(error) && error.code === "EEXIST";
-}
-function readOwner(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return;
-  }
-  if (!isRecord(parsed))
-    return;
-  const { pid, host, acquiredAt, machine } = parsed;
-  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
-    return;
-  if (typeof host !== "string" || host.length === 0)
-    return;
-  if (typeof acquiredAt !== "string")
-    return;
-  const identified = typeof machine === "string" && machine.length > 0 ? { machine } : {};
-  return { pid, host, acquiredAt, ...identified };
-}
-var detectedIdentity;
-async function firstReadableLine(paths) {
-  for (const path of paths) {
-    try {
-      const text = (await readFile(path, "utf8")).trim();
-      if (text.length > 0)
-        return text;
-    } catch {}
-  }
-  return null;
-}
-var run = promisify(execFile);
-function parsePlatformUuid(dump) {
-  return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(dump)?.[1] ?? null;
-}
-async function readDarwinPlatformUuid(command = "ioreg") {
-  try {
-    const { stdout } = await run(command, ["-rd1", "-c", "IOPlatformExpertDevice"], {
-      timeout: 2000,
-      maxBuffer: 1 << 20,
-      encoding: "utf8"
-    });
-    return parsePlatformUuid(stdout);
-  } catch {
-    return null;
-  }
-}
-async function machineIdentity(declared) {
-  if (declared !== undefined)
-    return declared;
-  if (detectedIdentity !== undefined)
-    return detectedIdentity;
-  detectedIdentity = platform() === "darwin" ? await readDarwinPlatformUuid() : await firstReadableLine(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
-  return detectedIdentity;
-}
-function attribute(owner, identity) {
-  if (identity !== null && owner.machine !== undefined) {
-    return owner.machine === identity ? "this-machine" : "another-machine";
-  }
-  return owner.host === hostname() ? "this-machine" : "unattributable";
-}
-async function probeLiveness(owner) {
-  try {
-    process.kill(owner.pid, 0);
-  } catch (error) {
-    return isRecord(error) && error.code === "ESRCH" ? "gone" : "alive";
-  }
-  return await isZombieProcess(owner.pid) ? "gone" : "alive";
-}
-async function isZombieProcess(pid, seam = {}) {
-  const { procRoot = "/proc", psCommand = "ps" } = seam;
-  try {
-    const stat = await readFile(`${procRoot}/${pid}/stat`, "utf8");
-    return stat.slice(stat.lastIndexOf(")") + 1).trimStart().startsWith("Z");
-  } catch {}
-  try {
-    const { stdout } = await run(psCommand, ["-o", "state=", "-p", String(pid)], {
-      timeout: 2000,
-      maxBuffer: 1 << 16,
-      encoding: "utf8"
-    });
-    return stdout.trim().startsWith("Z");
-  } catch {
-    return false;
-  }
-}
-async function diagnose(owner, declaredIdentity) {
-  if (!owner)
-    return { attribution: "unattributable", liveness: "not-probed", owner: null };
-  const attribution = attribute(owner, await machineIdentity(declaredIdentity));
-  const record = {
-    pid: owner.pid,
-    host: owner.host,
-    acquiredAt: owner.acquiredAt,
-    ...owner.machine !== undefined && { machine: owner.machine }
-  };
-  if (attribution !== "this-machine")
-    return { attribution, liveness: "not-probed", owner: record };
-  return { attribution, liveness: await probeLiveness(owner), owner: record };
-}
-async function readLockOwner(lockPath) {
-  let handle;
-  try {
-    handle = await open(lockPath, constants.O_RDONLY | constants.O_NOFOLLOW);
-    return readOwner(await handle.readFile("utf8"));
-  } catch {
-    return;
-  } finally {
-    await handle?.close().catch(() => {
-      return;
-    });
-  }
-}
-async function createExclusive(lockPath, mode, declaredIdentity) {
-  const handle = await open(lockPath, "wx", mode);
-  const identity = await machineIdentity(declaredIdentity);
-  const owner = {
-    pid: process.pid,
-    host: hostname(),
-    acquiredAt: new Date().toISOString(),
-    ...identity !== null && { machine: identity }
-  };
-  await handle.writeFile(`${JSON.stringify(owner)}
-`, "utf8");
-  return handle;
-}
 async function acquireDiagnosticJournalLock(lockPath, mode, policy, declaredIdentity) {
-  try {
-    return {
-      handle: await createExclusive(lockPath, mode, declaredIdentity),
-      reclaimedStale: false
-    };
-  } catch (error) {
-    if (policy !== "reclaim-stale" || !isExisting(error))
-      throw error;
-    const owner = await readLockOwner(lockPath);
-    const diagnosis = await diagnose(owner, declaredIdentity);
-    if (!owner || diagnosis.liveness !== "gone") {
-      if (isRecord(error))
-        Object.assign(error, { journalLock: diagnosis });
-      throw error;
-    }
-    await unlink(lockPath).catch(() => {
-      return;
-    });
-    return {
-      handle: await createExclusive(lockPath, mode, declaredIdentity),
-      reclaimedStale: true
-    };
+  const attempt = await attemptExclusiveLock(lockPath, {
+    mode,
+    reclaim: policy === "reclaim-stale",
+    ...declaredIdentity !== undefined && { machineIdentity: declaredIdentity }
+  });
+  if ("held" in attempt) {
+    return { lock: attempt.held, reclaimedStale: attempt.held.reclaimed };
+  }
+  const { error, diagnosis } = attempt;
+  if (diagnosis && error !== null && typeof error === "object") {
+    Object.assign(error, { journalLock: diagnosis });
   }
+  throw error;
 }
 
 // src/application/diagnostic-journal-storage.ts
@@ -204,7 +64,7 @@ async function removeIfPresent(path) {
     if (info.isSymbolicLink() || !info.isFile()) {
       throw new Error("Diagnostic journal generations must be regular files");
     }
-    await unlink2(path);
+    await unlink(path);
   } catch (error) {
     if (!isMissing(error))
       throw error;
@@ -243,7 +103,7 @@ async function createRotatingDiagnosticJournalStorage(config) {
   const parent = await realpath(dirname(config.path));
   const journalPath = resolve(parent, basename(config.path));
   const lockPath = `${journalPath}.lock`;
-  const { handle: lock, reclaimedStale } = await acquireDiagnosticJournalLock(lockPath, config.mode, config.lock, config.machineIdentity);
+  const { lock, reclaimedStale } = await acquireDiagnosticJournalLock(lockPath, config.mode, config.lock, config.machineIdentity);
   let handle;
   let currentFileBytes = 0;
   let retainedFiles = 1;
@@ -251,7 +111,7 @@ async function createRotatingDiagnosticJournalStorage(config) {
   let partialTails = 0;
   let closed = false;
   const openCurrent = async () => {
-    handle = await open2(journalPath, constants2.O_APPEND | constants2.O_CREAT | constants2.O_RDWR | constants2.O_NOFOLLOW, config.mode);
+    handle = await open(journalPath, constants.O_APPEND | constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, config.mode);
     const info = await handle.stat();
     if (!info.isFile()) {
       await handle.close();
@@ -312,10 +172,7 @@ async function createRotatingDiagnosticJournalStorage(config) {
     await handle?.close().catch(() => {
       return;
     });
-    await lock.close().catch(() => {
-      return;
-    });
-    await unlink2(lockPath).catch(() => {
+    await lock.release().catch(() => {
       return;
     });
     throw error;
@@ -359,8 +216,7 @@ async function createRotatingDiagnosticJournalStorage(config) {
         failure = error;
       }
       try {
-        await lock.close();
-        await unlink2(lockPath);
+        await lock.release();
       } catch (error) {
         failure ??= error;
       }
@@ -382,6 +238,45 @@ function waitBudget(options) {
   }
   return options.timeoutMs;
 }
+var NO_REFUSALS = {
+  closed: 0,
+  failed: 0,
+  invalid: 0,
+  oversized: 0,
+  "item-capacity": 0,
+  "byte-capacity": 0
+};
+function waitForProgress(progressWaiters, predicate, options) {
+  const timeoutMs = waitBudget(options);
+  if (predicate())
+    return Promise.resolve("settled");
+  if (options.signal?.aborted)
+    return Promise.resolve("cancelled");
+  return new Promise((resolve2) => {
+    let settled = false;
+    let timer;
+    const finish = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      progressWaiters.delete(onProgress);
+      options.signal?.removeEventListener("abort", onAbort);
+      if (timer)
+        clearTimeout(timer);
+      resolve2(outcome);
+    };
+    const onProgress = () => {
+      if (predicate())
+        finish("settled");
+    };
+    const onAbort = () => finish("cancelled");
+    progressWaiters.add(onProgress);
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (timeoutMs !== undefined)
+      timer = setTimeout(() => finish("timed-out"), timeoutMs);
+    onProgress();
+  });
+}
 function createDiagnosticJournalManager(config, storage) {
   const limits = DiagnosticJournalLimitsSchema.parse(config.limits);
   const encoder = new TextEncoder;
@@ -392,12 +287,7 @@ function createDiagnosticJournalManager(config, storage) {
     sizeOf: (frame) => frame.bytes.byteLength
   });
   const refusals = {
-    closed: 0,
-    failed: 0,
-    invalid: 0,
-    oversized: 0,
-    "item-capacity": 0,
-    "byte-capacity": 0
+    ...NO_REFUSALS
   };
   const progressWaiters = new Set;
   let state = "open";
@@ -477,37 +367,7 @@ function createDiagnosticJournalManager(config, storage) {
     refusals[reason] += 1;
     return DiagnosticJournalSubmitResultSchema.parse({ outcome: "refused", reason });
   };
-  const waitUntil = (predicate, options) => {
-    const timeoutMs = waitBudget(options);
-    if (predicate())
-      return Promise.resolve("settled");
-    if (options.signal?.aborted)
-      return Promise.resolve("cancelled");
-    return new Promise((resolve2) => {
-      let settled = false;
-      let timer;
-      const finish = (outcome) => {
-        if (settled)
-          return;
-        settled = true;
-        progressWaiters.delete(onProgress);
-        options.signal?.removeEventListener("abort", onAbort);
-        if (timer)
-          clearTimeout(timer);
-        resolve2(outcome);
-      };
-      const onProgress = () => {
-        if (predicate())
-          finish("settled");
-      };
-      const onAbort = () => finish("cancelled");
-      progressWaiters.add(onProgress);
-      options.signal?.addEventListener("abort", onAbort, { once: true });
-      if (timeoutMs !== undefined)
-        timer = setTimeout(() => finish("timed-out"), timeoutMs);
-      onProgress();
-    });
-  };
+  const waitUntil = (predicate, options) => waitForProgress(progressWaiters, predicate, options);
   const getStatus = () => {
     const file = storage.snapshot();
     return DiagnosticJournalStatusSchema.parse({

package/dist/entrypoints/application/opentelemetry.js

@@ -1,7 +1,7 @@
 import {
   ActivitySnapshotSchema,
   ManagedScheduleStatusSchema
-} from "../../index-sees8yf8.js";
+} from "../../index-ensd0r74.js";
 import {
   ApplicationSnapshotSchema
 } from "../../index-3gye9wzb.js";