payload 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

package/dist/branching/resolveBranchRowID.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveBranchRowID.d.ts","sourceRoot":"","sources":["../../src/branching/resolveBranchRowID.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAKvD,KAAK,IAAI,GAAG;IACV,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;CAC9B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,yDAK5B,IAAI,KAAG,OAAO,CAAC,MAAM,GAAG,MAAM,CA6ChC,CAAA"}

package/dist/branching/resolveBranchRowID.js

@@ -0,0 +1,70 @@
+import { peekBranchRowID, rememberBranchRowID, resolveBranch } from './resolveBranch.js';
+import { branchDocIDField, branchField, MAIN_BRANCH } from './types.js';
+/**
+ * Translates a canonical document ID into the primary key of the row that the
+ * active branch should actually write to.
+ *
+ * A canonical ID is the only identity the API exposes: on a branch it addresses
+ * the branch's own copy, on main it addresses the main row. Reads resolve this
+ * through the `where`-tree rewrite; writes cannot, because they address a row
+ * by primary key directly — so they resolve it here instead.
+ *
+ * Returns the ID unchanged on main, when branching is off, or when the branch
+ * has no copy of the document.
+ */ export const resolveBranchRowID = async ({ id, branch: branchOverride, collectionSlug, req })=>{
+    if (branchOverride === false || !req?.payload || id === undefined || id === null) {
+        return id;
+    }
+    if (req.context?._branchBypass) {
+        return id;
+    }
+    const branching = req.payload.config?.branching;
+    if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {
+        return id;
+    }
+    const branch = branchOverride ?? resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        return id;
+    }
+    // The fork that ran moments earlier already resolved this, and a write resolves it again
+    // on the way to the database.
+    const remembered = peekBranchRowID({
+        collectionSlug,
+        docID: id,
+        req
+    });
+    if (remembered !== undefined) {
+        return remembered;
+    }
+    const shadow = await req.payload.db.findOne({
+        branch: false,
+        collection: collectionSlug,
+        req,
+        where: {
+            and: [
+                {
+                    [branchField]: {
+                        equals: branch
+                    }
+                },
+                {
+                    [branchDocIDField]: {
+                        equals: id
+                    }
+                }
+            ]
+        }
+    });
+    const rowID = shadow?.id ?? id;
+    if (shadow) {
+        rememberBranchRowID({
+            collectionSlug,
+            docID: id,
+            req,
+            rowID
+        });
+    }
+    return rowID;
+};
+
+//# sourceMappingURL=resolveBranchRowID.js.map

package/dist/branching/resolveBranchRowID.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/resolveBranchRowID.ts"],"sourcesContent":["import type { PayloadRequest } from '../types/index.js'\n\nimport { peekBranchRowID, rememberBranchRowID, resolveBranch } from './resolveBranch.js'\nimport { branchDocIDField, branchField, MAIN_BRANCH } from './types.js'\n\ntype Args = {\n  branch?: false | string\n  collectionSlug: string\n  id: number | string\n  req?: Partial<PayloadRequest>\n}\n\n/**\n * Translates a canonical document ID into the primary key of the row that the\n * active branch should actually write to.\n *\n * A canonical ID is the only identity the API exposes: on a branch it addresses\n * the branch's own copy, on main it addresses the main row. Reads resolve this\n * through the `where`-tree rewrite; writes cannot, because they address a row\n * by primary key directly — so they resolve it here instead.\n *\n * Returns the ID unchanged on main, when branching is off, or when the branch\n * has no copy of the document.\n */\nexport const resolveBranchRowID = async ({\n  id,\n  branch: branchOverride,\n  collectionSlug,\n  req,\n}: Args): Promise<number | string> => {\n  if (branchOverride === false || !req?.payload || id === undefined || id === null) {\n    return id\n  }\n\n  if ((req.context as Record<string, unknown> | undefined)?._branchBypass) {\n    return id\n  }\n\n  const branching = req.payload.config?.branching\n\n  if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {\n    return id\n  }\n\n  const branch = branchOverride ?? resolveBranch(req as PayloadRequest)\n\n  if (branch === MAIN_BRANCH) {\n    return id\n  }\n\n  // The fork that ran moments earlier already resolved this, and a write resolves it again\n  // on the way to the database.\n  const remembered = peekBranchRowID({ collectionSlug, docID: id, req })\n\n  if (remembered !== undefined) {\n    return remembered\n  }\n\n  const shadow = await req.payload.db.findOne({\n    branch: false,\n    collection: collectionSlug,\n    req,\n    where: {\n      and: [{ [branchField]: { equals: branch } }, { [branchDocIDField]: { equals: id } }],\n    },\n  })\n\n  const rowID = (shadow?.id as number | string) ?? id\n\n  if (shadow) {\n    rememberBranchRowID({ collectionSlug, docID: id, req, rowID })\n  }\n\n  return rowID\n}\n"],"names":["peekBranchRowID","rememberBranchRowID","resolveBranch","branchDocIDField","branchField","MAIN_BRANCH","resolveBranchRowID","id","branch","branchOverride","collectionSlug","req","payload","undefined","context","_branchBypass","branching","config","enabled","branchableCollections","has","remembered","docID","shadow","db","findOne","collection","where","and","equals","rowID"],"mappings":"AAEA,SAASA,eAAe,EAAEC,mBAAmB,EAAEC,aAAa,QAAQ,qBAAoB;AACxF,SAASC,gBAAgB,EAAEC,WAAW,EAAEC,WAAW,QAAQ,aAAY;AASvE;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,qBAAqB,OAAO,EACvCC,EAAE,EACFC,QAAQC,cAAc,EACtBC,cAAc,EACdC,GAAG,EACE;IACL,IAAIF,mBAAmB,SAAS,CAACE,KAAKC,WAAWL,OAAOM,aAAaN,OAAO,MAAM;QAChF,OAAOA;IACT;IAEA,IAAKI,IAAIG,OAAO,EAA0CC,eAAe;QACvE,OAAOR;IACT;IAEA,MAAMS,YAAYL,IAAIC,OAAO,CAACK,MAAM,EAAED;IAEtC,IAAI,CAACA,WAAWE,WAAW,CAACF,UAAUG,qBAAqB,CAACC,GAAG,CAACV,iBAAiB;QAC/E,OAAOH;IACT;IAEA,MAAMC,SAASC,kBAAkBP,cAAcS;IAE/C,IAAIH,WAAWH,aAAa;QAC1B,OAAOE;IACT;IAEA,yFAAyF;IACzF,8BAA8B;IAC9B,MAAMc,aAAarB,gBAAgB;QAAEU;QAAgBY,OAAOf;QAAII;IAAI;IAEpE,IAAIU,eAAeR,WAAW;QAC5B,OAAOQ;IACT;IAEA,MAAME,SAAS,MAAMZ,IAAIC,OAAO,CAACY,EAAE,CAACC,OAAO,CAAC;QAC1CjB,QAAQ;QACRkB,YAAYhB;QACZC;QACAgB,OAAO;YACLC,KAAK;gBAAC;oBAAE,CAACxB,YAAY,EAAE;wBAAEyB,QAAQrB;oBAAO;gBAAE;gBAAG;oBAAE,CAACL,iBAAiB,EAAE;wBAAE0B,QAAQtB;oBAAG;gBAAE;aAAE;QACtF;IACF;IAEA,MAAMuB,QAAQ,AAACP,QAAQhB,MAA0BA;IAEjD,IAAIgB,QAAQ;QACVtB,oBAAoB;YAAES;YAAgBY,OAAOf;YAAII;YAAKmB;QAAM;IAC9D;IAEA,OAAOA;AACT,EAAC"}

package/dist/branching/sanitizeBranchingConfig.d.ts

@@ -0,0 +1,31 @@
+import type { Config } from '../config/types.js';
+import type { SanitizedBranchingConfig } from './types.js';
+/**
+ * Built-in Payload collections. Branching is off for these by default because
+ * none of them hold authored content, but each can opt in with `branching: true`
+ * — except collections that store branch state itself, which cannot be branched
+ * at all (see `hardExcludedSlugs`).
+ */
+export declare const corePayloadCollectionSlugs: readonly ['payload-jobs', 'payload-kv', 'payload-locked-documents', 'payload-migrations', 'payload-preferences', 'payload-query-presets'];
+/**
+ * Branching these is circular: resolving which documents are shadowed on a
+ * branch would require already knowing the active branch in order to read the
+ * registry that answers exactly that question.
+ */
+export declare const hardExcludedSlugs: readonly ["payload-branch-changes", "payload-branches", "payload-branch-merges"];
+/**
+ * Resolves which collections and globals branching is active for.
+ *
+ * Must run during `sanitizeConfig` rather than per-collection sanitization,
+ * and the ordering is load-bearing in both directions:
+ *
+ * - **after** the default-user-collection injection, or an auto-created `users`
+ *   collection is missed;
+ * - **before** the `sanitizeCollection` loop, which performs `_branch` field
+ *   injection and unique-index rewriting and needs the resolved set.
+ *
+ * Plugins have already run by this point (`buildConfig` executes them before
+ * `sanitizeConfig`), so plugin-added auth collections are included.
+ */
+export declare const sanitizeBranchingConfig: (config: Config) => SanitizedBranchingConfig;
+//# sourceMappingURL=sanitizeBranchingConfig.d.ts.map

package/dist/branching/sanitizeBranchingConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeBranchingConfig.d.ts","sourceRoot":"","sources":["../../src/branching/sanitizeBranchingConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAS1D;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,YACrC,cAAc,EACd,YAAY,EACZ,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,CACf,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,kFAIpB,CAAA;AAIV;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,WAAY,MAAM,KAAG,wBAiGxD,CAAA"}

package/dist/branching/sanitizeBranchingConfig.js

@@ -0,0 +1,110 @@
+import { branchChangesCollectionSlug, branchesCollectionSlug, branchMergesCollectionSlug } from './types.js';
+import { defaultBranchMergeValidation } from './validation.js';
+/**
+ * Built-in Payload collections. Branching is off for these by default because
+ * none of them hold authored content, but each can opt in with `branching: true`
+ * — except collections that store branch state itself, which cannot be branched
+ * at all (see `hardExcludedSlugs`).
+ */ export const corePayloadCollectionSlugs = [
+    'payload-jobs',
+    'payload-kv',
+    'payload-locked-documents',
+    'payload-migrations',
+    'payload-preferences',
+    'payload-query-presets'
+];
+/**
+ * Branching these is circular: resolving which documents are shadowed on a
+ * branch would require already knowing the active branch in order to read the
+ * registry that answers exactly that question.
+ */ export const hardExcludedSlugs = [
+    branchChangesCollectionSlug,
+    branchesCollectionSlug,
+    branchMergesCollectionSlug
+];
+const DEFAULT_MAX_SHADOWED_IDS = 2000;
+/**
+ * Resolves which collections and globals branching is active for.
+ *
+ * Must run during `sanitizeConfig` rather than per-collection sanitization,
+ * and the ordering is load-bearing in both directions:
+ *
+ * - **after** the default-user-collection injection, or an auto-created `users`
+ *   collection is missed;
+ * - **before** the `sanitizeCollection` loop, which performs `_branch` field
+ *   injection and unique-index rewriting and needs the resolved set.
+ *
+ * Plugins have already run by this point (`buildConfig` executes them before
+ * `sanitizeConfig`), so plugin-added auth collections are included.
+ */ export const sanitizeBranchingConfig = (config)=>{
+    const incoming = config.branching;
+    const enabled = Boolean(incoming);
+    const branching = typeof incoming === 'object' ? incoming : {};
+    const disabled = {
+        branchableCollections: new Set(),
+        branchableGlobals: new Set(),
+        enabled: false,
+        maxShadowedIDs: branching.maxShadowedIDs ?? DEFAULT_MAX_SHADOWED_IDS,
+        validate: branching.validate ?? defaultBranchMergeValidation
+    };
+    if (!enabled) {
+        return disabled;
+    }
+    const isMultiTenantPluginEnabled = config.plugins?.some((plugin)=>plugin.slug === '@payloadcms/plugin-multi-tenant' && plugin.options?.enabled !== false);
+    if (isMultiTenantPluginEnabled) {
+        console.warn('[Payload] Content branching and @payloadcms/plugin-multi-tenant are enabled together. This combination is not supported and does not provide tenant isolation.');
+    }
+    const explicitlyExcluded = new Set(branching.exclude ?? []);
+    const offByDefault = new Set(corePayloadCollectionSlugs);
+    // The KV collection's slug is configurable, so the literal above only covers
+    // the default. Branching it is meaningless — it is a key-value store, not
+    // content — and actively harmful: its `key` is unique, so the rewrite turns
+    // that into a branch-scoped compound index, and `ensureIndexes` then refuses to
+    // reconcile it against a database that already has the unique one. That fails
+    // at connect time, which takes the whole instance down rather than degrading.
+    const kvCollectionSlug = config.kv?.kvCollection?.slug;
+    if (kvCollectionSlug) {
+        offByDefault.add(kvCollectionSlug);
+    }
+    const branchableCollections = new Set();
+    for (const collection of config.collections ?? []){
+        const { slug } = collection;
+        if (hardExcludedSlugs.includes(slug)) {
+            if (collection.branching === true) {
+                throw new Error(`Collection "${slug}" stores branch state and cannot itself be branched. Remove \`branching: true\` from it.`);
+            }
+            continue;
+        }
+        if (collection.auth) {
+            if (collection.branching === true) {
+                throw new Error(`Collection "${slug}" has authentication enabled and cannot be branched. Remove \`branching: true\` from it.`);
+            }
+            continue;
+        }
+        if (explicitlyExcluded.has(slug) || collection.branching === false) {
+            continue;
+        }
+        if (offByDefault.has(slug) && collection.branching !== true) {
+            continue;
+        }
+        branchableCollections.add(slug);
+    }
+    const branchableGlobals = new Set();
+    for (const global of config.globals ?? []){
+        if (explicitlyExcluded.has(global.slug) || global.branching === false) {
+            continue;
+        }
+        branchableGlobals.add(global.slug);
+    }
+    return {
+        access: branching.access,
+        branchableCollections,
+        branchableGlobals,
+        enabled: true,
+        hooks: branching.hooks,
+        maxShadowedIDs: branching.maxShadowedIDs ?? DEFAULT_MAX_SHADOWED_IDS,
+        validate: branching.validate ?? defaultBranchMergeValidation
+    };
+};
+
+//# sourceMappingURL=sanitizeBranchingConfig.js.map

package/dist/branching/sanitizeBranchingConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/sanitizeBranchingConfig.ts"],"sourcesContent":["import type { Config } from '../config/types.js'\nimport type { SanitizedBranchingConfig } from './types.js'\n\nimport {\n  branchChangesCollectionSlug,\n  branchesCollectionSlug,\n  branchMergesCollectionSlug,\n} from './types.js'\nimport { defaultBranchMergeValidation } from './validation.js'\n\n/**\n * Built-in Payload collections. Branching is off for these by default because\n * none of them hold authored content, but each can opt in with `branching: true`\n * — except collections that store branch state itself, which cannot be branched\n * at all (see `hardExcludedSlugs`).\n */\nexport const corePayloadCollectionSlugs = [\n  'payload-jobs',\n  'payload-kv',\n  'payload-locked-documents',\n  'payload-migrations',\n  'payload-preferences',\n  'payload-query-presets',\n] as const\n\n/**\n * Branching these is circular: resolving which documents are shadowed on a\n * branch would require already knowing the active branch in order to read the\n * registry that answers exactly that question.\n */\nexport const hardExcludedSlugs = [\n  branchChangesCollectionSlug,\n  branchesCollectionSlug,\n  branchMergesCollectionSlug,\n] as const\n\nconst DEFAULT_MAX_SHADOWED_IDS = 2000\n\n/**\n * Resolves which collections and globals branching is active for.\n *\n * Must run during `sanitizeConfig` rather than per-collection sanitization,\n * and the ordering is load-bearing in both directions:\n *\n * - **after** the default-user-collection injection, or an auto-created `users`\n *   collection is missed;\n * - **before** the `sanitizeCollection` loop, which performs `_branch` field\n *   injection and unique-index rewriting and needs the resolved set.\n *\n * Plugins have already run by this point (`buildConfig` executes them before\n * `sanitizeConfig`), so plugin-added auth collections are included.\n */\nexport const sanitizeBranchingConfig = (config: Config): SanitizedBranchingConfig => {\n  const incoming = config.branching\n  const enabled = Boolean(incoming)\n\n  const branching = typeof incoming === 'object' ? incoming : {}\n\n  const disabled: SanitizedBranchingConfig = {\n    branchableCollections: new Set<string>(),\n    branchableGlobals: new Set<string>(),\n    enabled: false,\n    maxShadowedIDs: branching.maxShadowedIDs ?? DEFAULT_MAX_SHADOWED_IDS,\n    validate: branching.validate ?? defaultBranchMergeValidation,\n  }\n\n  if (!enabled) {\n    return disabled\n  }\n\n  const isMultiTenantPluginEnabled = config.plugins?.some(\n    (plugin) =>\n      plugin.slug === '@payloadcms/plugin-multi-tenant' && plugin.options?.enabled !== false,\n  )\n\n  if (isMultiTenantPluginEnabled) {\n    console.warn(\n      '[Payload] Content branching and @payloadcms/plugin-multi-tenant are enabled together. This combination is not supported and does not provide tenant isolation.',\n    )\n  }\n\n  const explicitlyExcluded = new Set<string>(branching.exclude ?? [])\n  const offByDefault = new Set<string>(corePayloadCollectionSlugs)\n\n  // The KV collection's slug is configurable, so the literal above only covers\n  // the default. Branching it is meaningless — it is a key-value store, not\n  // content — and actively harmful: its `key` is unique, so the rewrite turns\n  // that into a branch-scoped compound index, and `ensureIndexes` then refuses to\n  // reconcile it against a database that already has the unique one. That fails\n  // at connect time, which takes the whole instance down rather than degrading.\n  const kvCollectionSlug = config.kv?.kvCollection?.slug\n\n  if (kvCollectionSlug) {\n    offByDefault.add(kvCollectionSlug)\n  }\n\n  const branchableCollections = new Set<string>()\n\n  for (const collection of config.collections ?? []) {\n    const { slug } = collection\n\n    if ((hardExcludedSlugs as readonly string[]).includes(slug)) {\n      if (collection.branching === true) {\n        throw new Error(\n          `Collection \"${slug}\" stores branch state and cannot itself be branched. Remove \\`branching: true\\` from it.`,\n        )\n      }\n      continue\n    }\n\n    if (collection.auth) {\n      if (collection.branching === true) {\n        throw new Error(\n          `Collection \"${slug}\" has authentication enabled and cannot be branched. Remove \\`branching: true\\` from it.`,\n        )\n      }\n      continue\n    }\n\n    if (explicitlyExcluded.has(slug) || collection.branching === false) {\n      continue\n    }\n\n    if (offByDefault.has(slug) && collection.branching !== true) {\n      continue\n    }\n\n    branchableCollections.add(slug)\n  }\n\n  const branchableGlobals = new Set<string>()\n\n  for (const global of config.globals ?? []) {\n    if (explicitlyExcluded.has(global.slug) || global.branching === false) {\n      continue\n    }\n\n    branchableGlobals.add(global.slug)\n  }\n\n  return {\n    access: branching.access,\n    branchableCollections,\n    branchableGlobals,\n    enabled: true,\n    hooks: branching.hooks,\n    maxShadowedIDs: branching.maxShadowedIDs ?? DEFAULT_MAX_SHADOWED_IDS,\n    validate: branching.validate ?? defaultBranchMergeValidation,\n  }\n}\n"],"names":["branchChangesCollectionSlug","branchesCollectionSlug","branchMergesCollectionSlug","defaultBranchMergeValidation","corePayloadCollectionSlugs","hardExcludedSlugs","DEFAULT_MAX_SHADOWED_IDS","sanitizeBranchingConfig","config","incoming","branching","enabled","Boolean","disabled","branchableCollections","Set","branchableGlobals","maxShadowedIDs","validate","isMultiTenantPluginEnabled","plugins","some","plugin","slug","options","console","warn","explicitlyExcluded","exclude","offByDefault","kvCollectionSlug","kv","kvCollection","add","collection","collections","includes","Error","auth","has","global","globals","access","hooks"],"mappings":"AAGA,SACEA,2BAA2B,EAC3BC,sBAAsB,EACtBC,0BAA0B,QACrB,aAAY;AACnB,SAASC,4BAA4B,QAAQ,kBAAiB;AAE9D;;;;;CAKC,GACD,OAAO,MAAMC,6BAA6B;IACxC;IACA;IACA;IACA;IACA;IACA;CACD,CAAS;AAEV;;;;CAIC,GACD,OAAO,MAAMC,oBAAoB;IAC/BL;IACAC;IACAC;CACD,CAAS;AAEV,MAAMI,2BAA2B;AAEjC;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMC,0BAA0B,CAACC;IACtC,MAAMC,WAAWD,OAAOE,SAAS;IACjC,MAAMC,UAAUC,QAAQH;IAExB,MAAMC,YAAY,OAAOD,aAAa,WAAWA,WAAW,CAAC;IAE7D,MAAMI,WAAqC;QACzCC,uBAAuB,IAAIC;QAC3BC,mBAAmB,IAAID;QACvBJ,SAAS;QACTM,gBAAgBP,UAAUO,cAAc,IAAIX;QAC5CY,UAAUR,UAAUQ,QAAQ,IAAIf;IAClC;IAEA,IAAI,CAACQ,SAAS;QACZ,OAAOE;IACT;IAEA,MAAMM,6BAA6BX,OAAOY,OAAO,EAAEC,KACjD,CAACC,SACCA,OAAOC,IAAI,KAAK,qCAAqCD,OAAOE,OAAO,EAAEb,YAAY;IAGrF,IAAIQ,4BAA4B;QAC9BM,QAAQC,IAAI,CACV;IAEJ;IAEA,MAAMC,qBAAqB,IAAIZ,IAAYL,UAAUkB,OAAO,IAAI,EAAE;IAClE,MAAMC,eAAe,IAAId,IAAYX;IAErC,6EAA6E;IAC7E,0EAA0E;IAC1E,4EAA4E;IAC5E,gFAAgF;IAChF,8EAA8E;IAC9E,8EAA8E;IAC9E,MAAM0B,mBAAmBtB,OAAOuB,EAAE,EAAEC,cAAcT;IAElD,IAAIO,kBAAkB;QACpBD,aAAaI,GAAG,CAACH;IACnB;IAEA,MAAMhB,wBAAwB,IAAIC;IAElC,KAAK,MAAMmB,cAAc1B,OAAO2B,WAAW,IAAI,EAAE,CAAE;QACjD,MAAM,EAAEZ,IAAI,EAAE,GAAGW;QAEjB,IAAI,AAAC7B,kBAAwC+B,QAAQ,CAACb,OAAO;YAC3D,IAAIW,WAAWxB,SAAS,KAAK,MAAM;gBACjC,MAAM,IAAI2B,MACR,CAAC,YAAY,EAAEd,KAAK,wFAAwF,CAAC;YAEjH;YACA;QACF;QAEA,IAAIW,WAAWI,IAAI,EAAE;YACnB,IAAIJ,WAAWxB,SAAS,KAAK,MAAM;gBACjC,MAAM,IAAI2B,MACR,CAAC,YAAY,EAAEd,KAAK,wFAAwF,CAAC;YAEjH;YACA;QACF;QAEA,IAAII,mBAAmBY,GAAG,CAAChB,SAASW,WAAWxB,SAAS,KAAK,OAAO;YAClE;QACF;QAEA,IAAImB,aAAaU,GAAG,CAAChB,SAASW,WAAWxB,SAAS,KAAK,MAAM;YAC3D;QACF;QAEAI,sBAAsBmB,GAAG,CAACV;IAC5B;IAEA,MAAMP,oBAAoB,IAAID;IAE9B,KAAK,MAAMyB,UAAUhC,OAAOiC,OAAO,IAAI,EAAE,CAAE;QACzC,IAAId,mBAAmBY,GAAG,CAACC,OAAOjB,IAAI,KAAKiB,OAAO9B,SAAS,KAAK,OAAO;YACrE;QACF;QAEAM,kBAAkBiB,GAAG,CAACO,OAAOjB,IAAI;IACnC;IAEA,OAAO;QACLmB,QAAQhC,UAAUgC,MAAM;QACxB5B;QACAE;QACAL,SAAS;QACTgC,OAAOjC,UAAUiC,KAAK;QACtB1B,gBAAgBP,UAAUO,cAAc,IAAIX;QAC5CY,UAAUR,UAAUQ,QAAQ,IAAIf;IAClC;AACF,EAAC"}

package/dist/branching/schedule/job.d.ts

@@ -0,0 +1,51 @@
+import type { CollectionSlug } from '../../index.js';
+import type { TaskConfig } from '../../queues/config/types/taskTypes.js';
+import type { MergeResult } from '../merge.js';
+export type ScheduleMergeTaskInput = {
+    /** Branch slug. Stored rather than the document ID: the slug is what `_branch` holds. */
+    branch: string;
+    /** Change IDs to apply, or empty to apply whatever is pending when the job fires. */
+    changes?: string[];
+    closeBranch?: boolean;
+    /** The user whose production permissions the merge is checked against. */
+    user?: {
+        relationTo: CollectionSlug;
+        value: number | string;
+    } | number | string;
+};
+type Args = {
+    authCollectionSlugs: string[];
+};
+/**
+ * The `scheduleMerge` task: applies a branch to main at an appointed time.
+ *
+ * Modelled on `schedulePublish`, and identical in shape — a job carrying the intent,
+ * the user who formed it, and a `waitUntil`. Merging raises three questions that
+ * publishing one document does not, and the answers are the substance of this task:
+ *
+ * **Whose permissions?** The queueing user's, re-resolved at fire time and applied
+ * through the ordinary preflight (`overrideAccess: false`). This deliberately differs
+ * from `schedulePublish`, which falls back to `overrideAccess: user === null` when the
+ * user has since been deleted. A merge writes across production, so the same fallback
+ * would turn a deleted account into an unchecked one — the job fails instead, and a
+ * failed job is a signal someone can act on.
+ *
+ * **What if the branch moved?** Queued change IDs that no longer exist are skipped:
+ * `mergeBranch` matches the selection against what is pending, so a discarded or
+ * already-merged change simply does not match. A schedule with no selection applies
+ * whatever is pending when it fires, which is what "merge this branch at 9am" means.
+ *
+ * **What if main moved?** It proceeds. `main-moved` is advisory even interactively —
+ * branch data wins outright (§16) — and failing would leave the branch unmerged with
+ * nobody watching either. The warnings are returned as task output so they remain
+ * inspectable on the job afterwards.
+ */
+export declare const getScheduleMergeTask: ({ authCollectionSlugs, }: Args) => TaskConfig<{
+    input: ScheduleMergeTaskInput;
+    output: {
+        merged: number;
+        warnings: MergeResult['warnings'];
+    };
+}>;
+export {};
+//# sourceMappingURL=job.d.ts.map

package/dist/branching/schedule/job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/branching/schedule/job.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAQ,MAAM,gBAAgB,CAAA;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAA;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAO9C,MAAM,MAAM,sBAAsB,GAAG;IACnC,yFAAyF;IACzF,MAAM,EAAE,MAAM,CAAA;IACd,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,0EAA0E;IAC1E,IAAI,CAAC,EACD;QACE,UAAU,EAAE,cAAc,CAAA;QAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;KACvB,GACD,MAAM,GACN,MAAM,CAAA;CACX,CAAA;AAED,KAAK,IAAI,GAAG;IACV,mBAAmB,EAAE,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,oBAAoB,6BAE9B,IAAI,KAAG,UAAU,CAAC;IACnB,KAAK,EAAE,sBAAsB,CAAA;IAC7B,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,CAAA;KAAE,CAAA;CAC9D,CA6HC,CAAA"}

package/dist/branching/schedule/job.js

@@ -0,0 +1,151 @@
+import { isolateObjectProperty } from '../../utilities/isolateObjectProperty.js';
+import { createIsolatedDeferredCleanupContext } from '../../utilities/transactionCallbacks.js';
+import { mergeBranch } from '../merge.js';
+import { branchesCollectionSlug } from '../types.js';
+/**
+ * The `scheduleMerge` task: applies a branch to main at an appointed time.
+ *
+ * Modelled on `schedulePublish`, and identical in shape — a job carrying the intent,
+ * the user who formed it, and a `waitUntil`. Merging raises three questions that
+ * publishing one document does not, and the answers are the substance of this task:
+ *
+ * **Whose permissions?** The queueing user's, re-resolved at fire time and applied
+ * through the ordinary preflight (`overrideAccess: false`). This deliberately differs
+ * from `schedulePublish`, which falls back to `overrideAccess: user === null` when the
+ * user has since been deleted. A merge writes across production, so the same fallback
+ * would turn a deleted account into an unchecked one — the job fails instead, and a
+ * failed job is a signal someone can act on.
+ *
+ * **What if the branch moved?** Queued change IDs that no longer exist are skipped:
+ * `mergeBranch` matches the selection against what is pending, so a discarded or
+ * already-merged change simply does not match. A schedule with no selection applies
+ * whatever is pending when it fires, which is what "merge this branch at 9am" means.
+ *
+ * **What if main moved?** It proceeds. `main-moved` is advisory even interactively —
+ * branch data wins outright (§16) — and failing would leave the branch unmerged with
+ * nobody watching either. The warnings are returned as task output so they remain
+ * inspectable on the job afterwards.
+ */ export const getScheduleMergeTask = ({ authCollectionSlugs })=>({
+        slug: 'scheduleMerge',
+        handler: async ({ input, req })=>{
+            let user = null;
+            if (input.user != null) {
+                if (typeof input.user !== 'object') {
+                    throw new Error(`Scheduled merge of branch "${input.branch}" is missing the scheduling user auth collection and cannot run.`);
+                }
+                if (typeof input.user.relationTo !== 'string' || !authCollectionSlugs.includes(input.user.relationTo) || typeof input.user.value !== 'number' && typeof input.user.value !== 'string') {
+                    throw new Error(`Scheduled merge of branch "${input.branch}" has an invalid scheduling user relationship and cannot run.`);
+                }
+                user = await req.payload.findByID({
+                    id: input.user.value,
+                    collection: input.user.relationTo,
+                    depth: 0,
+                    disableErrors: true,
+                    overrideAccess: true,
+                    req
+                });
+                if (user) {
+                    user.collection = input.user.relationTo;
+                }
+            }
+            if (!user) {
+                throw new Error(`Scheduled merge of branch "${input.branch}" has no resolvable user, so its permissions cannot be checked. Re-schedule it as a current user.`);
+            }
+            const branchDoc = (await req.payload.find({
+                collection: branchesCollectionSlug,
+                depth: 0,
+                limit: 1,
+                overrideAccess: true,
+                pagination: false,
+                req,
+                where: {
+                    slug: {
+                        equals: input.branch
+                    }
+                }
+            })).docs[0];
+            const progressReq = isolateObjectProperty(req, [
+                'context',
+                'transactionID'
+            ]);
+            progressReq.context = createIsolatedDeferredCleanupContext({
+                req
+            });
+            delete progressReq.transactionID;
+            const writeProgress = async ({ mergeProgress })=>{
+                if (branchDoc) {
+                    await req.payload.update({
+                        id: branchDoc.id,
+                        collection: branchesCollectionSlug,
+                        data: {
+                            mergeProgress
+                        },
+                        depth: 0,
+                        overrideAccess: true,
+                        req: progressReq
+                    });
+                }
+            };
+            await writeProgress({
+                mergeProgress: 'running'
+            });
+            let result;
+            try {
+                result = await mergeBranch(req.payload, {
+                    branch: input.branch,
+                    changes: input.changes?.length ? input.changes : undefined,
+                    closeBranch: Boolean(input.closeBranch),
+                    overrideAccess: false,
+                    req,
+                    user
+                });
+            } catch (error) {
+                try {
+                    await writeProgress({
+                        mergeProgress: null
+                    });
+                } catch (err) {
+                    req.payload.logger.error({
+                        err,
+                        msg: 'Failed to clear scheduled merge progress.'
+                    });
+                }
+                throw error;
+            }
+            // Cleared after a successful merge too: a stale "running" outlives the run and reads as a
+            // merge still in flight. A cleanup failure now fails the job because there is no primary merge
+            // error to preserve.
+            await writeProgress({
+                mergeProgress: null
+            });
+            return {
+                output: {
+                    merged: result.merged.length,
+                    warnings: result.warnings
+                }
+            };
+        },
+        inputSchema: [
+            {
+                name: 'branch',
+                type: 'text',
+                required: true
+            },
+            {
+                name: 'changes',
+                type: 'text',
+                hasMany: true
+            },
+            {
+                name: 'closeBranch',
+                type: 'checkbox'
+            },
+            {
+                name: 'user',
+                type: 'relationship',
+                relationTo: authCollectionSlugs
+            }
+        ]
+    });
+
+//# sourceMappingURL=job.js.map

package/dist/branching/schedule/job.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/branching/schedule/job.ts"],"sourcesContent":["import type { CollectionSlug, User } from '../../index.js'\nimport type { TaskConfig } from '../../queues/config/types/taskTypes.js'\nimport type { MergeResult } from '../merge.js'\n\nimport { isolateObjectProperty } from '../../utilities/isolateObjectProperty.js'\nimport { createIsolatedDeferredCleanupContext } from '../../utilities/transactionCallbacks.js'\nimport { mergeBranch } from '../merge.js'\nimport { branchesCollectionSlug } from '../types.js'\n\nexport type ScheduleMergeTaskInput = {\n  /** Branch slug. Stored rather than the document ID: the slug is what `_branch` holds. */\n  branch: string\n  /** Change IDs to apply, or empty to apply whatever is pending when the job fires. */\n  changes?: string[]\n  closeBranch?: boolean\n  /** The user whose production permissions the merge is checked against. */\n  user?:\n    | {\n        relationTo: CollectionSlug\n        value: number | string\n      }\n    | number\n    | string\n}\n\ntype Args = {\n  authCollectionSlugs: string[]\n}\n\n/**\n * The `scheduleMerge` task: applies a branch to main at an appointed time.\n *\n * Modelled on `schedulePublish`, and identical in shape — a job carrying the intent,\n * the user who formed it, and a `waitUntil`. Merging raises three questions that\n * publishing one document does not, and the answers are the substance of this task:\n *\n * **Whose permissions?** The queueing user's, re-resolved at fire time and applied\n * through the ordinary preflight (`overrideAccess: false`). This deliberately differs\n * from `schedulePublish`, which falls back to `overrideAccess: user === null` when the\n * user has since been deleted. A merge writes across production, so the same fallback\n * would turn a deleted account into an unchecked one — the job fails instead, and a\n * failed job is a signal someone can act on.\n *\n * **What if the branch moved?** Queued change IDs that no longer exist are skipped:\n * `mergeBranch` matches the selection against what is pending, so a discarded or\n * already-merged change simply does not match. A schedule with no selection applies\n * whatever is pending when it fires, which is what \"merge this branch at 9am\" means.\n *\n * **What if main moved?** It proceeds. `main-moved` is advisory even interactively —\n * branch data wins outright (§16) — and failing would leave the branch unmerged with\n * nobody watching either. The warnings are returned as task output so they remain\n * inspectable on the job afterwards.\n */\nexport const getScheduleMergeTask = ({\n  authCollectionSlugs,\n}: Args): TaskConfig<{\n  input: ScheduleMergeTaskInput\n  output: { merged: number; warnings: MergeResult['warnings'] }\n}> => ({\n  slug: 'scheduleMerge',\n  handler: async ({ input, req }) => {\n    let user: null | User = null\n\n    if (input.user != null) {\n      if (typeof input.user !== 'object') {\n        throw new Error(\n          `Scheduled merge of branch \"${input.branch}\" is missing the scheduling user auth collection and cannot run.`,\n        )\n      }\n\n      if (\n        typeof input.user.relationTo !== 'string' ||\n        !authCollectionSlugs.includes(input.user.relationTo) ||\n        (typeof input.user.value !== 'number' && typeof input.user.value !== 'string')\n      ) {\n        throw new Error(\n          `Scheduled merge of branch \"${input.branch}\" has an invalid scheduling user relationship and cannot run.`,\n        )\n      }\n\n      user = (await req.payload.findByID({\n        id: input.user.value,\n        collection: input.user.relationTo,\n        depth: 0,\n        disableErrors: true,\n        overrideAccess: true,\n        req,\n      })) as null | User\n\n      if (user) {\n        user.collection = input.user.relationTo\n      }\n    }\n\n    if (!user) {\n      throw new Error(\n        `Scheduled merge of branch \"${input.branch}\" has no resolvable user, so its permissions cannot be checked. Re-schedule it as a current user.`,\n      )\n    }\n\n    const branchDoc = (\n      await req.payload.find({\n        collection: branchesCollectionSlug,\n        depth: 0,\n        limit: 1,\n        overrideAccess: true,\n        pagination: false,\n        req,\n        where: { slug: { equals: input.branch } },\n      })\n    ).docs[0]\n\n    const progressReq = isolateObjectProperty(req, ['context', 'transactionID'])\n\n    progressReq.context = createIsolatedDeferredCleanupContext({ req })\n    delete progressReq.transactionID\n\n    const writeProgress = async ({ mergeProgress }: { mergeProgress: null | string }) => {\n      if (branchDoc) {\n        await req.payload.update({\n          id: branchDoc.id,\n          collection: branchesCollectionSlug,\n          data: { mergeProgress },\n          depth: 0,\n          overrideAccess: true,\n          req: progressReq,\n        })\n      }\n    }\n\n    await writeProgress({ mergeProgress: 'running' })\n\n    let result: MergeResult\n\n    try {\n      result = await mergeBranch(req.payload, {\n        branch: input.branch,\n        changes: input.changes?.length ? input.changes : undefined,\n        closeBranch: Boolean(input.closeBranch),\n        overrideAccess: false,\n        req,\n        user,\n      })\n    } catch (error) {\n      try {\n        await writeProgress({ mergeProgress: null })\n      } catch (err) {\n        req.payload.logger.error({ err, msg: 'Failed to clear scheduled merge progress.' })\n      }\n\n      throw error\n    }\n\n    // Cleared after a successful merge too: a stale \"running\" outlives the run and reads as a\n    // merge still in flight. A cleanup failure now fails the job because there is no primary merge\n    // error to preserve.\n    await writeProgress({ mergeProgress: null })\n\n    return {\n      output: { merged: result.merged.length, warnings: result.warnings },\n    }\n  },\n  inputSchema: [\n    {\n      name: 'branch',\n      type: 'text',\n      required: true,\n    },\n    {\n      name: 'changes',\n      type: 'text',\n      hasMany: true,\n    },\n    {\n      name: 'closeBranch',\n      type: 'checkbox',\n    },\n    {\n      name: 'user',\n      type: 'relationship',\n      relationTo: authCollectionSlugs,\n    },\n  ],\n})\n"],"names":["isolateObjectProperty","createIsolatedDeferredCleanupContext","mergeBranch","branchesCollectionSlug","getScheduleMergeTask","authCollectionSlugs","slug","handler","input","req","user","Error","branch","relationTo","includes","value","payload","findByID","id","collection","depth","disableErrors","overrideAccess","branchDoc","find","limit","pagination","where","equals","docs","progressReq","context","transactionID","writeProgress","mergeProgress","update","data","result","changes","length","undefined","closeBranch","Boolean","error","err","logger","msg","output","merged","warnings","inputSchema","name","type","required","hasMany"],"mappings":"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"}

package/dist/branching/selectBranchChanges.d.ts

@@ -0,0 +1,8 @@
+export declare const selectBranchChanges: <Change extends {
+    id: number | string;
+}>({ changes, excluded, selected, }: {
+    changes: Change[];
+    excluded?: ReadonlySet<string>;
+    selected?: (number | string)[];
+}) => Change[];
+//# sourceMappingURL=selectBranchChanges.d.ts.map

package/dist/branching/selectBranchChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectBranchChanges.d.ts","sourceRoot":"","sources":["../../src/branching/selectBranchChanges.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,GAAI,MAAM,SAAS;IAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,oCAIvE;IACD,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC9B,QAAQ,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;CAC/B,KAAG,MAAM,EAQT,CAAA"}

package/dist/branching/selectBranchChanges.js

@@ -0,0 +1,9 @@
+export const selectBranchChanges = ({ changes, excluded, selected })=>{
+    const selectedIDs = selected ? new Set(selected.map(String)) : undefined;
+    return changes.filter((change)=>{
+        const changeID = String(change.id);
+        return !excluded?.has(changeID) && (!selectedIDs || selectedIDs.has(changeID));
+    });
+};
+
+//# sourceMappingURL=selectBranchChanges.js.map

package/dist/branching/selectBranchChanges.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/selectBranchChanges.ts"],"sourcesContent":["export const selectBranchChanges = <Change extends { id: number | string }>({\n  changes,\n  excluded,\n  selected,\n}: {\n  changes: Change[]\n  excluded?: ReadonlySet<string>\n  selected?: (number | string)[]\n}): Change[] => {\n  const selectedIDs = selected ? new Set(selected.map(String)) : undefined\n\n  return changes.filter((change) => {\n    const changeID = String(change.id)\n\n    return !excluded?.has(changeID) && (!selectedIDs || selectedIDs.has(changeID))\n  })\n}\n"],"names":["selectBranchChanges","changes","excluded","selected","selectedIDs","Set","map","String","undefined","filter","change","changeID","id","has"],"mappings":"AAAA,OAAO,MAAMA,sBAAsB,CAAyC,EAC1EC,OAAO,EACPC,QAAQ,EACRC,QAAQ,EAKT;IACC,MAAMC,cAAcD,WAAW,IAAIE,IAAIF,SAASG,GAAG,CAACC,WAAWC;IAE/D,OAAOP,QAAQQ,MAAM,CAAC,CAACC;QACrB,MAAMC,WAAWJ,OAAOG,OAAOE,EAAE;QAEjC,OAAO,CAACV,UAAUW,IAAIF,aAAc,CAAA,CAACP,eAAeA,YAAYS,GAAG,CAACF,SAAQ;IAC9E;AACF,EAAC"}

package/dist/branching/stripBranchMergeData.d.ts

@@ -0,0 +1,11 @@
+import type { Field } from '../fields/config/types.js';
+import type { JsonObject } from '../types/index.js';
+type Args = {
+    data: Record<string, unknown>;
+    fields: Field[];
+};
+/** Removes values that Payload, rather than a content author, owns during a merge write. */
+export declare const stripBranchMergeData: ({ data, fields }: Args) => JsonObject;
+export declare const stripBranchMergeGlobalData: ({ data, fields }: Args) => JsonObject;
+export {};
+//# sourceMappingURL=stripBranchMergeData.d.ts.map

package/dist/branching/stripBranchMergeData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripBranchMergeData.d.ts","sourceRoot":"","sources":["../../src/branching/stripBranchMergeData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAKnD,KAAK,IAAI,GAAG;IACV,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB,CAAA;AAED,4FAA4F;AAC5F,eAAO,MAAM,oBAAoB,qBAAsB,IAAI,KAAG,UAiB7D,CAAA;AAED,eAAO,MAAM,0BAA0B,qBAAsB,IAAI,KAAG,UAInE,CAAA"}

package/dist/branching/stripBranchMergeData.js

@@ -0,0 +1,20 @@
+import { isManagedAuthorshipField } from '../fields/baseFields/authorship/index.js';
+import { branchDocIDField, branchField } from './types.js';
+/** Removes values that Payload, rather than a content author, owns during a merge write. */ export const stripBranchMergeData = ({ data, fields })=>{
+    const { id: _id, [branchDocIDField]: _docID, [branchField]: _branch, createdAt: _createdAt, updatedAt: _updatedAt, ...mergeData } = data;
+    for (const field of fields){
+        if (isManagedAuthorshipField(field)) {
+            delete mergeData[field.name];
+        }
+    }
+    return mergeData;
+};
+export const stripBranchMergeGlobalData = ({ data, fields })=>{
+    const { globalType: _globalType, ...globalData } = data;
+    return stripBranchMergeData({
+        data: globalData,
+        fields
+    });
+};
+
+//# sourceMappingURL=stripBranchMergeData.js.map

package/dist/branching/stripBranchMergeData.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/stripBranchMergeData.ts"],"sourcesContent":["import type { Field } from '../fields/config/types.js'\nimport type { JsonObject } from '../types/index.js'\n\nimport { isManagedAuthorshipField } from '../fields/baseFields/authorship/index.js'\nimport { branchDocIDField, branchField } from './types.js'\n\ntype Args = {\n  data: Record<string, unknown>\n  fields: Field[]\n}\n\n/** Removes values that Payload, rather than a content author, owns during a merge write. */\nexport const stripBranchMergeData = ({ data, fields }: Args): JsonObject => {\n  const {\n    id: _id,\n    [branchDocIDField]: _docID,\n    [branchField]: _branch,\n    createdAt: _createdAt,\n    updatedAt: _updatedAt,\n    ...mergeData\n  } = data\n\n  for (const field of fields) {\n    if (isManagedAuthorshipField(field)) {\n      delete mergeData[field.name]\n    }\n  }\n\n  return mergeData as JsonObject\n}\n\nexport const stripBranchMergeGlobalData = ({ data, fields }: Args): JsonObject => {\n  const { globalType: _globalType, ...globalData } = data\n\n  return stripBranchMergeData({ data: globalData, fields })\n}\n"],"names":["isManagedAuthorshipField","branchDocIDField","branchField","stripBranchMergeData","data","fields","id","_id","_docID","_branch","createdAt","_createdAt","updatedAt","_updatedAt","mergeData","field","name","stripBranchMergeGlobalData","globalType","_globalType","globalData"],"mappings":"AAGA,SAASA,wBAAwB,QAAQ,2CAA0C;AACnF,SAASC,gBAAgB,EAAEC,WAAW,QAAQ,aAAY;AAO1D,0FAA0F,GAC1F,OAAO,MAAMC,uBAAuB,CAAC,EAAEC,IAAI,EAAEC,MAAM,EAAQ;IACzD,MAAM,EACJC,IAAIC,GAAG,EACP,CAACN,iBAAiB,EAAEO,MAAM,EAC1B,CAACN,YAAY,EAAEO,OAAO,EACtBC,WAAWC,UAAU,EACrBC,WAAWC,UAAU,EACrB,GAAGC,WACJ,GAAGV;IAEJ,KAAK,MAAMW,SAASV,OAAQ;QAC1B,IAAIL,yBAAyBe,QAAQ;YACnC,OAAOD,SAAS,CAACC,MAAMC,IAAI,CAAC;QAC9B;IACF;IAEA,OAAOF;AACT,EAAC;AAED,OAAO,MAAMG,6BAA6B,CAAC,EAAEb,IAAI,EAAEC,MAAM,EAAQ;IAC/D,MAAM,EAAEa,YAAYC,WAAW,EAAE,GAAGC,YAAY,GAAGhB;IAEnD,OAAOD,qBAAqB;QAAEC,MAAMgB;QAAYf;IAAO;AACzD,EAAC"}

package/dist/branching/tombstone.d.ts

@@ -0,0 +1,91 @@
+import type { PayloadRequest, Where } from '../types/index.js';
+type Args = {
+    branch?: false | string;
+    collectionSlug: string;
+    req?: Partial<PayloadRequest>;
+    where: undefined | Where;
+};
+type ConcurrentBranchDelete = {
+    branch: string;
+    collectionSlug: string;
+    doc: Record<string, unknown>;
+    docID: number | string;
+    retryError: unknown;
+    winnerID: number | string;
+};
+export type BranchDeleteOutcome = {
+    doc: Record<string, unknown>;
+    tombstoned: boolean;
+};
+type BranchDeleteOperation = {
+    branch: string;
+    collectionSlug: string;
+    docID: number | string;
+    isTombstoneExpected: boolean;
+    onResolved: (outcome: BranchDeleteOutcome) => void;
+    useAmbientTransaction: boolean;
+};
+type Result = {
+    /** Narrows the caller's delete to this row's primary key. */
+    deleteRowID?: number | string;
+    /** The document to report as deleted, when the delete was absorbed. */
+    doc?: Record<string, unknown>;
+    /** True when the delete became a tombstone and must not proceed. */
+    tombstoned: boolean;
+};
+export declare const setConcurrentBranchDelete: ({ branch, collectionSlug, doc, docID, req, retryError, winnerID, }: {
+    req: PayloadRequest;
+} & ConcurrentBranchDelete) => void;
+export declare const setBranchDeleteOperation: ({ branch, collectionSlug, docID, isTombstoneExpected, onResolved, req, useAmbientTransaction, }: {
+    req: PayloadRequest;
+} & BranchDeleteOperation) => void;
+export declare const requireBranchDeleteOutcome: ({ outcome, }: {
+    outcome: BranchDeleteOutcome | undefined;
+}) => BranchDeleteOutcome;
+export declare const assertBranchDeleteCanUseCallerTransaction: ({ branch, collectionSlug, docID, req, }: {
+    branch: string;
+    collectionSlug: string;
+    docID: number | string;
+    req: PayloadRequest;
+}) => Promise<void>;
+/**
+ * Checks a branch-created document before delete hooks and cascades can cause
+ * effects that a database rollback cannot restore.
+ */
+export declare const assertBranchCreatedDeleteUnreferenced: ({ branch: branchOverride, collectionSlug, doc, req, }: {
+    branch?: false | string;
+    collectionSlug: string;
+    doc: null | Record<string, unknown> | undefined;
+    req?: Partial<PayloadRequest>;
+}) => Promise<null | Record<string, unknown>>;
+/**
+ * Whether a delete will be absorbed into a tombstone rather than removing a row.
+ *
+ * `deleteByID` runs its cascades — associated files, scheduled publish jobs —
+ * before `db.deleteOne` decides this, and each of them addresses the canonical
+ * document. On a branch that means reaching into main: deleting an upload on a
+ * branch unlinks main's file while main keeps the row that points at it.
+ *
+ * Answered from the document already fetched for the delete, so it costs no extra
+ * read. A document created on the branch is exempt — nothing of main's stands
+ * behind it, so its side effects are its own to clean up.
+ */
+export declare const willBranchAbsorbDelete: ({ collectionSlug, doc, req, }: {
+    branch?: false | string;
+    collectionSlug: string;
+    doc: null | Record<string, unknown> | undefined;
+    req?: Partial<PayloadRequest>;
+}) => Promise<boolean>;
+/**
+ * Turns a delete on a branch into a tombstone against main.
+ *
+ * A branch cannot delete production content, so deleting a main document from
+ * a branch records the intent in its authoritative change record. The read
+ * predicate hides the matching canonical ID on that branch and nowhere else.
+ *
+ * A document created on the branch has no main row behind it, so it is deleted
+ * outright — nothing is left to hide.
+ */
+export declare const resolveBranchDelete: ({ branch: branchOverride, collectionSlug, req, where, }: Args) => Promise<Result>;
+export {};
+//# sourceMappingURL=tombstone.d.ts.map