@@ -131,10 +131,20 @@ was accepted, so editing the types afterwards invalidates it rather than riding
 along. And it is scoped to the published version it was taken against, so it
 expires on the next release instead of silently carrying forward.
 
-At release time the gate also checks the bump itself: once `package.json` moves
-off the published version, a changed type surface may not ship as a patch. During
-normal development the two match (the bump is its own commit, e.g. `7f93210`
-"4.2.6"), so there is nothing to assert and the rule stays quiet.
+At release time the gate also checks the bump itself: once `package.json` carries
+a different `major.minor.patch` from the published release, a changed type
+surface may not ship as a patch. During normal development the two match (the
+bump is its own commit, e.g. `7f93210` "4.2.6"), so there is nothing to assert
+and the rule stays quiet.
+
+The comparison is on the numeric core, not the version string, because CI stamps
+an experimental version into `package.json` before packing
+(`4.2.6-exp.<sha>` while 4.2.6 is published). A string comparison read every
+pull-request build as a release candidate and then, since the core matched, as a
+patch bump, which would have failed the first pull request to legitimately change
+the type surface. For the same reason the recorded sizes are matched within the
+tolerance rather than byte-exactly: `gate:accept` runs locally, its numbers are
+compared against a CI build, and the stamp alone makes those differ.
 
 Semantic additive/non-additive classification via api-extractor would remove the
 judgement call, but it is a much larger project and deliberately not attempted
 
@@ -268,6 +268,27 @@ export function parseVersion(version) {
   return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
 }
 
+/**
+ * Whether the candidate is a release being cut, rather than an ordinary build.
+ *
+ * Not a string comparison against the published version. CI stamps an
+ * experimental version into package.json before packing (`4.2.6-exp.a0f4f4c`
+ * for published 4.2.6), so `!==` treats every pull-request build as a release
+ * candidate, and since the numeric core matches it then reads as a patch bump.
+ * That would have failed the first pull request to legitimately change the type
+ * surface, with a version error that had nothing to do with the change.
+ *
+ * Comparing the numeric core instead means a stamped build of the published
+ * version is correctly seen as "not a release", while a genuine bump (4.2.7,
+ * 4.3.0, and their prereleases) still is.
+ */
+export function isReleaseCandidate(candidate, published) {
+  const a = parseVersion(candidate);
+  const b = parseVersion(published);
+  if (!a || !b) return false;
+  return a[0] !== b[0] || a[1] !== b[1] || a[2] !== b[2];
+}
+
 /**
  * Whether `candidate` is more than a patch bump over `published`.
  *
@@ -613,7 +634,7 @@ export function checkTypes(pkgDir, pkg, published, report, { acceptedFile = ACCE
   // so there is nothing to assert. Once it moves, this is a release candidate
   // and a changed type surface may not ship as a patch, which is exactly how
   // 4.2.4 broke consumer builds.
-  if (pkg.version === published.version) return;
+  if (!isReleaseCandidate(pkg.version, published.version)) return;
   const bumped = isMinorOrMajorBump(pkg.version, published.version);
   if (bumped === false) {
     report.fail(
@@ -641,6 +662,25 @@ export function measurePackage(pkgDir, pkg, tarball) {
   return { packed: fs.statSync(tarball).size, sizes };
 }
 
+/**
+ * Whether a recorded set of measurements still describes the current build,
+ * within `SIZE_TOLERANCE`.
+ *
+ * Every entry must be present on both sides: an acknowledgment that predates a
+ * new entry point should not silently cover it.
+ */
+export function sizesMatch(accepted, current) {
+  if (!accepted || typeof accepted.packed !== 'number') return false;
+  const within = (a, b) => b > 0 && Math.abs((a - b) / b) <= SIZE_TOLERANCE;
+  if (!within(current.packed, accepted.packed)) return false;
+
+  const acceptedKeys = Object.keys(accepted.sizes ?? {}).sort();
+  const currentKeys = Object.keys(current.sizes ?? {}).sort();
+  if (acceptedKeys.join() !== currentKeys.join()) return false;
+
+  return currentKeys.every((key) => within(current.sizes[key].gzip, accepted.sizes[key].gzip));
+}
+
 export function checkSize(pkgDir, pkg, tarball, published, report, { acceptedFile = ACCEPTED_FILE, publishedMetrics } = {}) {
   const current = measurePackage(pkgDir, pkg, tarball);
 
@@ -657,10 +697,14 @@ export function checkSize(pkgDir, pkg, tarball, published, report, { acceptedFil
   // Same acknowledgment as the type surface: an intended size move is recorded
   // once, against a named published version, and stops applying when that
   // version moves on.
-  const acknowledged =
-    accepted?.against === published.version &&
-    accepted?.size?.packed === current.packed &&
-    JSON.stringify(accepted?.size?.sizes ?? null) === JSON.stringify(current.sizes);
+  //
+  // Matched within the tolerance rather than byte-exactly. `gate:accept` is run
+  // locally, but the numbers it records get compared against a CI build, and the
+  // two are never byte-identical: CI stamps an experimental version into the
+  // bundle before packing (4.2.6-exp.<sha>), which measured ~+0.5% on the
+  // tarball. Exact matching would mean no acknowledgment ever applied in CI, so
+  // an intended size change could not be landed at all.
+  const acknowledged = accepted?.against === published.version && sizesMatch(accepted?.size, current);
 
   const over = [];
 
 
@@ -12,9 +12,11 @@ import {
   diffLines,
   isAllowedExternal,
   isMinorOrMajorBump,
+  isReleaseCandidate,
   measurePackage,
   parseVersion,
   runChecks,
+  sizesMatch,
   typesDigest,
   writeAccepted,
 } from '../scripts/release-gate.mjs';
@@ -417,6 +419,46 @@ describe('runChecks', () => {
     expect(failures.find((f) => f.check === 'size')).toBeUndefined();
   });
 
+  // `gate:accept` runs locally, but its numbers are compared against a CI build,
+  // and CI stamps a version into the bundle so the two are never byte-identical.
+  // Exact matching meant no acknowledgment ever applied in CI.
+  it('honours an acknowledgment whose sizes differ slightly, as a CI build does', () => {
+    const built = build({ esm: ESM_CLEAN });
+    accept(built);
+    const recorded = JSON.parse(fs.readFileSync(built.options.acceptedFile, 'utf8'));
+    // Stand in for the version stamp: ~+0.5% on the tarball, ~+0.2% on entries.
+    recorded.size.packed = Math.round(recorded.size.packed / 1.005);
+    recorded.size.sizes['dist/index.js'].gzip = Math.round(recorded.size.sizes['dist/index.js'].gzip / 1.002);
+    fs.writeFileSync(built.options.acceptedFile, JSON.stringify(recorded));
+    const publishedMetrics = publishedMetricsScaled(built, { entry: 1.5 });
+    const { failures } = runChecks(built.pkgDir, built.pkg, built.tarball, built.published, { ...built.options, publishedMetrics });
+    expect(failures.find((f) => f.check === 'size')).toBeUndefined();
+  });
+
+  // Tolerant matching must not become "any size is acknowledged".
+  it('does not honour an acknowledgment whose sizes moved beyond the tolerance', () => {
+    const built = build({ esm: ESM_CLEAN });
+    accept(built);
+    const recorded = JSON.parse(fs.readFileSync(built.options.acceptedFile, 'utf8'));
+    recorded.size.sizes['dist/index.js'].gzip = Math.round(recorded.size.sizes['dist/index.js'].gzip / 1.5);
+    fs.writeFileSync(built.options.acceptedFile, JSON.stringify(recorded));
+    const publishedMetrics = publishedMetricsScaled(built, { entry: 1.5 });
+    const { failures } = runChecks(built.pkgDir, built.pkg, built.tarball, built.published, { ...built.options, publishedMetrics });
+    expect(failures.find((f) => f.check === 'size')).toBeDefined();
+  });
+
+  // An acknowledgment taken before a new entry point existed should not cover it.
+  it('does not honour an acknowledgment that predates a new entry point', () => {
+    const built = build({ esm: ESM_CLEAN });
+    accept(built);
+    const recorded = JSON.parse(fs.readFileSync(built.options.acceptedFile, 'utf8'));
+    delete recorded.size.sizes['dist/index.umd.cjs'];
+    fs.writeFileSync(built.options.acceptedFile, JSON.stringify(recorded));
+    const publishedMetrics = publishedMetricsScaled(built, { entry: 1.5 });
+    const { failures } = runChecks(built.pkgDir, built.pkg, built.tarball, built.published, { ...built.options, publishedMetrics });
+    expect(failures.find((f) => f.check === 'size')).toBeDefined();
+  });
+
   // --- acknowledgment (#749) ---------------------------------------------
 
   const withChangedTypes = (overrides = {}) =>
@@ -483,6 +525,32 @@ describe('runChecks', () => {
     expect(failures).toEqual([]);
   });
 
+  // CI stamps an experimental version into package.json before packing
+  // (`4.2.6-exp.<sha>` while 4.2.6 is published), so a `!==` comparison read
+  // every pull-request build as a release candidate and then, because the
+  // numeric core matches, as a patch bump. That would have failed the first PR
+  // to legitimately change types, with an error about the version.
+  it('does not treat CI’s experimental version stamp as a release', () => {
+    const built = withChangedTypes({ version: '4.2.6-exp.a0f4f4c', publishedVersion: '4.2.6' });
+    accept(built);
+    const { failures } = runChecks(built.pkgDir, built.pkg, built.tarball, built.published, built.options);
+    expect(failures).toEqual([]);
+  });
+
+  // The stamp must not become a blanket exemption: a prerelease of a real bump
+  // is still a release, and still has to clear the rule.
+  it('still applies the rule to a prerelease of a genuine bump', () => {
+    const patch = withChangedTypes({ version: '4.2.7-exp.a0f4f4c', publishedVersion: '4.2.6' });
+    accept(patch);
+    const patchRun = runChecks(patch.pkgDir, patch.pkg, patch.tarball, patch.published, patch.options);
+    expect(patchRun.failures.find((f) => f.check === 'types')?.message).toContain('patch bump');
+
+    const minor = withChangedTypes({ version: '4.3.0-exp.a0f4f4c', publishedVersion: '4.2.6' });
+    accept(minor);
+    const minorRun = runChecks(minor.pkgDir, minor.pkg, minor.tarball, minor.published, minor.options);
+    expect(minorRun.failures).toEqual([]);
+  });
+
   it('allows a patch release that does not touch the type surface', () => {
     const built = build({ esm: ESM_CLEAN, version: '4.2.7', publishedVersion: '4.2.6' });
     const { failures } = runChecks(built.pkgDir, built.pkg, built.tarball, built.published, built.options);