@opentermsarchive/engine 13.0.1 → 14.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentermsarchive/engine",
-  "version": "13.0.1",
+  "version": "14.1.0",
   "description": "Tracks and makes visible changes to the terms of online services",
   "homepage": "https://opentermsarchive.org",
   "bugs": {
@@ -92,7 +92,7 @@
     "morgan": "^1.10.1",
     "node-fetch": "^3.3.2",
     "octokit": "^5.0.3",
-    "puppeteer": "^25.1.0",
+    "puppeteer": "^25.2.0",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "simple-git": "^3.28.0",
@@ -116,7 +116,7 @@
     "@opentermsarchive/terms-types": "^2.2.0"
   },
   "engines": {
-    "node": ">=20 <=24"
+    "node": ">=22 <=26"
   },
   "overrides": {
     "jsdom": {

package/scripts/declarations/validate/index.mocha.js

@@ -118,6 +118,14 @@ export default async options => {
               describe(type, () => {
                 const terms = service.getTerms({ type });
 
+                if (terms.hasMultipleSourceDocuments) {
+                  it('does not declare the same source document more than once', () => {
+                    const duplicateLocations = [...new Set(terms.duplicateSourceDocuments.map(sourceDocument => sourceDocument.location))];
+
+                    expect(duplicateLocations, `The same source document is declared more than once within the "${type}" combine: ${duplicateLocations.join(', ')}`).to.be.empty;
+                  });
+                }
+
                 terms.sourceDocuments.forEach(sourceDocument => {
                   let filteredContent;
 

package/src/archivist/fetcher/fullDomFetcher.js

@@ -108,7 +108,7 @@ export default async function fetch(url, cssSelectors, config) {
 
     throw new Error(error.message);
   } finally {
-    await cleanupPage(client, page, context);
+    await cleanupPage(client, context);
   }
 }
 
@@ -261,14 +261,11 @@ async function waitForSelectors(page, selectors, timeout) {
   });
 }
 
-async function cleanupPage(client, page, context) {
+async function cleanupPage(client, context) {
   if (client) {
     await client.detach().catch(() => {});
   }
-  if (page) {
-    await page.close().catch(() => {});
-  }
   if (context) {
-    await context.close().catch(() => {}); // Close the isolated context to free resources and ensure complete cleanup
+    await context.close().catch(() => {}); // Closing the context disposes its page too; closing the page explicitly is not only redundant but can hang indefinitely when a navigation is still in flight, for instance after a navigation timeout
   }
 }

package/src/archivist/recorder/repositories/git/git.js

@@ -33,7 +33,8 @@ export default class Git {
       .addConfig('user.name', this.author.name)
       .addConfig('user.email', this.author.email)
       .addConfig('core.quotePath', false) // Disable Git's encoding of special characters in pathnames. For example, `service·A` will be encoded as `service\302\267A` without this setting, leading to issues. See https://git-scm.com/docs/git-config#Documentation/git-config.txt-corequotePath
-      .addConfig('core.commitGraph', true); // Enable `commit-graph` feature for efficient commit data storage, improving performance of operations like `git log`
+      .addConfig('core.commitGraph', true) // Enable `commit-graph` feature for efficient commit data storage, improving performance of operations like `git log`
+      .addConfig('gc.writeCommitGraph', false); // Prevent automatic `git gc` from also writing the commit-graph: the engine writes it explicitly (see `writeCommitGraph`/`updateCommitGraph`), and a concurrent gc write races those, which can leave a stale `commit-graph.lock` and make subsequent operations fail
   }
 
   add(filePath) {
@@ -128,6 +129,7 @@ export default class Git {
   }
 
   async cleanUp() {
+    await fs.rm(path.join(this.path, '.git', 'objects', 'info', 'commit-graph.lock'), { force: true }); // Remove a leftover commit-graph lock from a previous `commit-graph write` that was killed mid-write (e.g. the process was terminated during a deploy or restart). The commit-graph is a disposable cache rebuilt by `writeCommitGraph`, so clearing a stale lock is safe and prevents every subsequent run from failing.
     await this.git.reset('hard');
 
     return this.git.clean('f', '-d');

package/src/archivist/recorder/repositories/git/git.test.js

@@ -83,4 +83,32 @@ describe('Git', () => {
       });
     });
   });
+
+  describe('#cleanUp', () => {
+    context('when a commit-graph lock has been left behind by an interrupted process', () => {
+      const infoDirectoryPath = path.join(RECORDER_PATH, '.git', 'objects', 'info');
+      const lockFilePath = path.join(infoDirectoryPath, 'commit-graph.lock');
+
+      before(async () => {
+        const filePath = `${RECORDER_PATH}/file-to-clean.md`;
+
+        await fs.writeFile(filePath, DEFAULT_CONTENT);
+        await subject.add(filePath);
+        await subject.commit({ filePath, message: DEFAULT_COMMIT_MESSAGE });
+
+        await fs.mkdir(infoDirectoryPath, { recursive: true });
+        await fs.writeFile(lockFilePath, '');
+
+        await subject.cleanUp();
+      });
+
+      after(() => subject.destroyHistory());
+
+      it('removes the stale commit-graph lock', async () => {
+        const infoDirectoryContent = await fs.readdir(infoDirectoryPath);
+
+        expect(infoDirectoryContent).to.not.include('commit-graph.lock');
+      });
+    });
+  });
 });

package/src/archivist/services/terms.js

@@ -13,6 +13,18 @@ export default class Terms {
     return this.sourceDocuments.length > 1;
   }
 
+  get duplicateSourceDocuments() {
+    const seenLocations = new Set();
+
+    return this.sourceDocuments.filter(({ location }) => {
+      const isDuplicate = seenLocations.has(location);
+
+      seenLocations.add(location);
+
+      return isDuplicate;
+    });
+  }
+
   toPersistence() {
     return {
       name: this.service.name,

package/src/archivist/services/terms.test.js

@@ -80,4 +80,12 @@ describe('Terms', () => {
       expect(result).to.deep.equal(expectedResult);
     });
   });
+
+  describe('#duplicateSourceDocuments', () => {
+    it('returns the source documents that repeat a location', () => {
+      const terms = new Terms({ service, type: termsType, sourceDocuments: [ document1, document2 ] });
+
+      expect(terms.duplicateSourceDocuments).to.deep.equal([document2]);
+    });
+  });
 });