stitchkit 0.55.0 → 0.56.1

package/dist/{index-npye5kt7.js → index-75njxz7p.js}

@@ -7,7 +7,7 @@ import {
   defaultSignalSource,
   guardSignalCallback,
   reportSignalError
-} from "./index-pzc32v75.js";
+} from "./index-sm2tjx06.js";
 import {
   errorCode,
   extractIp,
@@ -23,13 +23,13 @@ import {
   setRequestError,
   validateDeclaredOutput,
   zodIssues
-} from "./index-v4bbq3p4.js";
+} from "./index-j3dem06f.js";
 import {
   AppError,
   badRequest,
   isUnsafeKey,
   safeJsonParse
-} from "./index-h60df7rj.js";
+} from "./index-5r13htq1.js";
 import {
   isRecord,
   parseTrailingWildcard,
@@ -466,12 +466,20 @@ async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
 }
 
 // src/server/request-body.ts
+function requestAbortReason(req) {
+  return req.signal.reason ?? new DOMException("The connection was closed", "AbortError");
+}
+function throwIfRequestAborted(req) {
+  if (req.signal.aborted)
+    throw requestAbortReason(req);
+}
 function assertJsonBodyLimit(maxBytes, owner) {
   if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
     throw new Error(`${owner} must be a positive safe integer, received ${maxBytes}`);
   }
 }
 async function readRequestText(req, maxBytes) {
+  throwIfRequestAborted(req);
   if (maxBytes === undefined)
     return req.text();
   assertJsonBodyLimit(maxBytes, "maxJsonBodyBytes");
@@ -480,9 +488,25 @@ async function readRequestText(req, maxBytes) {
     return "";
   const chunks = [];
   let total = 0;
+  let rejectAbortedRead = (_reason) => {
+    return;
+  };
+  const abortedRead = new Promise((_resolve, reject) => {
+    rejectAbortedRead = reject;
+  });
+  const onAbort = () => {
+    const reason = requestAbortReason(req);
+    rejectAbortedRead(reason);
+    reader.cancel(reason).catch(() => {
+      return;
+    });
+  };
+  req.signal.addEventListener("abort", onAbort, { once: true });
+  if (req.signal.aborted)
+    onAbort();
   try {
     while (true) {
-      const { done, value } = await reader.read();
+      const { done, value } = await Promise.race([reader.read(), abortedRead]);
       if (done)
         break;
       total += value.byteLength;
@@ -493,7 +517,9 @@ async function readRequestText(req, maxBytes) {
       chunks.push(value);
     }
   } finally {
-    reader.releaseLock();
+    req.signal.removeEventListener("abort", onAbort);
+    if (!req.signal.aborted)
+      reader.releaseLock();
   }
   const bytes = new Uint8Array(total);
   let offset = 0;
@@ -630,6 +656,8 @@ function safePath(pathname) {
   return out;
 }
 function levelForStatus(status) {
+  if (status === 499)
+    return "info";
   if (status >= 500)
     return "error";
   if (status >= 400)
@@ -1037,6 +1065,29 @@ function validateRawRoutes(rawRoutes) {
 
 // src/server/create.ts
 var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var MAX_REQUEST_ABORT_CAUSE_DEPTH = 8;
+function containsRequestAbortReason(error, reason) {
+  let current = error;
+  const visited = new Set;
+  for (let depth = 0;depth <= MAX_REQUEST_ABORT_CAUSE_DEPTH; depth += 1) {
+    if (current === reason)
+      return true;
+    if (depth === MAX_REQUEST_ABORT_CAUSE_DEPTH || !isRecord(current))
+      return false;
+    if (visited.has(current))
+      return false;
+    visited.add(current);
+    current = current.cause;
+  }
+  return false;
+}
+function isClientClosedRequest(req, error) {
+  if (!req.signal.aborted)
+    return false;
+  if (isRecord(error) && error.name === "AbortError")
+    return true;
+  return req.signal.reason !== undefined && containsRequestAbortReason(error, req.signal.reason);
+}
 function createHandler(config) {
   const { cors, hooks, logging = false, observability, trustProxy = false } = config;
   if (cors)
@@ -1100,7 +1151,7 @@ function createHandler(config) {
       } catch {}
     }
     let completed = false;
-    const complete = (status, errorCode2) => {
+    const complete = (status, errorCode2, outcome) => {
       if (completed)
         return;
       completed = true;
@@ -1148,11 +1199,22 @@ function createHandler(config) {
       const context = getRequestContext();
       if (observability && context) {
         try {
-          observability.complete({ context, statusCode: status, durationMs, payload });
+          observability.complete({
+            context,
+            statusCode: status,
+            durationMs,
+            payload,
+            ...outcome !== undefined && { outcome }
+          });
         } catch {}
       }
     };
     const respondError = async (err, errCtx, endpoint) => {
+      if (isClientClosedRequest(req, err)) {
+        const response = applyCors(new Response(null, { status: 499, statusText: "Client Closed Request" }), cors, req);
+        complete(response.status, undefined, "cancelled");
+        return response;
+      }
       const recordFailure = (normalized) => {
         if (getRequestContext()?.error !== undefined)
           return;

package/dist/{index-1k16zv57.js → index-bfcpjw20.js}

@@ -9,11 +9,16 @@ import {
 // src/files/boundary.ts
 import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { link, open, realpath, rename, stat, unlink } from "node:fs/promises";
+import { link, mkdir, open, realpath, rename, stat, unlink } from "node:fs/promises";
 import { basename, dirname, resolve } from "node:path";
 var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
 var DEFAULT_INSPECTION_BYTES = 64 * 1024;
+var DEFAULT_INSPECTION_TIMEOUT_MS = 15000;
 var NOFOLLOW_FLAG = constants.O_NOFOLLOW ?? 0;
+var ManagedFileInspectionSchema = ManagedFileRefSchema.pick({
+  mediaType: true,
+  name: true
+});
 
 class ManagedFileError extends Error {
   code;
@@ -47,20 +52,118 @@ function ioError(message, error) {
     return error;
   return new ManagedFileError("FILE_IO_ERROR", message, { cause: error });
 }
+async function realpathOrNull(path, message) {
+  try {
+    return await realpath(path);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT")
+      return null;
+    throw ioError(message, error);
+  }
+}
+async function bindRoot(config) {
+  const requested = resolve(config.root);
+  let canonical = await realpathOrNull(requested, "failed to resolve managed-file root");
+  if (canonical === null && config.createRoot) {
+    const parent = await realpathOrNull(dirname(requested), "failed to resolve managed-file root parent");
+    if (parent === null) {
+      throw new ManagedFileError("FILE_NOT_FOUND", "managed-file root parent must exist");
+    }
+    const parentInfo = await stat(parent).catch((error) => {
+      throw ioError("failed to inspect managed-file root parent", error);
+    });
+    if (!parentInfo.isDirectory()) {
+      throw new ManagedFileError("FILE_NOT_REGULAR", "managed-file root parent must be a directory");
+    }
+    try {
+      await mkdir(requested, { mode: 448 });
+    } catch (error) {
+      if (errorCode(error) !== "EEXIST") {
+        if (errorCode(error) === "ENOENT") {
+          throw new ManagedFileError("FILE_NOT_FOUND", "managed-file root parent must exist");
+        }
+        throw ioError("failed to create managed-file root", error);
+      }
+    }
+    canonical = await realpathOrNull(requested, "failed to resolve managed-file root");
+  }
+  if (canonical === null) {
+    throw new ManagedFileError("FILE_NOT_FOUND", "managed-file root must exist");
+  }
+  const info = await stat(canonical).catch((error) => {
+    throw ioError("failed to inspect managed-file root", error);
+  });
+  if (!info.isDirectory()) {
+    throw new ManagedFileError("FILE_NOT_REGULAR", "managed-file root must be a directory");
+  }
+  return canonical;
+}
 async function existingParent(root, target) {
-  const parent = await realpath(dirname(target)).catch(() => null);
+  const parent = await realpathOrNull(dirname(target), "failed to resolve managed-file parent directory");
   if (parent === null) {
     throw new ManagedFileError("FILE_NOT_FOUND", "managed-file parent directory not found");
   }
   if (!isWithinDir(root, parent)) {
     throw new ManagedFileError("FILE_OUTSIDE_ROOT", "managed-file path escapes its boundary");
   }
-  const info = await stat(parent).catch(() => null);
-  if (!info?.isDirectory()) {
-    throw new ManagedFileError("FILE_NOT_FOUND", "managed-file parent directory not found");
+  const info = await stat(parent).catch((error) => {
+    throw ioError("failed to inspect managed-file parent directory", error);
+  });
+  if (!info.isDirectory()) {
+    throw new ManagedFileError("FILE_NOT_REGULAR", "managed-file parent is not a directory");
   }
   return parent;
 }
+function abortReason(signal) {
+  return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+function raceWithSignal(operation, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolvePromise, rejectPromise) => {
+    let settled = false;
+    const settle = (complete) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      complete();
+    };
+    const onAbort = () => settle(() => rejectPromise(abortReason(signal)));
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted)
+      onAbort();
+    operation.then((value) => settle(() => resolvePromise(value)), (error) => settle(() => rejectPromise(error)));
+  });
+}
+async function inspectFile(inspector, input, timeoutMs, outerSignal) {
+  if (!inspector)
+    return {};
+  outerSignal?.throwIfAborted();
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const signal = outerSignal ? AbortSignal.any([outerSignal, timeoutSignal]) : timeoutSignal;
+  try {
+    const inspected = await raceWithSignal(Promise.resolve().then(() => inspector({ ...input, signal })), signal);
+    return ManagedFileInspectionSchema.parse(inspected);
+  } catch (error) {
+    if (outerSignal?.aborted)
+      throw abortReason(outerSignal);
+    throw new ManagedFileError("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: error });
+  }
+}
+function inspectedRef(path, size, inspection, fallback = {}) {
+  const mediaType = inspection.mediaType ?? fallback.mediaType;
+  const name = inspection.name ?? fallback.name;
+  const parsed = ManagedFileRefSchema.safeParse({
+    path,
+    size,
+    ...mediaType ? { mediaType } : {},
+    ...name ? { name } : {}
+  });
+  if (!parsed.success) {
+    throw new ManagedFileError("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: parsed.error });
+  }
+  return parsed.data;
+}
 async function readHandle(handle, maxBytes, signal) {
   const chunks = [];
   let total = 0;
@@ -143,13 +246,11 @@ async function writeSource(handle, source, maxBytes, inspectionBytes, signal) {
   return { size, prefix };
 }
 async function createManagedFileBoundary(config) {
-  const root = await realpath(resolve(config.root)).catch(() => null);
-  if (root === null || !(await stat(root).catch(() => null))?.isDirectory()) {
-    throw new ManagedFileError("FILE_NOT_FOUND", "managed-file root must exist");
-  }
+  const root = await bindRoot(config);
   const maxReadBytes = positiveLimit(config.maxReadBytes, DEFAULT_MAX_BYTES, "maxReadBytes");
   const maxWriteBytes = positiveLimit(config.maxWriteBytes, DEFAULT_MAX_BYTES, "maxWriteBytes");
   const inspectionBytes = positiveLimit(config.inspectionBytes, DEFAULT_INSPECTION_BYTES, "inspectionBytes");
+  const inspectionTimeoutMs = positiveLimit(config.inspectionTimeoutMs, DEFAULT_INSPECTION_TIMEOUT_MS, "inspectionTimeoutMs");
   const targetFor = (path) => {
     const relative = filePath(path);
     const target = resolve(root, ...relative.split("/"));
@@ -161,7 +262,8 @@ async function createManagedFileBoundary(config) {
   return {
     async read(path, options = {}) {
       const resolved = targetFor(path);
-      const realTarget = await realpath(resolved.target).catch(() => null);
+      options.signal?.throwIfAborted();
+      const realTarget = await realpathOrNull(resolved.target, "failed to resolve managed file");
       if (realTarget === null) {
         throw new ManagedFileError("FILE_NOT_FOUND", "managed file not found");
       }
@@ -177,8 +279,12 @@ async function createManagedFileBoundary(config) {
           throw new ManagedFileError("FILE_NOT_REGULAR", "managed path is not a regular file");
         }
         const bytes = await readHandle(handle, maxBytes, options.signal);
+        const inspection = await inspectFile(config.inspect, {
+          prefix: bytes.slice(0, inspectionBytes),
+          name: basename(resolved.path)
+        }, inspectionTimeoutMs, options.signal);
         return {
-          ref: ManagedFileRefSchema.parse({ path: resolved.path, size: bytes.byteLength }),
+          ref: inspectedRef(resolved.path, bytes.byteLength, inspection),
           bytes
         };
       } catch (error) {
@@ -211,18 +317,11 @@ async function createManagedFileBoundary(config) {
           await handle.sync();
         await handle.close();
         handle = undefined;
-        let inspection = {};
-        if (config.inspect) {
-          try {
-            inspection = await config.inspect({
-              prefix: written.prefix,
-              declaredMediaType: options.mediaType,
-              name: options.name ?? basename(resolved.path)
-            });
-          } catch (error) {
-            throw new ManagedFileError("FILE_INSPECTION_REJECTED", "managed file rejected by inspection", { cause: error });
-          }
-        }
+        const inspection = await inspectFile(config.inspect, {
+          prefix: written.prefix,
+          ...options.mediaType ? { declaredMediaType: options.mediaType } : {},
+          name: options.name ?? basename(resolved.path)
+        }, inspectionTimeoutMs, options.signal);
         options.signal?.throwIfAborted();
         if (options.replace) {
           await rename(temporary, resolved.target);
@@ -238,15 +337,10 @@ async function createManagedFileBoundary(config) {
             throw error;
           }
         }
-        const mediaType = inspection.mediaType ?? options.mediaType;
-        const name = inspection.name ?? options.name;
-        const ref = ManagedFileRefSchema.parse({
-          path: resolved.path,
-          size,
-          ...mediaType ? { mediaType } : {},
-          ...name ? { name } : {}
+        return inspectedRef(resolved.path, size, inspection, {
+          mediaType: options.mediaType,
+          name: options.name
         });
-        return ref;
       } catch (error) {
         if (options.signal?.aborted && error === options.signal.reason)
           throw error;