stitchkit 0.111.2 → 0.111.3

package/dist/{index-8jv0trhg.js → index-5as18gs2.js}

@@ -14,7 +14,7 @@ import {
 import {
   ToolExecutionControlError2,
   isToolExecutionControlError2
-} from "./index-mha6b4vk.js";
+} from "./index-02h0dfpr.js";
 import {
   agentDurableEventId2
 } from "./index-mnkk1ffz.js";

package/dist/{index-t2bsd0hm.js → index-5v5a9k2n.js}

@@ -18,11 +18,93 @@ import {
 
 // src/internal/exclusive-lock.ts
 import { randomUUID } from "node:crypto";
-import { lstat, open, readdir, unlink } from "node:fs/promises";
-import { hostname } from "node:os";
+import { lstat, open as open2, readdir as readdir2, unlink } from "node:fs/promises";
+import { hostname as hostname2 } from "node:os";
 import { dirname, join } from "node:path";
+
+// src/internal/exclusive-lock-owner.ts
+import { hostname } from "node:os";
 import { z } from "zod";
 
+// src/internal/open-descriptors.ts
+import { constants, fstatSync } from "node:fs";
+import { open, readdir } from "node:fs/promises";
+var DESCRIPTOR_DIRECTORY = "/dev/fd";
+async function holdsOpenDescriptor(path, file, descriptorDirectory = DESCRIPTOR_DIRECTORY) {
+  const probe = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK).catch(() => null);
+  if (!probe)
+    return null;
+  try {
+    const opened = await probe.stat();
+    if (!opened.isFile() || opened.ino !== file.ino || opened.dev !== file.dev)
+      return null;
+    let names;
+    try {
+      names = await readdir(descriptorDirectory);
+    } catch {
+      return null;
+    }
+    let listedProbe = false;
+    for (const name of names) {
+      const descriptor = Number(name);
+      if (!Number.isInteger(descriptor) || descriptor < 0)
+        continue;
+      if (descriptor === probe.fd) {
+        listedProbe = true;
+        continue;
+      }
+      try {
+        const info = fstatSync(descriptor);
+        if (info.ino === file.ino && info.dev === file.dev)
+          return true;
+      } catch {}
+    }
+    return listedProbe ? false : null;
+  } finally {
+    await probe.close();
+  }
+}
+
+// src/internal/exclusive-lock-owner.ts
+var ExclusiveLockOwnerSchema = z.object({
+  pid: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  host: z.string().min(1),
+  acquiredAt: z.string(),
+  machine: z.string().min(1).optional().catch(undefined),
+  process: ProcessInstanceSchema2.nullable().optional().catch(null)
+});
+function readOwner(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { owner: undefined, ownerless: true };
+  }
+  const owner = ExclusiveLockOwnerSchema.safeParse(parsed);
+  if (owner.success)
+    return { owner: owner.data, ownerless: false };
+  const ownerlike = isRecord(parsed) && ["pid", "token", "host", "machine", "process", "acquiredAt"].some((key) => Object.hasOwn(parsed, key));
+  return { owner: undefined, ownerless: !ownerlike };
+}
+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 diagnose(lock, declaredIdentity) {
+  const owner = lock?.owner;
+  if (!lock || !owner)
+    return { attribution: "unattributable", liveness: "not-probed", owner: null };
+  const attribution = attribute(owner, await machineIdentity(declaredIdentity));
+  if (attribution !== "this-machine")
+    return { attribution, liveness: "not-probed", owner };
+  const evidence = await probeProcessOwner2(owner.pid, owner.process);
+  if (evidence.identity === "matched" && owner.pid === process.pid && await holdsOpenDescriptor(lock.path, lock) === false)
+    return { attribution, liveness: "gone", identity: "descriptor-closed", owner };
+  return { attribution, ...evidence, owner };
+}
+
 // src/internal/exclusive-lock-read.ts
 var OWNER_RECORD_BYTES = 16 * 1024;
 
@@ -60,49 +142,15 @@ async function readLockRecord(path, {
 }
 
 // src/internal/exclusive-lock.ts
-var ExclusiveLockOwnerSchema = z.object({
-  pid: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  host: z.string().min(1),
-  acquiredAt: z.string(),
-  machine: z.string().min(1).optional().catch(undefined),
-  process: ProcessInstanceSchema2.nullable().optional().catch(null)
-});
 function isCode(error, code) {
   return isRecord(error) && error.code === code;
 }
-function readOwner(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return { owner: undefined, ownerless: true };
-  }
-  const owner = ExclusiveLockOwnerSchema.safeParse(parsed);
-  if (owner.success)
-    return { owner: owner.data, ownerless: false };
-  const ownerlike = isRecord(parsed) && ["pid", "token", "host", "machine", "process", "acquiredAt"].some((key) => Object.hasOwn(parsed, key));
-  return { owner: undefined, ownerless: !ownerlike };
-}
-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 diagnose(owner, declaredIdentity) {
-  if (!owner)
-    return { attribution: "unattributable", liveness: "not-probed", owner: null };
-  const attribution = attribute(owner, await machineIdentity(declaredIdentity));
-  if (attribution !== "this-machine")
-    return { attribution, liveness: "not-probed", owner };
-  return { attribution, ...await probeProcessOwner2(owner.pid, owner.process), owner };
-}
 var MAX_RECLAIM_DEPTH = 16;
 var STALE_GUARD_GRACE_MS = 5000;
 var STAGED_NAME = /^\.lock-[0-9a-f-]{36}\.tmp$/;
 async function stagedSibling(path, ino, dev) {
   const directory = dirname(path);
-  for (const name of await readdir(directory)) {
+  for (const name of await readdir2(directory)) {
     if (!STAGED_NAME.test(name))
       continue;
     const candidate = join(directory, name);
@@ -130,6 +178,7 @@ async function readLockFile(path, onFailure, signal) {
       record = await readLockRecord(path, { signal, singleLink: false });
     }
     return {
+      path,
       ...readOwner(record.text),
       ino: record.info.ino,
       dev: record.info.dev,
@@ -143,14 +192,14 @@ async function readLockFile(path, onFailure, signal) {
   }
 }
 async function sweepStagedLocks(directory, machine, signal) {
-  for (const name of await readdir(directory).catch(() => [])) {
+  for (const name of await readdir2(directory).catch(() => [])) {
     if (!STAGED_NAME.test(name))
       continue;
     const candidate = join(directory, name);
     const state = await readLockFile(candidate, undefined, signal);
     if (!state?.owner)
       continue;
-    if ((await diagnose(state.owner, machine)).liveness !== "gone")
+    if ((await diagnose(state, machine)).liveness !== "gone")
       continue;
     await unlinkIfSame(candidate, state.ino, state.dev, state.stagedName === undefined ? 1 : 2);
   }
@@ -172,14 +221,14 @@ async function createOwned(path, options, reclaimed) {
   const owner = {
     pid: process.pid,
     process: instance,
-    host: hostname(),
+    host: hostname2(),
     acquiredAt: new Date().toISOString(),
     ...identity !== null && { machine: identity }
   };
   const ownedRecord = `${JSON.stringify(owner)}
 `;
   const staged = join(dirname(path), `.lock-${randomUUID()}.tmp`);
-  const handle = await open(staged, "wx", options.mode);
+  const handle = await open2(staged, "wx", options.mode);
   let ino;
   let dev;
   let published = false;
@@ -271,7 +320,7 @@ async function reclaimUnderGuard(path, options, depth) {
     if (readFailure !== undefined)
       return { refused: true, cause: readFailure };
     if (state) {
-      const diagnosis = await diagnose(state.owner, options.machineIdentity);
+      const diagnosis = await diagnose(state, options.machineIdentity);
       if (options.signal?.aborted)
         return { refused: true };
       if (!reclaimable(state, diagnosis, options.ownerlessGraceMs))
@@ -308,7 +357,7 @@ async function attemptExclusiveLock(path, options, depth = 0) {
       readFailure = cause;
     }, options.signal);
     const diagnosis = {
-      ...await diagnose(state?.owner, options.machineIdentity),
+      ...await diagnose(state, options.machineIdentity),
       ...readFailure !== undefined && { cause: readFailure }
     };
     if (options.signal?.aborted)

package/dist/{index-c5374vpt.js → index-651xsm48.js}

@@ -8,17 +8,17 @@ import {
   validateResolvedInputRounds,
   presentationMetadata,
   prepareProjectedMcpTools
-} from "./index-q6crhe1n.js";
+} from "./index-h7accrrv.js";
 import {
   parseToolCallArguments,
   toolResultFromError,
   observed
-} from "./index-mha6b4vk.js";
+} from "./index-02h0dfpr.js";
 import {
   collectTools2,
   createToolRunner,
   formatToolError
-} from "./index-ghwntn9n.js";
+} from "./index-vqdjym30.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS2,
   DEFAULT_PROCESS_SIGNALS,
@@ -31,7 +31,7 @@ import {
 } from "./index-e6c2spsd.js";
 import {
   collectToolSurface
-} from "./index-0d8m0kee.js";
+} from "./index-hvg9hctd.js";
 import {
   runWithRequestContext2,
   getRequestContext2

package/dist/{index-w9mqgnz9.js → index-6b3pcq5z.js}

@@ -1,6 +1,6 @@
 import {
   attemptExclusiveLock
-} from "./index-t2bsd0hm.js";
+} from "./index-5v5a9k2n.js";
 import {
   sleep
 } from "./index-eemvahkc.js";

package/dist/{index-7c046kxr.js → index-c7h371gr.js}

@@ -2,21 +2,21 @@ import {
   toolResultFromError,
   toolCauseFromResult,
   isToolExecutionControlError2
-} from "./index-mha6b4vk.js";
+} from "./index-02h0dfpr.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-ghwntn9n.js";
+} from "./index-vqdjym30.js";
 import {
   AgentToolError2,
   resolveToolDurability
 } from "./index-56yx8dxp.js";
 import {
   collectToolSurface
-} from "./index-0d8m0kee.js";
+} from "./index-hvg9hctd.js";
 import {
   agentPresenterOf
-} from "./index-636mggad.js";
+} from "./index-ff3agzaf.js";
 import {
   isRecord
 } from "./index-9jfdm5tg.js";

package/dist/{index-mnk5vgdr.js → index-d4cnhfdn.js}

@@ -17,7 +17,7 @@ import {
   replaceMessage,
   ArchiveSpillSchema,
   createAgentRuntimeStore2
-} from "./index-0z3kfphz.js";
+} from "./index-38gvr73z.js";
 
 // src/agent-runtime/store-memory.ts
 import { z as z2 } from "zod";

package/dist/{index-t5sjh517.js → index-epmnrnth.js}

@@ -82,6 +82,23 @@ function markJsonSchemaObjectGuards(schema) {
   };
   visit(schema);
 }
+var REMOTE_UNION_VERDICT = Symbol.for("stitchkit.tools.json-schema-remote-union-verdict.v1");
+function markRemoteUnionVerdict(schema) {
+  Reflect.defineProperty(schema, REMOTE_UNION_VERDICT, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+}
+function localVerdict(schema, error) {
+  if (Reflect.get(schema, REMOTE_UNION_VERDICT) !== true)
+    return error;
+  const local = error.issues.filter((issue) => issue.code !== "invalid_union");
+  if (local.length === 0)
+    return null;
+  return local.length === error.issues.length ? error : new z.ZodError(local);
+}
 function jsonSchemaObjectCoercionMembers(schema) {
   if (Reflect.get(schema, JSON_SCHEMA_OBJECT_GUARD) !== true)
     return;
@@ -97,4 +114,4 @@ function jsonSchemaObjectCoercionMembers(schema) {
   return;
 }
 
-export { markJsonSchemaObjectGuards, jsonSchemaObjectCoercionMembers };
+export { markJsonSchemaObjectGuards, markRemoteUnionVerdict, localVerdict, jsonSchemaObjectCoercionMembers };

package/dist/{index-636mggad.js → index-ff3agzaf.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-q6crhe1n.js";
+} from "./index-h7accrrv.js";
 import {
   isRecord
 } from "./index-9jfdm5tg.js";

package/dist/{index-7c957abz.js → index-fh2ht88b.js}

@@ -19,7 +19,7 @@ import {
   appendEventIn,
   ArchiveProjectionSchema,
   createAgentRuntimeStore2
-} from "./index-0z3kfphz.js";
+} from "./index-38gvr73z.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2

package/dist/{index-q6crhe1n.js → index-h7accrrv.js}

@@ -273,7 +273,8 @@ function typeNames(schema) {
 function typeSchema(type, nullable) {
   return { type: nullable ? [type, "null"] : type };
 }
-function commonBaseType(schemas) {
+function commonBaseType(variants, discriminator) {
+  const schemas = variants.map(({ schema }) => schema);
   const names = schemas.map(typeNames);
   if (names.some((value) => value === null))
     return {};
@@ -293,10 +294,19 @@ function commonBaseType(schemas) {
     return nullable ? { type: "null" } : {};
   if (bases.has("array") || bases.has("object")) {
     const alternatives = new Map;
-    for (const schema of schemas)
-      alternatives.set(serializeCanonicalJson(schema), schema);
-    const ordered = [...alternatives].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, schema]) => schema);
-    return { anyOf: structuredClone(ordered) };
+    for (const { schema, labels } of variants) {
+      const key = serializeCanonicalJson(schema);
+      const known = alternatives.get(key);
+      if (known)
+        known.labels.push(...labels);
+      else
+        alternatives.set(key, { schema, labels: [...labels] });
+    }
+    const ordered = [...alternatives].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, { schema, labels }]) => ({
+      ...structuredClone(schema),
+      description: `When ${discriminator} = ${[...new Set(labels)].join(" | ")}.`
+    }));
+    return { anyOf: ordered };
   }
   if (bases.size === 1) {
     const [only] = bases;
@@ -337,7 +347,10 @@ function mergePropertySchemas(properties, discriminator) {
   } else {
     const values = schemas.map(stringValues);
     const allStrings = values.every((value) => value !== null);
-    merged = allStrings ? { type: "string", enum: [...new Set(values.flatMap((value) => value ?? []))] } : commonBaseType(structural);
+    merged = allStrings ? { type: "string", enum: [...new Set(values.flatMap((value) => value ?? []))] } : commonBaseType(structural.map((schema, index) => ({
+      schema,
+      labels: properties[index]?.labels ?? []
+    })), discriminator);
   }
   const description = describeVariants(properties.map((property, index) => ({
     ...property,

package/dist/{index-0d8m0kee.js → index-hvg9hctd.js}

@@ -1,12 +1,12 @@
 import {
   projectToolSurface
-} from "./index-q6crhe1n.js";
+} from "./index-h7accrrv.js";
 import {
   contractToolMountable
-} from "./index-ghwntn9n.js";
+} from "./index-vqdjym30.js";
 import {
   runtimeToolMountable
-} from "./index-636mggad.js";
+} from "./index-ff3agzaf.js";
 
 // src/tools/surface.ts
 function collectToolSurface({

package/dist/{index-nx49x0tw.js → index-hy802jnr.js}

@@ -1,6 +1,6 @@
 import {
   withExclusiveLock2
-} from "./index-w9mqgnz9.js";
+} from "./index-6b3pcq5z.js";
 import {
   readBoundedFile
 } from "./index-m616f0yz.js";

package/dist/{index-dd1z5kxb.js → index-jfk93gja.js}

@@ -1,13 +1,13 @@
 import {
   assertUniqueToolName
-} from "./index-q6crhe1n.js";
+} from "./index-h7accrrv.js";
 import {
   toolErrorFromResult
-} from "./index-mha6b4vk.js";
+} from "./index-02h0dfpr.js";
 import {
   collectTools2,
   createToolRunner
-} from "./index-ghwntn9n.js";
+} from "./index-vqdjym30.js";
 import {
   AppError2
 } from "./index-j9gxbztg.js";

package/dist/{index-v2eyj2ws.js → index-jprxv2an.js}

@@ -3,10 +3,10 @@ import {
 } from "./index-fynr93w4.js";
 import {
   jsonSchemaObjectCoercionMembers
-} from "./index-t5sjh517.js";
+} from "./index-epmnrnth.js";
 import {
   coerceJsonArgs2
-} from "./index-cykxpxz5.js";
+} from "./index-jy9wq8tp.js";
 import {
   jsonSchemaFields
 } from "./index-ct75c3at.js";
@@ -14,15 +14,15 @@ import {
   objectShapeKeys,
   assertUniqueToolName,
   buildToolPresentationSchema
-} from "./index-q6crhe1n.js";
+} from "./index-h7accrrv.js";
 import {
   toolResultFromError,
   toolErrorFromResult
-} from "./index-mha6b4vk.js";
+} from "./index-02h0dfpr.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-ghwntn9n.js";
+} from "./index-vqdjym30.js";
 import {
   fetchGuarded,
   readCapped
@@ -35,7 +35,7 @@ import {
 } from "./index-eemvahkc.js";
 import {
   collectToolSurface
-} from "./index-0d8m0kee.js";
+} from "./index-hvg9hctd.js";
 import {
   isUnsafeKey,
   safeJsonParse

package/dist/{index-cykxpxz5.js → index-jy9wq8tp.js}

@@ -1,6 +1,6 @@
 import {
   jsonSchemaObjectCoercionMembers
-} from "./index-t5sjh517.js";
+} from "./index-epmnrnth.js";
 import {
   safeJsonParse
 } from "./index-zsarb5xp.js";

package/dist/{index-ey15wx6j.js → index-n0adphfg.js}

@@ -27,7 +27,7 @@ import {
 } from "./index-j4zh647a.js";
 import {
   defineRuntimeTool2
-} from "./index-636mggad.js";
+} from "./index-ff3agzaf.js";
 import {
   AppError2,
   forbidden2,

package/dist/{index-ghwntn9n.js → index-vqdjym30.js}

@@ -3,11 +3,11 @@ import {
   mergeSchemas,
   assertToolExtensionCompatible,
   projectToolSurface
-} from "./index-q6crhe1n.js";
+} from "./index-h7accrrv.js";
 import {
   toolErrorFromResult,
   executeToolMethod
-} from "./index-mha6b4vk.js";
+} from "./index-02h0dfpr.js";
 import {
   isRetryableStatus2
 } from "./index-j9gxbztg.js";

package/dist/internal/exclusive-lock-owner.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { type FileIdentity } from './open-descriptors.js';
+import { type ProcessOwnerEvidence } from './process-instance.js';
+/** Who holds a lock, as its file records it. */
+declare const ExclusiveLockOwnerSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    host: z.ZodString;
+    acquiredAt: z.ZodString;
+    machine: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    process: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        platform: z.ZodEnum<{
+            darwin: "darwin";
+            linux: "linux";
+        }>;
+        bootId: z.ZodString;
+        namespace: z.ZodString;
+        startId: z.ZodString;
+    }, z.core.$strict>>>>;
+}, z.core.$strip>;
+export type ExclusiveLockOwner = z.infer<typeof ExclusiveLockOwnerSchema>;
+/** Why a present lock was or was not taken. */
+export interface ExclusiveLockDiagnosis {
+    readonly attribution: 'this-machine' | 'another-machine' | 'unattributable';
+    readonly liveness: 'alive' | 'gone' | 'not-probed';
+    /**
+     * The process evidence, plus `descriptor-closed`: the record names this very process, and no
+     * descriptor of this process is open on the lock — an earlier image of the PID left it.
+     */
+    readonly identity?: ProcessOwnerEvidence['identity'] | 'descriptor-closed';
+    readonly owner: ExclusiveLockOwner | null;
+    readonly cause?: unknown;
+}
+export declare function readOwner(text: string): {
+    owner: ExclusiveLockOwner | undefined;
+    ownerless: boolean;
+};
+/** A lock file as read: its recorded owner, if readable, and the file it was read from. */
+export interface RecordedLock extends FileIdentity {
+    readonly path: string;
+    readonly owner: ExclusiveLockOwner | undefined;
+}
+/**
+ * Judge the recorded owner of a lock file that was read, or of none when it was not.
+ *
+ * A record that names this process with matching kernel identity is held only while a descriptor
+ * of this process is open on the file: a holder keeps the descriptor it created the lock with
+ * until it releases, in every version that records a process identity. A process image replaced
+ * in place keeps its PID and start time but not that descriptor, so the lock it left is gone —
+ * judged alive, it would stay held until the PID changed.
+ */
+export declare function diagnose(lock: RecordedLock | undefined, declaredIdentity: string | undefined): Promise<ExclusiveLockDiagnosis>;
+export {};
+//# sourceMappingURL=exclusive-lock-owner.d.ts.map

package/dist/internal/exclusive-lock-owner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exclusive-lock-owner.d.ts","sourceRoot":"","sources":["../../src/internal/exclusive-lock-owner.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,KAAK,YAAY,EAAuB,MAAM,oBAAoB,CAAC;AAE5E,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,oBAAoB,CAAC;AAG5B,gDAAgD;AAChD,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;iBAO5B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,+CAA+C;AAC/C,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,WAAW,EAAE,cAAc,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;IAC5E,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,YAAY,CAAC;IACnD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC,UAAU,CAAC,GAAG,mBAAmB,CAAC;IAC3E,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG;IACvC,KAAK,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACtC,SAAS,EAAE,OAAO,CAAC;CACpB,CAkBA;AAoBD,2FAA2F;AAC3F,MAAM,WAAW,YAAa,SAAQ,YAAY;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,SAAS,CAAC;CAChD;AAED;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,YAAY,GAAG,SAAS,EAC9B,gBAAgB,EAAE,MAAM,GAAG,SAAS,GACnC,OAAO,CAAC,sBAAsB,CAAC,CAcjC"}

package/dist/internal/exclusive-lock.d.ts

@@ -1,30 +1,4 @@
-import { z } from 'zod';
-import { type ProcessOwnerEvidence } from './process-instance.js';
-/** Who holds a lock, as its file records it. */
-declare const ExclusiveLockOwnerSchema: z.ZodObject<{
-    pid: z.ZodNumber;
-    host: z.ZodString;
-    acquiredAt: z.ZodString;
-    machine: z.ZodCatch<z.ZodOptional<z.ZodString>>;
-    process: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        platform: z.ZodEnum<{
-            darwin: "darwin";
-            linux: "linux";
-        }>;
-        bootId: z.ZodString;
-        namespace: z.ZodString;
-        startId: z.ZodString;
-    }, z.core.$strict>>>>;
-}, z.core.$strip>;
-export type ExclusiveLockOwner = z.infer<typeof ExclusiveLockOwnerSchema>;
-/** Why a present lock was not taken. */
-export interface ExclusiveLockDiagnosis {
-    readonly attribution: 'this-machine' | 'another-machine' | 'unattributable';
-    readonly liveness: 'alive' | 'gone' | 'not-probed';
-    readonly identity?: ProcessOwnerEvidence['identity'];
-    readonly owner: ExclusiveLockOwner | null;
-    readonly cause?: unknown;
-}
+import { type ExclusiveLockDiagnosis, type ExclusiveLockOwner } from './exclusive-lock-owner.js';
 /** A lock this process holds. */
 export interface HeldExclusiveLock {
     readonly path: string;
@@ -64,5 +38,4 @@ export type ExclusiveLockAttempt = {
 export declare function attemptExclusiveLock(path: string, options: ExclusiveLockAttemptOptions, depth?: number): Promise<ExclusiveLockAttempt>;
 /** Read the owner a present lock records, for a refusal that has to name it. */
 export declare function readExclusiveLockOwner(path: string): Promise<ExclusiveLockOwner | null>;
-export {};
 //# sourceMappingURL=exclusive-lock.d.ts.map

package/dist/internal/exclusive-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exclusive-lock.d.ts","sourceRoot":"","sources":["../../src/internal/exclusive-lock.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAEL,KAAK,oBAAoB,EAG1B,MAAM,oBAAoB,CAAC;AAG5B,gDAAgD;AAChD,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;iBAO5B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,wCAAwC;AACxC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,WAAW,EAAE,cAAc,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;IAC5E,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,YAAY,CAAC;IACnD,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC,UAAU,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,iCAAiC;AACjC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;IACnC,kFAAkF;IAClF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yEAAyE;IACzE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,uFAAuF;IACvF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GACpC;IACE,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AA8VN;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,2BAA2B,EACpC,KAAK,SAAI,GACR,OAAO,CAAC,oBAAoB,CAAC,CAgC/B;AAED,gFAAgF;AAChF,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAEpC"}
+{"version":3,"file":"exclusive-lock.d.ts","sourceRoot":"","sources":["../../src/internal/exclusive-lock.ts"],"names":[],"mappings":"AA6BA,OAAO,EAEL,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EAGxB,MAAM,wBAAwB,CAAC;AAMhC,iCAAiC;AACjC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;IACnC,kFAAkF;IAClF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,yEAAyE;IACzE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,uFAAuF;IACvF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GACpC;IACE,kDAAkD;IAClD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,sBAAsB,CAAC;CAC7C,CAAC;AAwSN;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,2BAA2B,EACpC,KAAK,SAAI,GACR,OAAO,CAAC,oBAAoB,CAAC,CAgC/B;AAED,gFAAgF;AAChF,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAEpC"}

package/dist/internal/open-descriptors.d.ts

@@ -0,0 +1,18 @@
+/** The file a descriptor must refer to, as `stat` identifies it. */
+export interface FileIdentity {
+    readonly ino: number;
+    readonly dev: number;
+}
+/**
+ * `true` when another descriptor of this process refers to the file at `path` — still the file
+ * `file` names — `false` when none does, and `null` when that cannot be told: the file is gone or
+ * replaced, or the listing is not proven complete. Unknown never proves that a holder is gone.
+ *
+ * The listing proves itself: the probe opens the file, and the answer counts only when the
+ * listing contains that fresh descriptor. A platform that lists a fixed few descriptors (a BSD
+ * `/dev/fd` without fdescfs lists 0–2) answers `null`, not a false "nobody holds it".
+ */
+export declare function holdsOpenDescriptor(path: string, file: FileIdentity, 
+/** @internal A fixture listing; the real one is always this process's own. */
+descriptorDirectory?: string): Promise<boolean | null>;
+//# sourceMappingURL=open-descriptors.d.ts.map

package/dist/internal/open-descriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-descriptors.d.ts","sourceRoot":"","sources":["../../src/internal/open-descriptors.ts"],"names":[],"mappings":"AAkBA,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY;AAClB,8EAA8E;AAC9E,mBAAmB,SAAuB,GACzC,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAkCzB"}

package/dist/internal/with-exclusive-lock.d.ts

@@ -1,15 +1,5 @@
-/**
- * Run work under an exclusive lock between processes, waiting for it within a
- * deadline and a cancellation signal.
- *
- * The waiting is what the journal never needed and every other caller does: a
- * registry, a cursor or a mailbox is held for milliseconds, so a second process
- * should wait its turn rather than fail. It waits within a bound, stops the
- * moment its signal aborts — during the wait, not after it — and a refusal names
- * the resource and whoever holds it, so "timed out" is never the whole message.
- */
-import { type ExclusiveLockOwner } from './exclusive-lock.js';
-export type { ExclusiveLockOwner } from './exclusive-lock.js';
+import type { ExclusiveLockOwner } from './exclusive-lock-owner.js';
+export type { ExclusiveLockOwner } from './exclusive-lock-owner.js';
 /** Options of {@link withExclusiveLock}. */
 export interface ExclusiveLockOptions {
     /** What the lock guards, named in a refusal. Defaults to the lock path. */