@teambit/ci 1.0.507 → 1.0.508

package/dist/sync/sync-planner.spec.js.map

@@ -1 +1 @@
-{"version":3,"names":["_chai","data","require","_syncPlanner","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","base","laneHead","branchExists","lastSyncedHead","hasDevCommits","tipIsSyncCommit","conflictLabelPresent","ownership","laneGone","undefined","table","name","input","type","reason","action","deleteBranch","keepReason","hasIndependentHistory","branchNamesDifferentLane","describe","it","result","planLaneSync","expect","to","equal","deep","contain"],"sources":["sync-planner.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport type { LaneOwnershipEvidence, LaneSyncAction, LaneSyncInput } from './sync-planner';\nimport { planLaneSync } from './sync-planner';\n\nconst base: LaneSyncInput = {\n  laneHead: 'L1',\n  branchExists: true,\n  lastSyncedHead: 'L1',\n  hasDevCommits: false,\n  tipIsSyncCommit: true,\n  conflictLabelPresent: false,\n  ownership: 'own-live',\n};\n\n/** the \"lane deleted remotely, branch still there\" shape — the only path that reads `ownership` */\nconst laneGone = (ownership: LaneOwnershipEvidence) => ({ laneHead: undefined, ownership });\n\n/**\n * The decision table. `action` (exact) is required on every row that decides a branch deletion: under\n * the defaults an ordinary developer branch reaches the planner in the same shape as a deleted lane's\n * branch, so `deleteBranch` and the keep reason are part of the contract, not incidental output.\n */\nconst table: Array<{\n  name: string;\n  input: Partial<LaneSyncInput>;\n  type: LaneSyncAction['type'];\n  action?: LaneSyncAction;\n  reason?: string;\n}> = [\n  { name: 'converged -> noop', input: {}, type: 'noop', reason: 'converged' },\n  {\n    name: 'conflict label present -> noop until resolved',\n    input: { laneHead: 'L2', conflictLabelPresent: true },\n    type: 'noop',\n  },\n  { name: 'lane gone + no branch -> noop', input: { laneHead: undefined, branchExists: false }, type: 'noop' },\n\n  {\n    name: \"own-live, no dev commits, OUR tip (the branch is exactly the lane's mirror) -> close-pr AND delete\",\n    input: laneGone('own-live'),\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    // A developer who commits their own `.bitmap` write looks own-live with nothing above the state\n    // commit; the marker is what separates our mirror from their branch.\n    name: 'own-live, no dev commits, a tip WE DID NOT WRITE -> close-pr but KEEP the branch',\n    input: { ...laneGone('own-live'), tipIsSyncCommit: false },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'tip-not-a-sync-commit' },\n  },\n  {\n    name: 'own-live WITH dev commits (never-exported work above the state commit) -> KEEP the branch',\n    input: { ...laneGone('own-live'), hasDevCommits: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' },\n  },\n  {\n    // \"tip-not-a-sync-commit\" would send the reader after the wrong thing when there is real work.\n    name: 'own-live with dev commits AND a foreign tip -> keeps, naming the commits as the reason',\n    input: { ...laneGone('own-live'), hasDevCommits: true, tipIsSyncCommit: false },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' },\n  },\n  {\n    // Adoption proved content matched, never that the branch's pre-existing history is disposable.\n    name: 'own-live, no dev commits, OUR tip, but it is the adoption ledger commit -> KEEP, never delete',\n    input: { ...laneGone('own-live'), hasIndependentHistory: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'adopted-branch' },\n  },\n  {\n    name: 'own-merged (branch tip already in the default branch) -> close-pr AND delete',\n    input: laneGone('own-merged'),\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    // Reachability alone proves deleting loses nothing, so no marker conjunction applies here.\n    name: 'own-merged deletes even with a foreign tip and dev commits',\n    input: { ...laneGone('own-merged'), tipIsSyncCommit: false, hasDevCommits: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    name: 'own-merged deletes even when the tip is the adoption ledger commit — reachability is enough',\n    input: { ...laneGone('own-merged'), hasIndependentHistory: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    name: 'own-superseded (PR merged, then more commits pushed) -> close-pr but KEEP the branch',\n    input: laneGone('own-superseded'),\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' },\n  },\n  {\n    name: 'inherited-or-none -> noop, and never close-pr',\n    input: laneGone('inherited-or-none'),\n    type: 'noop',\n    reason: 'maps to no lane and has no sync history',\n  },\n  {\n    name: 'inherited-or-none with the branch carrying its own dev commits -> still noop',\n    input: { ...laneGone('inherited-or-none'), lastSyncedHead: undefined, hasDevCommits: true },\n    type: 'noop',\n  },\n\n  // The adopt paths need no claim: nothing on them can delete a branch.\n  {\n    name: 'no branch yet -> import-lane',\n    input: { branchExists: false, lastSyncedHead: undefined, ownership: 'inherited-or-none' },\n    type: 'import-lane',\n  },\n  { name: 'lane moved, branch untouched -> import-lane', input: { laneHead: 'L2' }, type: 'import-lane' },\n  { name: 'dev commits, lane unchanged -> export-branch', input: { hasDevCommits: true }, type: 'export-branch' },\n  { name: 'both moved -> merge-diverged', input: { laneHead: 'L2', hasDevCommits: true }, type: 'merge-diverged' },\n  {\n    name: 'existing branch, never synced, no dev commits, lane EXISTS -> import-lane (adopt branch)',\n    input: { lastSyncedHead: undefined, ownership: 'inherited-or-none' },\n    type: 'import-lane',\n  },\n  {\n    name: 'existing branch, never synced, has dev commits, lane EXISTS -> adopt-branch (first contact)',\n    input: { lastSyncedHead: undefined, ownership: 'inherited-or-none', hasDevCommits: true },\n    type: 'adopt-branch',\n  },\n  {\n    name: 'existing branch, never synced, has dev commits, but .bitmap names a DIFFERENT lane -> halt',\n    input: {\n      lastSyncedHead: undefined,\n      ownership: 'inherited-or-none',\n      hasDevCommits: true,\n      branchNamesDifferentLane: true,\n    },\n    type: 'halt',\n    reason: 'names a different lane',\n  },\n  {\n    // The executor resolves an inherited (merged) different-lane pointer to `false` — history, not a claim.\n    name: 'existing branch, has dev commits, .bitmap names a MERGED-AND-INHERITED different lane -> adopt-branch',\n    input: {\n      lastSyncedHead: undefined,\n      ownership: 'inherited-or-none',\n      hasDevCommits: true,\n      branchNamesDifferentLane: false,\n    },\n    type: 'adopt-branch',\n  },\n];\n\ndescribe('planLaneSync', () => {\n  table.forEach(({ name, input, type, action, reason }) => {\n    it(name, () => {\n      const result = planLaneSync({ ...base, ...input });\n      expect(result.type, name).to.equal(type);\n      if (action) expect(result).to.deep.equal(action);\n      if (reason) expect((result as { reason?: string }).reason).to.contain(reason);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_chai","data","require","_syncPlanner","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","base","laneHead","branchExists","lastSyncedHead","hasDevCommits","tipIsSyncCommit","conflictLabelPresent","ownership","laneGone","undefined","table","name","input","type","reason","action","deleteBranch","keepReason","hasIndependentHistory","stateCommitBundlesSources","branchNamesDifferentLane","describe","it","result","planLaneSync","expect","to","equal","deep","contain"],"sources":["sync-planner.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport type { LaneOwnershipEvidence, LaneSyncAction, LaneSyncInput } from './sync-planner';\nimport { planLaneSync } from './sync-planner';\n\nconst base: LaneSyncInput = {\n  laneHead: 'L1',\n  branchExists: true,\n  lastSyncedHead: 'L1',\n  hasDevCommits: false,\n  tipIsSyncCommit: true,\n  conflictLabelPresent: false,\n  ownership: 'own-live',\n};\n\n/** the \"lane deleted remotely, branch still there\" shape — the only path that reads `ownership` */\nconst laneGone = (ownership: LaneOwnershipEvidence) => ({ laneHead: undefined, ownership });\n\n/**\n * The decision table. `action` (exact) is required on every row that decides a branch deletion: under\n * the defaults an ordinary developer branch reaches the planner in the same shape as a deleted lane's\n * branch, so `deleteBranch` and the keep reason are part of the contract, not incidental output.\n */\nconst table: Array<{\n  name: string;\n  input: Partial<LaneSyncInput>;\n  type: LaneSyncAction['type'];\n  action?: LaneSyncAction;\n  reason?: string;\n}> = [\n  { name: 'converged -> noop', input: {}, type: 'noop', reason: 'converged' },\n  {\n    name: 'conflict label present -> noop until resolved',\n    input: { laneHead: 'L2', conflictLabelPresent: true },\n    type: 'noop',\n  },\n  { name: 'lane gone + no branch -> noop', input: { laneHead: undefined, branchExists: false }, type: 'noop' },\n\n  {\n    name: \"own-live, no dev commits, OUR tip (the branch is exactly the lane's mirror) -> close-pr AND delete\",\n    input: laneGone('own-live'),\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    // A developer who commits their own `.bitmap` write looks own-live with nothing above the state\n    // commit; the marker is what separates our mirror from their branch.\n    name: 'own-live, no dev commits, a tip WE DID NOT WRITE -> close-pr but KEEP the branch',\n    input: { ...laneGone('own-live'), tipIsSyncCommit: false },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'tip-not-a-sync-commit' },\n  },\n  {\n    name: 'own-live WITH dev commits (never-exported work above the state commit) -> KEEP the branch',\n    input: { ...laneGone('own-live'), hasDevCommits: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' },\n  },\n  {\n    // \"tip-not-a-sync-commit\" would send the reader after the wrong thing when there is real work.\n    name: 'own-live with dev commits AND a foreign tip -> keeps, naming the commits as the reason',\n    input: { ...laneGone('own-live'), hasDevCommits: true, tipIsSyncCommit: false },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' },\n  },\n  {\n    // Adoption proved content matched, never that the branch's pre-existing history is disposable.\n    name: 'own-live, no dev commits, OUR tip, but it is the adoption ledger commit -> KEEP, never delete',\n    input: { ...laneGone('own-live'), hasIndependentHistory: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'adopted-branch' },\n  },\n  {\n    name: 'own-merged (branch tip already in the default branch) -> close-pr AND delete',\n    input: laneGone('own-merged'),\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    // Reachability alone proves deleting loses nothing, so no marker conjunction applies here.\n    name: 'own-merged deletes even with a foreign tip and dev commits',\n    input: { ...laneGone('own-merged'), tipIsSyncCommit: false, hasDevCommits: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    name: 'own-merged deletes even when the tip is the adoption ledger commit — reachability is enough',\n    input: { ...laneGone('own-merged'), hasIndependentHistory: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    name: 'own-superseded (PR merged, then more commits pushed) -> close-pr but KEEP the branch',\n    input: laneGone('own-superseded'),\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' },\n  },\n  {\n    name: 'inherited-or-none -> noop, and never close-pr',\n    input: laneGone('inherited-or-none'),\n    type: 'noop',\n    reason: 'maps to no lane and has no sync history',\n  },\n  {\n    name: 'inherited-or-none with the branch carrying its own dev commits -> still noop',\n    input: { ...laneGone('inherited-or-none'), lastSyncedHead: undefined, hasDevCommits: true },\n    type: 'noop',\n  },\n\n  // The adopt paths need no claim: nothing on them can delete a branch.\n  {\n    name: 'no branch yet -> import-lane',\n    input: { branchExists: false, lastSyncedHead: undefined, ownership: 'inherited-or-none' },\n    type: 'import-lane',\n  },\n  { name: 'lane moved, branch untouched -> import-lane', input: { laneHead: 'L2' }, type: 'import-lane' },\n  { name: 'dev commits, lane unchanged -> export-branch', input: { hasDevCommits: true }, type: 'export-branch' },\n  { name: 'both moved -> merge-diverged', input: { laneHead: 'L2', hasDevCommits: true }, type: 'merge-diverged' },\n  {\n    // Suspected work only — git cannot tell whether the bundled sources are inside the recorded snap,\n    // so the executor probes with a read-only status check and settles without writing when clean.\n    name: 'sources bundled into the state commit, otherwise converged -> export-branch (a probe)',\n    input: { stateCommitBundlesSources: true, tipIsSyncCommit: false },\n    type: 'export-branch',\n    action: { type: 'export-branch' },\n  },\n  {\n    name: 'bundled sources count as work when the lane also moved -> merge-diverged',\n    input: { laneHead: 'L2', stateCommitBundlesSources: true, tipIsSyncCommit: false },\n    type: 'merge-diverged',\n  },\n  {\n    name: 'own-live with bundled sources -> KEEP the branch, naming the commits',\n    input: { ...laneGone('own-live'), stateCommitBundlesSources: true, tipIsSyncCommit: false },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' },\n  },\n  {\n    // Our own ledger commits bundle sources too (import-lane writes the lane's files, merge-diverged\n    // the merged tree) — already-exported content, not work. No probe can run against a deleted lane,\n    // so the deletion path keeps consulting the tip marker, in the same direction it always has.\n    name: 'own-live, bundled sources but the tip is OUR OWN ledger commit -> close-pr AND delete',\n    input: { ...laneGone('own-live'), stateCommitBundlesSources: true, tipIsSyncCommit: true },\n    type: 'close-pr',\n    action: { type: 'close-pr', deleteBranch: true },\n  },\n  {\n    // The convergence path is the opposite: a probe IS available there, and a tip that merely CLAIMS\n    // to be ours (a squash body quoting the marker) must never suppress it — probe, don't trust.\n    name: 'bundled sources with a tip claiming to be ours still probe -> export-branch',\n    input: { stateCommitBundlesSources: true, tipIsSyncCommit: true },\n    type: 'export-branch',\n  },\n  {\n    // Adoption probes via `bit status`, so suspected bundled work routes there like dev commits do.\n    name: 'existing branch, never synced, bundled sources -> adopt-branch (first contact)',\n    input: { lastSyncedHead: undefined, ownership: 'inherited-or-none', stateCommitBundlesSources: true },\n    type: 'adopt-branch',\n  },\n  {\n    name: 'existing branch, never synced, no dev commits, lane EXISTS -> import-lane (adopt branch)',\n    input: { lastSyncedHead: undefined, ownership: 'inherited-or-none' },\n    type: 'import-lane',\n  },\n  {\n    name: 'existing branch, never synced, has dev commits, lane EXISTS -> adopt-branch (first contact)',\n    input: { lastSyncedHead: undefined, ownership: 'inherited-or-none', hasDevCommits: true },\n    type: 'adopt-branch',\n  },\n  {\n    name: 'existing branch, never synced, has dev commits, but .bitmap names a DIFFERENT lane -> halt',\n    input: {\n      lastSyncedHead: undefined,\n      ownership: 'inherited-or-none',\n      hasDevCommits: true,\n      branchNamesDifferentLane: true,\n    },\n    type: 'halt',\n    reason: 'names a different lane',\n  },\n  {\n    // The executor resolves an inherited (merged) different-lane pointer to `false` — history, not a claim.\n    name: 'existing branch, has dev commits, .bitmap names a MERGED-AND-INHERITED different lane -> adopt-branch',\n    input: {\n      lastSyncedHead: undefined,\n      ownership: 'inherited-or-none',\n      hasDevCommits: true,\n      branchNamesDifferentLane: false,\n    },\n    type: 'adopt-branch',\n  },\n];\n\ndescribe('planLaneSync', () => {\n  table.forEach(({ name, input, type, action, reason }) => {\n    it(name, () => {\n      const result = planLaneSync({ ...base, ...input });\n      expect(result.type, name).to.equal(type);\n      if (action) expect(result).to.deep.equal(action);\n      if (reason) expect((result as { reason?: string }).reason).to.contain(reason);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/sync/sync-state.d.ts

@@ -55,9 +55,10 @@ export declare const CONFLICT_LABEL = "bit-sync-conflict";
 export declare function hasSyncMarker(message: string): boolean;
 /**
  * Strict probe for "we wrote this commit": the marker alone on its own line. This is an input to branch
- * deletion and to the export-branch withhold (a branch whose tip is already our own commit settles
- * instead of re-exporting), so a developer merely quoting the marker must never count as authorship.
- * `\r?` tolerates CRLF; a recognition failure errs toward keeping the branch / re-attempting the export.
+ * DELETION only — the one decision no content probe can stand in for, because the lane it would compare
+ * against is gone. It must never decide convergence: a squash-merge's body quotes the squashed ledger
+ * messages verbatim, marker included, so a message can claim authorship the reconciler never had.
+ * `\r?` tolerates CRLF; a recognition failure errs toward keeping the branch.
  */
 export declare function isSyncAuthoredMessage(message: string): boolean;
 /**
@@ -98,6 +99,14 @@ export type BranchSyncState = {
     bitmap?: BranchBitmapState;
     /** Whether the branch carries commits on top of its bit state — work bit has not seen. */
     hasDevCommits: boolean;
+    /**
+     * Whether the state commit also touched files besides `.bitmap`. SUSPECTED work only: those files
+     * may already be inside the snap the `.bitmap` records, which git cannot tell — the executor's
+     * read-only status probe is what distinguishes real work. True for ANY other path (`docs/`, CI
+     * config, this reconciler's own source-bundling ledger commits): a spurious `true` re-probes, which
+     * writes nothing, so it can repeat without consequence.
+     */
+    stateCommitBundlesSources: boolean;
     /** The branch tip's full commit message (subject + body), for the sync-marker loop-guard probe. */
     tipMessage: string;
     /**
@@ -106,6 +115,26 @@ export type BranchSyncState = {
      */
     tipSha?: string;
 };
+/**
+ * The pure half of `hasUnsyncedWorkChanges` (ci.main.runtime.ts): whether a `bit status` result holds
+ * anything a snap/export would push. The unloadable categories count as work: `invalidComponents` AND
+ * `importPendingComponents` (`StatusMain` splits pending-import errors out of the invalid list) are
+ * both UNKNOWN — their sources may hold the branch's edits — and this answer gates a "converged,
+ * write nothing" exit, so not knowing must route to the snap (which fails loudly) rather than
+ * converge. Incoming-change categories (outdated, pending updates from main) deliberately do NOT
+ * count: they are the lane's or main's movement, which the planner routes, not branch work.
+ */
+export declare function statusReportsUnsyncedWork(status: {
+    newComponents: unknown[];
+    modifiedComponents: unknown[];
+    stagedComponents: unknown[];
+    locallySoftRemoved: unknown[];
+    pendingUpdateDependents: unknown[];
+    mergePendingComponents: unknown[];
+    componentsDuringMergeState: unknown[];
+    invalidComponents: unknown[];
+    importPendingComponents: unknown[];
+}): boolean;
 /**
  * Whether a `rev-list --count` output reports commits. An unreadable count answers `true`: `false` is an
  * input to branch retirement, so not knowing must withhold a deletion rather than license one. Empty
@@ -118,6 +147,8 @@ export declare function parseDevCommitCount(raw: string): boolean;
  * change that arrived through a merge would otherwise be picked as this branch's own state commit.
  */
 export declare function readBranchSyncState(branch: string, defaultBranch: string, defaultScope: string): Promise<BranchSyncState>;
+/** The pure half of `commitTouchesBeyondBitmap`, split out so it is testable without a real git log. */
+export declare function touchesBeyondBitmap(rawNames: string): boolean;
 /**
  * Whether `branch`'s committed `.bitmap` is byte-identical (by blob sha) to the one at its merge-base
  * with the default branch — i.e. the branch never asserted a `.bitmap` change of its own, so whatever

package/dist/sync/sync-state.js

@@ -15,6 +15,8 @@ exports.oldestCommitIsNonSync = oldestCommitIsNonSync;
 exports.parseBranchBitmap = parseBranchBitmap;
 exports.parseDevCommitCount = parseDevCommitCount;
 exports.readBranchSyncState = readBranchSyncState;
+exports.statusReportsUnsyncedWork = statusReportsUnsyncedWork;
+exports.touchesBeyondBitmap = touchesBeyondBitmap;
 function _legacy() {
   const data = require("@teambit/legacy.bit-map");
   _legacy = function () {
@@ -125,9 +127,10 @@ function hasSyncMarker(message) {
 
 /**
  * Strict probe for "we wrote this commit": the marker alone on its own line. This is an input to branch
- * deletion and to the export-branch withhold (a branch whose tip is already our own commit settles
- * instead of re-exporting), so a developer merely quoting the marker must never count as authorship.
- * `\r?` tolerates CRLF; a recognition failure errs toward keeping the branch / re-attempting the export.
+ * DELETION only — the one decision no content probe can stand in for, because the lane it would compare
+ * against is gone. It must never decide convergence: a squash-merge's body quotes the squashed ledger
+ * messages verbatim, marker included, so a message can claim authorship the reconciler never had.
+ * `\r?` tolerates CRLF; a recognition failure errs toward keeping the branch.
  */
 function isSyncAuthoredMessage(message) {
   return new RegExp(`^${SYNC_COMMIT_MARKER.replace(/[[\]]/g, '\\$&')}\\r?$`, 'm').test(message);
@@ -170,6 +173,20 @@ const ADOPTION_TRAILER = exports.ADOPTION_TRAILER = 'Bit-Adopted';
 function buildSyncCommitMessage(laneIdStr, laneHead, opts = {}) {
   return [`chore(bit-sync): sync lane ${laneIdStr} @ ${laneHead.slice(0, 9)}`, '', `${LANE_HEAD_TRAILER}: ${laneHead}`, ...(opts.adopted ? [`${ADOPTION_TRAILER}: true`] : []), SYNC_COMMIT_MARKER].join('\n');
 }
+/**
+ * The pure half of `hasUnsyncedWorkChanges` (ci.main.runtime.ts): whether a `bit status` result holds
+ * anything a snap/export would push. The unloadable categories count as work: `invalidComponents` AND
+ * `importPendingComponents` (`StatusMain` splits pending-import errors out of the invalid list) are
+ * both UNKNOWN — their sources may hold the branch's edits — and this answer gates a "converged,
+ * write nothing" exit, so not knowing must route to the snap (which fails loudly) rather than
+ * converge. Incoming-change categories (outdated, pending updates from main) deliberately do NOT
+ * count: they are the lane's or main's movement, which the planner routes, not branch work.
+ */
+function statusReportsUnsyncedWork(status) {
+  const divergence = [status.newComponents, status.modifiedComponents, status.stagedComponents, status.locallySoftRemoved, status.pendingUpdateDependents, status.mergePendingComponents, status.componentsDuringMergeState, status.invalidComponents, status.importPendingComponents];
+  return divergence.some(components => components.length > 0);
+}
+
 /**
  * Whether a `rev-list --count` output reports commits. An unreadable count answers `true`: `false` is an
  * input to branch retirement, so not knowing must withhold a deletion rather than license one. Empty
@@ -193,15 +210,56 @@ async function readBranchSyncState(branch, defaultBranch, defaultScope) {
   const bitmap = parseBranchBitmap(await readFileAtRef(revision, _legacy2().BIT_MAP), defaultScope);
   const range = stateCommit ? `${stateCommit}..${revision}` : `origin/${defaultBranch}..${revision}`;
   const count = await _git().git.raw(['rev-list', range, '--count']);
+
+  // Source edits can HIDE AT OR BELOW the state commit — bundled into it (the conflict-halt comment's
+  // resolve-by-hand recipe), or in an earlier commit that a later `.bitmap`-only commit covers — and
+  // `hasDevCommits` starts counting only after it, so they were invisible. Git file names alone cannot
+  // tell whether those sources are already inside the snap the `.bitmap` records (a dev who snapped,
+  // exported, and committed everything at once) or were never snapped at all — so this is SUSPECTED
+  // work, computed over the whole range since the PREVIOUS state commit (the last point a `.bitmap`
+  // write could have accounted for sources) and reported separately for the planner to probe.
+  // Deliberately content-only, per this module's header: this reconciler's own ledger commits have the
+  // same shape (import-lane and merge-diverged bundle already-exported sources) and its probe is a
+  // read, so a spurious `true` costs one status check — while consulting the tip's MESSAGE here read a
+  // squash-merge (whose body quotes the squashed ledger messages, marker included) as machine-authored
+  // and silently dropped the bundled work.
+  const stateCommitBundlesSources = !parseDevCommitCount(count) && stateCommit !== undefined && stateCommit === tipSha && (await sourcesTouchedSincePreviousState(revision, defaultBranch));
   return {
     stateCommit,
     bitmap,
     hasDevCommits: parseDevCommitCount(count),
+    stateCommitBundlesSources,
     tipMessage,
     tipSha
   };
 }
 
+/**
+ * Whether any file besides `.bitmap` changed between the PREVIOUS `.bitmap`-writing commit (or, on a
+ * branch with only one, its fork point off the default branch) and the tip. A tree diff over the
+ * whole range, not a per-commit walk: a source edit in one commit followed by a `.bitmap`-only commit
+ * would be invisible to a single-commit check, and a later revert legitimately cancels out.
+ * Unreadable answers `true`: this feeds `stateCommitBundlesSources`, where not knowing must plan the
+ * probe, never declare convergence.
+ */
+async function sourcesTouchedSincePreviousState(revision, defaultBranch) {
+  try {
+    const previousStateCommit = (await _git().git.raw(['log', revision, '--first-parent', '-n', '1', '--skip', '1', '--format=%H', '--', _legacy2().BIT_MAP])).trim();
+    const base = previousStateCommit || (await _git().git.raw(['merge-base', `origin/${defaultBranch}`, revision])).trim();
+    if (!base) return true;
+    const names = await _git().git.raw(['diff', '--name-only', `${base}..${revision}`]);
+    // Empty is legitimate here (a range whose edits cancel out), unlike a single state commit's diff.
+    return touchesBeyondBitmap(names);
+  } catch {
+    return true;
+  }
+}
+
+/** The pure half of `commitTouchesBeyondBitmap`, split out so it is testable without a real git log. */
+function touchesBeyondBitmap(rawNames) {
+  return rawNames.split('\n').map(name => name.trim()).filter(Boolean).some(name => name !== _legacy2().BIT_MAP);
+}
+
 /**
  * Whether `branch`'s committed `.bitmap` is byte-identical (by blob sha) to the one at its merge-base
  * with the default branch — i.e. the branch never asserted a `.bitmap` change of its own, so whatever

package/dist/sync/sync-state.js.map

@@ -1 +1 @@
-{"version":3,"names":["_legacy","data","require","_legacy2","_toolboxCrypto","_git","parseBranchBitmap","content","defaultScope","trim","undefined","bitMap","BitMap","loadFromContentWithoutLoadingFiles","Buffer","from","versions","components","forEach","componentMap","version","id","toStringWithoutVersion","laneId","isLaneExported","laneIdStr","scope","toString","fingerprintIdVersions","idAtVersion","sha1","sort","join","ABSENT_ON_BRANCH","exports","branchStateFingerprint","state","laneComponentIds","map","NO_CHANGES_TO_SNAP","LANE_HEAD_TRAILER","SYNC_COMMIT_MARKER","CONFLICT_LABEL","hasSyncMarker","message","includes","isSyncAuthoredMessage","RegExp","replace","test","COMMIT_MESSAGE_RECORD_SEPARATOR","oldestCommitIsNonSync","rawLog","messages","split","entry","filter","Boolean","oldest","isLedgerCommitMessage","ADOPTION_TRAILER","buildSyncCommitMessage","laneHead","opts","slice","adopted","parseDevCommitCount","raw","count","Number","parseInt","isNaN","readBranchSyncState","branch","defaultBranch","revision","tipSha","git","tipMessage","trimEnd","stateCommit","BIT_MAP","bitmap","readFileAtRef","range","hasDevCommits","branchBitmapUnchangedSinceFork","base","branchBlob","baseBlob","Promise","all","branchSha","filePath"],"sources":["sync-state.ts"],"sourcesContent":["import { BitMap } from '@teambit/legacy.bit-map';\nimport { BIT_MAP } from '@teambit/legacy.constants';\nimport { sha1 } from '@teambit/toolbox.crypto.sha1';\nimport { git } from '../git';\n\n/**\n * Sync state is derived from the `.bitmap` committed on a branch — the lane pointer (`_bit_lane`) and the\n * per-component versions — never from commit messages, which are forgeable and rewritten by squash/rebase.\n */\n\n/** What a branch's committed `.bitmap` says about the branch's bit state. */\nexport type BranchBitmapState = {\n  /**\n   * The scope-qualified lane id `.bitmap` points at (`<scope>/<name>`), or undefined when there is no\n   * usable pointer — none at all (branch on main), or one bit marked not exported.\n   */\n  laneIdStr?: string;\n  /** `<scope>/<name>` -> version (a snap hash, or a semver tag on main), exactly as `.bitmap` records it. */\n  versions: Record<string, string>;\n};\n\n/**\n * Parse a `.bitmap` file's content — no workspace, no filesystem. Fail-safe: an unreadable file returns\n * undefined, and a pointer that parses but cannot attribute (unscoped id, `exported: false`) withholds\n * `laneIdStr`; either way no lane id licenses nothing, so a parse failure can never authorize a deletion.\n * An unexported pointer is ignored because its lane never existed on any remote and treating it as a\n * mirror would retire the branch.\n */\nexport function parseBranchBitmap(content: string | undefined, defaultScope: string): BranchBitmapState | undefined {\n  if (!content || !content.trim()) return undefined;\n  try {\n    const bitMap = BitMap.loadFromContentWithoutLoadingFiles(Buffer.from(content, 'utf8'), '', '', defaultScope);\n    const versions: Record<string, string> = {};\n    bitMap.components.forEach((componentMap) => {\n      const version = componentMap.id.version;\n      // No version = never snapped/tagged; contributes nothing to the fingerprint.\n      if (version) versions[componentMap.id.toStringWithoutVersion()] = version;\n    });\n    // An unscoped lane id cannot be attribution: every comparison target is scope-qualified.\n    const laneId = bitMap.isLaneExported ? bitMap.laneId : undefined;\n    const laneIdStr = laneId?.scope ? laneId.toString() : undefined;\n    return { laneIdStr, versions };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Fingerprint of `<component-id>@<version>` pairs: sorted (so listing/key order cannot perturb it), then\n * sha1'd (the value doubles as a single-token `Bit-Lane-Head` trailer).\n */\nexport function fingerprintIdVersions(idAtVersion: string[]): string {\n  return sha1([...idAtVersion].sort().join('\\n'));\n}\n\n/**\n * Placeholder for a lane component the branch's `.bitmap` lacks. It must participate in the fingerprint,\n * or \"the lane grew a component\" would fingerprint identically to \"converged\".\n */\nexport const ABSENT_ON_BRANCH = '<absent>';\n\n/**\n * What the branch reflects, comparable to the lane's own fingerprint. Only the lane's components count:\n * the `.bitmap` also carries non-lane components at their main versions, and including those would make\n * an untouched pair read as diverged after any unrelated release.\n */\nexport function branchStateFingerprint(state: BranchBitmapState, laneComponentIds: string[]): string {\n  return fingerprintIdVersions(laneComponentIds.map((id) => `${id}@${state.versions[id] ?? ABSENT_ON_BRANCH}`));\n}\n\n/**\n * `snapPrCommit`'s return value when there was nothing to snap — its only signal either way. Lives in\n * this leaf module so `ci.main.runtime.ts` and `lane-sync-executor.ts` share it without a cycle.\n */\nexport const NO_CHANGES_TO_SNAP = 'No changes detected, nothing to snap';\n\nexport const LANE_HEAD_TRAILER = 'Bit-Lane-Head';\n/**\n * Marks a commit as machine-generated. Duplicated in the `bit-git-sync` action repo's event router\n * (the loop guard) — changing one copy without the other makes the reconciler re-trigger itself.\n */\nexport const SYNC_COMMIT_MARKER = '[bit-sync]';\nexport const CONFLICT_LABEL = 'bit-sync-conflict';\n\n/**\n * Permissive substring probe for \"looks machine-generated\" — the loop guard. Must NOT decide anything\n * irreversible; see `isSyncAuthoredMessage`.\n */\nexport function hasSyncMarker(message: string): boolean {\n  return message.includes(SYNC_COMMIT_MARKER);\n}\n\n/**\n * Strict probe for \"we wrote this commit\": the marker alone on its own line. This is an input to branch\n * deletion and to the export-branch withhold (a branch whose tip is already our own commit settles\n * instead of re-exporting), so a developer merely quoting the marker must never count as authorship.\n * `\\r?` tolerates CRLF; a recognition failure errs toward keeping the branch / re-attempting the export.\n */\nexport function isSyncAuthoredMessage(message: string): boolean {\n  return new RegExp(`^${SYNC_COMMIT_MARKER.replace(/[[\\]]/g, '\\\\$&')}\\\\r?$`, 'm').test(message);\n}\n\n/** The record separator `hasIndependentHistoryBelowStateCommit`'s `git log --format=%B%x1e` uses. */\nconst COMMIT_MESSAGE_RECORD_SEPARATOR = '\\x1e';\n\n/**\n * Whether the OLDEST record of a `git log --reverse --format=%B%x1e` run is NOT bit-authored — i.e. a\n * human created the branch before this reconciler touched it. Oldest only, not \"any\": ordinary lane\n * branches carry real dev commits between ledger commits too, and \"any\" would misclassify them all.\n */\nexport function oldestCommitIsNonSync(rawLog: string): boolean {\n  const messages = rawLog\n    .split(COMMIT_MESSAGE_RECORD_SEPARATOR)\n    .map((entry) => entry.trim())\n    .filter(Boolean);\n  const oldest = messages[0];\n  return oldest !== undefined && !isLedgerCommitMessage(oldest);\n}\n\n/**\n * Strict probe for \"this is one of our LEDGER commits\": the sync marker on its own line AND the\n * `Bit-Lane-Head` trailer — `buildSyncCommitMessage` always writes both. The deletion guard reads\n * this instead of `isSyncAuthoredMessage` so a human commit merely quoting `[bit-sync]` still counts\n * as independent history (a false \"human\" only ever keeps a branch).\n */\nexport function isLedgerCommitMessage(message: string): boolean {\n  return isSyncAuthoredMessage(message) && new RegExp(`^${LANE_HEAD_TRAILER}: `, 'm').test(message);\n}\n\n/**\n * Marks `adopt-branch`'s ledger commit. Audit-only — the deletion guard reads the branch's ancestry\n * instead, since a trailer marks only the one commit it is on and later ledger commits carry none.\n */\nexport const ADOPTION_TRAILER = 'Bit-Adopted';\n\n/**\n * The sync commit's message. Every part is an annotation (audit trail + loop-guard marker); nothing reads\n * it as state — messages are forgeable and rewritten on squash-merge. State comes from `.bitmap`.\n */\nexport function buildSyncCommitMessage(laneIdStr: string, laneHead: string, opts: { adopted?: boolean } = {}): string {\n  return [\n    `chore(bit-sync): sync lane ${laneIdStr} @ ${laneHead.slice(0, 9)}`,\n    '',\n    `${LANE_HEAD_TRAILER}: ${laneHead}`,\n    ...(opts.adopted ? [`${ADOPTION_TRAILER}: true`] : []),\n    SYNC_COMMIT_MARKER,\n  ].join('\\n');\n}\n\nexport type BranchSyncState = {\n  /**\n   * The newest first-parent commit that changed `.bitmap` — the reachability anchor for branch ownership\n   * and the baseline for `hasDevCommits`. Undefined when `.bitmap` was never written on the branch.\n   */\n  stateCommit?: string;\n  /**\n   * The branch tip's `.bitmap`, parsed; undefined when absent/unparseable (treated as \"not ours\").\n   * Reading at the tip equals reading at `stateCommit` — nothing after it changed the file.\n   */\n  bitmap?: BranchBitmapState;\n  /** Whether the branch carries commits on top of its bit state — work bit has not seen. */\n  hasDevCommits: boolean;\n  /** The branch tip's full commit message (subject + body), for the sync-marker loop-guard probe. */\n  tipMessage: string;\n  /**\n   * The tip sha every field above was read from. The retirement path re-reads the branch and refuses to\n   * delete anything else — the evidence licensed deleting THIS commit, not a later one.\n   */\n  tipSha?: string;\n};\n\n/**\n * Whether a `rev-list --count` output reports commits. An unreadable count answers `true`: `false` is an\n * input to branch retirement, so not knowing must withhold a deletion rather than license one. Empty\n * output is reachable — simple-git's `raw` resolves with it on some non-zero exits.\n */\nexport function parseDevCommitCount(raw: string): boolean {\n  const count = Number.parseInt(raw.trim(), 10);\n  return Number.isNaN(count) ? true : count > 0;\n}\n\n/**\n * Read a remote branch's sync state from its committed `.bitmap`. Assumes `git fetch origin` already ran.\n * `--first-parent` is a correctness requirement: `git log` orders across all parents, so a `.bitmap`\n * change that arrived through a merge would otherwise be picked as this branch's own state commit.\n */\nexport async function readBranchSyncState(\n  branch: string,\n  defaultBranch: string,\n  defaultScope: string\n): Promise<BranchSyncState> {\n  const revision = `origin/${branch}`;\n  const tipSha = (await git.raw(['rev-parse', revision])).trim() || undefined;\n  const tipMessage = (await git.raw(['log', revision, '-n', '1', '--format=%B'])).trimEnd();\n  const stateCommit =\n    (await git.raw(['log', revision, '--first-parent', '-n', '1', '--format=%H', '--', BIT_MAP])).trim() || undefined;\n\n  const bitmap = parseBranchBitmap(await readFileAtRef(revision, BIT_MAP), defaultScope);\n\n  const range = stateCommit ? `${stateCommit}..${revision}` : `origin/${defaultBranch}..${revision}`;\n  const count = await git.raw(['rev-list', range, '--count']);\n\n  return { stateCommit, bitmap, hasDevCommits: parseDevCommitCount(count), tipMessage, tipSha };\n}\n\n/**\n * Whether `branch`'s committed `.bitmap` is byte-identical (by blob sha) to the one at its merge-base\n * with the default branch — i.e. the branch never asserted a `.bitmap` change of its own, so whatever\n * pointer it carries is INHERITED. Compared at the fork point, not the default branch's current tip,\n * which moves on and would false-block. False on any git error: unreadable must not license adoption.\n */\nexport async function branchBitmapUnchangedSinceFork(branch: string, defaultBranch: string): Promise<boolean> {\n  try {\n    const base = (await git.raw(['merge-base', `origin/${defaultBranch}`, `origin/${branch}`])).trim();\n    if (!base) return false;\n    const [branchBlob, baseBlob] = await Promise.all([\n      git.raw(['rev-parse', `origin/${branch}:./${BIT_MAP}`]),\n      git.raw(['rev-parse', `${base}:./${BIT_MAP}`]),\n    ]);\n    const branchSha = branchBlob.trim();\n    return Boolean(branchSha) && branchSha === baseBlob.trim();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * A file's content at a git ref, or undefined when it isn't there. simple-git's `raw` can resolve with\n * empty output instead of rejecting on a missing path; `:./` keeps the path cwd-relative in case the\n * workspace is a subdirectory of the repo.\n */\nasync function readFileAtRef(revision: string, filePath: string): Promise<string | undefined> {\n  try {\n    return await git.raw(['show', `${revision}:./${filePath}`]);\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_legacy","data","require","_legacy2","_toolboxCrypto","_git","parseBranchBitmap","content","defaultScope","trim","undefined","bitMap","BitMap","loadFromContentWithoutLoadingFiles","Buffer","from","versions","components","forEach","componentMap","version","id","toStringWithoutVersion","laneId","isLaneExported","laneIdStr","scope","toString","fingerprintIdVersions","idAtVersion","sha1","sort","join","ABSENT_ON_BRANCH","exports","branchStateFingerprint","state","laneComponentIds","map","NO_CHANGES_TO_SNAP","LANE_HEAD_TRAILER","SYNC_COMMIT_MARKER","CONFLICT_LABEL","hasSyncMarker","message","includes","isSyncAuthoredMessage","RegExp","replace","test","COMMIT_MESSAGE_RECORD_SEPARATOR","oldestCommitIsNonSync","rawLog","messages","split","entry","filter","Boolean","oldest","isLedgerCommitMessage","ADOPTION_TRAILER","buildSyncCommitMessage","laneHead","opts","slice","adopted","statusReportsUnsyncedWork","status","divergence","newComponents","modifiedComponents","stagedComponents","locallySoftRemoved","pendingUpdateDependents","mergePendingComponents","componentsDuringMergeState","invalidComponents","importPendingComponents","some","length","parseDevCommitCount","raw","count","Number","parseInt","isNaN","readBranchSyncState","branch","defaultBranch","revision","tipSha","git","tipMessage","trimEnd","stateCommit","BIT_MAP","bitmap","readFileAtRef","range","stateCommitBundlesSources","sourcesTouchedSincePreviousState","hasDevCommits","previousStateCommit","base","names","touchesBeyondBitmap","rawNames","name","branchBitmapUnchangedSinceFork","branchBlob","baseBlob","Promise","all","branchSha","filePath"],"sources":["sync-state.ts"],"sourcesContent":["import { BitMap } from '@teambit/legacy.bit-map';\nimport { BIT_MAP } from '@teambit/legacy.constants';\nimport { sha1 } from '@teambit/toolbox.crypto.sha1';\nimport { git } from '../git';\n\n/**\n * Sync state is derived from the `.bitmap` committed on a branch — the lane pointer (`_bit_lane`) and the\n * per-component versions — never from commit messages, which are forgeable and rewritten by squash/rebase.\n */\n\n/** What a branch's committed `.bitmap` says about the branch's bit state. */\nexport type BranchBitmapState = {\n  /**\n   * The scope-qualified lane id `.bitmap` points at (`<scope>/<name>`), or undefined when there is no\n   * usable pointer — none at all (branch on main), or one bit marked not exported.\n   */\n  laneIdStr?: string;\n  /** `<scope>/<name>` -> version (a snap hash, or a semver tag on main), exactly as `.bitmap` records it. */\n  versions: Record<string, string>;\n};\n\n/**\n * Parse a `.bitmap` file's content — no workspace, no filesystem. Fail-safe: an unreadable file returns\n * undefined, and a pointer that parses but cannot attribute (unscoped id, `exported: false`) withholds\n * `laneIdStr`; either way no lane id licenses nothing, so a parse failure can never authorize a deletion.\n * An unexported pointer is ignored because its lane never existed on any remote and treating it as a\n * mirror would retire the branch.\n */\nexport function parseBranchBitmap(content: string | undefined, defaultScope: string): BranchBitmapState | undefined {\n  if (!content || !content.trim()) return undefined;\n  try {\n    const bitMap = BitMap.loadFromContentWithoutLoadingFiles(Buffer.from(content, 'utf8'), '', '', defaultScope);\n    const versions: Record<string, string> = {};\n    bitMap.components.forEach((componentMap) => {\n      const version = componentMap.id.version;\n      // No version = never snapped/tagged; contributes nothing to the fingerprint.\n      if (version) versions[componentMap.id.toStringWithoutVersion()] = version;\n    });\n    // An unscoped lane id cannot be attribution: every comparison target is scope-qualified.\n    const laneId = bitMap.isLaneExported ? bitMap.laneId : undefined;\n    const laneIdStr = laneId?.scope ? laneId.toString() : undefined;\n    return { laneIdStr, versions };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Fingerprint of `<component-id>@<version>` pairs: sorted (so listing/key order cannot perturb it), then\n * sha1'd (the value doubles as a single-token `Bit-Lane-Head` trailer).\n */\nexport function fingerprintIdVersions(idAtVersion: string[]): string {\n  return sha1([...idAtVersion].sort().join('\\n'));\n}\n\n/**\n * Placeholder for a lane component the branch's `.bitmap` lacks. It must participate in the fingerprint,\n * or \"the lane grew a component\" would fingerprint identically to \"converged\".\n */\nexport const ABSENT_ON_BRANCH = '<absent>';\n\n/**\n * What the branch reflects, comparable to the lane's own fingerprint. Only the lane's components count:\n * the `.bitmap` also carries non-lane components at their main versions, and including those would make\n * an untouched pair read as diverged after any unrelated release.\n */\nexport function branchStateFingerprint(state: BranchBitmapState, laneComponentIds: string[]): string {\n  return fingerprintIdVersions(laneComponentIds.map((id) => `${id}@${state.versions[id] ?? ABSENT_ON_BRANCH}`));\n}\n\n/**\n * `snapPrCommit`'s return value when there was nothing to snap — its only signal either way. Lives in\n * this leaf module so `ci.main.runtime.ts` and `lane-sync-executor.ts` share it without a cycle.\n */\nexport const NO_CHANGES_TO_SNAP = 'No changes detected, nothing to snap';\n\nexport const LANE_HEAD_TRAILER = 'Bit-Lane-Head';\n/**\n * Marks a commit as machine-generated. Duplicated in the `bit-git-sync` action repo's event router\n * (the loop guard) — changing one copy without the other makes the reconciler re-trigger itself.\n */\nexport const SYNC_COMMIT_MARKER = '[bit-sync]';\nexport const CONFLICT_LABEL = 'bit-sync-conflict';\n\n/**\n * Permissive substring probe for \"looks machine-generated\" — the loop guard. Must NOT decide anything\n * irreversible; see `isSyncAuthoredMessage`.\n */\nexport function hasSyncMarker(message: string): boolean {\n  return message.includes(SYNC_COMMIT_MARKER);\n}\n\n/**\n * Strict probe for \"we wrote this commit\": the marker alone on its own line. This is an input to branch\n * DELETION only — the one decision no content probe can stand in for, because the lane it would compare\n * against is gone. It must never decide convergence: a squash-merge's body quotes the squashed ledger\n * messages verbatim, marker included, so a message can claim authorship the reconciler never had.\n * `\\r?` tolerates CRLF; a recognition failure errs toward keeping the branch.\n */\nexport function isSyncAuthoredMessage(message: string): boolean {\n  return new RegExp(`^${SYNC_COMMIT_MARKER.replace(/[[\\]]/g, '\\\\$&')}\\\\r?$`, 'm').test(message);\n}\n\n/** The record separator `hasIndependentHistoryBelowStateCommit`'s `git log --format=%B%x1e` uses. */\nconst COMMIT_MESSAGE_RECORD_SEPARATOR = '\\x1e';\n\n/**\n * Whether the OLDEST record of a `git log --reverse --format=%B%x1e` run is NOT bit-authored — i.e. a\n * human created the branch before this reconciler touched it. Oldest only, not \"any\": ordinary lane\n * branches carry real dev commits between ledger commits too, and \"any\" would misclassify them all.\n */\nexport function oldestCommitIsNonSync(rawLog: string): boolean {\n  const messages = rawLog\n    .split(COMMIT_MESSAGE_RECORD_SEPARATOR)\n    .map((entry) => entry.trim())\n    .filter(Boolean);\n  const oldest = messages[0];\n  return oldest !== undefined && !isLedgerCommitMessage(oldest);\n}\n\n/**\n * Strict probe for \"this is one of our LEDGER commits\": the sync marker on its own line AND the\n * `Bit-Lane-Head` trailer — `buildSyncCommitMessage` always writes both. The deletion guard reads\n * this instead of `isSyncAuthoredMessage` so a human commit merely quoting `[bit-sync]` still counts\n * as independent history (a false \"human\" only ever keeps a branch).\n */\nexport function isLedgerCommitMessage(message: string): boolean {\n  return isSyncAuthoredMessage(message) && new RegExp(`^${LANE_HEAD_TRAILER}: `, 'm').test(message);\n}\n\n/**\n * Marks `adopt-branch`'s ledger commit. Audit-only — the deletion guard reads the branch's ancestry\n * instead, since a trailer marks only the one commit it is on and later ledger commits carry none.\n */\nexport const ADOPTION_TRAILER = 'Bit-Adopted';\n\n/**\n * The sync commit's message. Every part is an annotation (audit trail + loop-guard marker); nothing reads\n * it as state — messages are forgeable and rewritten on squash-merge. State comes from `.bitmap`.\n */\nexport function buildSyncCommitMessage(laneIdStr: string, laneHead: string, opts: { adopted?: boolean } = {}): string {\n  return [\n    `chore(bit-sync): sync lane ${laneIdStr} @ ${laneHead.slice(0, 9)}`,\n    '',\n    `${LANE_HEAD_TRAILER}: ${laneHead}`,\n    ...(opts.adopted ? [`${ADOPTION_TRAILER}: true`] : []),\n    SYNC_COMMIT_MARKER,\n  ].join('\\n');\n}\n\nexport type BranchSyncState = {\n  /**\n   * The newest first-parent commit that changed `.bitmap` — the reachability anchor for branch ownership\n   * and the baseline for `hasDevCommits`. Undefined when `.bitmap` was never written on the branch.\n   */\n  stateCommit?: string;\n  /**\n   * The branch tip's `.bitmap`, parsed; undefined when absent/unparseable (treated as \"not ours\").\n   * Reading at the tip equals reading at `stateCommit` — nothing after it changed the file.\n   */\n  bitmap?: BranchBitmapState;\n  /** Whether the branch carries commits on top of its bit state — work bit has not seen. */\n  hasDevCommits: boolean;\n  /**\n   * Whether the state commit also touched files besides `.bitmap`. SUSPECTED work only: those files\n   * may already be inside the snap the `.bitmap` records, which git cannot tell — the executor's\n   * read-only status probe is what distinguishes real work. True for ANY other path (`docs/`, CI\n   * config, this reconciler's own source-bundling ledger commits): a spurious `true` re-probes, which\n   * writes nothing, so it can repeat without consequence.\n   */\n  stateCommitBundlesSources: boolean;\n  /** The branch tip's full commit message (subject + body), for the sync-marker loop-guard probe. */\n  tipMessage: string;\n  /**\n   * The tip sha every field above was read from. The retirement path re-reads the branch and refuses to\n   * delete anything else — the evidence licensed deleting THIS commit, not a later one.\n   */\n  tipSha?: string;\n};\n\n/**\n * The pure half of `hasUnsyncedWorkChanges` (ci.main.runtime.ts): whether a `bit status` result holds\n * anything a snap/export would push. The unloadable categories count as work: `invalidComponents` AND\n * `importPendingComponents` (`StatusMain` splits pending-import errors out of the invalid list) are\n * both UNKNOWN — their sources may hold the branch's edits — and this answer gates a \"converged,\n * write nothing\" exit, so not knowing must route to the snap (which fails loudly) rather than\n * converge. Incoming-change categories (outdated, pending updates from main) deliberately do NOT\n * count: they are the lane's or main's movement, which the planner routes, not branch work.\n */\nexport function statusReportsUnsyncedWork(status: {\n  newComponents: unknown[];\n  modifiedComponents: unknown[];\n  stagedComponents: unknown[];\n  locallySoftRemoved: unknown[];\n  pendingUpdateDependents: unknown[];\n  mergePendingComponents: unknown[];\n  componentsDuringMergeState: unknown[];\n  invalidComponents: unknown[];\n  importPendingComponents: unknown[];\n}): boolean {\n  const divergence = [\n    status.newComponents,\n    status.modifiedComponents,\n    status.stagedComponents,\n    status.locallySoftRemoved,\n    status.pendingUpdateDependents,\n    status.mergePendingComponents,\n    status.componentsDuringMergeState,\n    status.invalidComponents,\n    status.importPendingComponents,\n  ];\n  return divergence.some((components) => components.length > 0);\n}\n\n/**\n * Whether a `rev-list --count` output reports commits. An unreadable count answers `true`: `false` is an\n * input to branch retirement, so not knowing must withhold a deletion rather than license one. Empty\n * output is reachable — simple-git's `raw` resolves with it on some non-zero exits.\n */\nexport function parseDevCommitCount(raw: string): boolean {\n  const count = Number.parseInt(raw.trim(), 10);\n  return Number.isNaN(count) ? true : count > 0;\n}\n\n/**\n * Read a remote branch's sync state from its committed `.bitmap`. Assumes `git fetch origin` already ran.\n * `--first-parent` is a correctness requirement: `git log` orders across all parents, so a `.bitmap`\n * change that arrived through a merge would otherwise be picked as this branch's own state commit.\n */\nexport async function readBranchSyncState(\n  branch: string,\n  defaultBranch: string,\n  defaultScope: string\n): Promise<BranchSyncState> {\n  const revision = `origin/${branch}`;\n  const tipSha = (await git.raw(['rev-parse', revision])).trim() || undefined;\n  const tipMessage = (await git.raw(['log', revision, '-n', '1', '--format=%B'])).trimEnd();\n  const stateCommit =\n    (await git.raw(['log', revision, '--first-parent', '-n', '1', '--format=%H', '--', BIT_MAP])).trim() || undefined;\n\n  const bitmap = parseBranchBitmap(await readFileAtRef(revision, BIT_MAP), defaultScope);\n\n  const range = stateCommit ? `${stateCommit}..${revision}` : `origin/${defaultBranch}..${revision}`;\n  const count = await git.raw(['rev-list', range, '--count']);\n\n  // Source edits can HIDE AT OR BELOW the state commit — bundled into it (the conflict-halt comment's\n  // resolve-by-hand recipe), or in an earlier commit that a later `.bitmap`-only commit covers — and\n  // `hasDevCommits` starts counting only after it, so they were invisible. Git file names alone cannot\n  // tell whether those sources are already inside the snap the `.bitmap` records (a dev who snapped,\n  // exported, and committed everything at once) or were never snapped at all — so this is SUSPECTED\n  // work, computed over the whole range since the PREVIOUS state commit (the last point a `.bitmap`\n  // write could have accounted for sources) and reported separately for the planner to probe.\n  // Deliberately content-only, per this module's header: this reconciler's own ledger commits have the\n  // same shape (import-lane and merge-diverged bundle already-exported sources) and its probe is a\n  // read, so a spurious `true` costs one status check — while consulting the tip's MESSAGE here read a\n  // squash-merge (whose body quotes the squashed ledger messages, marker included) as machine-authored\n  // and silently dropped the bundled work.\n  const stateCommitBundlesSources =\n    !parseDevCommitCount(count) &&\n    stateCommit !== undefined &&\n    stateCommit === tipSha &&\n    (await sourcesTouchedSincePreviousState(revision, defaultBranch));\n\n  return {\n    stateCommit,\n    bitmap,\n    hasDevCommits: parseDevCommitCount(count),\n    stateCommitBundlesSources,\n    tipMessage,\n    tipSha,\n  };\n}\n\n/**\n * Whether any file besides `.bitmap` changed between the PREVIOUS `.bitmap`-writing commit (or, on a\n * branch with only one, its fork point off the default branch) and the tip. A tree diff over the\n * whole range, not a per-commit walk: a source edit in one commit followed by a `.bitmap`-only commit\n * would be invisible to a single-commit check, and a later revert legitimately cancels out.\n * Unreadable answers `true`: this feeds `stateCommitBundlesSources`, where not knowing must plan the\n * probe, never declare convergence.\n */\nasync function sourcesTouchedSincePreviousState(revision: string, defaultBranch: string): Promise<boolean> {\n  try {\n    const previousStateCommit = (\n      await git.raw(['log', revision, '--first-parent', '-n', '1', '--skip', '1', '--format=%H', '--', BIT_MAP])\n    ).trim();\n    const base = previousStateCommit || (await git.raw(['merge-base', `origin/${defaultBranch}`, revision])).trim();\n    if (!base) return true;\n    const names = await git.raw(['diff', '--name-only', `${base}..${revision}`]);\n    // Empty is legitimate here (a range whose edits cancel out), unlike a single state commit's diff.\n    return touchesBeyondBitmap(names);\n  } catch {\n    return true;\n  }\n}\n\n/** The pure half of `commitTouchesBeyondBitmap`, split out so it is testable without a real git log. */\nexport function touchesBeyondBitmap(rawNames: string): boolean {\n  return rawNames\n    .split('\\n')\n    .map((name) => name.trim())\n    .filter(Boolean)\n    .some((name) => name !== BIT_MAP);\n}\n\n/**\n * Whether `branch`'s committed `.bitmap` is byte-identical (by blob sha) to the one at its merge-base\n * with the default branch — i.e. the branch never asserted a `.bitmap` change of its own, so whatever\n * pointer it carries is INHERITED. Compared at the fork point, not the default branch's current tip,\n * which moves on and would false-block. False on any git error: unreadable must not license adoption.\n */\nexport async function branchBitmapUnchangedSinceFork(branch: string, defaultBranch: string): Promise<boolean> {\n  try {\n    const base = (await git.raw(['merge-base', `origin/${defaultBranch}`, `origin/${branch}`])).trim();\n    if (!base) return false;\n    const [branchBlob, baseBlob] = await Promise.all([\n      git.raw(['rev-parse', `origin/${branch}:./${BIT_MAP}`]),\n      git.raw(['rev-parse', `${base}:./${BIT_MAP}`]),\n    ]);\n    const branchSha = branchBlob.trim();\n    return Boolean(branchSha) && branchSha === baseBlob.trim();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * A file's content at a git ref, or undefined when it isn't there. simple-git's `raw` can resolve with\n * empty output instead of rejecting on a missing path; `:./` keeps the path cwd-relative in case the\n * workspace is a subdirectory of the repo.\n */\nasync function readFileAtRef(revision: string, filePath: string): Promise<string | undefined> {\n  try {\n    return await git.raw(['show', `${revision}:./${filePath}`]);\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/sync/sync-state.spec.js

@@ -14,6 +14,11 @@ function _syncState() {
   };
   return data;
 }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 const DEFAULT_SCOPE = 'acme.shop';
 const SNAP_1 = 'a'.repeat(40);
 const SNAP_2 = 'b'.repeat(40);
@@ -216,6 +221,44 @@ describe('parseBranchBitmap', () => {
  * retirement, so every unreadable shape must read as "there is unmerged work" and keep the branch.
  */
 const DEV_COMMIT_COUNTS = [['a count of commits on top of the state commit', '3', true], ['the raw output shape, trailing newline and all', '3\n', true], ['a genuine zero — the only license to retire', '0', false], ["a genuine zero with git's trailing newline", '0\n', false], ['empty output, which simple-git resolves with on some non-zero exits', '', true], ['whitespace-only output', '  \n ', true], ['git writing an error where the count was expected', 'fatal: bad revision', true]];
+describe('statusReportsUnsyncedWork', () => {
+  const empty = {
+    newComponents: [],
+    modifiedComponents: [],
+    stagedComponents: [],
+    locallySoftRemoved: [],
+    pendingUpdateDependents: [],
+    mergePendingComponents: [],
+    componentsDuringMergeState: [],
+    invalidComponents: [],
+    importPendingComponents: []
+  };
+  it('an all-empty status is converged', () => {
+    (0, _chai().expect)((0, _syncState().statusReportsUnsyncedWork)(empty)).to.equal(false);
+  });
+  it('a modified component is work', () => {
+    (0, _chai().expect)((0, _syncState().statusReportsUnsyncedWork)(_objectSpread(_objectSpread({}, empty), {}, {
+      modifiedComponents: ['comp1']
+    }))).to.equal(true);
+  });
+
+  // An unloadable component is UNKNOWN, not converged: its sources may hold the branch's work, and
+  // "not knowing" must route to the snap (which fails loudly), never to a silent converged answer.
+  it('an invalid (unloadable) component is work, not convergence', () => {
+    (0, _chai().expect)((0, _syncState().statusReportsUnsyncedWork)(_objectSpread(_objectSpread({}, empty), {}, {
+      invalidComponents: [{
+        id: 'comp1'
+      }]
+    }))).to.equal(true);
+  });
+
+  // StatusMain SPLITS pending-import errors out of invalidComponents — same unknown, different array.
+  it('a pending-import component is the same unknown, not convergence', () => {
+    (0, _chai().expect)((0, _syncState().statusReportsUnsyncedWork)(_objectSpread(_objectSpread({}, empty), {}, {
+      importPendingComponents: ['comp1']
+    }))).to.equal(true);
+  });
+});
 describe('parseDevCommitCount', () => {
   DEV_COMMIT_COUNTS.forEach(([name, raw, hasDevCommits]) => {
     it(`${hasDevCommits ? 'keeps the branch' : 'permits retirement'} for ${name}`, () => {
@@ -223,6 +266,17 @@ describe('parseDevCommitCount', () => {
     });
   });
 });
+describe('touchesBeyondBitmap', () => {
+  it('is false for an empty diff and for a .bitmap-only commit', () => {
+    (0, _chai().expect)((0, _syncState().touchesBeyondBitmap)('')).to.equal(false);
+    (0, _chai().expect)((0, _syncState().touchesBeyondBitmap)('\n')).to.equal(false);
+    (0, _chai().expect)((0, _syncState().touchesBeyondBitmap)('.bitmap\n')).to.equal(false);
+  });
+  it('is true when any source file rides in the same commit as the .bitmap write', () => {
+    (0, _chai().expect)((0, _syncState().touchesBeyondBitmap)('.bitmap\ncomp1/index.js\n')).to.equal(true);
+    (0, _chai().expect)((0, _syncState().touchesBeyondBitmap)('comp1/index.js\n')).to.equal(true);
+  });
+});
 describe('oldestCommitIsNonSync', () => {
   it('is false for an empty range — no commits at all', () => {
     (0, _chai().expect)((0, _syncState().oldestCommitIsNonSync)('')).to.equal(false);

package/dist/sync/sync-state.spec.js.map

@@ -1 +1 @@
-{"version":3,"names":["_chai","data","require","_syncState","DEFAULT_SCOPE","SNAP_1","repeat","SNAP_2","LANE_SYNC","buildSyncCommitMessage","MAIN_SYNC","LANE_SNAP","describe","it","expect","split","to","equal","include","LANE_HEAD_TRAILER","SYNC_COMMIT_MARKER","MESSAGES","forEach","name","message","marker","authored","hasSyncMarker","isSyncAuthoredMessage","bitmapContent","lane","components","comp1","comp2","prefix","body","Object","entries","version","scope","mainFile","rootDir","_bit_lane","id","exported","JSON","stringify","bitmapWithRawLaneKey","laneKey","onLane","parseBranchBitmap","laneIdStr","versions","deep","state","POINTERS","undefined","not","UNREADABLE","content","defaultScope","DEV_COMMIT_COUNTS","raw","hasDevCommits","parseDevCommitCount","oldestCommitIsNonSync","log","join","spoof","a","b","fingerprintIdVersions","match","laneIds","laneSide","branchStateFingerprint","laneMoved","grown","ABSENT_ON_BRANCH","withExtra","comp9"],"sources":["sync-state.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport {\n  ABSENT_ON_BRANCH,\n  LANE_HEAD_TRAILER,\n  SYNC_COMMIT_MARKER,\n  branchStateFingerprint,\n  buildSyncCommitMessage,\n  fingerprintIdVersions,\n  oldestCommitIsNonSync,\n  hasSyncMarker,\n  isSyncAuthoredMessage,\n  parseBranchBitmap,\n  parseDevCommitCount,\n} from './sync-state';\n\nconst DEFAULT_SCOPE = 'acme.shop';\nconst SNAP_1 = 'a'.repeat(40);\nconst SNAP_2 = 'b'.repeat(40);\n\nconst LANE_SYNC = buildSyncCommitMessage('acme.shop/my-lane', 'a'.repeat(40));\nconst MAIN_SYNC = 'chore(bit-sync): sync git to latest main scope versions\\n\\n[bit-sync]';\n/** `executeMergeDiverged`'s snap message: a LANE message, whose marker is inline and never a tip. */\nconst LANE_SNAP = 'merge remote lane acme.shop/my-lane into my-lane [bit-sync]';\n\ndescribe('buildSyncCommitMessage', () => {\n  it('names the lane scope-qualified in the subject and carries both annotations', () => {\n    expect(LANE_SYNC.split('\\n', 1)[0]).to.equal(`chore(bit-sync): sync lane acme.shop/my-lane @ ${'a'.repeat(9)}`);\n    expect(LANE_SYNC).to.include(`${LANE_HEAD_TRAILER}: ${'a'.repeat(40)}`);\n    expect(LANE_SYNC).to.include(SYNC_COMMIT_MARKER);\n    expect(buildSyncCommitMessage('other.scope/my-lane', 'b'.repeat(40))).to.include('sync lane other.scope/my-lane');\n  });\n});\n\n/**\n * `hasSyncMarker` is the permissive loop guard; `isSyncAuthoredMessage` is an input to branch DELETION,\n * so a false positive there costs a developer's branch. Every row states both answers, and the rows\n * where they disagree are the laundering holes the strict probe exists to close.\n */\nconst MESSAGES: Array<[string, string, boolean, boolean]> = [\n  // message, hasSyncMarker, isSyncAuthoredMessage\n  ['what buildSyncCommitMessage produces', LANE_SYNC, true, true],\n  ['the raw `git log %B` shape, trailing newline and all', `${LANE_SYNC}\\n`, true, true],\n  ['the main-scope sync commit, whose marker is also its own line', MAIN_SYNC, true, true],\n  ['CRLF line endings', `subject\\r\\n\\r\\n${SYNC_COMMIT_MARKER}\\r\\n`, true, true],\n  ['a message that merely quotes the marker mid-line', 'revert the [bit-sync] bitmap churn', true, false],\n  ['the marker quoted mid-line inside a body', 'fix: undo\\n\\nthis reverts a [bit-sync] commit\\n', true, false],\n  ['the marker mentioned in a subject', 'chore: mention [bit-sync] here', true, false],\n  ['the inline-marker lane snap message', LANE_SNAP, true, false],\n  ['an ordinary commit', 'feat: something', false, false],\n  ['the lane-head trailer on its own', `${LANE_HEAD_TRAILER}: ${'c'.repeat(40)}`, false, false],\n];\n\ndescribe('sync-commit recognition', () => {\n  MESSAGES.forEach(([name, message, marker, authored]) => {\n    it(`${authored ? 'accepts' : 'REJECTS'} ${name}`, () => {\n      expect(hasSyncMarker(message), 'loop guard').to.equal(marker);\n      expect(isSyncAuthoredMessage(message), 'deletion gate').to.equal(authored);\n    });\n  });\n});\n\n/** A `.bitmap` in the exact shape bit writes it (schema 17) — what `git show` hands the parser. */\nfunction bitmapContent({\n  lane,\n  components = { comp1: SNAP_1, comp2: SNAP_2 },\n  prefix = '/**\\n * DO NOT EDIT THIS FILE\\n */\\n\\n',\n}: {\n  lane?: { scope: string; name: string };\n  components?: Record<string, string>;\n  prefix?: string;\n} = {}): string {\n  const body: Record<string, any> = {};\n  Object.entries(components).forEach(([name, version]) => {\n    body[name] = { name, scope: DEFAULT_SCOPE, version, mainFile: 'index.js', rootDir: name };\n  });\n  if (lane) body._bit_lane = { id: lane, exported: true };\n  body['$schema-version'] = '17.0.0';\n  return `${prefix}${JSON.stringify(body, null, 4)}`;\n}\n\n/** a `.bitmap` carrying whatever `_bit_lane` value the caller wants to see rejected */\nfunction bitmapWithRawLaneKey(laneKey: any): string {\n  return JSON.stringify({\n    comp1: { name: 'comp1', scope: DEFAULT_SCOPE, version: SNAP_1, mainFile: 'index.js', rootDir: 'comp1' },\n    _bit_lane: laneKey,\n    '$schema-version': '17.0.0',\n  });\n}\n\nconst onLane = (name = 'my-lane', scope = DEFAULT_SCOPE) =>\n  parseBranchBitmap(bitmapContent({ lane: { scope, name } }), DEFAULT_SCOPE) as NonNullable<\n    ReturnType<typeof parseBranchBitmap>\n  >;\n\ndescribe('parseBranchBitmap', () => {\n  it('reads the lane pointer scope-qualified — the attribution the ownership rule is built on', () => {\n    expect(onLane('my-lane', 'other.scope').laneIdStr).to.equal('other.scope/my-lane');\n  });\n\n  it('reads every component at the exact version the branch records', () => {\n    expect(onLane().versions).to.deep.equal({\n      [`${DEFAULT_SCOPE}/comp1`]: SNAP_1,\n      [`${DEFAULT_SCOPE}/comp2`]: SNAP_2,\n    });\n  });\n\n  it('survives the comment header bit prefixes every `.bitmap` with', () => {\n    // `.bitmap` is JSON-with-comments; a throw here silently degrades every branch to \"not ours\".\n    const state = parseBranchBitmap(\n      bitmapContent({ lane: { scope: DEFAULT_SCOPE, name: 'my-lane' }, prefix: '/* generated, do not edit */\\n' }),\n      DEFAULT_SCOPE\n    );\n    expect(state?.laneIdStr).to.equal(`${DEFAULT_SCOPE}/my-lane`);\n  });\n\n  /**\n   * Only a pointer bit marked exported, carrying a scoped id, is attribution. Honouring anything else\n   * would read \"lane removed\" for a lane that never existed remotely and retire a developer branch —\n   * and a bare name could still trigger the branch-aliasing halt over a lane that does not exist.\n   */\n  const POINTERS: Array<[string, any, string | undefined]> = [\n    ['bit marked it not exported', { id: { scope: DEFAULT_SCOPE, name: 'foo' }, exported: false }, undefined],\n    ['`exported` is missing entirely', { id: { scope: DEFAULT_SCOPE, name: 'foo' } }, undefined],\n    ['it is an empty object', {}, undefined],\n    ['`id` is a string rather than a {scope, name}', { id: `${DEFAULT_SCOPE}/foo`, exported: true }, undefined],\n    ['the lane id has no scope', { id: { scope: '', name: 'foo' }, exported: true }, undefined],\n    // non-vacuity for the rows above: a well-formed pointer through the same helper DOES attribute\n    [\n      'bit has marked the lane exported',\n      { id: { scope: DEFAULT_SCOPE, name: 'foo' }, exported: true },\n      `${DEFAULT_SCOPE}/foo`,\n    ],\n  ];\n\n  POINTERS.forEach(([name, laneKey, laneIdStr]) => {\n    it(`withholds attribution unless the pointer is usable: ${name}`, () => {\n      const state = parseBranchBitmap(bitmapWithRawLaneKey(laneKey), DEFAULT_SCOPE);\n      expect(state?.laneIdStr).to.equal(laneIdStr);\n    });\n  });\n\n  it('reports no lane pointer at all for a `.bitmap` on main — every ordinary developer branch', () => {\n    const state = parseBranchBitmap(bitmapContent(), DEFAULT_SCOPE);\n    expect(state).to.not.equal(undefined);\n    expect(state?.laneIdStr).to.equal(undefined);\n  });\n\n  /** Every way of not knowing must resolve to the answer that licenses nothing (no branch retired). */\n  const UNREADABLE: Array<[string, string | undefined]> = [\n    ['a `.bitmap` that is not valid JSON', '{ this is not json'],\n    ['a file git could not produce at all', undefined],\n    ['an empty file', ''],\n    ['a whitespace-only file', '   \\n '],\n    [\n      'an entry bit itself refuses — a scoped component with no version',\n      JSON.stringify({\n        comp1: { name: 'comp1', scope: DEFAULT_SCOPE, mainFile: 'index.js', rootDir: 'comp1' },\n        '$schema-version': '17.0.0',\n      }),\n    ],\n    [\n      'two components claiming the same rootDir',\n      JSON.stringify({\n        comp1: { name: 'comp1', scope: DEFAULT_SCOPE, version: SNAP_1, mainFile: 'index.js', rootDir: 'shared' },\n        comp2: { name: 'comp2', scope: DEFAULT_SCOPE, version: SNAP_2, mainFile: 'index.js', rootDir: 'shared' },\n        '$schema-version': '17.0.0',\n      }),\n    ],\n  ];\n\n  UNREADABLE.forEach(([name, content]) => {\n    it(`degrades to undefined rather than guessing, for ${name}`, () => {\n      expect(parseBranchBitmap(content, DEFAULT_SCOPE)).to.equal(undefined);\n    });\n  });\n\n  it('falls back to the repository default scope for a component `.bitmap` does not scope', () => {\n    // `latest` can never equal a snap hash, so such a pair reads as not-converged — the safe direction.\n    const content = JSON.stringify({\n      comp1: { name: 'comp1', scope: '', defaultScope: DEFAULT_SCOPE, mainFile: 'index.js', rootDir: 'comp1' },\n      '$schema-version': '17.0.0',\n    });\n    expect(parseBranchBitmap(content, DEFAULT_SCOPE)?.versions).to.deep.equal({\n      [`${DEFAULT_SCOPE}/comp1`]: 'latest',\n    });\n  });\n});\n\n/**\n * Only a count git actually printed may report \"no dev commits\" — that answer is an input to branch\n * retirement, so every unreadable shape must read as \"there is unmerged work\" and keep the branch.\n */\nconst DEV_COMMIT_COUNTS: Array<[string, string, boolean]> = [\n  ['a count of commits on top of the state commit', '3', true],\n  ['the raw output shape, trailing newline and all', '3\\n', true],\n  ['a genuine zero — the only license to retire', '0', false],\n  [\"a genuine zero with git's trailing newline\", '0\\n', false],\n  ['empty output, which simple-git resolves with on some non-zero exits', '', true],\n  ['whitespace-only output', '  \\n ', true],\n  ['git writing an error where the count was expected', 'fatal: bad revision', true],\n];\n\ndescribe('parseDevCommitCount', () => {\n  DEV_COMMIT_COUNTS.forEach(([name, raw, hasDevCommits]) => {\n    it(`${hasDevCommits ? 'keeps the branch' : 'permits retirement'} for ${name}`, () => {\n      expect(parseDevCommitCount(raw), JSON.stringify(raw)).to.equal(hasDevCommits);\n    });\n  });\n});\n\ndescribe('oldestCommitIsNonSync', () => {\n  it('is false for an empty range — no commits at all', () => {\n    expect(oldestCommitIsNonSync('')).to.equal(false);\n  });\n\n  it('is false when the oldest (first, with --reverse) record is bit-authored', () => {\n    // A normal bit-created branch: its own first ledger commit, then a later human dev commit and a\n    // second ledger commit from export-branch — non-sync work, but never the OLDEST record.\n    const log = [LANE_SYNC, 'feat: a later, normal dev commit\\n', MAIN_SYNC].join('\\x1e');\n    expect(oldestCommitIsNonSync(log)).to.equal(false);\n  });\n\n  it('is true when the oldest (first, with --reverse) record is a genuine, non-sync commit', () => {\n    // Adoption's exact shape: the branch's own first commit was a human's, before bit ever touched it.\n    const log = ['feat: a human created this branch before adoption\\n', LANE_SYNC].join('\\x1e');\n    expect(oldestCommitIsNonSync(log)).to.equal(true);\n  });\n\n  it('ignores a trailing separator with nothing after it', () => {\n    const log = `${LANE_SYNC}\\x1e`;\n    expect(oldestCommitIsNonSync(log)).to.equal(false);\n  });\n\n  // A ledger commit needs the marker AND the Bit-Lane-Head trailer; a human message that merely\n  // quotes [bit-sync] on its own line must still read as independent history (a keep, never a delete).\n  it('is true when the oldest human commit quotes the [bit-sync] marker but has no ledger trailer', () => {\n    const spoof = 'feat: mention our tooling\\n\\n[bit-sync]\\n';\n    const log = [spoof, LANE_SYNC].join('\\x1e');\n    expect(oldestCommitIsNonSync(log)).to.equal(true);\n  });\n});\n\ndescribe('fingerprintIdVersions', () => {\n  it('is a single 40-hex token, and stable under reordering', () => {\n    // A single token survives being written into a commit trailer; order-stability keeps neither\n    // listing order looking like a state change.\n    const a = `${DEFAULT_SCOPE}/comp1@${SNAP_1}`;\n    const b = `${DEFAULT_SCOPE}/comp2@${SNAP_2}`;\n    expect(fingerprintIdVersions([a])).to.match(/^[0-9a-f]{40}$/);\n    expect(fingerprintIdVersions([a, b])).to.equal(fingerprintIdVersions([b, a]));\n  });\n});\n\ndescribe('branchStateFingerprint', () => {\n  const laneIds = [`${DEFAULT_SCOPE}/comp1`, `${DEFAULT_SCOPE}/comp2`];\n\n  it('equals the lane fingerprint when the branch records every lane component at the lane head', () => {\n    // Computed the way `laneHeadFingerprint` computes it — the two sides must be comparable.\n    const laneSide = fingerprintIdVersions([`${DEFAULT_SCOPE}/comp1@${SNAP_1}`, `${DEFAULT_SCOPE}/comp2@${SNAP_2}`]);\n    expect(branchStateFingerprint(onLane(), laneIds)).to.equal(laneSide);\n  });\n\n  it('differs when the lane moved a component the branch has not caught up with', () => {\n    const laneMoved = fingerprintIdVersions([\n      `${DEFAULT_SCOPE}/comp1@${SNAP_1}`,\n      `${DEFAULT_SCOPE}/comp2@${'c'.repeat(40)}`,\n    ]);\n    expect(branchStateFingerprint(onLane(), laneIds)).to.not.equal(laneMoved);\n  });\n\n  it('counts a lane component the branch does not have at all', () => {\n    // Without the placeholder, \"the lane grew a component\" would fingerprint identically to \"converged\".\n    const grown = [...laneIds, `${DEFAULT_SCOPE}/comp3`];\n    expect(branchStateFingerprint(onLane(), grown)).to.not.equal(branchStateFingerprint(onLane(), laneIds));\n    expect(branchStateFingerprint(onLane(), grown)).to.equal(\n      fingerprintIdVersions([\n        `${DEFAULT_SCOPE}/comp1@${SNAP_1}`,\n        `${DEFAULT_SCOPE}/comp2@${SNAP_2}`,\n        `${DEFAULT_SCOPE}/comp3@${ABSENT_ON_BRANCH}`,\n      ])\n    );\n  });\n\n  it('ignores components the branch has that are not on the lane', () => {\n    // The `.bitmap` also carries non-lane components at their main versions; counting those would make\n    // an untouched pair read as diverged after any unrelated release.\n    const withExtra = parseBranchBitmap(\n      bitmapContent({\n        lane: { scope: DEFAULT_SCOPE, name: 'my-lane' },\n        components: { comp1: SNAP_1, comp2: SNAP_2, comp9: '0.0.7' },\n      }),\n      DEFAULT_SCOPE\n    ) as NonNullable<ReturnType<typeof parseBranchBitmap>>;\n    expect(branchStateFingerprint(withExtra, laneIds)).to.equal(branchStateFingerprint(onLane(), laneIds));\n  });\n});\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_chai","data","require","_syncState","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","DEFAULT_SCOPE","SNAP_1","repeat","SNAP_2","LANE_SYNC","buildSyncCommitMessage","MAIN_SYNC","LANE_SNAP","describe","it","expect","split","to","equal","include","LANE_HEAD_TRAILER","SYNC_COMMIT_MARKER","MESSAGES","name","message","marker","authored","hasSyncMarker","isSyncAuthoredMessage","bitmapContent","lane","components","comp1","comp2","prefix","body","entries","version","scope","mainFile","rootDir","_bit_lane","id","exported","JSON","stringify","bitmapWithRawLaneKey","laneKey","onLane","parseBranchBitmap","laneIdStr","versions","deep","state","POINTERS","undefined","not","UNREADABLE","content","defaultScope","DEV_COMMIT_COUNTS","empty","newComponents","modifiedComponents","stagedComponents","locallySoftRemoved","pendingUpdateDependents","mergePendingComponents","componentsDuringMergeState","invalidComponents","importPendingComponents","statusReportsUnsyncedWork","raw","hasDevCommits","parseDevCommitCount","touchesBeyondBitmap","oldestCommitIsNonSync","log","join","spoof","a","b","fingerprintIdVersions","match","laneIds","laneSide","branchStateFingerprint","laneMoved","grown","ABSENT_ON_BRANCH","withExtra","comp9"],"sources":["sync-state.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport {\n  ABSENT_ON_BRANCH,\n  LANE_HEAD_TRAILER,\n  SYNC_COMMIT_MARKER,\n  branchStateFingerprint,\n  buildSyncCommitMessage,\n  fingerprintIdVersions,\n  oldestCommitIsNonSync,\n  hasSyncMarker,\n  isSyncAuthoredMessage,\n  parseBranchBitmap,\n  parseDevCommitCount,\n  statusReportsUnsyncedWork,\n  touchesBeyondBitmap,\n} from './sync-state';\n\nconst DEFAULT_SCOPE = 'acme.shop';\nconst SNAP_1 = 'a'.repeat(40);\nconst SNAP_2 = 'b'.repeat(40);\n\nconst LANE_SYNC = buildSyncCommitMessage('acme.shop/my-lane', 'a'.repeat(40));\nconst MAIN_SYNC = 'chore(bit-sync): sync git to latest main scope versions\\n\\n[bit-sync]';\n/** `executeMergeDiverged`'s snap message: a LANE message, whose marker is inline and never a tip. */\nconst LANE_SNAP = 'merge remote lane acme.shop/my-lane into my-lane [bit-sync]';\n\ndescribe('buildSyncCommitMessage', () => {\n  it('names the lane scope-qualified in the subject and carries both annotations', () => {\n    expect(LANE_SYNC.split('\\n', 1)[0]).to.equal(`chore(bit-sync): sync lane acme.shop/my-lane @ ${'a'.repeat(9)}`);\n    expect(LANE_SYNC).to.include(`${LANE_HEAD_TRAILER}: ${'a'.repeat(40)}`);\n    expect(LANE_SYNC).to.include(SYNC_COMMIT_MARKER);\n    expect(buildSyncCommitMessage('other.scope/my-lane', 'b'.repeat(40))).to.include('sync lane other.scope/my-lane');\n  });\n});\n\n/**\n * `hasSyncMarker` is the permissive loop guard; `isSyncAuthoredMessage` is an input to branch DELETION,\n * so a false positive there costs a developer's branch. Every row states both answers, and the rows\n * where they disagree are the laundering holes the strict probe exists to close.\n */\nconst MESSAGES: Array<[string, string, boolean, boolean]> = [\n  // message, hasSyncMarker, isSyncAuthoredMessage\n  ['what buildSyncCommitMessage produces', LANE_SYNC, true, true],\n  ['the raw `git log %B` shape, trailing newline and all', `${LANE_SYNC}\\n`, true, true],\n  ['the main-scope sync commit, whose marker is also its own line', MAIN_SYNC, true, true],\n  ['CRLF line endings', `subject\\r\\n\\r\\n${SYNC_COMMIT_MARKER}\\r\\n`, true, true],\n  ['a message that merely quotes the marker mid-line', 'revert the [bit-sync] bitmap churn', true, false],\n  ['the marker quoted mid-line inside a body', 'fix: undo\\n\\nthis reverts a [bit-sync] commit\\n', true, false],\n  ['the marker mentioned in a subject', 'chore: mention [bit-sync] here', true, false],\n  ['the inline-marker lane snap message', LANE_SNAP, true, false],\n  ['an ordinary commit', 'feat: something', false, false],\n  ['the lane-head trailer on its own', `${LANE_HEAD_TRAILER}: ${'c'.repeat(40)}`, false, false],\n];\n\ndescribe('sync-commit recognition', () => {\n  MESSAGES.forEach(([name, message, marker, authored]) => {\n    it(`${authored ? 'accepts' : 'REJECTS'} ${name}`, () => {\n      expect(hasSyncMarker(message), 'loop guard').to.equal(marker);\n      expect(isSyncAuthoredMessage(message), 'deletion gate').to.equal(authored);\n    });\n  });\n});\n\n/** A `.bitmap` in the exact shape bit writes it (schema 17) — what `git show` hands the parser. */\nfunction bitmapContent({\n  lane,\n  components = { comp1: SNAP_1, comp2: SNAP_2 },\n  prefix = '/**\\n * DO NOT EDIT THIS FILE\\n */\\n\\n',\n}: {\n  lane?: { scope: string; name: string };\n  components?: Record<string, string>;\n  prefix?: string;\n} = {}): string {\n  const body: Record<string, any> = {};\n  Object.entries(components).forEach(([name, version]) => {\n    body[name] = { name, scope: DEFAULT_SCOPE, version, mainFile: 'index.js', rootDir: name };\n  });\n  if (lane) body._bit_lane = { id: lane, exported: true };\n  body['$schema-version'] = '17.0.0';\n  return `${prefix}${JSON.stringify(body, null, 4)}`;\n}\n\n/** a `.bitmap` carrying whatever `_bit_lane` value the caller wants to see rejected */\nfunction bitmapWithRawLaneKey(laneKey: any): string {\n  return JSON.stringify({\n    comp1: { name: 'comp1', scope: DEFAULT_SCOPE, version: SNAP_1, mainFile: 'index.js', rootDir: 'comp1' },\n    _bit_lane: laneKey,\n    '$schema-version': '17.0.0',\n  });\n}\n\nconst onLane = (name = 'my-lane', scope = DEFAULT_SCOPE) =>\n  parseBranchBitmap(bitmapContent({ lane: { scope, name } }), DEFAULT_SCOPE) as NonNullable<\n    ReturnType<typeof parseBranchBitmap>\n  >;\n\ndescribe('parseBranchBitmap', () => {\n  it('reads the lane pointer scope-qualified — the attribution the ownership rule is built on', () => {\n    expect(onLane('my-lane', 'other.scope').laneIdStr).to.equal('other.scope/my-lane');\n  });\n\n  it('reads every component at the exact version the branch records', () => {\n    expect(onLane().versions).to.deep.equal({\n      [`${DEFAULT_SCOPE}/comp1`]: SNAP_1,\n      [`${DEFAULT_SCOPE}/comp2`]: SNAP_2,\n    });\n  });\n\n  it('survives the comment header bit prefixes every `.bitmap` with', () => {\n    // `.bitmap` is JSON-with-comments; a throw here silently degrades every branch to \"not ours\".\n    const state = parseBranchBitmap(\n      bitmapContent({ lane: { scope: DEFAULT_SCOPE, name: 'my-lane' }, prefix: '/* generated, do not edit */\\n' }),\n      DEFAULT_SCOPE\n    );\n    expect(state?.laneIdStr).to.equal(`${DEFAULT_SCOPE}/my-lane`);\n  });\n\n  /**\n   * Only a pointer bit marked exported, carrying a scoped id, is attribution. Honouring anything else\n   * would read \"lane removed\" for a lane that never existed remotely and retire a developer branch —\n   * and a bare name could still trigger the branch-aliasing halt over a lane that does not exist.\n   */\n  const POINTERS: Array<[string, any, string | undefined]> = [\n    ['bit marked it not exported', { id: { scope: DEFAULT_SCOPE, name: 'foo' }, exported: false }, undefined],\n    ['`exported` is missing entirely', { id: { scope: DEFAULT_SCOPE, name: 'foo' } }, undefined],\n    ['it is an empty object', {}, undefined],\n    ['`id` is a string rather than a {scope, name}', { id: `${DEFAULT_SCOPE}/foo`, exported: true }, undefined],\n    ['the lane id has no scope', { id: { scope: '', name: 'foo' }, exported: true }, undefined],\n    // non-vacuity for the rows above: a well-formed pointer through the same helper DOES attribute\n    [\n      'bit has marked the lane exported',\n      { id: { scope: DEFAULT_SCOPE, name: 'foo' }, exported: true },\n      `${DEFAULT_SCOPE}/foo`,\n    ],\n  ];\n\n  POINTERS.forEach(([name, laneKey, laneIdStr]) => {\n    it(`withholds attribution unless the pointer is usable: ${name}`, () => {\n      const state = parseBranchBitmap(bitmapWithRawLaneKey(laneKey), DEFAULT_SCOPE);\n      expect(state?.laneIdStr).to.equal(laneIdStr);\n    });\n  });\n\n  it('reports no lane pointer at all for a `.bitmap` on main — every ordinary developer branch', () => {\n    const state = parseBranchBitmap(bitmapContent(), DEFAULT_SCOPE);\n    expect(state).to.not.equal(undefined);\n    expect(state?.laneIdStr).to.equal(undefined);\n  });\n\n  /** Every way of not knowing must resolve to the answer that licenses nothing (no branch retired). */\n  const UNREADABLE: Array<[string, string | undefined]> = [\n    ['a `.bitmap` that is not valid JSON', '{ this is not json'],\n    ['a file git could not produce at all', undefined],\n    ['an empty file', ''],\n    ['a whitespace-only file', '   \\n '],\n    [\n      'an entry bit itself refuses — a scoped component with no version',\n      JSON.stringify({\n        comp1: { name: 'comp1', scope: DEFAULT_SCOPE, mainFile: 'index.js', rootDir: 'comp1' },\n        '$schema-version': '17.0.0',\n      }),\n    ],\n    [\n      'two components claiming the same rootDir',\n      JSON.stringify({\n        comp1: { name: 'comp1', scope: DEFAULT_SCOPE, version: SNAP_1, mainFile: 'index.js', rootDir: 'shared' },\n        comp2: { name: 'comp2', scope: DEFAULT_SCOPE, version: SNAP_2, mainFile: 'index.js', rootDir: 'shared' },\n        '$schema-version': '17.0.0',\n      }),\n    ],\n  ];\n\n  UNREADABLE.forEach(([name, content]) => {\n    it(`degrades to undefined rather than guessing, for ${name}`, () => {\n      expect(parseBranchBitmap(content, DEFAULT_SCOPE)).to.equal(undefined);\n    });\n  });\n\n  it('falls back to the repository default scope for a component `.bitmap` does not scope', () => {\n    // `latest` can never equal a snap hash, so such a pair reads as not-converged — the safe direction.\n    const content = JSON.stringify({\n      comp1: { name: 'comp1', scope: '', defaultScope: DEFAULT_SCOPE, mainFile: 'index.js', rootDir: 'comp1' },\n      '$schema-version': '17.0.0',\n    });\n    expect(parseBranchBitmap(content, DEFAULT_SCOPE)?.versions).to.deep.equal({\n      [`${DEFAULT_SCOPE}/comp1`]: 'latest',\n    });\n  });\n});\n\n/**\n * Only a count git actually printed may report \"no dev commits\" — that answer is an input to branch\n * retirement, so every unreadable shape must read as \"there is unmerged work\" and keep the branch.\n */\nconst DEV_COMMIT_COUNTS: Array<[string, string, boolean]> = [\n  ['a count of commits on top of the state commit', '3', true],\n  ['the raw output shape, trailing newline and all', '3\\n', true],\n  ['a genuine zero — the only license to retire', '0', false],\n  [\"a genuine zero with git's trailing newline\", '0\\n', false],\n  ['empty output, which simple-git resolves with on some non-zero exits', '', true],\n  ['whitespace-only output', '  \\n ', true],\n  ['git writing an error where the count was expected', 'fatal: bad revision', true],\n];\n\ndescribe('statusReportsUnsyncedWork', () => {\n  const empty = {\n    newComponents: [],\n    modifiedComponents: [],\n    stagedComponents: [],\n    locallySoftRemoved: [],\n    pendingUpdateDependents: [],\n    mergePendingComponents: [],\n    componentsDuringMergeState: [],\n    invalidComponents: [],\n    importPendingComponents: [],\n  };\n\n  it('an all-empty status is converged', () => {\n    expect(statusReportsUnsyncedWork(empty)).to.equal(false);\n  });\n\n  it('a modified component is work', () => {\n    expect(statusReportsUnsyncedWork({ ...empty, modifiedComponents: ['comp1'] })).to.equal(true);\n  });\n\n  // An unloadable component is UNKNOWN, not converged: its sources may hold the branch's work, and\n  // \"not knowing\" must route to the snap (which fails loudly), never to a silent converged answer.\n  it('an invalid (unloadable) component is work, not convergence', () => {\n    expect(statusReportsUnsyncedWork({ ...empty, invalidComponents: [{ id: 'comp1' }] })).to.equal(true);\n  });\n\n  // StatusMain SPLITS pending-import errors out of invalidComponents — same unknown, different array.\n  it('a pending-import component is the same unknown, not convergence', () => {\n    expect(statusReportsUnsyncedWork({ ...empty, importPendingComponents: ['comp1'] })).to.equal(true);\n  });\n});\n\ndescribe('parseDevCommitCount', () => {\n  DEV_COMMIT_COUNTS.forEach(([name, raw, hasDevCommits]) => {\n    it(`${hasDevCommits ? 'keeps the branch' : 'permits retirement'} for ${name}`, () => {\n      expect(parseDevCommitCount(raw), JSON.stringify(raw)).to.equal(hasDevCommits);\n    });\n  });\n});\n\ndescribe('touchesBeyondBitmap', () => {\n  it('is false for an empty diff and for a .bitmap-only commit', () => {\n    expect(touchesBeyondBitmap('')).to.equal(false);\n    expect(touchesBeyondBitmap('\\n')).to.equal(false);\n    expect(touchesBeyondBitmap('.bitmap\\n')).to.equal(false);\n  });\n\n  it('is true when any source file rides in the same commit as the .bitmap write', () => {\n    expect(touchesBeyondBitmap('.bitmap\\ncomp1/index.js\\n')).to.equal(true);\n    expect(touchesBeyondBitmap('comp1/index.js\\n')).to.equal(true);\n  });\n});\n\ndescribe('oldestCommitIsNonSync', () => {\n  it('is false for an empty range — no commits at all', () => {\n    expect(oldestCommitIsNonSync('')).to.equal(false);\n  });\n\n  it('is false when the oldest (first, with --reverse) record is bit-authored', () => {\n    // A normal bit-created branch: its own first ledger commit, then a later human dev commit and a\n    // second ledger commit from export-branch — non-sync work, but never the OLDEST record.\n    const log = [LANE_SYNC, 'feat: a later, normal dev commit\\n', MAIN_SYNC].join('\\x1e');\n    expect(oldestCommitIsNonSync(log)).to.equal(false);\n  });\n\n  it('is true when the oldest (first, with --reverse) record is a genuine, non-sync commit', () => {\n    // Adoption's exact shape: the branch's own first commit was a human's, before bit ever touched it.\n    const log = ['feat: a human created this branch before adoption\\n', LANE_SYNC].join('\\x1e');\n    expect(oldestCommitIsNonSync(log)).to.equal(true);\n  });\n\n  it('ignores a trailing separator with nothing after it', () => {\n    const log = `${LANE_SYNC}\\x1e`;\n    expect(oldestCommitIsNonSync(log)).to.equal(false);\n  });\n\n  // A ledger commit needs the marker AND the Bit-Lane-Head trailer; a human message that merely\n  // quotes [bit-sync] on its own line must still read as independent history (a keep, never a delete).\n  it('is true when the oldest human commit quotes the [bit-sync] marker but has no ledger trailer', () => {\n    const spoof = 'feat: mention our tooling\\n\\n[bit-sync]\\n';\n    const log = [spoof, LANE_SYNC].join('\\x1e');\n    expect(oldestCommitIsNonSync(log)).to.equal(true);\n  });\n});\n\ndescribe('fingerprintIdVersions', () => {\n  it('is a single 40-hex token, and stable under reordering', () => {\n    // A single token survives being written into a commit trailer; order-stability keeps neither\n    // listing order looking like a state change.\n    const a = `${DEFAULT_SCOPE}/comp1@${SNAP_1}`;\n    const b = `${DEFAULT_SCOPE}/comp2@${SNAP_2}`;\n    expect(fingerprintIdVersions([a])).to.match(/^[0-9a-f]{40}$/);\n    expect(fingerprintIdVersions([a, b])).to.equal(fingerprintIdVersions([b, a]));\n  });\n});\n\ndescribe('branchStateFingerprint', () => {\n  const laneIds = [`${DEFAULT_SCOPE}/comp1`, `${DEFAULT_SCOPE}/comp2`];\n\n  it('equals the lane fingerprint when the branch records every lane component at the lane head', () => {\n    // Computed the way `laneHeadFingerprint` computes it — the two sides must be comparable.\n    const laneSide = fingerprintIdVersions([`${DEFAULT_SCOPE}/comp1@${SNAP_1}`, `${DEFAULT_SCOPE}/comp2@${SNAP_2}`]);\n    expect(branchStateFingerprint(onLane(), laneIds)).to.equal(laneSide);\n  });\n\n  it('differs when the lane moved a component the branch has not caught up with', () => {\n    const laneMoved = fingerprintIdVersions([\n      `${DEFAULT_SCOPE}/comp1@${SNAP_1}`,\n      `${DEFAULT_SCOPE}/comp2@${'c'.repeat(40)}`,\n    ]);\n    expect(branchStateFingerprint(onLane(), laneIds)).to.not.equal(laneMoved);\n  });\n\n  it('counts a lane component the branch does not have at all', () => {\n    // Without the placeholder, \"the lane grew a component\" would fingerprint identically to \"converged\".\n    const grown = [...laneIds, `${DEFAULT_SCOPE}/comp3`];\n    expect(branchStateFingerprint(onLane(), grown)).to.not.equal(branchStateFingerprint(onLane(), laneIds));\n    expect(branchStateFingerprint(onLane(), grown)).to.equal(\n      fingerprintIdVersions([\n        `${DEFAULT_SCOPE}/comp1@${SNAP_1}`,\n        `${DEFAULT_SCOPE}/comp2@${SNAP_2}`,\n        `${DEFAULT_SCOPE}/comp3@${ABSENT_ON_BRANCH}`,\n      ])\n    );\n  });\n\n  it('ignores components the branch has that are not on the lane', () => {\n    // The `.bitmap` also carries non-lane components at their main versions; counting those would make\n    // an untouched pair read as diverged after any unrelated release.\n    const withExtra = parseBranchBitmap(\n      bitmapContent({\n        lane: { scope: DEFAULT_SCOPE, name: 'my-lane' },\n        components: { comp1: SNAP_1, comp2: SNAP_2, comp9: '0.0.7' },\n      }),\n      DEFAULT_SCOPE\n    ) as NonNullable<ReturnType<typeof parseBranchBitmap>>;\n    expect(branchStateFingerprint(withExtra, laneIds)).to.equal(branchStateFingerprint(onLane(), laneIds));\n  });\n});\n"],"mappings":"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","ignoreList":[]}