@teambit/ci 1.0.533 → 1.0.535

package/dist/lane-archive-guard.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Decides whether `bit ci merge` may archive the lane it just released.
+ *
+ * A lane is hosted on one scope, but its components can belong to many. Each scope's repository
+ * releases only its own slice (the components in its `.bitmap`), so "this repository merged its
+ * pull request" is not "the lane is fully released". Archiving after the first slice strands the
+ * other slices on a lane nobody can read any more, and every other repository's `bit ci sync`
+ * then closes its mirror pull request as if the lane had been deleted.
+ *
+ * The rule: archive only when every component outside this release — another scope's, or a hidden
+ * dependent of this scope that no `.bitmap` lists — is released: either this very
+ * run tagged and exported it (the one-repository, many-scopes shape of `bit ci merge`), or it is
+ * already on its own scope's main. "On main" is read two ways,
+ * because a release reaches main two ways: the lane head is in main's history (a `bit lane merge`),
+ * or main's head carries the same files as the lane head (`bit ci merge` checks the branch content
+ * out and tags it, so the lane snaps never enter main's ancestry). The last repository to release
+ * archives the lane. When a state cannot be determined, the lane stays open — an open lane costs
+ * a manual `bit lane remove`, an archived one costs the work on it.
+ */
+import type { ComponentID } from '@teambit/component-id';
+import type { LaneId } from '@teambit/lane-id';
+import type { ModelComponent, Repository, Version } from '@teambit/objects';
+export type ForeignLaneComponent = {
+    /** the component id, without a version */
+    id: string;
+    /** the scope the component belongs to (never this repository's `defaultScope`) */
+    scope: string;
+    /**
+     * `true` when this run tagged and exported the component from this very lane head, or the lane head is already on the
+     * component's main — in its history, or as the content of its head — or, for a component the lane
+     * deletes, when its main is already removed;
+     * `false` when it is not (including a component that has no main yet);
+     * `undefined` when the state could not be read.
+     */
+    released: boolean | undefined;
+};
+export type LaneArchiveDecision = {
+    archive: boolean;
+    /** what to tell the user; empty when nothing beyond the archive itself is worth saying */
+    summary: string;
+    /** the lane the decision was made on (see `laneFingerprint`); absent when the lane is gone */
+    fingerprint?: string;
+};
+/** What reading the lane and its foreign components' main history needs from the workspace. */
+/** One versioned entry on a lane. `isDeleted` marks a component the lane deletes on merge. */
+export type LaneEntry = {
+    id: ComponentID;
+    head: string;
+    isDeleted?: boolean;
+    hidden?: boolean;
+};
+/**
+ * A lane as read from its hosting scope for the archive decision: the listed components — deleted
+ * ones included, since a deletion is lane work the owning scope's release applies — and the hidden
+ * `updateDependents` cascade entries.
+ */
+export type LaneSnapshot = {
+    components: LaneEntry[];
+    updateDependents: LaneEntry[];
+    /** the lane's readme component and its head, when one is set — lane state a writer can change too */
+    readme?: string;
+};
+export type LaneArchiveDeps = {
+    /** the remote lane, from its hosting scope; rejects with "was not found" when the lane is gone */
+    /** the lane as its hosting scope holds it, deletions and hidden entries included; `undefined` only when the scope has no such lane */
+    readLane(laneId: LaneId): Promise<LaneSnapshot | undefined>;
+    /** fetch the main history of these components from their own scopes; tolerate a missing main */
+    importMainObjects(ids: ComponentID[]): Promise<void>;
+    getModelComponent(id: ComponentID): Promise<ModelComponent | undefined>;
+    /** fetch these raw objects (lane heads) from the lane's hosting scope, if missing locally */
+    importObjectsByHashes(scope: string, hashes: string[]): Promise<void>;
+    /**
+     * the lane head this run tagged and exported the component from, if this run released it; a lane
+     * entry counts as released here only while it still sits at that head
+     */
+    releasedHeadByThisRun(id: ComponentID): string | undefined;
+    objects: Repository;
+    warn(message: string): void;
+};
+export declare function decideLaneArchive(laneId: string, defaultScope: string, foreign: ForeignLaneComponent[]): LaneArchiveDecision;
+export declare function sameReleasedState(lane: Version, main: Version, laneComponentIds: string[], mainHeadOf: ReadonlyMap<string, string | undefined>): boolean;
+/**
+ * Every versioned entry on the lane: the listed components and the hidden `updateDependents`
+ * cascade entries. The hidden entries are lane state too — they carry snaps, they can be foreign,
+ * and a release must account for them — even though no `.bitmap` ever lists them.
+ */
+export declare function allLaneEntries(lane: LaneSnapshot): LaneEntry[];
+/**
+ * The lane's `id@head` set — each entry with its bucket (visible or hidden) and deletion mark — and its
+ * readme: what an archive decision is made on, and what must not move before it acts.
+ */
+export declare function laneFingerprint(lane: LaneSnapshot): string;
+/**
+ * The remote lane, or `undefined` when its hosting scope no longer has it — a positive answer from
+ * the dependency (bit's own "no such lane"), never inferred from an error's text. Throws on any
+ * other failure to read it, and a lane that cannot be read is never archived.
+ */
+export declare function readRemoteLane(laneId: LaneId, deps: LaneArchiveDeps): Promise<LaneSnapshot | undefined>;
+/**
+ * For each component on the remote lane outside this release — another scope's, or a hidden
+ * dependent of this scope: is it released? Returns
+ * `undefined` when the lane no longer exists on its hosting scope. Throws when the lane cannot be
+ * read for any other reason.
+ */
+export declare function foreignLaneComponentsReleaseState(laneId: LaneId, lane: LaneSnapshot, defaultScope: string, deps: LaneArchiveDeps): Promise<ForeignLaneComponent[]>;
+/**
+ * The archive decision for a lane the merge just released. A lane that is already gone archives
+ * "as before" (the caller's archive reports not-found the way it always has); a lane that cannot
+ * be read stays open.
+ */
+export declare function laneArchiveDecision(laneId: LaneId, defaultScope: string, deps: LaneArchiveDeps): Promise<LaneArchiveDecision>;
+/**
+ * The lane moved between the decision and the archive: another writer exported to it. The
+ * decision is stale; archiving now could remove work nobody has looked at.
+ */
+export declare function laneMovedSummary(laneId: string): string;
+/** The lane could not be re-read right before the archive; without a current state, archiving is unsafe. */
+export declare function laneUnreadableBeforeArchiveSummary(laneId: string, error: string): string;

package/dist/lane-archive-guard.js

@@ -0,0 +1,314 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.allLaneEntries = allLaneEntries;
+exports.decideLaneArchive = decideLaneArchive;
+exports.foreignLaneComponentsReleaseState = foreignLaneComponentsReleaseState;
+exports.laneArchiveDecision = laneArchiveDecision;
+exports.laneFingerprint = laneFingerprint;
+exports.laneMovedSummary = laneMovedSummary;
+exports.laneUnreadableBeforeArchiveSummary = laneUnreadableBeforeArchiveSummary;
+exports.readRemoteLane = readRemoteLane;
+exports.sameReleasedState = sameReleasedState;
+function _objects() {
+  const data = require("@teambit/objects");
+  _objects = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component.snap-distance");
+  _component = 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); } /**
+ * Decides whether `bit ci merge` may archive the lane it just released.
+ *
+ * A lane is hosted on one scope, but its components can belong to many. Each scope's repository
+ * releases only its own slice (the components in its `.bitmap`), so "this repository merged its
+ * pull request" is not "the lane is fully released". Archiving after the first slice strands the
+ * other slices on a lane nobody can read any more, and every other repository's `bit ci sync`
+ * then closes its mirror pull request as if the lane had been deleted.
+ *
+ * The rule: archive only when every component outside this release — another scope's, or a hidden
+ * dependent of this scope that no `.bitmap` lists — is released: either this very
+ * run tagged and exported it (the one-repository, many-scopes shape of `bit ci merge`), or it is
+ * already on its own scope's main. "On main" is read two ways,
+ * because a release reaches main two ways: the lane head is in main's history (a `bit lane merge`),
+ * or main's head carries the same files as the lane head (`bit ci merge` checks the branch content
+ * out and tags it, so the lane snaps never enter main's ancestry). The last repository to release
+ * archives the lane. When a state cannot be determined, the lane stays open — an open lane costs
+ * a manual `bit lane remove`, an archived one costs the work on it.
+ */
+/** What reading the lane and its foreign components' main history needs from the workspace. */
+/** One versioned entry on a lane. `isDeleted` marks a component the lane deletes on merge. */
+
+/**
+ * A lane as read from its hosting scope for the archive decision: the listed components — deleted
+ * ones included, since a deletion is lane work the owning scope's release applies — and the hidden
+ * `updateDependents` cascade entries.
+ */
+
+/** How many component ids a message names before it summarizes the rest. */
+const MAX_LISTED = 5;
+function listIds(ids) {
+  const shown = ids.slice(0, MAX_LISTED).join(', ');
+  const rest = ids.length - MAX_LISTED;
+  return rest > 0 ? `${shown} and ${rest} more` : shown;
+}
+function scopesOf(components) {
+  return [...new Set(components.map(c => c.scope))].sort().join(', ');
+}
+function manualArchiveHint(laneId) {
+  return `To archive it by hand once every slice is released: bit lane remove --remote ${laneId}`;
+}
+function decideLaneArchive(laneId, defaultScope, foreign) {
+  if (!foreign.length) return {
+    archive: true,
+    summary: ''
+  };
+  const pending = foreign.filter(c => c.released === false);
+  const unknown = foreign.filter(c => c.released === undefined);
+  if (!pending.length && !unknown.length) {
+    return {
+      archive: true,
+      summary: `All ${foreign.length} component(s) outside this release (scope(s) ${scopesOf(foreign)}) ` + `are already on their main; the lane is fully released.`
+    };
+  }
+  const lines = [`Lane ${laneId} left open.`];
+  if (pending.length) {
+    lines.push(`${pending.length} component(s) from scope(s) ${scopesOf(pending)} are not on their main yet: ` + `${listIds(pending.map(c => c.id))}.`);
+  }
+  if (unknown.length) {
+    lines.push(`The state of ${unknown.length} component(s) from scope(s) ${scopesOf(unknown)} could not be read: ` + `${listIds(unknown.map(c => c.id))}.`);
+  }
+  lines.push(`This repository releases the ${defaultScope} slice only. The repository of each remaining scope ` + `releases its own slice, and the last release archives the lane.`);
+  if ([...pending, ...unknown].some(c => c.scope === defaultScope)) {
+    lines.push(`A hidden dependent of ${defaultScope} is released only by a run that tags a component it depends on.`);
+  }
+  lines.push(manualArchiveHint(laneId));
+  return {
+    archive: false,
+    summary: lines.join('\n')
+  };
+}
+
+/**
+ * Is `main` the released form of `lane`? `bit ci merge` checks the branch out and tags, so the
+ * release carries the lane head's sources and declared dependencies, but not its lineage. The
+ * comparison covers what the release transfers and nothing the release itself rewrites:
+ * - source files (path and content hash) and the main file;
+ * - package dependencies (dependencies, dev, peer) with their ranges;
+ * - component dependencies (dependencies, dev, peer) by id and version — a dependency that is itself
+ *   on the lane is re-versioned by its release, so main must reference that component's main head;
+ * - the binding prefix, the overrides and the package.json changes the component declares;
+ * - every extension's `config` and version, with the same rule for an extension that is itself a
+ *   component on the lane; not `data`, which the release recomputes (builder, dependencies).
+ * Anything else the lane changed (a dependency bump, an env change) leaves `main` different and the
+ * component pending — a false "pending" costs a manual archive, a false "released" costs the work.
+ */
+/**
+ * The extension's identity without a version: a component id (`teambit.envs/envs`) by scope and name,
+ * a legacy package-named extension (`@scope/pkg`) by its name.
+ */
+function extensionKey(ext) {
+  return ext.extensionId ? ext.extensionId.toStringWithoutVersion() : ext.stringId;
+}
+
+/** JSON with object keys in sorted order at every depth, so equal objects serialize equally. */
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`;
+  }
+  return JSON.stringify(value) ?? 'undefined';
+}
+function sameReleasedState(lane, main, laneComponentIds, mainHeadOf) {
+  const onLane = new Set(laneComponentIds);
+  // A component that is itself on the lane is re-versioned by its release. On the lane side its
+  // version is the lane snap; on the main side the released state references its main head — any
+  // other version is a stale main, not a release. Both sides normalize to one token when they hold
+  // the expected version, so only that pairing compares equal.
+  const versionToken = (id, ver, side) => {
+    if (!onLane.has(id)) return ver ?? '';
+    if (side === 'lane') return '<lane>';
+    return ver !== undefined && ver === mainHeadOf.get(id) ? '<lane>' : `stale:${ver}`;
+  };
+  const files = v => v.files.map(f => `${f.relativePath}:${f.file.toString()}`).sort().join('\n');
+  const packages = v => stableStringify([v.packageDependencies, v.devPackageDependencies, v.peerPackageDependencies]);
+  const components = (v, side) => [v.dependencies, v.devDependencies, v.peerDependencies].map(deps => deps.get().map(dep => {
+    const id = dep.id.toStringWithoutVersion();
+    return `${id}@${versionToken(id, dep.id.version, side)}`;
+  }).sort().join(',')).join('|');
+  const configs = (v, side) => stableStringify(v.extensions.map(ext => {
+    const id = extensionKey(ext);
+    const ver = ext.extensionId?.version ?? ext.stringId.split('@')[1];
+    return [id, versionToken(id, ver, side), ext.config ?? {}];
+  }).sort(([a], [b]) => a.localeCompare(b)));
+  const rest = v => stableStringify([v.bindingPrefix, v.overrides, v.packageJsonChangedProps]);
+  return lane.mainFile === main.mainFile && rest(lane) === rest(main) && files(lane) === files(main) && packages(lane) === packages(main) && components(lane, 'lane') === components(main, 'main') && configs(lane, 'lane') === configs(main, 'main');
+}
+
+/**
+ * Is the lane head already on the component's main? Either in main's history, or released onto
+ * main's head. Throws when an object it needs cannot be loaded.
+ */
+async function laneHeadIsOnMain(modelComponent, laneHead, mainHead, laneComponentIds, mainHeadOf, objects) {
+  if (await (0, _component().hasVersionByRef)(modelComponent, laneHead, objects, mainHead)) return true;
+  const laneVersion = await objects.load(laneHead, true);
+  const mainVersion = await objects.load(mainHead, true);
+  return sameReleasedState(laneVersion, mainVersion, laneComponentIds, mainHeadOf);
+}
+
+/**
+ * Every versioned entry on the lane: the listed components and the hidden `updateDependents`
+ * cascade entries. The hidden entries are lane state too — they carry snaps, they can be foreign,
+ * and a release must account for them — even though no `.bitmap` ever lists them.
+ */
+function allLaneEntries(lane) {
+  return [...lane.components, ...lane.updateDependents.map(comp => _objectSpread(_objectSpread({}, comp), {}, {
+    hidden: true
+  }))];
+}
+
+/**
+ * The lane's `id@head` set — each entry with its bucket (visible or hidden) and deletion mark — and its
+ * readme: what an archive decision is made on, and what must not move before it acts.
+ */
+function laneFingerprint(lane) {
+  const entries = allLaneEntries(lane).map(comp => `${comp.id.toStringWithoutVersion()}@${comp.head}${comp.isDeleted ? ' (deleted)' : ''}${comp.hidden ? ' (hidden)' : ''}`).sort();
+  return [...entries, `readme:${lane.readme ?? ''}`].join('\n');
+}
+
+/**
+ * The remote lane, or `undefined` when its hosting scope no longer has it — a positive answer from
+ * the dependency (bit's own "no such lane"), never inferred from an error's text. Throws on any
+ * other failure to read it, and a lane that cannot be read is never archived.
+ */
+async function readRemoteLane(laneId, deps) {
+  return deps.readLane(laneId);
+}
+
+/**
+ * For each component on the remote lane outside this release — another scope's, or a hidden
+ * dependent of this scope: is it released? Returns
+ * `undefined` when the lane no longer exists on its hosting scope. Throws when the lane cannot be
+ * read for any other reason.
+ */
+async function foreignLaneComponentsReleaseState(laneId, lane, defaultScope, deps) {
+  const entries = allLaneEntries(lane);
+  // What this release cannot vouch for: every component of another scope, and the hidden cascade
+  // entries of this scope — no `.bitmap` lists them, and the tag reaches one only when a component
+  // it depends on is tagged in the same run.
+  const foreign = entries.filter(comp => comp.id.scope !== defaultScope || comp.hidden);
+  if (!foreign.length) return [];
+  const laneComponentIds = entries.map(comp => comp.id.toStringWithoutVersion());
+  const entry = (comp, released) => ({
+    id: comp.id.toStringWithoutVersion(),
+    scope: comp.id.scope,
+    released
+  });
+  // A component this run tagged and exported is released by definition — as long as the lane still
+  // sits at the head this run tagged from; a head that moved since is another writer's work. Being
+  // in `.bitmap` is not enough: the tag covers changed components only, and a mirror writes the
+  // defaultScope slice only.
+  const releasedByThisRun = comp => deps.releasedHeadByThisRun(comp.id.changeVersion(undefined)) === comp.head;
+  const releasedHere = foreign.filter(releasedByThisRun);
+  const others = foreign.filter(comp => !releasedByThisRun(comp));
+  if (!others.length) return releasedHere.map(comp => entry(comp, true));
+
+  // Each other component's main history comes from its own scope, and its lane head from the
+  // lane's hosting scope. A component that has no main yet (created on the lane) is simply absent
+  // afterwards, which reads as "not released".
+  let objectsImported = true;
+  try {
+    // every lane component's main is needed: the released state of one references the heads of others
+    await deps.importMainObjects(entries.map(comp => comp.id.changeVersion(undefined)));
+    await deps.importObjectsByHashes(laneId.scope, others.map(comp => comp.head));
+  } catch (e) {
+    deps.warn(`Could not fetch the history of the lane's foreign components: ${e.message}`);
+    objectsImported = false;
+  }
+  const mainHeadOf = new Map();
+  if (objectsImported) {
+    await Promise.all(entries.map(async comp => {
+      const id = comp.id.toStringWithoutVersion();
+      try {
+        const model = await deps.getModelComponent(comp.id.changeVersion(undefined));
+        mainHeadOf.set(id, model?.getHeadAsTagIfExist() ?? model?.getHead()?.toString());
+      } catch {
+        mainHeadOf.set(id, undefined); // unknown head: a reference to it can never read as released
+      }
+    }));
+  }
+  const states = await Promise.all(others.map(async comp => {
+    if (!objectsImported) return entry(comp, undefined);
+    try {
+      const modelComponent = await deps.getModelComponent(comp.id.changeVersion(undefined));
+      const mainHead = modelComponent?.getHead();
+      if (!modelComponent || !mainHead) return entry(comp, false);
+      if (comp.isDeleted) {
+        // the lane deletes this component; released once its own main head carries the deletion.
+        // Read main's head Version itself — ModelComponent.isRemoved() may answer for a lane head.
+        const mainVersion = await deps.objects.load(mainHead, true);
+        return entry(comp, mainVersion.isRemoved());
+      }
+      return entry(comp, await laneHeadIsOnMain(modelComponent, _objects().Ref.from(comp.head), mainHead, laneComponentIds, mainHeadOf, deps.objects));
+    } catch (e) {
+      deps.warn(`Could not read the history of ${comp.id.toStringWithoutVersion()}: ${e.message}`);
+      return entry(comp, undefined);
+    }
+  }));
+  return [...releasedHere.map(comp => entry(comp, true)), ...states];
+}
+
+/**
+ * The archive decision for a lane the merge just released. A lane that is already gone archives
+ * "as before" (the caller's archive reports not-found the way it always has); a lane that cannot
+ * be read stays open.
+ */
+async function laneArchiveDecision(laneId, defaultScope, deps) {
+  let lane;
+  let foreign;
+  try {
+    lane = await readRemoteLane(laneId, deps);
+    foreign = lane && (await foreignLaneComponentsReleaseState(laneId, lane, defaultScope, deps));
+  } catch (e) {
+    return {
+      archive: false,
+      summary: `Could not read lane ${laneId.toString()} to check for components outside this release: ${e.message}\n` + `Leaving the lane open. ${manualArchiveHint(laneId.toString())}`
+    };
+  }
+  if (!lane || !foreign) return {
+    archive: true,
+    summary: ''
+  };
+  return _objectSpread(_objectSpread({}, decideLaneArchive(laneId.toString(), defaultScope, foreign)), {}, {
+    fingerprint: laneFingerprint(lane)
+  });
+}
+
+/**
+ * The lane moved between the decision and the archive: another writer exported to it. The
+ * decision is stale; archiving now could remove work nobody has looked at.
+ */
+function laneMovedSummary(laneId) {
+  return `Lane ${laneId} changed while the release was checking it, so it is left open; ` + `the next release evaluates the new state. ${manualArchiveHint(laneId)}`;
+}
+
+/** The lane could not be re-read right before the archive; without a current state, archiving is unsafe. */
+function laneUnreadableBeforeArchiveSummary(laneId, error) {
+  return `Could not re-read lane ${laneId} before archiving it: ${error}\n` + `Leaving the lane open. ${manualArchiveHint(laneId)}`;
+}
+
+//# sourceMappingURL=lane-archive-guard.js.map

package/dist/lane-archive-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_objects","data","require","_component","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","MAX_LISTED","listIds","ids","shown","slice","join","rest","scopesOf","components","Set","map","c","scope","sort","manualArchiveHint","laneId","decideLaneArchive","defaultScope","foreign","archive","summary","pending","released","unknown","undefined","lines","id","some","extensionKey","ext","extensionId","toStringWithoutVersion","stringId","stableStringify","Array","isArray","entries","a","b","localeCompare","k","v","JSON","stringify","sameReleasedState","lane","main","laneComponentIds","mainHeadOf","onLane","versionToken","ver","side","has","get","files","f","relativePath","file","toString","packages","packageDependencies","devPackageDependencies","peerPackageDependencies","dependencies","devDependencies","peerDependencies","deps","dep","version","configs","extensions","split","config","bindingPrefix","overrides","packageJsonChangedProps","mainFile","laneHeadIsOnMain","modelComponent","laneHead","mainHead","objects","hasVersionByRef","laneVersion","load","mainVersion","allLaneEntries","updateDependents","comp","hidden","laneFingerprint","head","isDeleted","readme","readRemoteLane","readLane","foreignLaneComponentsReleaseState","entry","releasedByThisRun","releasedHeadByThisRun","changeVersion","releasedHere","others","objectsImported","importMainObjects","importObjectsByHashes","warn","message","Map","Promise","all","model","getModelComponent","set","getHeadAsTagIfExist","getHead","states","isRemoved","Ref","from","laneArchiveDecision","fingerprint","laneMovedSummary","laneUnreadableBeforeArchiveSummary","error"],"sources":["lane-archive-guard.ts"],"sourcesContent":["/**\n * Decides whether `bit ci merge` may archive the lane it just released.\n *\n * A lane is hosted on one scope, but its components can belong to many. Each scope's repository\n * releases only its own slice (the components in its `.bitmap`), so \"this repository merged its\n * pull request\" is not \"the lane is fully released\". Archiving after the first slice strands the\n * other slices on a lane nobody can read any more, and every other repository's `bit ci sync`\n * then closes its mirror pull request as if the lane had been deleted.\n *\n * The rule: archive only when every component outside this release — another scope's, or a hidden\n * dependent of this scope that no `.bitmap` lists — is released: either this very\n * run tagged and exported it (the one-repository, many-scopes shape of `bit ci merge`), or it is\n * already on its own scope's main. \"On main\" is read two ways,\n * because a release reaches main two ways: the lane head is in main's history (a `bit lane merge`),\n * or main's head carries the same files as the lane head (`bit ci merge` checks the branch content\n * out and tags it, so the lane snaps never enter main's ancestry). The last repository to release\n * archives the lane. When a state cannot be determined, the lane stays open — an open lane costs\n * a manual `bit lane remove`, an archived one costs the work on it.\n */\nimport type { ComponentID } from '@teambit/component-id';\nimport type { LaneId } from '@teambit/lane-id';\nimport type { ModelComponent, Repository, Version } from '@teambit/objects';\nimport { Ref } from '@teambit/objects';\nimport { hasVersionByRef } from '@teambit/component.snap-distance';\n\nexport type ForeignLaneComponent = {\n  /** the component id, without a version */\n  id: string;\n  /** the scope the component belongs to (never this repository's `defaultScope`) */\n  scope: string;\n  /**\n   * `true` when this run tagged and exported the component from this very lane head, or the lane head is already on the\n   * component's main — in its history, or as the content of its head — or, for a component the lane\n   * deletes, when its main is already removed;\n   * `false` when it is not (including a component that has no main yet);\n   * `undefined` when the state could not be read.\n   */\n  released: boolean | undefined;\n};\n\nexport type LaneArchiveDecision = {\n  archive: boolean;\n  /** what to tell the user; empty when nothing beyond the archive itself is worth saying */\n  summary: string;\n  /** the lane the decision was made on (see `laneFingerprint`); absent when the lane is gone */\n  fingerprint?: string;\n};\n\n/** What reading the lane and its foreign components' main history needs from the workspace. */\n/** One versioned entry on a lane. `isDeleted` marks a component the lane deletes on merge. */\nexport type LaneEntry = { id: ComponentID; head: string; isDeleted?: boolean; hidden?: boolean };\n\n/**\n * A lane as read from its hosting scope for the archive decision: the listed components — deleted\n * ones included, since a deletion is lane work the owning scope's release applies — and the hidden\n * `updateDependents` cascade entries.\n */\nexport type LaneSnapshot = {\n  components: LaneEntry[];\n  updateDependents: LaneEntry[];\n  /** the lane's readme component and its head, when one is set — lane state a writer can change too */\n  readme?: string;\n};\n\nexport type LaneArchiveDeps = {\n  /** the remote lane, from its hosting scope; rejects with \"was not found\" when the lane is gone */\n  /** the lane as its hosting scope holds it, deletions and hidden entries included; `undefined` only when the scope has no such lane */\n  readLane(laneId: LaneId): Promise<LaneSnapshot | undefined>;\n  /** fetch the main history of these components from their own scopes; tolerate a missing main */\n  importMainObjects(ids: ComponentID[]): Promise<void>;\n  getModelComponent(id: ComponentID): Promise<ModelComponent | undefined>;\n  /** fetch these raw objects (lane heads) from the lane's hosting scope, if missing locally */\n  importObjectsByHashes(scope: string, hashes: string[]): Promise<void>;\n  /**\n   * the lane head this run tagged and exported the component from, if this run released it; a lane\n   * entry counts as released here only while it still sits at that head\n   */\n  releasedHeadByThisRun(id: ComponentID): string | undefined;\n  objects: Repository;\n  warn(message: string): void;\n};\n\n/** How many component ids a message names before it summarizes the rest. */\nconst MAX_LISTED = 5;\n\nfunction listIds(ids: string[]): string {\n  const shown = ids.slice(0, MAX_LISTED).join(', ');\n  const rest = ids.length - MAX_LISTED;\n  return rest > 0 ? `${shown} and ${rest} more` : shown;\n}\n\nfunction scopesOf(components: ForeignLaneComponent[]): string {\n  return [...new Set(components.map((c) => c.scope))].sort().join(', ');\n}\n\nfunction manualArchiveHint(laneId: string): string {\n  return `To archive it by hand once every slice is released: bit lane remove --remote ${laneId}`;\n}\n\nexport function decideLaneArchive(\n  laneId: string,\n  defaultScope: string,\n  foreign: ForeignLaneComponent[]\n): LaneArchiveDecision {\n  if (!foreign.length) return { archive: true, summary: '' };\n\n  const pending = foreign.filter((c) => c.released === false);\n  const unknown = foreign.filter((c) => c.released === undefined);\n\n  if (!pending.length && !unknown.length) {\n    return {\n      archive: true,\n      summary:\n        `All ${foreign.length} component(s) outside this release (scope(s) ${scopesOf(foreign)}) ` +\n        `are already on their main; the lane is fully released.`,\n    };\n  }\n\n  const lines = [`Lane ${laneId} left open.`];\n  if (pending.length) {\n    lines.push(\n      `${pending.length} component(s) from scope(s) ${scopesOf(pending)} are not on their main yet: ` +\n        `${listIds(pending.map((c) => c.id))}.`\n    );\n  }\n  if (unknown.length) {\n    lines.push(\n      `The state of ${unknown.length} component(s) from scope(s) ${scopesOf(unknown)} could not be read: ` +\n        `${listIds(unknown.map((c) => c.id))}.`\n    );\n  }\n  lines.push(\n    `This repository releases the ${defaultScope} slice only. The repository of each remaining scope ` +\n      `releases its own slice, and the last release archives the lane.`\n  );\n  if ([...pending, ...unknown].some((c) => c.scope === defaultScope)) {\n    lines.push(`A hidden dependent of ${defaultScope} is released only by a run that tags a component it depends on.`);\n  }\n  lines.push(manualArchiveHint(laneId));\n  return { archive: false, summary: lines.join('\\n') };\n}\n\n/**\n * Is `main` the released form of `lane`? `bit ci merge` checks the branch out and tags, so the\n * release carries the lane head's sources and declared dependencies, but not its lineage. The\n * comparison covers what the release transfers and nothing the release itself rewrites:\n * - source files (path and content hash) and the main file;\n * - package dependencies (dependencies, dev, peer) with their ranges;\n * - component dependencies (dependencies, dev, peer) by id and version — a dependency that is itself\n *   on the lane is re-versioned by its release, so main must reference that component's main head;\n * - the binding prefix, the overrides and the package.json changes the component declares;\n * - every extension's `config` and version, with the same rule for an extension that is itself a\n *   component on the lane; not `data`, which the release recomputes (builder, dependencies).\n * Anything else the lane changed (a dependency bump, an env change) leaves `main` different and the\n * component pending — a false \"pending\" costs a manual archive, a false \"released\" costs the work.\n */\n/**\n * The extension's identity without a version: a component id (`teambit.envs/envs`) by scope and name,\n * a legacy package-named extension (`@scope/pkg`) by its name.\n */\nfunction extensionKey(ext: Version['extensions'][number]): string {\n  return ext.extensionId ? ext.extensionId.toStringWithoutVersion() : ext.stringId;\n}\n\n/** JSON with object keys in sorted order at every depth, so equal objects serialize equally. */\nfunction stableStringify(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;\n  if (value && typeof value === 'object') {\n    const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b));\n    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`;\n  }\n  return JSON.stringify(value) ?? 'undefined';\n}\n\nexport function sameReleasedState(\n  lane: Version,\n  main: Version,\n  laneComponentIds: string[],\n  mainHeadOf: ReadonlyMap<string, string | undefined>\n): boolean {\n  const onLane = new Set(laneComponentIds);\n  // A component that is itself on the lane is re-versioned by its release. On the lane side its\n  // version is the lane snap; on the main side the released state references its main head — any\n  // other version is a stale main, not a release. Both sides normalize to one token when they hold\n  // the expected version, so only that pairing compares equal.\n  const versionToken = (id: string, ver: string | undefined, side: 'lane' | 'main') => {\n    if (!onLane.has(id)) return ver ?? '';\n    if (side === 'lane') return '<lane>';\n    return ver !== undefined && ver === mainHeadOf.get(id) ? '<lane>' : `stale:${ver}`;\n  };\n  const files = (v: Version) =>\n    v.files\n      .map((f) => `${f.relativePath}:${f.file.toString()}`)\n      .sort()\n      .join('\\n');\n  const packages = (v: Version) =>\n    stableStringify([v.packageDependencies, v.devPackageDependencies, v.peerPackageDependencies]);\n  const components = (v: Version, side: 'lane' | 'main') =>\n    [v.dependencies, v.devDependencies, v.peerDependencies]\n      .map((deps) =>\n        deps\n          .get()\n          .map((dep) => {\n            const id = dep.id.toStringWithoutVersion();\n            return `${id}@${versionToken(id, dep.id.version, side)}`;\n          })\n          .sort()\n          .join(',')\n      )\n      .join('|');\n  const configs = (v: Version, side: 'lane' | 'main') =>\n    stableStringify(\n      v.extensions\n        .map((ext) => {\n          const id = extensionKey(ext);\n          const ver = ext.extensionId?.version ?? ext.stringId.split('@')[1];\n          return [id, versionToken(id, ver, side), ext.config ?? {}] as const;\n        })\n        .sort(([a], [b]) => a.localeCompare(b))\n    );\n  const rest = (v: Version) => stableStringify([v.bindingPrefix, v.overrides, v.packageJsonChangedProps]);\n  return (\n    lane.mainFile === main.mainFile &&\n    rest(lane) === rest(main) &&\n    files(lane) === files(main) &&\n    packages(lane) === packages(main) &&\n    components(lane, 'lane') === components(main, 'main') &&\n    configs(lane, 'lane') === configs(main, 'main')\n  );\n}\n\n/**\n * Is the lane head already on the component's main? Either in main's history, or released onto\n * main's head. Throws when an object it needs cannot be loaded.\n */\nasync function laneHeadIsOnMain(\n  modelComponent: ModelComponent,\n  laneHead: Ref,\n  mainHead: Ref,\n  laneComponentIds: string[],\n  mainHeadOf: ReadonlyMap<string, string | undefined>,\n  objects: Repository\n): Promise<boolean> {\n  if (await hasVersionByRef(modelComponent, laneHead, objects, mainHead)) return true;\n  const laneVersion = (await objects.load(laneHead, true)) as Version;\n  const mainVersion = (await objects.load(mainHead, true)) as Version;\n  return sameReleasedState(laneVersion, mainVersion, laneComponentIds, mainHeadOf);\n}\n\n/**\n * Every versioned entry on the lane: the listed components and the hidden `updateDependents`\n * cascade entries. The hidden entries are lane state too — they carry snaps, they can be foreign,\n * and a release must account for them — even though no `.bitmap` ever lists them.\n */\nexport function allLaneEntries(lane: LaneSnapshot): LaneEntry[] {\n  return [...lane.components, ...lane.updateDependents.map((comp) => ({ ...comp, hidden: true }))];\n}\n\n/**\n * The lane's `id@head` set — each entry with its bucket (visible or hidden) and deletion mark — and its\n * readme: what an archive decision is made on, and what must not move before it acts.\n */\nexport function laneFingerprint(lane: LaneSnapshot): string {\n  const entries = allLaneEntries(lane)\n    .map(\n      (comp) =>\n        `${comp.id.toStringWithoutVersion()}@${comp.head}${comp.isDeleted ? ' (deleted)' : ''}${comp.hidden ? ' (hidden)' : ''}`\n    )\n    .sort();\n  return [...entries, `readme:${lane.readme ?? ''}`].join('\\n');\n}\n\n/**\n * The remote lane, or `undefined` when its hosting scope no longer has it — a positive answer from\n * the dependency (bit's own \"no such lane\"), never inferred from an error's text. Throws on any\n * other failure to read it, and a lane that cannot be read is never archived.\n */\nexport async function readRemoteLane(laneId: LaneId, deps: LaneArchiveDeps): Promise<LaneSnapshot | undefined> {\n  return deps.readLane(laneId);\n}\n\n/**\n * For each component on the remote lane outside this release — another scope's, or a hidden\n * dependent of this scope: is it released? Returns\n * `undefined` when the lane no longer exists on its hosting scope. Throws when the lane cannot be\n * read for any other reason.\n */\nexport async function foreignLaneComponentsReleaseState(\n  laneId: LaneId,\n  lane: LaneSnapshot,\n  defaultScope: string,\n  deps: LaneArchiveDeps\n): Promise<ForeignLaneComponent[]> {\n  const entries = allLaneEntries(lane);\n  // What this release cannot vouch for: every component of another scope, and the hidden cascade\n  // entries of this scope — no `.bitmap` lists them, and the tag reaches one only when a component\n  // it depends on is tagged in the same run.\n  const foreign = entries.filter((comp) => comp.id.scope !== defaultScope || comp.hidden);\n  if (!foreign.length) return [];\n  const laneComponentIds = entries.map((comp) => comp.id.toStringWithoutVersion());\n\n  const entry = (comp: (typeof foreign)[number], released: boolean | undefined): ForeignLaneComponent => ({\n    id: comp.id.toStringWithoutVersion(),\n    scope: comp.id.scope as string,\n    released,\n  });\n  // A component this run tagged and exported is released by definition — as long as the lane still\n  // sits at the head this run tagged from; a head that moved since is another writer's work. Being\n  // in `.bitmap` is not enough: the tag covers changed components only, and a mirror writes the\n  // defaultScope slice only.\n  const releasedByThisRun = (comp: LaneEntry) =>\n    deps.releasedHeadByThisRun(comp.id.changeVersion(undefined)) === comp.head;\n  const releasedHere = foreign.filter(releasedByThisRun);\n  const others = foreign.filter((comp) => !releasedByThisRun(comp));\n  if (!others.length) return releasedHere.map((comp) => entry(comp, true));\n\n  // Each other component's main history comes from its own scope, and its lane head from the\n  // lane's hosting scope. A component that has no main yet (created on the lane) is simply absent\n  // afterwards, which reads as \"not released\".\n  let objectsImported = true;\n  try {\n    // every lane component's main is needed: the released state of one references the heads of others\n    await deps.importMainObjects(entries.map((comp) => comp.id.changeVersion(undefined)));\n    await deps.importObjectsByHashes(\n      laneId.scope,\n      others.map((comp) => comp.head)\n    );\n  } catch (e: any) {\n    deps.warn(`Could not fetch the history of the lane's foreign components: ${e.message}`);\n    objectsImported = false;\n  }\n\n  const mainHeadOf = new Map<string, string | undefined>();\n  if (objectsImported) {\n    await Promise.all(\n      entries.map(async (comp) => {\n        const id = comp.id.toStringWithoutVersion();\n        try {\n          const model = await deps.getModelComponent(comp.id.changeVersion(undefined));\n          mainHeadOf.set(id, model?.getHeadAsTagIfExist() ?? model?.getHead()?.toString());\n        } catch {\n          mainHeadOf.set(id, undefined); // unknown head: a reference to it can never read as released\n        }\n      })\n    );\n  }\n\n  const states = await Promise.all(\n    others.map(async (comp): Promise<ForeignLaneComponent> => {\n      if (!objectsImported) return entry(comp, undefined);\n      try {\n        const modelComponent = await deps.getModelComponent(comp.id.changeVersion(undefined));\n        const mainHead = modelComponent?.getHead();\n        if (!modelComponent || !mainHead) return entry(comp, false);\n        if (comp.isDeleted) {\n          // the lane deletes this component; released once its own main head carries the deletion.\n          // Read main's head Version itself — ModelComponent.isRemoved() may answer for a lane head.\n          const mainVersion = (await deps.objects.load(mainHead, true)) as Version;\n          return entry(comp, mainVersion.isRemoved());\n        }\n        return entry(\n          comp,\n          await laneHeadIsOnMain(\n            modelComponent,\n            Ref.from(comp.head),\n            mainHead,\n            laneComponentIds,\n            mainHeadOf,\n            deps.objects\n          )\n        );\n      } catch (e: any) {\n        deps.warn(`Could not read the history of ${comp.id.toStringWithoutVersion()}: ${e.message}`);\n        return entry(comp, undefined);\n      }\n    })\n  );\n  return [...releasedHere.map((comp) => entry(comp, true)), ...states];\n}\n\n/**\n * The archive decision for a lane the merge just released. A lane that is already gone archives\n * \"as before\" (the caller's archive reports not-found the way it always has); a lane that cannot\n * be read stays open.\n */\nexport async function laneArchiveDecision(\n  laneId: LaneId,\n  defaultScope: string,\n  deps: LaneArchiveDeps\n): Promise<LaneArchiveDecision> {\n  let lane: LaneSnapshot | undefined;\n  let foreign: ForeignLaneComponent[] | undefined;\n  try {\n    lane = await readRemoteLane(laneId, deps);\n    foreign = lane && (await foreignLaneComponentsReleaseState(laneId, lane, defaultScope, deps));\n  } catch (e: any) {\n    return {\n      archive: false,\n      summary:\n        `Could not read lane ${laneId.toString()} to check for components outside this release: ${e.message}\\n` +\n        `Leaving the lane open. ${manualArchiveHint(laneId.toString())}`,\n    };\n  }\n  if (!lane || !foreign) return { archive: true, summary: '' };\n  return { ...decideLaneArchive(laneId.toString(), defaultScope, foreign), fingerprint: laneFingerprint(lane) };\n}\n\n/**\n * The lane moved between the decision and the archive: another writer exported to it. The\n * decision is stale; archiving now could remove work nobody has looked at.\n */\nexport function laneMovedSummary(laneId: string): string {\n  return (\n    `Lane ${laneId} changed while the release was checking it, so it is left open; ` +\n    `the next release evaluates the new state. ${manualArchiveHint(laneId)}`\n  );\n}\n\n/** The lane could not be re-read right before the archive; without a current state, archiving is unsafe. */\nexport function laneUnreadableBeforeArchiveSummary(laneId: string, error: string): string {\n  return (\n    `Could not re-read lane ${laneId} before archiving it: ${error}\\n` +\n    `Leaving the lane open. ${manualArchiveHint(laneId)}`\n  );\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/lane-archive-guard.spec.d.ts

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