payload 4.0.0-internal.e7d4ebc → 4.0.0-internal.ec73d44

package/dist/utilities/httpStatus.d.ts

@@ -0,0 +1,18 @@
+/** HTTP status codes used by Payload. */
+export declare const httpStatus: {
+    readonly BAD_REQUEST: 400;
+    readonly CONFLICT: 409;
+    readonly CREATED: 201;
+    readonly FORBIDDEN: 403;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly LOCKED: 423;
+    readonly NOT_FOUND: 404;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly OK: 200;
+    readonly PARTIAL_CONTENT: 206;
+    readonly REQUEST_ENTITY_TOO_LARGE: 413;
+    readonly REQUESTED_RANGE_NOT_SATISFIABLE: 416;
+    readonly UNAUTHORIZED: 401;
+    readonly UNPROCESSABLE_ENTITY: 422;
+};
+//# sourceMappingURL=httpStatus.d.ts.map

package/dist/utilities/httpStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpStatus.d.ts","sourceRoot":"","sources":["../../src/utilities/httpStatus.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,eAAO,MAAM,UAAU;aACrB,WAAW,EAAE,GAAG;aAChB,QAAQ,EAAE,GAAG;aACb,OAAO,EAAE,GAAG;aACZ,SAAS,EAAE,GAAG;aACd,qBAAqB,EAAE,GAAG;aAC1B,MAAM,EAAE,GAAG;aACX,SAAS,EAAE,GAAG;aACd,eAAe,EAAE,GAAG;aACpB,EAAE,EAAE,GAAG;aACP,eAAe,EAAE,GAAG;aACpB,wBAAwB,EAAE,GAAG;aAC7B,+BAA+B,EAAE,GAAG;aACpC,YAAY,EAAE,GAAG;aACjB,oBAAoB,EAAE,GAAG;CACjB,CAAA"}

package/dist/utilities/httpStatus.js

@@ -0,0 +1,18 @@
+/** HTTP status codes used by Payload. */ export const httpStatus = {
+    BAD_REQUEST: 400,
+    CONFLICT: 409,
+    CREATED: 201,
+    FORBIDDEN: 403,
+    INTERNAL_SERVER_ERROR: 500,
+    LOCKED: 423,
+    NOT_FOUND: 404,
+    NOT_IMPLEMENTED: 501,
+    OK: 200,
+    PARTIAL_CONTENT: 206,
+    REQUEST_ENTITY_TOO_LARGE: 413,
+    REQUESTED_RANGE_NOT_SATISFIABLE: 416,
+    UNAUTHORIZED: 401,
+    UNPROCESSABLE_ENTITY: 422
+};
+
+//# sourceMappingURL=httpStatus.js.map

package/dist/utilities/httpStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/httpStatus.ts"],"sourcesContent":["/** HTTP status codes used by Payload. */\nexport const httpStatus = {\n  BAD_REQUEST: 400,\n  CONFLICT: 409,\n  CREATED: 201,\n  FORBIDDEN: 403,\n  INTERNAL_SERVER_ERROR: 500,\n  LOCKED: 423,\n  NOT_FOUND: 404,\n  NOT_IMPLEMENTED: 501,\n  OK: 200,\n  PARTIAL_CONTENT: 206,\n  REQUEST_ENTITY_TOO_LARGE: 413,\n  REQUESTED_RANGE_NOT_SATISFIABLE: 416,\n  UNAUTHORIZED: 401,\n  UNPROCESSABLE_ENTITY: 422,\n} as const\n"],"names":["httpStatus","BAD_REQUEST","CONFLICT","CREATED","FORBIDDEN","INTERNAL_SERVER_ERROR","LOCKED","NOT_FOUND","NOT_IMPLEMENTED","OK","PARTIAL_CONTENT","REQUEST_ENTITY_TOO_LARGE","REQUESTED_RANGE_NOT_SATISFIABLE","UNAUTHORIZED","UNPROCESSABLE_ENTITY"],"mappings":"AAAA,uCAAuC,GACvC,OAAO,MAAMA,aAAa;IACxBC,aAAa;IACbC,UAAU;IACVC,SAAS;IACTC,WAAW;IACXC,uBAAuB;IACvBC,QAAQ;IACRC,WAAW;IACXC,iBAAiB;IACjBC,IAAI;IACJC,iBAAiB;IACjBC,0BAA0B;IAC1BC,iCAAiC;IACjCC,cAAc;IACdC,sBAAsB;AACxB,EAAU"}

package/dist/utilities/initTransaction.d.ts

@@ -1,5 +1,8 @@
 import type { MarkRequired } from 'ts-essentials';
 import type { PayloadRequest } from '../types/index.js';
+export declare function hasActiveTransaction({ req, }: {
+    req: Pick<PayloadRequest, 'transactionID'>;
+}): Promise<boolean>;
 /**
  * Starts a new transaction using the db adapter with a random id and then assigns it to the req.transaction
  * @returns true if beginning a transaction and false when req already has a transaction to use

package/dist/utilities/initTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initTransaction.d.ts","sourceRoot":"","sources":["../../src/utilities/initTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;GAGG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,OAAO,CAAC,CAwBlB"}
+{"version":3,"file":"initTransaction.d.ts","sourceRoot":"","sources":["../../src/utilities/initTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD,wBAAsB,oBAAoB,CAAC,EACzC,GAAG,GACJ,EAAE;IACD,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,CAAC,CAAA;CAC3C,GAAG,OAAO,CAAC,OAAO,CAAC,CAInB;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,OAAO,CAAC,CA6DlB"}

package/dist/utilities/initTransaction.js

@@ -1,3 +1,7 @@
+export async function hasActiveTransaction({ req }) {
+    const transactionID = await req.transactionID;
+    return typeof transactionID === 'number' || typeof transactionID === 'string';
+}
 /**
  * Starts a new transaction using the db adapter with a random id and then assigns it to the req.transaction
  * @returns true if beginning a transaction and false when req already has a transaction to use
@@ -5,7 +9,18 @@
     const { payload, transactionID } = req;
     if (transactionID instanceof Promise) {
         // wait for whoever else is already creating the transaction
-        await transactionID;
+        let resolvedTransactionID;
+        try {
+            resolvedTransactionID = await transactionID;
+        } catch (error) {
+            if (req.transactionID === transactionID) {
+                delete req.transactionID;
+            }
+            throw error;
+        }
+        if (!resolvedTransactionID && req.transactionID === transactionID) {
+            delete req.transactionID;
+        }
         return false;
     }
     if (transactionID) {
@@ -14,13 +29,30 @@
     }
     if (typeof payload.db.beginTransaction === 'function') {
         // create a new transaction
-        req.transactionID = payload.db.beginTransaction().then((transactionID)=>{
-            if (transactionID) {
-                req.transactionID = transactionID;
+        const pendingTransactionID = payload.db.beginTransaction();
+        const pendingTransactionToken = pendingTransactionID;
+        req.transactionID = pendingTransactionToken;
+        let resolvedTransactionID;
+        try {
+            resolvedTransactionID = await pendingTransactionID;
+        } catch (error) {
+            if (req.transactionID === pendingTransactionToken) {
+                delete req.transactionID;
             }
-            return transactionID;
-        });
-        return !!await req.transactionID;
+            throw error;
+        }
+        if (!resolvedTransactionID && req.transactionID === pendingTransactionToken) {
+            delete req.transactionID;
+        }
+        if (!resolvedTransactionID) {
+            return false;
+        }
+        if (req.transactionID !== pendingTransactionToken) {
+            await payload.db.rollbackTransaction(resolvedTransactionID);
+            return false;
+        }
+        req.transactionID = resolvedTransactionID;
+        return true;
     }
     return false;
 }

package/dist/utilities/initTransaction.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/initTransaction.ts"],"sourcesContent":["import type { MarkRequired } from 'ts-essentials'\n\nimport type { PayloadRequest } from '../types/index.js'\n\n/**\n * Starts a new transaction using the db adapter with a random id and then assigns it to the req.transaction\n * @returns true if beginning a transaction and false when req already has a transaction to use\n */\nexport async function initTransaction(\n  req: MarkRequired<Partial<PayloadRequest>, 'payload'>,\n): Promise<boolean> {\n  const { payload, transactionID } = req\n  if (transactionID instanceof Promise) {\n    // wait for whoever else is already creating the transaction\n    await transactionID\n    return false\n  }\n\n  if (transactionID) {\n    // we already have a transaction, we're not in charge of committing it\n    return false\n  }\n  if (typeof payload.db.beginTransaction === 'function') {\n    // create a new transaction\n    req.transactionID = payload.db.beginTransaction().then((transactionID) => {\n      if (transactionID) {\n        req.transactionID = transactionID\n      }\n\n      return transactionID!\n    })\n    return !!(await req.transactionID)\n  }\n  return false\n}\n"],"names":["initTransaction","req","payload","transactionID","Promise","db","beginTransaction","then"],"mappings":"AAIA;;;CAGC,GACD,OAAO,eAAeA,gBACpBC,GAAqD;IAErD,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAE,GAAGF;IACnC,IAAIE,yBAAyBC,SAAS;QACpC,4DAA4D;QAC5D,MAAMD;QACN,OAAO;IACT;IAEA,IAAIA,eAAe;QACjB,sEAAsE;QACtE,OAAO;IACT;IACA,IAAI,OAAOD,QAAQG,EAAE,CAACC,gBAAgB,KAAK,YAAY;QACrD,2BAA2B;QAC3BL,IAAIE,aAAa,GAAGD,QAAQG,EAAE,CAACC,gBAAgB,GAAGC,IAAI,CAAC,CAACJ;YACtD,IAAIA,eAAe;gBACjBF,IAAIE,aAAa,GAAGA;YACtB;YAEA,OAAOA;QACT;QACA,OAAO,CAAC,CAAE,MAAMF,IAAIE,aAAa;IACnC;IACA,OAAO;AACT"}
+{"version":3,"sources":["../../src/utilities/initTransaction.ts"],"sourcesContent":["import type { MarkRequired } from 'ts-essentials'\n\nimport type { PayloadRequest } from '../types/index.js'\n\nexport async function hasActiveTransaction({\n  req,\n}: {\n  req: Pick<PayloadRequest, 'transactionID'>\n}): Promise<boolean> {\n  const transactionID = await req.transactionID\n\n  return typeof transactionID === 'number' || typeof transactionID === 'string'\n}\n\n/**\n * Starts a new transaction using the db adapter with a random id and then assigns it to the req.transaction\n * @returns true if beginning a transaction and false when req already has a transaction to use\n */\nexport async function initTransaction(\n  req: MarkRequired<Partial<PayloadRequest>, 'payload'>,\n): Promise<boolean> {\n  const { payload, transactionID } = req\n  if (transactionID instanceof Promise) {\n    // wait for whoever else is already creating the transaction\n    let resolvedTransactionID: Awaited<typeof transactionID>\n\n    try {\n      resolvedTransactionID = await transactionID\n    } catch (error) {\n      if (req.transactionID === transactionID) {\n        delete req.transactionID\n      }\n      throw error\n    }\n\n    if (!resolvedTransactionID && req.transactionID === transactionID) {\n      delete req.transactionID\n    }\n    return false\n  }\n\n  if (transactionID) {\n    // we already have a transaction, we're not in charge of committing it\n    return false\n  }\n  if (typeof payload.db.beginTransaction === 'function') {\n    // create a new transaction\n    const pendingTransactionID = payload.db.beginTransaction()\n    const pendingTransactionToken = pendingTransactionID as Promise<number | string>\n\n    req.transactionID = pendingTransactionToken\n    let resolvedTransactionID: Awaited<typeof pendingTransactionID>\n\n    try {\n      resolvedTransactionID = await pendingTransactionID\n    } catch (error) {\n      if (req.transactionID === pendingTransactionToken) {\n        delete req.transactionID\n      }\n      throw error\n    }\n\n    if (!resolvedTransactionID && req.transactionID === pendingTransactionToken) {\n      delete req.transactionID\n    }\n\n    if (!resolvedTransactionID) {\n      return false\n    }\n\n    if (req.transactionID !== pendingTransactionToken) {\n      await payload.db.rollbackTransaction(resolvedTransactionID)\n\n      return false\n    }\n\n    req.transactionID = resolvedTransactionID\n\n    return true\n  }\n  return false\n}\n"],"names":["hasActiveTransaction","req","transactionID","initTransaction","payload","Promise","resolvedTransactionID","error","db","beginTransaction","pendingTransactionID","pendingTransactionToken","rollbackTransaction"],"mappings":"AAIA,OAAO,eAAeA,qBAAqB,EACzCC,GAAG,EAGJ;IACC,MAAMC,gBAAgB,MAAMD,IAAIC,aAAa;IAE7C,OAAO,OAAOA,kBAAkB,YAAY,OAAOA,kBAAkB;AACvE;AAEA;;;CAGC,GACD,OAAO,eAAeC,gBACpBF,GAAqD;IAErD,MAAM,EAAEG,OAAO,EAAEF,aAAa,EAAE,GAAGD;IACnC,IAAIC,yBAAyBG,SAAS;QACpC,4DAA4D;QAC5D,IAAIC;QAEJ,IAAI;YACFA,wBAAwB,MAAMJ;QAChC,EAAE,OAAOK,OAAO;YACd,IAAIN,IAAIC,aAAa,KAAKA,eAAe;gBACvC,OAAOD,IAAIC,aAAa;YAC1B;YACA,MAAMK;QACR;QAEA,IAAI,CAACD,yBAAyBL,IAAIC,aAAa,KAAKA,eAAe;YACjE,OAAOD,IAAIC,aAAa;QAC1B;QACA,OAAO;IACT;IAEA,IAAIA,eAAe;QACjB,sEAAsE;QACtE,OAAO;IACT;IACA,IAAI,OAAOE,QAAQI,EAAE,CAACC,gBAAgB,KAAK,YAAY;QACrD,2BAA2B;QAC3B,MAAMC,uBAAuBN,QAAQI,EAAE,CAACC,gBAAgB;QACxD,MAAME,0BAA0BD;QAEhCT,IAAIC,aAAa,GAAGS;QACpB,IAAIL;QAEJ,IAAI;YACFA,wBAAwB,MAAMI;QAChC,EAAE,OAAOH,OAAO;YACd,IAAIN,IAAIC,aAAa,KAAKS,yBAAyB;gBACjD,OAAOV,IAAIC,aAAa;YAC1B;YACA,MAAMK;QACR;QAEA,IAAI,CAACD,yBAAyBL,IAAIC,aAAa,KAAKS,yBAAyB;YAC3E,OAAOV,IAAIC,aAAa;QAC1B;QAEA,IAAI,CAACI,uBAAuB;YAC1B,OAAO;QACT;QAEA,IAAIL,IAAIC,aAAa,KAAKS,yBAAyB;YACjD,MAAMP,QAAQI,EAAE,CAACI,mBAAmB,CAACN;YAErC,OAAO;QACT;QAEAL,IAAIC,aAAa,GAAGI;QAEpB,OAAO;IACT;IACA,OAAO;AACT"}

package/dist/utilities/isErrorPublic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isErrorPublic.d.ts","sourceRoot":"","sources":["../../src/utilities/isErrorPublic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAOzD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,WAiBlE"}
+{"version":3,"file":"isErrorPublic.d.ts","sourceRoot":"","sources":["../../src/utilities/isErrorPublic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AASzD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,WAiBlE"}

package/dist/utilities/isErrorPublic.js

@@ -1,4 +1,4 @@
-import { status as httpStatus } from 'http-status';
+import { httpStatus } from './httpStatus.js';
 /**
  * Determines if an error should be shown to the user.
  */ export function isErrorPublic(error, config) {

package/dist/utilities/isErrorPublic.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/isErrorPublic.ts"],"sourcesContent":["import { status as httpStatus } from 'http-status'\n\nimport type { SanitizedConfig } from '../config/types.js'\n\ntype PayloadError = {\n  isPublic?: boolean\n  status?: number\n} & Error\n\n/**\n * Determines if an error should be shown to the user.\n */\nexport function isErrorPublic(error: Error, config: SanitizedConfig) {\n  const payloadError = error as PayloadError\n\n  if (config.debug) {\n    return true\n  }\n  if (payloadError.isPublic === true) {\n    return true\n  }\n  if (payloadError.isPublic === false) {\n    return false\n  }\n  if (payloadError.status && payloadError.status !== httpStatus.INTERNAL_SERVER_ERROR) {\n    return true\n  }\n\n  return false\n}\n"],"names":["status","httpStatus","isErrorPublic","error","config","payloadError","debug","isPublic","INTERNAL_SERVER_ERROR"],"mappings":"AAAA,SAASA,UAAUC,UAAU,QAAQ,cAAa;AASlD;;CAEC,GACD,OAAO,SAASC,cAAcC,KAAY,EAAEC,MAAuB;IACjE,MAAMC,eAAeF;IAErB,IAAIC,OAAOE,KAAK,EAAE;QAChB,OAAO;IACT;IACA,IAAID,aAAaE,QAAQ,KAAK,MAAM;QAClC,OAAO;IACT;IACA,IAAIF,aAAaE,QAAQ,KAAK,OAAO;QACnC,OAAO;IACT;IACA,IAAIF,aAAaL,MAAM,IAAIK,aAAaL,MAAM,KAAKC,WAAWO,qBAAqB,EAAE;QACnF,OAAO;IACT;IAEA,OAAO;AACT"}
+{"version":3,"sources":["../../src/utilities/isErrorPublic.ts"],"sourcesContent":["import type { SanitizedConfig } from '../config/types.js'\n\nimport { httpStatus } from './httpStatus.js'\n\ntype PayloadError = {\n  isPublic?: boolean\n  status?: number\n} & Error\n\n/**\n * Determines if an error should be shown to the user.\n */\nexport function isErrorPublic(error: Error, config: SanitizedConfig) {\n  const payloadError = error as PayloadError\n\n  if (config.debug) {\n    return true\n  }\n  if (payloadError.isPublic === true) {\n    return true\n  }\n  if (payloadError.isPublic === false) {\n    return false\n  }\n  if (payloadError.status && payloadError.status !== httpStatus.INTERNAL_SERVER_ERROR) {\n    return true\n  }\n\n  return false\n}\n"],"names":["httpStatus","isErrorPublic","error","config","payloadError","debug","isPublic","status","INTERNAL_SERVER_ERROR"],"mappings":"AAEA,SAASA,UAAU,QAAQ,kBAAiB;AAO5C;;CAEC,GACD,OAAO,SAASC,cAAcC,KAAY,EAAEC,MAAuB;IACjE,MAAMC,eAAeF;IAErB,IAAIC,OAAOE,KAAK,EAAE;QAChB,OAAO;IACT;IACA,IAAID,aAAaE,QAAQ,KAAK,MAAM;QAClC,OAAO;IACT;IACA,IAAIF,aAAaE,QAAQ,KAAK,OAAO;QACnC,OAAO;IACT;IACA,IAAIF,aAAaG,MAAM,IAAIH,aAAaG,MAAM,KAAKP,WAAWQ,qBAAqB,EAAE;QACnF,OAAO;IACT;IAEA,OAAO;AACT"}

package/dist/utilities/isValidationErrorPathLocalized.d.ts

@@ -0,0 +1,20 @@
+import type { Field } from '../fields/config/types.js';
+import type { SanitizedConfig } from '../index.js';
+import type { JsonObject } from '../types/index.js';
+type IsValidationErrorPathLocalizedArgs = {
+    configBlockReferences: SanitizedConfig['blocks'];
+    data: JsonObject;
+    fields: Field[];
+    path: string;
+};
+/**
+ * Reports whether a `ValidationFieldError.path` refers to a localized field by walking `fields`
+ * and `data` together. Used to tell apart a candidate
+ * error that's inherently per-locale from one for a shared, non-localized field that every locale
+ * pass in `runLocaleScopedValidation` re-validates identically. A path that can't be resolved
+ * (unknown field, malformed path) is conservatively treated as localized, since wrongly collapsing
+ * a genuinely per-locale error into one is worse than leaving an occasional duplicate.
+ */
+export declare function isValidationErrorPathLocalized({ configBlockReferences, data, fields, path, }: IsValidationErrorPathLocalizedArgs): boolean;
+export {};
+//# sourceMappingURL=isValidationErrorPathLocalized.d.ts.map

package/dist/utilities/isValidationErrorPathLocalized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isValidationErrorPathLocalized.d.ts","sourceRoot":"","sources":["../../src/utilities/isValidationErrorPathLocalized.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,KAAK,EAAkB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAInD,KAAK,kCAAkC,GAAG;IACxC,qBAAqB,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;IAChD,IAAI,EAAE,UAAU,CAAA;IAChB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,qBAAqB,EACrB,IAAI,EACJ,MAAM,EACN,IAAI,GACL,EAAE,kCAAkC,GAAG,OAAO,CAU9C"}

package/dist/utilities/isValidationErrorPathLocalized.js

@@ -0,0 +1,150 @@
+import { fieldAffectsData, fieldShouldBeLocalized, tabHasName } from '../fields/config/types.js';
+/**
+ * Reports whether a `ValidationFieldError.path` refers to a localized field by walking `fields`
+ * and `data` together. Used to tell apart a candidate
+ * error that's inherently per-locale from one for a shared, non-localized field that every locale
+ * pass in `runLocaleScopedValidation` re-validates identically. A path that can't be resolved
+ * (unknown field, malformed path) is conservatively treated as localized, since wrongly collapsing
+ * a genuinely per-locale error into one is worse than leaving an occasional duplicate.
+ */ export function isValidationErrorPathLocalized({ configBlockReferences, data, fields, path }) {
+    return resolvePathLocalization({
+        configBlockReferences,
+        data,
+        fields,
+        parentIsLocalized: false,
+        segments: path.split('.')
+    }) ?? true;
+}
+/**
+ * Returns `undefined` when `segments[0]` matches no field at this level, so the caller can keep
+ * searching sibling fields (relevant for `row`/`collapsible`/unnamed `tabs`, which don't consume a
+ * path segment themselves).
+ */ function resolvePathLocalization({ configBlockReferences, data, fields, parentIsLocalized, segments }) {
+    const [segment, ...remainingSegments] = segments;
+    if (segment === undefined) {
+        return parentIsLocalized;
+    }
+    if (/^\d+$/.test(segment) && Array.isArray(data)) {
+        return resolvePathLocalization({
+            configBlockReferences,
+            data: data[Number(segment)],
+            fields,
+            parentIsLocalized,
+            segments: remainingSegments
+        });
+    }
+    for (const field of fields){
+        if (fieldAffectsData(field)) {
+            if (field.name !== segment) {
+                continue;
+            }
+            const isLocalized = parentIsLocalized || fieldShouldBeLocalized({
+                field,
+                parentIsLocalized
+            });
+            if (remainingSegments.length === 0) {
+                return isLocalized;
+            }
+            const fieldValue = isObject(data) ? data[segment] : undefined;
+            switch(field.type){
+                case 'array':
+                case 'group':
+                    return resolvePathLocalization({
+                        configBlockReferences,
+                        data: fieldValue,
+                        fields: field.fields,
+                        parentIsLocalized: isLocalized,
+                        segments: remainingSegments
+                    }) ?? isLocalized;
+                case 'blocks':
+                    {
+                        if (!Array.isArray(fieldValue)) {
+                            return isLocalized;
+                        }
+                        const [rowSegment, ...afterRow] = remainingSegments;
+                        const row = rowSegment && /^\d+$/.test(rowSegment) ? fieldValue[Number(rowSegment)] : undefined;
+                        if (!isObject(row)) {
+                            return isLocalized;
+                        }
+                        const blockOrSlug = field.blocks.find((block)=>{
+                            const slug = typeof block === 'string' ? block : block.slug;
+                            return slug === row.blockType;
+                        });
+                        const block = typeof blockOrSlug === 'string' ? configBlockReferences?.find(({ slug })=>slug === blockOrSlug) : blockOrSlug;
+                        if (!block) {
+                            return isLocalized;
+                        }
+                        return resolvePathLocalization({
+                            configBlockReferences,
+                            data: row,
+                            fields: block.fields,
+                            parentIsLocalized: isLocalized,
+                            segments: afterRow
+                        }) ?? isLocalized;
+                    }
+                default:
+                    return isLocalized;
+            }
+        }
+        switch(field.type){
+            case 'collapsible':
+            case 'row':
+                {
+                    const nested = resolvePathLocalization({
+                        configBlockReferences,
+                        data,
+                        fields: field.fields,
+                        parentIsLocalized,
+                        segments
+                    });
+                    if (nested !== undefined) {
+                        return nested;
+                    }
+                    continue;
+                }
+            case 'tabs':
+                {
+                    for (const tab of field.tabs){
+                        if (!tabHasName(tab)) {
+                            const nested = resolvePathLocalization({
+                                configBlockReferences,
+                                data,
+                                fields: tab.fields,
+                                parentIsLocalized,
+                                segments
+                            });
+                            if (nested !== undefined) {
+                                return nested;
+                            }
+                            continue;
+                        }
+                        if (tab.name !== segment) {
+                            continue;
+                        }
+                        const isLocalized = parentIsLocalized || fieldShouldBeLocalized({
+                            field: tab,
+                            parentIsLocalized
+                        });
+                        if (remainingSegments.length === 0) {
+                            return isLocalized;
+                        }
+                        const tabValue = isObject(data) ? data[segment] : undefined;
+                        return resolvePathLocalization({
+                            configBlockReferences,
+                            data: tabValue,
+                            fields: tab.fields,
+                            parentIsLocalized: isLocalized,
+                            segments: remainingSegments
+                        }) ?? isLocalized;
+                    }
+                    continue;
+                }
+        }
+    }
+    return undefined;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+//# sourceMappingURL=isValidationErrorPathLocalized.js.map

package/dist/utilities/isValidationErrorPathLocalized.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/isValidationErrorPathLocalized.ts"],"sourcesContent":["import type { Block, Field, FlattenedBlock } from '../fields/config/types.js'\nimport type { SanitizedConfig } from '../index.js'\nimport type { JsonObject } from '../types/index.js'\n\nimport { fieldAffectsData, fieldShouldBeLocalized, tabHasName } from '../fields/config/types.js'\n\ntype IsValidationErrorPathLocalizedArgs = {\n  configBlockReferences: SanitizedConfig['blocks']\n  data: JsonObject\n  fields: Field[]\n  path: string\n}\n\n/**\n * Reports whether a `ValidationFieldError.path` refers to a localized field by walking `fields`\n * and `data` together. Used to tell apart a candidate\n * error that's inherently per-locale from one for a shared, non-localized field that every locale\n * pass in `runLocaleScopedValidation` re-validates identically. A path that can't be resolved\n * (unknown field, malformed path) is conservatively treated as localized, since wrongly collapsing\n * a genuinely per-locale error into one is worse than leaving an occasional duplicate.\n */\nexport function isValidationErrorPathLocalized({\n  configBlockReferences,\n  data,\n  fields,\n  path,\n}: IsValidationErrorPathLocalizedArgs): boolean {\n  return (\n    resolvePathLocalization({\n      configBlockReferences,\n      data,\n      fields,\n      parentIsLocalized: false,\n      segments: path.split('.'),\n    }) ?? true\n  )\n}\n\ntype ResolvePathLocalizationArgs = {\n  configBlockReferences: SanitizedConfig['blocks']\n  data: unknown\n  fields: Field[]\n  parentIsLocalized: boolean\n  segments: string[]\n}\n\n/**\n * Returns `undefined` when `segments[0]` matches no field at this level, so the caller can keep\n * searching sibling fields (relevant for `row`/`collapsible`/unnamed `tabs`, which don't consume a\n * path segment themselves).\n */\nfunction resolvePathLocalization({\n  configBlockReferences,\n  data,\n  fields,\n  parentIsLocalized,\n  segments,\n}: ResolvePathLocalizationArgs): boolean | undefined {\n  const [segment, ...remainingSegments] = segments\n\n  if (segment === undefined) {\n    return parentIsLocalized\n  }\n\n  if (/^\\d+$/.test(segment) && Array.isArray(data)) {\n    return resolvePathLocalization({\n      configBlockReferences,\n      data: data[Number(segment)],\n      fields,\n      parentIsLocalized,\n      segments: remainingSegments,\n    })\n  }\n\n  for (const field of fields) {\n    if (fieldAffectsData(field)) {\n      if (field.name !== segment) {\n        continue\n      }\n\n      const isLocalized = parentIsLocalized || fieldShouldBeLocalized({ field, parentIsLocalized })\n\n      if (remainingSegments.length === 0) {\n        return isLocalized\n      }\n\n      const fieldValue = isObject(data) ? data[segment] : undefined\n\n      switch (field.type) {\n        case 'array':\n        case 'group':\n          return (\n            resolvePathLocalization({\n              configBlockReferences,\n              data: fieldValue,\n              fields: field.fields,\n              parentIsLocalized: isLocalized,\n              segments: remainingSegments,\n            }) ?? isLocalized\n          )\n\n        case 'blocks': {\n          if (!Array.isArray(fieldValue)) {\n            return isLocalized\n          }\n\n          const [rowSegment, ...afterRow] = remainingSegments\n          const row =\n            rowSegment && /^\\d+$/.test(rowSegment) ? fieldValue[Number(rowSegment)] : undefined\n\n          if (!isObject(row)) {\n            return isLocalized\n          }\n\n          const blockOrSlug = field.blocks.find((block) => {\n            const slug = typeof block === 'string' ? block : block.slug\n            return slug === row.blockType\n          })\n          const block: Block | FlattenedBlock | undefined =\n            typeof blockOrSlug === 'string'\n              ? configBlockReferences?.find(({ slug }) => slug === blockOrSlug)\n              : blockOrSlug\n\n          if (!block) {\n            return isLocalized\n          }\n\n          return (\n            resolvePathLocalization({\n              configBlockReferences,\n              data: row,\n              fields: block.fields,\n              parentIsLocalized: isLocalized,\n              segments: afterRow,\n            }) ?? isLocalized\n          )\n        }\n\n        default:\n          return isLocalized\n      }\n    }\n\n    switch (field.type) {\n      case 'collapsible':\n      case 'row': {\n        const nested = resolvePathLocalization({\n          configBlockReferences,\n          data,\n          fields: field.fields,\n          parentIsLocalized,\n          segments,\n        })\n\n        if (nested !== undefined) {\n          return nested\n        }\n\n        continue\n      }\n\n      case 'tabs': {\n        for (const tab of field.tabs) {\n          if (!tabHasName(tab)) {\n            const nested = resolvePathLocalization({\n              configBlockReferences,\n              data,\n              fields: tab.fields,\n              parentIsLocalized,\n              segments,\n            })\n\n            if (nested !== undefined) {\n              return nested\n            }\n\n            continue\n          }\n\n          if (tab.name !== segment) {\n            continue\n          }\n\n          const isLocalized =\n            parentIsLocalized || fieldShouldBeLocalized({ field: tab, parentIsLocalized })\n\n          if (remainingSegments.length === 0) {\n            return isLocalized\n          }\n\n          const tabValue = isObject(data) ? data[segment] : undefined\n\n          return (\n            resolvePathLocalization({\n              configBlockReferences,\n              data: tabValue,\n              fields: tab.fields,\n              parentIsLocalized: isLocalized,\n              segments: remainingSegments,\n            }) ?? isLocalized\n          )\n        }\n\n        continue\n      }\n    }\n  }\n\n  return undefined\n}\n\nfunction isObject(value: unknown): value is JsonObject {\n  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)\n}\n"],"names":["fieldAffectsData","fieldShouldBeLocalized","tabHasName","isValidationErrorPathLocalized","configBlockReferences","data","fields","path","resolvePathLocalization","parentIsLocalized","segments","split","segment","remainingSegments","undefined","test","Array","isArray","Number","field","name","isLocalized","length","fieldValue","isObject","type","rowSegment","afterRow","row","blockOrSlug","blocks","find","block","slug","blockType","nested","tab","tabs","tabValue","value","Boolean"],"mappings":"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"}

package/dist/utilities/killTransaction.d.ts

@@ -2,6 +2,13 @@ import type { MarkRequired } from 'ts-essentials';
 import type { PayloadRequest } from '../types/index.js';
 /**
  * Rollback the transaction from the req using the db adapter and removes it from the req
+ *
+ * Only call this from an operation that owns the transaction, i.e. one whose own
+ * `initTransaction` call returned `true`. Operations that never open a transaction —
+ * every read operation — must not call this: `req` is shared with the caller, so rolling
+ * back here discards the caller's in-flight writes. If that caller catches the error
+ * (a hook tolerating a missing doc, for example) it goes on to commit a transaction that
+ * no longer exists, and the write is lost with no error surfaced.
  */
 export declare function killTransaction(req: MarkRequired<Partial<PayloadRequest>, 'payload'>): Promise<void>;
 //# sourceMappingURL=killTransaction.d.ts.map

package/dist/utilities/killTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"killTransaction.d.ts","sourceRoot":"","sources":["../../src/utilities/killTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;GAEG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,IAAI,CAAC,CAUf"}
+{"version":3,"file":"killTransaction.d.ts","sourceRoot":"","sources":["../../src/utilities/killTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAUvD;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,YAAY,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,IAAI,CAAC,CA2Bf"}

package/dist/utilities/killTransaction.js

@@ -1,14 +1,52 @@
+import { resetBranchState } from '../branching/resolveBranch.js';
+import { rollbackFileOperations } from '../uploads/fileVersioning/fileOperationManager.js';
+import { clearTransactionCommitCallbacks, clearTransactionRollbackCallbacks, runTransactionRollbackCallbacks } from './transactionCallbacks.js';
 /**
  * Rollback the transaction from the req using the db adapter and removes it from the req
+ *
+ * Only call this from an operation that owns the transaction, i.e. one whose own
+ * `initTransaction` call returned `true`. Operations that never open a transaction —
+ * every read operation — must not call this: `req` is shared with the caller, so rolling
+ * back here discards the caller's in-flight writes. If that caller catches the error
+ * (a hook tolerating a missing doc, for example) it goes on to commit a transaction that
+ * no longer exists, and the write is lost with no error surfaced.
  */ export async function killTransaction(req) {
     const { payload, transactionID } = req;
     if (transactionID && !(transactionID instanceof Promise)) {
+        let didRollBack = false;
         try {
             await payload.db.rollbackTransaction(req.transactionID);
+            didRollBack = true;
+            await rollbackFileOperations({
+                req: req
+            });
         } catch (ignore) {
         // swallow any errors while attempting to rollback
         }
         delete req.transactionID;
+        clearTransactionCommitCallbacks({
+            req,
+            transactionID
+        });
+        if (didRollBack) {
+            try {
+                await runTransactionRollbackCallbacks({
+                    req,
+                    transactionID
+                });
+            } catch (err) {
+                payload.logger.error({
+                    err,
+                    msg: 'A post-rollback callback failed.'
+                });
+            }
+        } else {
+            clearTransactionRollbackCallbacks({
+                req,
+                transactionID
+            });
+        }
+        resetBranchState(req);
     }
 }
 

package/dist/utilities/killTransaction.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/killTransaction.ts"],"sourcesContent":["import type { MarkRequired } from 'ts-essentials'\n\nimport type { PayloadRequest } from '../types/index.js'\n\n/**\n * Rollback the transaction from the req using the db adapter and removes it from the req\n */\nexport async function killTransaction(\n  req: MarkRequired<Partial<PayloadRequest>, 'payload'>,\n): Promise<void> {\n  const { payload, transactionID } = req\n  if (transactionID && !(transactionID instanceof Promise)) {\n    try {\n      await payload.db.rollbackTransaction(req.transactionID!)\n    } catch (ignore) {\n      // swallow any errors while attempting to rollback\n    }\n    delete req.transactionID\n  }\n}\n"],"names":["killTransaction","req","payload","transactionID","Promise","db","rollbackTransaction","ignore"],"mappings":"AAIA;;CAEC,GACD,OAAO,eAAeA,gBACpBC,GAAqD;IAErD,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAE,GAAGF;IACnC,IAAIE,iBAAiB,CAAEA,CAAAA,yBAAyBC,OAAM,GAAI;QACxD,IAAI;YACF,MAAMF,QAAQG,EAAE,CAACC,mBAAmB,CAACL,IAAIE,aAAa;QACxD,EAAE,OAAOI,QAAQ;QACf,kDAAkD;QACpD;QACA,OAAON,IAAIE,aAAa;IAC1B;AACF"}
+{"version":3,"sources":["../../src/utilities/killTransaction.ts"],"sourcesContent":["import type { MarkRequired } from 'ts-essentials'\n\nimport type { PayloadRequest } from '../types/index.js'\n\nimport { resetBranchState } from '../branching/resolveBranch.js'\nimport { rollbackFileOperations } from '../uploads/fileVersioning/fileOperationManager.js'\nimport {\n  clearTransactionCommitCallbacks,\n  clearTransactionRollbackCallbacks,\n  runTransactionRollbackCallbacks,\n} from './transactionCallbacks.js'\n\n/**\n * Rollback the transaction from the req using the db adapter and removes it from the req\n *\n * Only call this from an operation that owns the transaction, i.e. one whose own\n * `initTransaction` call returned `true`. Operations that never open a transaction —\n * every read operation — must not call this: `req` is shared with the caller, so rolling\n * back here discards the caller's in-flight writes. If that caller catches the error\n * (a hook tolerating a missing doc, for example) it goes on to commit a transaction that\n * no longer exists, and the write is lost with no error surfaced.\n */\nexport async function killTransaction(\n  req: MarkRequired<Partial<PayloadRequest>, 'payload'>,\n): Promise<void> {\n  const { payload, transactionID } = req\n  if (transactionID && !(transactionID instanceof Promise)) {\n    let didRollBack = false\n\n    try {\n      await payload.db.rollbackTransaction(req.transactionID!)\n      didRollBack = true\n      await rollbackFileOperations({ req: req as PayloadRequest })\n    } catch (ignore) {\n      // swallow any errors while attempting to rollback\n    }\n    delete req.transactionID\n    clearTransactionCommitCallbacks({ req, transactionID })\n\n    if (didRollBack) {\n      try {\n        await runTransactionRollbackCallbacks({ req, transactionID })\n      } catch (err) {\n        payload.logger.error({ err, msg: 'A post-rollback callback failed.' })\n      }\n    } else {\n      clearTransactionRollbackCallbacks({ req, transactionID })\n    }\n\n    resetBranchState(req as PayloadRequest)\n  }\n}\n"],"names":["resetBranchState","rollbackFileOperations","clearTransactionCommitCallbacks","clearTransactionRollbackCallbacks","runTransactionRollbackCallbacks","killTransaction","req","payload","transactionID","Promise","didRollBack","db","rollbackTransaction","ignore","err","logger","error","msg"],"mappings":"AAIA,SAASA,gBAAgB,QAAQ,gCAA+B;AAChE,SAASC,sBAAsB,QAAQ,oDAAmD;AAC1F,SACEC,+BAA+B,EAC/BC,iCAAiC,EACjCC,+BAA+B,QAC1B,4BAA2B;AAElC;;;;;;;;;CASC,GACD,OAAO,eAAeC,gBACpBC,GAAqD;IAErD,MAAM,EAAEC,OAAO,EAAEC,aAAa,EAAE,GAAGF;IACnC,IAAIE,iBAAiB,CAAEA,CAAAA,yBAAyBC,OAAM,GAAI;QACxD,IAAIC,cAAc;QAElB,IAAI;YACF,MAAMH,QAAQI,EAAE,CAACC,mBAAmB,CAACN,IAAIE,aAAa;YACtDE,cAAc;YACd,MAAMT,uBAAuB;gBAAEK,KAAKA;YAAsB;QAC5D,EAAE,OAAOO,QAAQ;QACf,kDAAkD;QACpD;QACA,OAAOP,IAAIE,aAAa;QACxBN,gCAAgC;YAAEI;YAAKE;QAAc;QAErD,IAAIE,aAAa;YACf,IAAI;gBACF,MAAMN,gCAAgC;oBAAEE;oBAAKE;gBAAc;YAC7D,EAAE,OAAOM,KAAK;gBACZP,QAAQQ,MAAM,CAACC,KAAK,CAAC;oBAAEF;oBAAKG,KAAK;gBAAmC;YACtE;QACF,OAAO;YACLd,kCAAkC;gBAAEG;gBAAKE;YAAc;QACzD;QAEAR,iBAAiBM;IACnB;AACF"}

package/dist/utilities/logError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logError.d.ts","sourceRoot":"","sources":["../../src/utilities/logError.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAEhD,eAAO,MAAM,QAAQ,qBAAsB;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,KAAG,IAyB/E,CAAA"}
+{"version":3,"file":"logError.d.ts","sourceRoot":"","sources":["../../src/utilities/logError.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAEhD,eAAO,MAAM,QAAQ,qBAAsB;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,KAAG,IAuB/E,CAAA"}

package/dist/utilities/logError.js

@@ -1,7 +1,10 @@
 export const logError = ({ err, payload })=>{
     let level = 'error';
-    if (err && typeof err === 'object' && 'name' in err && typeof err.name === 'string' && typeof payload.config.loggingLevels[err.name] !== 'undefined') {
-        level = payload.config.loggingLevels[err.name];
+    if (err && typeof err === 'object' && 'name' in err && typeof err.name === 'string') {
+        const configuredLevel = payload.config.loggingLevels[err.name];
+        if (configuredLevel !== undefined) {
+            level = configuredLevel;
+        }
     }
     if (level) {
         const logObject = {};

package/dist/utilities/logError.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/logError.ts"],"sourcesContent":["import type pino from 'pino'\n\nimport type { Payload } from '../types/index.js'\n\nexport const logError = ({ err, payload }: { err: unknown; payload: Payload }): void => {\n  let level: false | pino.Level = 'error'\n\n  if (\n    err &&\n    typeof err === 'object' &&\n    'name' in err &&\n    typeof err.name === 'string' &&\n    typeof payload.config.loggingLevels[err.name as keyof typeof payload.config.loggingLevels] !==\n      'undefined'\n  ) {\n    level = payload.config.loggingLevels[err.name as keyof typeof payload.config.loggingLevels]\n  }\n\n  if (level) {\n    const logObject: { err?: unknown; msg?: unknown } = {}\n\n    if (level === 'info') {\n      logObject.msg = typeof err === 'object' && 'message' in err! ? err.message : 'Error'\n    } else {\n      logObject.err = err\n    }\n\n    payload.logger[level](logObject)\n  }\n}\n"],"names":["logError","err","payload","level","name","config","loggingLevels","logObject","msg","message","logger"],"mappings":"AAIA,OAAO,MAAMA,WAAW,CAAC,EAAEC,GAAG,EAAEC,OAAO,EAAsC;IAC3E,IAAIC,QAA4B;IAEhC,IACEF,OACA,OAAOA,QAAQ,YACf,UAAUA,OACV,OAAOA,IAAIG,IAAI,KAAK,YACpB,OAAOF,QAAQG,MAAM,CAACC,aAAa,CAACL,IAAIG,IAAI,CAA8C,KACxF,aACF;QACAD,QAAQD,QAAQG,MAAM,CAACC,aAAa,CAACL,IAAIG,IAAI,CAA8C;IAC7F;IAEA,IAAID,OAAO;QACT,MAAMI,YAA8C,CAAC;QAErD,IAAIJ,UAAU,QAAQ;YACpBI,UAAUC,GAAG,GAAG,OAAOP,QAAQ,YAAY,aAAaA,MAAOA,IAAIQ,OAAO,GAAG;QAC/E,OAAO;YACLF,UAAUN,GAAG,GAAGA;QAClB;QAEAC,QAAQQ,MAAM,CAACP,MAAM,CAACI;IACxB;AACF,EAAC"}
+{"version":3,"sources":["../../src/utilities/logError.ts"],"sourcesContent":["import type pino from 'pino'\n\nimport type { Payload } from '../types/index.js'\n\nexport const logError = ({ err, payload }: { err: unknown; payload: Payload }): void => {\n  let level: false | pino.Level = 'error'\n\n  if (err && typeof err === 'object' && 'name' in err && typeof err.name === 'string') {\n    const configuredLevel =\n      payload.config.loggingLevels[err.name as keyof typeof payload.config.loggingLevels]\n\n    if (configuredLevel !== undefined) {\n      level = configuredLevel\n    }\n  }\n\n  if (level) {\n    const logObject: { err?: unknown; msg?: unknown } = {}\n\n    if (level === 'info') {\n      logObject.msg = typeof err === 'object' && 'message' in err! ? err.message : 'Error'\n    } else {\n      logObject.err = err\n    }\n\n    payload.logger[level](logObject)\n  }\n}\n"],"names":["logError","err","payload","level","name","configuredLevel","config","loggingLevels","undefined","logObject","msg","message","logger"],"mappings":"AAIA,OAAO,MAAMA,WAAW,CAAC,EAAEC,GAAG,EAAEC,OAAO,EAAsC;IAC3E,IAAIC,QAA4B;IAEhC,IAAIF,OAAO,OAAOA,QAAQ,YAAY,UAAUA,OAAO,OAAOA,IAAIG,IAAI,KAAK,UAAU;QACnF,MAAMC,kBACJH,QAAQI,MAAM,CAACC,aAAa,CAACN,IAAIG,IAAI,CAA8C;QAErF,IAAIC,oBAAoBG,WAAW;YACjCL,QAAQE;QACV;IACF;IAEA,IAAIF,OAAO;QACT,MAAMM,YAA8C,CAAC;QAErD,IAAIN,UAAU,QAAQ;YACpBM,UAAUC,GAAG,GAAG,OAAOT,QAAQ,YAAY,aAAaA,MAAOA,IAAIU,OAAO,GAAG;QAC/E,OAAO;YACLF,UAAUR,GAAG,GAAGA;QAClB;QAEAC,QAAQU,MAAM,CAACT,MAAM,CAACM;IACxB;AACF,EAAC"}

package/dist/utilities/nextJsDevReloadStrategy.d.ts

@@ -0,0 +1,7 @@
+import type { DevReloadStrategy } from '../admin/adapters/devReload.js';
+/**
+ * Default HMR reload strategy using the Next.js dev HMR WebSocket.
+ * Used as fallback when no custom devReloadStrategy is provided.
+ */
+export declare const defaultNextJsDevReloadStrategy: () => DevReloadStrategy | null;
+//# sourceMappingURL=nextJsDevReloadStrategy.d.ts.map

package/dist/utilities/nextJsDevReloadStrategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextJsDevReloadStrategy.d.ts","sourceRoot":"","sources":["../../src/utilities/nextJsDevReloadStrategy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAmBvE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,QAAO,iBAAiB,GAAG,IAgCrE,CAAA"}

package/dist/utilities/nextJsDevReloadStrategy.js

@@ -0,0 +1,68 @@
+import WebSocket from 'ws';
+import { compareVersions, parseVersion } from './dependencies/versionUtils.js';
+import { getNextVersion } from './getNextVersion.js';
+/** Next.js serves the dev HMR WebSocket on this path from 16.3 onwards. */ const modernHMRPath = '/_next/hmr';
+/**
+ * Next.js served the dev HMR WebSocket on this path before 16.3.
+ *
+ * TODO: Payload requires Next.js 16.4+, so this legacy path, along with `getHMRPath` and
+ * `getNextVersion`, is only kept temporarily so dev config reloading keeps working for projects
+ * that are still migrating from an older Next.js version. It can be removed in the future.
+ */ const legacyHMRPath = '/_next/webpack-hmr';
+const firstModernHMRPathVersion = '16.3.0';
+/**
+ * Default HMR reload strategy using the Next.js dev HMR WebSocket.
+ * Used as fallback when no custom devReloadStrategy is provided.
+ */ export const defaultNextJsDevReloadStrategy = ()=>{
+    try {
+        const url = getHMRURL();
+        return {
+            connect (onReload) {
+                const ws = new WebSocket(url);
+                ws.onmessage = (event)=>{
+                    if (typeof event.data === 'string') {
+                        const data = JSON.parse(event.data);
+                        if (data.type === 'serverComponentChanges' || data.action === 'serverComponentChanges') {
+                            onReload();
+                        }
+                    }
+                };
+                ws.onerror = ()=>{
+                // swallow any websocket connection error
+                };
+                return ()=>{
+                    ws.close();
+                };
+            }
+        };
+    } catch (_) {
+        return null;
+    }
+};
+const getHMRURL = ()=>{
+    if (process.env.PAYLOAD_HMR_URL_OVERRIDE) {
+        return process.env.PAYLOAD_HMR_URL_OVERRIDE;
+    }
+    const port = process.env.PORT || '3000';
+    const hasHTTPS = process.env.USE_HTTPS === 'true' || process.argv.includes('--experimental-https');
+    const protocol = hasHTTPS ? 'wss' : 'ws';
+    /**
+   * Next.js only inlines __NEXT_ASSET_PREFIX into bundled code. In dev, withPayload keeps `payload`
+   * external, so fall back to NEXT_BASE_PATH, which withPayload sets on process.env at runtime.
+   */ const prefix = process.env.__NEXT_ASSET_PREFIX || process.env.NEXT_BASE_PATH || '';
+    return `${protocol}://localhost:${port}${prefix}${getHMRPath()}`;
+};
+/**
+ * Pre-release identifiers are ignored, so that a `16.3.0-canary` build maps to the 16.3 path.
+ * An unreadable version uses the current path, as Payload being unable to resolve Next.js
+ * normally means it is not running under Next.js, where this strategy does not apply.
+ */ const getHMRPath = ()=>{
+    const nextVersion = getNextVersion();
+    if (!nextVersion) {
+        return modernHMRPath;
+    }
+    const mainVersion = parseVersion(nextVersion).parts.join('.');
+    return compareVersions(mainVersion, firstModernHMRPathVersion) === 'lower' ? legacyHMRPath : modernHMRPath;
+};
+
+//# sourceMappingURL=nextJsDevReloadStrategy.js.map

package/dist/utilities/nextJsDevReloadStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/nextJsDevReloadStrategy.ts"],"sourcesContent":["import WebSocket from 'ws'\n\nimport type { DevReloadStrategy } from '../admin/adapters/devReload.js'\n\nimport { compareVersions, parseVersion } from './dependencies/versionUtils.js'\nimport { getNextVersion } from './getNextVersion.js'\n\n/** Next.js serves the dev HMR WebSocket on this path from 16.3 onwards. */\nconst modernHMRPath = '/_next/hmr'\n\n/**\n * Next.js served the dev HMR WebSocket on this path before 16.3.\n *\n * TODO: Payload requires Next.js 16.4+, so this legacy path, along with `getHMRPath` and\n * `getNextVersion`, is only kept temporarily so dev config reloading keeps working for projects\n * that are still migrating from an older Next.js version. It can be removed in the future.\n */\nconst legacyHMRPath = '/_next/webpack-hmr'\n\nconst firstModernHMRPathVersion = '16.3.0'\n\n/**\n * Default HMR reload strategy using the Next.js dev HMR WebSocket.\n * Used as fallback when no custom devReloadStrategy is provided.\n */\nexport const defaultNextJsDevReloadStrategy = (): DevReloadStrategy | null => {\n  try {\n    const url = getHMRURL()\n\n    return {\n      connect(onReload) {\n        const ws = new WebSocket(url)\n\n        ws.onmessage = (event) => {\n          if (typeof event.data === 'string') {\n            const data = JSON.parse(event.data)\n            if (\n              data.type === 'serverComponentChanges' ||\n              data.action === 'serverComponentChanges'\n            ) {\n              onReload()\n            }\n          }\n        }\n\n        ws.onerror = () => {\n          // swallow any websocket connection error\n        }\n\n        return () => {\n          ws.close()\n        }\n      },\n    }\n  } catch (_) {\n    return null\n  }\n}\n\nconst getHMRURL = (): string => {\n  if (process.env.PAYLOAD_HMR_URL_OVERRIDE) {\n    return process.env.PAYLOAD_HMR_URL_OVERRIDE\n  }\n\n  const port = process.env.PORT || '3000'\n  const hasHTTPS = process.env.USE_HTTPS === 'true' || process.argv.includes('--experimental-https')\n  const protocol = hasHTTPS ? 'wss' : 'ws'\n  /**\n   * Next.js only inlines __NEXT_ASSET_PREFIX into bundled code. In dev, withPayload keeps `payload`\n   * external, so fall back to NEXT_BASE_PATH, which withPayload sets on process.env at runtime.\n   */\n  const prefix = process.env.__NEXT_ASSET_PREFIX || process.env.NEXT_BASE_PATH || ''\n\n  return `${protocol}://localhost:${port}${prefix}${getHMRPath()}`\n}\n\n/**\n * Pre-release identifiers are ignored, so that a `16.3.0-canary` build maps to the 16.3 path.\n * An unreadable version uses the current path, as Payload being unable to resolve Next.js\n * normally means it is not running under Next.js, where this strategy does not apply.\n */\nconst getHMRPath = (): string => {\n  const nextVersion = getNextVersion()\n\n  if (!nextVersion) {\n    return modernHMRPath\n  }\n\n  const mainVersion = parseVersion(nextVersion).parts.join('.')\n\n  return compareVersions(mainVersion, firstModernHMRPathVersion) === 'lower'\n    ? legacyHMRPath\n    : modernHMRPath\n}\n"],"names":["WebSocket","compareVersions","parseVersion","getNextVersion","modernHMRPath","legacyHMRPath","firstModernHMRPathVersion","defaultNextJsDevReloadStrategy","url","getHMRURL","connect","onReload","ws","onmessage","event","data","JSON","parse","type","action","onerror","close","_","process","env","PAYLOAD_HMR_URL_OVERRIDE","port","PORT","hasHTTPS","USE_HTTPS","argv","includes","protocol","prefix","__NEXT_ASSET_PREFIX","NEXT_BASE_PATH","getHMRPath","nextVersion","mainVersion","parts","join"],"mappings":"AAAA,OAAOA,eAAe,KAAI;AAI1B,SAASC,eAAe,EAAEC,YAAY,QAAQ,iCAAgC;AAC9E,SAASC,cAAc,QAAQ,sBAAqB;AAEpD,yEAAyE,GACzE,MAAMC,gBAAgB;AAEtB;;;;;;CAMC,GACD,MAAMC,gBAAgB;AAEtB,MAAMC,4BAA4B;AAElC;;;CAGC,GACD,OAAO,MAAMC,iCAAiC;IAC5C,IAAI;QACF,MAAMC,MAAMC;QAEZ,OAAO;YACLC,SAAQC,QAAQ;gBACd,MAAMC,KAAK,IAAIZ,UAAUQ;gBAEzBI,GAAGC,SAAS,GAAG,CAACC;oBACd,IAAI,OAAOA,MAAMC,IAAI,KAAK,UAAU;wBAClC,MAAMA,OAAOC,KAAKC,KAAK,CAACH,MAAMC,IAAI;wBAClC,IACEA,KAAKG,IAAI,KAAK,4BACdH,KAAKI,MAAM,KAAK,0BAChB;4BACAR;wBACF;oBACF;gBACF;gBAEAC,GAAGQ,OAAO,GAAG;gBACX,yCAAyC;gBAC3C;gBAEA,OAAO;oBACLR,GAAGS,KAAK;gBACV;YACF;QACF;IACF,EAAE,OAAOC,GAAG;QACV,OAAO;IACT;AACF,EAAC;AAED,MAAMb,YAAY;IAChB,IAAIc,QAAQC,GAAG,CAACC,wBAAwB,EAAE;QACxC,OAAOF,QAAQC,GAAG,CAACC,wBAAwB;IAC7C;IAEA,MAAMC,OAAOH,QAAQC,GAAG,CAACG,IAAI,IAAI;IACjC,MAAMC,WAAWL,QAAQC,GAAG,CAACK,SAAS,KAAK,UAAUN,QAAQO,IAAI,CAACC,QAAQ,CAAC;IAC3E,MAAMC,WAAWJ,WAAW,QAAQ;IACpC;;;GAGC,GACD,MAAMK,SAASV,QAAQC,GAAG,CAACU,mBAAmB,IAAIX,QAAQC,GAAG,CAACW,cAAc,IAAI;IAEhF,OAAO,GAAGH,SAAS,aAAa,EAAEN,OAAOO,SAASG,cAAc;AAClE;AAEA;;;;CAIC,GACD,MAAMA,aAAa;IACjB,MAAMC,cAAclC;IAEpB,IAAI,CAACkC,aAAa;QAChB,OAAOjC;IACT;IAEA,MAAMkC,cAAcpC,aAAamC,aAAaE,KAAK,CAACC,IAAI,CAAC;IAEzD,OAAOvC,gBAAgBqC,aAAahC,+BAA+B,UAC/DD,gBACAD;AACN"}

package/dist/utilities/parseDocumentID.d.ts

@@ -4,6 +4,9 @@ type ParseDocumentIDArgs = {
     id?: number | string;
     payload: Payload;
 };
-export declare function parseDocumentID({ id, collectionSlug, payload }: ParseDocumentIDArgs): string | number | undefined;
+export declare function parseDocumentID(args: {
+    id: number | string;
+} & ParseDocumentIDArgs): number | string;
+export declare function parseDocumentID(args: ParseDocumentIDArgs): number | string | undefined;
 export {};
 //# sourceMappingURL=parseDocumentID.d.ts.map

package/dist/utilities/parseDocumentID.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseDocumentID.d.ts","sourceRoot":"","sources":["../../src/utilities/parseDocumentID.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAI1D,KAAK,mBAAmB,GAAG;IACzB,cAAc,EAAE,cAAc,CAAA;IAC9B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,EAAE,mBAAmB,+BAInF"}
+{"version":3,"file":"parseDocumentID.d.ts","sourceRoot":"","sources":["../../src/utilities/parseDocumentID.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAI1D,KAAK,mBAAmB,GAAG;IACzB,cAAc,EAAE,cAAc,CAAA;IAC9B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,mBAAmB,GAClD,MAAM,GAAG,MAAM,CAAA;AAClB,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA"}

package/dist/utilities/parseDocumentID.js

@@ -1,7 +1,13 @@
 import { isNumber } from './isNumber.js';
 export function parseDocumentID({ id, collectionSlug, payload }) {
+    if (id === undefined) {
+        return undefined;
+    }
     const idType = payload.collections[collectionSlug]?.customIDType ?? payload.db.defaultIDType;
-    return id ? idType === 'number' && isNumber(id) ? parseFloat(String(id)) : id : undefined;
+    if (idType === 'number') {
+        return isNumber(id) ? parseFloat(String(id)) : id;
+    }
+    return String(id);
 }
 
 //# sourceMappingURL=parseDocumentID.js.map