@teambit/ci 1.0.485 → 1.0.487

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

@@ -0,0 +1 @@
+{"version":3,"names":["_chai","data","require","_syncOrchestrator","_syncConfig","orchestrator","SyncOrchestrator","conflicts","all","branch","lane","main","init","describe","it","options","expected","label","JSON","stringify","message","sync","catch","err","forEach","fragment","expect","to","contain","deps","config","workspace","defaultScope","ci","getDefaultBranchName","listGitHostProviders","lanes","getDefaultLaneId","name","logger","console","consoleWarning","debug","result","equal","assertCleanForDryRun","e","paths","Array","from","length","_","index","not","throw","cfg","resolveSyncConfig","branchToLaneName","map","b","syncableLaneNameForBranch","filter","Boolean","deep","prefixed","branchPrefix","undefined","overridden","branches"],"sources":["sync-orchestrator.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport { SyncOrchestrator, assertCleanForDryRun } from './sync-orchestrator';\nimport { branchToLaneName, resolveSyncConfig, syncableLaneNameForBranch } from './sync-config';\n\n// The deps are never reached: every conflict case throws before the first `this.deps` access.\nfunction orchestrator(): SyncOrchestrator {\n  return new SyncOrchestrator({} as any);\n}\n\n/** Each row must name every selector it refused, and which one would otherwise have silently won. */\nconst conflicts: Array<[Record<string, unknown>, string[]]> = [\n  [{ all: true, branch: 'my-branch' }, ['--all cannot be combined with', '--branch (\"my-branch\")']],\n  [{ all: true, lane: 'my-lane' }, ['--all cannot be combined with', 'a lane argument (\"my-lane\")']],\n  [{ all: true, main: true }, ['--all cannot be combined with', '--main']],\n  [\n    { lane: 'my-lane', branch: 'my-branch' },\n    [\n      'a lane argument (\"my-lane\") cannot be combined with --branch (\"my-branch\")',\n      'only --branch (\"my-branch\") would have run',\n    ],\n  ],\n  [\n    { lane: 'my-lane', main: true },\n    ['a lane argument (\"my-lane\") cannot be combined with --main', 'only --main would have run'],\n  ],\n  [\n    { branch: 'my-branch', main: true },\n    ['--branch (\"my-branch\") cannot be combined with --main', 'only --main would have run'],\n  ],\n  [\n    { lane: 'my-lane', branch: 'my-branch', main: true },\n    [\n      'a lane argument (\"my-lane\") cannot be combined with --branch (\"my-branch\") or with --main',\n      'only --main would have run',\n    ],\n  ],\n  // --init only scaffolds, so pairing it with a target could not mean anything.\n  [{ init: true, branch: 'x' }, ['--init cannot be combined']],\n];\n\ndescribe('SyncOrchestrator target guards', () => {\n  it('refuses every combination of selectors, naming the ones it saw', async () => {\n    for (const [options, expected] of conflicts) {\n      const label = JSON.stringify(options);\n      let message = '';\n      await orchestrator()\n        .sync(options as any)\n        .catch((err) => {\n          message = err.message;\n        });\n      expected.forEach((fragment) => expect(message, label).to.contain(fragment));\n    }\n  });\n\n  it('reports a branch whose mapped name is not a valid lane name, instead of syncing it', async () => {\n    const deps = {\n      config: { sync: {} },\n      workspace: { defaultScope: 'org.scope' },\n      ci: { getDefaultBranchName: async () => 'main', listGitHostProviders: () => [] },\n      lanes: { getDefaultLaneId: () => ({ name: 'main' }) },\n      logger: { console() {}, consoleWarning() {}, debug() {} },\n    };\n    const result = await new SyncOrchestrator(deps as any).sync({ branch: 'feature/foo' });\n    expect(result).to.equal('branch feature/foo does not map to a valid lane name; nothing to do');\n  });\n});\n\n// A dry run computes the main-scope plan by force-checking-out the sync branch, so a dirty tree would be\n// discarded by a run that promised to write nothing.\ndescribe('assertCleanForDryRun', () => {\n  it('refuses a dirty tree, naming the paths at stake and how to keep them', () => {\n    let message = '';\n    try {\n      assertCleanForDryRun(['comp1/index.js', 'notes.txt']);\n    } catch (e: any) {\n      message = e.message;\n    }\n    expect(message).to.contain('--dry-run refuses to run');\n    expect(message).to.contain('2 uncommitted change(s)');\n    expect(message).to.contain('comp1/index.js, notes.txt');\n    expect(message).to.contain('Commit or stash them first');\n  });\n\n  it('caps the named paths so a large diff cannot produce an unreadable error', () => {\n    const paths = Array.from({ length: 12 }, (_, index) => `file-${index}.js`);\n    let message = '';\n    try {\n      assertCleanForDryRun(paths);\n    } catch (e: any) {\n      message = e.message;\n    }\n    expect(message).to.contain('12 uncommitted change(s)');\n    expect(message).to.contain('file-9.js');\n    expect(message).to.not.contain('file-10.js');\n    expect(message).to.contain('…');\n  });\n\n  it('permits a clean tree: the write-then-restore is only acceptable when nothing can be lost', () => {\n    expect(() => assertCleanForDryRun([])).to.not.throw();\n  });\n});\n\ndescribe('branch -> lane enumeration filter', () => {\n  it('queues only the branches whose mapped name could actually be a lane', () => {\n    const cfg = resolveSyncConfig({});\n    // non-vacuity: the default mapping really is the identity, so the filter is what excludes anything\n    expect(branchToLaneName('feature/foo', cfg)).to.equal('feature/foo');\n    expect(\n      ['feature/foo', 'FEATURE', 'ok-lane'].map((b) => syncableLaneNameForBranch(b, cfg)).filter(Boolean)\n    ).to.deep.equal(['ok-lane']);\n  });\n\n  it('honours the prefix (stripped before the name is checked) and an explicit branches override', () => {\n    const prefixed = resolveSyncConfig({ branchPrefix: 'lane/' });\n    expect(syncableLaneNameForBranch('lane/my-lane', prefixed)).to.equal('my-lane');\n    expect(syncableLaneNameForBranch('feature/foo', prefixed)).to.equal(undefined);\n    const overridden = resolveSyncConfig({ branches: { 'my-lane': 'custom/branch' } });\n    expect(syncableLaneNameForBranch('custom/branch', overridden)).to.equal('my-lane');\n  });\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,60 @@
+/**
+ * How much of a claim this lane/branch pair has on `origin/<branch>` — the only thing that licenses
+ * retiring it, because `close-pr` deletes the branch. Under the default config every branch name maps
+ * to a same-named lane, and branches cut after a merged sync PR inherit its `.bitmap`, so "looks
+ * bit-managed" is not enough. Evidence = attribution (the branch's `.bitmap` lane pointer) plus
+ * reachability of the state commit / tip from the default branch:
+ *
+ * - `own-live` — names this lane; state commit not in the default branch (real, unmerged lane branch).
+ * - `own-merged` — names this lane; branch tip already in the default branch (deleting loses nothing).
+ * - `own-superseded` — state commit merged but tip not: close the PR, KEEP the branch.
+ * - `inherited-or-none` — no pointer, another lane's, or unreadable: not ours, touch nothing.
+ */
+export type LaneOwnershipEvidence = 'own-live' | 'own-merged' | 'own-superseded' | 'inherited-or-none';
+export type LaneSyncInput = {
+    /** fingerprint of the lane's component heads on bit.cloud; undefined when the lane is gone */
+    laneHead?: string;
+    branchExists: boolean;
+    /**
+     * The lane-component fingerprint as the branch's committed `.bitmap` records it; undefined when the
+     * branch holds no state for this lane. Equality with `laneHead` is the definition of converged.
+     */
+    lastSyncedHead?: string;
+    /** whether the branch carries commits on top of the commit that last wrote its `.bitmap` */
+    hasDevCommits: boolean;
+    /**
+     * Whether the reconciler itself wrote the tip commit. The one exception to "markers are annotations":
+     * consulted only on the branch-deletion path, and only ever to WITHHOLD a deletion. Must be computed
+     * with `isSyncAuthoredMessage`, not the loop guard's substring match.
+     */
+    tipIsSyncCommit: boolean;
+    conflictLabelPresent: boolean;
+    /** @see LaneOwnershipEvidence — consulted only on the "lane is gone" path. */
+    ownership: LaneOwnershipEvidence;
+};
+/**
+ * Why a `close-pr` is keeping the branch rather than deleting it. `tip-advanced-during-run` is the one
+ * the planner never emits: it is discovered when the executor re-reads the branch just before deleting.
+ */
+export type BranchKeepReason = 'unmerged-commits' | 'tip-not-a-sync-commit' | 'tip-advanced-during-run';
+export type LaneSyncAction = {
+    type: 'noop';
+    reason: string;
+} | {
+    type: 'import-lane';
+} | {
+    type: 'export-branch';
+} | {
+    type: 'merge-diverged';
+} | {
+    type: 'close-pr';
+    deleteBranch: true;
+} | {
+    type: 'close-pr';
+    deleteBranch: false;
+    keepReason: BranchKeepReason;
+} | {
+    type: 'halt';
+    reason: string;
+};
+export declare function planLaneSync(input: LaneSyncInput): LaneSyncAction;

package/dist/sync/sync-planner.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.planLaneSync = planLaneSync;
+/**
+ * How much of a claim this lane/branch pair has on `origin/<branch>` — the only thing that licenses
+ * retiring it, because `close-pr` deletes the branch. Under the default config every branch name maps
+ * to a same-named lane, and branches cut after a merged sync PR inherit its `.bitmap`, so "looks
+ * bit-managed" is not enough. Evidence = attribution (the branch's `.bitmap` lane pointer) plus
+ * reachability of the state commit / tip from the default branch:
+ *
+ * - `own-live` — names this lane; state commit not in the default branch (real, unmerged lane branch).
+ * - `own-merged` — names this lane; branch tip already in the default branch (deleting loses nothing).
+ * - `own-superseded` — state commit merged but tip not: close the PR, KEEP the branch.
+ * - `inherited-or-none` — no pointer, another lane's, or unreadable: not ours, touch nothing.
+ */
+
+/**
+ * Why a `close-pr` is keeping the branch rather than deleting it. `tip-advanced-during-run` is the one
+ * the planner never emits: it is discovered when the executor re-reads the branch just before deleting.
+ */
+
+function planLaneSync(input) {
+  const {
+    laneHead,
+    branchExists,
+    lastSyncedHead,
+    hasDevCommits,
+    conflictLabelPresent,
+    ownership
+  } = input;
+  const {
+    tipIsSyncCommit
+  } = input;
+  if (conflictLabelPresent) {
+    return {
+      type: 'noop',
+      reason: 'PR is labeled bit-sync-conflict; resolve and remove the label to resume'
+    };
+  }
+  if (!laneHead) {
+    if (!branchExists) return {
+      type: 'noop',
+      reason: 'lane and branch both absent'
+    };
+    switch (ownership) {
+      case 'own-live':
+        // DELETION NEEDS BOTH HALVES: `.bitmap` attribution alone is not enough — a developer who commits
+        // their own `.bitmap` write (bit create / unexported snap / deps set) looks exactly like
+        // "own-live, nothing above the state commit". The marker can only withhold a deletion, never
+        // authorize one; a false keep is harmless, a false delete destroys the only copy of the work.
+        if (!hasDevCommits && tipIsSyncCommit) return {
+          type: 'close-pr',
+          deleteBranch: true
+        };
+        return {
+          type: 'close-pr',
+          deleteBranch: false,
+          keepReason: hasDevCommits ? 'unmerged-commits' : 'tip-not-a-sync-commit'
+        };
+      case 'own-merged':
+        // No marker conjunction needed: the tip being an ancestor of the default branch is unforgeable
+        // proof that deleting loses nothing.
+        return {
+          type: 'close-pr',
+          deleteBranch: true
+        };
+      case 'own-superseded':
+        // Those commits are in no other ref.
+        return {
+          type: 'close-pr',
+          deleteBranch: false,
+          keepReason: 'unmerged-commits'
+        };
+      default:
+        return {
+          type: 'noop',
+          reason: 'branch maps to no lane and has no sync history of its own; ignoring'
+        };
+    }
+  }
+  if (!branchExists) return {
+    type: 'import-lane'
+  };
+  if (!lastSyncedHead) {
+    if (hasDevCommits) {
+      return {
+        type: 'halt',
+        reason: 'branch has commits but its .bitmap records no state for this lane; cannot tell which side is newer'
+      };
+    }
+    return {
+      type: 'import-lane'
+    };
+  }
+  const laneMoved = laneHead !== lastSyncedHead;
+  if (laneMoved && hasDevCommits) return {
+    type: 'merge-diverged'
+  };
+  if (laneMoved) return {
+    type: 'import-lane'
+  };
+  if (hasDevCommits) return {
+    type: 'export-branch'
+  };
+  return {
+    type: 'noop',
+    reason: 'converged'
+  };
+}
+
+//# sourceMappingURL=sync-planner.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["planLaneSync","input","laneHead","branchExists","lastSyncedHead","hasDevCommits","conflictLabelPresent","ownership","tipIsSyncCommit","type","reason","deleteBranch","keepReason","laneMoved"],"sources":["sync-planner.ts"],"sourcesContent":["/**\n * How much of a claim this lane/branch pair has on `origin/<branch>` — the only thing that licenses\n * retiring it, because `close-pr` deletes the branch. Under the default config every branch name maps\n * to a same-named lane, and branches cut after a merged sync PR inherit its `.bitmap`, so \"looks\n * bit-managed\" is not enough. Evidence = attribution (the branch's `.bitmap` lane pointer) plus\n * reachability of the state commit / tip from the default branch:\n *\n * - `own-live` — names this lane; state commit not in the default branch (real, unmerged lane branch).\n * - `own-merged` — names this lane; branch tip already in the default branch (deleting loses nothing).\n * - `own-superseded` — state commit merged but tip not: close the PR, KEEP the branch.\n * - `inherited-or-none` — no pointer, another lane's, or unreadable: not ours, touch nothing.\n */\nexport type LaneOwnershipEvidence = 'own-live' | 'own-merged' | 'own-superseded' | 'inherited-or-none';\n\nexport type LaneSyncInput = {\n  /** fingerprint of the lane's component heads on bit.cloud; undefined when the lane is gone */\n  laneHead?: string;\n  branchExists: boolean;\n  /**\n   * The lane-component fingerprint as the branch's committed `.bitmap` records it; undefined when the\n   * branch holds no state for this lane. Equality with `laneHead` is the definition of converged.\n   */\n  lastSyncedHead?: string;\n  /** whether the branch carries commits on top of the commit that last wrote its `.bitmap` */\n  hasDevCommits: boolean;\n  /**\n   * Whether the reconciler itself wrote the tip commit. The one exception to \"markers are annotations\":\n   * consulted only on the branch-deletion path, and only ever to WITHHOLD a deletion. Must be computed\n   * with `isSyncAuthoredMessage`, not the loop guard's substring match.\n   */\n  tipIsSyncCommit: boolean;\n  conflictLabelPresent: boolean;\n  /** @see LaneOwnershipEvidence — consulted only on the \"lane is gone\" path. */\n  ownership: LaneOwnershipEvidence;\n};\n\n/**\n * Why a `close-pr` is keeping the branch rather than deleting it. `tip-advanced-during-run` is the one\n * the planner never emits: it is discovered when the executor re-reads the branch just before deleting.\n */\nexport type BranchKeepReason = 'unmerged-commits' | 'tip-not-a-sync-commit' | 'tip-advanced-during-run';\n\nexport type LaneSyncAction =\n  | { type: 'noop'; reason: string }\n  | { type: 'import-lane' }\n  | { type: 'export-branch' }\n  | { type: 'merge-diverged' }\n  // Two variants rather than an optional `keepReason` so the type enforces that a keep always says why.\n  | { type: 'close-pr'; deleteBranch: true }\n  | { type: 'close-pr'; deleteBranch: false; keepReason: BranchKeepReason }\n  | { type: 'halt'; reason: string };\n\nexport function planLaneSync(input: LaneSyncInput): LaneSyncAction {\n  const { laneHead, branchExists, lastSyncedHead, hasDevCommits, conflictLabelPresent, ownership } = input;\n  const { tipIsSyncCommit } = input;\n  if (conflictLabelPresent) {\n    return { type: 'noop', reason: 'PR is labeled bit-sync-conflict; resolve and remove the label to resume' };\n  }\n  if (!laneHead) {\n    if (!branchExists) return { type: 'noop', reason: 'lane and branch both absent' };\n    switch (ownership) {\n      case 'own-live':\n        // DELETION NEEDS BOTH HALVES: `.bitmap` attribution alone is not enough — a developer who commits\n        // their own `.bitmap` write (bit create / unexported snap / deps set) looks exactly like\n        // \"own-live, nothing above the state commit\". The marker can only withhold a deletion, never\n        // authorize one; a false keep is harmless, a false delete destroys the only copy of the work.\n        if (!hasDevCommits && tipIsSyncCommit) return { type: 'close-pr', deleteBranch: true };\n        return {\n          type: 'close-pr',\n          deleteBranch: false,\n          keepReason: hasDevCommits ? 'unmerged-commits' : 'tip-not-a-sync-commit',\n        };\n      case 'own-merged':\n        // No marker conjunction needed: the tip being an ancestor of the default branch is unforgeable\n        // proof that deleting loses nothing.\n        return { type: 'close-pr', deleteBranch: true };\n      case 'own-superseded':\n        // Those commits are in no other ref.\n        return { type: 'close-pr', deleteBranch: false, keepReason: 'unmerged-commits' };\n      default:\n        return { type: 'noop', reason: 'branch maps to no lane and has no sync history of its own; ignoring' };\n    }\n  }\n  if (!branchExists) return { type: 'import-lane' };\n  if (!lastSyncedHead) {\n    if (hasDevCommits) {\n      return {\n        type: 'halt',\n        reason: 'branch has commits but its .bitmap records no state for this lane; cannot tell which side is newer',\n      };\n    }\n    return { type: 'import-lane' };\n  }\n  const laneMoved = laneHead !== lastSyncedHead;\n  if (laneMoved && hasDevCommits) return { type: 'merge-diverged' };\n  if (laneMoved) return { type: 'import-lane' };\n  if (hasDevCommits) return { type: 'export-branch' };\n  return { type: 'noop', reason: 'converged' };\n}\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAyBA;AACA;AACA;AACA;;AAaO,SAASA,YAAYA,CAACC,KAAoB,EAAkB;EACjE,MAAM;IAAEC,QAAQ;IAAEC,YAAY;IAAEC,cAAc;IAAEC,aAAa;IAAEC,oBAAoB;IAAEC;EAAU,CAAC,GAAGN,KAAK;EACxG,MAAM;IAAEO;EAAgB,CAAC,GAAGP,KAAK;EACjC,IAAIK,oBAAoB,EAAE;IACxB,OAAO;MAAEG,IAAI,EAAE,MAAM;MAAEC,MAAM,EAAE;IAA0E,CAAC;EAC5G;EACA,IAAI,CAACR,QAAQ,EAAE;IACb,IAAI,CAACC,YAAY,EAAE,OAAO;MAAEM,IAAI,EAAE,MAAM;MAAEC,MAAM,EAAE;IAA8B,CAAC;IACjF,QAAQH,SAAS;MACf,KAAK,UAAU;QACb;QACA;QACA;QACA;QACA,IAAI,CAACF,aAAa,IAAIG,eAAe,EAAE,OAAO;UAAEC,IAAI,EAAE,UAAU;UAAEE,YAAY,EAAE;QAAK,CAAC;QACtF,OAAO;UACLF,IAAI,EAAE,UAAU;UAChBE,YAAY,EAAE,KAAK;UACnBC,UAAU,EAAEP,aAAa,GAAG,kBAAkB,GAAG;QACnD,CAAC;MACH,KAAK,YAAY;QACf;QACA;QACA,OAAO;UAAEI,IAAI,EAAE,UAAU;UAAEE,YAAY,EAAE;QAAK,CAAC;MACjD,KAAK,gBAAgB;QACnB;QACA,OAAO;UAAEF,IAAI,EAAE,UAAU;UAAEE,YAAY,EAAE,KAAK;UAAEC,UAAU,EAAE;QAAmB,CAAC;MAClF;QACE,OAAO;UAAEH,IAAI,EAAE,MAAM;UAAEC,MAAM,EAAE;QAAsE,CAAC;IAC1G;EACF;EACA,IAAI,CAACP,YAAY,EAAE,OAAO;IAAEM,IAAI,EAAE;EAAc,CAAC;EACjD,IAAI,CAACL,cAAc,EAAE;IACnB,IAAIC,aAAa,EAAE;MACjB,OAAO;QACLI,IAAI,EAAE,MAAM;QACZC,MAAM,EAAE;MACV,CAAC;IACH;IACA,OAAO;MAAED,IAAI,EAAE;IAAc,CAAC;EAChC;EACA,MAAMI,SAAS,GAAGX,QAAQ,KAAKE,cAAc;EAC7C,IAAIS,SAAS,IAAIR,aAAa,EAAE,OAAO;IAAEI,IAAI,EAAE;EAAiB,CAAC;EACjE,IAAII,SAAS,EAAE,OAAO;IAAEJ,IAAI,EAAE;EAAc,CAAC;EAC7C,IAAIJ,aAAa,EAAE,OAAO;IAAEI,IAAI,EAAE;EAAgB,CAAC;EACnD,OAAO;IAAEA,IAAI,EAAE,MAAM;IAAEC,MAAM,EAAE;EAAY,CAAC;AAC9C","ignoreList":[]}

package/dist/sync/sync-planner.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,210 @@
+"use strict";
+
+function _chai() {
+  const data = require("chai");
+  _chai = function () {
+    return data;
+  };
+  return data;
+}
+function _syncPlanner() {
+  const data = require("./sync-planner");
+  _syncPlanner = function () {
+    return data;
+  };
+  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 base = {
+  laneHead: 'L1',
+  branchExists: true,
+  lastSyncedHead: 'L1',
+  hasDevCommits: false,
+  tipIsSyncCommit: true,
+  conflictLabelPresent: false,
+  ownership: 'own-live'
+};
+
+/** the "lane deleted remotely, branch still there" shape — the only path that reads `ownership` */
+const laneGone = ownership => ({
+  laneHead: undefined,
+  ownership
+});
+
+/**
+ * The decision table. `action` (exact) is required on every row that decides a branch deletion: under
+ * the defaults an ordinary developer branch reaches the planner in the same shape as a deleted lane's
+ * branch, so `deleteBranch` and the keep reason are part of the contract, not incidental output.
+ */
+const table = [{
+  name: 'converged -> noop',
+  input: {},
+  type: 'noop',
+  reason: 'converged'
+}, {
+  name: 'conflict label present -> noop until resolved',
+  input: {
+    laneHead: 'L2',
+    conflictLabelPresent: true
+  },
+  type: 'noop'
+}, {
+  name: 'lane gone + no branch -> noop',
+  input: {
+    laneHead: undefined,
+    branchExists: false
+  },
+  type: 'noop'
+}, {
+  name: "own-live, no dev commits, OUR tip (the branch is exactly the lane's mirror) -> close-pr AND delete",
+  input: laneGone('own-live'),
+  type: 'close-pr',
+  action: {
+    type: 'close-pr',
+    deleteBranch: true
+  }
+}, {
+  // A developer who commits their own `.bitmap` write looks own-live with nothing above the state
+  // commit; the marker is what separates our mirror from their branch.
+  name: 'own-live, no dev commits, a tip WE DID NOT WRITE -> close-pr but KEEP the branch',
+  input: _objectSpread(_objectSpread({}, laneGone('own-live')), {}, {
+    tipIsSyncCommit: false
+  }),
+  type: 'close-pr',
+  action: {
+    type: 'close-pr',
+    deleteBranch: false,
+    keepReason: 'tip-not-a-sync-commit'
+  }
+}, {
+  name: 'own-live WITH dev commits (never-exported work above the state commit) -> KEEP the branch',
+  input: _objectSpread(_objectSpread({}, laneGone('own-live')), {}, {
+    hasDevCommits: true
+  }),
+  type: 'close-pr',
+  action: {
+    type: 'close-pr',
+    deleteBranch: false,
+    keepReason: 'unmerged-commits'
+  }
+}, {
+  // "tip-not-a-sync-commit" would send the reader after the wrong thing when there is real work.
+  name: 'own-live with dev commits AND a foreign tip -> keeps, naming the commits as the reason',
+  input: _objectSpread(_objectSpread({}, laneGone('own-live')), {}, {
+    hasDevCommits: true,
+    tipIsSyncCommit: false
+  }),
+  type: 'close-pr',
+  action: {
+    type: 'close-pr',
+    deleteBranch: false,
+    keepReason: 'unmerged-commits'
+  }
+}, {
+  name: 'own-merged (branch tip already in the default branch) -> close-pr AND delete',
+  input: laneGone('own-merged'),
+  type: 'close-pr',
+  action: {
+    type: 'close-pr',
+    deleteBranch: true
+  }
+}, {
+  // Reachability alone proves deleting loses nothing, so no marker conjunction applies here.
+  name: 'own-merged deletes even with a foreign tip and dev commits',
+  input: _objectSpread(_objectSpread({}, laneGone('own-merged')), {}, {
+    tipIsSyncCommit: false,
+    hasDevCommits: true
+  }),
+  type: 'close-pr',
+  action: {
+    type: 'close-pr',
+    deleteBranch: true
+  }
+}, {
+  name: 'own-superseded (PR merged, then more commits pushed) -> close-pr but KEEP the branch',
+  input: laneGone('own-superseded'),
+  type: 'close-pr',
+  action: {
+    type: 'close-pr',
+    deleteBranch: false,
+    keepReason: 'unmerged-commits'
+  }
+}, {
+  name: 'inherited-or-none -> noop, and never close-pr',
+  input: laneGone('inherited-or-none'),
+  type: 'noop',
+  reason: 'maps to no lane and has no sync history'
+}, {
+  name: 'inherited-or-none with the branch carrying its own dev commits -> still noop',
+  input: _objectSpread(_objectSpread({}, laneGone('inherited-or-none')), {}, {
+    lastSyncedHead: undefined,
+    hasDevCommits: true
+  }),
+  type: 'noop'
+},
+// The adopt paths need no claim: nothing on them can delete a branch.
+{
+  name: 'no branch yet -> import-lane',
+  input: {
+    branchExists: false,
+    lastSyncedHead: undefined,
+    ownership: 'inherited-or-none'
+  },
+  type: 'import-lane'
+}, {
+  name: 'lane moved, branch untouched -> import-lane',
+  input: {
+    laneHead: 'L2'
+  },
+  type: 'import-lane'
+}, {
+  name: 'dev commits, lane unchanged -> export-branch',
+  input: {
+    hasDevCommits: true
+  },
+  type: 'export-branch'
+}, {
+  name: 'both moved -> merge-diverged',
+  input: {
+    laneHead: 'L2',
+    hasDevCommits: true
+  },
+  type: 'merge-diverged'
+}, {
+  name: 'existing branch, never synced, no dev commits, lane EXISTS -> import-lane (adopt branch)',
+  input: {
+    lastSyncedHead: undefined,
+    ownership: 'inherited-or-none'
+  },
+  type: 'import-lane'
+}, {
+  name: 'existing branch, never synced, has dev commits, lane EXISTS -> halt (ambiguous)',
+  input: {
+    lastSyncedHead: undefined,
+    ownership: 'inherited-or-none',
+    hasDevCommits: true
+  },
+  type: 'halt'
+}];
+describe('planLaneSync', () => {
+  table.forEach(({
+    name,
+    input,
+    type,
+    action,
+    reason
+  }) => {
+    it(name, () => {
+      const result = (0, _syncPlanner().planLaneSync)(_objectSpread(_objectSpread({}, base), input));
+      (0, _chai().expect)(result.type, name).to.equal(type);
+      if (action) (0, _chai().expect)(result).to.deep.equal(action);
+      if (reason) (0, _chai().expect)(result.reason).to.contain(reason);
+    });
+  });
+});
+
+//# sourceMappingURL=sync-planner.spec.js.map

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

@@ -0,0 +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","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    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-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 -> halt (ambiguous)',\n    input: { lastSyncedHead: undefined, ownership: 'inherited-or-none', hasDevCommits: true },\n    type: 'halt',\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

@@ -0,0 +1,94 @@
+/**
+ * Sync state is derived from the `.bitmap` committed on a branch — the lane pointer (`_bit_lane`) and the
+ * per-component versions — never from commit messages, which are forgeable and rewritten by squash/rebase.
+ */
+/** What a branch's committed `.bitmap` says about the branch's bit state. */
+export type BranchBitmapState = {
+    /**
+     * The scope-qualified lane id `.bitmap` points at (`<scope>/<name>`), or undefined when there is no
+     * usable pointer — none at all (branch on main), or one bit marked not exported.
+     */
+    laneIdStr?: string;
+    /** `<scope>/<name>` -> version (a snap hash, or a semver tag on main), exactly as `.bitmap` records it. */
+    versions: Record<string, string>;
+};
+/**
+ * Parse a `.bitmap` file's content — no workspace, no filesystem. Fail-safe: an unreadable file returns
+ * undefined, and a pointer that parses but cannot attribute (unscoped id, `exported: false`) withholds
+ * `laneIdStr`; either way no lane id licenses nothing, so a parse failure can never authorize a deletion.
+ * An unexported pointer is ignored because its lane never existed on any remote and treating it as a
+ * mirror would retire the branch.
+ */
+export declare function parseBranchBitmap(content: string | undefined, defaultScope: string): BranchBitmapState | undefined;
+/**
+ * Fingerprint of `<component-id>@<version>` pairs: sorted (so listing/key order cannot perturb it), then
+ * sha1'd (the value doubles as a single-token `Bit-Lane-Head` trailer).
+ */
+export declare function fingerprintIdVersions(idAtVersion: string[]): string;
+/**
+ * Placeholder for a lane component the branch's `.bitmap` lacks. It must participate in the fingerprint,
+ * or "the lane grew a component" would fingerprint identically to "converged".
+ */
+export declare const ABSENT_ON_BRANCH = "<absent>";
+/**
+ * What the branch reflects, comparable to the lane's own fingerprint. Only the lane's components count:
+ * the `.bitmap` also carries non-lane components at their main versions, and including those would make
+ * an untouched pair read as diverged after any unrelated release.
+ */
+export declare function branchStateFingerprint(state: BranchBitmapState, laneComponentIds: string[]): string;
+export declare const LANE_HEAD_TRAILER = "Bit-Lane-Head";
+/**
+ * Marks a commit as machine-generated. Duplicated in the `bit-git-sync` action repo's event router
+ * (the loop guard) — changing one copy without the other makes the reconciler re-trigger itself.
+ */
+export declare const SYNC_COMMIT_MARKER = "[bit-sync]";
+export declare const CONFLICT_LABEL = "bit-sync-conflict";
+/**
+ * Permissive substring probe for "looks machine-generated" — the loop guard. Must NOT decide anything
+ * irreversible; see `isSyncAuthoredMessage`.
+ */
+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, so a developer merely quoting the marker must never count as authorship. `\r?` tolerates CRLF;
+ * a recognition failure errs toward keeping the branch.
+ */
+export declare function isSyncAuthoredMessage(message: string): boolean;
+/**
+ * The sync commit's message. Every part is an annotation (audit trail + loop-guard marker); nothing reads
+ * it as state — messages are forgeable and rewritten on squash-merge. State comes from `.bitmap`.
+ */
+export declare function buildSyncCommitMessage(laneIdStr: string, laneHead: string): string;
+export type BranchSyncState = {
+    /**
+     * The newest first-parent commit that changed `.bitmap` — the reachability anchor for branch ownership
+     * and the baseline for `hasDevCommits`. Undefined when `.bitmap` was never written on the branch.
+     */
+    stateCommit?: string;
+    /**
+     * The branch tip's `.bitmap`, parsed; undefined when absent/unparseable (treated as "not ours").
+     * Reading at the tip equals reading at `stateCommit` — nothing after it changed the file.
+     */
+    bitmap?: BranchBitmapState;
+    /** Whether the branch carries commits on top of its bit state — work bit has not seen. */
+    hasDevCommits: boolean;
+    /** The branch tip's full commit message (subject + body), for the sync-marker loop-guard probe. */
+    tipMessage: string;
+    /**
+     * The tip sha every field above was read from. The retirement path re-reads the branch and refuses to
+     * delete anything else — the evidence licensed deleting THIS commit, not a later one.
+     */
+    tipSha?: string;
+};
+/**
+ * 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
+ * output is reachable — simple-git's `raw` resolves with it on some non-zero exits.
+ */
+export declare function parseDevCommitCount(raw: string): boolean;
+/**
+ * Read a remote branch's sync state from its committed `.bitmap`. Assumes `git fetch origin` already ran.
+ * `--first-parent` is a correctness requirement: `git log` orders across all parents, so a `.bitmap`
+ * 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>;