Fix FFD bin-packing under-allocation that overflowed the schema-attr cap

deriveDomainsByCapacity seeded the packer's bin count from a LOWER bound
(max(ceil(tables/maxTableCount), ceil(attrs/maxSchemaAttrs))), so when
independent (no-edge) clusters fragment, FFD ran out of bins and dropped the
non-fitting cluster into the least-loaded bucket — overflowing it past
maxSchemaAttrs with no warning (the oversized-cluster guard only checks per-
cluster table COUNT, not attrs). Verified repro: 4 independent 8000-attr tables,
maxSchemaAttrs 15000 -> seed n=3 -> one bucket holds 16000 attrs.

Seed the packer with the maximum permitted bins instead (one per cluster, capped
at maxSchemaSplitSolutions). FFD still consolidates — clusters that fit together
share a bin and empty bins are dropped, so the solution count stays minimal — but
a cluster that fits nowhere opens a NEW bin rather than overflowing. The existing
16000-attr/2-solution test is unchanged (FFD still consolidates); added a
regression test for the 4-independent-table overflow case.

1211 tests pass, alm-lint 0 findings.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: tyaginidhi

plugins/power-pages/scripts/lib/compute-split-plan.js

@@ -427,14 +427,16 @@ function deriveDomainsByCapacity(estimate, thresholds) {
   if (tables.length === 0) return [{ name: 'Tables', tableLogicalNames: [] }];
 
   const clusters = buildTableClusters(tables, estimate.tableRelationships || []);
-  const totalAttrs = tables.reduce((s, t) => s + t.attributeCount, 0);
   const ceiling = (thresholds && thresholds.maxSchemaSplitSolutions) || 8;
-  let n = Math.max(
-    1,
-    Math.ceil(tables.length / thresholds.maxTableCount),
-    Math.ceil(totalAttrs / Math.max(thresholds.maxSchemaAttrs, 1)),
-  );
-  n = Math.min(n, ceiling, clusters.length);
+  // Seed the packer with the maximum permitted bins (one per cluster, capped at
+  // maxSchemaSplitSolutions). First-fit-decreasing still consolidates — clusters
+  // that fit together share a bin and the empty bins are dropped, so the final
+  // count stays minimal — but a cluster that fits nowhere lands in a NEW bin
+  // instead of overflowing an existing one. Seeding from a lower bound
+  // (ceil(tables/maxTable), ceil(attrs/maxAttr)) under-allocated bins and let
+  // independent attr-heavy clusters bust maxSchemaAttrs in the least-loaded
+  // bucket, unwarned (the oversized guard only catches per-cluster table count).
+  const n = Math.min(clusters.length, ceiling);
 
   const buckets = packClusters(clusters, n, thresholds);
   const multi = buckets.length > 1;

plugins/power-pages/scripts/tests/compute-split-plan.test.js

@@ -205,6 +205,39 @@ test('computeSplitPlan Strategy 3 packs tables by capacity (no domains configure
   assert.equal(tableSolutions.length, 2, '16000 attrs / 15000 cap -> 2 Table solutions, not one-per-table');
 });
 
+test('computeSplitPlan Strategy 3 never overflows the attr cap when independent clusters fragment', () => {
+  // Regression for the FFD under-allocation bug: 4 INDEPENDENT (no-edge) tables of
+  // 8000 attrs each = 32000 total. Seeding the packer from the lower bound
+  // ceil(32000/15000)=3 gave only 3 bins, so the 4th cluster fell into the
+  // least-loaded bucket -> 16000 attrs (> 15000 cap), unwarned. The packer must
+  // instead open a 4th bin (clusters.length permits it) so no bucket busts the cap.
+  const result = computeSplitPlan({
+    estimate: baseEstimate({
+      tableCount: 4,
+      schemaAttrCount: 32000,
+      tables: [
+        { logicalName: 'tst_alpha', attributeCount: 8000 },
+        { logicalName: 'tst_beta', attributeCount: 8000 },
+        { logicalName: 'tst_gamma', attributeCount: 8000 },
+        { logicalName: 'tst_delta', attributeCount: 8000 },
+      ],
+      tableRelationships: [], // no edges -> 4 singleton clusters
+    }),
+    config: baseConfig(),
+    meta: { baseName: 'Test', siteName: 'Test Site' },
+  });
+  assert.equal(result.splitStrategy, 'strategy-3-schema-segmentation');
+  const tableSolutions = result.proposedSolutions.filter(
+    (s) => Array.isArray(s.componentTypes) && s.componentTypes.length === 1 && s.componentTypes[0] === 'Table',
+  );
+  // 4 independent 8000-attr tables -> 4 single-table solutions (each 8000 < 15000),
+  // NOT 3 with one 16000-attr overflow bucket.
+  assert.equal(tableSolutions.length, 4, '4 independent 8000-attr tables -> 4 Table solutions (no attr-cap overflow)');
+  for (const s of tableSolutions) {
+    assert.equal(s.tableLogicalNames.length, 1, `${s.uniqueName} must hold exactly one table — no bucket over the attr cap`);
+  }
+});
+
 test('computeSplitPlan additive Strategy 4 prepends EnvVars solution', () => {
   const result = computeSplitPlan({
     estimate: baseEstimate({ totalSizeMB: 142, webFilesAggregateMB: 110, envVarCount: 800 }),