@ifc-lite/viewer 1.26.0 → 1.28.0

package/src/components/viewer/lists/list-table-utils.ts

@@ -0,0 +1,123 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Pure helpers for the Lists results table — value formatting, comparison,
+ * numeric-column detection, content-aware column widths, and the grouping /
+ * aggregation that powers the in-table (settings-free) grouped view.
+ */
+
+import type { CellValue, ColumnDefinition, ListRow, ListGrouping } from '@ifc-lite/lists';
+
+export function formatCellValue(value: CellValue): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'boolean') return value ? 'Yes' : 'No';
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) return value.toLocaleString();
+    return value.toFixed(4).replace(/\.?0+$/, '');
+  }
+  return String(value);
+}
+
+export function compareCells(a: CellValue, b: CellValue): number {
+  if (a === null && b === null) return 0;
+  if (a === null) return -1;
+  if (b === null) return 1;
+  if (typeof a === 'number' && typeof b === 'number') return a - b;
+  return String(a).localeCompare(String(b));
+}
+
+/** A column is numeric (summable) when every sampled non-empty value is a
+ *  finite number and at least one such value exists. */
+export function detectNumericColumns(columns: ColumnDefinition[], rows: ListRow[]): boolean[] {
+  const sample = rows.slice(0, 120);
+  return columns.map((_, i) => {
+    let sawNumber = false;
+    for (const r of sample) {
+      const v = r.values[i];
+      if (v === null || v === undefined || v === '') continue;
+      if (typeof v === 'number' && Number.isFinite(v)) { sawNumber = true; continue; }
+      return false;
+    }
+    return sawNumber;
+  });
+}
+
+/** Content-aware default width: fits the header + the widest sampled value
+ *  (≈7px/char), clamped to a readable range. */
+export function autoColumnWidth(label: string, rows: ListRow[], colIdx: number): number {
+  let maxLen = label.length;
+  const sample = rows.slice(0, 200);
+  for (const r of sample) {
+    const v = r.values[colIdx];
+    if (v === null || v === undefined) continue;
+    const len = (typeof v === 'number' ? formatCellValue(v) : String(v)).length;
+    if (len > maxLen) maxLen = len;
+  }
+  return Math.max(80, Math.min(460, maxLen * 7 + 34));
+}
+
+export type DisplayItem =
+  | { kind: 'group'; key: string; label: string; count: number; sums: Record<string, number> }
+  | { kind: 'row'; row: ListRow };
+
+export interface Totals { count: number; sums: Record<string, number> }
+export interface GroupedView { items: DisplayItem[]; groupCount: number; totals: Totals }
+
+function sumIndices(columns: ColumnDefinition[], sumColumnIds: string[]) {
+  return sumColumnIds
+    .map((id) => ({ id, idx: columns.findIndex((c) => c.id === id) }))
+    .filter((s) => s.idx >= 0);
+}
+
+/** Bucket already-filtered/sorted rows by the group-by column, accumulate
+ *  per-group + grand count/sums, and flatten into a virtualizable list
+ *  (group header followed by its rows when the group is expanded). */
+export function buildGroupedView(
+  rows: ListRow[],
+  columns: ColumnDefinition[],
+  grouping: ListGrouping,
+  expanded: Set<string>,
+): GroupedView {
+  const groupIdx = columns.findIndex((c) => c.id === grouping.columnId);
+  const sums = sumIndices(columns, grouping.sumColumnIds);
+  const zero = (): Record<string, number> => Object.fromEntries(sums.map((s) => [s.id, 0]));
+
+  const totals: Totals = { count: rows.length, sums: zero() };
+  const byKey = new Map<string, { key: string; label: string; count: number; sums: Record<string, number>; rows: ListRow[] }>();
+
+  for (const row of rows) {
+    const raw = groupIdx >= 0 ? row.values[groupIdx] : null;
+    const label = raw === null || raw === undefined || raw === '' ? '(none)' : formatCellValue(raw);
+    let g = byKey.get(label);
+    if (!g) { g = { key: label, label, count: 0, sums: zero(), rows: [] }; byKey.set(label, g); }
+    g.count++;
+    g.rows.push(row);
+    for (const s of sums) {
+      const v = row.values[s.idx];
+      if (typeof v === 'number' && Number.isFinite(v)) { g.sums[s.id] += v; totals.sums[s.id] += v; }
+    }
+  }
+
+  const groups = Array.from(byKey.values()).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+  const items: DisplayItem[] = [];
+  for (const g of groups) {
+    items.push({ kind: 'group', key: g.key, label: g.label, count: g.count, sums: g.sums });
+    if (expanded.has(g.key)) for (const r of g.rows) items.push({ kind: 'row', row: r });
+  }
+  return { items, groupCount: groups.length, totals };
+}
+
+/** Grand totals for the flat (ungrouped) view when sum columns are active. */
+export function flatTotals(rows: ListRow[], columns: ColumnDefinition[], sumColumnIds: string[]): Totals {
+  const sums = sumIndices(columns, sumColumnIds);
+  const acc: Record<string, number> = Object.fromEntries(sums.map((s) => [s.id, 0]));
+  for (const r of rows) {
+    for (const s of sums) {
+      const v = r.values[s.idx];
+      if (typeof v === 'number' && Number.isFinite(v)) acc[s.id] += v;
+    }
+  }
+  return { count: rows.length, sums: acc };
+}

package/src/components/viewer/properties/MaterialTotalsPanel.tsx

@@ -0,0 +1,283 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Material totals panel — shown when a material is selected from the
+ * "Materials" hierarchy tab. Surfaces the material's own property sets
+ * (IfcMaterialProperties) plus quantities aggregated across every element that
+ * uses the material. Volumes/areas are apportioned by each element's material
+ * share (layer thickness / constituent fraction), so a layered wall's volume is
+ * split between its concrete and insulation rather than double-counted.
+ */
+
+import { useMemo } from 'react';
+import { Layers, Calculator, Boxes, Info } from 'lucide-react';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import { useIfc } from '@/hooks/useIfc';
+import {
+  buildMaterialUsageIndex,
+  getMaterialDisplay,
+  extractMaterialPropertiesForMaterialId,
+  extractQuantitiesOnDemand,
+  type IfcDataStore,
+} from '@ifc-lite/parser';
+import { QuantityType } from '@ifc-lite/data';
+import { PropertySetCard } from './PropertySetCard';
+import type { PropertySet } from './encodingUtils';
+
+interface MaterialTotals {
+  /** Number of elements using this material (across all loaded models). */
+  elementCount: number;
+  /** Elements that contributed at least one volume quantity. */
+  elementsWithVolume: number;
+  volume: number;
+  hasVolume: boolean;
+  area: number;
+  hasArea: boolean;
+  weight: number;
+  hasWeight: boolean;
+  /** Element count per IFC class, sorted desc. */
+  byClass: Array<{ ifcClass: string; count: number }>;
+}
+
+/** Pick a quantity value by candidate names (case-insensitive), else by type. */
+function pickQuantity(
+  byName: Map<string, number>,
+  candidates: string[],
+): number | undefined {
+  for (const c of candidates) {
+    const v = byName.get(c);
+    if (v !== undefined) return v;
+  }
+  return undefined;
+}
+
+/** Format an aggregated quantity with magnitude-appropriate precision. */
+function formatNumber(value: number): string {
+  if (value === 0) return '0';
+  if (Math.abs(value) >= 1000) return value.toLocaleString(undefined, { maximumFractionDigits: 0 });
+  if (Math.abs(value) >= 1) return value.toLocaleString(undefined, { maximumFractionDigits: 2 });
+  return value.toLocaleString(undefined, { maximumFractionDigits: 4 });
+}
+
+export function MaterialTotalsPanel({ materialId, modelId }: { materialId: number; modelId: string }) {
+  const { ifcDataStore, models } = useIfc();
+
+  // The store the selected material lives in, plus every loaded store (so the
+  // totals merge same-named materials across a federation).
+  const { selectedStore, allStores } = useMemo(() => {
+    const stores: IfcDataStore[] = [];
+    if (models.size > 0) {
+      for (const [, m] of models) {
+        if (m.ifcDataStore) stores.push(m.ifcDataStore as IfcDataStore);
+      }
+    } else if (ifcDataStore) {
+      stores.push(ifcDataStore as IfcDataStore);
+    }
+    const sel = modelId !== 'legacy'
+      ? (models.get(modelId)?.ifcDataStore as IfcDataStore | undefined) ?? (ifcDataStore as IfcDataStore | null) ?? undefined
+      : (ifcDataStore as IfcDataStore | null) ?? undefined;
+    return { selectedStore: sel, allStores: stores.length > 0 ? stores : (sel ? [sel] : []) };
+  }, [models, ifcDataStore, modelId]);
+
+  const display = useMemo(() => {
+    if (!selectedStore) return { name: `Material #${materialId}`, type: 'IfcMaterial' };
+    return getMaterialDisplay(selectedStore, materialId);
+  }, [selectedStore, materialId]);
+
+  // The material's own property sets (Pset_Material*).
+  const psetGroups = useMemo(() => {
+    if (!selectedStore) return [];
+    return extractMaterialPropertiesForMaterialId(selectedStore, materialId);
+  }, [selectedStore, materialId]);
+
+  // Aggregate quantities across all elements using a material of this name.
+  const totals = useMemo<MaterialTotals>(() => {
+    const result: MaterialTotals = {
+      elementCount: 0,
+      elementsWithVolume: 0,
+      volume: 0,
+      hasVolume: false,
+      area: 0,
+      hasArea: false,
+      weight: 0,
+      hasWeight: false,
+      byClass: [],
+    };
+    const classCounts = new Map<string, number>();
+    const targetName = display.name;
+
+    for (const store of allStores) {
+      const usageIndex = buildMaterialUsageIndex(store);
+      // Forward map of entity -> quantity-set ids (when on-demand parsing is
+      // active). Used to skip the per-element extractor allocation for elements
+      // that carry no quantities — the common case in large models, so a
+      // material used by thousands of elements only pays the parse cost for the
+      // subset that actually has Qto data.
+      const qMap = store.onDemandQuantityMap;
+      for (const usage of usageIndex.values()) {
+        if (usage.name !== targetName) continue;
+        for (const { entityId, weight } of usage.entries) {
+          result.elementCount += 1;
+
+          const ifcClass = store.entityIndex.byId.get(entityId)?.type || usage.ifcClass;
+          classCounts.set(ifcClass, (classCounts.get(ifcClass) ?? 0) + 1);
+
+          if (qMap && !qMap.get(entityId)?.length) continue; // no quantities — skip extraction
+          const qsets = extractQuantitiesOnDemand(store, entityId);
+          if (qsets.length === 0) continue;
+          const volByName = new Map<string, number>();
+          const areaByName = new Map<string, number>();
+          const weightByName = new Map<string, number>();
+          for (const qset of qsets) {
+            for (const q of qset.quantities) {
+              const key = q.name.toLowerCase();
+              if (q.type === QuantityType.Volume) volByName.set(key, q.value);
+              else if (q.type === QuantityType.Area) areaByName.set(key, q.value);
+              else if (q.type === QuantityType.Weight) weightByName.set(key, q.value);
+            }
+          }
+
+          const vol = pickQuantity(volByName, ['netvolume', 'grossvolume', 'volume'])
+            ?? (volByName.size > 0 ? [...volByName.values()][0] : undefined);
+          if (vol !== undefined) {
+            result.volume += vol * weight;
+            result.hasVolume = true;
+            result.elementsWithVolume += 1;
+          }
+
+          const area = pickQuantity(areaByName, ['netarea', 'grossarea', 'netsidearea', 'grosssidearea', 'netfloorarea', 'grossfloorarea', 'area']);
+          if (area !== undefined) {
+            result.area += area * weight;
+            result.hasArea = true;
+          }
+
+          const wt = pickQuantity(weightByName, ['netweight', 'grossweight', 'weight']);
+          if (wt !== undefined) {
+            result.weight += wt * weight;
+            result.hasWeight = true;
+          }
+        }
+      }
+    }
+
+    result.byClass = [...classCounts.entries()]
+      .map(([ifcClass, count]) => ({ ifcClass, count }))
+      .sort((a, b) => b.count - a.count);
+    return result;
+  }, [allStores, display.name]);
+
+  const psetCount = psetGroups.reduce((sum, g) => sum + g.psets.length, 0);
+
+  return (
+    <div className="h-full flex flex-col border-l-2 border-zinc-200 dark:border-zinc-800 bg-white dark:bg-black">
+      {/* Header */}
+      <div className="p-4 border-b-2 border-zinc-200 dark:border-zinc-800 bg-amber-50/40 dark:bg-amber-950/20 space-y-2">
+        <div className="flex items-start gap-3">
+          <div className="p-2 border-2 border-amber-200 dark:border-amber-800 bg-white dark:bg-zinc-950 shrink-0">
+            <Layers className="h-5 w-5 text-amber-600 dark:text-amber-400" />
+          </div>
+          <div className="flex-1 min-w-0 pt-0.5">
+            <h3 className="font-bold text-sm truncate uppercase tracking-tight text-zinc-900 dark:text-zinc-100 min-w-0">
+              {display.name}
+            </h3>
+            <p className="text-xs font-mono text-amber-600/80 dark:text-amber-400/80">{display.type}</p>
+          </div>
+        </div>
+      </div>
+
+      <ScrollArea className="flex-1 bg-white dark:bg-black">
+        <div className="p-3 space-y-3 w-full overflow-hidden">
+          {/* Totals */}
+          <div className="border-2 border-amber-200 dark:border-amber-800 bg-amber-50/20 dark:bg-amber-950/20">
+            <div className="flex items-center gap-2 px-2.5 py-2 border-b-2 border-amber-200 dark:border-amber-800">
+              <Calculator className="h-3.5 w-3.5 text-amber-600 dark:text-amber-400 shrink-0" />
+              <span className="font-bold text-xs text-amber-700 dark:text-amber-400 uppercase tracking-wide">Totals</span>
+            </div>
+            <div className="divide-y divide-amber-100 dark:divide-amber-900/30">
+              <TotalRow label="Elements" value={totals.elementCount.toLocaleString()} />
+              {totals.hasVolume && (
+                <TotalRow label="Volume" value={`${formatNumber(totals.volume)} m³`} />
+              )}
+              {totals.hasArea && (
+                <TotalRow label="Area" value={`${formatNumber(totals.area)} m²`} />
+              )}
+              {totals.hasWeight && (
+                <TotalRow label="Weight" value={`${formatNumber(totals.weight)} kg`} />
+              )}
+            </div>
+            {totals.elementCount > 0 && !totals.hasVolume && (
+              <div className="flex items-start gap-1.5 px-2.5 py-2 text-[10px] text-zinc-500 dark:text-zinc-400 border-t border-amber-100 dark:border-amber-900/30">
+                <Info className="h-3 w-3 shrink-0 mt-px" />
+                <span>No volume quantities (Qto_*) found on these elements.</span>
+              </div>
+            )}
+            {totals.hasVolume && totals.elementsWithVolume < totals.elementCount && (
+              <div className="flex items-start gap-1.5 px-2.5 py-2 text-[10px] text-zinc-500 dark:text-zinc-400 border-t border-amber-100 dark:border-amber-900/30">
+                <Info className="h-3 w-3 shrink-0 mt-px" />
+                <span>
+                  Volume from {totals.elementsWithVolume.toLocaleString()} of {totals.elementCount.toLocaleString()} elements with reported quantities;
+                  multi-material elements are split by layer thickness / constituent fraction.
+                </span>
+              </div>
+            )}
+          </div>
+
+          {/* Breakdown by class */}
+          {totals.byClass.length > 0 && (
+            <div className="border border-zinc-200 dark:border-zinc-800">
+              <div className="flex items-center gap-2 px-2.5 py-2 border-b border-zinc-200 dark:border-zinc-800">
+                <Boxes className="h-3.5 w-3.5 text-zinc-500 shrink-0" />
+                <span className="font-bold text-xs text-zinc-600 dark:text-zinc-300 uppercase tracking-wide">By Class</span>
+              </div>
+              <div className="divide-y divide-zinc-100 dark:divide-zinc-900">
+                {totals.byClass.map((c) => (
+                  <div key={c.ifcClass} className="flex items-center justify-between px-2.5 py-1.5 text-xs">
+                    <span className="font-mono text-zinc-600 dark:text-zinc-400 truncate">{c.ifcClass}</span>
+                    <span className="font-mono text-zinc-900 dark:text-zinc-100">{c.count.toLocaleString()}</span>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {/* Material property sets */}
+          {psetCount > 0 && (
+            <div className="space-y-3">
+              <div className="flex items-center gap-2 px-1 pt-1 pb-0.5 text-[11px] text-amber-600/70 dark:text-amber-400/60 uppercase tracking-wider font-semibold">
+                <Layers className="h-3 w-3 shrink-0" />
+                <span className="truncate">Material Properties</span>
+              </div>
+              {psetGroups.map((group) =>
+                group.psets.map((pset) => {
+                  const psetView: PropertySet = {
+                    name: pset.name,
+                    properties: pset.properties.map((p) => ({ name: p.name, value: p.value, isMutated: false })),
+                  };
+                  return <PropertySetCard key={`${group.materialId}-${pset.name}`} pset={psetView} />;
+                }),
+              )}
+            </div>
+          )}
+
+          {psetCount === 0 && totals.elementCount === 0 && (
+            <p className="text-sm text-zinc-500 dark:text-zinc-500 text-center py-8 font-mono">
+              No data for this material
+            </p>
+          )}
+        </div>
+      </ScrollArea>
+    </div>
+  );
+}
+
+/** A single label/value row in the material totals card. */
+function TotalRow({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="flex items-center justify-between px-2.5 py-2 text-xs">
+      <span className="text-zinc-500 dark:text-zinc-400 font-medium">{label}</span>
+      <span className="font-mono font-semibold text-amber-700 dark:text-amber-300 tabular-nums">{value}</span>
+    </div>
+  );
+}

package/src/generated/mcp-catalog.json

@@ -25,6 +25,10 @@
     { "name": "geometry_volume",     "category": "Geometry",   "scope": "read",   "description": "Net/gross volume in m³ for a single entity or a type aggregate.", "inputSchema": { "type": "object", "required": ["global_id"] } },
     { "name": "geometry_area",       "category": "Geometry",   "scope": "read",   "description": "Surface area for an entity (front/side/footprint depending on what the IFC carries).", "inputSchema": { "type": "object", "required": ["global_id"] } },
 
+    { "name": "clash_check",         "category": "Clash",      "scope": "read",   "description": "Find clashes in a single model — the DEFAULT for any 'find/run clashes' request. Omit BOTH a and b to check every element vs every other (all clashes in the model). Give a TYPE selector for a to self-clash within a group, or both a and b for a pairwise check (a=\"IfcDuct*\", b=\"IfcWall*\"). Meshes the model in-browser; returns a summary plus the worst clashes by penetration depth.", "inputSchema": { "type": "object", "properties": { "a": { "type": "string", "description": "Type selector for set A. Defaults to \"*\" (all elements). e.g. \"IfcDuct*|IfcPipe*\", \"!IfcSpace\"." }, "b": { "type": "string", "description": "Type selector for set B. OMIT for a self-clash within A (every element vs every other in the group)." }, "mode": { "type": "string", "enum": ["hard", "clearance"] }, "tolerance": { "type": "number", "description": "Touching band (m). Defaults to the engine tolerance." }, "clearance": { "type": "number", "description": "Required gap (m) for mode=\"clearance\"." }, "model_id": { "type": "string", "description": "Optional; defaults to the only loaded model." } } } },
+    { "name": "clash_matrix",        "category": "Clash",      "scope": "read",   "description": "Run the standard discipline clash matrix (MEP×STR, HVAC×ARCH, ...) — INTER-discipline pairs ONLY. Returns NOTHING on a single-discipline or architectural model (no cross-discipline pairs exist to test). For a general 'find all clashes' request use clash_check instead; use this only when the user explicitly asks for the discipline matrix. Returns per-rule and per-severity breakdowns plus a sample of the worst clashes.", "inputSchema": { "type": "object", "properties": { "mode": { "type": "string", "enum": ["hard", "clearance"] }, "clearance": { "type": "number", "description": "Required gap (m) applied to every matrix rule when mode=\"clearance\". Without it a clearance matrix reports nothing." }, "model_id": { "type": "string", "description": "Optional; defaults to the only loaded model." } } } },
+    { "name": "clash_bcf_export",    "category": "Clash",      "scope": "export", "description": "Turn the last clash run (clash_check / clash_matrix) into a rich .bcfzip: one BCF topic per clash group, each with a framed 3D viewpoint, the clashing elements as components, and severity/status/distance metadata. Runs a default all-vs-all clash_check first if you haven't clashed yet. Use THIS for 'create/export BCF from clashes' — not bcf_topic_create. (Snapshots are omitted: the inline viewer can't render frames headlessly; BCF viewpoints are valid without an image.)", "inputSchema": { "type": "object", "properties": { "group_by": { "type": "string", "enum": ["cluster", "rule", "typePair", "element"], "description": "How clashes collapse into topics. Default \"cluster\" (spatially-near clashes merge into one topic)." }, "cluster_epsilon": { "type": "number", "description": "Cluster radius (m) for group_by=\"cluster\". Default 1.5." }, "status": { "type": "string", "description": "BCF topic status, e.g. \"Open\"." }, "max_topics": { "type": "integer", "description": "Cap the number of topics. Default 1000." }, "file_path": { "type": "string", "description": "Output .bcfzip name." } } } },
+
     { "name": "model_audit",         "category": "Validation", "scope": "read",   "description": "Out-of-the-box health score + a list of issues (missing GlobalIds, broken refs, orphan entities).", "inputSchema": { "type": "object" } },
     { "name": "ids_validate",        "category": "Validation", "scope": "read",   "description": "Run a buildingSMART IDS spec against the loaded model. Per-spec pass/fail with offending entities.", "inputSchema": { "type": "object", "required": ["ids_path"], "properties": { "ids_path": { "type": "string" } } } },
     { "name": "ids_explain",         "category": "Validation", "scope": "read",   "description": "Parse + summarize an IDS file in plain language — what each spec asks for, in what order.", "inputSchema": { "type": "object", "required": ["ids_path"] } },

package/src/hooks/federationLoadGate.test.ts

@@ -59,11 +59,21 @@ describe('federationLoadGate', () => {
     const bPromise = acquireFederationLoadSlot(50).then((id) => { order.push('b'); return id; });
 
     await new Promise((r) => setTimeout(r, 10));
+    // Releasing the blocker frees the budget for the head of the FIFO queue.
+    // A 2048 MB load costs more than the whole budget, so the first-queued load
+    // is admitted alone (single-file exception) and the 50 MB load stays queued
+    // until it releases. Awaiting them together would deadlock — and asserting
+    // that B does NOT wake alongside A is exactly what proves the gate respects
+    // the budget during the drain (the regression this guards against).
     releaseFederationLoadSlot(blocker);
 
-    const [a, b] = await Promise.all([aPromise, bPromise]);
-    assert.strictEqual(order[0], 'a');
+    const a = await aPromise;
+    assert.deepStrictEqual(order, ['a']);
+    assert.strictEqual(__getFederationLoadGateStats().queuedCount, 1);
+
     releaseFederationLoadSlot(a);
+    const b = await bPromise;
+    assert.deepStrictEqual(order, ['a', 'b']);
     releaseFederationLoadSlot(b);
   });
 

package/src/hooks/federationLoadGate.ts

@@ -21,6 +21,7 @@
  */
 
 interface PendingAcquire {
+  id: number;
   fileSizeMB: number;
   resolve: () => void;
 }
@@ -70,6 +71,11 @@ function tryAdmit(): void {
     // Always admit when nothing is active (single file should never wait).
     if (active.size === 0 || wouldCost <= available) {
       queue.shift();
+      // Reserve the budget synchronously so activeCostMB() reflects this
+      // admission for the rest of this pass. The awaited acquire resumes in a
+      // later microtask, so registering here (not after the await) prevents the
+      // freed budget from being counted in full against every queued item.
+      active.set(head.id, { id: head.id, fileSizeMB: head.fileSizeMB });
       head.resolve();
       // Loop continues — we may be able to admit several queued small loads
       // after a single large load releases.
@@ -95,9 +101,10 @@ export async function acquireFederationLoadSlot(fileSizeMB: number): Promise<num
   }
 
   await new Promise<void>((resolve) => {
-    queue.push({ fileSizeMB, resolve });
+    queue.push({ id, fileSizeMB, resolve });
   });
-  active.set(id, { id, fileSizeMB });
+  // The slot is registered into `active` by tryAdmit at the moment of
+  // admission, so no active.set is needed here.
   return id;
 }