stitchkit 0.114.1 → 0.115.0

package/dist/{index-s47ac8zt.js → index-7yx8j6ay.js}

@@ -1,33 +1,35 @@
-import {
-  loadDarwinBinding
-} from "./index-2kbysk9s.js";
 import {
   NativeCommandError2
-} from "./index-84bf5spd.js";
+} from "./index-f6m4c545.js";
 import {
   CommandStopped,
   startNativeCommand
-} from "./index-7r4knwf8.js";
+} from "./index-dr3t5n1v.js";
+import {
+  scanContainedFiles
+} from "./index-nregbbsc.js";
+import {
+  writeContainedFile
+} from "./index-j8kf56wx.js";
 import {
-  NumericFileHandle,
-  descriptorPath,
   listContainedDirectory,
   missingContainedDirectories,
+  UnapprovedContainedDirectoryError,
   openContainedParent,
   openContainedFile,
+  ContainedPathChangedError,
   assertContainedFileCurrent,
   assertContainedParentCurrent,
   containedEntryMetadata,
   openContainedParentFile,
-  readContainedUtf8Handle,
-  scanContainedFiles
-} from "./index-zrtrjkbf.js";
+  readContainedUtf8Handle
+} from "./index-x0ddbj85.js";
 import {
   defineRuntimeTool2
 } from "./index-ega3yz4c.js";
 import {
-  stagingName
-} from "./index-j4zh647a.js";
+  errnoOf
+} from "./index-jj9228tt.js";
 import {
   AppError2,
   forbidden2,
@@ -250,7 +252,7 @@ async function recordAgentSandboxProbe2(input) {
 }
 
 // src/agent-runtime/coding-tools.ts
-import path5 from "node:path";
+import path4 from "node:path";
 import { z as z5 } from "zod";
 
 // src/agent-runtime/coding-tool-files.ts
@@ -278,7 +280,8 @@ function codingPathRefusal(code, message, path, options = {}) {
   });
 }
 function refuseMissingCodingPath(error, relative) {
-  const code = error?.code;
+  refuseChangedPath(error, relative);
+  const code = errnoOf(error);
   if (error instanceof Error && error.message.includes("is not a regular file")) {
     codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
       hint: "Use list_directory to see what is here."
@@ -299,13 +302,55 @@ function refuseMissingCodingPath(error, relative) {
       hint: "Read or write the target directly, by its own workspace-relative path."
     });
   }
-  if (code === "EISDIR") {
+  if (code === "EISDIR" || code === "ENXIO" || code === "EOPNOTSUPP") {
     codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
       hint: "Use list_directory to see what is here."
     });
   }
   throw error;
 }
+function refuseChangedPath(error, relative) {
+  if (error instanceof ContainedPathChangedError) {
+    codingPathRefusal("CONFLICT", "This path changed while it was being authorized", relative, {
+      hint: "Read it again and retry."
+    });
+  }
+}
+function refuseWriteConflict(error, relative, details = {}) {
+  refuseChangedPath(error, relative);
+  const code = errnoOf(error);
+  if (code === "ENOENT") {
+    codingPathRefusal("CONFLICT", "This path changed while it was being written", relative, {
+      details,
+      hint: "Read it again and retry."
+    });
+  }
+  if (code === "ENOTDIR") {
+    codingPathRefusal("CONFLICT", "A segment of this path is not a directory", relative, {
+      details,
+      hint: "Write under a different path, or remove the file blocking it."
+    });
+  }
+  if (code === "ELOOP") {
+    codingPathRefusal("FORBIDDEN", "This path is a symlink, which is not followed", relative, {
+      details,
+      hint: "Write to the target directly, by its own workspace-relative path."
+    });
+  }
+  if (code === "EISDIR") {
+    codingPathRefusal("CONFLICT", "This path is a directory", relative, {
+      details,
+      hint: "Write to a file path inside it, or choose another name."
+    });
+  }
+  if (code === "EEXIST") {
+    codingPathRefusal("CONFLICT", "This file already exists", relative, {
+      details,
+      hint: "Pass overwrite: true to replace it, or edit_file to change part of it."
+    });
+  }
+  throw error;
+}
 function refuseUnknownSpillReference(reference) {
   codingRefusal("SPILL_REFERENCE_UNKNOWN", `No spilled output is held under \`${reference}\``, {
     details: { reference },
@@ -343,6 +388,12 @@ function inputPath(root, requested, maxPathBytes) {
   return resolved;
 }
 function boundedCodingRelativePath(root, requested, maxPathBytes) {
+  if (requested.includes("\x00")) {
+    codingRefusal("BAD_REQUEST", "Path segments cannot contain a NUL byte", {
+      details: { path: requested },
+      hint: "Pass the exact workspace-relative entry name without NUL bytes."
+    });
+  }
   if (path.isAbsolute(requested))
     inputPath(root, requested, maxPathBytes);
   if (requested.includes("\\")) {
@@ -462,86 +513,6 @@ function utf8AlignedStart(data, start, end) {
   return safe;
 }
 
-// src/agent-runtime/contained-write.ts
-import { fchmod, write as writeDescriptor } from "node:fs";
-import { rename, unlink, writeFile } from "node:fs/promises";
-import path2 from "node:path";
-async function writeDescriptorFully(descriptor, content) {
-  const bytes = Buffer.from(content);
-  let offset = 0;
-  while (offset < bytes.byteLength) {
-    const written = await new Promise((resolve, reject) => {
-      writeDescriptor(descriptor, bytes, offset, bytes.byteLength - offset, null, (error, bytesWritten) => error ? reject(error) : resolve(bytesWritten));
-    });
-    if (written === 0)
-      throw new Error("Contained file write made no progress");
-    offset += written;
-  }
-}
-async function chmodDescriptor(descriptor, mode) {
-  await new Promise((resolve, reject) => {
-    fchmod(descriptor, mode & 4095, (error) => error ? reject(error) : resolve());
-  });
-}
-async function createDarwinFile(parent, name, content, mode) {
-  const binding = loadDarwinBinding();
-  const descriptor = binding.createFileAt(parent.fd, name, mode & 4095);
-  let failed;
-  try {
-    await writeDescriptorFully(descriptor, content);
-    await chmodDescriptor(descriptor, mode);
-  } catch (error) {
-    failed = error;
-  } finally {
-    try {
-      await new NumericFileHandle(descriptor).close();
-    } catch (error) {
-      failed ??= error;
-    }
-  }
-  if (failed) {
-    binding.unlinkAt(parent.fd, name);
-    throw failed;
-  }
-}
-async function writeContainedFile(input) {
-  const mode = input.mode ?? 438;
-  if (!input.replace) {
-    if (process.platform === "darwin") {
-      await createDarwinFile(input.parent.handle, input.parent.basename, input.content, mode);
-      return;
-    }
-    await writeFile(path2.join(descriptorPath(input.parent.handle), input.parent.basename), input.content, { flag: "wx", mode });
-    return;
-  }
-  const temporary = stagingName();
-  if (process.platform === "darwin") {
-    const binding = loadDarwinBinding();
-    let created = false;
-    try {
-      await createDarwinFile(input.parent.handle, temporary, input.content, mode);
-      created = true;
-      binding.renameAt(input.parent.handle.fd, temporary, input.parent.basename);
-    } catch (error) {
-      if (created)
-        binding.unlinkAt(input.parent.handle.fd, temporary);
-      throw error;
-    }
-    return;
-  }
-  const directory = descriptorPath(input.parent.handle);
-  const temporaryPath = path2.join(directory, temporary);
-  try {
-    await writeFile(temporaryPath, input.content, { flag: "wx", mode });
-    await rename(temporaryPath, path2.join(directory, input.parent.basename));
-  } catch (error) {
-    await unlink(temporaryPath).catch(() => {
-      return;
-    });
-    throw error;
-  }
-}
-
 // src/agent-runtime/coding-tool-files.ts
 async function digestFile(handle, size) {
   const hash = createHash("sha256");
@@ -556,6 +527,17 @@ async function digestFile(handle, size) {
   }
   return hash.digest("hex");
 }
+async function openAuthorizedWriteParent(root, relative, createsDirectories) {
+  return openContainedParent(root, relative, { createDirectories: createsDirectories }).catch((error) => {
+    if (error instanceof UnapprovedContainedDirectoryError) {
+      codingPathRefusal("CONFLICT", "The directory creation plan changed during authorization", relative, {
+        details: { createsDirectories },
+        hint: "Retry the write so the host can authorize the current directories."
+      });
+    }
+    refuseWriteConflict(error, relative, { createsDirectories });
+  });
+}
 function createFileCodingTools(config, limits) {
   const read = defineRuntimeTool2({
     name: "read_file",
@@ -576,7 +558,7 @@ function createFileCodingTools(config, limits) {
       let sha256;
       try {
         await authorizeCodingTool(config, { operation: "read", path: relative });
-        await assertContainedFileCurrent(root, relative, handle);
+        await assertContainedFileCurrent(root, relative, handle).catch((error) => refuseMissingCodingPath(error, relative));
         const metadata = await handle.stat();
         if (!metadata.isFile()) {
           codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
@@ -639,14 +621,7 @@ function createFileCodingTools(config, limits) {
           hint: "Write a smaller file, or split it."
         });
       }
-      const createsDirectories = await missingContainedDirectories(root, relative).catch((error) => {
-        if (error.code === "ENOTDIR") {
-          codingPathRefusal("CONFLICT", "A segment of this path is not a directory", relative, {
-            hint: "Write under a different path, or remove the file blocking it."
-          });
-        }
-        throw error;
-      });
+      const createsDirectories = await missingContainedDirectories(root, relative).catch((error) => refuseWriteConflict(error, relative));
       await authorizeCodingTool(config, {
         operation: "write",
         path: relative,
@@ -654,42 +629,39 @@ function createFileCodingTools(config, limits) {
         overwrite: input.overwrite,
         createsDirectories
       });
-      const parent = await openContainedParent(root, relative, { create: true }).catch((error) => {
-        const code = error.code;
-        if (code === "ENOTDIR" || error instanceof Error && error.message.includes("ancestor is not a directory")) {
-          codingPathRefusal("CONFLICT", "A segment of this path is not a directory", relative, {
-            details: { createsDirectories },
-            hint: "Write under a different path, or remove the file blocking it."
-          });
-        }
-        throw error;
-      });
-      try {
-        await assertContainedParentCurrent(root, relative, parent.handle);
-        const current = await containedEntryMetadata(parent);
-        if (input.overwrite) {
-          if (current?.isSymbolicLink()) {
-            codingPathRefusal("FORBIDDEN", "This path is a symlink", relative, {
-              hint: "Coding tools never write through symlinks; write to the target directly."
-            });
-          }
-          await writeContainedFile({
-            parent,
-            content: input.content,
-            replace: true,
-            ...current && { mode: current.mode }
-          });
-        } else {
-          if (current) {
-            codingPathRefusal("CONFLICT", "This file already exists", relative, {
-              hint: "Pass overwrite: true to replace it, or edit_file to change part of it."
-            });
+      await withCodingPathLock(`${root}:${relative}`, async () => {
+        const parent = await openAuthorizedWriteParent(root, relative, createsDirectories);
+        try {
+          await assertContainedParentCurrent(root, relative, parent.handle).catch((error) => refuseWriteConflict(error, relative));
+          const current = await containedEntryMetadata(parent);
+          if (input.overwrite) {
+            if (current?.isSymbolicLink()) {
+              codingPathRefusal("FORBIDDEN", "This path is a symlink", relative, {
+                hint: "Coding tools never write through symlinks; write to the target directly."
+              });
+            }
+            await writeContainedFile({
+              parent,
+              content: input.content,
+              replace: true,
+              ...current && { mode: current.mode }
+            }).catch((error) => refuseWriteConflict(error, relative));
+          } else {
+            if (current) {
+              codingPathRefusal("CONFLICT", "This file already exists", relative, {
+                hint: "Pass overwrite: true to replace it, or edit_file to change part of it."
+              });
+            }
+            await writeContainedFile({
+              parent,
+              content: input.content,
+              replace: false
+            }).catch((error) => refuseWriteConflict(error, relative));
           }
-          await writeContainedFile({ parent, content: input.content, replace: false });
+        } finally {
+          await parent.handle.close();
         }
-      } finally {
-        await parent.handle.close();
-      }
+      });
       return { path: relative, bytes, createdDirectories: createsDirectories };
     }
   });
@@ -698,7 +670,7 @@ function createFileCodingTools(config, limits) {
 
 // src/agent-runtime/coding-tool-listing.ts
 import { realpath as realpath3 } from "node:fs/promises";
-import path3 from "node:path";
+import path2 from "node:path";
 import { z as z3 } from "zod";
 var DEFAULT_EXCLUDED_DIRECTORIES = [
   ".git",
@@ -773,12 +745,7 @@ function createListingCodingTools(config, limits) {
       await authorizeCodingPathChain(config, relative);
       await authorizeCodingTool(config, { operation: "list", path: relative });
       const listing = await listContainedDirectory(root, relative, limits.maxListEntries, (candidate) => isCodingPathAuthorized(config, candidate)).catch((error) => {
-        if (error instanceof Error && error.message.includes("ancestor is not a directory")) {
-          codingPathRefusal("BAD_REQUEST", "This path is not a directory", relative, {
-            hint: "Pass a directory; use read_file for a file."
-          });
-        }
-        if (error.code === "ENOENT") {
+        if (errnoOf(error) === "ENOENT") {
           codingPathRefusal("NOT_FOUND", "This directory does not exist", relative, {
             hint: "List a parent directory to see what is there."
           });
@@ -794,7 +761,7 @@ function createListingCodingTools(config, limits) {
         truncated: listing.truncated,
         ...listing.denied.length > 0 && {
           denied: listing.denied.map((entry) => ({
-            path: relative === "." ? entry.name : path3.join(relative, entry.name),
+            path: relative === "." ? entry.name : path2.join(relative, entry.name),
             kind: entry.kind
           })),
           deniedTruncated: listing.deniedTruncated
@@ -832,10 +799,10 @@ function createListingCodingTools(config, limits) {
         maxDepth: limits.maxSearchDepth,
         maxFiles: limits.maxSearchFiles,
         symlinks: "skip",
-        excludeDirectory: (directory) => directory.split(path3.sep).some((segment) => excluded.has(segment)),
+        excludeDirectory: (directory) => directory.split(path2.sep).some((segment) => excluded.has(segment)),
         authorizePath: (candidate) => isCodingPathAuthorized(config, candidate)
       });
-      const prefix = relative === "." ? "" : `${relative}${path3.sep}`;
+      const prefix = relative === "." ? "" : `${relative}${path2.sep}`;
       const matched = scan.files.filter((file) => file.relative.startsWith(prefix)).map((file) => file.relative).filter((candidate) => matcher.test(candidate.slice(prefix.length))).sort();
       const paths = matched.slice(0, limits.maxSearchResults);
       const scopedDenied = scan.denied.filter((entry) => entry.relative.startsWith(prefix));
@@ -862,7 +829,7 @@ function createListingCodingTools(config, limits) {
 // src/agent-runtime/coding-tool-search-patch.ts
 import { createHash as createHash2 } from "node:crypto";
 import { realpath as realpath4 } from "node:fs/promises";
-import path4 from "node:path";
+import path3 from "node:path";
 import { z as z4 } from "zod";
 var SearchInputSchema = z4.object({
   query: z4.string().min(1),
@@ -943,7 +910,7 @@ async function searchFiles(config, limits, input) {
       readMaxBytes: limits.maxReadBytes,
       skipUnreadable: true
     },
-    excludeDirectory: (relative) => relative.split(path4.sep).some((segment) => excluded.has(segment)),
+    excludeDirectory: (relative) => relative.split(path3.sep).some((segment) => excluded.has(segment)),
     includeFile: (candidate) => {
       if (included && !included.test(candidate)) {
         rejectedByInclude += 1;
@@ -1019,8 +986,12 @@ async function editFile(config, limits, input) {
   const parent = await openContainedParent(root, relative).catch((error) => refuseMissingCodingPath(error, relative));
   try {
     return await withCodingPathLock(`${root}:${relative}`, async () => {
-      const handle = await openContainedParentFile(parent).catch((error) => refuseMissingCodingPath(error, relative));
-      const read = await readContainedUtf8Handle(handle, limits.maxWriteBytes).finally(() => handle.close());
+      const readCurrent = async () => {
+        const handle = await openContainedParentFile(parent).catch((error) => refuseMissingCodingPath(error, relative));
+        return readContainedUtf8Handle(handle, limits.maxWriteBytes).finally(() => handle.close());
+      };
+      await authorizeCodingTool(config, { operation: "read", path: relative });
+      const read = await readCurrent();
       const source = read.text;
       const baseSha256 = sha256(source);
       if (input.expectedSha256 !== undefined && baseSha256 !== input.expectedSha256) {
@@ -1064,14 +1035,20 @@ async function editFile(config, limits, input) {
         replacements,
         dryRun: input.dryRun
       });
-      await assertContainedParentCurrent(root, relative, parent.handle);
+      await assertContainedParentCurrent(root, relative, parent.handle).catch((error) => refuseWriteConflict(error, relative));
       if (!input.dryRun) {
+        if (sha256((await readCurrent()).text) !== baseSha256) {
+          conflict2("The file changed since it was read", {
+            message: "The file changed since it was read",
+            path: relative
+          });
+        }
         await writeContainedFile({
           parent,
           content: changed,
           replace: true,
           mode: read.mode
-        });
+        }).catch((error) => refuseWriteConflict(error, relative));
       }
       return {
         path: relative,
@@ -1383,10 +1360,10 @@ var AGENT_CODING_TOOL_NAMES = {
   writeFile: "write_file"
 };
 function createAgentCodingTools2(config) {
-  if (!path5.isAbsolute(config.root))
+  if (!path4.isAbsolute(config.root))
     throw new Error("Coding tool root must be absolute");
   for (const executable of Object.values(config.executables ?? {})) {
-    if (!path5.isAbsolute(executable)) {
+    if (!path4.isAbsolute(executable)) {
       throw new Error("Coding tool executables must be absolute paths");
     }
   }

package/dist/{index-kdnfe0sr.js → index-90p34rts.js}

@@ -5,10 +5,10 @@ import {
   fetchGuarded,
   PrivateAddressRefusal,
   readCapped
-} from "./index-t65erk4z.js";
+} from "./index-mgb7r8b8.js";
 import {
   writeFileAtomicSync2
-} from "./index-07dcf2yn.js";
+} from "./index-ac6vvm30.js";
 import {
   raceAbort
 } from "./index-b0kddvzw.js";

package/dist/{index-a3462dqf.js → index-944x38nv.js}

@@ -4,7 +4,7 @@ import {
   AgentSandboxRestrictionSchema2,
   AgentSandboxGradeSchema2,
   AGENT_CODING_TOOL_NAMES
-} from "./index-s47ac8zt.js";
+} from "./index-7yx8j6ay.js";
 import {
   AgentRecordIdSchema2,
   AgentRecordVersionSchema2,

package/dist/{index-07dcf2yn.js → index-ac6vvm30.js}

@@ -6,7 +6,10 @@ import {
 } from "./index-b56nnscm.js";
 import {
   stagingPath
-} from "./index-j4zh647a.js";
+} from "./index-tt30h7mr.js";
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 
 // src/internal/atomic-file.ts
 import { closeSync, fchmodSync, fsyncSync, openSync, unlinkSync, writeSync } from "node:fs";
@@ -27,7 +30,7 @@ async function writeFileAtomic2(target, data, options = {}) {
   return writeAtomicFileData(target, data, options);
 }
 function isMissing(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  return errnoOf(error) === "ENOENT";
 }
 async function writeAtomicFileStaged(target, stage, options, io = { open, unlink, publish: publishAtomicFile }) {
   const mode = options.mode ?? DEFAULT_MODE;

package/dist/{index-qj1sy4ep.js → index-crmswbrt.js}

@@ -19,7 +19,7 @@ import {
   appendEventIn,
   ArchiveProjectionSchema,
   createAgentRuntimeStore2
-} from "./index-a3462dqf.js";
+} from "./index-944x38nv.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2

package/dist/{index-7r4knwf8.js → index-dr3t5n1v.js}

@@ -11,7 +11,10 @@ import {
   spawnBunChild,
   spawnBunInheritedChild,
   ownerLossGuardEntry
-} from "./index-84bf5spd.js";
+} from "./index-f6m4c545.js";
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 import {
   raceAbort
 } from "./index-b0kddvzw.js";
@@ -30,7 +33,8 @@ var ObservationSchema = z.object({
   groupId: z.number().int().positive(),
   observations: z.number().int().nonnegative(),
   lastStates: z.array(z.string().max(32)).max(16),
-  elapsedMs: z.number().int().nonnegative()
+  elapsedMs: z.number().int().nonnegative(),
+  reason: z.string().max(32).optional()
 });
 var observations = new WeakMap;
 
@@ -119,6 +123,12 @@ function processGroups(timeoutMs) {
     });
   });
 }
+function observationFailureReason(cause) {
+  if (!(cause instanceof Error))
+    return "unknown";
+  const signal = "signal" in cause && typeof cause.signal === "string" ? cause.signal : undefined;
+  return (errnoOf(cause) ?? signal ?? cause.name).slice(0, 32);
+}
 async function waitForProcessGroupExit(pid, deadline, killLiveMembers) {
   if (pid === undefined)
     return;
@@ -155,7 +165,7 @@ async function waitForProcessGroupExit(pid, deadline, killLiveMembers) {
   } catch (cause) {
     if (cause instanceof GroupSettlementError)
       throw cause;
-    throw new GroupSettlementError("Could not observe command process group settlement", { ...observation(), failure: "observation" }, cause);
+    throw new GroupSettlementError("Could not observe command process group settlement", { ...observation(), failure: "observation", reason: observationFailureReason(cause) }, cause);
   }
 }
 
@@ -185,7 +195,7 @@ function deniedOnDarwin(error) {
   return process.platform === "darwin" && error instanceof Error && "code" in error && error.code === "EPERM";
 }
 function isErrno(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
+  return errnoOf(error) === code;
 }
 function signalGroup(pid, signal) {
   if (pid === undefined)

package/dist/{index-dc9ere5p.js → index-dx5cm9pc.js}

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

package/dist/{index-84bf5spd.js → index-f6m4c545.js}

@@ -1,3 +1,6 @@
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 import {
   MAX_TIMER_MS
 } from "./index-eemvahkc.js";
@@ -177,7 +180,7 @@ function abortOwnerLossLaunch(pid) {
   try {
     process.kill(-pid, "SIGKILL");
   } catch (error) {
-    if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
+    if (errnoOf(error) !== "ESRCH")
       throw error;
   }
 }
@@ -575,7 +578,7 @@ function runOwnerLossGuard(signalTarget, executable, args) {
         try {
           process.kill(targetPid, signal);
         } catch (error) {
-          if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
+          if (errnoOf(error) !== "ESRCH")
             throw error;
         }
       };

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

@@ -1,15 +1,18 @@
 import {
   withExclusiveLock2
-} from "./index-6b3pcq5z.js";
+} from "./index-zqkz4af9.js";
 import {
   readBoundedFile
 } from "./index-m616f0yz.js";
 import {
   writeAtomicFileData
-} from "./index-07dcf2yn.js";
+} from "./index-ac6vvm30.js";
 import {
   publishAtomicFile
 } from "./index-b56nnscm.js";
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 import {
   assertPositiveSafeInteger
 } from "./index-0s4xebbg.js";
@@ -21,7 +24,7 @@ var NATIVE_IO = { write: writeAtomicFileData, lock: withExclusiveLock2 };
 var DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
 var encode = (state) => `${JSON.stringify(state)}
 `;
-var missing = (error) => error instanceof Error && ("code" in error) && error.code === "ENOENT";
+var missing = (error) => errnoOf(error) === "ENOENT";
 function createFileStateStore2(path, options) {
   return createFileStateStoreOn(path, options, NATIVE_IO);
 }